From 9a7863e977649c201af3c438d875347df82b3936 Mon Sep 17 00:00:00 2001
From: Yue Wang <yue.wang@iws.uni-stuttgart.de>
Date: Wed, 7 Apr 2021 15:12:16 +0200
Subject: [PATCH] [bin][parameter] Implement new parameter extraction scripts
Manual inputs are provided via a human-readable json file which is
under version control. The parameters.txt file is now completely
auto-generated and shouldn't be manually edited. All edits
happen to the json file. This makes sure formatting and data
are separated properly and git changes are minimal.
---
.gitlab/issue_templates/Release.md | 2 +-
bin/doc/generate_parameterlist.py | 420 +++
bin/doc/getparameterlist.py | 256 --
doc/doxygen/extradoc/parameterlist.txt | 611 ++--
doc/doxygen/extradoc/parameters.json | 4412 ++++++++++++++++++++++++
5 files changed, 5103 insertions(+), 598 deletions(-)
create mode 100644 bin/doc/generate_parameterlist.py
delete mode 100644 bin/doc/getparameterlist.py
create mode 100644 doc/doxygen/extradoc/parameters.json
diff --git a/.gitlab/issue_templates/Release.md b/.gitlab/issue_templates/Release.md
index 7df7b748b0..7ecaecb2af 100644
--- a/.gitlab/issue_templates/Release.md
+++ b/.gitlab/issue_templates/Release.md
@@ -34,7 +34,7 @@ __Hard Feature Freeze!__
- [ ] Announce hard feature freeze on the mailing list
- [ ] Update all install scripts and the install text in the handbook
- [ ] Header check (run `make headercheck`)
-- [ ] Check and update the runtime parameters (see `bin/doc/getparameterlist.py`)
+- [ ] Re-generate parameter list (`bin/doc/generate_parameterlist.py`) and check log file (maybe manual updates to `bin/doc/docextra/parameters.json` are needed)
- [ ] Make sure the CMakeLists.txt in `dumux` subfolder are up-to-date (generated with `bin/utils/create_cmakelists.py`, dumux `make install` should result in a useable installed dumux version)
- [ ] Create release branches
- [ ] Configure CI to test release branch
diff --git a/bin/doc/generate_parameterlist.py b/bin/doc/generate_parameterlist.py
new file mode 100644
index 0000000000..59b47d820c
--- /dev/null
+++ b/bin/doc/generate_parameterlist.py
@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+
+"""
+Automatically updates parameterlist.txt by searching all *.hh files
+for usage of getParam or getParamFromGroup.
+"""
+
+import os
+import argparse
+import json
+
+
+def getEnclosedContent(string, openKey, closeKey):
+ """find the content of the given string between
+ the first matching pair of opening/closing keys"""
+
+ # cut off everything before the first occurrence of openKey
+ string = openKey + string.partition(openKey)[2]
+
+ # get content between mathing pair
+ rest = string.partition(closeKey)
+ result, rest = rest[0] + closeKey, rest[2]
+ while result.count(openKey) != result.count(closeKey):
+ rest = rest.partition(closeKey)
+ if rest[1] == "":
+ raise IOError(
+ 'Could not get content between "{}" and "{}" in given string "{}"'.format(
+ openKey, closeKey, string
+ )
+ )
+ result, rest = result + rest[0] + closeKey, rest[2]
+
+ return result.partition(openKey)[2].rpartition(closeKey)[0]
+
+
+def extractParameterName(line):
+ """extract a parameter from a given line"""
+
+ # split occurrences of getParam<T>(CALLARGS) or getParamFromGroup<T>(CALLARGS)
+ # into the template arguments T and the function arguments CALLARGS
+ if "getParamFromGroup<" in line:
+ line = line.split("getParamFromGroup")[1]
+ hasGroupPrefix = True
+ elif "getParam<" in line:
+ line = line.split("getParam")[1]
+ hasGroupPrefix = False
+ else:
+ return {}
+
+ # this is a current limitation (fix this if it starts to occur)
+ if line.count("getParam") > 1:
+ raise IOError('Cannot process multiple occurrences of "getParam" in one line')
+
+ # remove trailing spaces and cut off everything behind semicolon
+ line = line.strip("\n").strip(" ").split(";")[0]
+
+ # extract template arg between '<' and '>'
+ paramType = getEnclosedContent(line, "<", ">")
+
+ # extract function arguments
+ functionArgs = line.partition("<" + paramType + ">")[2]
+ functionArgs = getEnclosedContent(functionArgs, "(", ")")
+
+ if hasGroupPrefix:
+ functionArgs = functionArgs.partition(",")[2]
+ functionArgs = functionArgs.partition(",")
+ parameterName = functionArgs[0]
+ defaultValueArg = None if not functionArgs[2] else functionArgs[2]
+
+ paramType = paramType.strip(" ")
+ parameterName = parameterName.strip(" ")
+ if defaultValueArg:
+ defaultValueArg = defaultValueArg.strip(" ")
+
+ # if we get an empty name
+ if len(parameterName) == 0:
+ raise IOError("Could not correctly process parameter name")
+ # if interior spaces occur in the parameter name, we can't identify it
+ if parameterName[0] != '"' or parameterName[-1] != '"' or " " in parameterName:
+ raise IOError("Could not correctly process parameter name")
+
+ return {
+ "paramType": paramType,
+ "paramName": parameterName.strip('"'),
+ "defaultValue": defaultValueArg,
+ }
+
+
+def getParameterListFromFile(fileName, logMessage):
+ """extract all parameters from a given file"""
+ parameterList = []
+ errors = {}
+ with open(fileName) as paramsFile:
+ for lineIdx, line in enumerate(paramsFile):
+ try:
+ param = extractParameterName(line)
+ if param:
+ parameterList.append(param)
+ except IOError as exc:
+ errors[lineIdx] = {"line": line.strip(), "message": exc}
+
+ # print encountered errors
+ if errors:
+ logMessage.append(
+ (
+ "\n\n{} parameter{} in file {} could not be retrieved automatically. "
+ "Please check them yourself:"
+ ).format(len(errors), "s" if len(errors) > 1 else "", fileName)
+ )
+ for lineIdx, errorInfo in errors.items():
+ logMessage.append(f"\n\t-> line {lineIdx}: {errorInfo['line']}")
+ logMessage.append(f"\n\t\t-> error message: {errorInfo['message']}")
+ logMessage.append(" ")
+
+ return parameterList
+
+
+class CheckExistAction(argparse.Action):
+ """check if the input file exists"""
+
+ def __call__(self, parser, namespace, values, option_strings=None):
+ if os.path.isfile(values):
+ setattr(namespace, self.dest, values)
+ setattr(namespace, "hasInput", True)
+ else:
+ parser.error("File {} does not exist!".format(values))
+
+
+argumentParser = argparse.ArgumentParser(
+ description="""
+ This script generates parameters list from header files.
+ The header files "test" and "examples" folders are not included.
+ ----------------------------------------------------------------
+ If input file is given, the descriptions will be copied from the input.
+ Multientry of parameters are allowed in input files.
+ """,
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+argumentParser.add_argument(
+ "--root",
+ help="root path of Dumux",
+ metavar="rootpath",
+ default=os.path.abspath(os.path.join(os.path.abspath(__file__), "../../../")),
+)
+argumentParser.add_argument(
+ "--input",
+ help="json file of given paratemers",
+ action=CheckExistAction,
+ metavar="input",
+ dest="inputFile",
+ default=os.path.abspath(
+ os.path.join(
+ os.path.dirname(os.path.abspath(__file__)), "../../doc/doxygen/extradoc/parameters.json"
+ )
+ ),
+)
+argumentParser.add_argument(
+ "--output",
+ help="relative path (to the root path) of the output file",
+ metavar="output",
+ default="doc/doxygen/extradoc/parameterlist.txt",
+)
+args = vars(argumentParser.parse_args())
+
+# search all *.hh files for parameters
+parameters = []
+log = []
+rootDir = args["root"]
+for root, dirs, files in os.walk(rootDir):
+ dirs[:] = [d for d in dirs if d not in ("test", "examples")]
+ for file in files:
+ if os.path.splitext(file)[1] == ".hh" and os.path.splitext(file)[0] != "parameters":
+ parameters.extend(getParameterListFromFile(os.path.join(root, file), log))
+
+# make sorted dictionary of the entries
+# treat duplicates (could have differing default values or type names - e.g. via aliases)
+parameterDict = {}
+for params in parameters:
+ key = params["paramName"]
+ if key in parameterDict:
+ parameterDict[key]["defaultValue"].append(params["defaultValue"])
+ parameterDict[key]["paramType"].append(params["paramType"])
+ else:
+ parameterDict[key] = params
+ parameterDict[key]["defaultValue"] = [params["defaultValue"]]
+ parameterDict[key]["paramType"] = [params["paramType"]]
+
+# get the explanations from current parameter json file
+inputDict = {}
+if args["inputFile"]:
+ with open(args["inputFile"], "r") as f:
+ data = f.read()
+ inputDict = json.loads(data)
+
+# add the missing parameters from input
+missingParameters = [key for key in inputDict if key.replace("-.", "") not in parameterDict]
+
+for missingKey in missingParameters:
+
+ parameter = inputDict[missingKey]["group"] + "." + inputDict[missingKey]["parameter"]
+
+ hasMode = "mode" in inputDict[missingKey].keys()
+ MODE = ""
+ if hasMode:
+ MODE = inputDict[missingKey]["mode"]
+ if MODE == "manual":
+ key = missingKey.replace("-.", "")
+ parameterDict[key] = inputDict[missingKey]
+ parameterDict[key]["defaultValue"] = inputDict[missingKey]["default"]
+ parameterDict[key]["paramType"] = inputDict[missingKey]["type"]
+ parameterDict[key]["paramName"] = parameter
+
+ log.append(
+ f"\nAdd to parameter list: '{parameter}'"
+ " which could not be extracted from code"
+ f" but is explicitly added in {args['inputFile']}\n"
+ )
+
+ else:
+ log.append(
+ f"\nFound parameter in {args['inputFile']}: "
+ f"'{parameter}', set mode to 'manual' in the input file if it is to be kept.\n"
+ )
+
+parameterDict = dict(sorted(parameterDict.items(), key=lambda kv: kv[0]))
+# determine actual entries (from duplicates)
+# and determine maximum occurring column widths
+
+tableEntryData = []
+for key in parameterDict:
+
+ entry = parameterDict[key]
+ hasGroup = entry["paramName"].count(".") > 0
+ group = "-" if not hasGroup else entry["paramName"].split(".")[0]
+ parameter = entry["paramName"] if not hasGroup else entry["paramName"].partition(".")[2]
+
+ # In case of multiple occurrences,
+ # we prefer the default value from input
+ # otherwise use the first entry that is not None
+ # and write the others in log for possible manual editing
+ # determin multiple entries in input
+ keyInput = group + "." + parameter
+ NUM_ENTRIES = 0
+ if keyInput in inputDict:
+ NUM_ENTRIES = max(
+ len(inputDict[keyInput]["default"]),
+ len(inputDict[keyInput]["type"]),
+ len(inputDict[keyInput]["explanation"]),
+ )
+
+ parameterTypeName = entry["paramType"][0]
+ defaultValue = next((e for e in entry["defaultValue"] if e), "-")
+
+ hasMultiplePT = not all(pt == parameterTypeName for pt in entry["paramType"])
+ hasMultipleDV = not all(
+ dv == (defaultValue if defaultValue != "-" else None) for dv in entry["defaultValue"]
+ )
+ if hasMultiplePT or hasMultipleDV:
+ log.append(
+ f"\n\nFound multiple occurrences of parameter {parameter}"
+ " with differing specifications: "
+ )
+ if hasMultiplePT:
+ log.append("\n -> Specified type names:")
+ for typeName in entry["paramType"]:
+ log.append("\n" + " " * 8 + typeName)
+ if NUM_ENTRIES == 0:
+ log.append(
+ f"\n ---> For the parameters list, {parameterTypeName}"
+ " has been chosen. Please adapt manually if desired."
+ )
+ else:
+ parameterTypeName = inputDict[keyInput]["type"]
+ log.append(
+ f"\n ---> For the parameters list, {parameterTypeName}"
+ " has been chosen. Type is from input file."
+ )
+ if hasMultipleDV:
+ log.append("\n -> Specified default values:")
+ for default in entry["defaultValue"]:
+ log.append("\n" + " " * 8 + (default if default else "- (none given)"))
+ if NUM_ENTRIES == 0:
+ log.append(
+ f"\n ---> For the parameters list, {defaultValue}"
+ " has been chosen. Please adapt manually if desired."
+ )
+ else:
+ defaultValue = inputDict[keyInput]["default"]
+ log.append(
+ f"\n ---> For the parameters list, {defaultValue}"
+ " has been chosen. Default value is from input file."
+ )
+
+ if NUM_ENTRIES == 0:
+ tableEntryData.append(
+ {
+ "group": group,
+ "name": parameter,
+ "type": parameterTypeName,
+ "default": defaultValue,
+ "explanation": "",
+ }
+ )
+ else:
+ explanationMsg = inputDict[keyInput]["explanation"]
+ parameterTypeName = inputDict[keyInput]["type"]
+ defaultValue = inputDict[keyInput]["default"]
+ for i in range(NUM_ENTRIES):
+ # maybe fewer entries for some keys
+ if len(defaultValue) < i + 1:
+ defaultValue.append(defaultValue[i - 1])
+ if len(explanationMsg) < i + 1:
+ explanationMsg.append(explanationMsg[i - 1])
+ if len(parameterTypeName) < i + 1:
+ parameterTypeName.append(parameterTypeName[i - 1])
+
+ tableEntryData.append(
+ {
+ "group": group,
+ "name": parameter,
+ "type": parameterTypeName[i],
+ "default": defaultValue[i],
+ "explanation": explanationMsg[i],
+ }
+ )
+
+# generate actual table entries
+tableEntriesWithGroup = []
+tableEntriesWithoutGroup = []
+PREVIOUS_GROUP_ENTRY = None
+
+GROUP_ENTRY_LENGTH = 20
+PARAM_NAME_LENGTH = 45
+PARAM_TYPE_LENGTH = 24
+DEFAULT_VALUE_LENGTH = 15
+EXPLANATION_LENGTH = 80
+
+
+def tableEntry(groupEntry, paramName, paramTypeName, defaultParamValue, explanation):
+ """Create a table entry for a parameter"""
+ return " * | {} | {} | {} | {} | {} |".format(
+ groupEntry.ljust(GROUP_ENTRY_LENGTH),
+ paramName.ljust(PARAM_NAME_LENGTH),
+ paramTypeName.ljust(PARAM_TYPE_LENGTH),
+ defaultParamValue.ljust(DEFAULT_VALUE_LENGTH),
+ explanation.ljust(EXPLANATION_LENGTH),
+ )
+
+
+for data in tableEntryData:
+
+ groupName = data["group"]
+ if groupName != PREVIOUS_GROUP_ENTRY:
+ PREVIOUS_GROUP_ENTRY = groupName
+ if groupName != "-":
+ groupName = "\\b " + groupName
+
+ if len(data["explanation"].strip()) == 0:
+ log.append(f"\n parameter {groupName}.{data['name']} has no explanation.")
+
+ TABLE_ENTRY = tableEntry(
+ groupEntry=groupName,
+ paramName=data["name"],
+ paramTypeName=data["type"],
+ defaultParamValue=data["default"],
+ explanation=data["explanation"],
+ )
+ if groupName != "-":
+ tableEntriesWithGroup.append(TABLE_ENTRY)
+ else:
+ tableEntriesWithoutGroup.append(TABLE_ENTRY)
+
+# combine entries
+tableEntries = tableEntriesWithoutGroup + tableEntriesWithGroup
+
+HEADER = """/*!
+ *\\internal
+ * ****** W A R N I N G **************************************
+ * This file is auto-generated. Do not manually edit.
+ * Run bin/doc/generate_parameterlist.py
+ * ***********************************************************
+ *\\endinternal
+ *
+ *\\file
+ *\\ingroup Parameter
+ *
+ *\\brief List of currently useable run-time parameters
+ *
+ * The listed run-time parameters are available in general,
+ * but we point out that a certain model might not be able
+ * to use every parameter!
+ *\n"""
+HEADER += " * | " + "Group".ljust(GROUP_ENTRY_LENGTH)
+HEADER += " | " + "Parameter".ljust(PARAM_NAME_LENGTH)
+HEADER += " | " + "Type".ljust(PARAM_TYPE_LENGTH)
+HEADER += " | " + "Default Value".ljust(DEFAULT_VALUE_LENGTH)
+HEADER += " | Explanation ".ljust(EXPLANATION_LENGTH) + "|\n"
+
+HEADER += " * | " + ":-".ljust(GROUP_ENTRY_LENGTH)
+HEADER += " | " + ":-".ljust(PARAM_NAME_LENGTH)
+HEADER += " | " + ":-".ljust(PARAM_TYPE_LENGTH)
+HEADER += " | " + ":-".ljust(DEFAULT_VALUE_LENGTH)
+HEADER += " | :- ".ljust(EXPLANATION_LENGTH) + "|\n"
+
+HEADER += " * | " + "-".ljust(GROUP_ENTRY_LENGTH)
+HEADER += " | " + "ParameterFile".ljust(PARAM_NAME_LENGTH)
+HEADER += " | " + "std::string".ljust(PARAM_TYPE_LENGTH)
+HEADER += " | " + "executable.input".ljust(DEFAULT_VALUE_LENGTH)
+HEADER += " | :- ".ljust(EXPLANATION_LENGTH) + "|\n"
+
+# overwrite the old parameterlist.txt file
+with open(os.path.join(rootDir, args["output"]), "w") as outputfile:
+ outputfile.write(HEADER)
+ for e in tableEntries:
+ outputfile.write(e + "\n")
+ outputfile.write(" */\n")
+ print("Finished, check the output file and log.")
+
+with open("generate_parameterlist.log", "w") as f:
+ f.writelines(log)
diff --git a/bin/doc/getparameterlist.py b/bin/doc/getparameterlist.py
deleted file mode 100644
index 79a1f5fc7f..0000000000
--- a/bin/doc/getparameterlist.py
+++ /dev/null
@@ -1,256 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Automatically updates parameterlist.txt by searching all *.hh files
-for usage of getParam or getParamFromGroup.
-"""
-
-# pylint: skip-file
-# Remove this after rewrite!
-
-import os
-
-
-# find the content of the given string between the first matching pair of opening/closing keys
-def getEnclosedContent(string, openKey, closeKey):
-
- # cut off everything before the first occurence of openKey
- string = openKey + string.partition(openKey)[2]
-
- # get content between mathing pair
- rest = string.partition(closeKey)
- result, rest = rest[0] + closeKey, rest[2]
- while result.count(openKey) != result.count(closeKey):
- rest = rest.partition(closeKey)
- if rest[1] == "":
- raise IOError(
- 'Could not get content between "{}" and "{}" in given string "{}"'.format(
- openKey, closeKey, string
- )
- )
- result, rest = result + rest[0] + closeKey, rest[2]
-
- return result.partition(openKey)[2].rpartition(closeKey)[0]
-
-
-# extract a parameter from a given line
-def extractParamName(line):
-
- # split occurrences of getParam<T>(CALLARGS) or getParamFromGroup<T>(CALLARGS)
- # into the template arguments T and the function arguments CALLARGS
- if "getParamFromGroup<" in line:
- line = line.split("getParamFromGroup")[1]
- hasGroup = True
- elif "getParam<" in line:
- line = line.split("getParam")[1]
- hasGroup = False
- else:
- return {}
-
- # TODO: Support this also
- if line.count("getParam") > 1:
- raise IOError('Cannot process multiple occurrences of "getParam" in one line')
-
- # remove trailing spaces and cut off everything behind semicolon
- line = line.strip("\n").strip(" ").split(";")[0]
-
- # extract template arg between '<' and '>'
- paramType = getEnclosedContent(line, "<", ">")
-
- # extract function arguments
- functionArgs = line.partition("<" + paramType + ">")[2]
- functionArgs = getEnclosedContent(functionArgs, "(", ")")
-
- if hasGroup:
- functionArgs = functionArgs.partition(",")[2]
- functionArgs = functionArgs.partition(",")
- paramName = functionArgs[0]
- defaultValue = None if not functionArgs[2] else functionArgs[2]
-
- paramType = paramType.strip(" ")
- paramName = paramName.strip(" ")
- if defaultValue:
- defaultValue = defaultValue.strip(" ")
-
- # if interior spaces occur in the parameter name, we can't identify it
- if paramName[0] != '"' or paramName[-1] != '"' or " " in paramName:
- raise IOError("Could not correctly process parameter name")
-
- return {"paramType": paramType, "paramName": paramName.strip('"'), "defaultValue": defaultValue}
-
-
-# extract all parameters from a given file
-def getParamsFromFile(file):
- parameters = []
- errors = {}
- with open(file) as f:
- for lineIdx, line in enumerate(f):
- try:
- param = extractParamName(line)
- if param:
- parameters.append(param)
- except IOError as e:
- errors[lineIdx] = {"line": line.strip(), "message": e}
-
- # print encountered errors
- if errors:
- print(
- f"\n\n{len(errors)} parameter{'s' if len(errors) > 1 else ''}"
- f"in file {file} could not be retrieved automatically. "
- "Please check them yourself:"
- )
- for lineIdx in errors:
- print(f"\n\t-> line {lineIdx}: {errors[lineIdx]['line']}")
- print(f"\t\t-> error message: {errors[lineIdx]['message']}")
-
- return parameters
-
-
-# search all *.hh files for parameters
-# TODO: allow runtime args with extensions and folder(s) to be checked
-parameters = []
-rootDir = os.path.dirname(os.path.abspath(__file__)) + "/../../dumux"
-for root, _, files in os.walk(rootDir):
- for file in files:
- if os.path.splitext(file)[1] == ".hh" and os.path.splitext(file)[0] != "parameters":
- parameters.extend(getParamsFromFile(os.path.join(root, file)))
-
-# make sorted dictionary of the entries
-# treat duplicates (could have differing default values or type names - e.g. via aliases)
-parameterDict = {}
-for params in parameters:
- key = params["paramName"]
- if key in parameterDict:
- parameterDict[key]["defaultValue"].append(params["defaultValue"])
- parameterDict[key]["paramType"].append(params["paramType"])
- else:
- parameterDict[key] = params
- parameterDict[key]["defaultValue"] = [params["defaultValue"]]
- parameterDict[key]["paramType"] = [params["paramType"]]
-parameterDict = {key: value for key, value in sorted(parameterDict.items())}
-
-# determine actual entries (from duplicates)
-# and determine maximum occurring column widths
-maxGroupWidth = 0
-maxParamWidth = 0
-maxTypeWidth = 0
-maxDefaultWidth = 0
-
-tableEntryData = []
-for key in parameterDict:
-
- entry = parameterDict[key]
- hasGroup = True if entry["paramName"].count(".") != 0 else False
- groupEntry = "-" if not hasGroup else entry["paramName"].split(".")[0]
- paramName = entry["paramName"] if not hasGroup else entry["paramName"].partition(".")[2]
-
- # In case of multiple occurrences,
- # we use the first entry that is not None
- # and print the others for possible manual editing
- paramType = entry["paramType"][0]
- defaultValue = next((e for e in entry["defaultValue"] if e), "-")
-
- hasMultiplePT = True if not all(pt == paramType for pt in entry["paramType"]) else False
- hasMultipleDV = (
- True
- if not all(
- dv == (defaultValue if defaultValue != "-" else None) for dv in entry["defaultValue"]
- )
- else False
- )
- if hasMultiplePT or hasMultipleDV:
- print(
- f"\nFound multiple occurrences of parameter {paramName}",
- " with differing specifications: ",
- )
- if hasMultiplePT:
- print(" -> Specified type names:")
- for typeName in entry["paramType"]:
- print(" " * 8 + typeName)
- print(
- " ---> For the parameters list, {paramType}"
- " has been chosen. Please adapt manually if desired."
- )
- if hasMultipleDV:
- print(" -> Specified default values:")
- for default in entry["defaultValue"]:
- print(" " * 8 + (default if default else "- (none given)"))
- print(
- f" ---> For the parameters list, {defaultValue}"
- " has been chosen. Please adapt manually if desired."
- )
-
- maxGroupWidth = max(maxGroupWidth, len(groupEntry) + 3) # +3 because \b will be added later
- maxParamWidth = max(maxParamWidth, len(paramName))
- maxTypeWidth = max(maxTypeWidth, len(paramType))
- maxDefaultWidth = max(maxDefaultWidth, len(defaultValue))
- tableEntryData.append(
- {"group": groupEntry, "name": paramName, "type": paramType, "default": defaultValue}
- )
-
-# generate actual table entries
-tableEntriesWithGroup = []
-tableEntriesWithoutGroup = []
-previousGroupEntry = None
-
-for data in tableEntryData:
-
- groupEntry = data["group"]
- paramName = data["name"]
- paramType = data["type"]
- defaultValue = data["default"]
-
- if groupEntry != previousGroupEntry:
- previousGroupEntry = groupEntry
- if groupEntry != "-":
- groupEntry = "\\b " + groupEntry
-
- tableEntry = " * | {} | {} | {} | {} | TODO: explanation |".format(
- groupEntry.ljust(maxGroupWidth),
- paramName.ljust(maxParamWidth),
- paramType.ljust(maxTypeWidth),
- defaultValue.ljust(maxDefaultWidth),
- )
-
- if groupEntry != "-":
- tableEntriesWithGroup.append(tableEntry)
- else:
- tableEntriesWithoutGroup.append(tableEntry)
-
-# combine entries
-tableEntries = tableEntriesWithoutGroup + tableEntriesWithGroup
-
-header = """/*!
- *\\file
- *\\ingroup Parameter
- *
- *\\brief List of currently useable run-time parameters
- *
- * The listed run-time parameters are available in general,
- * but we point out that a certain model might not be able
- * to use every parameter!
- *\n"""
-header += " * | " + "Group".ljust(maxGroupWidth)
-header += " | " + "Parameter".ljust(maxParamWidth)
-header += " | " + "Type".ljust(maxTypeWidth)
-header += " | " + "Default Value".ljust(maxDefaultWidth)
-header += " | Explanation |\n"
-
-header += " * | " + ":-".ljust(maxGroupWidth)
-header += " | " + ":-".ljust(maxParamWidth)
-header += " | " + ":-".ljust(maxTypeWidth)
-header += " | " + ":-".ljust(maxDefaultWidth)
-header += " | :- |\n"
-
-header += " * | " + "".ljust(maxGroupWidth)
-header += " | " + "ParameterFile".ljust(maxParamWidth)
-header += " | " + "std::string".ljust(maxTypeWidth)
-header += " | " + "executable.input".ljust(maxDefaultWidth)
-header += " | :- |\n"
-
-# overwrite the old parameterlist.txt file
-with open(rootDir + "/../doc/doxygen/extradoc/parameterlist.txt", "w") as outputfile:
- outputfile.write(header)
- for e in tableEntries:
- outputfile.write(e + "\n")
- outputfile.write(" */\n")
diff --git a/doc/doxygen/extradoc/parameterlist.txt b/doc/doxygen/extradoc/parameterlist.txt
index c66c5a9f44..822403b159 100644
--- a/doc/doxygen/extradoc/parameterlist.txt
+++ b/doc/doxygen/extradoc/parameterlist.txt
@@ -1,4 +1,11 @@
/*!
+ *\internal
+ * ****** W A R N I N G **************************************
+ * This file is auto-generated. Do not manually edit.
+ * Run bin/doc/generate_parameterlist.py
+ * ***********************************************************
+ *\endinternal
+ *
*\file
*\ingroup Parameter
*
@@ -8,345 +15,267 @@
* but we point out that a certain model might not be able
* to use every parameter!
*
- * | Group | Parameter | Type | Default Value | Explanation |
- * | :- | :- | :- | :- | :- |
- * | - | A00 | Scalar | 0.0 | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A01 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A02 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A1 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A10 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A11 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A2 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A20 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | A3 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
- * | - | BrooksCoreyLambda | Scalar | - | Parameter lambda in Brooks Corey. |
- * | - | BrooksCoreyPcEntry | Scalar | - | Entry capillary pressure in Brooks Corey. |
- * | - | BrooksCoreyPcLowSweThreshold | Scalar | 0.01 | For effective wetting phase saturations below this value, capillary pressure is given by a regularized capillary pressure-saturation curve. |
- * | - | HeatpipeLawGamma | Scalar | - | Parameter gamma in heat pipe law. |
- * | - | HeatpipeLawP0 | Scalar | - | Parameter p0 in heat pipe law. |
- * | - | KrnData | std::vector<Scalar> | - | Relative permeability for the non-wetting phase data for spline material law. |
- * | - | HighSwRegularizationMethod | std::string | - | A regularization method for the capillary pressure at high wetting saturations. Possible values are "Linear", "Spline" and "PowerLaw". |
- * | - | HighSwSplineZeroSlope | bool | true | Whether to use a zero slope of the capillary pressure at high wetting saturations. |
- * | - | KrwData | std::vector<Scalar> | - | Relative permeability for the wetting phase data for spline material law. |
- * | - | LinearPcEntry | Scalar | - | Entry capillary pressure for the linear capillary pressure and relative permeability <-> saturation relations. |
- * | - | LinearPcMax | Scalar | - | Maximum capillary pressure for the linear capillary pressure and relative permeability <-> saturation relations. |
- * | - | ParameterFile | std::string | executablename.input | Command line argument: overwrite parameter file if one was specified on the command line |
- * | - | ParkerVanGenuchtenAlpha | Scalar | - | Shape parameter \f$\mathrm{\alpha}\f$ \f$\mathrm{[1/Pa]}\f$ in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenBetaGn | Scalar | 1.0 | Scaling parameter \f$\mathrm{betaGn}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenBetaGw | Scalar | 1.0 | Scaling parameter \f$\mathrm{betaGw}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenBetaNw | Scalar | 1.0 | Scaling parameter \f$\mathrm{betaNw}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenKrgLowSteThreshold | Scalar | 1e-3 | The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenKrnLowSweThreshold | Scalar | 0.1 | The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenKrwHighSweThreshold | Scalar | 0.9 | The threshold saturation above which the relative permeability of the wetting phase gets regularized in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenN | Scalar | - | Shape parameter \f$\mathrm{n}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenPcHighSweThreshold | Scalar | 0.99 | Threshold saturation above which the capillary pressure is regularized in Parker/vanGenuchten laws. |
- * | - | ParkerVanGenuchtenPcLowSweThreshold | Scalar | 0.01 | Threshold saturation below which the capillary pressure is regularized in Parker/vanGenuchten laws. Most problems are very sensitive to this value (e.g. making it smaller might result in very high capillary pressures). |
- * | - | ParkerVanGenuchtenRegardSnrForKrn | bool | false | In Parker/vanGenuchten laws regard the relative non-wetting saturation in the permeability of the non-wetting phase, see Helmig1997. |
- * | - | PcData | std::vector<Scalar> | - | Capillary pressure data for spline material law. |
- * | - | PcMax | Scalar | - | Maximum capillary pressure for calculating the interfacial area between the nonwetting and wetting phase as in Nuske 2014 (https://elib.uni-stuttgart.de/handle/11682/614, page 60) \cite nuske2014. |
- * | - | RegularizationHighSw | Scalar | std::numeric_limits<Scalar>::quiet_NaN() | The capillary pressure at high wetting saturations. |
- * | - | RegularizationHighSwFixedSlope | Scalar | std::numeric_limits<Scalar>::quiet_NaN() | A fixed slope of the capillary pressure at high wetting saturations. |
- * | - | RegularizationLowSw | Scalar | params.pcLowSw() | The capillary pressure at low wetting saturations. |
- * | - | Restart | double | - | The restart time stamp for a previously interrupted simulation |
- * | - | Sgr | Scalar | 0.0 | Residual gas phase saturation. |
- * | - | SmoothedLinearLawKrHighS | Scalar | - | If the saturation is higher than this value, smoothed linear material law changes to a spline for the relative permeability. |
- * | - | SmoothedLinearLawKrLowS | Scalar | - | If the saturation is lower than this value, smoothed linear material law changes to a spline for the relative permeability. |
- * | - | SmoothedLinearLawPcMax | Scalar | - | The maximum capillary pressure used in the smoothed linear law. |
- * | - | SmoothedLinearLawPe | Scalar | - | The entry pressure used in the smoothed linear law. |
- * | - | Snr | Scalar | 0.0 | Residual non-wetting phase saturation. |
- * | - | SplineNumSwSamples | Scalar | 30 | Number of sample points from which the wetting saturation spline is built. |
- * | - | SplineSweInterval | std::array<Scalar, 2> | std::array<Scalar, 2> default{{ 0.01, 1.0 }} | Effective wetting saturation interval for spline material law. |
- * | - | SwData | std::vector<Scalar> | - | Wetting saturation pressure data for spline material law. |
- * | - | Swr | Scalar | 0.0 | Residual wetting phase saturation. |
- * | - | ThreePNAPLAdsorptionKdNAPL | Scalar | - | kd parameter for the adsportion of NAPL in a 3 phase simulation. |
- * | - | ThreePNAPLAdsorptionRhoBulk | Scalar | - | bulk density for calculating the adsorption of NAPL in a 3 phase simulation. |
- * | - | VanGenuchtenAlpha | Scalar | - | Shape parameter \f$\mathrm{\alpha}\f$ \f$\mathrm{[1/Pa]}\f$ in vanGenuchten laws. |
- * | - | VanGenuchtenConstantRegularization | bool | false | If specified, a constant value is used for regularization in Parker/vanGenuchten. |
- * | - | VanGenuchtenKrnLowSweThreshold | Scalar | 0.1 | The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in vanGenuchten laws. |
- * | - | VanGenuchtenKrwHighSweThreshold | Scalar | 0.9 | The threshold saturation above which the relative permeability of the wetting phase gets regularized in vanGenuchten laws. |
- * | - | VanGenuchtenL | Scalar | 0.5 | Shape parameter \f$\mathrm{m}\f$ \f$\mathrm{[-]}\f$ in vanGenuchten laws. |
- * | - | VanGenuchtenN | Scalar | - | Shape parameter \f$\mathrm{n}\f$ \f$\mathrm{[-]}\f$ in vanGenuchten laws. |
- * | - | VanGenuchtenPcHighSweThreshold | Scalar | 0.99 | Threshold saturation above which the capillary pressure is regularized in vanGenuchten laws. |
- * | - | VanGenuchtenPcLowSweThreshold | Scalar | 0.01 | Threshold saturation below which the capillary pressure is regularized in vanGenuchten laws. |
- * | \b Adaptive | BCRefinementThreshold | Scalar | 1e-10 | The threshold above which fluxes are treated as non-zero |
- * | Adaptive | MaxLevel | int | - | The maximum refinement level |
- * | Adaptive | MinLevel | int | - | The minimum refinement level |
- * | Adaptive | RefineAtDirichletBC | bool | true | Whether to refine at Dirichlet boundaries |
- * | Adaptive | RefineAtFluxBC | bool | true | Whether to refine at Neumann/Robin boundaries |
- * | Adaptive | RefineAtSource | bool | true | Whether to refine where source terms are specified |
- * | \b Assembly | NumericDifference.BaseEpsilon | Scalar | 1e-10 | The basic numeric epsilon used in the differentiation for deflecting primary variables |
- * | Assembly | NumericDifference.PriVarMagnitude | NumEqVector | NumEqVector(-1) | The magnitude of the primary variables used for finding a good numeric epsilon for deflecting primary variables. |
- * | Assembly | NumericDifferenceMethod | int | 1 | The numeric difference method (1: foward differences (default), 0: central differences, -1: backward differences) |
- * | \b BinaryCoefficients | GasDiffCoeff | Scalar | - | The binary diffusion coefficient in gas |
- * | BinaryCoefficients | LiquidDiffCoeff | Scalar | - | The binary diffusion coefficient in liquid |
- * | \b Brine | Salinity | Scalar | - | The salinity |
- * | \b Component | GasDensity | Scalar | - | The density of the gas |
- * | Component | GasDiffusionCoefficient | Scalar | 1.0 | Binary diffusion coefficient for molecular water and the constant component |
- * | Component | GasKinematicViscosity | Scalar | - | The gas kinematic viscosity |
- * | Component | HenryComponentInWater | Scalar | 1.0 | Henry coefficient for the constant component in liquid water |
- * | Component | HenryWaterInComponent | Scalar | 1.0 | Henry coefficient for water in the constant component |
- * | Component | LiquidDensity | Scalar | - | The density of the liquid |
- * | Component | LiquidDiffusionCoefficient | Scalar | 1.0 | Diffusion coefficient for the constant component in liquid water |
- * | Component | LiquidHeatCapacity | Scalar | - | Specific isobaric heat capacity of the component \f$\mathrm{[J/(kg*K)]}\f$ as a liquid. |
- * | Component | LiquidKinematicViscosity | Scalar | - | The liquid kinematic viscosity |
- * | Component | LiquidThermalConductivity | Scalar | - | Thermal conductivity of the component \f$\mathrm{[W/(m*K)]}\f$ as a liquid. |
- * | Component | MolarMass | Scalar | - | The mass in one mole of the component |
- * | Component | Name | std::string | component | A human readable name for the component |
- * | Component | ReferenceTemperature | Scalar | 293.15 | The reference termperature in \f$\mathrm{[K]}\f$ used when calculating the specific internal energy of a constant component as a liquid. |
- * | Component | SolidDensity | Scalar | - | The density of the component in solid state |
- * | Component | SolidHeatCapacity | Scalar | - | Specific isobaric heat capacity of the component as a solid |
- * | Component | SolidThermalConductivity | Scalar | - | Thermal conductivity of the component as a solid |
- * | \b ElectroChemistry | ActivationBarrier | Scalar | - | The activation barrier to calculate the exchange current density. |
- * | ElectroChemistry | CellVoltage | Scalar | - | The voltage of the fuel cell. |
- * | ElectroChemistry | MaxIterations | int | - | The maximum number of iterations in iteatively (Newton solver) calculating the current density. |
- * | ElectroChemistry | NumElectrons | Scalar | - | The number of electrons for the calculation of activation and concentration losses. |
- * | ElectroChemistry | pO2Inlet | Scalar | - | The oxygen pressure at the inlet. |
- * | ElectroChemistry | RefCurrentDensity | Scalar | - | The reference current density to calculate the exchange current density. |
- * | ElectroChemistry | RefO2PartialPressure | Scalar | - | The reference oxygen partial pressure. |
- * | ElectroChemistry | RefTemperature | Scalar | - | The reference temperature to calculate the exchange current density. |
- * | ElectroChemistry | ReversibleVoltage | Scalar | - | The reversible voltage. |
- * | ElectroChemistry | SpecificResistance | Scalar | - | The specific resistance, see \cite A3:acosta:2006. |
- * | ElectroChemistry | SurfaceIncreasingFactor | Scalar | - | The surface-increasing factor to calculate the exchange current density. |
- * | ElectroChemistry | ThermoneutralVoltage | Scalar | - | Thermoneutral voltage for the non-isothermal electrochemistry model. |
- * | ElectroChemistry | TransferCoefficient | Scalar | - | The transport coefficient. |
- * | ElectroChemistry | TransportNumberH20 | Scalar | - | The water transport number to calculate the osmotic term in the membrane. |
- * | \b FacetCoupling | Xi | Scalar | 1.0 | The xi factor for coupling conditions |
- * | \b Flux | DifferencingScheme | std::string | Minmod | Choice of a staggered TVD method |
- * | Flux | TvdApproach | std::string | Uniform | If you use a staggered grid with a TVD approach: For a uniform grid "Uniform" is fine. For a nonuniform grid decide between "Li" and "Hou" (two literature-based methods). |
- * | Flux | UpwindWeight | Scalar | - | Upwind weight in staggered upwind method |
- * | \b FluxLimiterLET | LowerWaterDepth | Scalar | 1e-5 | The lower water depth |
- * | FluxLimiterLET | UpperWaterDepth | Scalar | 1e-3 | The upper water depth |
- * | FluxLimiterLET | UpwindFluxLimiting | bool | false | If this is set true, the upwind water depth from the flux direction is used. This can improve stability. |
- * | \b FluxOverSurface | Verbose | bool | false | For enabling or disabling the console output |
- * | \b Forchheimer | MaxIterations | std::size_t | 30 | The maximum number of Newton iterations for solving the Forchheimer equation |
- * | Forchheimer | NewtonTolerance | Scalar | 1e-12 | The error tolerance in the Newton method for solving the Forchheimer equation |
- * | \b FreeFlow | EnableUnsymmetrizedVelocityGradient | bool | false | For enabling unsymmetrized velocity gradient. If false consider the shear stress caused by the gradient of the velocities normal to our face of interest. |
- * | FreeFlow | EnableUnsymmetrizedVelocityGradientForBeaversJoseph | bool | false | For enabling unsymmetrized velocity gradient for the Beavers Joseph coupling condition. If true and if the current scvf is on a boundary and if a Dirichlet BC for the pressure or a BJ condition for the slip velocity is set there, assume a tangential velocity gradient of zero along the lateral face. |
- * | \b Grid | AddThroatVolumeToPoreVolume | bool | false | Whether to add the throat volume to the pore volume. |
- * | Grid | AllowIntersectingDiagonals | bool | true | Wether to allow diagonals to intersect in the context of the generation of a structured-lattice pore-network. |
- * | Grid | Angular0/1/2 | std::vector<Scalar> | - | min/max value for angular coordinate. Cake grids can be created by either specifying Radial,Angular or Axial in all coordinate directions. |
- * | Grid | Axial0/1/2 | std::vector<Scalar> | - | min/max value for axial coordinate. Cake grids can be created by either specifying Radial,Angular or Axial in all coordinate directions. |
- * | Grid | BoundaryFaceMarker | BoundaryList | - | With this, the boundary faces can be set in the format xmin xmax ymin ymax (zmin zmax). |
- * | Grid | BoundarySegments | bool | false | For the dune gmsh reader: Whether to insert boundary segments into the grid |
- * | Grid | CapPoreRadii | bool | true | If true a maximal pore radius is set. |
- * | Grid | CapPoresOnBoundaries | std::vector<int> | std::vector<int>{} | A vector of boundary indices of for which the pore volume should be halved in a direction within automatically determining the pore volume |
- * | Grid | Cells | std::array<int, dim> | - | The number of elements in a structured uniform grid in x, y and z direction |
- * | Grid | Cells0 | std::vector<int> | - | For a grid with zones, number of cells of the leftmost zone, number of cells of the second-leftmost zone, ..., number of cells of the rightmost zone, spaceseparated. (assuming x-axis points to the right) |
- * | Grid | Cells1 | std::vector<int> | - | Spaceseparated list of the number of cells per zone in y-direction (see more details for x-direction in Cells1). |
- * | Grid | Cells2 | std::vector<int> | - | Spaceseparated list of the number of cells per zone in z-direction (see more details for x-direction in Cells1). |
- * | Grid | CellType | std::string | Cube | "Cube" or "Simplex" to be used for structured grids |
- * | Grid | ClosureType | std::string | Green | Decide whether to add a green closure to locally refined grid sections or not: "Green" (Standard red/green refinement) or "None" (No closure, results in nonconforming meshes) |
- * | Grid | Coordinates | std::vector<ctype> | - | To construct a 1D grid with just a coordinates vector |
- * | Grid | DeletionProbability | std::array<double, numDirections> | - | For a non-regular lattice, you must specifiy deletion probabilities for deleting throats in all directions. For example (3D): DeletionProbability = 0.5 0.5 0 0 0 0 0 0 0 0 0 0 0 deletes approximately 50% of all throats in x and y direction, while no deletion in any other direction takes place. In 2D four values are required (x (1,0),y (0,1) and two diagnals through cell midpoint (1,1),(1,-1)). In 3D thirteen values are required (x(1,0,0),y(0,1,0),z(0,0,1), six face diagonals (1,1,0),(1,-1,0),(1,0,1),(1,0,-1),(0,1,1),(0,1,-1) and four diagonals through cell midpoint (1,1,1),(1,1,-1),(-1,1,1),(-1,-1,1). |
- * | Grid | DeletionRandomNumberSeed | std::size_t | - | A seed for the random number generation for the random deletion of connecting throats. |
- * | Grid | DomainMarkers | bool | false | Whether the grid managers work with domain markers. |
- * | Grid | File | std::string | - | A DGF or gmsh file to load from |
- * | Grid | GmshPhysicalEntityThreshold | std::size_t | 0 | |
- * | Grid | Grading0 | std::vector<Scalar> | - | For a grid with zones, grading factors for the x-zones. 1.0 means all cells within this zone have equal extension in x-direction. Negative factors are possible. |
- * | Grid | Grading1 | std::vector<Scalar> | - | For a grid with zones, grading factors for the y-zones. |
- * | Grid | Grading2 | std::vector<Scalar> | - | For a grid with zones, grading factors for the z-zones. |
- * | Grid | Image | std::string | - | The image file if the sub grid is constructed from a raster image |
- * | Grid | KeepPhysicalOverlap | bool | true | Whether to keep the physical overlap in physical size or in number of cells upon refinement |
- * | Grid | LeftBoundary | Scalar | 0.0 | The start coordinate of a 1D grid |
- * | Grid | LowerLeft | GlobalPosition | - | The lowerLeft corner of a structured grid |
- * | Grid | Marker | bool | 0 | To customize the subgrid generation. |
- * | Grid | MinThroatLength | Scalar | 1e-6 | The minimum pore throat length. |
- * | Grid | NumPores | std::array<unsigned int, dimWorld>| - | The number of pores for a 1D grid. For a more-dimensional grid the number of pores in x,y (and z) direction. |
- * | Grid | NumSubregions | std::size_t | 0 | The number of subregions within a pore-network model. |
- * | Grid | Overlap | int | 1 | The overlap size in cells |
- * | Grid | OverwriteGridDataWithShapeSpecificValues | bool | true | If Grid.ThroatCrossSectionShape is set, here one can set to overwrite the grid data with the shape-specific values. |
- * | Grid | Partitioning | std::array<int, dim> | - | A non-standard load-balancing, number of processors per direction |
- * | Grid | Periodic | std::bitset<dim> | std::bitset<dim>() | True or false for each direction |
- * | Grid | PixelDimensions | GlobalPosition | - | For subgrid generation, this can be used to specify the UpperRight position. To calculate UpperRight this is in every dimension multiplied by the number of cells and added to LowerLeft. |
- * | Grid | PoreGeometry | std::string | - | Pore geometry shape. Possibilities are "Square", "Circle", "Cube", "Sphere", "Cylinder", "Tetrahedron", "Octahedron", "Icosahedron" or "Dodecahedron". |
- * | Grid | PoreHeight | Scalar | -1.0 | A fixed pore height. |
- * | Grid | Positions0 | std::vector<ctype> | - | For a grid with zones, x-positions of the left of the leftmost zone followed by the right of all zones (from left to right). (assuming x-axis points to the right) |
- * | Grid | Positions1 | std::vector<ctype> | - | For a grid with zones, y-positions for zoning in y (more details in Positions0 for x). |
- * | Grid | Positions2 | std::vector<ctype> | - | For a grid with zones, z-positions for zoning in z (more details in Positions0 for x).|
- * | Grid | PriorityList | BoundaryList | - | The priority which decides the order the vertices on the boundary are indexed. By default, vertices on min/max faces in x direction have the highest priority, followed by y and z. |
- * | Grid | PruningSeedIndices | std::vector<int> | std::vector<int>{1} | Indices from which to start the search process for finding elements not connected to pores at a Dirichlet boundary, which are then removed. |
- * | Grid | Radial0/1/2 | std::vector<Scalar> | - | min/max value for radial coordinate. Cake grids can be created by either specifying Radial,Angular or Axial in all coordinate directions. |
- * | Grid | Refinement | int | 0 | The number of global refines to perform |
- * | Grid | RefinementType | std::string | Local | e.g. UGGrid "Local" (New level consists only of the refined elements and the closure) or "Copy" (New level consists of the refined elements and the unrefined ones, too) |
- * | Grid | RegularLattice | bool | false | A regular lattice is when pore are always connected parallel to the main axes and never connected in other directions. |
- * | Grid | RemoveThroatsOnBoundary | std::vector<std::size_t> | - | Whether the throats on the boundary should be removed. |
- * | Grid | RightBoundary | Scalar | - | The end coordinate of a 1D grid |
- * | Grid | SanitationMode | std::string | "KeepLargestCluster" | The mode of sanitation. Sanitation is a post-processing to remove insular groups of elements that are not connected to a Dirichlet boundary. Possible modes are "UsePoreLabels" (keep cluster connected to a specific pore given by a pore label) and "KeepLargestCluster". |
- * | Grid | Sanitize | bool |false(makeFromDgf),true(makeFromStructure)| Whether to sanitize the grid. Sanitizing is a post-processing to remove insular groups of elements that are not connected to a Dirichlet boundary. |
- * | Grid | ThroatCrossSectionShape | std::string | - | A geometry that should be used for all throatcrosssections. The possibilities are "ScaleneTriangle", "EquilateralTriangle", "Square", "Rectangle", "Circle", "TwoPlates", "Polygon". |
- * | Grid | ThroatHeight | Scalar | - | Throat height for a rectangle-shaped throat cross section. |
- * | Grid | ThroatLength | Scalar | -1.0 | A user-specified fixed throat lenght. |
- * | Grid | ThroatShapeFactor | Scalar | - | Throat shape factor for a polygonal throat cross section or a scalene triangle one. |
- * | Grid | UpperRight | GlobalPosition | - | The upperright corner of a structured grid |
- * | Grid | Verbosity | bool | false | Whether the grid construction should output to standard out |
- * | Grid. | FixedPoreRadiusForLabel | std::vector<Scalar> | std::vector<Scalar>{} | Vector of pore radii to be set to the corresponding pores not belonging to a subregion indicated by PoreLabelsToSetFixedRadius. |
- * | Grid. | MaxPoreInscribedRadius | Scalar | - | In the case of a uniform random distribution, this specifies the maximum pore radius. |
- * | Grid. | MeanPoreInscribedRadius | Scalar | - | In the case of a lognormal random distribution, this specifies the mean pore radius. |
- * | Grid. | MinPoreInscribedRadius | Scalar | - | In the case of a uniform random distribution, this specifies the minimum pore radius. |
- * | Grid. | ParameterRandomNumberSeed | unsigned int | std::random_device{}() | If PoreInscribedRadius is not set, this allows to specify a seed to get reproducible results. |
- * | Grid. | ParameterType | std::string | "lognormal" | If PoreInscribedRadius is not set, this allows to specify the type of random distribution for the radii. Possible values are "lognormal" and "uniform". |
- * | Grid. | PoreInscribedRadius | Scalar | -1.0 | If this is set, all pore radii of pore bodies not belonging to a subregion are set to this value. If this is not set, a random radius is set according to a user-specified distribution.|
- * | Grid. | PoreLabelsToApplyFactorForRadius | std::vector<int> | std::vector<int>{} | Lables of pores of pores bodies not belonging to a subregion which should be treated by applying a factor for the radius. |
- * | Grid. | PoreLabelsToSetFixedRadius | std::vector<int> | std::vector<int>{} | Lables of pores of pores bodies not belonging to a subregion which should be treated by setting a fixed radius. |
- * | Grid. | PoreRadiusFactorForLabel | std::vector<Scalar> | std::vector<Scalar>{} | Vector of factors for the radii of the corresponding pores not belonging to a subregion indicated by PoreLabelsToApplyFactorForRadius. |
- * | Grid. | StandardDeviationPoreInscribedRadius | Scalar | - | In the case of a lognormal random distribution, this specifies the standard deviation of the pore radius. |
- * | Grid. | SubstractRadiiFromThroatLength | bool | true | Decide whether to substract the pore radii from the throat length or not for a pore throat not belonging to a subregion. |
- * | Grid. | ThroatInscribedRadius | Scalar | -1.0 | Radius of a pore throat not belonging to a subregion. |
- * | Grid. | ThroatInscribedRadiusN | Scalar | 0.1 | Shape parameter for the calculation of the radius of a pore throat not belonging to a subregion when ThroatInscribedRadius is not set. |
- * | Grid. | ThroatLength | Scalar | -1.0 | Length of a pore throat not belonging to a subregion. |
- * | \b Grid.Subregion0,1,... | FixedPoreRadiusForLabel | std::vector<Scalar> | std::vector<Scalar>{} | Vector of pore radii to be set to the corresponding pores within this subregion indicated by PoreLabelsToSetFixedRadius. |
- * | Grid.Subregion0,1,... | LowerLeft | GlobalPosition | - | Gives the lower left corner position of the subregion grid in the context of a pore-network. |
- * | Grid.Subregion0,1,... | MaxPoreInscribedRadius | Scalar | - | In the case of a uniform random distribution, this specifies the maximum pore radius. |
- * | Grid.Subregion0,1,... | MeanPoreInscribedRadius | Scalar | - | In the case of a lognormal random distribution, this specifies the mean pore radius. |
- * | Grid.Subregion0,1,... | MinPoreInscribedRadius | Scalar | - | In the case of a uniform random distribution, this specifies the minimum pore radius. |
- * | Grid.Subregion0,1,... | ParameterRandomNumberSeed | unsigned int | std::random_device{}() | If PoreInscribedRadius is not set, this allows to specify a seed to get reproducible results. |
- * | Grid.Subregion0,1,... | ParameterType | std::string | "lognormal" | If PoreInscribedRadius is not set, this allows to specify the type of random distribution for the radii. Possible values are "lognormal" and "uniform". |
- * | Grid.Subregion0,1,... | PoreInscribedRadius | Scalar | -1.0 | If this is set, all pore radii of pore bodies of this subregion are set to this value. If this is not set, a random radius is set according to a user-specified distribution.|
- * | Grid.Subregion0,1,... | PoreLabelsToApplyFactorForRadius | std::vector<int> | std::vector<int>{} | Lables of pores of pores bodies within this subregion which should be treated by applying a factor for the radius, case with subregions. |
- * | Grid.Subregion0,1,... | PoreLabelsToSetFixedRadius | std::vector<int> | std::vector<int>{} | Lables of pores of pores bodies within this subregion which should be treated by setting a fixed radius. |
- * | Grid.Subregion0,1,... | PoreRadiusFactorForLabel | std::vector<Scalar> | std::vector<Scalar>{} | Vector of factors for the radii of the corresponding pores within this subregion indicated by PoreLabelsToApplyFactorForRadius. |
- * | Grid.Subregion0,1,... | StandardDeviationPoreInscribedRadius | Scalar | - | In the case of a lognormal random distribution, this specifies the standard deviation of the pore radius. |
- * | Grid.Subregion0,1,... | SubstractRadiiFromThroatLength | bool | true | Decide whether to substract the pore radii from the throat length or not for a pore throat belonging to this subregion. |
- * | Grid.Subregion0,1,... | ThroatInscribedRadius | Scalar | -1.0 | Radius of a pore throat belonging to this subregion. |
- * | Grid.Subregion0,1,... | ThroatInscribedRadiusN | Scalar | 0.1 | Shape parameter for the calculation of the radius of a pore throat belonging to this subregion when ThroatInscribedRadius is not set. |
- * | Grid.Subregion0,1,... | ThroatLength | Scalar | -1.0 | Length of a pore throat belonging to this subregion. |
- * | Grid.Subregion0,1,... | UpperRight | GlobalPosition | - | Gives the upper right corner position of the subregion grid in the context of a pore-network. |
- * | \b GridAdapt | AdaptionInterval | int | 1 | The time step interval for adaption |
- * | GridAdapt | CoarsenTolerance | Scalar | 0.001 | Coarsening threshold to decide whether a cell should be marked for coarsening |
- * | GridAdapt | EnableInitializationIndicator | bool | false | Whether to use initial grid adaption |
- * | GridAdapt | EnableMultiPointFluxApproximation | bool | true | Whether to enable mpfa on hanging nodes |
- * | GridAdapt | MaxInteractionVolumes | int | 4 | The maximum number of interaction volumes considered |
- * | GridAdapt | MaxLevel | int | 1 | The maximum allowed level |
- * | GridAdapt | MinLevel | int | 0 | The minimum allowed level |
- * | GridAdapt | RefineAtDirichletBC | bool | false | To switch for refinement at Dirichlet BCs |
- * | GridAdapt | RefineAtFluxBC | bool | false | To switch for refinement at Neumann BCs |
- * | GridAdapt | RefineAtSource | bool | false | To switch for refinement at sources |
- * | GridAdapt | RefineTolerance | Scalar | 0.05 | Coarsening threshold to decide whether a cell should be marked for refinement |
- * | \b InvasionState | AccuracyCriterion | Scalar | -1.0 | Specifies the allowed relative deviation of the capillary pressure of the upstream pore from the throat's entry capillary pressure after an invasion event. This effectively forces the Newton scheme to use very small time steps at invasion events. A value of 0.9 means that pc must not be smaller than 0.9*pc_entry after the invasion.
- * | InvasionState | BlockNonwettingPhaseAtThroatLabel | std::vector<int> | std::vector<int>{Labels::outlet} | A vector of labels of throats. Block non-wetting phase flux out of the outlet. |
- * | InvasionState | RestrictInvasionToGlobalCapillaryPressure| bool | false | Whether to restrict the invasion behavior by a global capillary pressure defined in the problem. |
- * | InvasionState | Verbosity | bool | true | Whether to print detailed invasion information. |
- * | \b KEpsilon | EnableZeroEqScaling | bool | true | Whether to match the potential zeroeq eddy viscosities for two-layer model at the matching point |
- * | KEpsilon | YPlusThreshold | Scalar | 30 | yPlus below this value is considered as near-wall region |
- * | \b KOmega | EnableDissipationLimiter | bool | true | Whether to enable the dissipation limiter |
- * | KOmega | EnableProductionLimiter | bool | false | Whether to enable the production limiter |
- * | \b LinearSolver | GMResRestart | int | 10 | cycles before restarting |
- * | LinearSolver | MaxIterations | int | 250 | The maximum iterations of the linear solver |
- * | LinearSolver | MaxOrthogonalizationVectors | int | 10 | Maximal number of previous vectors which are orthogonalized against the new search direction |
- * | LinearSolver | Preconditioner.AmgAccumulationMode | std::string | - | If and how data is agglomerated on coarser level to fewer processors. ("atOnce": do agglomeration once and to one process; "successive": Multiple agglomerations to fewer proceses until all data is on one process; "none": Do no agglomeration at all and solve coarse level iteratively). |
- * | LinearSolver | Preconditioner.AmgAdditive | bool | - | Whether to use additive multigrid. |
- * | LinearSolver | Preconditioner.AmgAlpha | double | - | Scaling value for marking connections as strong. |
- * | LinearSolver | Preconditioner.AmgBeta | double | - | Threshold for marking nodes as isolated. |
- * | LinearSolver | Preconditioner.AmgCoarsenTarget | int | - | Maximum number of unknowns on the coarsest level. |
- * | LinearSolver | Preconditioner.AmgCriterionSymmetric | bool | true | If true use SymmetricCriterion (default), else UnSymmetricCriterion |
- * | LinearSolver | Preconditioner.AmgDefaultAggregationDimension| std::size_t | std::to_string(dimension) | Dimension of the problem (used for setting default aggregate size). |
- * | LinearSolver | Preconditioner.AmgDefaultAggregationSizeMode | std::string | isotropic | Whether to set default values depending on isotropy of problem uses parameters "defaultAggregationDimension" and "maxAggregateDistance" (isotropic: For and isotropic problem; anisotropic: for an anisotropic problem). |
- * | LinearSolver | Preconditioner.AmgDiagonalRowIndex | int | 0 | The index to use for the diagonal strength (default 0) if this is i and strengthMeasure is "diagonal", then block[i][i] will be used when determining strength of connection. |
- * | LinearSolver | Preconditioner.AmgGamma | std::size_t | - | 1 for V-cycle, 2 for W-cycle. |
- * | LinearSolver | Preconditioner.AmgMaxAggregateDistance | std::size_t | 2 | Maximum distance in an aggregte (in term of minimum edges needed to travel. one vertex to another within the aggregate). |
- * | LinearSolver | Preconditioner.AmgMaxAggregateSize | std::size_t | - | Maximum number of vertices an aggregate should consist of. |
- * | LinearSolver | Preconditioner.AmgMaxLevel | int | 100 | Maximum number of levels allowed in the hierarchy. |
- * | LinearSolver | Preconditioner.AmgMinAggregateSize | std::size_t | - | Minimum number of vertices an aggregate should consist of. |
- * | LinearSolver | Preconditioner.AmgMinCoarseningRate | int | - | Coarsening will stop if the rate is below this threshold. |
- * | LinearSolver | Preconditioner.AmgPostSmoothingSteps | std::size_t | - | Number of postsmoothing steps. |
- * | LinearSolver | Preconditioner.AmgPreSmoothingSteps | std::size_t | - | Number of presmoothing steps. |
- * | LinearSolver | Preconditioner.AmgProlongationDampingFactor | double | - | Damping factor for the prolongation. |
- * | LinearSolver | Preconditioner.AmgSmootherIterations | int | - | The number of iterations to perform.|
- * | LinearSolver | Preconditioner.AmgSmootherRelaxation | typename SmootherArgs::RelaxationFactor| - | The relaxation factor |
- * | LinearSolver | Preconditioner.AmgStrengthMeasure | std::string | diagonal | What conversion to use to convert a matrix block to a scalar when determining strength of connection: diagonal (use a diagonal of row diagonalRowIndex, class Diagonal, default); rowSum (rowSum norm), frobenius (Frobenius norm); one (use always one and neglect the actual entries). |
- * | LinearSolver | Preconditioner.DetermineRelaxationFactor | bool | true | Whether within the Uzawa algorithm the parameter omega is the relaxation factor is estimated by use of AMG |
- * | LinearSolver | Preconditioner.DirectSolverForA | bool | false | Whether within the Uzawa algorithm a direct solver is used for inverting the 00 matrix block. |
- * | LinearSolver | Preconditioner.ILUOrder | int | 0 | The order of the ILU decomposition. |
- * | LinearSolver | Preconditioner.ILUResort | bool | false | true if a resort of the computed ILU for improved performance should be done. |
- * | LinearSolver | Preconditioner.Iterations | int | 1 | Usually specifies the number of times the preconditioner is applied |
- * | LinearSolver | Preconditioner.PowerLawIterations | std::size_t | 5 | Number of iterations done to estimate the relaxation factor within the Uzawa algorithm. |
- * | LinearSolver | Preconditioner.Relaxation | double | 1 | The relaxation parameter for the preconditioner |
- * | LinearSolver | Preconditioner.Type | std::string | - | The preconditioner type. |
- * | LinearSolver | Preconditioner.Verbosity | int | 0 | The preconditioner verbosity level |
- * | LinearSolver | ResidualReduction | double |1e-13(linear solver),1e-6(nonlinear)| The residual reduction threshold, i.e. stopping criterion |
- * | LinearSolver | Restart | int | 10 | cycles before restarting |
- * | LinearSolver | Type | std::string | - | The type of linear solver, e.g. restartedflexiblegmressolver or uzawa |
- * | LinearSolver | UMFPackOrdering | int | 1 | You can chosse from one of the following ordering strategies: 0: UMFPACK_ORDERING_CHOLMOD, 1: UMFPACK_ORDERING_AMD (default), 2: UMFPACK_ORDERING_GIVEN, 3: UMFPACK_ORDERING_METIS, 4: UMFPACK_ORDERING_BEST, 5: UMFPACK_ORDERING_NONE, 6: UMFPACK_ORDERING_USER. See https://fossies.org/linux/SuiteSparse/UMFPACK/Doc/UMFPACK_UserGuide.pdf page 17 for details.|
- * | LinearSolver | Verbosity | int | 0 | The verbosity level of the linear solver |
- * | \b LoadSolution | CellCenterPriVarNames | std::vector<std::string> | - | Names of cell-centered primary variables of a model with staggered grid discretization |
- * | LoadSolution | FacePriVarNames | std::vector<std::string> | - | Names of primary variables on the cell faces of a model with staggered grid discretization |
- * | LoadSolution | PriVarNames | std::vector<std::string> | - | Primary variable names |
- * | LoadSolution | PriVarNamesState... | std::vector<std::string> | - | Primary variable names state, e.g. p_liq S_gas |
- * | LoadSolution | PriVarNamesState1 | std::vector<std::string> | - | Primary variable names state, e.g. p_liq x^N2_liq |
- * | LoadSolution | PriVarNamesState2 | std::vector<std::string> | - | Primary variable names state, e.g. p_liq x^H2O_gas |
- * | \b MatrixConverter | DeletePatternEntriesBelowAbsThreshold | Scalar | -1.0 | Only set non-zero value if original matrix entry is larger than this. |
- * | \b MixedDimension | IntegrationOrder | int | 1 | The integration order for coupling source |
- * | MixedDimension | KernelIntegrationCRL | double | 0.1 | The characteristic relative length |
- * | MixedDimension | KernelWidthFactor | Scalar | - | The kernel width factor |
- * | MixedDimension | NumCircleSegments | int | - | The number of circle segements in the context of integration points. |
- * | MixedDimension | UseCircleAverage | bool | true | if we use the circle average as the 3D values or a point evaluation |
- * | MixedDimension | WriteIntegrationPointsToFile | bool | false | Whether to write integration points to a file |
- * | \b MPFA | CalcVelocityInTransport | bool | - | Indicates if velocity is reconstructed in the pressure step or in the transport step |
- * | MPFA | EnableComplexLStencil | bool | true | Whether to enable the two non-centered flux stencils |
- * | MPFA | EnableSimpleLStencil | bool | true | Whether to enable the two centered flux stencils |
- * | MPFA | EnableTPFA | bool | false | Whether to enable the use of TPFA if neighboring cells are of the same grid level |
- * | MPFA | Q | CoordScalar | - | The quadrature point parameterizaion to be used on scvfs |
- * | MPFA | TransmissibilityCriterion | int | 0 | |
- * | MPFA | TransmissibilityCriterionThreshold | Scalar | 1e-8 | |
- * | \b Newton | AllowedSaturationChange | Scalar | -1.0 | Maximum allowed (relative or absolute) shift of saturation between to consecutive time steps. If this is not set, any shift is allowed. If SaturationChangeIsRelative is true, relative shifts are considered (while not dividing by zero). If SaturationChangeIsRelative is false, absolute shifts are considered. |
- * | Newton | EnableAbsoluteResidualCriterion | bool | - | For Newton iterations to stop the absolute residual is demanded to be below a threshold value. At least two iterations. |
- * | Newton | EnableChop | bool | - | chop the Newton update at the beginning of the non-linear solver |
- * | Newton | EnableDynamicOutput | bool | true | Prints current information about assembly and solution process in the coarse of the simulation. |
- * | Newton | EnablePartialReassembly | bool | - | Every entity where the primary variables exhibit a relative shift summed up since the last linearization above 'eps' will be reassembled. |
- * | Newton | EnableResidualCriterion | bool | - | declare convergence if the initial residual is reduced by the factor ResidualReduction |
- * | Newton | EnableShiftCriterion | bool | - | For Newton iterations to stop the maximum relative shift abs(uLastIter - uNew)/scalarmax(1.0, abs(uLastIter + uNew)*0.5) is demanded to be below a threshold value. At least two iterations. |
- * | Newton | LineSearchMinRelaxationFactor | Scalar | 0.125 | A minimum relaxation factor for the line serach process. |
- * | Newton | MaxAbsoluteResidual | Scalar | - | The maximum acceptable absolute residual for declaring convergence |
- * | Newton | MaxRelativeShift | Scalar | - | Set the maximum acceptable difference of any primary variable between two iterations for declaring convergence |
- * | Newton | MaxSteps | int | - | The number of iterations after we give up |
- * | Newton | MaxTimeStepDivisions | std::size_t | 10 | The maximum number of time-step divisions |
- * | Newton | MinSteps | int | - | The minimum number of iterations |
- * | Newton | PlausibilityCheck | bool | false | If this is set true, an error is thrown is a saturation is not between zero and one. |
- * | Newton | ReassemblyMaxThreshold | Scalar | 1e2*shiftTolerance_ | 'maxEps' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'maxEps' leads to less/more reassembly if 'omega*shift' is large, i.e., for the first Newton iterations. |
- * | Newton | ReassemblyMinThreshold | Scalar | 1e-1*shiftTolerance_ | 'minEps' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'minEps' leads to less/more reassembly if 'omega*shift' is small, i.e., for the last Newton iterations. |
- * | Newton | ReassemblyShiftWeight | Scalar | 1e-3 | 'omega' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'maxEps' leads to less/more reassembly if 'omega*shift' is large, i.e., for the first Newton iterations. |
- * | Newton | ResidualReduction | Scalar | - | The maximum acceptable residual norm reduction |
- * | Newton | RetryTimeStepReductionFactor | Scalar | 0.5 | Factor for reducing the current time-step |
- * | Newton | SatisfyResidualAndShiftCriterion | bool | - | declare convergence only if both criteria are met |
- * | Newton | SaturationChangeIsRelative | Scalar | false | See explanatio of AllowedSaturationChange. |
- * | Newton | TargetSteps | int | - | The number of iterations which are considered "optimal" |
- * | Newton | UseLineSearch | bool | - | Whether to use line search |
- * | Newton | Verbosity | int | 2 | The verbosity level of the Newton solver |
- * | \b PointSource | EnableBoxLumping | bool | true | For a DOF-index to point source map distribute source using a check if point sources are inside a subcontrolvolume instead of using basis function weights. |
- * | \b PrimaryVariableSwitch | Verbosity | int | 1 | Verbosity level of the primary variable switch. |
- * | \b Problem | EnableGravity | bool | - | Whether to enable the gravity term |
- * | Problem | EnableInertiaTerms | bool | - | Whether to enable the inertia terms |
- * | Problem | Name | std::string | - | Set a name for a problem |
- * | Problem | SandGrainRoughness | Scalar | - | The sand grain roughness |
- * | Problem | UsePrimaryVariableSwitch | bool | - | Whether to perform variable switch at a degree of freedom location |
- * | \b RANS | EddyViscosityModel | std::string | vanDriest | Choose the eddy viscosity model |
- * | RANS | FlowDirectionAxis | int | 0 | The flow direction axis |
- * | RANS | IsFlatWallBounded | bool | false | Set to true, if geometry consists of flat walls |
- * | RANS | TurbulentPrandtlNumber | Scalar | 1.0 | The turbulent Prandtl number |
- * | RANS | TurbulentSchmidtNumber | Scalar | 1.0 | The turbulent Schmidt number |
- * | RANS | UseStoredEddyViscosity | bool | true for lowrekepsilon, false else | Whether to use the stored eddy viscosity |
- * | RANS | WallNormalAxis | int | 1 | The normal wall axis of a flat wall bounded flow |
- * | RANS | WriteFlatWallBoundedFields | bool | isFlatWallBounded | Whether to write output fields for flat wall geometries |
- * | \b ShallowWater | EnableViscousFlux | bool | false | Whether to include a viscous flux contribution. |
- * | ShallowWater | HorizontalCoefficientOfMixingLengthModel | Scalar | 0.1 | For the turbulence model base on the mixing length: The Smagorinsky-like horizontal turbulence coefficient. |
- * | ShallowWater | TurbulentViscosity | Scalar | 1.0e-6 | The (constant) background turbulent viscosity. |
- * | ShallowWater | UseMixingLengthTurbulenceModel | bool | false | Whether the mixing-length turbulence model is used. |
- * | ShallowWater | VerticalCoefficientOfMixingLengthModel | Scalar | 1.0 | For the turbulence model base on the mixing length: The Elder-like vertical turbulence coefficient. |
- * | \b SimpleH2O | ReferenceTemperature | Scalar | 293.15 | The reference temperature in \f$\mathrm{[K]}\f$ for calculating the (liquid or gas) enthalpy of simple H2O. |
- * | \b SpatialParams | ComputeAwsFromAnsAndPcMax | bool | true | Compute volume-specific interfacial area between the wetting and solid phase from interfacial area between nonwetting and solid phase and maximum capillary pressure. |
- * | SpatialParams | ContactAngle | Scalar | 0.0 | This contact angle \f$[rad]\f$ is set both as the contact angle within a pore throat and the one within a pore body. It can be overloaded for solution-dependent values. |
- * | SpatialParams | ForchCoeff | Scalar | 0.55 | The Forchheimer coefficient |
- * | SpatialParams | MinBoundaryPermeability | Scalar | - | The minimum permeability |
- * | SpatialParams | Permeability | Scalar | - | The permeability |
- * | SpatialParams | Porosity | Scalar | - | The porosity |
- * | SpatialParams | SurfaceTension | Scalar | 0.0725 | The value of the surface tension \f$[N/m]\f$. It defaults to the surface tension of water/air. |
- * | SpatialParams | Tortuosity | Scalar | 0.5 | The tortuosity |
- * | \b TimeLoop | Restart | double | 0.0 | The restart time stamp for a previously interrupted simulation |
- * | \b Transmissibility | ConsiderPoreResistance | bool | true | Whether or not the pore resistance should be considered on runtime. |
- * | \b Vtk | AddProcessRank | bool | - | Whether to add a process rank |
- * | Vtk | AddVelocity | bool | true | Whether to enable velocity output |
- * | Vtk | CoordPrecision | std::string | value set to Vtk.Precision before | The output precision of coordinates. |
- * | Vtk | OutputLevel | int | - | in sequential models: indicates which values the VTK output contains, e.g. if the OutputLevel is zero, only primary variables are written |
- * | Vtk | Precision | std::string | Float32 | Precision of the vtk output |
- * | Vtk | WriteFaceData | bool | false | For the staggered grid approach, write face-related data into vtp files. |
+ * | Group | Parameter | Type | Default Value | Explanation |
+ * | :- | :- | :- | :- | :- |
+ * | - | ParameterFile | std::string | executable.input | :- |
+ * | - | A00 | Scalar | 0.0 | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A00 | Bool | true | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A01 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A02 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A1 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A10 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A11 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A2 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A20 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | A3 | Scalar | - | A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order. |
+ * | - | BrooksCoreyLambda | Scalar | - | Parameter lambda in Brooks Corey. |
+ * | - | BrooksCoreyPcEntry | Scalar | - | Entry capillary pressure in Brooks Corey. |
+ * | - | BrooksCoreyPcLowSweThreshold | Scalar | 0.01 | For effective wetting phase saturations below this value, capillary pressure is given by a regularized capillary pressure-saturation curve. |
+ * | - | HeatpipeLawGamma | Scalar | - | Parameter gamma in heat pipe law. |
+ * | - | HeatpipeLawP0 | Scalar | - | Parameter p0 in heat pipe law. |
+ * | - | HighSwRegularizationMethod | std::string | - | A regularization method for the capillary pressure at high wetting saturations. Possible values are "Linear", "Spline" and "PowerLaw". |
+ * | - | HighSwSplineZeroSlope | bool | true | Whether to use a zero slope of the capillary pressure at high wetting saturations. |
+ * | - | KrnData | std::vector<Scalar> | - | Relative permeability for the non-wetting phase data for spline material law. |
+ * | - | KrwData | std::vector<Scalar> | - | Relative permeability for the wetting phase data for spline material law. |
+ * | - | LinearPcEntry | Scalar | - | Entry capillary pressure for the linear capillary pressure and relative permeability <-> saturation relations. |
+ * | - | LinearPcMax | Scalar | - | Maximum capillary pressure for the linear capillary pressure and relative permeability <-> saturation relations. |
+ * | - | ParkerVanGenuchtenAlpha | Scalar | - | Shape parameter \f$\mathrm{\alpha}\f$ \f$\mathrm{[1/Pa]}\f$ in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenBetaGn | Scalar | 1.0 | Scaling parameter \f$\mathrm{betaGn}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenBetaGw | Scalar | 1.0 | Scaling parameter \f$\mathrm{betaGw}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenBetaNw | Scalar | 1.0 | Scaling parameter \f$\mathrm{betaNw}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenKrgLowSteThreshold | Scalar | 1e-3 | The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenKrnLowSweThreshold | Scalar | 0.1 | The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenKrwHighSweThreshold | Scalar | 0.9 | The threshold saturation above which the relative permeability of the wetting phase gets regularized in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenN | Scalar | - | Shape parameter \f$\mathrm{n}\f$ \f$\mathrm{[-]}\f$ in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenPcHighSweThreshold | Scalar | 0.99 | Threshold saturation above which the capillary pressure is regularized in Parker/vanGenuchten laws. |
+ * | - | ParkerVanGenuchtenPcLowSweThreshold | Scalar | 0.01 | Threshold saturation below which the capillary pressure is regularized in Parker/vanGenuchten laws. Most problems are very sensitive to this value (e.g. making it smaller might result in very high capillary pressures). |
+ * | - | ParkerVanGenuchtenRegardSnrForKrn | bool | false | In Parker/vanGenuchten laws regard the relative non-wetting saturation in the permeability of the non-wetting phase, see Helmig1997. |
+ * | - | PcData | std::vector<Scalar> | - | Capillary pressure data for spline material law. |
+ * | - | PcMax | Scalar | - | Maximum capillary pressure for calculating the interfacial area between the nonwetting and wetting phase as in Nuske 2014 (https://elib.uni-stuttgart.de/handle/11682/614, page 60) \cite nuske2014. |
+ * | - | RegularizationHighSw | Scalar | std::numeric_limits<Scalar>::quiet_NaN() | The capillary pressure at high wetting saturations. |
+ * | - | RegularizationHighSwFixedSlope | Scalar | std::numeric_limits<Scalar>::quiet_NaN() | A fixed slope of the capillary pressure at high wetting saturations. |
+ * | - | RegularizationLowSw | Scalar | params.pcLowSw() | The capillary pressure at low wetting saturations. |
+ * | - | Restart | double | - | The restart time stamp for a previously interrupted simulation |
+ * | - | Sgr | Scalar | 0.0 | Residual gas phase saturation. |
+ * | - | SmoothedLinearLawKrHighS | Scalar | - | If the saturation is higher than this value, smoothed linear material law changes to a spline for the relative permeability. |
+ * | - | SmoothedLinearLawKrLowS | Scalar | - | If the saturation is lower than this value, smoothed linear material law changes to a spline for the relative permeability. |
+ * | - | SmoothedLinearLawPcMax | Scalar | - | The maximum capillary pressure used in the smoothed linear law. |
+ * | - | SmoothedLinearLawPe | Scalar | - | The entry pressure used in the smoothed linear law. |
+ * | - | Snr | Scalar | 0.0 | Residual non-wetting phase saturation. |
+ * | - | SplineNumSwSamples | Scalar | 30 | Number of sample points from which the wetting saturation spline is built. |
+ * | - | SplineSweInterval | std::array<Scalar, 2> | std::array<Scalar, 2> default{{ 0.01, 1.0 }} | Effective wetting saturation interval for spline material law. |
+ * | - | SwData | std::vector<Scalar> | - | Wetting saturation pressure data for spline material law. |
+ * | - | Swr | Scalar | 0.0 | Residual wetting phase saturation. |
+ * | - | ThreePNAPLAdsorptionKdNAPL | Scalar | - | kd parameter for the adsportion of NAPL in a 3 phase simulation. |
+ * | - | ThreePNAPLAdsorptionRhoBulk | Scalar | - | bulk density for calculating the adsorption of NAPL in a 3 phase simulation. |
+ * | - | VanGenuchtenAlpha | Scalar | - | Shape parameter \f$\mathrm{\alpha}\f$ \f$\mathrm{[1/Pa]}\f$ in vanGenuchten laws. |
+ * | - | VanGenuchtenConstantRegularization | bool | false | If specified, a constant value is used for regularization in Parker/vanGenuchten. |
+ * | - | VanGenuchtenKrnLowSweThreshold | Scalar | 0.1 | The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in vanGenuchten laws. |
+ * | - | VanGenuchtenKrwHighSweThreshold | Scalar | 0.9 | The threshold saturation above which the relative permeability of the wetting phase gets regularized in vanGenuchten laws. |
+ * | - | VanGenuchtenL | Scalar | 0.5 | Shape parameter \f$\mathrm{m}\f$ \f$\mathrm{[-]}\f$ in vanGenuchten laws. |
+ * | - | VanGenuchtenN | Scalar | - | Shape parameter \f$\mathrm{n}\f$ \f$\mathrm{[-]}\f$ in vanGenuchten laws. |
+ * | - | VanGenuchtenPcHighSweThreshold | Scalar | 0.99 | Threshold saturation above which the capillary pressure is regularized in vanGenuchten laws. |
+ * | - | VanGenuchtenPcLowSweThreshold | Scalar | 0.01 | Threshold saturation below which the capillary pressure is regularized in vanGenuchten laws. |
+ * | \b Adaptive | BCRefinementThreshold | Scalar | 1e-10 | The threshold above which fluxes are treated as non-zero |
+ * | Adaptive | MaxLevel | int | - | The maximum refinement level |
+ * | Adaptive | MinLevel | int | - | The minimum refinement level |
+ * | Adaptive | RefineAtDirichletBC | bool | true | Whether to refine at Dirichlet boundaries |
+ * | Adaptive | RefineAtFluxBC | bool | true | Whether to refine at Neumann/Robin boundaries |
+ * | Adaptive | RefineAtSource | bool | true | Whether to refine where source terms are specified |
+ * | \b Assembly | NumericDifference.BaseEpsilon | Scalar | 1e-10 | The basic numeric epsilon used in the differentiation for deflecting primary variables |
+ * | Assembly | NumericDifference.PriVarMagnitude | NumEqVector | NumEqVector(-1) | The magnitude of the primary variables used for finding a good numeric epsilon for deflecting primary variables. |
+ * | Assembly | NumericDifferenceMethod | int | 1 | The numeric difference method (1: foward differences (default), 0: central differences, -1: backward differences) |
+ * | \b BinaryCoefficients | GasDiffCoeff | Scalar | - | The binary diffusion coefficient in gas |
+ * | BinaryCoefficients | LiquidDiffCoeff | Scalar | - | The binary diffusion coefficient in liquid |
+ * | \b Brine | Salinity | Scalar | - | The salinity |
+ * | \b Component | GasDensity | Scalar | - | The density of the gas |
+ * | Component | GasDiffusionCoefficient | Scalar | 1.0 | Binary diffusion coefficient for molecular water and the constant component |
+ * | Component | GasDynamicViscosity | Scalar | - | |
+ * | Component | GasKinematicViscosity | Scalar | - | The gas kinematic viscosity |
+ * | Component | HenryComponentInWater | Scalar | 1.0 | Henry coefficient for the constant component in liquid water |
+ * | Component | HenryWaterInComponent | Scalar | 1.0 | Henry coefficient for water in the constant component |
+ * | Component | LiquidDensity | Scalar | - | The density of the liquid |
+ * | Component | LiquidDiffusionCoefficient | Scalar | 1.0 | Diffusion coefficient for the constant component in liquid water |
+ * | Component | LiquidDynamicViscosity | Scalar | - | |
+ * | Component | LiquidHeatCapacity | Scalar | - | Specific isobaric heat capacity of the component \f$\mathrm{[J/(kg*K)]}\f$ as a liquid. |
+ * | Component | LiquidKinematicViscosity | Scalar | - | The liquid kinematic viscosity |
+ * | Component | LiquidThermalConductivity | Scalar | - | Thermal conductivity of the component \f$\mathrm{[W/(m*K)]}\f$ as a liquid. |
+ * | Component | MolarMass | Scalar | - | The mass in one mole of the component |
+ * | Component | Name | std::string | component | A human readable name for the component |
+ * | Component | ReferenceTemperature | Scalar | 293.15 | The reference termperature in \f$\mathrm{[K]}\f$ used when calculating the specific internal energy of a constant component as a liquid. |
+ * | Component | SolidDensity | Scalar | - | The density of the component in solid state |
+ * | Component | SolidHeatCapacity | Scalar | - | Specific isobaric heat capacity of the component as a solid |
+ * | Component | SolidThermalConductivity | Scalar | - | Thermal conductivity of the component as a solid |
+ * | \b ElectroChemistry | ActivationBarrier | Scalar | - | The activation barrier to calculate the exchange current density. |
+ * | ElectroChemistry | CellVoltage | Scalar | - | The voltage of the fuel cell. |
+ * | ElectroChemistry | MaxIterations | int | - | The maximum number of iterations in iteatively (Newton solver) calculating the current density. |
+ * | ElectroChemistry | NumElectrons | Scalar | - | The number of electrons for the calculation of activation and concentration losses. |
+ * | ElectroChemistry | RefCurrentDensity | Scalar | - | The reference current density to calculate the exchange current density. |
+ * | ElectroChemistry | RefO2PartialPressure | Scalar | - | The reference oxygen partial pressure. |
+ * | ElectroChemistry | RefTemperature | Scalar | - | The reference temperature to calculate the exchange current density. |
+ * | ElectroChemistry | ReversibleVoltage | Scalar | - | The reversible voltage. |
+ * | ElectroChemistry | SpecificResistance | Scalar | - | The specific resistance, see \cite A3:acosta:2006. |
+ * | ElectroChemistry | SurfaceIncreasingFactor | Scalar | - | The surface-increasing factor to calculate the exchange current density. |
+ * | ElectroChemistry | ThermoneutralVoltage | Scalar | - | Thermoneutral voltage for the non-isothermal electrochemistry model. |
+ * | ElectroChemistry | TransferCoefficient | Scalar | - | The transport coefficient. |
+ * | ElectroChemistry | TransportNumberH20 | Scalar | - | The water transport number to calculate the osmotic term in the membrane. |
+ * | ElectroChemistry | pO2Inlet | Scalar | - | The oxygen pressure at the inlet. |
+ * | \b FacetCoupling | Xi | Scalar | 1.0 | The xi factor for coupling conditions |
+ * | \b Flux | DifferencingScheme | std::string | Minmod | Choice of a staggered TVD method |
+ * | Flux | EnableOutflowReversalWarning | bool | true | |
+ * | Flux | TvdApproach | std::string | Uniform | If you use a staggered grid with a TVD approach: For a uniform grid "Uniform" is fine. For a nonuniform grid decide between "Li" and "Hou" (two literature-based methods). |
+ * | Flux | UpwindWeight | Scalar | - | Upwind weight in staggered upwind method |
+ * | \b FluxLimiterLET | LowerWaterDepth | Scalar | 1e-5 | The lower water depth |
+ * | FluxLimiterLET | UpperWaterDepth | Scalar | 1e-3 | The upper water depth |
+ * | FluxLimiterLET | UpwindFluxLimiting | bool | false | If this is set true, the upwind water depth from the flux direction is used. This can improve stability. |
+ * | \b FluxOverSurface | Verbose | bool | false | For enabling or disabling the console output |
+ * | \b Forchheimer | MaxIterations | std::size_t | 30 | The maximum number of Newton iterations for solving the Forchheimer equation |
+ * | Forchheimer | NewtonTolerance | Scalar | 1e-12 | The error tolerance in the Newton method for solving the Forchheimer equation |
+ * | \b FreeFlow | EnableDilatationTerm | bool | false | |
+ * | FreeFlow | EnableUnsymmetrizedVelocityGradient | bool | false | For enabling unsymmetrized velocity gradient. If false consider the shear stress caused by the gradient of the velocities normal to our face of interest. |
+ * | FreeFlow | EnableUnsymmetrizedVelocityGradientForBeaversJoseph | bool | false | For enabling unsymmetrized velocity gradient for the Beavers Joseph coupling condition. If true and if the current scvf is on a boundary and if a Dirichlet BC for the pressure or a BJ condition for the slip velocity is set there, assume a tangential velocity gradient of zero along the lateral face. |
+ * | FreeFlow | UseOldTransportingVelocity | bool | true | |
+ * | \b Grid | AddThroatVolumeToPoreVolume | bool | false | Whether to add the throat volume to the pore volume. |
+ * | Grid | AllowIntersectingDiagonals | bool | true | Wether to allow diagonals to intersect in the context of the generation of a structured-lattice pore-network. |
+ * | Grid | BoundaryFaceMarker | BoundaryList | - | With this, the boundary faces can be set in the format xmin xmax ymin ymax (zmin zmax). |
+ * | Grid | BoundarySegments | bool | false | For the dune gmsh reader: Whether to insert boundary segments into the grid |
+ * | Grid | CapPoreRadii | bool | true | If true a maximal pore radius is set. |
+ * | Grid | CapPoresOnBoundaries | std::vector<int> | std::vector<int>{} | A vector of boundary indices of for which the pore volume should be halved in a direction within automatically determining the pore volume |
+ * | Grid | CellType | std::string | Cube | "Cube" or "Simplex" to be used for structured grids |
+ * | Grid | Cells | std::array<int, dim> | - | The number of elements in a structured uniform grid in x, y and z direction |
+ * | Grid | ClosureType | std::string | Green | Decide whether to add a green closure to locally refined grid sections or not: "Green" (Standard red/green refinement) or "None" (No closure, results in nonconforming meshes) |
+ * | Grid | Coordinates | std::vector<ctype> | - | To construct a 1D grid with just a coordinates vector |
+ * | Grid | DeletionProbability | std::array<double, numDirections> | - | For a non-regular lattice, you must specifiy deletion probabilities for deleting throats in all directions. For example (3D): DeletionProbability = 0.5 0.5 0 0 0 0 0 0 0 0 0 0 0 deletes approximately 50% of all throats in x and y direction, while no deletion in any other direction takes place. In 2D four values are required (x (1,0),y (0,1) and two diagnals through cell midpoint (1,1),(1,-1)). In 3D thirteen values are required (x(1,0,0),y(0,1,0),z(0,0,1), six face diagonals (1,1,0),(1,-1,0),(1,0,1),(1,0,-1),(0,1,1),(0,1,-1) and four diagonals through cell midpoint (1,1,1),(1,1,-1),(-1,1,1),(-1,-1,1). |
+ * | Grid | DeletionRandomNumberSeed | std::size_t | - | A seed for the random number generation for the random deletion of connecting throats. |
+ * | Grid | DomainMarkers | bool | false | Whether the grid managers work with domain markers. |
+ * | Grid | File | std::string | - | A DGF or gmsh file to load from |
+ * | Grid | GmshPhysicalEntityThreshold | std::size_t | 0 | |
+ * | Grid | Image | std::string | - | The image file if the sub grid is constructed from a raster image |
+ * | Grid | KeepPhysicalOverlap | bool | true | Whether to keep the physical overlap in physical size or in number of cells upon refinement |
+ * | Grid | LeftBoundary | Scalar | 0.0 | The start coordinate of a 1D grid |
+ * | Grid | LowerLeft | GlobalPosition | - | The lowerLeft corner of a structured grid |
+ * | Grid | MakeConsistentlyOriented | bool | true | |
+ * | Grid | Marker | bool | 0 | To customize the subgrid generation. |
+ * | Grid | MinThroatLength | Scalar | 1e-6 | The minimum pore throat length. |
+ * | Grid | NumPores | std::array<unsigned int, dimWorld> | - | The number of pores for a 1D grid. For a more-dimensional grid the number of pores in x,y (and z) direction. |
+ * | Grid | NumSubregions | std::size_t | 0 | The number of subregions within a pore-network model. |
+ * | Grid | Overlap | int | 1 | The overlap size in cells |
+ * | Grid | OverwriteGridDataWithShapeSpecificValues | bool | true | If Grid.ThroatCrossSectionShape is set, here one can set to overwrite the grid data with the shape-specific values. |
+ * | Grid | Partitioning | std::array<int, dim> | - | A non-standard load-balancing, number of processors per direction |
+ * | Grid | Periodic | std::bitset<dim> | std::bitset<dim>() | True or false for each direction |
+ * | Grid | PixelDimensions | GlobalPosition | - | For subgrid generation, this can be used to specify the UpperRight position. To calculate UpperRight this is in every dimension multiplied by the number of cells and added to LowerLeft. |
+ * | Grid | PoreGeometry | std::string | - | Pore geometry shape. Possibilities are "Square", "Circle", "Cube", "Sphere", "Cylinder", "Tetrahedron", "Octahedron", "Icosahedron" or "Dodecahedron". |
+ * | Grid | PoreHeight | Scalar | -1.0 | A fixed pore height. |
+ * | Grid | Positions0 | std::vector<ctype> | - | For a grid with zones, x-positions of the left of the leftmost zone followed by the right of all zones (from left to right). (assuming x-axis points to the right) |
+ * | Grid | PriorityList | BoundaryList | - | The priority which decides the order the vertices on the boundary are indexed. By default, vertices on min/max faces in x direction have the highest priority, followed by y and z. |
+ * | Grid | PruningSeedIndices | std::vector<int> | std::vector<int>{1} | Indices from which to start the search process for finding elements not connected to pores at a Dirichlet boundary, which are then removed. |
+ * | Grid | Refinement | int | 0 | The number of global refines to perform |
+ * | Grid | RefinementType | std::string | Local | e.g. UGGrid "Local" (New level consists only of the refined elements and the closure) or "Copy" (New level consists of the refined elements and the unrefined ones, too) |
+ * | Grid | RegularLattice | bool | false | A regular lattice is when pore are always connected parallel to the main axes and never connected in other directions. |
+ * | Grid | RemoveThroatsOnBoundary | std::vector<std::size_t> | - | Whether the throats on the boundary should be removed. |
+ * | Grid | RightBoundary | Scalar | - | The end coordinate of a 1D grid |
+ * | Grid | SanitationMode | std::string | "KeepLargestCluster" | The mode of sanitation. Sanitation is a post-processing to remove insular groups of elements that are not connected to a Dirichlet boundary. Possible modes are "UsePoreLabels" (keep cluster connected to a specific pore given by a pore label) and "KeepLargestCluster". |
+ * | Grid | Sanitize | bool | false(makeFromDgf),true(makeFromStructure) | Whether to sanitize the grid. Sanitizing is a post-processing to remove insular groups of elements that are not connected to a Dirichlet boundary. |
+ * | Grid | ThroatCrossSectionShape | std::string | - | A geometry that should be used for all throatcrosssections. The possibilities are "ScaleneTriangle", "EquilateralTriangle", "Square", "Rectangle", "Circle", "TwoPlates", "Polygon". |
+ * | Grid | ThroatHeight | Scalar | - | Throat height for a rectangle-shaped throat cross section. |
+ * | Grid | ThroatLength | Scalar | -1.0 | A user-specified fixed throat lenght. |
+ * | Grid | ThroatShapeFactor | Scalar | - | Throat shape factor for a polygonal throat cross section or a scalene triangle one. |
+ * | Grid | UpperRight | GlobalPosition | - | The upperright corner of a structured grid |
+ * | Grid | Verbosity | bool | false | Whether the grid construction should output to standard out |
+ * | \b InvasionState | AccuracyCriterion | Scalar | -1.0 | Specifies the allowed relative deviation of the capillary pressure of the upstream pore from the throat's entry capillary pressure after an invasion event. This effectively forces the Newton scheme to use very small time steps at invasion events. A value of 0.9 means that pc must not be smaller than 0.9*pc_entry after the invasion. |
+ * | InvasionState | BlockNonwettingPhaseAtThroatLabel | std::vector<int> | std::vector<int>{Labels::outlet} | A vector of labels of throats. Block non-wetting phase flux out of the outlet. |
+ * | InvasionState | RestrictInvasionToGlobalCapillaryPressure | bool | false | Whether to restrict the invasion behavior by a global capillary pressure defined in the problem. |
+ * | InvasionState | Verbosity | bool | true | Whether to print detailed invasion information. |
+ * | \b KEpsilon | EnableZeroEqScaling | bool | true | Whether to match the potential zeroeq eddy viscosities for two-layer model at the matching point |
+ * | KEpsilon | YPlusThreshold | Scalar | 30 | yPlus below this value is considered as near-wall region |
+ * | \b KOmega | EnableDissipationLimiter | bool | true | Whether to enable the dissipation limiter |
+ * | KOmega | EnableProductionLimiter | bool | false | Whether to enable the production limiter |
+ * | \b LinearSolver | GMResRestart | int | 10 | cycles before restarting |
+ * | LinearSolver | MaxIterations | int | 250 | The maximum iterations of the linear solver |
+ * | LinearSolver | Preconditioner.DetermineRelaxationFactor | bool | true | Whether within the Uzawa algorithm the parameter omega is the relaxation factor is estimated by use of AMG |
+ * | LinearSolver | Preconditioner.DirectSolverForA | bool | false | Whether within the Uzawa algorithm a direct solver is used for inverting the 00 matrix block. |
+ * | LinearSolver | Preconditioner.Iterations | int | 1 | Usually specifies the number of times the preconditioner is applied |
+ * | LinearSolver | Preconditioner.PowerLawIterations | std::size_t | 5 | Number of iterations done to estimate the relaxation factor within the Uzawa algorithm. |
+ * | LinearSolver | Preconditioner.Relaxation | double | 1 | The relaxation parameter for the preconditioner |
+ * | LinearSolver | Preconditioner.Verbosity | int | 0 | The preconditioner verbosity level |
+ * | LinearSolver | ResidualReduction | double | 1e-13(linear solver),1e-6(nonlinear) | The residual reduction threshold, i.e. stopping criterion |
+ * | LinearSolver | UMFPackOrdering | int | 1 | You can chosse from one of the following ordering strategies: 0: UMFPACK_ORDERING_CHOLMOD, 1: UMFPACK_ORDERING_AMD (default), 2: UMFPACK_ORDERING_GIVEN, 3: UMFPACK_ORDERING_METIS, 4: UMFPACK_ORDERING_BEST, 5: UMFPACK_ORDERING_NONE, 6: UMFPACK_ORDERING_USER. See https://fossies.org/linux/SuiteSparse/UMFPACK/Doc/UMFPACK_UserGuide.pdf page 17 for details. |
+ * | LinearSolver | Verbosity | int | 0 | The verbosity level of the linear solver |
+ * | \b LoadSolution | CellCenterPriVarNames | std::vector<std::string> | - | Names of cell-centered primary variables of a model with staggered grid discretization |
+ * | LoadSolution | FacePriVarNames | std::vector<std::string> | - | Names of primary variables on the cell faces of a model with staggered grid discretization |
+ * | LoadSolution | PriVarNames | std::vector<std::string> | - | Primary variable names |
+ * | \b MPFA | Q | CoordScalar | - | The quadrature point parameterizaion to be used on scvfs |
+ * | \b MatrixConverter | DeletePatternEntriesBelowAbsThreshold | Scalar | -1.0 | Only set non-zero value if original matrix entry is larger than this. |
+ * | \b MixedDimension | IntegrationOrder | int | 1 | The integration order for coupling source |
+ * | MixedDimension | KernelIntegrationCRL | double | 0.1 | The characteristic relative length |
+ * | MixedDimension | KernelWidthFactor | Scalar | - | The kernel width factor |
+ * | MixedDimension | NumCircleSegments | int | - | The number of circle segements in the context of integration points. |
+ * | MixedDimension | Projection.ConsiderFacesWithinBoundingBoxCoupled | bool | false | |
+ * | MixedDimension | Projection.CoupledAngleFactor | Scalar | 0.3 | |
+ * | MixedDimension | Projection.CoupledBoundingBoxShrinkingFactor | Scalar | 1e-2 | |
+ * | MixedDimension | Projection.CoupledRadiusFactor | Scalar | 0.1 | |
+ * | MixedDimension | Projection.EnableIntersectionOutput | bool | false | |
+ * | MixedDimension | Projection.EstimateNumberOfPointSources | std::size_t | bulkFvGridGeometry.gridView().size(0) | |
+ * | MixedDimension | Projection.SimplexIntegrationRefine | std::size_t | 4 | |
+ * | MixedDimension | UseCircleAverage | bool | true | if we use the circle average as the 3D values or a point evaluation |
+ * | MixedDimension | WriteIntegrationPointsToFile | bool | false | Whether to write integration points to a file |
+ * | \b Newton | AllowedSaturationChange | Scalar | -1.0 | Maximum allowed (relative or absolute) shift of saturation between to consecutive time steps. If this is not set, any shift is allowed. If SaturationChangeIsRelative is true, relative shifts are considered (while not dividing by zero). If SaturationChangeIsRelative is false, absolute shifts are considered. |
+ * | Newton | EnableAbsoluteResidualCriterion | bool | - | For Newton iterations to stop the absolute residual is demanded to be below a threshold value. At least two iterations. |
+ * | Newton | EnableChop | bool | - | chop the Newton update at the beginning of the non-linear solver |
+ * | Newton | EnableDynamicOutput | bool | true | Prints current information about assembly and solution process in the coarse of the simulation. |
+ * | Newton | EnablePartialReassembly | bool | - | Every entity where the primary variables exhibit a relative shift summed up since the last linearization above 'eps' will be reassembled. |
+ * | Newton | EnableResidualCriterion | bool | - | declare convergence if the initial residual is reduced by the factor ResidualReduction |
+ * | Newton | EnableShiftCriterion | bool | - | For Newton iterations to stop the maximum relative shift abs(uLastIter - uNew)/scalarmax(1.0, abs(uLastIter + uNew)*0.5) is demanded to be below a threshold value. At least two iterations. |
+ * | Newton | LineSearchMinRelaxationFactor | Scalar | 0.125 | A minimum relaxation factor for the line serach process. |
+ * | Newton | MaxAbsoluteResidual | Scalar | - | The maximum acceptable absolute residual for declaring convergence |
+ * | Newton | MaxRelativeShift | Scalar | - | Set the maximum acceptable difference of any primary variable between two iterations for declaring convergence |
+ * | Newton | MaxSteps | int | - | The number of iterations after we give up |
+ * | Newton | MaxTimeStepDivisions | std::size_t | 10 | The maximum number of time-step divisions |
+ * | Newton | MinSteps | int | - | The minimum number of iterations |
+ * | Newton | PlausibilityCheck | bool | false | If this is set true, an error is thrown is a saturation is not between zero and one. |
+ * | Newton | ReassemblyMaxThreshold | Scalar | 1e2*shiftTolerance_ | 'maxEps' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'maxEps' leads to less/more reassembly if 'omega*shift' is large, i.e., for the first Newton iterations. |
+ * | Newton | ReassemblyMinThreshold | Scalar | 1e-1*shiftTolerance_ | 'minEps' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'minEps' leads to less/more reassembly if 'omega*shift' is small, i.e., for the last Newton iterations. |
+ * | Newton | ReassemblyShiftWeight | Scalar | 1e-3 | 'omega' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'maxEps' leads to less/more reassembly if 'omega*shift' is large, i.e., for the first Newton iterations. |
+ * | Newton | ResidualReduction | Scalar | - | The maximum acceptable residual norm reduction |
+ * | Newton | RetryTimeStepReductionFactor | Scalar | 0.5 | Factor for reducing the current time-step |
+ * | Newton | SatisfyResidualAndShiftCriterion | bool | - | declare convergence only if both criteria are met |
+ * | Newton | SaturationChangeIsRelative | Scalar | false | See explanatio of AllowedSaturationChange. |
+ * | Newton | TargetSteps | int | - | The number of iterations which are considered "optimal" |
+ * | Newton | UseLineSearch | bool | - | Whether to use line search |
+ * | Newton | Verbosity | int | 2 | The verbosity level of the Newton solver |
+ * | \b PointSource | EnableBoxLumping | bool | true | For a DOF-index to point source map distribute source using a check if point sources are inside a subcontrolvolume instead of using basis function weights. |
+ * | \b PrimaryVariableSwitch | Verbosity | int | 1 | Verbosity level of the primary variable switch. |
+ * | \b Problem | EnableGravity | bool | - | Whether to enable the gravity term |
+ * | Problem | EnableInertiaTerms | bool | - | Whether to enable the inertia terms |
+ * | Problem | Name | std::string | - | Set a name for a problem |
+ * | Problem | SandGrainRoughness | Scalar | - | The sand grain roughness |
+ * | Problem | UsePrimaryVariableSwitch | bool | - | Whether to perform variable switch at a degree of freedom location |
+ * | \b RANS | EddyViscosityModel | std::string | vanDriest | Choose the eddy viscosity model |
+ * | RANS | FlowDirectionAxis | int | 0 | The flow direction axis |
+ * | RANS | IsFlatWallBounded | bool | false | Set to true, if geometry consists of flat walls |
+ * | RANS | TurbulentPrandtlNumber | Scalar | 1.0 | The turbulent Prandtl number |
+ * | RANS | TurbulentSchmidtNumber | Scalar | 1.0 | The turbulent Schmidt number |
+ * | RANS | UseStoredEddyViscosity | bool | true for lowrekepsilon, false else | Whether to use the stored eddy viscosity |
+ * | RANS | WallNormalAxis | int | 1 | The normal wall axis of a flat wall bounded flow |
+ * | RANS | WriteFlatWallBoundedFields | bool | isFlatWallBounded | Whether to write output fields for flat wall geometries |
+ * | \b ShallowWater | EnableViscousFlux | bool | false | Whether to include a viscous flux contribution. |
+ * | ShallowWater | HorizontalCoefficientOfMixingLengthModel | Scalar | 0.1 | For the turbulence model base on the mixing length: The Smagorinsky-like horizontal turbulence coefficient. |
+ * | ShallowWater | TurbulentViscosity | Scalar | 1.0e-6 | The (constant) background turbulent viscosity. |
+ * | ShallowWater | UseMixingLengthTurbulenceModel | bool | false | Whether the mixing-length turbulence model is used. |
+ * | ShallowWater | VerticalCoefficientOfMixingLengthModel | Scalar | 1.0 | For the turbulence model base on the mixing length: The Elder-like vertical turbulence coefficient. |
+ * | \b SimpleH2O | ReferenceTemperature | Scalar | 293.15 | The reference temperature in \f$\mathrm{[K]}\f$ for calculating the (liquid or gas) enthalpy of simple H2O. |
+ * | \b SpatialParams | ComputeAwsFromAnsAndPcMax | bool | true | Compute volume-specific interfacial area between the wetting and solid phase from interfacial area between nonwetting and solid phase and maximum capillary pressure. |
+ * | SpatialParams | ContactAngle | Scalar | 0.0 | This contact angle \f$[rad]\f$ is set both as the contact angle within a pore throat and the one within a pore body. It can be overloaded for solution-dependent values. |
+ * | SpatialParams | ForchCoeff | Scalar | 0.55 | The Forchheimer coefficient |
+ * | SpatialParams | Permeability | Scalar | - | The permeability |
+ * | SpatialParams | Porosity | Scalar | - | The porosity |
+ * | SpatialParams | SurfaceTension | Scalar | 0.0725 | The value of the surface tension \f$[N/m]\f$. It defaults to the surface tension of water/air. |
+ * | SpatialParams | Tortuosity | Scalar | 0.5 | The tortuosity |
+ * | \b TimeLoop | Restart | double | 0.0 | The restart time stamp for a previously interrupted simulation |
+ * | \b Transmissibility | ConsiderPoreResistance | bool | true | Whether or not the pore resistance should be considered on runtime. |
+ * | \b Vtk | AddProcessRank | bool | - | Whether to add a process rank |
+ * | Vtk | AddVelocity | bool | true | Whether to enable velocity output |
+ * | Vtk | CoordPrecision | std::string | value set to Vtk.Precision before | The output precision of coordinates. |
+ * | Vtk | Precision | std::string | Float32 | Precision of the vtk output |
+ * | Vtk | WriteFaceData | bool | false | For the staggered grid approach, write face-related data into vtp files. |
*/
diff --git a/doc/doxygen/extradoc/parameters.json b/doc/doxygen/extradoc/parameters.json
new file mode 100644
index 0000000000..8fe6e57d95
--- /dev/null
+++ b/doc/doxygen/extradoc/parameters.json
@@ -0,0 +1,4412 @@
+{
+ "-.A00": {
+ "default": [
+ "0.0",
+ "true"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A00",
+ "type": [
+ "Scalar",
+ "Bool"
+ ]
+ },
+ "-.A01": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A01",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A02": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A02",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A1": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A1",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A10": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A10",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A11": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A11",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A2",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A20": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A20",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.A3": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A coefficient for capillary-pressure-saturation-interfacial-area relations described by a polynomial of second order."
+ ],
+ "group": "-",
+ "parameter": "A3",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.BrooksCoreyLambda": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Parameter lambda in Brooks Corey."
+ ],
+ "group": "-",
+ "parameter": "BrooksCoreyLambda",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.BrooksCoreyPcEntry": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Entry capillary pressure in Brooks Corey."
+ ],
+ "group": "-",
+ "parameter": "BrooksCoreyPcEntry",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.BrooksCoreyPcLowSweThreshold": {
+ "default": [
+ "0.01"
+ ],
+ "explanation": [
+ "For effective wetting phase saturations below this value, capillary pressure is given by a regularized capillary pressure-saturation curve."
+ ],
+ "group": "-",
+ "parameter": "BrooksCoreyPcLowSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.HeatpipeLawGamma": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Parameter gamma in heat pipe law."
+ ],
+ "group": "-",
+ "parameter": "HeatpipeLawGamma",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.HeatpipeLawP0": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Parameter p0 in heat pipe law."
+ ],
+ "group": "-",
+ "parameter": "HeatpipeLawP0",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.HighSwRegularizationMethod": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A regularization method for the capillary pressure at high wetting saturations. Possible values are \"Linear\", \"Spline\" and \"PowerLaw\"."
+ ],
+ "group": "-",
+ "parameter": "HighSwRegularizationMethod",
+ "type": [
+ "std::string"
+ ]
+ },
+ "-.HighSwSplineZeroSlope": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to use a zero slope of the capillary pressure at high wetting saturations."
+ ],
+ "group": "-",
+ "parameter": "HighSwSplineZeroSlope",
+ "type": [
+ "bool"
+ ]
+ },
+ "-.KrnData": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Relative permeability for the non-wetting phase data for spline material law."
+ ],
+ "group": "-",
+ "parameter": "KrnData",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "-.KrwData": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Relative permeability for the wetting phase data for spline material law."
+ ],
+ "group": "-",
+ "parameter": "KrwData",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "-.LinearPcEntry": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Entry capillary pressure for the linear capillary pressure and relative permeability <-> saturation relations."
+ ],
+ "group": "-",
+ "parameter": "LinearPcEntry",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.LinearPcMax": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Maximum capillary pressure for the linear capillary pressure and relative permeability <-> saturation relations."
+ ],
+ "group": "-",
+ "parameter": "LinearPcMax",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParameterFile": {
+ "default": [
+ "executablename.input"
+ ],
+ "explanation": [
+ "Command line argument: overwrite parameter file if one was specified on the command line"
+ ],
+ "group": "-",
+ "parameter": "ParameterFile",
+ "type": [
+ "std::string"
+ ]
+ },
+ "-.ParkerVanGenuchtenAlpha": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Shape parameter \\f$\\mathrm{\\alpha}\\f$ \\f$\\mathrm{[1/Pa]}\\f$ in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenAlpha",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenBetaGn": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Scaling parameter \\f$\\mathrm{betaGn}\\f$ \\f$\\mathrm{[-]}\\f$ in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenBetaGn",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenBetaGw": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Scaling parameter \\f$\\mathrm{betaGw}\\f$ \\f$\\mathrm{[-]}\\f$ in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenBetaGw",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenBetaNw": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Scaling parameter \\f$\\mathrm{betaNw}\\f$ \\f$\\mathrm{[-]}\\f$ in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenBetaNw",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenKrgLowSteThreshold": {
+ "default": [
+ "1e-3"
+ ],
+ "explanation": [
+ "The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenKrgLowSteThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenKrnLowSweThreshold": {
+ "default": [
+ "0.1"
+ ],
+ "explanation": [
+ "The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenKrnLowSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenKrwHighSweThreshold": {
+ "default": [
+ "0.9"
+ ],
+ "explanation": [
+ "The threshold saturation above which the relative permeability of the wetting phase gets regularized in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenKrwHighSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenN": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Shape parameter \\f$\\mathrm{n}\\f$ \\f$\\mathrm{[-]}\\f$ in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenN",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenPcHighSweThreshold": {
+ "default": [
+ "0.99"
+ ],
+ "explanation": [
+ "Threshold saturation above which the capillary pressure is regularized in Parker/vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenPcHighSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenPcLowSweThreshold": {
+ "default": [
+ "0.01"
+ ],
+ "explanation": [
+ "Threshold saturation below which the capillary pressure is regularized in Parker/vanGenuchten laws. Most problems are very sensitive to this value (e.g. making it smaller might result in very high capillary pressures)."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenPcLowSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ParkerVanGenuchtenRegardSnrForKrn": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "In Parker/vanGenuchten laws regard the relative non-wetting saturation in the permeability of the non-wetting phase, see Helmig1997."
+ ],
+ "group": "-",
+ "parameter": "ParkerVanGenuchtenRegardSnrForKrn",
+ "type": [
+ "bool"
+ ]
+ },
+ "-.PcData": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Capillary pressure data for spline material law."
+ ],
+ "group": "-",
+ "parameter": "PcData",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "-.PcMax": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Maximum capillary pressure for calculating the interfacial area between the nonwetting and wetting phase as in Nuske 2014 (https://elib.uni-stuttgart.de/handle/11682/614, page 60) \\cite nuske2014."
+ ],
+ "group": "-",
+ "parameter": "PcMax",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.RegularizationHighSw": {
+ "default": [
+ "std::numeric_limits<Scalar>::quiet_NaN()"
+ ],
+ "explanation": [
+ "The capillary pressure at high wetting saturations."
+ ],
+ "group": "-",
+ "parameter": "RegularizationHighSw",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.RegularizationHighSwFixedSlope": {
+ "default": [
+ "std::numeric_limits<Scalar>::quiet_NaN()"
+ ],
+ "explanation": [
+ "A fixed slope of the capillary pressure at high wetting saturations."
+ ],
+ "group": "-",
+ "parameter": "RegularizationHighSwFixedSlope",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.RegularizationLowSw": {
+ "default": [
+ "params.pcLowSw()"
+ ],
+ "explanation": [
+ "The capillary pressure at low wetting saturations."
+ ],
+ "group": "-",
+ "parameter": "RegularizationLowSw",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.Restart": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The restart time stamp for a previously interrupted simulation"
+ ],
+ "group": "-",
+ "parameter": "Restart",
+ "type": [
+ "double"
+ ]
+ },
+ "-.Sgr": {
+ "default": [
+ "0.0"
+ ],
+ "explanation": [
+ "Residual gas phase saturation."
+ ],
+ "group": "-",
+ "parameter": "Sgr",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.SmoothedLinearLawKrHighS": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "If the saturation is higher than this value, smoothed linear material law changes to a spline for the relative permeability."
+ ],
+ "group": "-",
+ "parameter": "SmoothedLinearLawKrHighS",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.SmoothedLinearLawKrLowS": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "If the saturation is lower than this value, smoothed linear material law changes to a spline for the relative permeability."
+ ],
+ "group": "-",
+ "parameter": "SmoothedLinearLawKrLowS",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.SmoothedLinearLawPcMax": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The maximum capillary pressure used in the smoothed linear law."
+ ],
+ "group": "-",
+ "parameter": "SmoothedLinearLawPcMax",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.SmoothedLinearLawPe": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The entry pressure used in the smoothed linear law."
+ ],
+ "group": "-",
+ "parameter": "SmoothedLinearLawPe",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.Snr": {
+ "default": [
+ "0.0"
+ ],
+ "explanation": [
+ "Residual non-wetting phase saturation."
+ ],
+ "group": "-",
+ "parameter": "Snr",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.SplineNumSwSamples": {
+ "default": [
+ "30"
+ ],
+ "explanation": [
+ "Number of sample points from which the wetting saturation spline is built."
+ ],
+ "group": "-",
+ "parameter": "SplineNumSwSamples",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.SplineSweInterval": {
+ "default": [
+ "std::array<Scalar, 2> default{{ 0.01, 1.0 }}"
+ ],
+ "explanation": [
+ "Effective wetting saturation interval for spline material law."
+ ],
+ "group": "-",
+ "parameter": "SplineSweInterval",
+ "type": [
+ "std::array<Scalar, 2>"
+ ]
+ },
+ "-.SwData": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Wetting saturation pressure data for spline material law."
+ ],
+ "group": "-",
+ "parameter": "SwData",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "-.Swr": {
+ "default": [
+ "0.0"
+ ],
+ "explanation": [
+ "Residual wetting phase saturation."
+ ],
+ "group": "-",
+ "parameter": "Swr",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ThreePNAPLAdsorptionKdNAPL": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "kd parameter for the adsportion of NAPL in a 3 phase simulation."
+ ],
+ "group": "-",
+ "parameter": "ThreePNAPLAdsorptionKdNAPL",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.ThreePNAPLAdsorptionRhoBulk": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "bulk density for calculating the adsorption of NAPL in a 3 phase simulation."
+ ],
+ "group": "-",
+ "parameter": "ThreePNAPLAdsorptionRhoBulk",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenAlpha": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Shape parameter \\f$\\mathrm{\\alpha}\\f$ \\f$\\mathrm{[1/Pa]}\\f$ in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenAlpha",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenConstantRegularization": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "If specified, a constant value is used for regularization in Parker/vanGenuchten."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenConstantRegularization",
+ "type": [
+ "bool"
+ ]
+ },
+ "-.VanGenuchtenKrnLowSweThreshold": {
+ "default": [
+ "0.1"
+ ],
+ "explanation": [
+ "The threshold saturation below which the relative permeability of the nonwetting phase gets regularized in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenKrnLowSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenKrwHighSweThreshold": {
+ "default": [
+ "0.9"
+ ],
+ "explanation": [
+ "The threshold saturation above which the relative permeability of the wetting phase gets regularized in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenKrwHighSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenL": {
+ "default": [
+ "0.5"
+ ],
+ "explanation": [
+ "Shape parameter \\f$\\mathrm{m}\\f$ \\f$\\mathrm{[-]}\\f$ in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenL",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenN": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Shape parameter \\f$\\mathrm{n}\\f$ \\f$\\mathrm{[-]}\\f$ in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenN",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenPcHighSweThreshold": {
+ "default": [
+ "0.99"
+ ],
+ "explanation": [
+ "Threshold saturation above which the capillary pressure is regularized in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenPcHighSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "-.VanGenuchtenPcLowSweThreshold": {
+ "default": [
+ "0.01"
+ ],
+ "explanation": [
+ "Threshold saturation below which the capillary pressure is regularized in vanGenuchten laws."
+ ],
+ "group": "-",
+ "parameter": "VanGenuchtenPcLowSweThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Adaptive.BCRefinementThreshold": {
+ "default": [
+ "1e-10"
+ ],
+ "explanation": [
+ "The threshold above which fluxes are treated as non-zero"
+ ],
+ "group": "Adaptive",
+ "parameter": "BCRefinementThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Adaptive.MaxLevel": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The maximum refinement level"
+ ],
+ "group": "Adaptive",
+ "parameter": "MaxLevel",
+ "type": [
+ "int"
+ ]
+ },
+ "Adaptive.MinLevel": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The minimum refinement level"
+ ],
+ "group": "Adaptive",
+ "parameter": "MinLevel",
+ "type": [
+ "int"
+ ]
+ },
+ "Adaptive.RefineAtDirichletBC": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to refine at Dirichlet boundaries"
+ ],
+ "group": "Adaptive",
+ "parameter": "RefineAtDirichletBC",
+ "type": [
+ "bool"
+ ]
+ },
+ "Adaptive.RefineAtFluxBC": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to refine at Neumann/Robin boundaries"
+ ],
+ "group": "Adaptive",
+ "parameter": "RefineAtFluxBC",
+ "type": [
+ "bool"
+ ]
+ },
+ "Adaptive.RefineAtSource": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to refine where source terms are specified"
+ ],
+ "group": "Adaptive",
+ "parameter": "RefineAtSource",
+ "type": [
+ "bool"
+ ]
+ },
+ "Assembly.NumericDifference.BaseEpsilon": {
+ "default": [
+ "1e-10"
+ ],
+ "explanation": [
+ "The basic numeric epsilon used in the differentiation for deflecting primary variables"
+ ],
+ "group": "Assembly",
+ "parameter": "NumericDifference.BaseEpsilon",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Assembly.NumericDifference.PriVarMagnitude": {
+ "default": [
+ "NumEqVector(-1)"
+ ],
+ "explanation": [
+ "The magnitude of the primary variables used for finding a good numeric epsilon for deflecting primary variables."
+ ],
+ "group": "Assembly",
+ "parameter": "NumericDifference.PriVarMagnitude",
+ "type": [
+ "NumEqVector"
+ ]
+ },
+ "Assembly.NumericDifferenceMethod": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The numeric difference method (1: foward differences (default), 0: central differences, -1: backward differences)"
+ ],
+ "group": "Assembly",
+ "parameter": "NumericDifferenceMethod",
+ "type": [
+ "int"
+ ]
+ },
+ "BinaryCoefficients.GasDiffCoeff": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The binary diffusion coefficient in gas"
+ ],
+ "group": "BinaryCoefficients",
+ "parameter": "GasDiffCoeff",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "BinaryCoefficients.LiquidDiffCoeff": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The binary diffusion coefficient in liquid"
+ ],
+ "group": "BinaryCoefficients",
+ "parameter": "LiquidDiffCoeff",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Brine.Salinity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The salinity"
+ ],
+ "group": "Brine",
+ "parameter": "Salinity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.GasDensity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The density of the gas"
+ ],
+ "group": "Component",
+ "parameter": "GasDensity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.GasDiffusionCoefficient": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Binary diffusion coefficient for molecular water and the constant component"
+ ],
+ "group": "Component",
+ "parameter": "GasDiffusionCoefficient",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.GasKinematicViscosity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The gas kinematic viscosity"
+ ],
+ "group": "Component",
+ "parameter": "GasKinematicViscosity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.HenryComponentInWater": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Henry coefficient for the constant component in liquid water"
+ ],
+ "group": "Component",
+ "parameter": "HenryComponentInWater",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.HenryWaterInComponent": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Henry coefficient for water in the constant component"
+ ],
+ "group": "Component",
+ "parameter": "HenryWaterInComponent",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.LiquidDensity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The density of the liquid"
+ ],
+ "group": "Component",
+ "parameter": "LiquidDensity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.LiquidDiffusionCoefficient": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "Diffusion coefficient for the constant component in liquid water"
+ ],
+ "group": "Component",
+ "parameter": "LiquidDiffusionCoefficient",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.LiquidHeatCapacity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Specific isobaric heat capacity of the component \\f$\\mathrm{[J/(kg*K)]}\\f$ as a liquid."
+ ],
+ "group": "Component",
+ "parameter": "LiquidHeatCapacity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.LiquidKinematicViscosity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The liquid kinematic viscosity"
+ ],
+ "group": "Component",
+ "parameter": "LiquidKinematicViscosity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.LiquidThermalConductivity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Thermal conductivity of the component \\f$\\mathrm{[W/(m*K)]}\\f$ as a liquid."
+ ],
+ "group": "Component",
+ "parameter": "LiquidThermalConductivity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.MolarMass": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The mass in one mole of the component"
+ ],
+ "group": "Component",
+ "parameter": "MolarMass",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.Name": {
+ "default": [
+ "component"
+ ],
+ "explanation": [
+ "A human readable name for the component"
+ ],
+ "group": "Component",
+ "parameter": "Name",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Component.ReferenceTemperature": {
+ "default": [
+ "293.15"
+ ],
+ "explanation": [
+ "The reference termperature in \\f$\\mathrm{[K]}\\f$ used when calculating the specific internal energy of a constant component as a liquid."
+ ],
+ "group": "Component",
+ "parameter": "ReferenceTemperature",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.SolidDensity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The density of the component in solid state"
+ ],
+ "group": "Component",
+ "parameter": "SolidDensity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.SolidHeatCapacity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Specific isobaric heat capacity of the component as a solid"
+ ],
+ "group": "Component",
+ "parameter": "SolidHeatCapacity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Component.SolidThermalConductivity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Thermal conductivity of the component as a solid"
+ ],
+ "group": "Component",
+ "parameter": "SolidThermalConductivity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.ActivationBarrier": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The activation barrier to calculate the exchange current density."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "ActivationBarrier",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.CellVoltage": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The voltage of the fuel cell."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "CellVoltage",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.MaxIterations": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The maximum number of iterations in iteatively (Newton solver) calculating the current density."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "MaxIterations",
+ "type": [
+ "int"
+ ]
+ },
+ "ElectroChemistry.NumElectrons": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of electrons for the calculation of activation and concentration losses."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "NumElectrons",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.RefCurrentDensity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The reference current density to calculate the exchange current density."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "RefCurrentDensity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.RefO2PartialPressure": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The reference oxygen partial pressure."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "RefO2PartialPressure",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.RefTemperature": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The reference temperature to calculate the exchange current density."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "RefTemperature",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.ReversibleVoltage": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The reversible voltage."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "ReversibleVoltage",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.SpecificResistance": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The specific resistance, see \\cite A3:acosta:2006."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "SpecificResistance",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.SurfaceIncreasingFactor": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The surface-increasing factor to calculate the exchange current density."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "SurfaceIncreasingFactor",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.ThermoneutralVoltage": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Thermoneutral voltage for the non-isothermal electrochemistry model."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "ThermoneutralVoltage",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.TransferCoefficient": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The transport coefficient."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "TransferCoefficient",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.TransportNumberH20": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The water transport number to calculate the osmotic term in the membrane."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "TransportNumberH20",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ElectroChemistry.pO2Inlet": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The oxygen pressure at the inlet."
+ ],
+ "group": "ElectroChemistry",
+ "parameter": "pO2Inlet",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "FacetCoupling.Xi": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "The xi factor for coupling conditions"
+ ],
+ "group": "FacetCoupling",
+ "parameter": "Xi",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Flux.DifferencingScheme": {
+ "default": [
+ "Minmod"
+ ],
+ "explanation": [
+ "Choice of a staggered TVD method"
+ ],
+ "group": "Flux",
+ "parameter": "DifferencingScheme",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Flux.TvdApproach": {
+ "default": [
+ "Uniform"
+ ],
+ "explanation": [
+ "If you use a staggered grid with a TVD approach: For a uniform grid \"Uniform\" is fine. For a nonuniform grid decide between \"Li\" and \"Hou\" (two literature-based methods)."
+ ],
+ "group": "Flux",
+ "parameter": "TvdApproach",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Flux.UpwindWeight": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Upwind weight in staggered upwind method"
+ ],
+ "group": "Flux",
+ "parameter": "UpwindWeight",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "FluxLimiterLET.LowerWaterDepth": {
+ "default": [
+ "1e-5"
+ ],
+ "explanation": [
+ "The lower water depth"
+ ],
+ "group": "FluxLimiterLET",
+ "parameter": "LowerWaterDepth",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "FluxLimiterLET.UpperWaterDepth": {
+ "default": [
+ "1e-3"
+ ],
+ "explanation": [
+ "The upper water depth"
+ ],
+ "group": "FluxLimiterLET",
+ "parameter": "UpperWaterDepth",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "FluxLimiterLET.UpwindFluxLimiting": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "If this is set true, the upwind water depth from the flux direction is used. This can improve stability."
+ ],
+ "group": "FluxLimiterLET",
+ "parameter": "UpwindFluxLimiting",
+ "type": [
+ "bool"
+ ]
+ },
+ "FluxOverSurface.Verbose": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "For enabling or disabling the console output"
+ ],
+ "group": "FluxOverSurface",
+ "parameter": "Verbose",
+ "type": [
+ "bool"
+ ]
+ },
+ "Forchheimer.MaxIterations": {
+ "default": [
+ "30"
+ ],
+ "explanation": [
+ "The maximum number of Newton iterations for solving the Forchheimer equation"
+ ],
+ "group": "Forchheimer",
+ "parameter": "MaxIterations",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "Forchheimer.NewtonTolerance": {
+ "default": [
+ "1e-12"
+ ],
+ "explanation": [
+ "The error tolerance in the Newton method for solving the Forchheimer equation"
+ ],
+ "group": "Forchheimer",
+ "parameter": "NewtonTolerance",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "FreeFlow.EnableUnsymmetrizedVelocityGradient": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "For enabling unsymmetrized velocity gradient. If false consider the shear stress caused by the gradient of the velocities normal to our face of interest."
+ ],
+ "group": "FreeFlow",
+ "parameter": "EnableUnsymmetrizedVelocityGradient",
+ "type": [
+ "bool"
+ ]
+ },
+ "FreeFlow.EnableUnsymmetrizedVelocityGradientForBeaversJoseph": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "For enabling unsymmetrized velocity gradient for the Beavers Joseph coupling condition. If true and if the current scvf is on a boundary and if a Dirichlet BC for the pressure or a BJ condition for the slip velocity is set there, assume a tangential velocity gradient of zero along the lateral face."
+ ],
+ "group": "FreeFlow",
+ "parameter": "EnableUnsymmetrizedVelocityGradientForBeaversJoseph",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.FixedPoreRadiusForLabel": {
+ "default": [
+ "std::vector<Scalar>{}"
+ ],
+ "explanation": [
+ "Vector of pore radii to be set to the corresponding pores not belonging to a subregion indicated by PoreLabelsToSetFixedRadius."
+ ],
+ "group": "Grid",
+ "parameter": "FixedPoreRadiusForLabel",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.MaxPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a uniform random distribution, this specifies the maximum pore radius."
+ ],
+ "group": "Grid",
+ "parameter": "MaxPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.MeanPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a lognormal random distribution, this specifies the mean pore radius."
+ ],
+ "group": "Grid",
+ "parameter": "MeanPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.MinPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a uniform random distribution, this specifies the minimum pore radius."
+ ],
+ "group": "Grid",
+ "parameter": "MinPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.ParameterRandomNumberSeed": {
+ "default": [
+ "std::random_device{}()"
+ ],
+ "explanation": [
+ "If PoreInscribedRadius is not set, this allows to specify a seed to get reproducible results."
+ ],
+ "group": "Grid",
+ "parameter": "ParameterRandomNumberSeed",
+ "type": [
+ "unsigned int"
+ ]
+ },
+ "Grid.ParameterType": {
+ "default": [
+ "\"lognormal\""
+ ],
+ "explanation": [
+ "If PoreInscribedRadius is not set, this allows to specify the type of random distribution for the radii. Possible values are \"lognormal\" and \"uniform\"."
+ ],
+ "group": "Grid",
+ "parameter": "ParameterType",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.PoreInscribedRadius": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "If this is set, all pore radii of pore bodies not belonging to a subregion are set to this value. If this is not set, a random radius is set according to a user-specified distribution."
+ ],
+ "group": "Grid",
+ "parameter": "PoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.PoreLabelsToApplyFactorForRadius": {
+ "default": [
+ "std::vector<int>{}"
+ ],
+ "explanation": [
+ "Lables of pores of pores bodies not belonging to a subregion which should be treated by applying a factor for the radius."
+ ],
+ "group": "Grid",
+ "parameter": "PoreLabelsToApplyFactorForRadius",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.PoreLabelsToSetFixedRadius": {
+ "default": [
+ "std::vector<int>{}"
+ ],
+ "explanation": [
+ "Lables of pores of pores bodies not belonging to a subregion which should be treated by setting a fixed radius."
+ ],
+ "group": "Grid",
+ "parameter": "PoreLabelsToSetFixedRadius",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.PoreRadiusFactorForLabel": {
+ "default": [
+ "std::vector<Scalar>{}"
+ ],
+ "explanation": [
+ "Vector of factors for the radii of the corresponding pores not belonging to a subregion indicated by PoreLabelsToApplyFactorForRadius."
+ ],
+ "group": "Grid",
+ "parameter": "PoreRadiusFactorForLabel",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.StandardDeviationPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a lognormal random distribution, this specifies the standard deviation of the pore radius."
+ ],
+ "group": "Grid",
+ "parameter": "StandardDeviationPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.SubstractRadiiFromThroatLength": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Decide whether to substract the pore radii from the throat length or not for a pore throat not belonging to a subregion."
+ ],
+ "group": "Grid",
+ "parameter": "SubstractRadiiFromThroatLength",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.ThroatInscribedRadius": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Radius of a pore throat not belonging to a subregion."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.ThroatInscribedRadiusN": {
+ "default": [
+ "0.1"
+ ],
+ "explanation": [
+ "Shape parameter for the calculation of the radius of a pore throat not belonging to a subregion when ThroatInscribedRadius is not set."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatInscribedRadiusN",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.ThroatLength": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Length of a pore throat not belonging to a subregion."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatLength",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.AddThroatVolumeToPoreVolume": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to add the throat volume to the pore volume."
+ ],
+ "group": "Grid",
+ "parameter": "AddThroatVolumeToPoreVolume",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.AllowIntersectingDiagonals": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Wether to allow diagonals to intersect in the context of the generation of a structured-lattice pore-network."
+ ],
+ "group": "Grid",
+ "parameter": "AllowIntersectingDiagonals",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.Angular0/1/2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "min/max value for angular coordinate. Cake grids can be created by either specifying Radial,Angular or Axial in all coordinate directions."
+ ],
+ "group": "Grid",
+ "parameter": "Angular0/1/2",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Axial0/1/2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "min/max value for axial coordinate. Cake grids can be created by either specifying Radial,Angular or Axial in all coordinate directions."
+ ],
+ "group": "Grid",
+ "parameter": "Axial0/1/2",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.BoundaryFaceMarker": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "With this, the boundary faces can be set in the format xmin xmax ymin ymax (zmin zmax)."
+ ],
+ "group": "Grid",
+ "parameter": "BoundaryFaceMarker",
+ "type": [
+ "BoundaryList"
+ ]
+ },
+ "Grid.BoundarySegments": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "For the dune gmsh reader: Whether to insert boundary segments into the grid"
+ ],
+ "group": "Grid",
+ "parameter": "BoundarySegments",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.CapPoreRadii": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "If true a maximal pore radius is set."
+ ],
+ "group": "Grid",
+ "parameter": "CapPoreRadii",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.CapPoresOnBoundaries": {
+ "default": [
+ "std::vector<int>{}"
+ ],
+ "explanation": [
+ "A vector of boundary indices of for which the pore volume should be halved in a direction within automatically determining the pore volume"
+ ],
+ "group": "Grid",
+ "parameter": "CapPoresOnBoundaries",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.CellType": {
+ "default": [
+ "Cube"
+ ],
+ "explanation": [
+ "\"Cube\" or \"Simplex\" to be used for structured grids"
+ ],
+ "group": "Grid",
+ "parameter": "CellType",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.Cells": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of elements in a structured uniform grid in x, y and z direction"
+ ],
+ "group": "Grid",
+ "parameter": "Cells",
+ "type": [
+ "std::array<int, dim>"
+ ]
+ },
+ "Grid.Cells0": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, number of cells of the leftmost zone, number of cells of the second-leftmost zone, ..., number of cells of the rightmost zone, spaceseparated. (assuming x-axis points to the right)"
+ ],
+ "group": "Grid",
+ "parameter": "Cells0",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.Cells1": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Spaceseparated list of the number of cells per zone in y-direction (see more details for x-direction in Cells1)."
+ ],
+ "group": "Grid",
+ "parameter": "Cells1",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.Cells2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Spaceseparated list of the number of cells per zone in z-direction (see more details for x-direction in Cells1)."
+ ],
+ "group": "Grid",
+ "parameter": "Cells2",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.ClosureType": {
+ "default": [
+ "Green"
+ ],
+ "explanation": [
+ "Decide whether to add a green closure to locally refined grid sections or not: \"Green\" (Standard red/green refinement) or \"None\" (No closure, results in nonconforming meshes)"
+ ],
+ "group": "Grid",
+ "parameter": "ClosureType",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.Coordinates": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "To construct a 1D grid with just a coordinates vector"
+ ],
+ "group": "Grid",
+ "parameter": "Coordinates",
+ "type": [
+ "std::vector<ctype>"
+ ]
+ },
+ "Grid.DeletionProbability": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a non-regular lattice, you must specifiy deletion probabilities for deleting throats in all directions. For example (3D): DeletionProbability = 0.5 0.5 0 0 0 0 0 0 0 0 0 0 0 deletes approximately 50% of all throats in x and y direction, while no deletion in any other direction takes place. In 2D four values are required (x (1,0),y (0,1) and two diagnals through cell midpoint (1,1),(1,-1)). In 3D thirteen values are required (x(1,0,0),y(0,1,0),z(0,0,1), six face diagonals (1,1,0),(1,-1,0),(1,0,1),(1,0,-1),(0,1,1),(0,1,-1) and four diagonals through cell midpoint (1,1,1),(1,1,-1),(-1,1,1),(-1,-1,1)."
+ ],
+ "group": "Grid",
+ "parameter": "DeletionProbability",
+ "type": [
+ "std::array<double, numDirections>"
+ ]
+ },
+ "Grid.DeletionRandomNumberSeed": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A seed for the random number generation for the random deletion of connecting throats."
+ ],
+ "group": "Grid",
+ "parameter": "DeletionRandomNumberSeed",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "Grid.DomainMarkers": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether the grid managers work with domain markers."
+ ],
+ "group": "Grid",
+ "parameter": "DomainMarkers",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.File": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A DGF or gmsh file to load from"
+ ],
+ "group": "Grid",
+ "parameter": "File",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.GmshPhysicalEntityThreshold": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ ""
+ ],
+ "group": "Grid",
+ "parameter": "GmshPhysicalEntityThreshold",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "Grid.Grading0": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, grading factors for the x-zones. 1.0 means all cells within this zone have equal extension in x-direction. Negative factors are possible."
+ ],
+ "group": "Grid",
+ "parameter": "Grading0",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Grading1": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, grading factors for the y-zones."
+ ],
+ "group": "Grid",
+ "parameter": "Grading1",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Grading2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, grading factors for the z-zones."
+ ],
+ "group": "Grid",
+ "parameter": "Grading2",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Image": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The image file if the sub grid is constructed from a raster image"
+ ],
+ "group": "Grid",
+ "parameter": "Image",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.KeepPhysicalOverlap": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to keep the physical overlap in physical size or in number of cells upon refinement"
+ ],
+ "group": "Grid",
+ "parameter": "KeepPhysicalOverlap",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.LeftBoundary": {
+ "default": [
+ "0.0"
+ ],
+ "explanation": [
+ "The start coordinate of a 1D grid"
+ ],
+ "group": "Grid",
+ "parameter": "LeftBoundary",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.LowerLeft": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The lowerLeft corner of a structured grid"
+ ],
+ "group": "Grid",
+ "parameter": "LowerLeft",
+ "type": [
+ "GlobalPosition"
+ ]
+ },
+ "Grid.Marker": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "To customize the subgrid generation."
+ ],
+ "group": "Grid",
+ "parameter": "Marker",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.MinThroatLength": {
+ "default": [
+ "1e-6"
+ ],
+ "explanation": [
+ "The minimum pore throat length."
+ ],
+ "group": "Grid",
+ "parameter": "MinThroatLength",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.NumPores": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of pores for a 1D grid. For a more-dimensional grid the number of pores in x,y (and z) direction."
+ ],
+ "group": "Grid",
+ "parameter": "NumPores",
+ "type": [
+ "std::array<unsigned int, dimWorld>"
+ ]
+ },
+ "Grid.NumSubregions": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The number of subregions within a pore-network model."
+ ],
+ "group": "Grid",
+ "parameter": "NumSubregions",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "Grid.Overlap": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The overlap size in cells"
+ ],
+ "group": "Grid",
+ "parameter": "Overlap",
+ "type": [
+ "int"
+ ]
+ },
+ "Grid.OverwriteGridDataWithShapeSpecificValues": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "If Grid.ThroatCrossSectionShape is set, here one can set to overwrite the grid data with the shape-specific values."
+ ],
+ "group": "Grid",
+ "parameter": "OverwriteGridDataWithShapeSpecificValues",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.Partitioning": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A non-standard load-balancing, number of processors per direction"
+ ],
+ "group": "Grid",
+ "parameter": "Partitioning",
+ "type": [
+ "std::array<int, dim>"
+ ]
+ },
+ "Grid.Periodic": {
+ "default": [
+ "std::bitset<dim>()"
+ ],
+ "explanation": [
+ "True or false for each direction"
+ ],
+ "group": "Grid",
+ "parameter": "Periodic",
+ "type": [
+ "std::bitset<dim>"
+ ]
+ },
+ "Grid.PixelDimensions": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For subgrid generation, this can be used to specify the UpperRight position. To calculate UpperRight this is in every dimension multiplied by the number of cells and added to LowerLeft."
+ ],
+ "group": "Grid",
+ "parameter": "PixelDimensions",
+ "type": [
+ "GlobalPosition"
+ ]
+ },
+ "Grid.PoreGeometry": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Pore geometry shape. Possibilities are \"Square\", \"Circle\", \"Cube\", \"Sphere\", \"Cylinder\", \"Tetrahedron\", \"Octahedron\", \"Icosahedron\" or \"Dodecahedron\"."
+ ],
+ "group": "Grid",
+ "parameter": "PoreGeometry",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.PoreHeight": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "A fixed pore height."
+ ],
+ "group": "Grid",
+ "parameter": "PoreHeight",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Positions0": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, x-positions of the left of the leftmost zone followed by the right of all zones (from left to right). (assuming x-axis points to the right)"
+ ],
+ "group": "Grid",
+ "parameter": "Positions0",
+ "type": [
+ "std::vector<ctype>"
+ ],
+ "mode":"manual"
+ },
+ "Grid.Positions1": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, y-positions for zoning in y (more details in Positions0 for x)."
+ ],
+ "group": "Grid",
+ "parameter": "Positions1",
+ "type": [
+ "std::vector<ctype>"
+ ]
+ },
+ "Grid.Positions2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For a grid with zones, z-positions for zoning in z (more details in Positions0 for x)."
+ ],
+ "group": "Grid",
+ "parameter": "Positions2",
+ "type": [
+ "std::vector<ctype>"
+ ]
+ },
+ "Grid.PriorityList": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The priority which decides the order the vertices on the boundary are indexed. By default, vertices on min/max faces in x direction have the highest priority, followed by y and z."
+ ],
+ "group": "Grid",
+ "parameter": "PriorityList",
+ "type": [
+ "BoundaryList"
+ ]
+ },
+ "Grid.PruningSeedIndices": {
+ "default": [
+ "std::vector<int>{1}"
+ ],
+ "explanation": [
+ "Indices from which to start the search process for finding elements not connected to pores at a Dirichlet boundary, which are then removed."
+ ],
+ "group": "Grid",
+ "parameter": "PruningSeedIndices",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.Radial0/1/2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "min/max value for radial coordinate. Cake grids can be created by either specifying Radial,Angular or Axial in all coordinate directions."
+ ],
+ "group": "Grid",
+ "parameter": "Radial0/1/2",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Refinement": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The number of global refines to perform"
+ ],
+ "group": "Grid",
+ "parameter": "Refinement",
+ "type": [
+ "int"
+ ]
+ },
+ "Grid.RefinementType": {
+ "default": [
+ "Local"
+ ],
+ "explanation": [
+ "e.g. UGGrid \"Local\" (New level consists only of the refined elements and the closure) or \"Copy\" (New level consists of the refined elements and the unrefined ones, too)"
+ ],
+ "group": "Grid",
+ "parameter": "RefinementType",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.RegularLattice": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "A regular lattice is when pore are always connected parallel to the main axes and never connected in other directions."
+ ],
+ "group": "Grid",
+ "parameter": "RegularLattice",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.RemoveThroatsOnBoundary": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether the throats on the boundary should be removed."
+ ],
+ "group": "Grid",
+ "parameter": "RemoveThroatsOnBoundary",
+ "type": [
+ "std::vector<std::size_t>"
+ ]
+ },
+ "Grid.RightBoundary": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The end coordinate of a 1D grid"
+ ],
+ "group": "Grid",
+ "parameter": "RightBoundary",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.SanitationMode": {
+ "default": [
+ "\"KeepLargestCluster\""
+ ],
+ "explanation": [
+ "The mode of sanitation. Sanitation is a post-processing to remove insular groups of elements that are not connected to a Dirichlet boundary. Possible modes are \"UsePoreLabels\" (keep cluster connected to a specific pore given by a pore label) and \"KeepLargestCluster\"."
+ ],
+ "group": "Grid",
+ "parameter": "SanitationMode",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.Sanitize": {
+ "default": [
+ "false(makeFromDgf),true(makeFromStructure)"
+ ],
+ "explanation": [
+ "Whether to sanitize the grid. Sanitizing is a post-processing to remove insular groups of elements that are not connected to a Dirichlet boundary."
+ ],
+ "group": "Grid",
+ "parameter": "Sanitize",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.Subregion0,1,....FixedPoreRadiusForLabel": {
+ "default": [
+ "std::vector<Scalar>{}"
+ ],
+ "explanation": [
+ "Vector of pore radii to be set to the corresponding pores within this subregion indicated by PoreLabelsToSetFixedRadius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "FixedPoreRadiusForLabel",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Subregion0,1,....LowerLeft": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Gives the lower left corner position of the subregion grid in the context of a pore-network."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "LowerLeft",
+ "type": [
+ "GlobalPosition"
+ ]
+ },
+ "Grid.Subregion0,1,....MaxPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a uniform random distribution, this specifies the maximum pore radius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "MaxPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....MeanPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a lognormal random distribution, this specifies the mean pore radius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "MeanPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....MinPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a uniform random distribution, this specifies the minimum pore radius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "MinPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....ParameterRandomNumberSeed": {
+ "default": [
+ "std::random_device{}()"
+ ],
+ "explanation": [
+ "If PoreInscribedRadius is not set, this allows to specify a seed to get reproducible results."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "ParameterRandomNumberSeed",
+ "type": [
+ "unsigned int"
+ ]
+ },
+ "Grid.Subregion0,1,....ParameterType": {
+ "default": [
+ "\"lognormal\""
+ ],
+ "explanation": [
+ "If PoreInscribedRadius is not set, this allows to specify the type of random distribution for the radii. Possible values are \"lognormal\" and \"uniform\"."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "ParameterType",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.Subregion0,1,....PoreInscribedRadius": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "If this is set, all pore radii of pore bodies of this subregion are set to this value. If this is not set, a random radius is set according to a user-specified distribution."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "PoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....PoreLabelsToApplyFactorForRadius": {
+ "default": [
+ "std::vector<int>{}"
+ ],
+ "explanation": [
+ "Lables of pores of pores bodies within this subregion which should be treated by applying a factor for the radius, case with subregions."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "PoreLabelsToApplyFactorForRadius",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.Subregion0,1,....PoreLabelsToSetFixedRadius": {
+ "default": [
+ "std::vector<int>{}"
+ ],
+ "explanation": [
+ "Lables of pores of pores bodies within this subregion which should be treated by setting a fixed radius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "PoreLabelsToSetFixedRadius",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "Grid.Subregion0,1,....PoreRadiusFactorForLabel": {
+ "default": [
+ "std::vector<Scalar>{}"
+ ],
+ "explanation": [
+ "Vector of factors for the radii of the corresponding pores within this subregion indicated by PoreLabelsToApplyFactorForRadius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "PoreRadiusFactorForLabel",
+ "type": [
+ "std::vector<Scalar>"
+ ]
+ },
+ "Grid.Subregion0,1,....StandardDeviationPoreInscribedRadius": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "In the case of a lognormal random distribution, this specifies the standard deviation of the pore radius."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "StandardDeviationPoreInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....SubstractRadiiFromThroatLength": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Decide whether to substract the pore radii from the throat length or not for a pore throat belonging to this subregion."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "SubstractRadiiFromThroatLength",
+ "type": [
+ "bool"
+ ]
+ },
+ "Grid.Subregion0,1,....ThroatInscribedRadius": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Radius of a pore throat belonging to this subregion."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "ThroatInscribedRadius",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....ThroatInscribedRadiusN": {
+ "default": [
+ "0.1"
+ ],
+ "explanation": [
+ "Shape parameter for the calculation of the radius of a pore throat belonging to this subregion when ThroatInscribedRadius is not set."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "ThroatInscribedRadiusN",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....ThroatLength": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Length of a pore throat belonging to this subregion."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "ThroatLength",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.Subregion0,1,....UpperRight": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Gives the upper right corner position of the subregion grid in the context of a pore-network."
+ ],
+ "group": "Grid.Subregion0,1,...",
+ "parameter": "UpperRight",
+ "type": [
+ "GlobalPosition"
+ ]
+ },
+ "Grid.ThroatCrossSectionShape": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "A geometry that should be used for all throatcrosssections. The possibilities are \"ScaleneTriangle\", \"EquilateralTriangle\", \"Square\", \"Rectangle\", \"Circle\", \"TwoPlates\", \"Polygon\"."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatCrossSectionShape",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Grid.ThroatHeight": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Throat height for a rectangle-shaped throat cross section."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatHeight",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.ThroatLength": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "A user-specified fixed throat lenght."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatLength",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.ThroatShapeFactor": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Throat shape factor for a polygonal throat cross section or a scalene triangle one."
+ ],
+ "group": "Grid",
+ "parameter": "ThroatShapeFactor",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Grid.UpperRight": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The upperright corner of a structured grid"
+ ],
+ "group": "Grid",
+ "parameter": "UpperRight",
+ "type": [
+ "GlobalPosition"
+ ]
+ },
+ "Grid.Verbosity": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether the grid construction should output to standard out"
+ ],
+ "group": "Grid",
+ "parameter": "Verbosity",
+ "type": [
+ "bool"
+ ]
+ },
+ "GridAdapt.AdaptionInterval": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The time step interval for adaption"
+ ],
+ "group": "GridAdapt",
+ "parameter": "AdaptionInterval",
+ "type": [
+ "int"
+ ]
+ },
+ "GridAdapt.CoarsenTolerance": {
+ "default": [
+ "0.001"
+ ],
+ "explanation": [
+ "Coarsening threshold to decide whether a cell should be marked for coarsening"
+ ],
+ "group": "GridAdapt",
+ "parameter": "CoarsenTolerance",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "GridAdapt.EnableInitializationIndicator": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to use initial grid adaption"
+ ],
+ "group": "GridAdapt",
+ "parameter": "EnableInitializationIndicator",
+ "type": [
+ "bool"
+ ]
+ },
+ "GridAdapt.EnableMultiPointFluxApproximation": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to enable mpfa on hanging nodes"
+ ],
+ "group": "GridAdapt",
+ "parameter": "EnableMultiPointFluxApproximation",
+ "type": [
+ "bool"
+ ]
+ },
+ "GridAdapt.MaxInteractionVolumes": {
+ "default": [
+ "4"
+ ],
+ "explanation": [
+ "The maximum number of interaction volumes considered"
+ ],
+ "group": "GridAdapt",
+ "parameter": "MaxInteractionVolumes",
+ "type": [
+ "int"
+ ]
+ },
+ "GridAdapt.MaxLevel": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The maximum allowed level"
+ ],
+ "group": "GridAdapt",
+ "parameter": "MaxLevel",
+ "type": [
+ "int"
+ ]
+ },
+ "GridAdapt.MinLevel": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The minimum allowed level"
+ ],
+ "group": "GridAdapt",
+ "parameter": "MinLevel",
+ "type": [
+ "int"
+ ]
+ },
+ "GridAdapt.RefineAtDirichletBC": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "To switch for refinement at Dirichlet BCs"
+ ],
+ "group": "GridAdapt",
+ "parameter": "RefineAtDirichletBC",
+ "type": [
+ "bool"
+ ]
+ },
+ "GridAdapt.RefineAtFluxBC": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "To switch for refinement at Neumann BCs"
+ ],
+ "group": "GridAdapt",
+ "parameter": "RefineAtFluxBC",
+ "type": [
+ "bool"
+ ]
+ },
+ "GridAdapt.RefineAtSource": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "To switch for refinement at sources"
+ ],
+ "group": "GridAdapt",
+ "parameter": "RefineAtSource",
+ "type": [
+ "bool"
+ ]
+ },
+ "GridAdapt.RefineTolerance": {
+ "default": [
+ "0.05"
+ ],
+ "explanation": [
+ "Coarsening threshold to decide whether a cell should be marked for refinement"
+ ],
+ "group": "GridAdapt",
+ "parameter": "RefineTolerance",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "InvasionState.AccuracyCriterion": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Specifies the allowed relative deviation of the capillary pressure of the upstream pore from the throat's entry capillary pressure after an invasion event. This effectively forces the Newton scheme to use very small time steps at invasion events. A value of 0.9 means that pc must not be smaller than 0.9*pc_entry after the invasion."
+ ],
+ "group": "InvasionState",
+ "parameter": "AccuracyCriterion",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "InvasionState.BlockNonwettingPhaseAtThroatLabel": {
+ "default": [
+ "std::vector<int>{Labels::outlet}"
+ ],
+ "explanation": [
+ "A vector of labels of throats. Block non-wetting phase flux out of the outlet."
+ ],
+ "group": "InvasionState",
+ "parameter": "BlockNonwettingPhaseAtThroatLabel",
+ "type": [
+ "std::vector<int>"
+ ]
+ },
+ "InvasionState.RestrictInvasionToGlobalCapillaryPressure": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to restrict the invasion behavior by a global capillary pressure defined in the problem."
+ ],
+ "group": "InvasionState",
+ "parameter": "RestrictInvasionToGlobalCapillaryPressure",
+ "type": [
+ "bool"
+ ]
+ },
+ "InvasionState.Verbosity": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to print detailed invasion information."
+ ],
+ "group": "InvasionState",
+ "parameter": "Verbosity",
+ "type": [
+ "bool"
+ ]
+ },
+ "KEpsilon.EnableZeroEqScaling": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to match the potential zeroeq eddy viscosities for two-layer model at the matching point"
+ ],
+ "group": "KEpsilon",
+ "parameter": "EnableZeroEqScaling",
+ "type": [
+ "bool"
+ ]
+ },
+ "KEpsilon.YPlusThreshold": {
+ "default": [
+ "30"
+ ],
+ "explanation": [
+ "yPlus below this value is considered as near-wall region"
+ ],
+ "group": "KEpsilon",
+ "parameter": "YPlusThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "KOmega.EnableDissipationLimiter": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to enable the dissipation limiter"
+ ],
+ "group": "KOmega",
+ "parameter": "EnableDissipationLimiter",
+ "type": [
+ "bool"
+ ]
+ },
+ "KOmega.EnableProductionLimiter": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to enable the production limiter"
+ ],
+ "group": "KOmega",
+ "parameter": "EnableProductionLimiter",
+ "type": [
+ "bool"
+ ]
+ },
+ "LinearSolver.GMResRestart": {
+ "default": [
+ "10"
+ ],
+ "explanation": [
+ "cycles before restarting"
+ ],
+ "group": "LinearSolver",
+ "parameter": "GMResRestart",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.MaxIterations": {
+ "default": [
+ "250"
+ ],
+ "explanation": [
+ "The maximum iterations of the linear solver"
+ ],
+ "group": "LinearSolver",
+ "parameter": "MaxIterations",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.MaxOrthogonalizationVectors": {
+ "default": [
+ "10"
+ ],
+ "explanation": [
+ "Maximal number of previous vectors which are orthogonalized against the new search direction"
+ ],
+ "group": "LinearSolver",
+ "parameter": "MaxOrthogonalizationVectors",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgAccumulationMode": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "If and how data is agglomerated on coarser level to fewer processors. (\"atOnce\": do agglomeration once and to one process; \"successive\": Multiple agglomerations to fewer proceses until all data is on one process; \"none\": Do no agglomeration at all and solve coarse level iteratively)."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgAccumulationMode",
+ "type": [
+ "std::string"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgAdditive": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether to use additive multigrid."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgAdditive",
+ "type": [
+ "bool"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgAlpha": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Scaling value for marking connections as strong."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgAlpha",
+ "type": [
+ "double"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgBeta": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Threshold for marking nodes as isolated."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgBeta",
+ "type": [
+ "double"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgCoarsenTarget": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Maximum number of unknowns on the coarsest level."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgCoarsenTarget",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgCriterionSymmetric": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "If true use SymmetricCriterion (default), else UnSymmetricCriterion"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgCriterionSymmetric",
+ "type": [
+ "bool"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgDefaultAggregationDimension": {
+ "default": [
+ "std::to_string(dimension)"
+ ],
+ "explanation": [
+ "Dimension of the problem (used for setting default aggregate size)."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgDefaultAggregationDimension",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgDefaultAggregationSizeMode": {
+ "default": [
+ "isotropic"
+ ],
+ "explanation": [
+ "Whether to set default values depending on isotropy of problem uses parameters \"defaultAggregationDimension\" and \"maxAggregateDistance\" (isotropic: For and isotropic problem; anisotropic: for an anisotropic problem)."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgDefaultAggregationSizeMode",
+ "type": [
+ "std::string"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgDiagonalRowIndex": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The index to use for the diagonal strength (default 0) if this is i and strengthMeasure is \"diagonal\", then block[i][i] will be used when determining strength of connection."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgDiagonalRowIndex",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgGamma": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "1 for V-cycle, 2 for W-cycle."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgGamma",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgMaxAggregateDistance": {
+ "default": [
+ "2"
+ ],
+ "explanation": [
+ "Maximum distance in an aggregte (in term of minimum edges needed to travel. one vertex to another within the aggregate)."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgMaxAggregateDistance",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgMaxAggregateSize": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Maximum number of vertices an aggregate should consist of."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgMaxAggregateSize",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgMaxLevel": {
+ "default": [
+ "100"
+ ],
+ "explanation": [
+ "Maximum number of levels allowed in the hierarchy."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgMaxLevel",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgMinAggregateSize": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Minimum number of vertices an aggregate should consist of."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgMinAggregateSize",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgMinCoarseningRate": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Coarsening will stop if the rate is below this threshold."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgMinCoarseningRate",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgPostSmoothingSteps": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Number of postsmoothing steps."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgPostSmoothingSteps",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgPreSmoothingSteps": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Number of presmoothing steps."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgPreSmoothingSteps",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgProlongationDampingFactor": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Damping factor for the prolongation."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgProlongationDampingFactor",
+ "type": [
+ "double"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgSmootherIterations": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of iterations to perform."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgSmootherIterations",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgSmootherRelaxation": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The relaxation factor"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgSmootherRelaxation",
+ "type": [
+ "typename SmootherArgs::RelaxationFactor"
+ ]
+ },
+ "LinearSolver.Preconditioner.AmgStrengthMeasure": {
+ "default": [
+ "diagonal"
+ ],
+ "explanation": [
+ "What conversion to use to convert a matrix block to a scalar when determining strength of connection: diagonal (use a diagonal of row diagonalRowIndex, class Diagonal, default); rowSum (rowSum norm), frobenius (Frobenius norm); one (use always one and neglect the actual entries)."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.AmgStrengthMeasure",
+ "type": [
+ "std::string"
+ ]
+ },
+ "LinearSolver.Preconditioner.DetermineRelaxationFactor": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether within the Uzawa algorithm the parameter omega is the relaxation factor is estimated by use of AMG"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.DetermineRelaxationFactor",
+ "type": [
+ "bool"
+ ]
+ },
+ "LinearSolver.Preconditioner.DirectSolverForA": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether within the Uzawa algorithm a direct solver is used for inverting the 00 matrix block."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.DirectSolverForA",
+ "type": [
+ "bool"
+ ]
+ },
+ "LinearSolver.Preconditioner.ILUOrder": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The order of the ILU decomposition."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.ILUOrder",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.ILUResort": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "true if a resort of the computed ILU for improved performance should be done."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.ILUResort",
+ "type": [
+ "bool"
+ ]
+ },
+ "LinearSolver.Preconditioner.Iterations": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "Usually specifies the number of times the preconditioner is applied"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.Iterations",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Preconditioner.PowerLawIterations": {
+ "default": [
+ "5"
+ ],
+ "explanation": [
+ "Number of iterations done to estimate the relaxation factor within the Uzawa algorithm."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.PowerLawIterations",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "LinearSolver.Preconditioner.Relaxation": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The relaxation parameter for the preconditioner"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.Relaxation",
+ "type": [
+ "double"
+ ]
+ },
+ "LinearSolver.Preconditioner.Type": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The preconditioner type."
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.Type",
+ "type": [
+ "std::string"
+ ]
+ },
+ "LinearSolver.Preconditioner.Verbosity": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The preconditioner verbosity level"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Preconditioner.Verbosity",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.ResidualReduction": {
+ "default": [
+ "1e-13(linear solver),1e-6(nonlinear)"
+ ],
+ "explanation": [
+ "The residual reduction threshold, i.e. stopping criterion"
+ ],
+ "group": "LinearSolver",
+ "parameter": "ResidualReduction",
+ "type": [
+ "double"
+ ]
+ },
+ "LinearSolver.Restart": {
+ "default": [
+ "10"
+ ],
+ "explanation": [
+ "cycles before restarting"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Restart",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Type": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The type of linear solver, e.g. restartedflexiblegmressolver or uzawa"
+ ],
+ "group": "LinearSolver",
+ "parameter": "type",
+ "type": [
+ "std::string"
+ ]
+ },
+ "LinearSolver.UMFPackOrdering": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "You can chosse from one of the following ordering strategies: 0: UMFPACK_ORDERING_CHOLMOD, 1: UMFPACK_ORDERING_AMD (default), 2: UMFPACK_ORDERING_GIVEN, 3: UMFPACK_ORDERING_METIS, 4: UMFPACK_ORDERING_BEST, 5: UMFPACK_ORDERING_NONE, 6: UMFPACK_ORDERING_USER. See https://fossies.org/linux/SuiteSparse/UMFPACK/Doc/UMFPACK_UserGuide.pdf page 17 for details."
+ ],
+ "group": "LinearSolver",
+ "parameter": "UMFPackOrdering",
+ "type": [
+ "int"
+ ]
+ },
+ "LinearSolver.Verbosity": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The verbosity level of the linear solver"
+ ],
+ "group": "LinearSolver",
+ "parameter": "Verbosity",
+ "type": [
+ "int"
+ ]
+ },
+ "LoadSolution.CellCenterPriVarNames": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Names of cell-centered primary variables of a model with staggered grid discretization"
+ ],
+ "group": "LoadSolution",
+ "parameter": "CellCenterPriVarNames",
+ "type": [
+ "std::vector<std::string>"
+ ]
+ },
+ "LoadSolution.FacePriVarNames": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Names of primary variables on the cell faces of a model with staggered grid discretization"
+ ],
+ "group": "LoadSolution",
+ "parameter": "FacePriVarNames",
+ "type": [
+ "std::vector<std::string>"
+ ]
+ },
+ "LoadSolution.PriVarNames": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Primary variable names"
+ ],
+ "group": "LoadSolution",
+ "parameter": "PriVarNames",
+ "type": [
+ "std::vector<std::string>"
+ ]
+ },
+ "LoadSolution.PriVarNamesState...": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Primary variable names state, e.g. p_liq S_gas"
+ ],
+ "group": "LoadSolution",
+ "parameter": "PriVarNamesState...",
+ "type": [
+ "std::vector<std::string>"
+ ]
+ },
+ "LoadSolution.PriVarNamesState1": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Primary variable names state, e.g. p_liq x^N2_liq"
+ ],
+ "group": "LoadSolution",
+ "parameter": "PriVarNamesState1",
+ "type": [
+ "std::vector<std::string>"
+ ]
+ },
+ "LoadSolution.PriVarNamesState2": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Primary variable names state, e.g. p_liq x^H2O_gas"
+ ],
+ "group": "LoadSolution",
+ "parameter": "PriVarNamesState2",
+ "type": [
+ "std::vector<std::string>"
+ ]
+ },
+ "MPFA.CalcVelocityInTransport": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Indicates if velocity is reconstructed in the pressure step or in the transport step"
+ ],
+ "group": "MPFA",
+ "parameter": "CalcVelocityInTransport",
+ "type": [
+ "bool"
+ ]
+ },
+ "MPFA.EnableComplexLStencil": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to enable the two non-centered flux stencils"
+ ],
+ "group": "MPFA",
+ "parameter": "EnableComplexLStencil",
+ "type": [
+ "bool"
+ ]
+ },
+ "MPFA.EnableSimpleLStencil": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to enable the two centered flux stencils"
+ ],
+ "group": "MPFA",
+ "parameter": "EnableSimpleLStencil",
+ "type": [
+ "bool"
+ ]
+ },
+ "MPFA.EnableTPFA": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to enable the use of TPFA if neighboring cells are of the same grid level"
+ ],
+ "group": "MPFA",
+ "parameter": "EnableTPFA",
+ "type": [
+ "bool"
+ ]
+ },
+ "MPFA.Q": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The quadrature point parameterizaion to be used on scvfs"
+ ],
+ "group": "MPFA",
+ "parameter": "Q",
+ "type": [
+ "CoordScalar"
+ ]
+ },
+ "MPFA.TransmissibilityCriterion": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ ""
+ ],
+ "group": "MPFA",
+ "parameter": "TransmissibilityCriterion",
+ "type": [
+ "int"
+ ]
+ },
+ "MPFA.TransmissibilityCriterionThreshold": {
+ "default": [
+ "1e-8"
+ ],
+ "explanation": [
+ ""
+ ],
+ "group": "MPFA",
+ "parameter": "TransmissibilityCriterionThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "MatrixConverter.DeletePatternEntriesBelowAbsThreshold": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Only set non-zero value if original matrix entry is larger than this."
+ ],
+ "group": "MatrixConverter",
+ "parameter": "DeletePatternEntriesBelowAbsThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "MixedDimension.IntegrationOrder": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The integration order for coupling source"
+ ],
+ "group": "MixedDimension",
+ "parameter": "IntegrationOrder",
+ "type": [
+ "int"
+ ]
+ },
+ "MixedDimension.KernelIntegrationCRL": {
+ "default": [
+ "0.1"
+ ],
+ "explanation": [
+ "The characteristic relative length"
+ ],
+ "group": "MixedDimension",
+ "parameter": "KernelIntegrationCRL",
+ "type": [
+ "double"
+ ]
+ },
+ "MixedDimension.KernelWidthFactor": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The kernel width factor"
+ ],
+ "group": "MixedDimension",
+ "parameter": "KernelWidthFactor",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "MixedDimension.NumCircleSegments": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of circle segements in the context of integration points."
+ ],
+ "group": "MixedDimension",
+ "parameter": "NumCircleSegments",
+ "type": [
+ "int"
+ ]
+ },
+ "MixedDimension.UseCircleAverage": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "if we use the circle average as the 3D values or a point evaluation"
+ ],
+ "group": "MixedDimension",
+ "parameter": "UseCircleAverage",
+ "type": [
+ "bool"
+ ]
+ },
+ "MixedDimension.WriteIntegrationPointsToFile": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to write integration points to a file"
+ ],
+ "group": "MixedDimension",
+ "parameter": "WriteIntegrationPointsToFile",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.AllowedSaturationChange": {
+ "default": [
+ "-1.0"
+ ],
+ "explanation": [
+ "Maximum allowed (relative or absolute) shift of saturation between to consecutive time steps. If this is not set, any shift is allowed. If SaturationChangeIsRelative is true, relative shifts are considered (while not dividing by zero). If SaturationChangeIsRelative is false, absolute shifts are considered."
+ ],
+ "group": "Newton",
+ "parameter": "AllowedSaturationChange",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.EnableAbsoluteResidualCriterion": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For Newton iterations to stop the absolute residual is demanded to be below a threshold value. At least two iterations."
+ ],
+ "group": "Newton",
+ "parameter": "EnableAbsoluteResidualCriterion",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.EnableChop": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "chop the Newton update at the beginning of the non-linear solver"
+ ],
+ "group": "Newton",
+ "parameter": "EnableChop",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.EnableDynamicOutput": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Prints current information about assembly and solution process in the coarse of the simulation."
+ ],
+ "group": "Newton",
+ "parameter": "EnableDynamicOutput",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.EnablePartialReassembly": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Every entity where the primary variables exhibit a relative shift summed up since the last linearization above 'eps' will be reassembled."
+ ],
+ "group": "Newton",
+ "parameter": "EnablePartialReassembly",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.EnableResidualCriterion": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "declare convergence if the initial residual is reduced by the factor ResidualReduction"
+ ],
+ "group": "Newton",
+ "parameter": "EnableResidualCriterion",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.EnableShiftCriterion": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "For Newton iterations to stop the maximum relative shift abs(uLastIter - uNew)/scalarmax(1.0, abs(uLastIter + uNew)*0.5) is demanded to be below a threshold value. At least two iterations."
+ ],
+ "group": "Newton",
+ "parameter": "EnableShiftCriterion",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.LineSearchMinRelaxationFactor": {
+ "default": [
+ "0.125"
+ ],
+ "explanation": [
+ "A minimum relaxation factor for the line serach process."
+ ],
+ "group": "Newton",
+ "parameter": "LineSearchMinRelaxationFactor",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.MaxAbsoluteResidual": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The maximum acceptable absolute residual for declaring convergence"
+ ],
+ "group": "Newton",
+ "parameter": "MaxAbsoluteResidual",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.MaxRelativeShift": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Set the maximum acceptable difference of any primary variable between two iterations for declaring convergence"
+ ],
+ "group": "Newton",
+ "parameter": "MaxRelativeShift",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.MaxSteps": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of iterations after we give up"
+ ],
+ "group": "Newton",
+ "parameter": "MaxSteps",
+ "type": [
+ "int"
+ ]
+ },
+ "Newton.MaxTimeStepDivisions": {
+ "default": [
+ "10"
+ ],
+ "explanation": [
+ "The maximum number of time-step divisions"
+ ],
+ "group": "Newton",
+ "parameter": "MaxTimeStepDivisions",
+ "type": [
+ "std::size_t"
+ ]
+ },
+ "Newton.MinSteps": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The minimum number of iterations"
+ ],
+ "group": "Newton",
+ "parameter": "MinSteps",
+ "type": [
+ "int"
+ ]
+ },
+ "Newton.PlausibilityCheck": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "If this is set true, an error is thrown is a saturation is not between zero and one."
+ ],
+ "group": "Newton",
+ "parameter": "PlausibilityCheck",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.ReassemblyMaxThreshold": {
+ "default": [
+ "1e2*shiftTolerance_"
+ ],
+ "explanation": [
+ "'maxEps' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'maxEps' leads to less/more reassembly if 'omega*shift' is large, i.e., for the first Newton iterations."
+ ],
+ "group": "Newton",
+ "parameter": "ReassemblyMaxThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.ReassemblyMinThreshold": {
+ "default": [
+ "1e-1*shiftTolerance_"
+ ],
+ "explanation": [
+ "'minEps' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'minEps' leads to less/more reassembly if 'omega*shift' is small, i.e., for the last Newton iterations."
+ ],
+ "group": "Newton",
+ "parameter": "ReassemblyMinThreshold",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.ReassemblyShiftWeight": {
+ "default": [
+ "1e-3"
+ ],
+ "explanation": [
+ "'omega' in reassembly threshold max( minEps, min(maxEps, omega*(currently achieved maximum relative shift)) ). Increasing/decreasing 'maxEps' leads to less/more reassembly if 'omega*shift' is large, i.e., for the first Newton iterations."
+ ],
+ "group": "Newton",
+ "parameter": "ReassemblyShiftWeight",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.ResidualReduction": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The maximum acceptable residual norm reduction"
+ ],
+ "group": "Newton",
+ "parameter": "ResidualReduction",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.RetryTimeStepReductionFactor": {
+ "default": [
+ "0.5"
+ ],
+ "explanation": [
+ "Factor for reducing the current time-step"
+ ],
+ "group": "Newton",
+ "parameter": "RetryTimeStepReductionFactor",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.SatisfyResidualAndShiftCriterion": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "declare convergence only if both criteria are met"
+ ],
+ "group": "Newton",
+ "parameter": "SatisfyResidualAndShiftCriterion",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.SaturationChangeIsRelative": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "See explanatio of AllowedSaturationChange."
+ ],
+ "group": "Newton",
+ "parameter": "SaturationChangeIsRelative",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Newton.TargetSteps": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The number of iterations which are considered \"optimal\""
+ ],
+ "group": "Newton",
+ "parameter": "TargetSteps",
+ "type": [
+ "int"
+ ]
+ },
+ "Newton.UseLineSearch": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether to use line search"
+ ],
+ "group": "Newton",
+ "parameter": "UseLineSearch",
+ "type": [
+ "bool"
+ ]
+ },
+ "Newton.Verbosity": {
+ "default": [
+ "2"
+ ],
+ "explanation": [
+ "The verbosity level of the Newton solver"
+ ],
+ "group": "Newton",
+ "parameter": "Verbosity",
+ "type": [
+ "int"
+ ]
+ },
+ "PointSource.EnableBoxLumping": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "For a DOF-index to point source map distribute source using a check if point sources are inside a subcontrolvolume instead of using basis function weights."
+ ],
+ "group": "PointSource",
+ "parameter": "EnableBoxLumping",
+ "type": [
+ "bool"
+ ]
+ },
+ "PrimaryVariableSwitch.Verbosity": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "Verbosity level of the primary variable switch."
+ ],
+ "group": "PrimaryVariableSwitch",
+ "parameter": "Verbosity",
+ "type": [
+ "int"
+ ]
+ },
+ "Problem.EnableGravity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether to enable the gravity term"
+ ],
+ "group": "Problem",
+ "parameter": "EnableGravity",
+ "type": [
+ "bool"
+ ]
+ },
+ "Problem.EnableInertiaTerms": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether to enable the inertia terms"
+ ],
+ "group": "Problem",
+ "parameter": "EnableInertiaTerms",
+ "type": [
+ "bool"
+ ]
+ },
+ "Problem.Name": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Set a name for a problem"
+ ],
+ "group": "Problem",
+ "parameter": "Name",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Problem.SandGrainRoughness": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The sand grain roughness"
+ ],
+ "group": "Problem",
+ "parameter": "SandGrainRoughness",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "Problem.UsePrimaryVariableSwitch": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether to perform variable switch at a degree of freedom location"
+ ],
+ "group": "Problem",
+ "parameter": "UsePrimaryVariableSwitch",
+ "type": [
+ "bool"
+ ]
+ },
+ "RANS.EddyViscosityModel": {
+ "default": [
+ "vanDriest"
+ ],
+ "explanation": [
+ "Choose the eddy viscosity model"
+ ],
+ "group": "RANS",
+ "parameter": "EddyViscosityModel",
+ "type": [
+ "std::string"
+ ]
+ },
+ "RANS.FlowDirectionAxis": {
+ "default": [
+ "0"
+ ],
+ "explanation": [
+ "The flow direction axis"
+ ],
+ "group": "RANS",
+ "parameter": "FlowDirectionAxis",
+ "type": [
+ "int"
+ ]
+ },
+ "RANS.IsFlatWallBounded": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Set to true, if geometry consists of flat walls"
+ ],
+ "group": "RANS",
+ "parameter": "IsFlatWallBounded",
+ "type": [
+ "bool"
+ ]
+ },
+ "RANS.TurbulentPrandtlNumber": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "The turbulent Prandtl number"
+ ],
+ "group": "RANS",
+ "parameter": "TurbulentPrandtlNumber",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "RANS.TurbulentSchmidtNumber": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "The turbulent Schmidt number"
+ ],
+ "group": "RANS",
+ "parameter": "TurbulentSchmidtNumber",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "RANS.UseStoredEddyViscosity": {
+ "default": [
+ "true for lowrekepsilon, false else"
+ ],
+ "explanation": [
+ "Whether to use the stored eddy viscosity"
+ ],
+ "group": "RANS",
+ "parameter": "UseStoredEddyViscosity",
+ "type": [
+ "bool"
+ ]
+ },
+ "RANS.WallNormalAxis": {
+ "default": [
+ "1"
+ ],
+ "explanation": [
+ "The normal wall axis of a flat wall bounded flow"
+ ],
+ "group": "RANS",
+ "parameter": "WallNormalAxis",
+ "type": [
+ "int"
+ ]
+ },
+ "RANS.WriteFlatWallBoundedFields": {
+ "default": [
+ "isFlatWallBounded"
+ ],
+ "explanation": [
+ "Whether to write output fields for flat wall geometries"
+ ],
+ "group": "RANS",
+ "parameter": "WriteFlatWallBoundedFields",
+ "type": [
+ "bool"
+ ]
+ },
+ "ShallowWater.EnableViscousFlux": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether to include a viscous flux contribution."
+ ],
+ "group": "ShallowWater",
+ "parameter": "EnableViscousFlux",
+ "type": [
+ "bool"
+ ]
+ },
+ "ShallowWater.HorizontalCoefficientOfMixingLengthModel": {
+ "default": [
+ "0.1"
+ ],
+ "explanation": [
+ "For the turbulence model base on the mixing length: The Smagorinsky-like horizontal turbulence coefficient."
+ ],
+ "group": "ShallowWater",
+ "parameter": "HorizontalCoefficientOfMixingLengthModel",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ShallowWater.TurbulentViscosity": {
+ "default": [
+ "1.0e-6"
+ ],
+ "explanation": [
+ "The (constant) background turbulent viscosity."
+ ],
+ "group": "ShallowWater",
+ "parameter": "TurbulentViscosity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "ShallowWater.UseMixingLengthTurbulenceModel": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "Whether the mixing-length turbulence model is used."
+ ],
+ "group": "ShallowWater",
+ "parameter": "UseMixingLengthTurbulenceModel",
+ "type": [
+ "bool"
+ ]
+ },
+ "ShallowWater.VerticalCoefficientOfMixingLengthModel": {
+ "default": [
+ "1.0"
+ ],
+ "explanation": [
+ "For the turbulence model base on the mixing length: The Elder-like vertical turbulence coefficient."
+ ],
+ "group": "ShallowWater",
+ "parameter": "VerticalCoefficientOfMixingLengthModel",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SimpleH2O.ReferenceTemperature": {
+ "default": [
+ "293.15"
+ ],
+ "explanation": [
+ "The reference temperature in \\f$\\mathrm{[K]}\\f$ for calculating the (liquid or gas) enthalpy of simple H2O."
+ ],
+ "group": "SimpleH2O",
+ "parameter": "ReferenceTemperature",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.ComputeAwsFromAnsAndPcMax": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Compute volume-specific interfacial area between the wetting and solid phase from interfacial area between nonwetting and solid phase and maximum capillary pressure."
+ ],
+ "group": "SpatialParams",
+ "parameter": "ComputeAwsFromAnsAndPcMax",
+ "type": [
+ "bool"
+ ]
+ },
+ "SpatialParams.ContactAngle": {
+ "default": [
+ "0.0"
+ ],
+ "explanation": [
+ "This contact angle \\f$[rad]\\f$ is set both as the contact angle within a pore throat and the one within a pore body. It can be overloaded for solution-dependent values."
+ ],
+ "group": "SpatialParams",
+ "parameter": "ContactAngle",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.ForchCoeff": {
+ "default": [
+ "0.55"
+ ],
+ "explanation": [
+ "The Forchheimer coefficient"
+ ],
+ "group": "SpatialParams",
+ "parameter": "ForchCoeff",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.MinBoundaryPermeability": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The minimum permeability"
+ ],
+ "group": "SpatialParams",
+ "parameter": "MinBoundaryPermeability",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.Permeability": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The permeability"
+ ],
+ "group": "SpatialParams",
+ "parameter": "Permeability",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.Porosity": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "The porosity"
+ ],
+ "group": "SpatialParams",
+ "parameter": "Porosity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.SurfaceTension": {
+ "default": [
+ "0.0725"
+ ],
+ "explanation": [
+ "The value of the surface tension \\f$[N/m]\\f$. It defaults to the surface tension of water/air."
+ ],
+ "group": "SpatialParams",
+ "parameter": "SurfaceTension",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "SpatialParams.Tortuosity": {
+ "default": [
+ "0.5"
+ ],
+ "explanation": [
+ "The tortuosity"
+ ],
+ "group": "SpatialParams",
+ "parameter": "Tortuosity",
+ "type": [
+ "Scalar"
+ ]
+ },
+ "TimeLoop.Restart": {
+ "default": [
+ "0.0"
+ ],
+ "explanation": [
+ "The restart time stamp for a previously interrupted simulation"
+ ],
+ "group": "TimeLoop",
+ "parameter": "Restart",
+ "type": [
+ "double"
+ ]
+ },
+ "Transmissibility.ConsiderPoreResistance": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether or not the pore resistance should be considered on runtime."
+ ],
+ "group": "Transmissibility",
+ "parameter": "ConsiderPoreResistance",
+ "type": [
+ "bool"
+ ]
+ },
+ "Vtk.AddProcessRank": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "Whether to add a process rank"
+ ],
+ "group": "Vtk",
+ "parameter": "AddProcessRank",
+ "type": [
+ "bool"
+ ]
+ },
+ "Vtk.AddVelocity": {
+ "default": [
+ "true"
+ ],
+ "explanation": [
+ "Whether to enable velocity output"
+ ],
+ "group": "Vtk",
+ "parameter": "AddVelocity",
+ "type": [
+ "bool"
+ ]
+ },
+ "Vtk.CoordPrecision": {
+ "default": [
+ "value set to Vtk.Precision before"
+ ],
+ "explanation": [
+ "The output precision of coordinates."
+ ],
+ "group": "Vtk",
+ "parameter": "CoordPrecision",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Vtk.OutputLevel": {
+ "default": [
+ "-"
+ ],
+ "explanation": [
+ "in sequential models: indicates which values the VTK output contains, e.g. if the OutputLevel is zero, only primary variables are written"
+ ],
+ "group": "Vtk",
+ "parameter": "OutputLevel",
+ "type": [
+ "int"
+ ]
+ },
+ "Vtk.Precision": {
+ "default": [
+ "Float32"
+ ],
+ "explanation": [
+ "Precision of the vtk output"
+ ],
+ "group": "Vtk",
+ "parameter": "Precision",
+ "type": [
+ "std::string"
+ ]
+ },
+ "Vtk.WriteFaceData": {
+ "default": [
+ "false"
+ ],
+ "explanation": [
+ "For the staggered grid approach, write face-related data into vtp files."
+ ],
+ "group": "Vtk",
+ "parameter": "WriteFaceData",
+ "type": [
+ "bool"
+ ]
+ }
+}
--
GitLab