From 2b060155c399fff7f75eb1f87faee8abfe96b3cd Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Thu, 8 Jun 2017 16:05:31 +0100 Subject: [PATCH 01/22] ENH: Added script to create bash tab-completions --- bin/foamCreateBashCompletions | 195 ++++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100755 bin/foamCreateBashCompletions diff --git a/bin/foamCreateBashCompletions b/bin/foamCreateBashCompletions new file mode 100755 index 0000000000..a941a23f33 --- /dev/null +++ b/bin/foamCreateBashCompletions @@ -0,0 +1,195 @@ +#!/bin/sh +#------------------------------------------------------------------------------ +# ========= | +# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox +# \\ / O peration | +# \\ / A nd | Copyright (C) 2017 OpenCFD Ltd. +# \\/ M anipulation | +#------------------------------------------------------------------------------- +# License +# This file is part of OpenFOAM. +# +# OpenFOAM is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# OpenFOAM is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with OpenFOAM. If not, see . +# +# Script +# foamCreateBashCompletions +# +# Description +# Create bash completions for OpenFOAM applications +# +#------------------------------------------------------------------------------ +#set -x + +usage() { + exec 1>&2 + while [ "$#" -ge 1 ]; do echo "$1"; shift; done + cat< + +* Create bash completions for OpenFOAM applications and write to . + By default searches directories \$FOAM_APPBIN and \$FOAM_USER_APPBIN + + +Options: + -d | -directory Directory to process + -h | -help Print the usage + +USAGE + exit 1 +} + +searchDirs="$FOAM_APPBIN $FOAM_USER_APPBIN" +while [ "$#" -gt 0 ] +do + case "$1" in + -h | -help) + usage + ;; + -d | -directory) + searchDirs="$2" + [ -d $searchDirs ] || usage "directory not found '$searchDirs'" + shift + ;; + -*) + usage "unknown option: '$1'" + ;; + *) + outFile=$1 + break + ;; + esac + shift +done + +[ -z $outFile ] && usage +\rm -f $outFile +touch $outFile + + +writeFilterFunction() +{ + cat<> $1 +unset -f _filter_opts +_filter_opts() +{ + local allOpts=\$1 + local applied=\$2 + for o in \${allOpts}; do + [ "\${applied/\$o/}" == "\${applied}" ] && echo \$o + done +} + +WRITEFILTER +} + + +commonOptions() +{ + local options=$@ + local indent1=" " + local indent2=" " + for o in ${options[@]}; do + case $o in + -case) + echo "${indent1}-case)" + echo "${indent2}COMPREPLY=(\$(compgen -d -- \${cur}))" + echo "${indent2};;" + ;; + -srcDoc|-help) + echo "${indent1}-srcDoc|-help)" + echo "${indent2}COMPREPLY=()" + echo "${indent2};;" + ;; + -time) + echo "${indent1}-time)" + echo "${indent2}COMPREPLY=(\$(compgen -d -X '![-0-9]*' -- \${cur}))" + echo "${indent2};;" + ;; + -region) + echo "${indent1}-region)" + echo "${indent2}local regions=\$(sed 's#/##g' <<< \$([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))" + echo "${indent2}COMPREPLY=(\$(compgen -W \"\$regions\" -- \${cur}))" + echo "${indent2};;" + ;; + *Dict) + echo "${indent1}*Dict)" +# echo "${indent2}local dirs=\$(\ls -d s*/)" +# echo "${indent2}local files=\$(\ls -f | grep Dict)" +# echo "${indent2}COMPREPLY=(\$(compgen -W \"\$dirs \$files\" -- \${cur}))" + echo "${indent2}COMPREPLY=(\$(compgen -f -- \${cur}))" + echo "${indent2};;" + ;; + esac + done +} + + +writeFilterFunction $outFile + +for dir in ${searchDirs} +do + echo "Processing directory $dir" + + apps=($(\ls $dir)) + for appName in "${apps[@]}"; do + appHelp=$($appName -help) + + echo "Processing $appName" + + # Options with args + optsWithArgs=($(awk '/^ *-[a-z]/ && /> $outFile +unset -f _${appName} +_${appName}() +{ + local cur="\${COMP_WORDS[COMP_CWORD]}" + local prev="\${COMP_WORDS[COMP_CWORD-1]}" + + local opts="${opts[@]} " + local optsWithArgs="${optsWithArgs[@]} " + + case \${prev} in +$(commonOptions ${optsWithArgs[@]}) + *) + if [ "\${optsWithArgs/\${prev} /}" != "\${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=(\$(compgen -f -- \${cur})) + else + # Catch-all - present all remaining options + opts=\$(_filter_opts "\${opts}" "\${COMP_LINE}") + optsWithArgs=\$(_filter_opts "\${optsWithArgs}" "\${COMP_LINE}") + COMPREPLY=(\$(compgen -W "\${opts} \${optsWithArgs}" -- \${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _${appName} $appName + +WRITECOMPLETION + done +done + +unset searchDirs writeFilterFunction commonOptions + + +#------------------------------------------------------------------------------ From 40ddfb4277898357a58c6834f38a3903b1f9c9b8 Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Thu, 8 Jun 2017 16:06:16 +0100 Subject: [PATCH 02/22] COMP: renamed runtime selection table to avoid duplicate entry clashes --- .../constantSurfaceTensionCoefficient.C | 2 +- .../surfaceTensionModel/newSurfaceTensionModel.C | 6 +++--- .../surfaceTensionModel/surfaceTensionModel.C | 2 +- .../surfaceTensionModel/surfaceTensionModel.H | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.C b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.C index d0632c55dc..72392f76c3 100644 --- a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.C +++ b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.C @@ -38,7 +38,7 @@ namespace surfaceTensionModels ( surfaceTensionModel, constantSurfaceTensionCoefficient, - dictionary + multiphase ); } } diff --git a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/newSurfaceTensionModel.C b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/newSurfaceTensionModel.C index f14c0da92f..f2c28eeb5d 100644 --- a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/newSurfaceTensionModel.C +++ b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/newSurfaceTensionModel.C @@ -40,8 +40,8 @@ Foam::surfaceTensionModel::New Info<< "Selecting surfaceTensionModel for " << pair << ": " << surfaceTensionModelType << endl; - dictionaryConstructorTable::iterator cstrIter = - dictionaryConstructorTablePtr_->find(surfaceTensionModelType); + multiphaseConstructorTable::iterator cstrIter = + multiphaseConstructorTablePtr_->find(surfaceTensionModelType); if (!cstrIter.found()) { @@ -49,7 +49,7 @@ Foam::surfaceTensionModel::New << "Unknown surfaceTensionModelType type " << surfaceTensionModelType << endl << endl << "Valid surfaceTensionModel types are : " << endl - << dictionaryConstructorTablePtr_->sortedToc() + << multiphaseConstructorTablePtr_->sortedToc() << exit(FatalError); } diff --git a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.C b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.C index 8d7a487495..9836cad235 100644 --- a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.C +++ b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.C @@ -31,7 +31,7 @@ License namespace Foam { defineTypeNameAndDebug(surfaceTensionModel, 0); - defineRunTimeSelectionTable(surfaceTensionModel, dictionary); + defineRunTimeSelectionTable(surfaceTensionModel, multiphase); } const Foam::dimensionSet Foam::surfaceTensionModel::dimSigma(1, 0, -2, 0, 0); diff --git a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.H b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.H index 8fb8877d5c..a69f14e58e 100644 --- a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.H +++ b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/surfaceTensionModel/surfaceTensionModel.H @@ -73,7 +73,7 @@ public: ( autoPtr, surfaceTensionModel, - dictionary, + multiphase, ( const dictionary& dict, const phasePair& pair, From c187e9b523f78e8dc2a1d1637420e5f760404d67 Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Thu, 8 Jun 2017 16:07:58 +0100 Subject: [PATCH 03/22] ENH: foamHelp - minro refactoring to enable use of foamHelp -help option --- .../miscellaneous/foamHelp/addToolOption.H | 10 ++++++++++ .../utilities/miscellaneous/foamHelp/foamHelp.C | 13 ++++++++++--- .../foamHelp/helpTypes/helpBoundary/helpBoundary.C | 2 -- .../helpFunctionObject/helpFunctionObject.C | 2 -- .../foamHelp/helpTypes/helpSolver/helpSolver.C | 1 - 5 files changed, 20 insertions(+), 8 deletions(-) create mode 100644 applications/utilities/miscellaneous/foamHelp/addToolOption.H diff --git a/applications/utilities/miscellaneous/foamHelp/addToolOption.H b/applications/utilities/miscellaneous/foamHelp/addToolOption.H new file mode 100644 index 0000000000..71aa071179 --- /dev/null +++ b/applications/utilities/miscellaneous/foamHelp/addToolOption.H @@ -0,0 +1,10 @@ +argList::validArgs.append("tool"); +const wordList opts(helpType::dictionaryConstructorTablePtr_->sortedToc()); + +string note = "Valid options include:"; +forAll(opts, i) +{ + note = note + ' ' + opts[i]; +} + +argList::notes.append(note); diff --git a/applications/utilities/miscellaneous/foamHelp/foamHelp.C b/applications/utilities/miscellaneous/foamHelp/foamHelp.C index d4d145ee21..a0e7097e4f 100644 --- a/applications/utilities/miscellaneous/foamHelp/foamHelp.C +++ b/applications/utilities/miscellaneous/foamHelp/foamHelp.C @@ -3,7 +3,7 @@ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / O peration | \\ / A nd | Copyright (C) 2012-2014 OpenFOAM Foundation - \\/ M anipulation | + \\/ M anipulation | Copyright (C) 2017 OpenCFD Ltd. ------------------------------------------------------------------------------- License This file is part of OpenFOAM. @@ -42,6 +42,14 @@ using namespace Foam; int main(int argc, char *argv[]) { #include "addRegionOption.H" + #include "addToolOption.H" + + // Intercept request for help + if ((argc > 0) && (strcmp(argv[1], "-help") == 0)) + { + #include "setRootCase.H" + } + if (argc < 2) { FatalError @@ -49,8 +57,7 @@ int main(int argc, char *argv[]) << exit(FatalError); } - const word utilityName = argv[1]; - + word utilityName = argv[1]; Foam::autoPtr utility ( helpType::New(utilityName) diff --git a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpBoundary/helpBoundary.C b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpBoundary/helpBoundary.C index 5052b76a14..3e3931c4c3 100644 --- a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpBoundary/helpBoundary.C +++ b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpBoundary/helpBoundary.C @@ -62,8 +62,6 @@ void Foam::helpTypes::helpBoundary::init() { helpType::init(); - argList::validArgs.append("boundary"); - argList::addOption ( "field", diff --git a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpFunctionObject/helpFunctionObject.C b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpFunctionObject/helpFunctionObject.C index c42a430a06..81fca4a918 100644 --- a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpFunctionObject/helpFunctionObject.C +++ b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpFunctionObject/helpFunctionObject.C @@ -61,8 +61,6 @@ Foam::helpTypes::helpFunctionObject::~helpFunctionObject() void Foam::helpTypes::helpFunctionObject::init() { helpType::init(); - - argList::validArgs.append("functionObject"); } diff --git a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpSolver/helpSolver.C b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpSolver/helpSolver.C index cac59967c3..ac628c09c6 100644 --- a/applications/utilities/miscellaneous/foamHelp/helpTypes/helpSolver/helpSolver.C +++ b/applications/utilities/miscellaneous/foamHelp/helpTypes/helpSolver/helpSolver.C @@ -63,7 +63,6 @@ void Foam::helpTypes::helpSolver::init() { helpType::init(); - argList::validArgs.append("solver"); argList::addBoolOption ( "read", From b36491576dcc4b57290c20ca883de856313da40e Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Thu, 8 Jun 2017 16:14:51 +0100 Subject: [PATCH 04/22] COMP: foamList - removed corruption error on exit --- .../miscellaneous/foamList/Make/options | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/applications/utilities/miscellaneous/foamList/Make/options b/applications/utilities/miscellaneous/foamList/Make/options index 6487208998..4d19e89721 100644 --- a/applications/utilities/miscellaneous/foamList/Make/options +++ b/applications/utilities/miscellaneous/foamList/Make/options @@ -38,28 +38,22 @@ EXE_LIBS = \ -lfvMotionSolvers \ -lfvOptions \ -lgenericPatchFields \ - -limmiscibleIncompressibleTwoPhaseMixture \ -lincompressibleTransportModels \ -lincompressibleTurbulenceModels \ - -linterfaceProperties \ + -llagrangian \ -llagrangianFunctionObjects \ -llagrangianIntermediate \ - -llagrangian \ -llagrangianSpray \ -llagrangianTurbulence \ -llaminarFlameSpeedModels \ - -lthermophysicalProperties \ -lmeshTools \ -lmolecularMeasurements \ -lmolecule \ -lODE \ - -lOpenFOAM \ -lpairPatchAgglomeration \ - -lphaseChangeTwoPhaseMixtures \ -lpotential \ -lpyrolysisModels \ -lradiationModels \ - -lrandomProcesses \ -lreactingEulerianInterfacialCompositionModels \ -lreactingEulerianInterfacialModels \ -lreactingPhaseSystem \ @@ -88,10 +82,17 @@ EXE_LIBS = \ -lsurfaceFilmModels \ -lsurfMesh \ -lthermalBaffleModels \ + -lthermophysicalProperties \ -ltopoChangerFvMesh \ -lturbulenceModels \ -ltwoPhaseMixture \ - -ltwoPhaseMixtureThermo \ - -ltwoPhaseProperties \ -ltwoPhaseReactingTurbulenceModels \ -lutilityFunctionObjects +/* + Combinations of the following libs leads to corruption errors... ? + -limmiscibleIncompressibleTwoPhaseMixture \ + -linterfaceProperties \ + -lphaseChangeTwoPhaseMixtures \ + -ltwoPhaseMixtureThermo \ + -ltwoPhaseProperties \ +*/ From caf9a0870d3f01a4d5f5bc650c3d1f9649d30245 Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Thu, 8 Jun 2017 16:24:06 +0100 Subject: [PATCH 05/22] ENH: Added bash completion for OpenFOAM applications --- etc/bashrc | 1 + etc/config.sh/bashcompletion | 8185 ++++++++++++++++++++++++++++++++++ 2 files changed, 8186 insertions(+) create mode 100644 etc/config.sh/bashcompletion diff --git a/etc/bashrc b/etc/bashrc index ccc6a3eebc..188c0a133c 100644 --- a/etc/bashrc +++ b/etc/bashrc @@ -170,6 +170,7 @@ export PATH LD_LIBRARY_PATH MANPATH # ~~~~~~~~~~~~~~~~~~~~~~~~~~ _foamEtc config.sh/settings _foamEtc config.sh/aliases +_foamEtc config.sh/bashcompletion # Source user setup files for optional packages diff --git a/etc/config.sh/bashcompletion b/etc/config.sh/bashcompletion new file mode 100644 index 0000000000..34fe2f5e91 --- /dev/null +++ b/etc/config.sh/bashcompletion @@ -0,0 +1,8185 @@ +unset -f _filter_opts +_filter_opts() +{ + local allOpts=$1 + local applied=$2 + for o in ${allOpts}; do + [ "${applied/$o/}" == "${applied}" ] && echo $o + done +} + +unset -f _adiabaticFlameT +_adiabaticFlameT() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _adiabaticFlameT adiabaticFlameT + +unset -f _adjointShapeOptimizationFoam +_adjointShapeOptimizationFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _adjointShapeOptimizationFoam adjointShapeOptimizationFoam + +unset -f _ansysToFoam +_ansysToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _ansysToFoam ansysToFoam + +unset -f _applyBoundaryLayer +_applyBoundaryLayer() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -ybl " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _applyBoundaryLayer applyBoundaryLayer + +unset -f _attachMesh +_attachMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _attachMesh attachMesh + +unset -f _autoPatch +_autoPatch() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _autoPatch autoPatch + +unset -f _blockMesh +_blockMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-blockTopology -noClean -noFunctionObjects -sets -srcDoc -doc -help " + local optsWithArgs="-case -dict -region " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _blockMesh blockMesh + +unset -f _boundaryFoam +_boundaryFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _boundaryFoam boundaryFoam + +unset -f _boxTurb +_boxTurb() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _boxTurb boxTurb + +unset -f _buoyantBoussinesqPimpleFoam +_buoyantBoussinesqPimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _buoyantBoussinesqPimpleFoam buoyantBoussinesqPimpleFoam + +unset -f _buoyantBoussinesqSimpleFoam +_buoyantBoussinesqSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _buoyantBoussinesqSimpleFoam buoyantBoussinesqSimpleFoam + +unset -f _buoyantPimpleFoam +_buoyantPimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _buoyantPimpleFoam buoyantPimpleFoam + +unset -f _buoyantSimpleFoam +_buoyantSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _buoyantSimpleFoam buoyantSimpleFoam + +unset -f _cavitatingDyMFoam +_cavitatingDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _cavitatingDyMFoam cavitatingDyMFoam + +unset -f _cavitatingFoam +_cavitatingFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _cavitatingFoam cavitatingFoam + +unset -f _cfx4ToFoam +_cfx4ToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _cfx4ToFoam cfx4ToFoam + +unset -f _changeDictionary +_changeDictionary() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -disablePatchGroups -enableFunctionEntries -latestTime -literalRE -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -instance -region -roots -subDict -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _changeDictionary changeDictionary + +unset -f _checkMesh +_checkMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-allGeometry -allTopology -constant -latestTime -meshQuality -newTimes -noFunctionObjects -noTopology -noZero -parallel -writeAllFields -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -time -writeFields -writeSets " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _checkMesh checkMesh + +unset -f _chemFoam +_chemFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -postProcess -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _chemFoam chemFoam + +unset -f _chemkinToFoam +_chemkinToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-newFormat -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _chemkinToFoam chemkinToFoam + +unset -f _chtMultiRegionFoam +_chtMultiRegionFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _chtMultiRegionFoam chtMultiRegionFoam + +unset -f _chtMultiRegionSimpleFoam +_chtMultiRegionSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _chtMultiRegionSimpleFoam chtMultiRegionSimpleFoam + +unset -f _coalChemistryFoam +_coalChemistryFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _coalChemistryFoam coalChemistryFoam + +unset -f _coldEngineFoam +_coldEngineFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _coldEngineFoam coldEngineFoam + +unset -f _collapseEdges +_collapseEdges() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-collapseFaces -constant -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -collapseFaceSet -decomposeParDict -dict -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _collapseEdges collapseEdges + +unset -f _combinePatchFaces +_combinePatchFaces() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-meshQuality -noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -concaveAngle -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _combinePatchFaces combinePatchFaces + +unset -f _compressibleInterDyMFoam +_compressibleInterDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _compressibleInterDyMFoam compressibleInterDyMFoam + +unset -f _compressibleInterFoam +_compressibleInterFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _compressibleInterFoam compressibleInterFoam + +unset -f _compressibleMultiphaseInterFoam +_compressibleMultiphaseInterFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _compressibleMultiphaseInterFoam compressibleMultiphaseInterFoam + +unset -f _createBaffles +_createBaffles() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _createBaffles createBaffles + +unset -f _createExternalCoupledPatchGeometry +_createExternalCoupledPatchGeometry() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -commsDir -decomposeParDict -region -regions -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _createExternalCoupledPatchGeometry createExternalCoupledPatchGeometry + +unset -f _createPatch +_createPatch() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -writeObj -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _createPatch createPatch + +unset -f _createZeroDirectory +_createZeroDirectory() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots -templateDir " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _createZeroDirectory createZeroDirectory + +unset -f _datToFoam +_datToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _datToFoam datToFoam + +unset -f _decomposePar +_decomposePar() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-allRegions -cellDist -constant -copyUniform -copyZero -fields -force -ifRequired -latestTime -newTimes -noFunctionObjects -noSets -noZero -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _decomposePar decomposePar + +unset -f _deformedGeom +_deformedGeom() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _deformedGeom deformedGeom + +unset -f _dnsFoam +_dnsFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _dnsFoam dnsFoam + +unset -f _DPMDyMFoam +_DPMDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloudName -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _DPMDyMFoam DPMDyMFoam + +unset -f _DPMFoam +_DPMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloud -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _DPMFoam DPMFoam + +unset -f _driftFluxFoam +_driftFluxFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _driftFluxFoam driftFluxFoam + +unset -f _dsmcFoam +_dsmcFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _dsmcFoam dsmcFoam + +unset -f _dsmcInitialise +_dsmcInitialise() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _dsmcInitialise dsmcInitialise + +unset -f _electrostaticFoam +_electrostaticFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _electrostaticFoam electrostaticFoam + +unset -f _engineCompRatio +_engineCompRatio() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _engineCompRatio engineCompRatio + +unset -f _engineFoam +_engineFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _engineFoam engineFoam + +unset -f _engineSwirl +_engineSwirl() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _engineSwirl engineSwirl + +unset -f _equilibriumCO +_equilibriumCO() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _equilibriumCO equilibriumCO + +unset -f _equilibriumFlameT +_equilibriumFlameT() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _equilibriumFlameT equilibriumFlameT + +unset -f _extrude2DMesh +_extrude2DMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _extrude2DMesh extrude2DMesh + +unset -f _extrudeMesh +_extrudeMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _extrudeMesh extrudeMesh + +unset -f _extrudeToRegionMesh +_extrudeToRegionMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _extrudeToRegionMesh extrudeToRegionMesh + +unset -f _faceAgglomerate +_faceAgglomerate() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _faceAgglomerate faceAgglomerate + +unset -f _financialFoam +_financialFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _financialFoam financialFoam + +unset -f _fireFoam +_fireFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _fireFoam fireFoam + +unset -f _fireToFoam +_fireToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-ascii -check -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _fireToFoam fireToFoam + +unset -f _flattenMesh +_flattenMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _flattenMesh flattenMesh + +unset -f _fluent3DMeshToFoam +_fluent3DMeshToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-cubit -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -ignoreCellGroups -ignoreFaceGroups -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _fluent3DMeshToFoam fluent3DMeshToFoam + +unset -f _fluentMeshToFoam +_fluentMeshToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -writeSets -writeZones -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _fluentMeshToFoam fluentMeshToFoam + +unset -f _foamDataToFluent +_foamDataToFluent() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help " + local optsWithArgs="-case -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamDataToFluent foamDataToFluent + +unset -f _foamDictionary +_foamDictionary() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-disableFunctionEntries -expand -includes -keywords -noFunctionObjects -parallel -remove -value -srcDoc -doc -help " + local optsWithArgs="-add -case -decomposeParDict -diff -entry -roots -set " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamDictionary foamDictionary + +unset -f _foamFormatConvert +_foamFormatConvert() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -enableFunctionEntries -latestTime -newTimes -noConstant -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamFormatConvert foamFormatConvert + +unset -f _foamHelp +_foamHelp() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamHelp foamHelp + +unset -f _foamList +_foamList() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-compressibleTurbulenceModels -functionObjects -fvOptions -incompressibleTurbulenceModels -noFunctionObjects -registeredSwitches -switches -unset -srcDoc -doc -help " + local optsWithArgs="-case -scalarBCs -vectorBCs " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamList foamList + +unset -f _foamListTimes +_foamListTimes() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -processor -rm -withZero -srcDoc -doc -help " + local optsWithArgs="-case -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamListTimes foamListTimes + +unset -f _foamMeshToFluent +_foamMeshToFluent() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamMeshToFluent foamMeshToFluent + +unset -f _foamToEnsight +_foamToEnsight() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-ascii -constant -deprecatedOrder -latestTime -newTimes -noFunctionObjects -noLagrangian -noPatches -noZero -nodeValues -parallel -srcDoc -doc -help " + local optsWithArgs="-case -cellZone -decomposeParDict -faceZones -fields -name -patches -region -roots -time -width " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToEnsight foamToEnsight + +unset -f _foamToEnsightParts +_foamToEnsightParts() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noLagrangian -noMesh -noZero -srcDoc -doc -help " + local optsWithArgs="-case -index -name -time -width " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToEnsightParts foamToEnsightParts + +unset -f _foamToFireMesh +_foamToFireMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help " + local optsWithArgs="-case -scale -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToFireMesh foamToFireMesh + +unset -f _foamToGMV +_foamToGMV() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToGMV foamToGMV + +unset -f _foamToStarMesh +_foamToStarMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noBnd -noFunctionObjects -noZero -srcDoc -doc -help " + local optsWithArgs="-case -scale -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToStarMesh foamToStarMesh + +unset -f _foamToSurface +_foamToSurface() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -tri -srcDoc -doc -help " + local optsWithArgs="-case -scale -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToSurface foamToSurface + +unset -f _foamToTetDualMesh +_foamToTetDualMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToTetDualMesh foamToTetDualMesh + +unset -f _foamToVTK +_foamToVTK() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-allPatches -ascii -constant -latestTime -nearCellValue -newTimes -noFaceZones -noFunctionObjects -noInternal -noLagrangian -noLinks -noPointValues -noZero -parallel -poly -surfaceFields -useTimeName -srcDoc -doc -help " + local optsWithArgs="-case -cellSet -decomposeParDict -excludePatches -faceSet -fields -pointSet -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamToVTK foamToVTK + +unset -f _foamUpgradeCyclics +_foamUpgradeCyclics() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -enableFunctionEntries -latestTime -newTimes -noFunctionObjects -noZero -parallel -test -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamUpgradeCyclics foamUpgradeCyclics + +unset -f _foamyHexMesh +_foamyHexMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-checkGeometry -conformationOnly -noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamyHexMesh foamyHexMesh + +unset -f _foamyQuadMesh +_foamyQuadMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -srcDoc -doc -help " + local optsWithArgs="-case -pointsFile " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _foamyQuadMesh foamyQuadMesh + +unset -f _gambitToFoam +_gambitToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _gambitToFoam gambitToFoam + +unset -f _gmshToFoam +_gmshToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-keepOrientation -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -region " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _gmshToFoam gmshToFoam + +unset -f _icoFoam +_icoFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _icoFoam icoFoam + +unset -f _icoUncoupledKinematicParcelDyMFoam +_icoUncoupledKinematicParcelDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloud -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _icoUncoupledKinematicParcelDyMFoam icoUncoupledKinematicParcelDyMFoam + +unset -f _icoUncoupledKinematicParcelFoam +_icoUncoupledKinematicParcelFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloud -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _icoUncoupledKinematicParcelFoam icoUncoupledKinematicParcelFoam + +unset -f _ideasUnvToFoam +_ideasUnvToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-dump -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _ideasUnvToFoam ideasUnvToFoam + +unset -f _insideCells +_insideCells() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _insideCells insideCells + +unset -f _interCondensatingEvaporatingFoam +_interCondensatingEvaporatingFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _interCondensatingEvaporatingFoam interCondensatingEvaporatingFoam + +unset -f _interDyMFoam +_interDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _interDyMFoam interDyMFoam + +unset -f _interFoam +_interFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _interFoam interFoam + +unset -f _interMixingFoam +_interMixingFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _interMixingFoam interMixingFoam + +unset -f _interPhaseChangeDyMFoam +_interPhaseChangeDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _interPhaseChangeDyMFoam interPhaseChangeDyMFoam + +unset -f _interPhaseChangeFoam +_interPhaseChangeFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _interPhaseChangeFoam interPhaseChangeFoam + +unset -f _kivaToFoam +_kivaToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -file -version -zHeadMin " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _kivaToFoam kivaToFoam + +unset -f _laplacianFoam +_laplacianFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _laplacianFoam laplacianFoam + +unset -f _magneticFoam +_magneticFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noB -noFunctionObjects -noH -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _magneticFoam magneticFoam + +unset -f _mapFields +_mapFields() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-consistent -noFunctionObjects -parallelSource -parallelTarget -subtract -srcDoc -doc -help " + local optsWithArgs="-case -mapMethod -sourceDecomposeParDict -sourceRegion -sourceTime -targetDecomposeParDict -targetRegion " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mapFields mapFields + +unset -f _mapFieldsPar +_mapFieldsPar() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-consistent -noFunctionObjects -noLagrangian -parallel -subtract -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -fields -mapMethod -patchMapMethod -roots -sourceRegion -sourceTime -targetRegion " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mapFieldsPar mapFieldsPar + +unset -f _mdEquilibrationFoam +_mdEquilibrationFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mdEquilibrationFoam mdEquilibrationFoam + +unset -f _mdFoam +_mdFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mdFoam mdFoam + +unset -f _mdInitialise +_mdInitialise() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mdInitialise mdInitialise + +unset -f _mergeMeshes +_mergeMeshes() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-addRegion -case -decomposeParDict -masterRegion -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mergeMeshes mergeMeshes + +unset -f _mergeOrSplitBaffles +_mergeOrSplitBaffles() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-detectOnly -noFunctionObjects -overwrite -parallel -split -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mergeOrSplitBaffles mergeOrSplitBaffles + +unset -f _mhdFoam +_mhdFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mhdFoam mhdFoam + +unset -f _mirrorMesh +_mirrorMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mirrorMesh mirrorMesh + +unset -f _mixtureAdiabaticFlameT +_mixtureAdiabaticFlameT() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mixtureAdiabaticFlameT mixtureAdiabaticFlameT + +unset -f _modifyMesh +_modifyMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _modifyMesh modifyMesh + +unset -f _moveDynamicMesh +_moveDynamicMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-checkAMI -noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _moveDynamicMesh moveDynamicMesh + +unset -f _moveEngineMesh +_moveEngineMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _moveEngineMesh moveEngineMesh + +unset -f _moveMesh +_moveMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _moveMesh moveMesh + +unset -f _MPPICDyMFoam +_MPPICDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloudName -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _MPPICDyMFoam MPPICDyMFoam + +unset -f _MPPICFoam +_MPPICFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloud -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _MPPICFoam MPPICFoam + +unset -f _MPPICInterFoam +_MPPICInterFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _MPPICInterFoam MPPICInterFoam + +unset -f _mshToFoam +_mshToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-hex -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _mshToFoam mshToFoam + +unset -f _multiphaseEulerFoam +_multiphaseEulerFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _multiphaseEulerFoam multiphaseEulerFoam + +unset -f _multiphaseInterDyMFoam +_multiphaseInterDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _multiphaseInterDyMFoam multiphaseInterDyMFoam + +unset -f _multiphaseInterFoam +_multiphaseInterFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _multiphaseInterFoam multiphaseInterFoam + +unset -f _netgenNeutralToFoam +_netgenNeutralToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _netgenNeutralToFoam netgenNeutralToFoam + +unset -f _noise +_noise() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _noise noise + +unset -f _nonNewtonianIcoFoam +_nonNewtonianIcoFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _nonNewtonianIcoFoam nonNewtonianIcoFoam + +unset -f _objToVTK +_objToVTK() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _objToVTK objToVTK + +unset -f _orientFaceZone +_orientFaceZone() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _orientFaceZone orientFaceZone + +unset -f _particleTracks +_particleTracks() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _particleTracks particleTracks + +unset -f _patchSummary +_patchSummary() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -expand -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _patchSummary patchSummary + +unset -f _pdfPlot +_pdfPlot() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _pdfPlot pdfPlot + +unset -f _PDRFoam +_PDRFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _PDRFoam PDRFoam + +unset -f _PDRMesh +_PDRMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _PDRMesh PDRMesh + +unset -f _pimpleDyMFoam +_pimpleDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _pimpleDyMFoam pimpleDyMFoam + +unset -f _pimpleFoam +_pimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _pimpleFoam pimpleFoam + +unset -f _pisoFoam +_pisoFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _pisoFoam pisoFoam + +unset -f _plot3dToFoam +_plot3dToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noBlank -noFunctionObjects -singleBlock -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _plot3dToFoam plot3dToFoam + +unset -f _polyDualMesh +_polyDualMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-concaveMultiCells -doNotPreserveFaceZones -noFunctionObjects -overwrite -splitAllFaces -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _polyDualMesh polyDualMesh + +unset -f _porousSimpleFoam +_porousSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _porousSimpleFoam porousSimpleFoam + +unset -f _postChannel +_postChannel() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help " + local optsWithArgs="-case -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _postChannel postChannel + +unset -f _postProcess +_postProcess() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -list -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -field -fields -func -funcs -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _postProcess postProcess + +unset -f _potentialFoam +_potentialFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-initialiseUBCs -noFunctionObjects -parallel -withFunctionObjects -writePhi -writep -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -pName -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _potentialFoam potentialFoam + +unset -f _potentialFreeSurfaceDyMFoam +_potentialFreeSurfaceDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _potentialFreeSurfaceDyMFoam potentialFreeSurfaceDyMFoam + +unset -f _potentialFreeSurfaceFoam +_potentialFreeSurfaceFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _potentialFreeSurfaceFoam potentialFreeSurfaceFoam + +unset -f _reactingFoam +_reactingFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reactingFoam reactingFoam + +unset -f _reactingMultiphaseEulerFoam +_reactingMultiphaseEulerFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reactingMultiphaseEulerFoam reactingMultiphaseEulerFoam + +unset -f _reactingParcelFilmFoam +_reactingParcelFilmFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reactingParcelFilmFoam reactingParcelFilmFoam + +unset -f _reactingParcelFoam +_reactingParcelFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reactingParcelFoam reactingParcelFoam + +unset -f _reactingTwoPhaseEulerFoam +_reactingTwoPhaseEulerFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reactingTwoPhaseEulerFoam reactingTwoPhaseEulerFoam + +unset -f _reconstructPar +_reconstructPar() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-allRegions -constant -latestTime -newTimes -noFields -noFunctionObjects -noLagrangian -noSets -noZero -withZero -srcDoc -doc -help " + local optsWithArgs="-case -fields -lagrangianFields -region -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reconstructPar reconstructPar + +unset -f _reconstructParMesh +_reconstructParMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-cellDist -constant -fullMatch -latestTime -newTimes -noFunctionObjects -noZero -withZero -srcDoc -doc -help " + local optsWithArgs="-case -mergeTol -region -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _reconstructParMesh reconstructParMesh + +unset -f _redistributePar +_redistributePar() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-cellDist -constant -decompose -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -reconstruct -withZero -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -mergeTol -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _redistributePar redistributePar + +unset -f _refineHexMesh +_refineHexMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-minSet -noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _refineHexMesh refineHexMesh + +unset -f _refinementLevel +_refinementLevel() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -readLevel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _refinementLevel refinementLevel + +unset -f _refineMesh +_refineMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-all -noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _refineMesh refineMesh + +unset -f _refineWallLayer +_refineWallLayer() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots -useSet " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _refineWallLayer refineWallLayer + +unset -f _removeFaces +_removeFaces() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _removeFaces removeFaces + +unset -f _renumberMesh +_renumberMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -frontWidth -latestTime -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _renumberMesh renumberMesh + +unset -f _rhoCentralDyMFoam +_rhoCentralDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoCentralDyMFoam rhoCentralDyMFoam + +unset -f _rhoCentralFoam +_rhoCentralFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoCentralFoam rhoCentralFoam + +unset -f _rhoPimpleDyMFoam +_rhoPimpleDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoPimpleDyMFoam rhoPimpleDyMFoam + +unset -f _rhoPimpleFoam +_rhoPimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoPimpleFoam rhoPimpleFoam + +unset -f _rhoPorousSimpleFoam +_rhoPorousSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoPorousSimpleFoam rhoPorousSimpleFoam + +unset -f _rhoReactingBuoyantFoam +_rhoReactingBuoyantFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoReactingBuoyantFoam rhoReactingBuoyantFoam + +unset -f _rhoReactingFoam +_rhoReactingFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoReactingFoam rhoReactingFoam + +unset -f _rhoSimpleFoam +_rhoSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rhoSimpleFoam rhoSimpleFoam + +unset -f _rotateMesh +_rotateMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _rotateMesh rotateMesh + +unset -f _scalarTransportFoam +_scalarTransportFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _scalarTransportFoam scalarTransportFoam + +unset -f _selectCells +_selectCells() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _selectCells selectCells + +unset -f _setFields +_setFields() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _setFields setFields + +unset -f _setSet +_setSet() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -loop -newTimes -noFunctionObjects -noSync -noVTK -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-batch -case -decomposeParDict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _setSet setSet + +unset -f _setsToZones +_setsToZones() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFlipMap -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _setsToZones setsToZones + +unset -f _shallowWaterFoam +_shallowWaterFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _shallowWaterFoam shallowWaterFoam + +unset -f _simpleCoalParcelFoam +_simpleCoalParcelFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _simpleCoalParcelFoam simpleCoalParcelFoam + +unset -f _simpleFoam +_simpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _simpleFoam simpleFoam + +unset -f _simpleReactingParcelFoam +_simpleReactingParcelFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _simpleReactingParcelFoam simpleReactingParcelFoam + +unset -f _singleCellMesh +_singleCellMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _singleCellMesh singleCellMesh + +unset -f _smapToFoam +_smapToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _smapToFoam smapToFoam + +unset -f _snappyHexMesh +_snappyHexMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-checkGeometry -noFunctionObjects -overwrite -parallel -profiling -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -outFile -patches -region -roots -surfaceSimplify " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _snappyHexMesh snappyHexMesh + +unset -f _snappyRefineMesh +_snappyRefineMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _snappyRefineMesh snappyRefineMesh + +unset -f _solidDisplacementFoam +_solidDisplacementFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _solidDisplacementFoam solidDisplacementFoam + +unset -f _solidEquilibriumDisplacementFoam +_solidEquilibriumDisplacementFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _solidEquilibriumDisplacementFoam solidEquilibriumDisplacementFoam + +unset -f _sonicDyMFoam +_sonicDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _sonicDyMFoam sonicDyMFoam + +unset -f _sonicFoam +_sonicFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _sonicFoam sonicFoam + +unset -f _sonicLiquidFoam +_sonicLiquidFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _sonicLiquidFoam sonicLiquidFoam + +unset -f _splitCells +_splitCells() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-geometry -noFunctionObjects -overwrite -srcDoc -doc -help " + local optsWithArgs="-case -set -tol " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _splitCells splitCells + +unset -f _splitMesh +_splitMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _splitMesh splitMesh + +unset -f _splitMeshRegions +_splitMeshRegions() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-cellZones -cellZonesOnly -detectOnly -largestOnly -makeCellZones -noFunctionObjects -overwrite -parallel -prefixRegion -sloppyCellZones -useFaceZones -srcDoc -doc -help " + local optsWithArgs="-blockedFaces -case -cellZonesFileOnly -decomposeParDict -insidePoint -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _splitMeshRegions splitMeshRegions + +unset -f _sprayDyMFoam +_sprayDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _sprayDyMFoam sprayDyMFoam + +unset -f _sprayEngineFoam +_sprayEngineFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _sprayEngineFoam sprayEngineFoam + +unset -f _sprayFoam +_sprayFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _sprayFoam sprayFoam + +unset -f _SRFPimpleFoam +_SRFPimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _SRFPimpleFoam SRFPimpleFoam + +unset -f _SRFSimpleFoam +_SRFSimpleFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _SRFSimpleFoam SRFSimpleFoam + +unset -f _star4ToFoam +_star4ToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-ascii -noFunctionObjects -solids -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _star4ToFoam star4ToFoam + +unset -f _steadyParticleTracks +_steadyParticleTracks() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help " + local optsWithArgs="-case -dict -region -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _steadyParticleTracks steadyParticleTracks + +unset -f _stitchMesh +_stitchMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -partial -perfect -srcDoc -doc -help " + local optsWithArgs="-case -region -toleranceDict " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _stitchMesh stitchMesh + +unset -f _subsetMesh +_subsetMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -patch -patches -region -resultTime -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _subsetMesh subsetMesh + +unset -f _surfaceAdd +_surfaceAdd() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-mergeRegions -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -points " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceAdd surfaceAdd + +unset -f _surfaceBooleanFeatures +_surfaceBooleanFeatures() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-invertedSpace -noFunctionObjects -perturb -surf1Baffle -surf2Baffle -srcDoc -doc -help " + local optsWithArgs="-case -trim " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceBooleanFeatures surfaceBooleanFeatures + +unset -f _surfaceCheck +_surfaceCheck() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-blockMesh -checkSelfIntersection -noFunctionObjects -splitNonManifold -verbose -srcDoc -doc -help " + local optsWithArgs="-case -outputThreshold " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceCheck surfaceCheck + +unset -f _surfaceClean +_surfaceClean() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noClean -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceClean surfaceClean + +unset -f _surfaceCoarsen +_surfaceCoarsen() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceCoarsen surfaceCoarsen + +unset -f _surfaceConvert +_surfaceConvert() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-clean -group -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -scale -writePrecision " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceConvert surfaceConvert + +unset -f _surfaceFeatureConvert +_surfaceFeatureConvert() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceFeatureConvert surfaceFeatureConvert + +unset -f _surfaceFeatureExtract +_surfaceFeatureExtract() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs="-case -dict " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceFeatureExtract surfaceFeatureExtract + +unset -f _surfaceFind +_surfaceFind() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -x -y -z " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceFind surfaceFind + +unset -f _surfaceHookUp +_surfaceHookUp() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -dict " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceHookUp surfaceHookUp + +unset -f _surfaceInertia +_surfaceInertia() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -shellProperties -srcDoc -doc -help " + local optsWithArgs="-case -density -referencePoint " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceInertia surfaceInertia + +unset -f _surfaceInflate +_surfaceInflate() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-checkSelfIntersection -debug -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -featureAngle -nSmooth " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceInflate surfaceInflate + +unset -f _surfaceLambdaMuSmooth +_surfaceLambdaMuSmooth() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs="-featureFile " + + case ${prev} in + + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceLambdaMuSmooth surfaceLambdaMuSmooth + +unset -f _surfaceMeshConvert +_surfaceMeshConvert() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-clean -noFunctionObjects -tri -srcDoc -doc -help " + local optsWithArgs="-case -dict -from -scaleIn -scaleOut -to " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceMeshConvert surfaceMeshConvert + +unset -f _surfaceMeshConvertTesting +_surfaceMeshConvertTesting() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-clean -noFunctionObjects -orient -stdout -surfMesh -testModify -triFace -triSurface -unsorted -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceMeshConvertTesting surfaceMeshConvertTesting + +unset -f _surfaceMeshExport +_surfaceMeshExport() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-clean -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -dict -from -name -scaleIn -scaleOut -to " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceMeshExport surfaceMeshExport + +unset -f _surfaceMeshImport +_surfaceMeshImport() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-clean -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -dict -from -name -scaleIn -scaleOut -to " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceMeshImport surfaceMeshImport + +unset -f _surfaceMeshInfo +_surfaceMeshInfo() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-areas -noFunctionObjects -xml -srcDoc -doc -help " + local optsWithArgs="-case -scale " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceMeshInfo surfaceMeshInfo + +unset -f _surfaceMeshTriangulate +_surfaceMeshTriangulate() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -excludeProcPatches -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -faceZones -patches -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceMeshTriangulate surfaceMeshTriangulate + +unset -f _surfaceOrient +_surfaceOrient() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-inside -noFunctionObjects -usePierceTest -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceOrient surfaceOrient + +unset -f _surfacePatch +_surfacePatch() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -dict " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfacePatch surfacePatch + +unset -f _surfacePointMerge +_surfacePointMerge() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfacePointMerge surfacePointMerge + +unset -f _surfaceRedistributePar +_surfaceRedistributePar() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-keepNonMapped -noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceRedistributePar surfaceRedistributePar + +unset -f _surfaceRefineRedGreen +_surfaceRefineRedGreen() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceRefineRedGreen surfaceRefineRedGreen + +unset -f _surfaceSplitByPatch +_surfaceSplitByPatch() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceSplitByPatch surfaceSplitByPatch + +unset -f _surfaceSplitByTopology +_surfaceSplitByTopology() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-srcDoc -doc -help " + local optsWithArgs=" " + + case ${prev} in + + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceSplitByTopology surfaceSplitByTopology + +unset -f _surfaceSplitNonManifolds +_surfaceSplitNonManifolds() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-debug -noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceSplitNonManifolds surfaceSplitNonManifolds + +unset -f _surfaceSubset +_surfaceSubset() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceSubset surfaceSubset + +unset -f _surfaceToPatch +_surfaceToPatch() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -faceSet -tol " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceToPatch surfaceToPatch + +unset -f _surfaceTransformPoints +_surfaceTransformPoints() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case -rollPitchYaw -rotate -scale -translate -yawPitchRoll " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _surfaceTransformPoints surfaceTransformPoints + +unset -f _temporalInterpolate +_temporalInterpolate() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -divisions -fields -interpolationType -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _temporalInterpolate temporalInterpolate + +unset -f _tetgenToFoam +_tetgenToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFaceFile -noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _tetgenToFoam tetgenToFoam + +unset -f _thermoFoam +_thermoFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _thermoFoam thermoFoam + +unset -f _topoSet +_topoSet() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noSync -noZero -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -dict -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _topoSet topoSet + +unset -f _transformPoints +_transformPoints() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -rotateFields -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -rollPitchYaw -roots -rotate -scale -translate -yawPitchRoll " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _transformPoints transformPoints + +unset -f _twoLiquidMixingFoam +_twoLiquidMixingFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _twoLiquidMixingFoam twoLiquidMixingFoam + +unset -f _twoPhaseEulerFoam +_twoPhaseEulerFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _twoPhaseEulerFoam twoPhaseEulerFoam + +unset -f _uncoupledKinematicParcelFoam +_uncoupledKinematicParcelFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -cloud -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _uncoupledKinematicParcelFoam uncoupledKinematicParcelFoam + +unset -f _viewFactorsGen +_viewFactorsGen() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _viewFactorsGen viewFactorsGen + +unset -f _vtkUnstructuredToFoam +_vtkUnstructuredToFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -srcDoc -doc -help " + local optsWithArgs="-case " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _vtkUnstructuredToFoam vtkUnstructuredToFoam + +unset -f _wallFunctionTable +_wallFunctionTable() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _wallFunctionTable wallFunctionTable + +unset -f _writeMeshObj +_writeMeshObj() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -patchEdges -patchFaces -srcDoc -doc -help " + local optsWithArgs="-case -cell -cellSet -decomposeParDict -face -faceSet -point -region -roots -time " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + -time) + COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _writeMeshObj writeMeshObj + +unset -f _XiDyMFoam +_XiDyMFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _XiDyMFoam XiDyMFoam + +unset -f _XiFoam +_XiFoam() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _XiFoam XiFoam + +unset -f _zipUpMesh +_zipUpMesh() +{ + local cur="${COMP_WORDS[COMP_CWORD]}" + local prev="${COMP_WORDS[COMP_CWORD-1]}" + + local opts="-noFunctionObjects -parallel -srcDoc -doc -help " + local optsWithArgs="-case -decomposeParDict -region -roots " + + case ${prev} in + -case) + COMPREPLY=($(compgen -d -- ${cur})) + ;; + *Dict) + COMPREPLY=($(compgen -f -- ${cur})) + ;; + -region) + local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null)))) + COMPREPLY=($(compgen -W "$regions" -- ${cur})) + ;; + *) + if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]; then + # Unknown what type of arg follows - set to files + # not always correct but at least can still navigate path if + # needed... + COMPREPLY=($(compgen -f -- ${cur})) + else + # Catch-all - present all remaining options + opts=$(_filter_opts "${opts}" "${COMP_LINE}") + optsWithArgs=$(_filter_opts "${optsWithArgs}" "${COMP_LINE}") + COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur})) + fi + ;; + esac + + return 0 +} +complete -o nospace -F _zipUpMesh zipUpMesh + From 2af8d388277c15e838f5c5915873484e5fc781f9 Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Fri, 9 Jun 2017 10:29:21 +0100 Subject: [PATCH 06/22] ENH: Added new Joule Heating fvOption and test case Evolves an electrical potential equation \f[ \grad \left( \sigma \grad V \right) \f] where \f$ V \f$ is electrical potential and \f$\sigma\f$ is the electrical current To provide a Joule heating contribution according to: Differential form of Joule heating - power per unit volume: \f[ \frac{d(P)}{d(V)} = J \cdot E \f] where \f$ J \f$ is the current density and \f$ E \f$ the electric field. If no magnetic field is present: \f[ J = \sigma E \f] The electric field given by \f[ E = \grad V \f] Therefore: \f[ \frac{d(P)}{d(V)} = J \cdot E = (sigma E) \cdot E = (sigma \grad V) \cdot \grad V \f] Usage Isotropic (scalar) electrical conductivity \verbatim jouleHeatingSourceCoeffs { anisotropicElectricalConductivity no; // Optionally specify the conductivity as a function of // temperature // Note: if not supplied, this will be read from the time // directory sigma table ( (273 1e5) (1000 1e5) ); } \endverbatim Anisotropic (vectorial) electrical conductivity jouleHeatingSourceCoeffs { anisotropicElectricalConductivity yes; coordinateSystem { type cartesian; origin (0 0 0); coordinateRotation { type axesRotation; e1 (1 0 0); e3 (0 0 1); } } // Optionally specify sigma as a function of temperature //sigma (31900 63800 127600); // //sigma table //( // (0 (0 0 0)) // (1000 (127600 127600 127600)) //); } Where: \table Property | Description | Required | Default value T | Name of temperature field | no | T sigma | Electrical conductivity as a function of temperature |no| anisotropicElectricalConductivity | Anisotropic flag | yes | \endtable The electrical conductivity can be specified using either: - If the \c sigma entry is present the electrical conductivity is specified as a function of temperature using a Function1 type - If not present the sigma field will be read from file - If the anisotropicElectricalConductivity flag is set to 'true', sigma should be specified as a vector quantity --- src/fvOptions/Make/files | 2 + .../jouleHeatingSource/jouleHeatingSource.C | 215 ++++++++++++++ .../jouleHeatingSource/jouleHeatingSource.H | 278 ++++++++++++++++++ .../jouleHeatingSource/jouleHeatingSourceIO.C | 59 ++++ .../jouleHeatingSourceTemplates.C | 147 +++++++++ .../jouleHeatingSolid/0.orig/solid/T | 49 +++ .../0.orig/solid/jouleHeatingSource:V | 49 +++ .../0.orig/solid/jouleHeatingSource:sigma | 47 +++ .../jouleHeatingSolid/0.orig/solid/p | 36 +++ .../jouleHeatingSolid/Allclean | 14 + .../jouleHeatingSolid/Allrun | 13 + .../jouleHeatingSolid/Allrun-parallel | 17 ++ .../jouleHeatingSolid/Allrun.pre | 15 + .../constant/regionProperties | 24 ++ .../constant/solid/thermophysicalProperties | 54 ++++ .../jouleHeatingSolid/createGraphs | 87 ++++++ .../jouleHeatingSolid/system/controlDict | 75 +++++ .../jouleHeatingSolid/system/decomposeParDict | 23 ++ .../system/solid/blockMeshDict | 89 ++++++ .../system/solid/decomposeParDict | 1 + .../jouleHeatingSolid/system/solid/fvOptions | 39 +++ .../jouleHeatingSolid/system/solid/fvSchemes | 50 ++++ .../jouleHeatingSolid/system/solid/fvSolution | 49 +++ 23 files changed, 1432 insertions(+) create mode 100644 src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.C create mode 100644 src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.H create mode 100644 src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceIO.C create mode 100644 src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceTemplates.C create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/T create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:V create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:sigma create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/p create mode 100755 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allclean create mode 100755 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun create mode 100755 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun-parallel create mode 100755 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun.pre create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/regionProperties create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/solid/thermophysicalProperties create mode 100755 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/createGraphs create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/controlDict create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/decomposeParDict create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/solid/blockMeshDict create mode 120000 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/solid/decomposeParDict create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/solid/fvOptions create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/solid/fvSchemes create mode 100644 tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/system/solid/fvSolution diff --git a/src/fvOptions/Make/files b/src/fvOptions/Make/files index 889ddebabb..9a8376a95c 100644 --- a/src/fvOptions/Make/files +++ b/src/fvOptions/Make/files @@ -22,6 +22,8 @@ $(derivedSources)/directionalPressureGradientExplicitSource/directionalPressureG $(derivedSources)/directionalPressureGradientExplicitSource/directionalPressureGradientExplicitSourceIO.C $(derivedSources)/effectivenessHeatExchangerSource/effectivenessHeatExchangerSource.C $(derivedSources)/explicitPorositySource/explicitPorositySource.C +$(derivedSources)/jouleHeatingSource/jouleHeatingSource.C +$(derivedSources)/jouleHeatingSource/jouleHeatingSourceIO.C $(derivedSources)/meanVelocityForce/meanVelocityForce.C $(derivedSources)/meanVelocityForce/meanVelocityForceIO.C $(derivedSources)/meanVelocityForce/patchMeanVelocityForce/patchMeanVelocityForce.C diff --git a/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.C b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.C new file mode 100644 index 0000000000..7a7a8ccde7 --- /dev/null +++ b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.C @@ -0,0 +1,215 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016-2017 OpenCFD Ltd. + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "jouleHeatingSource.H" +#include "fvMatrices.H" +#include "fvmLaplacian.H" +#include "fvcGrad.H" +#include "zeroGradientFvPatchField.H" +#include "basicThermo.H" +#include "addToRunTimeSelectionTable.H" + +// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * // + +namespace Foam +{ +namespace fv +{ + defineTypeNameAndDebug(jouleHeatingSource, 0); + + addToRunTimeSelectionTable + ( + option, + jouleHeatingSource, + dictionary + ); +} +} + + +const Foam::word Foam::fv::jouleHeatingSource::sigmaName(typeName + ":sigma"); + + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +const Foam::coordinateSystem& Foam::fv::jouleHeatingSource::coordSys() const +{ + if (!coordSysPtr_.valid()) + { + FatalErrorInFunction + << "Co-ordinate system invalid" + << abort(FatalError); + } + + return coordSysPtr_(); +} + + +Foam::tmp +Foam::fv::jouleHeatingSource::transformSigma +( + const volVectorField& sigmaLocal +) const +{ + tmp tsigma + ( + new volSymmTensorField + ( + IOobject + ( + sigmaName, + mesh_.time().timeName(), + mesh_, + IOobject::NO_READ, + IOobject::NO_WRITE, + false + ), + mesh_, + dimensionedSymmTensor("0", sigmaLocal.dimensions(), Zero), + zeroGradientFvPatchField::typeName + ) + ); + + volSymmTensorField& sigma = tsigma.ref(); + sigma.primitiveFieldRef() = coordSys().R().transformVector(sigmaLocal); + + sigma.correctBoundaryConditions(); + + return tsigma; +} + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::fv::jouleHeatingSource::jouleHeatingSource +( + const word& sourceName, + const word& modelType, + const dictionary& dict, + const fvMesh& mesh +) +: + option(sourceName, modelType, dict, mesh), + TName_("T"), + V_ + ( + IOobject + ( + typeName + ":V", + mesh.time().timeName(), + mesh, + IOobject::MUST_READ, + IOobject::AUTO_WRITE + ), + mesh + ), + anisotropicElectricalConductivity_(false), + scalarSigmaVsTPtr_(nullptr), + vectorSigmaVsTPtr_(nullptr), + coordSysPtr_(nullptr), + curTimeIndex_(-1) +{ + // Set the field name to that of the energy field from which the temperature + // is obtained + + const basicThermo& thermo = + mesh_.lookupObject(basicThermo::dictName); + + fieldNames_.setSize(1, thermo.he().name()); + + applied_.setSize(fieldNames_.size(), false); + + read(dict); +} + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::fv::jouleHeatingSource::~jouleHeatingSource() +{} + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +void Foam::fv::jouleHeatingSource::addSup +( + const volScalarField& rho, + fvMatrix& eqn, + const label fieldi +) +{ + DebugInfo<< name() << ": applying source to " << eqn.psi().name() << endl; + + if (curTimeIndex_ != mesh_.time().timeIndex()) + { + if (anisotropicElectricalConductivity_) + { + // Update sigma as a function of T if required + const volVectorField& sigmaLocal = updateSigma(vectorSigmaVsTPtr_); + + tmp sigma = transformSigma(sigmaLocal); + + // Solve the electrical potential equation + fvScalarMatrix VEqn(fvm::laplacian(sigma, V_)); + VEqn.relax(); + VEqn.solve(); + } + else + { + // Update sigma as a function of T if required + const volScalarField& sigma = updateSigma(scalarSigmaVsTPtr_); + + // Solve the electrical potential equation + fvScalarMatrix VEqn(fvm::laplacian(sigma, V_)); + VEqn.relax(); + VEqn.solve(); + } + + curTimeIndex_ = mesh_.time().timeIndex(); + } + + // Add the Joule heating contribution + + const volVectorField gradV(fvc::grad(V_)); + if (anisotropicElectricalConductivity_) + { + const volVectorField& sigmaLocal = + mesh_.lookupObject(sigmaName); + + tmp sigma = transformSigma(sigmaLocal); + + eqn += (sigma & gradV) & gradV; + } + else + { + const volScalarField& sigma = + mesh_.lookupObject(sigmaName); + + eqn += (sigma*gradV) & gradV; + } +} + + +// ************************************************************************* // diff --git a/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.H b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.H new file mode 100644 index 0000000000..5856564739 --- /dev/null +++ b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSource.H @@ -0,0 +1,278 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016-2017 OpenCFD Ltd. + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::fv::jouleHeatingSource + +Group + grpFvOptionsSources + +Description + Evolves an electrical potential equation + + \f[ + \grad \left( \sigma \grad V \right) + \f] + + where \f$ V \f$ is electrical potential and \f$\sigma\f$ is the + electrical current + + To provide a Joule heating contribution according to: + + Differential form of Joule heating - power per unit volume: + + \f[ + \frac{d(P)}{d(V)} = J \cdot E + \f] + + where \f$ J \f$ is the current density and \f$ E \f$ the electric field. + If no magnetic field is present: + + \f[ + J = \sigma E + \f] + + The electric field given by + + \f[ + E = \grad V + \f] + + Therefore: + + \f[ + \frac{d(P)}{d(V)} = J \cdot E + = (sigma E) \cdot E + = (sigma \grad V) \cdot \grad V + \f] + + +Usage + Isotropic (scalar) electrical conductivity + \verbatim + jouleHeatingSourceCoeffs + { + anisotropicElectricalConductivity no; + + // Optionally specify the conductivity as a function of temperature + // Note: if not supplied, this will be read from the time directory + sigma table + ( + (273 1e5) + (1000 1e5) + ); + } + \endverbatim + + Anisotropic (vectorial) electrical conductivity + jouleHeatingSourceCoeffs + { + anisotropicElectricalConductivity yes; + + coordinateSystem + { + type cartesian; + origin (0 0 0); + + coordinateRotation + { + type axesRotation; + e1 (1 0 0); + e3 (0 0 1); + } + } + + // Optionally specify sigma as a function of temperature + //sigma (31900 63800 127600); + // + //sigma table + //( + // (0 (0 0 0)) + // (1000 (127600 127600 127600)) + //); + } + + + Where: + \table + Property | Description | Required | Default value + T | Name of temperature field | no | T + sigma | Electrical conductivity as a function of temperature |no| + anisotropicElectricalConductivity | Anisotropic flag | yes | + \endtable + + The electrical conductivity can be specified using either: + - If the \c sigma entry is present the electrical conductivity is specified + as a function of temperature using a Function1 type + - If not present the sigma field will be read from file + - If the anisotropicElectricalConductivity flag is set to 'true', sigma + should be specified as a vector quantity + +SourceFiles + jouleHeatingSource.C + +SeeAlso + Foam::Function1 + +\*---------------------------------------------------------------------------*/ + +#ifndef fv_jouleHeatingSource_H +#define fv_jouleHeatingSource_H + +#include "fvOption.H" +#include "Function1.H" +#include "coordinateSystem.H" +#include "volFields.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace fv +{ + +/*---------------------------------------------------------------------------*\ + Class jouleHeatingSource Declaration +\*---------------------------------------------------------------------------*/ + +class jouleHeatingSource +: + public option +{ + // Private data + + //- Name of electrical conductivity field + static const word sigmaName; + + //- Name of temperature field - default = "T" (optional) + word TName_; + + //- Electrical potential field / [V] + volScalarField V_; + + //- Flag to indicate that the electrical conductivity is anisotropic + bool anisotropicElectricalConductivity_; + + //- Electrical conductivity as a scalar function of temperature + autoPtr> scalarSigmaVsTPtr_; + + //- Electrical conductivity as a vector function of temperature + autoPtr> vectorSigmaVsTPtr_; + + //- Co-ordinate system - used for vectorial electrical conductivity + autoPtr coordSysPtr_; + + //- Current time index (used for updating) + label curTimeIndex_; + + + // Private Member Functions + + //- Disallow default bitwise copy construct + jouleHeatingSource(const jouleHeatingSource&); + + //- Disallow default bitwise assignment + void operator=(const jouleHeatingSource&); + + //- Return the co-ordinate system for anisotropic electrical + // conductivity + const coordinateSystem& coordSys() const; + + //- Transform the anisotropic electrical conductivity into global system + tmp transformSigma + ( + const volVectorField& sigmaLocal + ) const; + + //- Initialise the electrical conductivity field + template + void initialiseSigma + ( + const dictionary& dict, + autoPtr>& sigmaVsTPtr + ); + + //- Update the electrical conductivity field + template + const GeometricField& + updateSigma(const autoPtr>& sigmaVsTPtr) const; + + +public: + + //- Runtime type information + TypeName("jouleHeatingSource"); + + + // Constructors + + //- Construct from explicit source name and mesh + jouleHeatingSource + ( + const word& sourceName, + const word& modelType, + const dictionary& dict, + const fvMesh& mesh + ); + + + //- Destructor + virtual ~jouleHeatingSource(); + + + // Member Functions + + // Evaluate + + //- Add explicit contribution to compressible momentum equation + virtual void addSup + ( + const volScalarField& rho, + fvMatrix& eqn, + const label fieldi + ); + + + // IO + + //- Read source dictionary + virtual bool read(const dictionary& dict); +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace fv +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#ifdef NoRepository + #include "jouleHeatingSourceTemplates.C" +#endif + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // diff --git a/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceIO.C b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceIO.C new file mode 100644 index 0000000000..ce4dde6f95 --- /dev/null +++ b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceIO.C @@ -0,0 +1,59 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016-2017 OpenCFD Ltd. + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "jouleHeatingSource.H" + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +bool Foam::fv::jouleHeatingSource::read(const dictionary& dict) +{ + if (option::read(dict)) + { + coeffs_.readIfPresent("T", TName_); + coeffs_.lookup("anisotropicElectricalConductivity") + >> anisotropicElectricalConductivity_; + + if (anisotropicElectricalConductivity_) + { + Info<< " Using vector electrical conductivity" << endl; + + initialiseSigma(coeffs_, vectorSigmaVsTPtr_); + coordSysPtr_ = coordinateSystem::New(mesh_, coeffs_); + } + else + { + Info<< " Using scalar electrical conductivity" << endl; + + initialiseSigma(coeffs_, scalarSigmaVsTPtr_); + } + + return true; + } + + return false; +} + + +// ************************************************************************* // diff --git a/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceTemplates.C b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceTemplates.C new file mode 100644 index 0000000000..11d7eed98c --- /dev/null +++ b/src/fvOptions/sources/derived/jouleHeatingSource/jouleHeatingSourceTemplates.C @@ -0,0 +1,147 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016-2017 OpenCFD Ltd. + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "emptyFvPatchField.H" + +template +void Foam::fv::jouleHeatingSource::initialiseSigma +( + const dictionary& dict, + autoPtr>& sigmaVsTPtr +) +{ + typedef GeometricField VolFieldType; + + if (dict.found("sigma")) + { + // Sigma to be defined using a Funcion1 type + sigmaVsTPtr = Function1::New("sigma", dict); + + tmp tsigma + ( + new VolFieldType + ( + IOobject + ( + typeName + ":sigma", + mesh_.time().timeName(), + mesh_, + IOobject::NO_READ, + IOobject::AUTO_WRITE + ), + mesh_, + dimensioned + ( + "0", + sqr(dimCurrent)/dimPower/dimLength, + Zero + ) + ) + ); + + mesh_.objectRegistry::store(tsigma.ptr()); + + Info<< " Conductivity 'sigma' read from dictionary as f(T)" + << nl << endl; + } + else + { + // Sigma to be defined by user input + tmp tsigma + ( + new VolFieldType + ( + IOobject + ( + typeName + ":sigma", + mesh_.time().timeName(), + mesh_, + IOobject::MUST_READ, + IOobject::AUTO_WRITE + ), + mesh_ + ) + ); + + mesh_.objectRegistry::store(tsigma.ptr()); + + Info<< " Conductivity 'sigma' read from file" << nl << endl; + } +} + + +template +const Foam::GeometricField& +Foam::fv::jouleHeatingSource::updateSigma +( + const autoPtr>& sigmaVsTPtr +) const +{ + typedef GeometricField VolFieldType; + + VolFieldType& sigma = + const_cast + ( + mesh_.lookupObject(typeName + ":sigma") + ); + + if (!sigmaVsTPtr.valid()) + { + // Electrical conductivity field, sigma, was specified by the user + return sigma; + } + + const volScalarField& T = mesh_.lookupObject(TName_); + + // Internal field + forAll(sigma, i) + { + sigma[i] = sigmaVsTPtr->value(T[i]); + } + + + // Boundary field + typename VolFieldType::Boundary& bf = sigma.boundaryFieldRef(); + forAll(bf, patchi) + { + fvPatchField& pf = bf[patchi]; + if (!isA>(pf)) + { + const scalarField& Tbf = T.boundaryField()[patchi]; + forAll(pf, facei) + { + pf[facei] = sigmaVsTPtr->value(Tbf[facei]); + } + } + } + + // Update processor patches + sigma.correctBoundaryConditions(); + + return sigma; +} + + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/T b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/T new file mode 100644 index 0000000000..302392cd2c --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/T @@ -0,0 +1,49 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: v1612+ | +| \\ / A nd | Web: www.OpenFOAM.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class volScalarField; + location "0/solid"; + object T; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +dimensions [ 0 0 0 1 0 0 0 ]; + +internalField uniform 500; + +boundaryField +{ + left + { + type fixedValue; + value uniform 500; + } + right + { + type fixedValue; + value uniform 500; + } + top + { + type zeroGradient; + } + bottom + { + type zeroGradient; + } + frontAndBack + { + type empty; + } +} + + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:V b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:V new file mode 100644 index 0000000000..407005dbd4 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:V @@ -0,0 +1,49 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: v1612+ | +| \\ / A nd | Web: www.OpenFOAM.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class volScalarField; + location "0/heater"; + object jouleHeatingSource:V; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +dimensions [ 1 2 -3 0 0 -1 0 ]; + +internalField uniform 0; + +boundaryField +{ + left + { + type fixedValue; + value uniform 1.5; + } + right + { + type fixedValue; + value uniform 0; + } + top + { + type zeroGradient; + } + bottom + { + type zeroGradient; + } + frontAndBack + { + type empty; + } +} + + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:sigma b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:sigma new file mode 100644 index 0000000000..b3acde6b36 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/jouleHeatingSource:sigma @@ -0,0 +1,47 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: v1612+ | +| \\ / A nd | Web: www.OpenFOAM.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class volScalarField; + location "0/heater"; + object jouleHeatingSource:sigma; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +dimensions [ -1 -3 3 0 0 2 0 ]; + +internalField uniform 127599.8469; + +boundaryField +{ + left + { + type zeroGradient; + } + right + { + type zeroGradient; + } + top + { + type zeroGradient; + } + bottom + { + type zeroGradient; + } + frontAndBack + { + type empty; + } +} + + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/p b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/p new file mode 100644 index 0000000000..d0b8fa4f65 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/0.orig/solid/p @@ -0,0 +1,36 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: v1612+ | +| \\ / A nd | Web: www.OpenFOAM.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class volScalarField; + location "0/solid"; + object p; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +dimensions [1 -1 -2 0 0 0 0]; + +internalField uniform 100000; + +boundaryField +{ + ".*" + { + type calculated; + value uniform 100000; + } + frontAndBack + { + type empty; + } +} + + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allclean b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allclean new file mode 100755 index 0000000000..31c0b764b5 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allclean @@ -0,0 +1,14 @@ +#!/bin/sh +cd ${0%/*} || exit 1 # Run from this directory + +# Source tutorial clean functions +. $WM_PROJECT_DIR/bin/tools/CleanFunctions + +cleanCase +rm -rf 0 + +foamCleanPolyMesh -region solid + +rm -f *.OpenFOAM OF_vs_ANALYTICAL.eps + +#------------------------------------------------------------------------------ diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun new file mode 100755 index 0000000000..98857416a9 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun @@ -0,0 +1,13 @@ +#!/bin/sh +cd ${0%/*} || exit 1 # Run from this directory + +# Source tutorial run functions +. $WM_PROJECT_DIR/bin/tools/RunFunctions + +./Allrun.pre + +runApplication $(getApplication) + +./createGraphs + +# ----------------------------------------------------------------------------- diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun-parallel b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun-parallel new file mode 100755 index 0000000000..b48e4c119d --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun-parallel @@ -0,0 +1,17 @@ +#!/bin/sh +cd ${0%/*} || exit 1 # Run from this directory + +# Source tutorial run functions +. $WM_PROJECT_DIR/bin/tools/RunFunctions + +./Allrun.pre + +runApplication -s solid decomposePar -region solid + +runParallel $(getApplication) + +runApplication -s solid reconstructPar -latestTime -region solid + +./createGraphs + +# ----------------------------------------------------------------------------- diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun.pre b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun.pre new file mode 100755 index 0000000000..c8198f9848 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/Allrun.pre @@ -0,0 +1,15 @@ +#!/bin/sh +cd ${0%/*} || exit 1 # Run from this directory + +# Source tutorial run functions +. $WM_PROJECT_DIR/bin/tools/RunFunctions + +# Create meshe +runApplication -s solid blockMesh -region solid + +# create dummy files for post-processing +paraFoam -touch -region solid + +restore0Dir + +# ----------------------------------------------------------------------------- diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/regionProperties b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/regionProperties new file mode 100644 index 0000000000..4b0d4cf1d5 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/regionProperties @@ -0,0 +1,24 @@ +/*--------------------------------*- C++ -*----------------------------------*\ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: plus | +| \\ / A nd | Web: www.OpenFOAM.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + location "constant"; + object regionProperties; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +regions +( + fluid () + solid (solid) +); + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/solid/thermophysicalProperties b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/solid/thermophysicalProperties new file mode 100644 index 0000000000..a24fa3e3ab --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/constant/solid/thermophysicalProperties @@ -0,0 +1,54 @@ +/*--------------------------------*- C++ -*----------------------------------* \ +| ========= | | +| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | +| \\ / O peration | Version: plus | +| \\ / A nd | Web: www.OpenFOAM.com | +| \\/ M anipulation | | +\*---------------------------------------------------------------------------*/ +FoamFile +{ + version 2.0; + format ascii; + class dictionary; + object thermophysicalProperties; +} +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +thermoType +{ + type heSolidThermo; + mixture pureMixture; + transport constIso; + thermo hConst; + equationOfState rhoConst; + specie specie; + energy sensibleEnthalpy; +} + +mixture +{ + specie + { + nMoles 1; + molWeight 12; + } + + transport + { + kappa 200; + } + + thermodynamics + { + Hf 0; + Cp 700; + } + + equationOfState + { + rho 8000; + } +} + + +// ************************************************************************* // diff --git a/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/createGraphs b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/createGraphs new file mode 100755 index 0000000000..04bbc57ea0 --- /dev/null +++ b/tutorials/heatTransfer/chtMultiRegionSimpleFoam/jouleHeatingSolid/createGraphs @@ -0,0 +1,87 @@ +#!/bin/sh +#------------------------------------------------------------------------------ +# ========= | +# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox +# \\ / O peration | +# \\ / A nd | Copyright (C) 2017 OpenCFD Ltd. +# \\/ M anipulation | +#------------------------------------------------------------------------------- +# License +# This file is part of OpenFOAM. +# +# OpenFOAM is free software: you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# OpenFOAM is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# +# You should have received a copy of the GNU General Public License +# along with OpenFOAM. If not, see . +# +# Script +# createGraphs +# +# Description +# Creates .eps graph of OpenFOAM results vs analytical solution for the +# Joule heating case +# +#------------------------------------------------------------------------------ + +cd ${0%/*} || exit 1 # Run from this directory + +# Stop on first error +set -e + +# test if gnuplot exists on the system +if ! which gnuplot > /dev/null 2>&1 +then + echo "FOAM FATAL ERROR: gnuplot not found - skipping graph creation" >&2 + exit 1 +fi + + +echo "Creating graph" +OFDATA='postProcessing/sample1/solid/20000/centreLine_T_jouleHeatingSource:V_jouleHeatingSource:sigma.xy' + +if [ ! -f "$OFDATA" ] +then + echo "FOAM FATAL ERROR: OpenFOAM results not available in $OFDATA" >&2 + exit 1 +fi + +gnuplot< Date: Fri, 9 Jun 2017 10:53:37 +0100 Subject: [PATCH 07/22] TUT: Added min/max(p) function object --- .../engineFoam/kivaTest/system/controlDict | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/tutorials/combustion/engineFoam/kivaTest/system/controlDict b/tutorials/combustion/engineFoam/kivaTest/system/controlDict index 8418e8b269..57744257b5 100644 --- a/tutorials/combustion/engineFoam/kivaTest/system/controlDict +++ b/tutorials/combustion/engineFoam/kivaTest/system/controlDict @@ -59,10 +59,6 @@ functions libs ("libutilityFunctionObjects.so"); name setDeltaT; - code - #{ - #}; - codeExecute #{ const Time& runTime = mesh().time(); @@ -75,6 +71,14 @@ functions } #}; } + + fieldMinMax + { + type fieldMinMax; + libs ("libfieldFunctionObjects.so"); + fields (p); + } } + // ************************************************************************* // From 24d1e50f45bc2b669a38af0b35c5ce72c236a0b7 Mon Sep 17 00:00:00 2001 From: Andrew Heather Date: Mon, 12 Jun 2017 09:18:22 +0100 Subject: [PATCH 08/22] BUG: LimitedScheme - corrected oriented flag. Fixes #493 --- .../LimitedScheme/LimitedScheme.C | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/LimitedScheme/LimitedScheme.C b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/LimitedScheme/LimitedScheme.C index efe01350d4..9c19472a1f 100644 --- a/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/LimitedScheme/LimitedScheme.C +++ b/src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/LimitedScheme/LimitedScheme.C @@ -37,18 +37,19 @@ void Foam::LimitedScheme::calcLimiter surfaceScalarField& limiterField ) const { + typedef GeometricField + VolFieldType; + + typedef GeometricField + GradVolFieldType; + const fvMesh& mesh = this->mesh(); - tmp> - tlPhi = LimitFunc()(phi); + tmp tlPhi = LimitFunc()(phi); + const VolFieldType& lPhi = tlPhi(); - const GeometricField& - lPhi = tlPhi(); - - tmp> - tgradc(fvc::grad(lPhi)); - const GeometricField& - gradc = tgradc(); + tmp tgradc(fvc::grad(lPhi)); + const GradVolFieldType& gradc = tgradc(); const surfaceScalarField& CDweights = mesh.surfaceInterpolation::weights(); @@ -76,8 +77,7 @@ void Foam::LimitedScheme::calcLimiter ); } - surfaceScalarField::Boundary& bLim = - limiterField.boundaryFieldRef(); + surfaceScalarField::Boundary& bLim = limiterField.boundaryFieldRef(); forAll(bLim, patchi) { @@ -128,6 +128,8 @@ void Foam::LimitedScheme::calcLimiter pLim = 1.0; } } + + limiterField.setOriented(); } From d27d69e3f7228e98a517917702c4c32f86a15201 Mon Sep 17 00:00:00 2001 From: Henry Weller Date: Tue, 9 May 2017 09:32:25 +0100 Subject: [PATCH 09/22] reconstructParMesh: Use tree method to improve speed and scaling Based on development contributed by Paul Edwards, Intel. Conflicts: applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C --- .../reconstructParMesh/reconstructParMesh.C | 260 +++++++++++++----- 1 file changed, 189 insertions(+), 71 deletions(-) diff --git a/applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C b/applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C index ef68688bf7..b1fa2872af 100644 --- a/applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C +++ b/applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C @@ -87,8 +87,11 @@ static void renumber autoPtr determineCoupledFaces ( const bool fullMatch, - const label proci, + const label masterMeshProcStart, + const label masterMeshProcEnd, const polyMesh& masterMesh, + const label meshToAddProcStart, + const label meshToAddProcEnd, const polyMesh& meshToAdd, const scalar mergeDist ) @@ -113,7 +116,6 @@ autoPtr determineCoupledFaces const polyBoundaryMesh& masterPatches = masterMesh.boundaryMesh(); - const string toProcString("to" + name(proci)); DynamicList