ee777e4083
OpenFOAM is predominantly written in Britain with British spelling conventions so -ise is preferred to -ize.
6006 lines
184 KiB
Bash
6006 lines
184 KiB
Bash
#----------------------------------*-sh-*--------------------------------------
|
|
# ========= |
|
|
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
# \\ / O peration | Website: https://openfoam.org
|
|
# \\ / A nd | Copyright (C) 2017-2021 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
|
|
|
|
_adjointShapeOptimisationFoam_ ()
|
|
{
|
|
local cur="${COMP_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _adjointShapeOptimisationFoam_ adjointShapeOptimisationFoam
|
|
|
|
_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 -libs -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="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantPimpleFoam_ buoyantPimpleFoam
|
|
|
|
_buoyantReactingFoam_ ()
|
|
{
|
|
local cur="${COMP_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantReactingFoam_ buoyantReactingFoam
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantSimpleFoam_ buoyantSimpleFoam
|
|
|
|
_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -literalRE -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|-libs|-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 -libs -meshQuality -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chtMultiRegionFoam_ chtMultiRegionFoam
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _combinePatchFaces_ combinePatchFaces
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -noFields -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|-libs|-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 -libs -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _deformedGeom_ deformedGeom
|
|
|
|
_denseParticleFoam_ ()
|
|
{
|
|
local cur="${COMP_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 -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _denseParticleFoam_ denseParticleFoam
|
|
|
|
_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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dnsFoam_ dnsFoam
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -dict -doc -fileHandler -help -hostRoots -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _financialFoam_ financialFoam
|
|
|
|
_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 -libs -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|-libs|-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 -includedAngle -libs -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|-includedAngle|-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-ignoreCellGroups|-ignoreFaceGroups|-includedAngle|-libs|-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 -libs -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|-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-2D|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -dict -diff -doc -entry -expand -fileHandler -help -hostRoots -includes -keywords -libs -merge -noFunctionObjects -parallel -remove -roots -set -srcDoc -value -writePrecision"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-add|-diff|-entry|-hostRoots|-libs|-merge|-roots|-set|-writePrecision)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-add|-diff|-entry|-hostRoots|-libs|-merge|-roots|-set|-writePrecision|-fileHandler) ;;
|
|
*) 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 -libs -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|-libs|-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 -libs -noFunctionObjects -noZero -processor -rm -srcDoc -time -withFunctionEntries -withFunctionObjects -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -name -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|-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -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|-libs|-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 -libs -nearCellValue -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|-libs|-pointSet|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToVTK_ foamToVTK
|
|
|
|
_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 -libs -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|-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -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="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -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="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _icoFoam_ icoFoam
|
|
|
|
_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 -libs -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="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-region|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interMixingFoam_ interMixingFoam
|
|
|
|
_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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
|
|
-libs|-mapMethod|-sourceRegion|-sourceTime|-targetRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -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|-libs|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-fields|-hostRoots|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveMesh_ moveMesh
|
|
|
|
_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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-hostRoots|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _orientFaceZone_ orientFaceZone
|
|
|
|
_particleFoam_ ()
|
|
{
|
|
local cur="${COMP_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _particleFoam_ particleFoam
|
|
|
|
_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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-2D|-libs|-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 -libs -noFields -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -list -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-pName|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _potentialFoam_ potentialFoam
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingFoam_ reactingFoam
|
|
|
|
_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 -libs -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|-libs|-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 -help -latestTime -libs -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="" ;;
|
|
-libs|-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 -libs -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|-libs|-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 -libs -minSet -noFields -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|-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-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 -inSet -libs -noFunctionObjects -overwrite -region -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="" ;;
|
|
-inSet|-libs|-region)
|
|
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 -libs -noFields -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|-libs|-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 -libs -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|-libs|-region|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _renumberMesh_ renumberMesh
|
|
|
|
_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoCentralFoam_ rhoCentralFoam
|
|
|
|
_rhoParticleFoam_ ()
|
|
{
|
|
local cur="${COMP_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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoParticleFoam_ rhoParticleFoam
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoPorousSimpleFoam_ rhoPorousSimpleFoam
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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|-libs|-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 -libs -loop -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|-libs|-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 -libs -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|-libs|-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 -dict -doc -fileHandler -gas -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time -U"
|
|
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="" ;;
|
|
-U|-alpha|-hostRoots|-libs|-region|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _simpleFoam_ simpleFoam
|
|
|
|
_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 -libs -noFields -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _solidEquilibriumDisplacementFoam_ solidEquilibriumDisplacementFoam
|
|
|
|
_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 -libs -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="" ;;
|
|
-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -makeCellZones -noFields -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|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitMeshRegions_ splitMeshRegions
|
|
|
|
_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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -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="" ;;
|
|
-libs|-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 -libs -noFields -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="" ;;
|
|
-libs|-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 -libs -noFields -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatureConvert_ surfaceFeatureConvert
|
|
|
|
_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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; 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 -doc -fileHandler -from -help -libs -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" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-libs|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-from|-libs|-scaleIn|-scaleOut|-to|-case|-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 -doc -fileHandler -from -help -libs -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" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-libs|-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 -doc -fileHandler -from -help -libs -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" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-libs|-name|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-from|-libs|-name|-scaleIn|-scaleOut|-to|-case|-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 -libs -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="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-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 -libs -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|-libs|-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 -libs -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-hostRoots|-libs|-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 -libs -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|-libs|-tol)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-faceSet|-libs|-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 -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 _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 -libs -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|-libs|-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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-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 -libs -noFunctionObjects -parallel -region -roots -rotateFields -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|-libs|-region|-roots)
|
|
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 -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _twoLiquidMixingFoam_ twoLiquidMixingFoam
|
|
|
|
_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 -libs -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|-libs|-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 -libs -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="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _vtkUnstructuredToFoam_ vtkUnstructuredToFoam
|
|
|
|
_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 -libs -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -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|-libs|-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 -libs -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|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _zipUpMesh_ zipUpMesh
|
|
|
|
_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=""
|
|
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 _coalChemistryFoam_ coalChemistryFoam
|
|
|
|
_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=""
|
|
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 _compressibleInterFilmFoam_ compressibleInterFilmFoam
|
|
|
|
_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=""
|
|
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 _DPMFoam_ DPMFoam
|
|
|
|
_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="-add -help -latestTime -no-orig -no-scripts -processor -template"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
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_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
_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
|
|
}
|
|
|
|
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 -keyword -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="-ascii -help -idle -logscale -refresh -size -title -yrange"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-idle|-title|-refresh|-yrange|-size)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-idle|-title|-refresh|-yrange|-size) ;;
|
|
*) 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
|
|
|
|
_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=""
|
|
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 _icoUncoupledKinematicParcelFoam_ icoUncoupledKinematicParcelFoam
|
|
|
|
_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=""
|
|
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 _interPhaseChangeFoam_ interPhaseChangeFoam
|
|
|
|
_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
|
|
|
|
_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=""
|
|
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 _MPPICFoam_ MPPICFoam
|
|
|
|
_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 -empty -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
|
|
|
|
_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=""
|
|
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 _reactingParcelFoam_ reactingParcelFoam
|
|
|
|
_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=""
|
|
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 _uncoupledKinematicParcelFoam_ uncoupledKinematicParcelFoam
|
|
|
|
_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
|
|
|
|
#------------------------------------------------------------------------------
|