3a3a844173
foamToC: New run-time selection table of contents printing and interrogation utility
The new solver modules cannot provide the equivalent functionality of the -list
options available in the solver applications so foamToC has been developed as a
better, more general and flexible alternative, providing a means to print any or
all run-time selection tables in any or all libraries and search the tables for
any particular entries and print which library files the corresponding tables
are in, e.g.
foamToC -solver fluid -table fvPatchScalarField
Contents of table fvPatchScalarField, base type fvPatchField:
advective libfiniteVolume.so
calculated libfiniteVolume.so
codedFixedValue libfiniteVolume.so
codedMixed libfiniteVolume.so
compressible::alphatJayatillekeWallFunctionlibthermophysicalTransportModels.so
compressible::alphatWallFunction libthermophysicalTransportModels.so
compressible::thermalBaffle1D<eConstSolidThermoPhysics>libthermophysicalTransportModels.so
compressible::thermalBaffle1D<ePowerSolidThermoPhysics>libthermophysicalTransportModels.so
compressible::turbulentTemperatureCoupledBaffleMixedlibthermophysicalTransportModels.so
compressible::turbulentTemperatureRadCoupledMixedlibthermophysicalTransportModels.so
.
.
.
foamToC -solver fluid -search compressible::alphatWallFunction
compressible::alphatWallFunction is in tables
fvPatchField
fvPatchScalarField libthermophysicalTransportModels.so
and the very useful -allLibs option allows ALL libraries to be searched to find
in which table and which library file a particular model in in for example:
foamToC -allLibs -search phaseTurbulenceStabilisation
Loading libraries:
libtwoPhaseSurfaceTension.so
libcv2DMesh.so
libODE.so
.
.
.
phaseTurbulenceStabilisation is in tables
fvModel libmultiphaseEulerFoamFvModels.so
Application
foamToC
Description
Run-time selection table of contents printing and interrogation.
The run-time selection tables are populated by the optionally specified
solver class and any additional libraries listed in the \c -libs option or
all libraries using the \c -allLibs option. Once populated the tables can
be searched and printed by a range of options listed below. Table entries
are printed with the corresponding library they are in to aid selection
and the addition of \c libs entries to ensure availability to the solver.
Usage
\b foamToC [OPTION]
- \par -solver \<name\>
Specify the solver class
- \par -libs '(\"lib1.so\" ... \"libN.so\")'
Specify the additional libraries to load
- \par -allLibs
Load all libraries
- \par switches,
List all available debug, info and optimisation switches
- \par all,
List the contents of all the run-time selection tables
- \par tables
List the run-time selection table names (this is the default action)
- \par table \<name\>
List the contents of the specified table or the list sub-tables
- \par search \<name\>
Search for and list the tables containing the given entry
- \par scalarBCs,
List scalar field boundary conditions (fvPatchField<scalar>)
- \par vectorBCs,
List vector field boundary conditions (fvPatchField<vector>)
- \par functionObjects,
List functionObjects
- \par fvModels,
List fvModels
- \par fvConstraints,
List fvConstraints
Example usage:
- Print the list of scalar boundary conditions (fvPatchField<scalar>)
provided by the \c fluid solver without additional libraries:
\verbatim
foamToC -solver fluid -scalarBCs
\endverbatim
- Print the list of RAS momentum transport models provided by the
\c fluid solver:
\verbatim
foamToC -solver fluid -table RAScompressibleMomentumTransportModel
\endverbatim
- Print the list of functionObjects provided by the
\c multicomponentFluid solver with the libfieldFunctionObjects.so
library:
\verbatim
foamToC -solver multicomponentFluid \
-libs '("libfieldFunctionObjects.so")' -functionObjects
\endverbatim
- Print a complete list of all run-time selection tables:
\verbatim
foamToC -allLibs -tables
or
foamToC -allLibs
\endverbatim
- Print a complete list of all entries in all run-time selection tables:
\verbatim
foamToC -allLibs -all
\endverbatim
5520 lines
166 KiB
Bash
5520 lines
166 KiB
Bash
#----------------------------------*-sh-*--------------------------------------
|
|
# ========= |
|
|
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
# \\ / O peration | Website: https://openfoam.org
|
|
# \\ / A nd | Copyright (C) 2017-2023 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 -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 -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
|
|
|
|
_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 -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 -precision -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-precision)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chemkinToFoam_ chemkinToFoam
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_createNonConformalCouples_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -fields -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 _createNonConformalCouples_ createNonConformalCouples
|
|
|
|
_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 -cellProc -constant -copyUniform -copyZero -doc -fields -fileHandler -force -help -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="" ;;
|
|
-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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
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 -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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
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 -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 -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
|
|
|
|
_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 -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 -case -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
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-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|-case|-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
|
|
|
|
_foamMultiRun_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 _foamMultiRun_ foamMultiRun
|
|
|
|
_foamPostProcess_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamPostProcess_ foamPostProcess
|
|
|
|
_foamRun_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamRun_ foamRun
|
|
|
|
_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
|
|
|
|
_foamToC_ ()
|
|
{
|
|
local cur="${COMP_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 -allLibs -doc -functionObjects -fvConstraints -fvModels -help -libs -scalarBCs -search -solver -srcDoc -switches -table -tables -vectorBCs"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-libs|-search|-solver|-table)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToC_ foamToC
|
|
|
|
_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 -polyhedra -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|-polyhedra|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToVTK_ foamToVTK
|
|
|
|
_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 -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
|
|
|
|
_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 -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 -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 -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 -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 -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 -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
|
|
|
|
_mergeBaffles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -fields -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" ;;
|
|
-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 _mergeBaffles_ mergeBaffles
|
|
|
|
_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
|
|
|
|
_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 -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
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_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 -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
|
|
|
|
_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 -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
|
|
|
|
_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 -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
|
|
|
|
_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 -cellProc -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
|
|
|
|
_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
|
|
|
|
_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 -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
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_setAtmBoundaryLayer_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -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" ;;
|
|
-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 _setAtmBoundaryLayer_ setAtmBoundaryLayer
|
|
|
|
_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 -constant -dict -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" ;;
|
|
-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 _setFields_ setFields
|
|
|
|
_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 -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
|
|
|
|
_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
|
|
|
|
_splitBaffles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -fields -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" ;;
|
|
-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 _splitBaffles_ splitBaffles
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_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
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
*) opts=""; extra="-d -f" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceTransformPoints_ surfaceTransformPoints
|
|
_temporalInterpolate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -divisions -doc -fields -fileHandler -help -hostRoots -interpolationType -latestTime -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 -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 -pointSet -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|-pointSet|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _transformPoints_ transformPoints
|
|
|
|
_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
|
|
|
|
_zeroDimensionalMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 _zeroDimensionalMesh_ zeroDimensionalMesh
|
|
|
|
_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
|
|
|
|
_buoyantFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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 -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantFoam_ buoyantFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantReactingFoam_ buoyantReactingFoam
|
|
|
|
_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 -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 _chtMultiRegionFoam_ chtMultiRegionFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleMultiphaseInterFoam_ compressibleMultiphaseInterFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _denseParticleFoam_ denseParticleFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _driftFluxFoam_ driftFluxFoam
|
|
|
|
_foamCleanCase_ ()
|
|
{
|
|
local cur="${COMP_WORDS[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"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanCase_ foamCleanCase
|
|
|
|
_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
|
|
|
|
_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 -startFrom -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="-begin-pause -dir -end-pause -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" ;;
|
|
-begin-pause|-end-pause|-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
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interFoam_ interFoam
|
|
|
|
_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 -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveDynamicMesh_ moveDynamicMesh
|
|
|
|
_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 -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveMesh_ moveMesh
|
|
|
|
_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
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _multiphaseInterFoam_ multiphaseInterFoam
|
|
|
|
_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
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pisoFoam_ pisoFoam
|
|
|
|
_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 -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _postProcess_ postProcess
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingFoam_ reactingFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoCentralFoam_ rhoCentralFoam
|
|
|
|
_rhoPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoPimpleFoam_ rhoPimpleFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoSimpleFoam_ rhoSimpleFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _simpleFoam_ simpleFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _solidEquilibriumDisplacementFoam_ solidEquilibriumDisplacementFoam
|
|
|
|
_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 -noFunctionObjects -parallel -roots -solver -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|-solver)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _XiFoam_ XiFoam
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
_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
|
|
|
|
#------------------------------------------------------------------------------
|