49ce8f6507
With the new fvModels framework it is now possible to implement complex models
and wrappers around existing complex models which can then be optionally
selected in any general solver which provides compatible fields and
thermophysical properties. This simplifies code development and maintenance by
significantly reducing complex code duplication and also provide the opportunity
of running these models in other solvers without the need for code duplication
and alteration.
The immediate advantage of this development is the replacement of the
specialised Lagrangian solvers with their general counterparts:
reactingParticleFoam -> reactingFoam
reactingParcelFoam -> reactingFoam
sprayFoam -> reactingFoam
simpleReactingParticleFoam -> reactingFoam
buoyantReactingParticleFoam -> buoyantReactingFoam
For example to run a reactingParticleFoam case in reactingFoam add the following
entries in constant/fvModels:
buoyancyForce
{
type buoyancyForce;
}
clouds
{
type clouds;
libs ("liblagrangianParcel.so");
}
which add the acceleration due to gravity needed by Lagrangian clouds and the
clouds themselves.
See the following cases for examples converted from reactingParticleFoam:
$FOAM_TUTORIALS/combustion/reactingFoam/Lagrangian
and to run a buoyantReactingParticleFoam case in buoyantReactingFoam add the
following entry constant/fvModels:
clouds
{
type clouds;
libs ("liblagrangianParcel.so");
}
to add support for Lagrangian clouds and/or
surfaceFilm
{
type surfaceFilm;
libs ("libsurfaceFilmModels.so");
}
to add support for surface film. The buoyancyForce fvModel is not required in
this case as the buoyantReactingFoam solver has built-in support for buoyancy
utilising the p_rgh formulation to provide better numerical handling for this
force for strongly buoyancy-driven flows.
See the following cases for examples converted from buoyantReactingParticleFoam:
$FOAM_TUTORIALS/combustion/buoyantReactingFoam/Lagrangian
All the tutorial cases for the redundant solvers have been updated and converted
into their new equivalents and redirection scripts replace these solvers to
provide users with prompts on which solvers have been replaced by which and
information on how to upgrade their cases.
To support this change and allow all previous Lagrangian tutorials to run as
before the special Lagrangian solver fvSolution/PIMPLE control
solvePrimaryRegion has been replaced by the more general and useful controls:
models : Enable the fvModels
thermophysics : Enable thermophysics (energy and optional composition)
flow : Enable flow (pressure/velocity system)
which also replace the fvSolution/PIMPLE control frozenFlow present in some
solvers. These three controls can be used in various combinations to allow for
example only the fvModels to be evaluated, e.g. in
$FOAM_TUTORIALS/combustion/buoyantReactingFoam/Lagrangian/rivuletPanel
PIMPLE
{
models yes;
thermophysics no;
flow no;
.
.
.
so that only the film is solved. Or during the start-up of a case it might be
beneficial to run the pressure-velocity system for a while without updating
temperature which can be achieved by switching-off thermophysics. Also the
behaviour of the previous frozenFlow switch can be reproduced by switching flow
off with the other two switches on, allowing for example reactions, temperature
and composition update without flow.
6031 lines
185 KiB
Bash
6031 lines
185 KiB
Bash
#----------------------------------*-sh-*--------------------------------------
|
|
# ========= |
|
|
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
# \\ / O peration | Website: https://openfoam.org
|
|
# \\ / A nd | Copyright (C) 2017-2021 OpenFOAM Foundation
|
|
# \\/ M anipulation |
|
|
#------------------------------------------------------------------------------
|
|
# License
|
|
# This file is part of OpenFOAM.
|
|
#
|
|
# OpenFOAM is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# File
|
|
# etc/config.sh/bash_completion
|
|
#
|
|
# Description
|
|
# Bash [TAB] completion file from OpenFOAM
|
|
# Sourced from /etc/bashrc
|
|
#
|
|
#------------------------------------------------------------------------------
|
|
|
|
_adiabaticFlameT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _adiabaticFlameT_ adiabaticFlameT
|
|
|
|
_adjointShapeOptimizationFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _adjointShapeOptimizationFoam_ adjointShapeOptimizationFoam
|
|
|
|
_ansysToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _ansysToFoam_ ansysToFoam
|
|
|
|
_applyBoundaryLayer_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -Cbl -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc -writenut -ybl"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-Cbl|-hostRoots|-libs|-roots|-ybl)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _applyBoundaryLayer_ applyBoundaryLayer
|
|
|
|
_attachMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _attachMesh_ attachMesh
|
|
|
|
_autoPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _autoPatch_ autoPatch
|
|
|
|
_autoRefineMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _autoRefineMesh_ autoRefineMesh
|
|
|
|
_blockMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-blockTopology -case -dict -doc -fileHandler -help -libs -noClean -noFunctionObjects -region -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _blockMesh_ blockMesh
|
|
|
|
_boundaryFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _boundaryFoam_ boundaryFoam
|
|
|
|
_boxTurb_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _boxTurb_ boxTurb
|
|
|
|
_buoyantPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantPimpleFoam_ buoyantPimpleFoam
|
|
|
|
_buoyantReactingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantReactingFoam_ buoyantReactingFoam
|
|
|
|
_buoyantSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _buoyantSimpleFoam_ buoyantSimpleFoam
|
|
|
|
_cavitatingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _cavitatingFoam_ cavitatingFoam
|
|
|
|
_cfx4ToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _cfx4ToFoam_ cfx4ToFoam
|
|
|
|
_changeDictionary_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -disablePatchGroups -doc -enableFunctionEntries -fileHandler -help -hostRoots -instance -latestTime -libs -literalRE -noFunctionObjects -noZero -parallel -region -roots -srcDoc -subDict -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-instance|-libs|-region|-roots|-subDict)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _changeDictionary_ changeDictionary
|
|
|
|
_checkMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allGeometry -allTopology -case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -meshQuality -noFunctionObjects -noTopology -noZero -parallel -region -roots -srcDoc -time -writeSets"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots|-writeSets)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _checkMesh_ checkMesh
|
|
|
|
_chemFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -postProcess -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chemFoam_ chemFoam
|
|
|
|
_chemkinToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -newFormat -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chemkinToFoam_ chemkinToFoam
|
|
|
|
_chtMultiRegionFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _chtMultiRegionFoam_ chtMultiRegionFoam
|
|
|
|
_coldEngineFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _coldEngineFoam_ coldEngineFoam
|
|
|
|
_collapseEdges_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -collapseFaces -collapseFaceSet -constant -dict -doc -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -overwrite -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-collapseFaceSet|-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _collapseEdges_ collapseEdges
|
|
|
|
_combinePatchFaces_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -concaveAngle -doc -fileHandler -help -hostRoots -libs -meshQuality -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-concaveAngle|-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _combinePatchFaces_ combinePatchFaces
|
|
|
|
_compressibleInterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleInterFoam_ compressibleInterFoam
|
|
|
|
_compressibleMultiphaseInterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleMultiphaseInterFoam_ compressibleMultiphaseInterFoam
|
|
|
|
_createBaffles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _createBaffles_ createBaffles
|
|
|
|
_createExternalCoupledPatchGeometry_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _createExternalCoupledPatchGeometry_ createExternalCoupledPatchGeometry
|
|
|
|
_createPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _createPatch_ createPatch
|
|
|
|
_datToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _datToFoam_ datToFoam
|
|
|
|
_decomposePar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allRegions -case -cellDist -constant -copyUniform -copyZero -dict -doc -fields -fileHandler -force -help -ifRequired -latestTime -libs -noFields -noFunctionObjects -noSets -noZero -region -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-dict|-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _decomposePar_ decomposePar
|
|
|
|
_deformedGeom_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _deformedGeom_ deformedGeom
|
|
|
|
_denseParticleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _denseParticleFoam_ denseParticleFoam
|
|
|
|
_dnsFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dnsFoam_ dnsFoam
|
|
|
|
_driftFluxFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _driftFluxFoam_ driftFluxFoam
|
|
|
|
_dsmcFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dsmcFoam_ dsmcFoam
|
|
|
|
_dsmcInitialise_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _dsmcInitialise_ dsmcInitialise
|
|
|
|
_electrostaticFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _electrostaticFoam_ electrostaticFoam
|
|
|
|
_engineCompRatio_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _engineCompRatio_ engineCompRatio
|
|
|
|
_engineFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _engineFoam_ engineFoam
|
|
|
|
_engineSwirl_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _engineSwirl_ engineSwirl
|
|
|
|
_equilibriumCO_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _equilibriumCO_ equilibriumCO
|
|
|
|
_equilibriumFlameT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _equilibriumFlameT_ equilibriumFlameT
|
|
|
|
_extrude2DMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _extrude2DMesh_ extrude2DMesh
|
|
|
|
_extrudeMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _extrudeMesh_ extrudeMesh
|
|
|
|
_extrudeToRegionMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _extrudeToRegionMesh_ extrudeToRegionMesh
|
|
|
|
_faceAgglomerate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _faceAgglomerate_ faceAgglomerate
|
|
|
|
_financialFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _financialFoam_ financialFoam
|
|
|
|
_fireFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _fireFoam_ fireFoam
|
|
|
|
_flattenMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _flattenMesh_ flattenMesh
|
|
|
|
_fluent3DMeshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cubit -doc -fileHandler -help -ignoreCellGroups -ignoreFaceGroups -includedAngle -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-ignoreCellGroups|-ignoreFaceGroups|-includedAngle|-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-ignoreCellGroups|-ignoreFaceGroups|-includedAngle|-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _fluent3DMeshToFoam_ fluent3DMeshToFoam
|
|
|
|
_fluentMeshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-2D -case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc -writeSets -writeZones"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-2D|-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-2D|-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _fluentMeshToFoam_ fluentMeshToFoam
|
|
|
|
_foamDataToFluent_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -latestTime -libs -noFunctionObjects -noZero -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamDataToFluent_ foamDataToFluent
|
|
|
|
_foamDictionary_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-add -dict -diff -doc -entry -expand -fileHandler -help -hostRoots -includes -keywords -libs -merge -noFunctionObjects -parallel -remove -roots -set -srcDoc -value -writePrecision"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-add|-diff|-entry|-hostRoots|-libs|-merge|-roots|-set|-writePrecision)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-add|-diff|-entry|-hostRoots|-libs|-merge|-roots|-set|-writePrecision|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamDictionary_ foamDictionary
|
|
|
|
_foamFormatConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noConstant -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamFormatConvert_ foamFormatConvert
|
|
|
|
_foamListTimes_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -libs -noFunctionObjects -noZero -processor -rm -srcDoc -time -withFunctionEntries -withFunctionObjects -withZero"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamListTimes_ foamListTimes
|
|
|
|
_foamMeshToFluent_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamMeshToFluent_ foamMeshToFluent
|
|
|
|
_foamSetupCHT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamSetupCHT_ foamSetupCHT
|
|
|
|
_foamToEnsight_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -case -cellZone -constant -doc -faceZones -fields -fileHandler -help -hostRoots -latestTime -libs -nodeValues -noFunctionObjects -noPatches -noZero -parallel -patches -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-cellZone|-faceZones|-fields|-hostRoots|-libs|-patches|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToEnsight_ foamToEnsight
|
|
|
|
_foamToEnsightParts_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -case -constant -doc -fileHandler -help -index -latestTime -libs -name -noFunctionObjects -noMesh -noZero -srcDoc -time -width"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-index|-libs|-name|-width)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToEnsightParts_ foamToEnsightParts
|
|
|
|
_foamToGMV_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToGMV_ foamToGMV
|
|
|
|
_foamToStarMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -libs -noBnd -noFunctionObjects -noZero -scale -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToStarMesh_ foamToStarMesh
|
|
|
|
_foamToSurface_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -libs -noFunctionObjects -noZero -scale -srcDoc -time -tri"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToSurface_ foamToSurface
|
|
|
|
_foamToTetDualMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -overwrite -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToTetDualMesh_ foamToTetDualMesh
|
|
|
|
_foamToVTK_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allPatches -ascii -case -cellSet -constant -doc -excludePatches -faceSet -fields -fileHandler -help -hostRoots -latestTime -libs -nearCellValue -noFaceZones -noFunctionObjects -noInternal -noLinks -noPointValues -noZero -parallel -pointSet -poly -region -roots -srcDoc -surfaceFields -time -useTimeName"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-cellSet|-excludePatches|-faceSet|-fields|-hostRoots|-libs|-pointSet|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamToVTK_ foamToVTK
|
|
|
|
_foamyHexMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -checkGeometry -conformationOnly -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamyHexMesh_ foamyHexMesh
|
|
|
|
_foamyQuadMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -overwrite -pointsFile -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-pointsFile)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamyQuadMesh_ foamyQuadMesh
|
|
|
|
_gambitToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _gambitToFoam_ gambitToFoam
|
|
|
|
_gmshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -keepOrientation -libs -noFunctionObjects -region -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-region|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _gmshToFoam_ gmshToFoam
|
|
|
|
_icoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _icoFoam_ icoFoam
|
|
|
|
_ideasUnvToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -dump -fileHandler -help -libs -noFunctionObjects -region -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-region|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _ideasUnvToFoam_ ideasUnvToFoam
|
|
|
|
_insideCells_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _insideCells_ insideCells
|
|
|
|
_interFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interFoam_ interFoam
|
|
|
|
_interMixingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interMixingFoam_ interMixingFoam
|
|
|
|
_kivaToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -file -fileHandler -help -libs -noFunctionObjects -srcDoc -version -zHeadMin"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-file|-libs|-version|-zHeadMin)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _kivaToFoam_ kivaToFoam
|
|
|
|
_laplacianFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _laplacianFoam_ laplacianFoam
|
|
|
|
_magneticFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -HdotGradH -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noB -noFunctionObjects -noH -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _magneticFoam_ magneticFoam
|
|
|
|
_mapFields_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -consistent -doc -fileHandler -help -libs -mapMethod -noFunctionObjects -parallelSource -parallelTarget -sourceRegion -sourceTime -srcDoc -subtract -targetRegion"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-mapMethod|-sourceRegion|-sourceTime|-targetRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-mapMethod|-sourceRegion|-sourceTime|-targetRegion|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mapFields_ mapFields
|
|
|
|
_mapFieldsPar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -consistent -doc -fields -fileHandler -help -hostRoots -libs -mapMethod -noFunctionObjects -noLagrangian -parallel -roots -sourceRegion -sourceTime -srcDoc -subtract -targetRegion"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-fields|-hostRoots|-libs|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-fields|-hostRoots|-libs|-mapMethod|-roots|-sourceRegion|-sourceTime|-targetRegion|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mapFieldsPar_ mapFieldsPar
|
|
|
|
_mdEquilibrationFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mdEquilibrationFoam_ mdEquilibrationFoam
|
|
|
|
_mdFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mdFoam_ mdFoam
|
|
|
|
_mdInitialise_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mdInitialise_ mdInitialise
|
|
|
|
_mergeMeshes_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-addRegion -case -doc -fileHandler -help -libs -masterRegion -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-addRegion|-libs|-masterRegion)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mergeMeshes_ mergeMeshes
|
|
|
|
_mergeOrSplitBaffles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -detectOnly -doc -fields -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -region -roots -split -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mergeOrSplitBaffles_ mergeOrSplitBaffles
|
|
|
|
_mhdFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mhdFoam_ mhdFoam
|
|
|
|
_mirrorMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mirrorMesh_ mirrorMesh
|
|
|
|
_mixtureAdiabaticFlameT_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mixtureAdiabaticFlameT_ mixtureAdiabaticFlameT
|
|
|
|
_modifyMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _modifyMesh_ modifyMesh
|
|
|
|
_moveDynamicMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -checkAMI -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveDynamicMesh_ moveDynamicMesh
|
|
|
|
_moveEngineMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveEngineMesh_ moveEngineMesh
|
|
|
|
_moveMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _moveMesh_ moveMesh
|
|
|
|
_mshToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hex -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mshToFoam_ mshToFoam
|
|
|
|
_multiphaseEulerFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _multiphaseEulerFoam_ multiphaseEulerFoam
|
|
|
|
_multiphaseInterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _multiphaseInterFoam_ multiphaseInterFoam
|
|
|
|
_netgenNeutralToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-hostRoots|-libs|-roots|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _netgenNeutralToFoam_ netgenNeutralToFoam
|
|
|
|
_noise_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _noise_ noise
|
|
|
|
_nonNewtonianIcoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _nonNewtonianIcoFoam_ nonNewtonianIcoFoam
|
|
|
|
_objToVTK_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _objToVTK_ objToVTK
|
|
|
|
_orientFaceZone_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _orientFaceZone_ orientFaceZone
|
|
|
|
_particleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _particleFoam_ particleFoam
|
|
|
|
_particleTracks_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _particleTracks_ particleTracks
|
|
|
|
_patchSummary_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -expand -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _patchSummary_ patchSummary
|
|
|
|
_pdfPlot_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pdfPlot_ pdfPlot
|
|
|
|
_PDRFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _PDRFoam_ PDRFoam
|
|
|
|
_PDRMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _PDRMesh_ PDRMesh
|
|
|
|
_pimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pimpleFoam_ pimpleFoam
|
|
|
|
_pisoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _pisoFoam_ pisoFoam
|
|
|
|
_plot3dToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-2D -case -doc -fileHandler -help -libs -noBlank -noFunctionObjects -scale -singleBlock -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-2D|-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-2D|-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _plot3dToFoam_ plot3dToFoam
|
|
|
|
_polyDualMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -concaveMultiCells -doc -doNotPreserveFaceZones -fileHandler -help -libs -noFields -noFunctionObjects -overwrite -splitAllFaces -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _polyDualMesh_ polyDualMesh
|
|
|
|
_porousSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _porousSimpleFoam_ porousSimpleFoam
|
|
|
|
_postChannel_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -latestTime -libs -noFunctionObjects -noZero -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _postChannel_ postChannel
|
|
|
|
_postProcess_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -field -fields -fileHandler -func -funcs -help -hostRoots -latestTime -libs -list -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-field|-fields|-func|-funcs|-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _postProcess_ postProcess
|
|
|
|
_potentialFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -initialiseUBCs -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -pName -roots -srcDoc -withFunctionObjects -writep -writePhi"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-pName|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _potentialFoam_ potentialFoam
|
|
|
|
_potentialFreeSurfaceFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _potentialFreeSurfaceFoam_ potentialFreeSurfaceFoam
|
|
|
|
_reactingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingFoam_ reactingFoam
|
|
|
|
_reconstructPar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="- -allRegions -case -constant -doc -fields -fileHandler -help -lagrangianFields -latestTime -libs -newTimes -noFields -noFunctionObjects -noLagrangian -noSets -noZero -region -srcDoc -time -withZero"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-fields|-lagrangianFields|-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reconstructPar_ reconstructPar
|
|
|
|
_reconstructParMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allRegions -case -cellDist -constant -doc -fileHandler -help -latestTime -libs -noFunctionObjects -noZero -region -srcDoc -time -withZero"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reconstructParMesh_ reconstructParMesh
|
|
|
|
_redistributePar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -overwrite -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _redistributePar_ redistributePar
|
|
|
|
_refineHexMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -minSet -noFields -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refineHexMesh_ refineHexMesh
|
|
|
|
_refinementLevel_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -readLevel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refinementLevel_ refinementLevel
|
|
|
|
_refineMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -overwrite -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refineMesh_ refineMesh
|
|
|
|
_refineWallLayer_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -inSet -libs -noFunctionObjects -overwrite -region -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-inSet|-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _refineWallLayer_ refineWallLayer
|
|
|
|
_removeFaces_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFields -noFunctionObjects -overwrite -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _removeFaces_ removeFaces
|
|
|
|
_renumberMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -fileHandler -frontWidth -help -hostRoots -latestTime -libs -noFields -noFunctionObjects -noZero -overwrite -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _renumberMesh_ renumberMesh
|
|
|
|
_rhoCentralFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoCentralFoam_ rhoCentralFoam
|
|
|
|
_rhoParticleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoParticleFoam_ rhoParticleFoam
|
|
|
|
_rhoPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoPimpleFoam_ rhoPimpleFoam
|
|
|
|
_rhoPorousSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoPorousSimpleFoam_ rhoPorousSimpleFoam
|
|
|
|
_rhoSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rhoSimpleFoam_ rhoSimpleFoam
|
|
|
|
_rotateMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _rotateMesh_ rotateMesh
|
|
|
|
_sammToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _sammToFoam_ sammToFoam
|
|
|
|
_scalarTransportFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _scalarTransportFoam_ scalarTransportFoam
|
|
|
|
_selectCells_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _selectCells_ selectCells
|
|
|
|
_setFields_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setFields_ setFields
|
|
|
|
_setSet_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-batch -case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -loop -noFunctionObjects -noSync -noVTK -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-batch)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setSet_ setSet
|
|
|
|
_setsToZones_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noFlipMap -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots|-time)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setsToZones_ setsToZones
|
|
|
|
_setWaves_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-alpha -case -dict -doc -fileHandler -gas -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time -U"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-U|-alpha|-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _setWaves_ setWaves
|
|
|
|
_shallowWaterFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _shallowWaterFoam_ shallowWaterFoam
|
|
|
|
_simpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _simpleFoam_ simpleFoam
|
|
|
|
_singleCellMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -doc -fileHandler -help -hostRoots -latestTime -libs -noFields -noFunctionObjects -noZero -parallel -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _singleCellMesh_ singleCellMesh
|
|
|
|
_smapToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _smapToFoam_ smapToFoam
|
|
|
|
_snappyHexMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -checkGeometry -dict -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -outFile -overwrite -parallel -patches -roots -srcDoc -surfaceSimplify"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict|-outFile)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-patches|-roots|-surfaceSimplify)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _snappyHexMesh_ snappyHexMesh
|
|
|
|
_solidDisplacementFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _solidDisplacementFoam_ solidDisplacementFoam
|
|
|
|
_solidEquilibriumDisplacementFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _solidEquilibriumDisplacementFoam_ solidEquilibriumDisplacementFoam
|
|
|
|
_splitCells_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -geometry -help -libs -noFunctionObjects -overwrite -set -srcDoc -tol"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-set|-tol)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitCells_ splitCells
|
|
|
|
_splitMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -overwrite -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitMesh_ splitMesh
|
|
|
|
_splitMeshRegions_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-blockedFaces -case -cellZones -cellZonesFileOnly -cellZonesOnly -defaultRegionName -detectOnly -doc -fileHandler -help -hostRoots -insidePoint -largestOnly -libs -makeCellZones -noFields -noFunctionObjects -overwrite -parallel -prefixRegion -region -roots -sloppyCellZones -srcDoc -useFaceZones"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-cellZonesFileOnly)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-blockedFaces|-defaultRegionName|-hostRoots|-insidePoint|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _splitMeshRegions_ splitMeshRegions
|
|
|
|
_SRFPimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _SRFPimpleFoam_ SRFPimpleFoam
|
|
|
|
_SRFSimpleFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _SRFSimpleFoam_ SRFSimpleFoam
|
|
|
|
_star3ToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _star3ToFoam_ star3ToFoam
|
|
|
|
_star4ToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -case -doc -fileHandler -help -libs -noFunctionObjects -scale -solids -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _star4ToFoam_ star4ToFoam
|
|
|
|
_steadyParticleTracks_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -fileHandler -help -latestTime -libs -noFunctionObjects -noZero -region -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _steadyParticleTracks_ steadyParticleTracks
|
|
|
|
_stitchMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFields -noFunctionObjects -overwrite -partial -perfect -region -srcDoc -toleranceDict"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-toleranceDict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _stitchMesh_ stitchMesh
|
|
|
|
_subsetMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFields -noFunctionObjects -overwrite -parallel -patch -region -resultTime -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-patch|-region|-resultTime|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _subsetMesh_ subsetMesh
|
|
|
|
_surfaceAdd_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -mergeRegions -points -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-points)
|
|
opts="" ; extra="-d -f" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceAdd_ surfaceAdd
|
|
|
|
_surfaceAutoPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceAutoPatch_ surfaceAutoPatch
|
|
|
|
_surfaceBooleanFeatures_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -invertedSpace -libs -noFunctionObjects -perturb -srcDoc -surf1Baffle -surf2Baffle"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceBooleanFeatures_ surfaceBooleanFeatures
|
|
|
|
_surfaceCheck_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-blockMesh -checkSelfIntersection -doc -help -splitNonManifold -srcDoc -verbose"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceCheck_ surfaceCheck
|
|
|
|
_surfaceClean_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -noClean -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceClean_ surfaceClean
|
|
|
|
_surfaceCoarsen_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceCoarsen_ surfaceCoarsen
|
|
|
|
_surfaceConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-clean -doc -group -help -scale -srcDoc -writePrecision"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-scale|-writePrecision)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale|-writePrecision) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceConvert_ surfaceConvert
|
|
|
|
_surfaceFeatureConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatureConvert_ surfaceFeatureConvert
|
|
|
|
_surfaceFeatures_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFeatures_ surfaceFeatures
|
|
|
|
_surfaceFind_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc -x -y -z"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-x|-y|-z)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-x|-y|-z) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceFind_ surfaceFind
|
|
|
|
_surfaceHookUp_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dict -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceHookUp_ surfaceHookUp
|
|
|
|
_surfaceInertia_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-density -doc -help -referencePoint -shellProperties -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-density|-referencePoint)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-density|-referencePoint) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceInertia_ surfaceInertia
|
|
|
|
_surfaceLambdaMuSmooth_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -featureFile -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-featureFile)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-featureFile) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceLambdaMuSmooth_ surfaceLambdaMuSmooth
|
|
|
|
_surfaceMeshConvert_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -clean -doc -fileHandler -from -help -libs -noFunctionObjects -scaleIn -scaleOut -srcDoc -to -tri"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-libs|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-from|-libs|-scaleIn|-scaleOut|-to|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshConvert_ surfaceMeshConvert
|
|
|
|
_surfaceMeshConvertTesting_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-clean -doc -help -orient -scale -srcDoc -surfMesh -triFace -triSurface -unsorted"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-scale) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshConvertTesting_ surfaceMeshConvertTesting
|
|
|
|
_surfaceMeshExport_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -clean -doc -fileHandler -from -help -libs -name -noFunctionObjects -scaleIn -scaleOut -srcDoc -to"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-libs|-name|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshExport_ surfaceMeshExport
|
|
|
|
_surfaceMeshImport_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -clean -doc -fileHandler -from -help -libs -name -noFunctionObjects -scaleIn -scaleOut -srcDoc -to"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-from|-libs|-name|-scaleIn|-scaleOut|-to)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-from|-libs|-name|-scaleIn|-scaleOut|-to|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshImport_ surfaceMeshImport
|
|
|
|
_surfaceMeshInfo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-areas -case -doc -fileHandler -help -libs -noFunctionObjects -scale -srcDoc -xml"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs|-scale)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-scale|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshInfo_ surfaceMeshInfo
|
|
|
|
_surfaceMeshTriangulate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -excludeProcPatches -faceZones -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -patches -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-faceZones|-hostRoots|-libs|-patches|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceMeshTriangulate_ surfaceMeshTriangulate
|
|
|
|
_surfaceOrient_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -inside -srcDoc -usePierceTest"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceOrient_ surfaceOrient
|
|
|
|
_surfacePointMerge_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfacePointMerge_ surfacePointMerge
|
|
|
|
_surfaceRedistributePar_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -keepNonMapped -libs -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-hostRoots|-libs|-roots|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceRedistributePar_ surfaceRedistributePar
|
|
|
|
_surfaceRefineRedGreen_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceRefineRedGreen_ surfaceRefineRedGreen
|
|
|
|
_surfaceSplitByPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSplitByPatch_ surfaceSplitByPatch
|
|
|
|
_surfaceSplitByTopology_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSplitByTopology_ surfaceSplitByTopology
|
|
|
|
_surfaceSplitNonManifolds_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-debug -doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSplitNonManifolds_ surfaceSplitNonManifolds
|
|
|
|
_surfaceSubset_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceSubset_ surfaceSubset
|
|
|
|
_surfaceToPatch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -faceSet -fileHandler -help -libs -noFunctionObjects -srcDoc -tol"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-faceSet|-libs|-tol)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-faceSet|-libs|-tol|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceToPatch_ surfaceToPatch
|
|
|
|
_surfaceTransformPoints_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-doc -help -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _surfaceTransformPoints_ surfaceTransformPoints
|
|
|
|
_temporalInterpolate_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -divisions -doc -fields -fileHandler -help -hostRoots -interpolationType -latestTime -libs -noFunctionObjects -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-divisions|-fields|-hostRoots|-interpolationType|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _temporalInterpolate_ temporalInterpolate
|
|
|
|
_tetgenToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFaceFile -noFunctionObjects -parallel -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _tetgenToFoam_ tetgenToFoam
|
|
|
|
_thermoFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _thermoFoam_ thermoFoam
|
|
|
|
_topoSet_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -constant -dict -doc -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noSync -noZero -parallel -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-dict)
|
|
opts="" ; extra="-d -f" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _topoSet_ topoSet
|
|
|
|
_transformPoints_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-allRegions -case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -rotateFields -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _transformPoints_ transformPoints
|
|
|
|
_twoLiquidMixingFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _twoLiquidMixingFoam_ twoLiquidMixingFoam
|
|
|
|
_viewFactorsGen_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _viewFactorsGen_ viewFactorsGen
|
|
|
|
_vtkUnstructuredToFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -libs -noFunctionObjects -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-libs)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-libs|-case|-fileHandler) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _vtkUnstructuredToFoam_ vtkUnstructuredToFoam
|
|
|
|
_writeMeshObj_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -cell -cellSet -constant -doc -face -faceSet -fileHandler -help -hostRoots -latestTime -libs -noFunctionObjects -noZero -parallel -patchEdges -patchFaces -point -region -roots -srcDoc -time"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-time)
|
|
opts="$(foamListTimes -withZero 2> /dev/null)" ; extra="" ;;
|
|
-cell|-cellSet|-face|-faceSet|-hostRoots|-libs|-point|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _writeMeshObj_ writeMeshObj
|
|
|
|
_XiEngineFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _XiEngineFoam_ XiEngineFoam
|
|
|
|
_XiFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -listFunctionObjects -listFvModels -listMomentumTransportModels -listScalarBCs -listSwitches -listVectorBCs -noFunctionObjects -parallel -postProcess -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _XiFoam_ XiFoam
|
|
|
|
_zipUpMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -doc -fileHandler -help -hostRoots -libs -noFunctionObjects -parallel -region -roots -srcDoc"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-fileHandler)
|
|
opts="uncollated collated masterUncollated" ; extra="" ;;
|
|
-hostRoots|-libs|-region|-roots)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _zipUpMesh_ zipUpMesh
|
|
|
|
_coalChemistryFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _coalChemistryFoam_ coalChemistryFoam
|
|
|
|
_compressibleInterFilmFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _compressibleInterFilmFoam_ compressibleInterFilmFoam
|
|
|
|
_DPMFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _DPMFoam_ DPMFoam
|
|
|
|
_foamCleanPath_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -strip"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanPath_ foamCleanPath
|
|
|
|
_foamCleanPolyMesh_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -help -region"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanPolyMesh_ foamCleanPolyMesh
|
|
|
|
_foamCleanTutorials_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCleanTutorials_ foamCleanTutorials
|
|
|
|
_foamCloneCase_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-add -help -latestTime -no-orig -no-scripts -processor -template"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCloneCase_ foamCloneCase
|
|
|
|
_foamCreateVideo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-dir -fps -help -image -out -start -webm"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-dir)
|
|
opts="" ; extra="-d" ;;
|
|
-fps|-image|-out|-start)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamCreateVideo_ foamCreateVideo
|
|
|
|
_foamEtcFile_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -help -list -mode -prefix -quiet -silent -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-prefix)
|
|
opts="" ; extra="-d" ;;
|
|
-mode|-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamEtcFile_ foamEtcFile
|
|
|
|
_foamExec_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -prefix -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-prefix)
|
|
opts="" ; extra="-d" ;;
|
|
-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamExec_ foamExec
|
|
|
|
_foamGet_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
_searchDirs () {
|
|
_dirs="\
|
|
${HOME}/.OpenFOAM/$WM_PROJECT_VERSION \
|
|
${HOME}/.OpenFOAM"
|
|
[ -n "$WM_PROJECT_SITE" ] && _dirs=" \
|
|
$WM_PROJECT_SITE/$WM_PROJECT_VERSION/etc \
|
|
$WM_PROJECT_SITE/etc"
|
|
_dirs+=" \
|
|
$WM_PROJECT_INST_DIR/site/$WM_PROJECT_VERSION/etc \
|
|
$WM_PROJECT_INST_DIR/site/etc \
|
|
$FOAM_ETC/caseDicts"
|
|
|
|
_files=""
|
|
for _d in $_dirs
|
|
do
|
|
[ -d "$_d" ] && \
|
|
_files="$_files $(find "$_d" -type f ! -name "*.*" -exec basename {} \;)"
|
|
done
|
|
echo "${_files}" | xargs -n 1 | sort -u
|
|
}
|
|
|
|
opts="-case -ext -help -no-ext -target"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
opts="${opts} $(_searchDirs)"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case|-target)
|
|
opts="" ; extra="-d" ;;
|
|
-ext)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-case|-ext|-target) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamGet_ foamGet
|
|
|
|
_foamInfo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -browser -help -keyword -web"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-browser)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamInfo_ foamInfo
|
|
|
|
_foamJob_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-append -case -help -parallel -screen -version -wait"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamJob_ foamJob
|
|
|
|
_foamLog_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -list -localDB -n -quiet"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamLog_ foamLog
|
|
|
|
_foamMonitor_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-ascii -help -idle -logscale -refresh -size -title -yrange"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-idle|-title|-refresh|-yrange|-size)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-idle|-title|-refresh|-yrange|-size) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamMonitor_ foamMonitor
|
|
|
|
_foamNew_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -source -template"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-source|-template)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNew_ foamNew
|
|
|
|
_foamNewApp_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNewApp_ foamNewApp
|
|
|
|
_foamNewBC_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNewBC_ foamNewBC
|
|
|
|
_foamNewFunctionObject_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamNewFunctionObject_ foamNewFunctionObject
|
|
|
|
_foamRunTutorials_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -skipFirst -test"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamRunTutorials_ foamRunTutorials
|
|
|
|
_foamSearch_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-count -help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamSearch_ foamSearch
|
|
|
|
_foamSequenceVTKFiles_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-case -dir -help -out"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case|-dir|-out)
|
|
opts="" ; extra="-d" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamSequenceVTKFiles_ foamSequenceVTKFiles
|
|
|
|
_foamTags_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _foamTags_ foamTags
|
|
|
|
_icoUncoupledKinematicParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _icoUncoupledKinematicParcelFoam_ icoUncoupledKinematicParcelFoam
|
|
|
|
_interPhaseChangeFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _interPhaseChangeFoam_ interPhaseChangeFoam
|
|
|
|
_mpirunDebug_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _mpirunDebug_ mpirunDebug
|
|
|
|
_MPPICFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _MPPICFoam_ MPPICFoam
|
|
|
|
_paraFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-block -builtin -case -empty -help -region -touch -touchAll"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-case)
|
|
opts="" ; extra="-d" ;;
|
|
-region)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _paraFoam_ paraFoam
|
|
|
|
_reactingParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _reactingParcelFoam_ reactingParcelFoam
|
|
|
|
_uncoupledKinematicParcelFoam_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _uncoupledKinematicParcelFoam_ uncoupledKinematicParcelFoam
|
|
|
|
_wclean_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -silent"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wclean_ wclean
|
|
|
|
_wcleanLnIncludeAll_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*) opts="";;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wcleanLnIncludeAll_ wcleanLnIncludeAll
|
|
|
|
_wcleanPlatform_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -current -help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wcleanPlatform_ wcleanPlatform
|
|
|
|
_wdep_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wdep_ wdep
|
|
|
|
_wmake_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -help -j -j -non-stop -no-scheduler -queue -silent -update"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-j)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-j) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmake_ wmake
|
|
|
|
_wmakeCheckPwd_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -quiet"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeCheckPwd_ wmakeCheckPwd
|
|
|
|
_wmakeCollect_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-clean -help -kill"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeCollect_ wmakeCollect
|
|
|
|
_wmakeFilesAndOptions_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeFilesAndOptions_ wmakeFilesAndOptions
|
|
|
|
_wmakeLnInclude_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -silent -update"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeLnInclude_ wmakeLnInclude
|
|
|
|
_wmakeLnIncludeAll_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help -j -j"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-j)
|
|
opts="" ; extra="" ;;
|
|
-*) ;;
|
|
*)
|
|
case "${COMP_WORDS[COMP_CWORD-2]}" in
|
|
-j) ;;
|
|
*) opts=""; extra="" ;;
|
|
esac
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeLnIncludeAll_ wmakeLnIncludeAll
|
|
|
|
_wmakePrintBuild_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-check -help -major -pkg -short -update -version"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-pkg|-version)
|
|
opts="" ; extra="" ;;
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakePrintBuild_ wmakePrintBuild
|
|
|
|
_wmakeScheduler_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeScheduler_ wmakeScheduler
|
|
|
|
_wmakeSchedulerUptime_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wmakeSchedulerUptime_ wmakeSchedulerUptime
|
|
|
|
_wrmdep_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts=""
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra=""
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
*) ;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wrmdep_ wrmdep
|
|
|
|
_wrmo_ ()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local line=${COMP_LINE}
|
|
local used=$(echo "$line" | grep -oE "\-[a-zA-Z]+ ")
|
|
|
|
opts="-all -help"
|
|
for o in $used ; do opts="${opts/$o/}" ; done
|
|
extra="-d -f"
|
|
|
|
[ "$COMP_CWORD" = 1 ] || \
|
|
case "$prev" in
|
|
-*) ;;
|
|
*)
|
|
opts=""; extra=""
|
|
;;
|
|
esac
|
|
COMPREPLY=( $(compgen -W "${opts}" $extra -- ${cur}) )
|
|
}
|
|
complete -o filenames -o nospace -F _wrmo_ wrmo
|
|
|
|
#------------------------------------------------------------------------------
|