9bf34679bd
With the selection of the Boussinesq equation of state the general buoyancy solvers buoyantSimpleFoam and buoyantPimpleFoam can be used instead of the specialised Boussinesq solvers avoiding the need for special implementation of thermal and pressure boundary conditions and providing support for radiation and fvOptions which would not have been feasible or practical in the Boussinesq solvers. Other incompressible equations of state are also supported; for most gaseous problems the incompressiblePerfectGas equation of state is likely to be more accurate than the Boussinesq equation of state. The buoyantBoussinesq[SP]impleFoam tutorials have been updated and moved to the corresponding buoyant[SP]impleFoam directories.
6573 lines
206 KiB
Bash
6573 lines
206 KiB
Bash
#----------------------------------*-sh-*--------------------------------------
|
|
# ========= |
|
|
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
# \\ / O peration | Website: https://openfoam.org
|
|
# \\ / A nd | Copyright (C) 2017-2019 OpenFOAM Foundation
|
|
# \\/ 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 <http://www.gnu.org/licenses/>.
|
|
#
|
|
# File
|
|
# etc/config.sh/bash_completion
|
|
#
|
|
# Description
|
|
# Bash [TAB] completion file from OpenFOAM
|
|
# Sourced from /etc/bashrc
|
|
#
|
|
#------------------------------------------------------------------------------
|
|
|
|
_adiabaticFlameT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _adiabaticFlameT_ adiabaticFlameT
|
|
|
|
_adjointShapeOptimizationFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _adjointShapeOptimizationFoam_ adjointShapeOptimizationFoam
|
|
|
|
_ansysToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _ansysToFoam_ ansysToFoam
|
|
|
|
_applyBoundaryLayer_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -Cbl -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc -writenut -ybl"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-Cbl|-hostRoots|-roots|-ybl)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _applyBoundaryLayer_ applyBoundaryLayer
|
|
|
|
_attachMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _attachMesh_ attachMesh
|
|
|
|
_autoPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _autoPatch_ autoPatch
|
|
|
|
_autoRefineMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _autoRefineMesh_ autoRefineMesh
|
|
|
|
_blockMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-blockTopology -case -dict -doc -fileHandler -help -noClean -noFunctionObjects -region -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _blockMesh_ blockMesh
|
|
|
|
_boundaryFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _boundaryFoam_ boundaryFoam
|
|
|
|
_boxTurb_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _boxTurb_ boxTurb
|
|
|
|
_buoyantPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantPimpleFoam_ buoyantPimpleFoam
|
|
|
|
_buoyantSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantSimpleFoam_ buoyantSimpleFoam
|
|
|
|
_cavitatingDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _cavitatingDyMFoam_ cavitatingDyMFoam
|
|
|
|
_cavitatingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _cavitatingFoam_ cavitatingFoam
|
|
|
|
_cfx4ToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _cfx4ToFoam_ cfx4ToFoam
|
|
|
|
_changeDictionary_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -disablePatchGroups -doc -enableFunctionEntries -fileHandler -help -hostRoots -instance -latestTime -literalRE -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -subDict -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-instance|-region|-roots|-subDict)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _changeDictionary_ changeDictionary
|
|
|
|
_checkMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allGeometry -allTopology -case -constant -doc -fileHandler -help -hostRoots -latestTime -meshQuality -newTimes -noFunctionObjects -noTopology -noZero -parallel -region -roots -srcDoc -time -writeSets"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots|-writeSets)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _checkMesh_ checkMesh
|
|
|
|
_chemFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -postProcess -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chemFoam_ chemFoam
|
|
|
|
_chemkinToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -newFormat -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chemkinToFoam_ chemkinToFoam
|
|
|
|
_chtMultiRegionFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chtMultiRegionFoam_ chtMultiRegionFoam
|
|
|
|
_coalChemistryFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _coalChemistryFoam_ coalChemistryFoam
|
|
|
|
_coldEngineFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _coldEngineFoam_ coldEngineFoam
|
|
|
|
_collapseEdges_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -collapseFaces -collapseFaceSet -constant -dict -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-collapseFaceSet|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _collapseEdges_ collapseEdges
|
|
|
|
_combinePatchFaces_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -concaveAngle -doc -fileHandler -help -hostRoots -meshQuality -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-concaveAngle|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _combinePatchFaces_ combinePatchFaces
|
|
|
|
_compressibleInterDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleInterDyMFoam_ compressibleInterDyMFoam
|
|
|
|
_compressibleInterFilmFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleInterFilmFoam_ compressibleInterFilmFoam
|
|
|
|
_compressibleInterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleInterFoam_ compressibleInterFoam
|
|
|
|
_compressibleMultiphaseInterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleMultiphaseInterFoam_ compressibleMultiphaseInterFoam
|
|
|
|
_createBaffles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _createBaffles_ createBaffles
|
|
|
|
_createExternalCoupledPatchGeometry_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _createExternalCoupledPatchGeometry_ createExternalCoupledPatchGeometry
|
|
|
|
_createPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _createPatch_ createPatch
|
|
|
|
_datToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _datToFoam_ datToFoam
|
|
|
|
_decomposePar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allRegions -case -cellDist -constant -copyUniform -copyZero -dict -doc -fields -fileHandler -force -help -ifRequired -latestTime -newTimes -noFunctionObjects -noSets -noZero -region -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-dict|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _decomposePar_ decomposePar
|
|
|
|
_deformedGeom_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _deformedGeom_ deformedGeom
|
|
|
|
_dnsFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dnsFoam_ dnsFoam
|
|
|
|
_DPMDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _DPMDyMFoam_ DPMDyMFoam
|
|
|
|
_DPMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _DPMFoam_ DPMFoam
|
|
|
|
_driftFluxFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _driftFluxFoam_ driftFluxFoam
|
|
|
|
_dsmcFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dsmcFoam_ dsmcFoam
|
|
|
|
_dsmcInitialise_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dsmcInitialise_ dsmcInitialise
|
|
|
|
_electrostaticFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _electrostaticFoam_ electrostaticFoam
|
|
|
|
_engineCompRatio_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _engineCompRatio_ engineCompRatio
|
|
|
|
_engineFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _engineFoam_ engineFoam
|
|
|
|
_engineSwirl_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _engineSwirl_ engineSwirl
|
|
|
|
_equilibriumCO_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _equilibriumCO_ equilibriumCO
|
|
|
|
_equilibriumFlameT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _equilibriumFlameT_ equilibriumFlameT
|
|
|
|
_extrude2DMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _extrude2DMesh_ extrude2DMesh
|
|
|
|
_extrudeMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _extrudeMesh_ extrudeMesh
|
|
|
|
_extrudeToRegionMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _extrudeToRegionMesh_ extrudeToRegionMesh
|
|
|
|
_faceAgglomerate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _faceAgglomerate_ faceAgglomerate
|
|
|
|
_financialFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _financialFoam_ financialFoam
|
|
|
|
_fireFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _fireFoam_ fireFoam
|
|
|
|
_flattenMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _flattenMesh_ flattenMesh
|
|
|
|
_fluent3DMeshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cubit -doc -fileHandler -help -ignoreCellGroups -ignoreFaceGroups -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-ignoreCellGroups|-ignoreFaceGroups|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-ignoreCellGroups|-ignoreFaceGroups|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _fluent3DMeshToFoam_ fluent3DMeshToFoam
|
|
|
|
_fluentMeshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-2D -case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc -writeSets -writeZones"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-2D|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-2D|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _fluentMeshToFoam_ fluentMeshToFoam
|
|
|
|
_foamDataToFluent_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamDataToFluent_ foamDataToFluent
|
|
|
|
_foamDictionary_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-add -diff -disableFunctionEntries -doc -entry -expand -help -includes -keywords -remove -set -srcDoc -value"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-add|-diff|-entry|-set)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-add|-diff|-entry|-set) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamDictionary_ foamDictionary
|
|
|
|
_foamFormatConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noConstant -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamFormatConvert_ foamFormatConvert
|
|
|
|
_foamListTimes_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -processor -rm -srcDoc -time -withZero"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamListTimes_ foamListTimes
|
|
|
|
_foamMeshToFluent_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamMeshToFluent_ foamMeshToFluent
|
|
|
|
_foamSetupCHT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamSetupCHT_ foamSetupCHT
|
|
|
|
_foamToEnsight_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -case -cellZone -constant -doc -faceZones -fields -fileHandler -help -hostRoots -latestTime -newTimes -nodeValues -noFunctionObjects -noPatches -noZero -parallel -patches -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-cellZone|-faceZones|-fields|-hostRoots|-patches|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToEnsight_ foamToEnsight
|
|
|
|
_foamToEnsightParts_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -case -constant -doc -fileHandler -help -index -latestTime -name -newTimes -noFunctionObjects -noMesh -noZero -srcDoc -time -width"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-index|-name|-width)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToEnsightParts_ foamToEnsightParts
|
|
|
|
_foamToGMV_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToGMV_ foamToGMV
|
|
|
|
_foamToStarMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noBnd -noFunctionObjects -noZero -scale -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToStarMesh_ foamToStarMesh
|
|
|
|
_foamToSurface_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -scale -srcDoc -time -tri"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToSurface_ foamToSurface
|
|
|
|
_foamToTetDualMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -noFunctionObjects -noZero -overwrite -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToTetDualMesh_ foamToTetDualMesh
|
|
|
|
_foamToVTK_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allPatches -ascii -case -cellSet -constant -doc -excludePatches -faceSet -fields -fileHandler -help -hostRoots -latestTime -nearCellValue -newTimes -noFaceZones -noFunctionObjects -noInternal -noLinks -noPointValues -noZero -parallel -pointSet -poly -region -roots -srcDoc -surfaceFields -time -useTimeName"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-cellSet|-excludePatches|-faceSet|-fields|-hostRoots|-pointSet|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToVTK_ foamToVTK
|
|
|
|
_foamUpgradeCyclics_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -enableFunctionEntries -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -test -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamUpgradeCyclics_ foamUpgradeCyclics
|
|
|
|
_foamyHexMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -checkGeometry -conformationOnly -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamyHexMesh_ foamyHexMesh
|
|
|
|
_foamyQuadMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -pointsFile -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-pointsFile)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamyQuadMesh_ foamyQuadMesh
|
|
|
|
_gambitToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _gambitToFoam_ gambitToFoam
|
|
|
|
_gmshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -keepOrientation -noFunctionObjects -region -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-region|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _gmshToFoam_ gmshToFoam
|
|
|
|
_icoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _icoFoam_ icoFoam
|
|
|
|
_icoUncoupledKinematicParcelDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _icoUncoupledKinematicParcelDyMFoam_ icoUncoupledKinematicParcelDyMFoam
|
|
|
|
_icoUncoupledKinematicParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _icoUncoupledKinematicParcelFoam_ icoUncoupledKinematicParcelFoam
|
|
|
|
_ideasUnvToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -dump -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _ideasUnvToFoam_ ideasUnvToFoam
|
|
|
|
_insideCells_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _insideCells_ insideCells
|
|
|
|
_interFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interFoam_ interFoam
|
|
|
|
_interMixingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interMixingFoam_ interMixingFoam
|
|
|
|
_interPhaseChangeDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interPhaseChangeDyMFoam_ interPhaseChangeDyMFoam
|
|
|
|
_interPhaseChangeFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interPhaseChangeFoam_ interPhaseChangeFoam
|
|
|
|
_kivaToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -file -fileHandler -help -noFunctionObjects -srcDoc -version -zHeadMin"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-file|-version|-zHeadMin)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _kivaToFoam_ kivaToFoam
|
|
|
|
_laplacianFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _laplacianFoam_ laplacianFoam
|
|
|
|
_magneticFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -HdotGradH -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noB -noFunctionObjects -noH -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _magneticFoam_ magneticFoam
|
|
|
|
_mapFields_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -consistent -doc -fileHandler -help -mapMethod -noFunctionObjects -parallelSource -parallelTarget -sourceRegion -sourceTime -srcDoc -subtract -targetRegion"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-mapMethod|-sourceRegion|-sourceTime|-targetRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-mapMethod|-sourceRegion|-sourceTime|-targetRegion|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mapFields_ mapFields
|
|
|
|
_mapFieldsPar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -consistent -doc -fields -fileHandler -help -hostRoots -mapMethod -noFunctionObjects -noLagrangian -parallel -roots -sourceRegion -sourceTime -srcDoc -subtract -targetRegion"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-fields|-hostRoots|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-fields|-hostRoots|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mapFieldsPar_ mapFieldsPar
|
|
|
|
_mdEquilibrationFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mdEquilibrationFoam_ mdEquilibrationFoam
|
|
|
|
_mdFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mdFoam_ mdFoam
|
|
|
|
_mdInitialise_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mdInitialise_ mdInitialise
|
|
|
|
_mergeMeshes_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-addRegion -case -doc -fileHandler -help -masterRegion -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-addRegion|-masterRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mergeMeshes_ mergeMeshes
|
|
|
|
_mergeOrSplitBaffles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -detectOnly -doc -fields -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -split -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mergeOrSplitBaffles_ mergeOrSplitBaffles
|
|
|
|
_mhdFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mhdFoam_ mhdFoam
|
|
|
|
_mirrorMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mirrorMesh_ mirrorMesh
|
|
|
|
_mixtureAdiabaticFlameT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mixtureAdiabaticFlameT_ mixtureAdiabaticFlameT
|
|
|
|
_modifyMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _modifyMesh_ modifyMesh
|
|
|
|
_moveDynamicMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -checkAMI -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveDynamicMesh_ moveDynamicMesh
|
|
|
|
_moveEngineMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveEngineMesh_ moveEngineMesh
|
|
|
|
_moveMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveMesh_ moveMesh
|
|
|
|
_MPPICDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _MPPICDyMFoam_ MPPICDyMFoam
|
|
|
|
_MPPICFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _MPPICFoam_ MPPICFoam
|
|
|
|
_mshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hex -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mshToFoam_ mshToFoam
|
|
|
|
_multiphaseEulerFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _multiphaseEulerFoam_ multiphaseEulerFoam
|
|
|
|
_multiphaseInterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _multiphaseInterFoam_ multiphaseInterFoam
|
|
|
|
_netgenNeutralToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-hostRoots|-roots|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _netgenNeutralToFoam_ netgenNeutralToFoam
|
|
|
|
_noise_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _noise_ noise
|
|
|
|
_nonNewtonianIcoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _nonNewtonianIcoFoam_ nonNewtonianIcoFoam
|
|
|
|
_objToVTK_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _objToVTK_ objToVTK
|
|
|
|
_orientFaceZone_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _orientFaceZone_ orientFaceZone
|
|
|
|
_particleTracks_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _particleTracks_ particleTracks
|
|
|
|
_patchSummary_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -expand -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _patchSummary_ patchSummary
|
|
|
|
_pdfPlot_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pdfPlot_ pdfPlot
|
|
|
|
_PDRFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _PDRFoam_ PDRFoam
|
|
|
|
_PDRMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _PDRMesh_ PDRMesh
|
|
|
|
_pimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pimpleFoam_ pimpleFoam
|
|
|
|
_pisoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pisoFoam_ pisoFoam
|
|
|
|
_plot3dToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-2D -case -doc -fileHandler -help -noBlank -noFunctionObjects -scale -singleBlock -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-2D|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-2D|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _plot3dToFoam_ plot3dToFoam
|
|
|
|
_polyDualMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -concaveMultiCells -doc -doNotPreserveFaceZones -fileHandler -help -noFunctionObjects -overwrite -splitAllFaces -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _polyDualMesh_ polyDualMesh
|
|
|
|
_porousSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _porousSimpleFoam_ porousSimpleFoam
|
|
|
|
_postChannel_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _postChannel_ postChannel
|
|
|
|
_postProcess_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -field -fields -fileHandler -func -funcs -help -hostRoots -latestTime -list -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-field|-fields|-func|-funcs|-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _postProcess_ postProcess
|
|
|
|
_potentialFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -initialiseUBCs -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -pName -roots -srcDoc -withFunctionObjects -writep -writePhi"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-pName|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _potentialFoam_ potentialFoam
|
|
|
|
_potentialFreeSurfaceDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _potentialFreeSurfaceDyMFoam_ potentialFreeSurfaceDyMFoam
|
|
|
|
_potentialFreeSurfaceFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _potentialFreeSurfaceFoam_ potentialFreeSurfaceFoam
|
|
|
|
_reactingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingFoam_ reactingFoam
|
|
|
|
_reactingMultiphaseEulerFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingMultiphaseEulerFoam_ reactingMultiphaseEulerFoam
|
|
|
|
_reactingParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingParcelFoam_ reactingParcelFoam
|
|
|
|
_reactingTwoPhaseEulerFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingTwoPhaseEulerFoam_ reactingTwoPhaseEulerFoam
|
|
|
|
_reconstructPar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="- -allRegions -case -constant -doc -fields -fileHandler -help -lagrangianFields -latestTime -newTimes -noFields -noFunctionObjects -noLagrangian -noSets -noZero -region -srcDoc -time -withZero"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-fields|-lagrangianFields|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reconstructPar_ reconstructPar
|
|
|
|
_reconstructParMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allRegions -case -cellDist -constant -doc -fileHandler -fullMatch -help -latestTime -mergeTol -newTimes -noFunctionObjects -noZero -region -srcDoc -time -withZero"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-mergeTol|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reconstructParMesh_ reconstructParMesh
|
|
|
|
_redistributePar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -mergeTol -newTimes -noFunctionObjects -noZero -overwrite -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-mergeTol|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _redistributePar_ redistributePar
|
|
|
|
_refineHexMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -minSet -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refineHexMesh_ refineHexMesh
|
|
|
|
_refinementLevel_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -readLevel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refinementLevel_ refinementLevel
|
|
|
|
_refineMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refineMesh_ refineMesh
|
|
|
|
_refineWallLayer_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc -useSet"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-useSet)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refineWallLayer_ refineWallLayer
|
|
|
|
_removeFaces_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _removeFaces_ removeFaces
|
|
|
|
_renumberMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -fileHandler -frontWidth -help -hostRoots -latestTime -noFields -noFunctionObjects -noZero -overwrite -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _renumberMesh_ renumberMesh
|
|
|
|
_rhoCentralDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoCentralDyMFoam_ rhoCentralDyMFoam
|
|
|
|
_rhoCentralFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoCentralFoam_ rhoCentralFoam
|
|
|
|
_rhoPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoPimpleFoam_ rhoPimpleFoam
|
|
|
|
_rhoPorousSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoPorousSimpleFoam_ rhoPorousSimpleFoam
|
|
|
|
_rhoReactingBuoyantFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoReactingBuoyantFoam_ rhoReactingBuoyantFoam
|
|
|
|
_rhoReactingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoReactingFoam_ rhoReactingFoam
|
|
|
|
_rhoSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoSimpleFoam_ rhoSimpleFoam
|
|
|
|
_rotateMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rotateMesh_ rotateMesh
|
|
|
|
_sammToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _sammToFoam_ sammToFoam
|
|
|
|
_scalarTransportFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _scalarTransportFoam_ scalarTransportFoam
|
|
|
|
_selectCells_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _selectCells_ selectCells
|
|
|
|
_setFields_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setFields_ setFields
|
|
|
|
_setSet_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-batch -case -constant -doc -fileHandler -help -hostRoots -latestTime -loop -newTimes -noFunctionObjects -noSync -noVTK -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-batch)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setSet_ setSet
|
|
|
|
_setsToZones_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFlipMap -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setsToZones_ setsToZones
|
|
|
|
_setWaves_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-alpha -case -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -roots -srcDoc -time -U"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-U|-alpha|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setWaves_ setWaves
|
|
|
|
_shallowWaterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _shallowWaterFoam_ shallowWaterFoam
|
|
|
|
_simpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _simpleFoam_ simpleFoam
|
|
|
|
_simpleReactingParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _simpleReactingParcelFoam_ simpleReactingParcelFoam
|
|
|
|
_singleCellMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _singleCellMesh_ singleCellMesh
|
|
|
|
_smapToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _smapToFoam_ smapToFoam
|
|
|
|
_snappyHexMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -checkGeometry -dict -doc -fileHandler -help -hostRoots -noFunctionObjects -outFile -overwrite -parallel -patches -roots -srcDoc -surfaceSimplify"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict|-outFile)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-patches|-roots|-surfaceSimplify)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _snappyHexMesh_ snappyHexMesh
|
|
|
|
_solidDisplacementFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _solidDisplacementFoam_ solidDisplacementFoam
|
|
|
|
_solidEquilibriumDisplacementFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _solidEquilibriumDisplacementFoam_ solidEquilibriumDisplacementFoam
|
|
|
|
_sonicFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _sonicFoam_ sonicFoam
|
|
|
|
_sonicLiquidFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _sonicLiquidFoam_ sonicLiquidFoam
|
|
|
|
_splitCells_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -geometry -help -noFunctionObjects -overwrite -set -srcDoc -tol"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-set|-tol)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitCells_ splitCells
|
|
|
|
_splitMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitMesh_ splitMesh
|
|
|
|
_splitMeshRegions_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-blockedFaces -case -cellZones -cellZonesFileOnly -cellZonesOnly -defaultRegionName -detectOnly -doc -fileHandler -help -hostRoots -insidePoint -largestOnly -makeCellZones -noFunctionObjects -overwrite -parallel -prefixRegion -region -roots -sloppyCellZones -srcDoc -useFaceZones"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-cellZonesFileOnly)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-blockedFaces|-defaultRegionName|-hostRoots|-insidePoint|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitMeshRegions_ splitMeshRegions
|
|
|
|
_sprayDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _sprayDyMFoam_ sprayDyMFoam
|
|
|
|
_sprayFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _sprayFoam_ sprayFoam
|
|
|
|
_SRFPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _SRFPimpleFoam_ SRFPimpleFoam
|
|
|
|
_SRFSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _SRFSimpleFoam_ SRFSimpleFoam
|
|
|
|
_star3ToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _star3ToFoam_ star3ToFoam
|
|
|
|
_star4ToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -case -doc -fileHandler -help -noFunctionObjects -scale -solids -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _star4ToFoam_ star4ToFoam
|
|
|
|
_steadyParticleTracks_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -fileHandler -help -latestTime -newTimes -noFunctionObjects -noZero -region -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _steadyParticleTracks_ steadyParticleTracks
|
|
|
|
_stitchMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -overwrite -partial -perfect -region -srcDoc -toleranceDict"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-toleranceDict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _stitchMesh_ stitchMesh
|
|
|
|
_subsetMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -overwrite -parallel -patch -region -resultTime -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-patch|-region|-resultTime|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _subsetMesh_ subsetMesh
|
|
|
|
_surfaceAdd_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -mergeRegions -points -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-points)
|
|
opts="" ; extra="-d -f" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceAdd_ surfaceAdd
|
|
|
|
_surfaceAutoPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceAutoPatch_ surfaceAutoPatch
|
|
|
|
_surfaceBooleanFeatures_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -invertedSpace -noFunctionObjects -perturb -srcDoc -surf1Baffle -surf2Baffle"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceBooleanFeatures_ surfaceBooleanFeatures
|
|
|
|
_surfaceCheck_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-blockMesh -checkSelfIntersection -doc -help -splitNonManifold -srcDoc -verbose"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceCheck_ surfaceCheck
|
|
|
|
_surfaceClean_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -noClean -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceClean_ surfaceClean
|
|
|
|
_surfaceCoarsen_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceCoarsen_ surfaceCoarsen
|
|
|
|
_surfaceConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-clean -doc -group -help -scale -srcDoc -writePrecision"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-scale|-writePrecision)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-writePrecision) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceConvert_ surfaceConvert
|
|
|
|
_surfaceFeatureConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatureConvert_ surfaceFeatureConvert
|
|
|
|
_surfaceFeatureExtract_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatureExtract_ surfaceFeatureExtract
|
|
|
|
_surfaceFeatures_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatures_ surfaceFeatures
|
|
|
|
_surfaceFind_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc -x -y -z"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-x|-y|-z)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-x|-y|-z) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFind_ surfaceFind
|
|
|
|
_surfaceHookUp_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceHookUp_ surfaceHookUp
|
|
|
|
_surfaceInertia_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-density -doc -help -referencePoint -shellProperties -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-density|-referencePoint)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-density|-referencePoint) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceInertia_ surfaceInertia
|
|
|
|
_surfaceLambdaMuSmooth_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -featureFile -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-featureFile)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-featureFile) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceLambdaMuSmooth_ surfaceLambdaMuSmooth
|
|
|
|
_surfaceMeshConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -clean -dict -doc -fileHandler -from -help -noFunctionObjects -scaleIn -scaleOut -srcDoc -to -tri"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-from|-scaleIn|-scaleOut|-to|-case|-dict|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshConvert_ surfaceMeshConvert
|
|
|
|
_surfaceMeshConvertTesting_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-clean -doc -help -orient -scale -srcDoc -surfMesh -triFace -triSurface -unsorted"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshConvertTesting_ surfaceMeshConvertTesting
|
|
|
|
_surfaceMeshExport_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -clean -dict -doc -fileHandler -from -help -name -noFunctionObjects -scaleIn -scaleOut -srcDoc -to"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-name|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshExport_ surfaceMeshExport
|
|
|
|
_surfaceMeshImport_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -clean -dict -doc -fileHandler -from -help -name -noFunctionObjects -scaleIn -scaleOut -srcDoc -to"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-name|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-from|-name|-scaleIn|-scaleOut|-to|-case|-dict|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshImport_ surfaceMeshImport
|
|
|
|
_surfaceMeshInfo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-areas -case -doc -fileHandler -help -noFunctionObjects -scale -srcDoc -xml"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshInfo_ surfaceMeshInfo
|
|
|
|
_surfaceMeshTriangulate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -excludeProcPatches -faceZones -fileHandler -help -hostRoots -noFunctionObjects -parallel -patches -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-faceZones|-hostRoots|-patches|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshTriangulate_ surfaceMeshTriangulate
|
|
|
|
_surfaceOrient_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -inside -srcDoc -usePierceTest"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceOrient_ surfaceOrient
|
|
|
|
_surfacePointMerge_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfacePointMerge_ surfacePointMerge
|
|
|
|
_surfaceRedistributePar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -keepNonMapped -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-hostRoots|-roots|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceRedistributePar_ surfaceRedistributePar
|
|
|
|
_surfaceRefineRedGreen_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceRefineRedGreen_ surfaceRefineRedGreen
|
|
|
|
_surfaceSplitByPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSplitByPatch_ surfaceSplitByPatch
|
|
|
|
_surfaceSplitByTopology_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSplitByTopology_ surfaceSplitByTopology
|
|
|
|
_surfaceSplitNonManifolds_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-debug -doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSplitNonManifolds_ surfaceSplitNonManifolds
|
|
|
|
_surfaceSubset_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSubset_ surfaceSubset
|
|
|
|
_surfaceToPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -faceSet -fileHandler -help -noFunctionObjects -srcDoc -tol"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-faceSet|-tol)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-faceSet|-tol|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceToPatch_ surfaceToPatch
|
|
|
|
_surfaceTransformPoints_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -rollPitchYaw -rotate -scale -srcDoc -translate -yawPitchRoll"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-rollPitchYaw|-rotate|-scale|-translate|-yawPitchRoll)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-rollPitchYaw|-rotate|-scale|-translate|-yawPitchRoll) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceTransformPoints_ surfaceTransformPoints
|
|
|
|
_temporalInterpolate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -divisions -doc -fields -fileHandler -help -hostRoots -interpolationType -latestTime -newTimes -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-divisions|-fields|-hostRoots|-interpolationType|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _temporalInterpolate_ temporalInterpolate
|
|
|
|
_tetgenToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFaceFile -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _tetgenToFoam_ tetgenToFoam
|
|
|
|
_thermoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _thermoFoam_ thermoFoam
|
|
|
|
_topoSet_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noSync -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _topoSet_ topoSet
|
|
|
|
_transformPoints_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allRegions -case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -rollPitchYaw -roots -rotate -rotateFields -scale -srcDoc -translate -yawPitchRoll"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-rollPitchYaw|-roots|-rotate|-scale|-translate|-yawPitchRoll)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _transformPoints_ transformPoints
|
|
|
|
_twoLiquidMixingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _twoLiquidMixingFoam_ twoLiquidMixingFoam
|
|
|
|
_twoPhaseEulerFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _twoPhaseEulerFoam_ twoPhaseEulerFoam
|
|
|
|
_uncoupledKinematicParcelDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _uncoupledKinematicParcelDyMFoam_ uncoupledKinematicParcelDyMFoam
|
|
|
|
_uncoupledKinematicParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cloudName -doc -fileHandler -help -hostRoots -listFunctionObjects -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-cloudName|-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _uncoupledKinematicParcelFoam_ uncoupledKinematicParcelFoam
|
|
|
|
_viewFactorsGen_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _viewFactorsGen_ viewFactorsGen
|
|
|
|
_vtkUnstructuredToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _vtkUnstructuredToFoam_ vtkUnstructuredToFoam
|
|
|
|
_wallFunctionTable_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wallFunctionTable_ wallFunctionTable
|
|
|
|
_writeMeshObj_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cell -cellSet -constant -doc -face -faceSet -fileHandler -help -hostRoots -latestTime -newTimes -noFunctionObjects -noZero -parallel -patchEdges -patchFaces -point -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-cell|-cellSet|-face|-faceSet|-hostRoots|-point|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _writeMeshObj_ writeMeshObj
|
|
|
|
_XiEngineFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _XiEngineFoam_ XiEngineFoam
|
|
|
|
_XiFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -listFunctionObjects -listFvOptions -listRegisteredSwitches -listScalarBCs -listSwitches -listTurbulenceModels -listUnsetSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _XiFoam_ XiFoam
|
|
|
|
_zipUpMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _zipUpMesh_ zipUpMesh
|
|
|
|
_foamCleanPath_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -strip"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanPath_ foamCleanPath
|
|
|
|
_foamCleanPolyMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -help -region"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanPolyMesh_ foamCleanPolyMesh
|
|
|
|
_foamCleanTutorials_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanTutorials_ foamCleanTutorials
|
|
|
|
_foamCloneCase_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -latestTime -no-orig -no-scripts -template"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCloneCase_ foamCloneCase
|
|
|
|
_foamCreateVideo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-dir -fps -help -image -out -start -webm"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-dir)
|
|
opts="" ; extra="-d" ;;
|
|
-fps|-image|-out|-start)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCreateVideo_ foamCreateVideo
|
|
|
|
_foamEtcFile_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -help -list -mode -prefix -quiet -silent -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-prefix)
|
|
opts="" ; extra="-d" ;;
|
|
-mode|-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamEtcFile_ foamEtcFile
|
|
|
|
_foamExec_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -prefix -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-prefix)
|
|
opts="" ; extra="-d" ;;
|
|
-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamExec_ foamExec
|
|
|
|
_foamGet_ ()
|
|
{
|
|
_searchDirs () {
|
|
_dirs="\
|
|
${HOME}/.OpenFOAM/$WM_PROJECT_VERSION \
|
|
${HOME}/.OpenFOAM"
|
|
[ -n "$WM_PROJECT_SITE" ] && _dirs=" \
|
|
$WM_PROJECT_SITE/$WM_PROJECT_VERSION/etc \
|
|
$WM_PROJECT_SITE/etc"
|
|
_dirs+=" \
|
|
$WM_PROJECT_INST_DIR/site/$WM_PROJECT_VERSION/etc \
|
|
$WM_PROJECT_INST_DIR/site/etc \
|
|
$FOAM_ETC/caseDicts"
|
|
|
|
_files=""
|
|
for _d in $_dirs
|
|
do
|
|
[ -d "$_d" ] && \
|
|
_files="$_files $(find "$_d" -type f ! -name "*.*" -exec basename {} \;)"
|
|
done
|
|
echo "${_files}" | xargs -n 1 | sort -u
|
|
}
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used
|
|
used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -ext -help -no-ext -target"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
opts="${opts} $(_searchDirs)"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case|-target)
|
|
opts="" ; extra="-d" ;;
|
|
-ext)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-ext|-target) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- "${cur}") )
|
|
}
|
|
complete -o filenames -o nospace -F _foamGet_ foamGet
|
|
|
|
_foamInfo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -browser -help -web"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-browser)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamInfo_ foamInfo
|
|
|
|
_foamJob_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-append -case -help -parallel -screen -version -wait"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamJob_ foamJob
|
|
|
|
_foamLog_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -list -localDB -n -quiet"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamLog_ foamLog
|
|
|
|
_foamMonitor_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -idle -logscale -refresh -title -yrange"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-idle|-title|-refresh|-yrange)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-idle|-title|-refresh|-yrange) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamMonitor_ foamMonitor
|
|
|
|
_foamNew_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -source -template"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-source|-template)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNew_ foamNew
|
|
|
|
_foamNewApp_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNewApp_ foamNewApp
|
|
|
|
_foamNewBC_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNewBC_ foamNewBC
|
|
|
|
_foamNewFunctionObject_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNewFunctionObject_ foamNewFunctionObject
|
|
|
|
_foamRunTutorials_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -skipFirst -test"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamRunTutorials_ foamRunTutorials
|
|
|
|
_foamSearch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-count -help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamSearch_ foamSearch
|
|
|
|
_foamSequenceVTKFiles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dir -help -out"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case|-dir|-out)
|
|
opts="" ; extra="-d" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamSequenceVTKFiles_ foamSequenceVTKFiles
|
|
|
|
_foamTags_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamTags_ foamTags
|
|
|
|
_foamUpdateCaseFileHeader_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamUpdateCaseFileHeader_ foamUpdateCaseFileHeader
|
|
|
|
_mergedDyM_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mergedDyM_ mergedDyM
|
|
|
|
_mpirunDebug_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mpirunDebug_ mpirunDebug
|
|
|
|
_paraFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-block -builtin -case -help -region -touch -touchAll"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _paraFoam_ paraFoam
|
|
|
|
_pimpleDyMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pimpleDyMFoam_ pimpleDyMFoam
|
|
|
|
_surfaceFeatureExtract_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatureExtract_ surfaceFeatureExtract
|
|
|
|
_wclean_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -silent"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wclean_ wclean
|
|
|
|
_wcleanLnIncludeAll_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wcleanLnIncludeAll_ wcleanLnIncludeAll
|
|
|
|
_wcleanPlatform_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -current -help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wcleanPlatform_ wcleanPlatform
|
|
|
|
_wdep_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wdep_ wdep
|
|
|
|
_wmake_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -help -j -j -non-stop -no-scheduler -queue -silent -update"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-j)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-j) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmake_ wmake
|
|
|
|
_wmakeCheckPwd_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -quiet"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeCheckPwd_ wmakeCheckPwd
|
|
|
|
_wmakeCollect_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-clean -help -kill"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeCollect_ wmakeCollect
|
|
|
|
_wmakeFilesAndOptions_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeFilesAndOptions_ wmakeFilesAndOptions
|
|
|
|
_wmakeLnInclude_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -silent -update"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeLnInclude_ wmakeLnInclude
|
|
|
|
_wmakeLnIncludeAll_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -j -j"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-j)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-j) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeLnIncludeAll_ wmakeLnIncludeAll
|
|
|
|
_wmakePrintBuild_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-check -help -major -pkg -short -update -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-pkg|-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakePrintBuild_ wmakePrintBuild
|
|
|
|
_wmakeScheduler_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeScheduler_ wmakeScheduler
|
|
|
|
_wmakeSchedulerUptime_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeSchedulerUptime_ wmakeSchedulerUptime
|
|
|
|
_wrmdep_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wrmdep_ wrmdep
|
|
|
|
_wrmo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wrmo_ wrmo
|
|
|
|
#------------------------------------------------------------------------------
|