mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
9e88a8a21e
- added an explicit print, but only report profiling to the log file from master process. We don't wish to overwrite any profiling that was conducted during the simulation. Besides which, we don't have a proper Time object for handling the write nicely either.
8547 lines
265 KiB
Bash
8547 lines
265 KiB
Bash
#----------------------------------*-sh-*--------------------------------------
|
|
# Bash completions for OpenFOAM applications
|
|
# Formatted as "complete ... -F _of_APPNAME APPNAME
|
|
|
|
unset -f _of_filter_opts 2>/dev/null
|
|
_of_filter_opts()
|
|
{
|
|
local allOpts=$1
|
|
local applied=$2
|
|
for o in ${allOpts}; do
|
|
[ "${applied/$o/}" == "${applied}" ] && echo $o
|
|
done
|
|
}
|
|
|
|
unset -f _of_adiabaticFlameT 2>/dev/null
|
|
_of_adiabaticFlameT()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_adiabaticFlameT adiabaticFlameT
|
|
|
|
unset -f _of_adjointShapeOptimizationFoam 2>/dev/null
|
|
_of_adjointShapeOptimizationFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_adjointShapeOptimizationFoam adjointShapeOptimizationFoam
|
|
|
|
unset -f _of_ansysToFoam 2>/dev/null
|
|
_of_ansysToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_ansysToFoam ansysToFoam
|
|
|
|
unset -f _of_applyBoundaryLayer 2>/dev/null
|
|
_of_applyBoundaryLayer()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -ybl "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_applyBoundaryLayer applyBoundaryLayer
|
|
|
|
unset -f _of_attachMesh 2>/dev/null
|
|
_of_attachMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_attachMesh attachMesh
|
|
|
|
unset -f _of_autoPatch 2>/dev/null
|
|
_of_autoPatch()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_autoPatch autoPatch
|
|
|
|
unset -f _of_blockMesh 2>/dev/null
|
|
_of_blockMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-blockTopology -noClean -noFunctionObjects -sets -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict -region "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_blockMesh blockMesh
|
|
|
|
unset -f _of_boundaryFoam 2>/dev/null
|
|
_of_boundaryFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_boundaryFoam boundaryFoam
|
|
|
|
unset -f _of_boxTurb 2>/dev/null
|
|
_of_boxTurb()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_boxTurb boxTurb
|
|
|
|
unset -f _of_buoyantBoussinesqPimpleFoam 2>/dev/null
|
|
_of_buoyantBoussinesqPimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_buoyantBoussinesqPimpleFoam buoyantBoussinesqPimpleFoam
|
|
|
|
unset -f _of_buoyantBoussinesqSimpleFoam 2>/dev/null
|
|
_of_buoyantBoussinesqSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_buoyantBoussinesqSimpleFoam buoyantBoussinesqSimpleFoam
|
|
|
|
unset -f _of_buoyantPimpleFoam 2>/dev/null
|
|
_of_buoyantPimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_buoyantPimpleFoam buoyantPimpleFoam
|
|
|
|
unset -f _of_buoyantSimpleFoam 2>/dev/null
|
|
_of_buoyantSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_buoyantSimpleFoam buoyantSimpleFoam
|
|
|
|
unset -f _of_cavitatingDyMFoam 2>/dev/null
|
|
_of_cavitatingDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_cavitatingDyMFoam cavitatingDyMFoam
|
|
|
|
unset -f _of_cavitatingFoam 2>/dev/null
|
|
_of_cavitatingFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_cavitatingFoam cavitatingFoam
|
|
|
|
unset -f _of_cfx4ToFoam 2>/dev/null
|
|
_of_cfx4ToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_cfx4ToFoam cfx4ToFoam
|
|
|
|
unset -f _of_changeDictionary 2>/dev/null
|
|
_of_changeDictionary()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -disablePatchGroups -enableFunctionEntries -latestTime -literalRE -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -instance -region -roots -subDict -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_changeDictionary changeDictionary
|
|
|
|
unset -f _of_checkMesh 2>/dev/null
|
|
_of_checkMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-allGeometry -allTopology -constant -latestTime -meshQuality -newTimes -noFunctionObjects -noTopology -noZero -parallel -writeAllFields -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time -writeFields -writeSets "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_checkMesh checkMesh
|
|
|
|
unset -f _of_chemFoam 2>/dev/null
|
|
_of_chemFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_chemFoam chemFoam
|
|
|
|
unset -f _of_chemkinToFoam 2>/dev/null
|
|
_of_chemkinToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-newFormat -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_chemkinToFoam chemkinToFoam
|
|
|
|
unset -f _of_chtMultiRegionFoam 2>/dev/null
|
|
_of_chtMultiRegionFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_chtMultiRegionFoam chtMultiRegionFoam
|
|
|
|
unset -f _of_chtMultiRegionSimpleFoam 2>/dev/null
|
|
_of_chtMultiRegionSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_chtMultiRegionSimpleFoam chtMultiRegionSimpleFoam
|
|
|
|
unset -f _of_coalChemistryFoam 2>/dev/null
|
|
_of_coalChemistryFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_coalChemistryFoam coalChemistryFoam
|
|
|
|
unset -f _of_coldEngineFoam 2>/dev/null
|
|
_of_coldEngineFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_coldEngineFoam coldEngineFoam
|
|
|
|
unset -f _of_collapseEdges 2>/dev/null
|
|
_of_collapseEdges()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-collapseFaces -constant -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -collapseFaceSet -decomposeParDict -dict -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_collapseEdges collapseEdges
|
|
|
|
unset -f _of_combinePatchFaces 2>/dev/null
|
|
_of_combinePatchFaces()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-meshQuality -noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -concaveAngle -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_combinePatchFaces combinePatchFaces
|
|
|
|
unset -f _of_compressibleInterDyMFoam 2>/dev/null
|
|
_of_compressibleInterDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_compressibleInterDyMFoam compressibleInterDyMFoam
|
|
|
|
unset -f _of_compressibleInterFoam 2>/dev/null
|
|
_of_compressibleInterFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_compressibleInterFoam compressibleInterFoam
|
|
|
|
unset -f _of_compressibleMultiphaseInterFoam 2>/dev/null
|
|
_of_compressibleMultiphaseInterFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_compressibleMultiphaseInterFoam compressibleMultiphaseInterFoam
|
|
|
|
unset -f _of_createBaffles 2>/dev/null
|
|
_of_createBaffles()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_createBaffles createBaffles
|
|
|
|
unset -f _of_createExternalCoupledPatchGeometry 2>/dev/null
|
|
_of_createExternalCoupledPatchGeometry()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -commsDir -decomposeParDict -region -regions -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_createExternalCoupledPatchGeometry createExternalCoupledPatchGeometry
|
|
|
|
unset -f _of_createPatch 2>/dev/null
|
|
_of_createPatch()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -writeObj -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_createPatch createPatch
|
|
|
|
unset -f _of_createZeroDirectory 2>/dev/null
|
|
_of_createZeroDirectory()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots -templateDir "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_createZeroDirectory createZeroDirectory
|
|
|
|
unset -f _of_datToFoam 2>/dev/null
|
|
_of_datToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_datToFoam datToFoam
|
|
|
|
unset -f _of_decomposePar 2>/dev/null
|
|
_of_decomposePar()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-allRegions -cellDist -constant -copyUniform -copyZero -fields -force -ifRequired -latestTime -newTimes -noFunctionObjects -noSets -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_decomposePar decomposePar
|
|
|
|
unset -f _of_deformedGeom 2>/dev/null
|
|
_of_deformedGeom()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_deformedGeom deformedGeom
|
|
|
|
unset -f _of_dnsFoam 2>/dev/null
|
|
_of_dnsFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_dnsFoam dnsFoam
|
|
|
|
unset -f _of_DPMDyMFoam 2>/dev/null
|
|
_of_DPMDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloudName -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_DPMDyMFoam DPMDyMFoam
|
|
|
|
unset -f _of_DPMFoam 2>/dev/null
|
|
_of_DPMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloud -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_DPMFoam DPMFoam
|
|
|
|
unset -f _of_driftFluxFoam 2>/dev/null
|
|
_of_driftFluxFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_driftFluxFoam driftFluxFoam
|
|
|
|
unset -f _of_dsmcFoam 2>/dev/null
|
|
_of_dsmcFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_dsmcFoam dsmcFoam
|
|
|
|
unset -f _of_dsmcInitialise 2>/dev/null
|
|
_of_dsmcInitialise()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_dsmcInitialise dsmcInitialise
|
|
|
|
unset -f _of_electrostaticFoam 2>/dev/null
|
|
_of_electrostaticFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_electrostaticFoam electrostaticFoam
|
|
|
|
unset -f _of_engineCompRatio 2>/dev/null
|
|
_of_engineCompRatio()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_engineCompRatio engineCompRatio
|
|
|
|
unset -f _of_engineFoam 2>/dev/null
|
|
_of_engineFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_engineFoam engineFoam
|
|
|
|
unset -f _of_engineSwirl 2>/dev/null
|
|
_of_engineSwirl()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_engineSwirl engineSwirl
|
|
|
|
unset -f _of_equilibriumCO 2>/dev/null
|
|
_of_equilibriumCO()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_equilibriumCO equilibriumCO
|
|
|
|
unset -f _of_equilibriumFlameT 2>/dev/null
|
|
_of_equilibriumFlameT()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_equilibriumFlameT equilibriumFlameT
|
|
|
|
unset -f _of_extrude2DMesh 2>/dev/null
|
|
_of_extrude2DMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_extrude2DMesh extrude2DMesh
|
|
|
|
unset -f _of_extrudeMesh 2>/dev/null
|
|
_of_extrudeMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_extrudeMesh extrudeMesh
|
|
|
|
unset -f _of_extrudeToRegionMesh 2>/dev/null
|
|
_of_extrudeToRegionMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_extrudeToRegionMesh extrudeToRegionMesh
|
|
|
|
unset -f _of_faceAgglomerate 2>/dev/null
|
|
_of_faceAgglomerate()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_faceAgglomerate faceAgglomerate
|
|
|
|
unset -f _of_financialFoam 2>/dev/null
|
|
_of_financialFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_financialFoam financialFoam
|
|
|
|
unset -f _of_fireFoam 2>/dev/null
|
|
_of_fireFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_fireFoam fireFoam
|
|
|
|
unset -f _of_fireToFoam 2>/dev/null
|
|
_of_fireToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-ascii -check -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_fireToFoam fireToFoam
|
|
|
|
unset -f _of_flattenMesh 2>/dev/null
|
|
_of_flattenMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_flattenMesh flattenMesh
|
|
|
|
unset -f _of_fluent3DMeshToFoam 2>/dev/null
|
|
_of_fluent3DMeshToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-cubit -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -ignoreCellGroups -ignoreFaceGroups -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_fluent3DMeshToFoam fluent3DMeshToFoam
|
|
|
|
unset -f _of_fluentMeshToFoam 2>/dev/null
|
|
_of_fluentMeshToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -writeSets -writeZones -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_fluentMeshToFoam fluentMeshToFoam
|
|
|
|
unset -f _of_foamDataToFluent 2>/dev/null
|
|
_of_foamDataToFluent()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamDataToFluent foamDataToFluent
|
|
|
|
unset -f _of_foamDictionary 2>/dev/null
|
|
_of_foamDictionary()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-disableFunctionEntries -expand -includes -keywords -noFunctionObjects -parallel -remove -value -srcDoc -doc -help "
|
|
local optsWithArgs="-add -case -decomposeParDict -diff -entry -roots -set "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamDictionary foamDictionary
|
|
|
|
unset -f _of_foamFormatConvert 2>/dev/null
|
|
_of_foamFormatConvert()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -enableFunctionEntries -latestTime -newTimes -noConstant -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamFormatConvert foamFormatConvert
|
|
|
|
unset -f _of_foamHelp 2>/dev/null
|
|
_of_foamHelp()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamHelp foamHelp
|
|
|
|
unset -f _of_foamList 2>/dev/null
|
|
_of_foamList()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-compressibleTurbulenceModels -functionObjects -fvOptions -incompressibleTurbulenceModels -noFunctionObjects -registeredSwitches -switches -unset -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scalarBCs -vectorBCs "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamList foamList
|
|
|
|
unset -f _of_foamListTimes 2>/dev/null
|
|
_of_foamListTimes()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -processor -rm -withZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamListTimes foamListTimes
|
|
|
|
unset -f _of_foamMeshToFluent 2>/dev/null
|
|
_of_foamMeshToFluent()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamMeshToFluent foamMeshToFluent
|
|
|
|
unset -f _of_foamToEnsight 2>/dev/null
|
|
_of_foamToEnsight()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noLagrangian -noPatches -noZero -nodeValues -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cellZone -decomposeParDict -faceZones -fields -name -patches -region -roots -time -width "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToEnsight foamToEnsight
|
|
|
|
unset -f _of_foamToEnsightParts 2>/dev/null
|
|
_of_foamToEnsightParts()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noLagrangian -noMesh -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -index -name -time -width "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToEnsightParts foamToEnsightParts
|
|
|
|
unset -f _of_foamToFireMesh 2>/dev/null
|
|
_of_foamToFireMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-ascii -constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToFireMesh foamToFireMesh
|
|
|
|
unset -f _of_foamToGMV 2>/dev/null
|
|
_of_foamToGMV()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToGMV foamToGMV
|
|
|
|
unset -f _of_foamToStarMesh 2>/dev/null
|
|
_of_foamToStarMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noBnd -noFunctionObjects -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToStarMesh foamToStarMesh
|
|
|
|
unset -f _of_foamToSurface 2>/dev/null
|
|
_of_foamToSurface()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -tri -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToSurface foamToSurface
|
|
|
|
unset -f _of_foamToTetDualMesh 2>/dev/null
|
|
_of_foamToTetDualMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToTetDualMesh foamToTetDualMesh
|
|
|
|
unset -f _of_foamToVTK 2>/dev/null
|
|
_of_foamToVTK()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-allPatches -ascii -constant -latestTime -nearCellValue -newTimes -noFaceZones -noFunctionObjects -noInternal -noLagrangian -noLinks -noPointValues -noZero -parallel -poly -surfaceFields -useTimeName -xml -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cellSet -decomposeParDict -excludePatches -faceSet -fields -name -pointSet -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamToVTK foamToVTK
|
|
|
|
unset -f _of_foamUpgradeCyclics 2>/dev/null
|
|
_of_foamUpgradeCyclics()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -enableFunctionEntries -latestTime -newTimes -noFunctionObjects -noZero -parallel -test -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamUpgradeCyclics foamUpgradeCyclics
|
|
|
|
unset -f _of_foamyHexMesh 2>/dev/null
|
|
_of_foamyHexMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-checkGeometry -conformationOnly -noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamyHexMesh foamyHexMesh
|
|
|
|
unset -f _of_foamyQuadMesh 2>/dev/null
|
|
_of_foamyQuadMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
|
|
local optsWithArgs="-case -pointsFile "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_foamyQuadMesh foamyQuadMesh
|
|
|
|
unset -f _of_gambitToFoam 2>/dev/null
|
|
_of_gambitToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_gambitToFoam gambitToFoam
|
|
|
|
unset -f _of_gmshToFoam 2>/dev/null
|
|
_of_gmshToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-keepOrientation -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -region "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_gmshToFoam gmshToFoam
|
|
|
|
unset -f _of_icoFoam 2>/dev/null
|
|
_of_icoFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_icoFoam icoFoam
|
|
|
|
unset -f _of_icoUncoupledKinematicParcelDyMFoam 2>/dev/null
|
|
_of_icoUncoupledKinematicParcelDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloud -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_icoUncoupledKinematicParcelDyMFoam icoUncoupledKinematicParcelDyMFoam
|
|
|
|
unset -f _of_icoUncoupledKinematicParcelFoam 2>/dev/null
|
|
_of_icoUncoupledKinematicParcelFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloud -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_icoUncoupledKinematicParcelFoam icoUncoupledKinematicParcelFoam
|
|
|
|
unset -f _of_ideasUnvToFoam 2>/dev/null
|
|
_of_ideasUnvToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-dump -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_ideasUnvToFoam ideasUnvToFoam
|
|
|
|
unset -f _of_insideCells 2>/dev/null
|
|
_of_insideCells()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_insideCells insideCells
|
|
|
|
unset -f _of_interCondensatingEvaporatingFoam 2>/dev/null
|
|
_of_interCondensatingEvaporatingFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interCondensatingEvaporatingFoam interCondensatingEvaporatingFoam
|
|
|
|
unset -f _of_interDyMFoam 2>/dev/null
|
|
_of_interDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interDyMFoam interDyMFoam
|
|
|
|
unset -f _of_interFoam 2>/dev/null
|
|
_of_interFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interFoam interFoam
|
|
|
|
unset -f _of_interIsoFoam 2>/dev/null
|
|
_of_interIsoFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interIsoFoam interIsoFoam
|
|
|
|
unset -f _of_interMixingFoam 2>/dev/null
|
|
_of_interMixingFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interMixingFoam interMixingFoam
|
|
|
|
unset -f _of_interPhaseChangeDyMFoam 2>/dev/null
|
|
_of_interPhaseChangeDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interPhaseChangeDyMFoam interPhaseChangeDyMFoam
|
|
|
|
unset -f _of_interPhaseChangeFoam 2>/dev/null
|
|
_of_interPhaseChangeFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_interPhaseChangeFoam interPhaseChangeFoam
|
|
|
|
unset -f _of_kivaToFoam 2>/dev/null
|
|
_of_kivaToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -file -version -zHeadMin "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_kivaToFoam kivaToFoam
|
|
|
|
unset -f _of_laplacianFoam 2>/dev/null
|
|
_of_laplacianFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_laplacianFoam laplacianFoam
|
|
|
|
unset -f _of_lumpedPointForces 2>/dev/null
|
|
_of_lumpedPointForces()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noZero -parallel -vtk -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_lumpedPointForces lumpedPointForces
|
|
|
|
unset -f _of_lumpedPointMovement 2>/dev/null
|
|
_of_lumpedPointMovement()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-removeLock -slave -srcDoc -doc -help "
|
|
local optsWithArgs="-case -max -scale -span "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_lumpedPointMovement lumpedPointMovement
|
|
|
|
unset -f _of_lumpedPointZones 2>/dev/null
|
|
_of_lumpedPointZones()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-verbose -srcDoc -doc -help "
|
|
local optsWithArgs="-case -region "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_lumpedPointZones lumpedPointZones
|
|
|
|
unset -f _of_magneticFoam 2>/dev/null
|
|
_of_magneticFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noB -noFunctionObjects -noH -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_magneticFoam magneticFoam
|
|
|
|
unset -f _of_mapFields 2>/dev/null
|
|
_of_mapFields()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-consistent -noFunctionObjects -parallelSource -parallelTarget -subtract -srcDoc -doc -help "
|
|
local optsWithArgs="-case -mapMethod -sourceDecomposeParDict -sourceRegion -sourceTime -targetDecomposeParDict -targetRegion "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mapFields mapFields
|
|
|
|
unset -f _of_mapFieldsPar 2>/dev/null
|
|
_of_mapFieldsPar()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-consistent -noFunctionObjects -noLagrangian -parallel -subtract -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -fields -mapMethod -patchMapMethod -roots -sourceRegion -sourceTime -targetRegion "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mapFieldsPar mapFieldsPar
|
|
|
|
unset -f _of_mdEquilibrationFoam 2>/dev/null
|
|
_of_mdEquilibrationFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mdEquilibrationFoam mdEquilibrationFoam
|
|
|
|
unset -f _of_mdFoam 2>/dev/null
|
|
_of_mdFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mdFoam mdFoam
|
|
|
|
unset -f _of_mdInitialise 2>/dev/null
|
|
_of_mdInitialise()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mdInitialise mdInitialise
|
|
|
|
unset -f _of_mergeMeshes 2>/dev/null
|
|
_of_mergeMeshes()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-addRegion -case -decomposeParDict -masterRegion -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mergeMeshes mergeMeshes
|
|
|
|
unset -f _of_mergeOrSplitBaffles 2>/dev/null
|
|
_of_mergeOrSplitBaffles()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-detectOnly -noFunctionObjects -overwrite -parallel -split -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mergeOrSplitBaffles mergeOrSplitBaffles
|
|
|
|
unset -f _of_mhdFoam 2>/dev/null
|
|
_of_mhdFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mhdFoam mhdFoam
|
|
|
|
unset -f _of_mirrorMesh 2>/dev/null
|
|
_of_mirrorMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mirrorMesh mirrorMesh
|
|
|
|
unset -f _of_mixtureAdiabaticFlameT 2>/dev/null
|
|
_of_mixtureAdiabaticFlameT()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mixtureAdiabaticFlameT mixtureAdiabaticFlameT
|
|
|
|
unset -f _of_modifyMesh 2>/dev/null
|
|
_of_modifyMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_modifyMesh modifyMesh
|
|
|
|
unset -f _of_moveDynamicMesh 2>/dev/null
|
|
_of_moveDynamicMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-checkAMI -noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_moveDynamicMesh moveDynamicMesh
|
|
|
|
unset -f _of_moveEngineMesh 2>/dev/null
|
|
_of_moveEngineMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_moveEngineMesh moveEngineMesh
|
|
|
|
unset -f _of_moveMesh 2>/dev/null
|
|
_of_moveMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_moveMesh moveMesh
|
|
|
|
unset -f _of_MPPICDyMFoam 2>/dev/null
|
|
_of_MPPICDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloudName -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_MPPICDyMFoam MPPICDyMFoam
|
|
|
|
unset -f _of_MPPICFoam 2>/dev/null
|
|
_of_MPPICFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloud -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_MPPICFoam MPPICFoam
|
|
|
|
unset -f _of_MPPICInterFoam 2>/dev/null
|
|
_of_MPPICInterFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_MPPICInterFoam MPPICInterFoam
|
|
|
|
unset -f _of_mshToFoam 2>/dev/null
|
|
_of_mshToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-hex -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_mshToFoam mshToFoam
|
|
|
|
unset -f _of_multiphaseEulerFoam 2>/dev/null
|
|
_of_multiphaseEulerFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_multiphaseEulerFoam multiphaseEulerFoam
|
|
|
|
unset -f _of_multiphaseInterDyMFoam 2>/dev/null
|
|
_of_multiphaseInterDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_multiphaseInterDyMFoam multiphaseInterDyMFoam
|
|
|
|
unset -f _of_multiphaseInterFoam 2>/dev/null
|
|
_of_multiphaseInterFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_multiphaseInterFoam multiphaseInterFoam
|
|
|
|
unset -f _of_netgenNeutralToFoam 2>/dev/null
|
|
_of_netgenNeutralToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_netgenNeutralToFoam netgenNeutralToFoam
|
|
|
|
unset -f _of_noise 2>/dev/null
|
|
_of_noise()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_noise noise
|
|
|
|
unset -f _of_nonNewtonianIcoFoam 2>/dev/null
|
|
_of_nonNewtonianIcoFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_nonNewtonianIcoFoam nonNewtonianIcoFoam
|
|
|
|
unset -f _of_objToVTK 2>/dev/null
|
|
_of_objToVTK()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_objToVTK objToVTK
|
|
|
|
unset -f _of_orientFaceZone 2>/dev/null
|
|
_of_orientFaceZone()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_orientFaceZone orientFaceZone
|
|
|
|
unset -f _of_overInterDyMFoam 2>/dev/null
|
|
_of_overInterDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_overInterDyMFoam overInterDyMFoam
|
|
|
|
unset -f _of_overLaplacianDyMFoam 2>/dev/null
|
|
_of_overLaplacianDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_overLaplacianDyMFoam overLaplacianDyMFoam
|
|
|
|
unset -f _of_overPimpleDyMFoam 2>/dev/null
|
|
_of_overPimpleDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_overPimpleDyMFoam overPimpleDyMFoam
|
|
|
|
unset -f _of_overRhoPimpleDyMFoam 2>/dev/null
|
|
_of_overRhoPimpleDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_overRhoPimpleDyMFoam overRhoPimpleDyMFoam
|
|
|
|
unset -f _of_overSimpleFoam 2>/dev/null
|
|
_of_overSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_overSimpleFoam overSimpleFoam
|
|
|
|
unset -f _of_particleTracks 2>/dev/null
|
|
_of_particleTracks()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_particleTracks particleTracks
|
|
|
|
unset -f _of_patchSummary 2>/dev/null
|
|
_of_patchSummary()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -expand -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_patchSummary patchSummary
|
|
|
|
unset -f _of_pdfPlot 2>/dev/null
|
|
_of_pdfPlot()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_pdfPlot pdfPlot
|
|
|
|
unset -f _of_PDRFoam 2>/dev/null
|
|
_of_PDRFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_PDRFoam PDRFoam
|
|
|
|
unset -f _of_PDRMesh 2>/dev/null
|
|
_of_PDRMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_PDRMesh PDRMesh
|
|
|
|
unset -f _of_pimpleDyMFoam 2>/dev/null
|
|
_of_pimpleDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_pimpleDyMFoam pimpleDyMFoam
|
|
|
|
unset -f _of_pimpleFoam 2>/dev/null
|
|
_of_pimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_pimpleFoam pimpleFoam
|
|
|
|
unset -f _of_pisoFoam 2>/dev/null
|
|
_of_pisoFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_pisoFoam pisoFoam
|
|
|
|
unset -f _of_plot3dToFoam 2>/dev/null
|
|
_of_plot3dToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noBlank -noFunctionObjects -singleBlock -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_plot3dToFoam plot3dToFoam
|
|
|
|
unset -f _of_polyDualMesh 2>/dev/null
|
|
_of_polyDualMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-concaveMultiCells -doNotPreserveFaceZones -noFunctionObjects -overwrite -splitAllFaces -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_polyDualMesh polyDualMesh
|
|
|
|
unset -f _of_porousSimpleFoam 2>/dev/null
|
|
_of_porousSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_porousSimpleFoam porousSimpleFoam
|
|
|
|
unset -f _of_postChannel 2>/dev/null
|
|
_of_postChannel()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_postChannel postChannel
|
|
|
|
unset -f _of_postProcess 2>/dev/null
|
|
_of_postProcess()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -list -newTimes -noFunctionObjects -noZero -parallel -profiling -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -field -fields -func -funcs -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_postProcess postProcess
|
|
|
|
unset -f _of_potentialFoam 2>/dev/null
|
|
_of_potentialFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-initialiseUBCs -noFunctionObjects -parallel -withFunctionObjects -writePhi -writep -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -pName -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_potentialFoam potentialFoam
|
|
|
|
unset -f _of_potentialFreeSurfaceDyMFoam 2>/dev/null
|
|
_of_potentialFreeSurfaceDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_potentialFreeSurfaceDyMFoam potentialFreeSurfaceDyMFoam
|
|
|
|
unset -f _of_potentialFreeSurfaceFoam 2>/dev/null
|
|
_of_potentialFreeSurfaceFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_potentialFreeSurfaceFoam potentialFreeSurfaceFoam
|
|
|
|
unset -f _of_reactingFoam 2>/dev/null
|
|
_of_reactingFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reactingFoam reactingFoam
|
|
|
|
unset -f _of_reactingMultiphaseEulerFoam 2>/dev/null
|
|
_of_reactingMultiphaseEulerFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reactingMultiphaseEulerFoam reactingMultiphaseEulerFoam
|
|
|
|
unset -f _of_reactingParcelFilmFoam 2>/dev/null
|
|
_of_reactingParcelFilmFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reactingParcelFilmFoam reactingParcelFilmFoam
|
|
|
|
unset -f _of_reactingParcelFoam 2>/dev/null
|
|
_of_reactingParcelFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reactingParcelFoam reactingParcelFoam
|
|
|
|
unset -f _of_reactingTwoPhaseEulerFoam 2>/dev/null
|
|
_of_reactingTwoPhaseEulerFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reactingTwoPhaseEulerFoam reactingTwoPhaseEulerFoam
|
|
|
|
unset -f _of_reconstructPar 2>/dev/null
|
|
_of_reconstructPar()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-allRegions -constant -latestTime -newTimes -noFields -noFunctionObjects -noLagrangian -noSets -noZero -withZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -fields -lagrangianFields -region -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reconstructPar reconstructPar
|
|
|
|
unset -f _of_reconstructParMesh 2>/dev/null
|
|
_of_reconstructParMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-cellDist -constant -fullMatch -latestTime -newTimes -noFunctionObjects -noZero -withZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -mergeTol -region -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_reconstructParMesh reconstructParMesh
|
|
|
|
unset -f _of_redistributePar 2>/dev/null
|
|
_of_redistributePar()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-cellDist -constant -decompose -latestTime -newTimes -noFunctionObjects -noZero -overwrite -parallel -reconstruct -withZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -mergeTol -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_redistributePar redistributePar
|
|
|
|
unset -f _of_refineHexMesh 2>/dev/null
|
|
_of_refineHexMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-minSet -noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_refineHexMesh refineHexMesh
|
|
|
|
unset -f _of_refinementLevel 2>/dev/null
|
|
_of_refinementLevel()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -readLevel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_refinementLevel refinementLevel
|
|
|
|
unset -f _of_refineMesh 2>/dev/null
|
|
_of_refineMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-all -noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_refineMesh refineMesh
|
|
|
|
unset -f _of_refineWallLayer 2>/dev/null
|
|
_of_refineWallLayer()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots -useSet "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_refineWallLayer refineWallLayer
|
|
|
|
unset -f _of_removeFaces 2>/dev/null
|
|
_of_removeFaces()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_removeFaces removeFaces
|
|
|
|
unset -f _of_renumberMesh 2>/dev/null
|
|
_of_renumberMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -frontWidth -latestTime -noFunctionObjects -noZero -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_renumberMesh renumberMesh
|
|
|
|
unset -f _of_rhoCentralDyMFoam 2>/dev/null
|
|
_of_rhoCentralDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoCentralDyMFoam rhoCentralDyMFoam
|
|
|
|
unset -f _of_rhoCentralFoam 2>/dev/null
|
|
_of_rhoCentralFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoCentralFoam rhoCentralFoam
|
|
|
|
unset -f _of_rhoPimpleDyMFoam 2>/dev/null
|
|
_of_rhoPimpleDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoPimpleDyMFoam rhoPimpleDyMFoam
|
|
|
|
unset -f _of_rhoPimpleFoam 2>/dev/null
|
|
_of_rhoPimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoPimpleFoam rhoPimpleFoam
|
|
|
|
unset -f _of_rhoPorousSimpleFoam 2>/dev/null
|
|
_of_rhoPorousSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoPorousSimpleFoam rhoPorousSimpleFoam
|
|
|
|
unset -f _of_rhoReactingBuoyantFoam 2>/dev/null
|
|
_of_rhoReactingBuoyantFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoReactingBuoyantFoam rhoReactingBuoyantFoam
|
|
|
|
unset -f _of_rhoReactingFoam 2>/dev/null
|
|
_of_rhoReactingFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoReactingFoam rhoReactingFoam
|
|
|
|
unset -f _of_rhoSimpleFoam 2>/dev/null
|
|
_of_rhoSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rhoSimpleFoam rhoSimpleFoam
|
|
|
|
unset -f _of_rotateMesh 2>/dev/null
|
|
_of_rotateMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_rotateMesh rotateMesh
|
|
|
|
unset -f _of_scalarTransportFoam 2>/dev/null
|
|
_of_scalarTransportFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_scalarTransportFoam scalarTransportFoam
|
|
|
|
unset -f _of_selectCells 2>/dev/null
|
|
_of_selectCells()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_selectCells selectCells
|
|
|
|
unset -f _of_setAlphaField 2>/dev/null
|
|
_of_setAlphaField()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_setAlphaField setAlphaField
|
|
|
|
unset -f _of_setFields 2>/dev/null
|
|
_of_setFields()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_setFields setFields
|
|
|
|
unset -f _of_setSet 2>/dev/null
|
|
_of_setSet()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -loop -newTimes -noFunctionObjects -noSync -noVTK -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-batch -case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_setSet setSet
|
|
|
|
unset -f _of_setsToZones 2>/dev/null
|
|
_of_setsToZones()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFlipMap -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_setsToZones setsToZones
|
|
|
|
unset -f _of_shallowWaterFoam 2>/dev/null
|
|
_of_shallowWaterFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_shallowWaterFoam shallowWaterFoam
|
|
|
|
unset -f _of_simpleCoalParcelFoam 2>/dev/null
|
|
_of_simpleCoalParcelFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_simpleCoalParcelFoam simpleCoalParcelFoam
|
|
|
|
unset -f _of_simpleFoam 2>/dev/null
|
|
_of_simpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_simpleFoam simpleFoam
|
|
|
|
unset -f _of_simpleReactingParcelFoam 2>/dev/null
|
|
_of_simpleReactingParcelFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_simpleReactingParcelFoam simpleReactingParcelFoam
|
|
|
|
unset -f _of_singleCellMesh 2>/dev/null
|
|
_of_singleCellMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_singleCellMesh singleCellMesh
|
|
|
|
unset -f _of_smapToFoam 2>/dev/null
|
|
_of_smapToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_smapToFoam smapToFoam
|
|
|
|
unset -f _of_snappyHexMesh 2>/dev/null
|
|
_of_snappyHexMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-checkGeometry -noFunctionObjects -overwrite -parallel -profiling -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -outFile -patches -region -roots -surfaceSimplify "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_snappyHexMesh snappyHexMesh
|
|
|
|
unset -f _of_snappyRefineMesh 2>/dev/null
|
|
_of_snappyRefineMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_snappyRefineMesh snappyRefineMesh
|
|
|
|
unset -f _of_solidDisplacementFoam 2>/dev/null
|
|
_of_solidDisplacementFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_solidDisplacementFoam solidDisplacementFoam
|
|
|
|
unset -f _of_solidEquilibriumDisplacementFoam 2>/dev/null
|
|
_of_solidEquilibriumDisplacementFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_solidEquilibriumDisplacementFoam solidEquilibriumDisplacementFoam
|
|
|
|
unset -f _of_sonicDyMFoam 2>/dev/null
|
|
_of_sonicDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_sonicDyMFoam sonicDyMFoam
|
|
|
|
unset -f _of_sonicFoam 2>/dev/null
|
|
_of_sonicFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_sonicFoam sonicFoam
|
|
|
|
unset -f _of_sonicLiquidFoam 2>/dev/null
|
|
_of_sonicLiquidFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_sonicLiquidFoam sonicLiquidFoam
|
|
|
|
unset -f _of_splitCells 2>/dev/null
|
|
_of_splitCells()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-geometry -noFunctionObjects -overwrite -srcDoc -doc -help "
|
|
local optsWithArgs="-case -set -tol "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_splitCells splitCells
|
|
|
|
unset -f _of_splitMesh 2>/dev/null
|
|
_of_splitMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_splitMesh splitMesh
|
|
|
|
unset -f _of_splitMeshRegions 2>/dev/null
|
|
_of_splitMeshRegions()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-cellZones -cellZonesOnly -detectOnly -largestOnly -makeCellZones -noFunctionObjects -overwrite -parallel -prefixRegion -sloppyCellZones -useFaceZones -srcDoc -doc -help "
|
|
local optsWithArgs="-blockedFaces -case -cellZonesFileOnly -decomposeParDict -insidePoint -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_splitMeshRegions splitMeshRegions
|
|
|
|
unset -f _of_sprayDyMFoam 2>/dev/null
|
|
_of_sprayDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_sprayDyMFoam sprayDyMFoam
|
|
|
|
unset -f _of_sprayEngineFoam 2>/dev/null
|
|
_of_sprayEngineFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_sprayEngineFoam sprayEngineFoam
|
|
|
|
unset -f _of_sprayFoam 2>/dev/null
|
|
_of_sprayFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_sprayFoam sprayFoam
|
|
|
|
unset -f _of_SRFPimpleFoam 2>/dev/null
|
|
_of_SRFPimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_SRFPimpleFoam SRFPimpleFoam
|
|
|
|
unset -f _of_SRFSimpleFoam 2>/dev/null
|
|
_of_SRFSimpleFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_SRFSimpleFoam SRFSimpleFoam
|
|
|
|
unset -f _of_star4ToFoam 2>/dev/null
|
|
_of_star4ToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-ascii -noFunctionObjects -solids -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_star4ToFoam star4ToFoam
|
|
|
|
unset -f _of_steadyParticleTracks 2>/dev/null
|
|
_of_steadyParticleTracks()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict -region -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_steadyParticleTracks steadyParticleTracks
|
|
|
|
unset -f _of_stitchMesh 2>/dev/null
|
|
_of_stitchMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -partial -perfect -srcDoc -doc -help "
|
|
local optsWithArgs="-case -region -toleranceDict "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_stitchMesh stitchMesh
|
|
|
|
unset -f _of_subsetMesh 2>/dev/null
|
|
_of_subsetMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -overwrite -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -patch -patches -region -resultTime -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_subsetMesh subsetMesh
|
|
|
|
unset -f _of_surfaceAdd 2>/dev/null
|
|
_of_surfaceAdd()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-mergeRegions -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -points "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceAdd surfaceAdd
|
|
|
|
unset -f _of_surfaceBooleanFeatures 2>/dev/null
|
|
_of_surfaceBooleanFeatures()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-invertedSpace -noFunctionObjects -perturb -surf1Baffle -surf2Baffle -srcDoc -doc -help "
|
|
local optsWithArgs="-case -trim "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceBooleanFeatures surfaceBooleanFeatures
|
|
|
|
unset -f _of_surfaceCheck 2>/dev/null
|
|
_of_surfaceCheck()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-blockMesh -checkSelfIntersection -noFunctionObjects -splitNonManifold -verbose -srcDoc -doc -help "
|
|
local optsWithArgs="-case -outputThreshold "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceCheck surfaceCheck
|
|
|
|
unset -f _of_surfaceClean 2>/dev/null
|
|
_of_surfaceClean()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noClean -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceClean surfaceClean
|
|
|
|
unset -f _of_surfaceCoarsen 2>/dev/null
|
|
_of_surfaceCoarsen()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceCoarsen surfaceCoarsen
|
|
|
|
unset -f _of_surfaceConvert 2>/dev/null
|
|
_of_surfaceConvert()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-clean -group -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale -writePrecision "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceConvert surfaceConvert
|
|
|
|
unset -f _of_surfaceFeatureConvert 2>/dev/null
|
|
_of_surfaceFeatureConvert()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceFeatureConvert surfaceFeatureConvert
|
|
|
|
unset -f _of_surfaceFeatureExtract 2>/dev/null
|
|
_of_surfaceFeatureExtract()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceFeatureExtract surfaceFeatureExtract
|
|
|
|
unset -f _of_surfaceFind 2>/dev/null
|
|
_of_surfaceFind()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -x -y -z "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceFind surfaceFind
|
|
|
|
unset -f _of_surfaceHookUp 2>/dev/null
|
|
_of_surfaceHookUp()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceHookUp surfaceHookUp
|
|
|
|
unset -f _of_surfaceInertia 2>/dev/null
|
|
_of_surfaceInertia()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -shellProperties -srcDoc -doc -help "
|
|
local optsWithArgs="-case -density -referencePoint "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceInertia surfaceInertia
|
|
|
|
unset -f _of_surfaceInflate 2>/dev/null
|
|
_of_surfaceInflate()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-checkSelfIntersection -debug -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -featureAngle -nSmooth "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceInflate surfaceInflate
|
|
|
|
unset -f _of_surfaceLambdaMuSmooth 2>/dev/null
|
|
_of_surfaceLambdaMuSmooth()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs="-featureFile "
|
|
|
|
case ${prev} in
|
|
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceLambdaMuSmooth surfaceLambdaMuSmooth
|
|
|
|
unset -f _of_surfaceMeshConvert 2>/dev/null
|
|
_of_surfaceMeshConvert()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-clean -noFunctionObjects -tri -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict -from -scaleIn -scaleOut -to "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceMeshConvert surfaceMeshConvert
|
|
|
|
unset -f _of_surfaceMeshConvertTesting 2>/dev/null
|
|
_of_surfaceMeshConvertTesting()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-clean -noFunctionObjects -orient -stdout -surfMesh -testModify -triFace -triSurface -unsorted -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceMeshConvertTesting surfaceMeshConvertTesting
|
|
|
|
unset -f _of_surfaceMeshExport 2>/dev/null
|
|
_of_surfaceMeshExport()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-clean -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict -from -name -scaleIn -scaleOut -to "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceMeshExport surfaceMeshExport
|
|
|
|
unset -f _of_surfaceMeshImport 2>/dev/null
|
|
_of_surfaceMeshImport()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-clean -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict -from -name -scaleIn -scaleOut -to "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceMeshImport surfaceMeshImport
|
|
|
|
unset -f _of_surfaceMeshInfo 2>/dev/null
|
|
_of_surfaceMeshInfo()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-areas -noFunctionObjects -xml -srcDoc -doc -help "
|
|
local optsWithArgs="-case -scale "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceMeshInfo surfaceMeshInfo
|
|
|
|
unset -f _of_surfaceMeshTriangulate 2>/dev/null
|
|
_of_surfaceMeshTriangulate()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -excludeProcPatches -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -faceZones -patches -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceMeshTriangulate surfaceMeshTriangulate
|
|
|
|
unset -f _of_surfaceOrient 2>/dev/null
|
|
_of_surfaceOrient()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-inside -noFunctionObjects -usePierceTest -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceOrient surfaceOrient
|
|
|
|
unset -f _of_surfacePatch 2>/dev/null
|
|
_of_surfacePatch()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -dict "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfacePatch surfacePatch
|
|
|
|
unset -f _of_surfacePointMerge 2>/dev/null
|
|
_of_surfacePointMerge()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfacePointMerge surfacePointMerge
|
|
|
|
unset -f _of_surfaceRedistributePar 2>/dev/null
|
|
_of_surfaceRedistributePar()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-keepNonMapped -noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceRedistributePar surfaceRedistributePar
|
|
|
|
unset -f _of_surfaceRefineRedGreen 2>/dev/null
|
|
_of_surfaceRefineRedGreen()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceRefineRedGreen surfaceRefineRedGreen
|
|
|
|
unset -f _of_surfaceSplitByPatch 2>/dev/null
|
|
_of_surfaceSplitByPatch()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceSplitByPatch surfaceSplitByPatch
|
|
|
|
unset -f _of_surfaceSplitByTopology 2>/dev/null
|
|
_of_surfaceSplitByTopology()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-srcDoc -doc -help "
|
|
local optsWithArgs=" "
|
|
|
|
case ${prev} in
|
|
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceSplitByTopology surfaceSplitByTopology
|
|
|
|
unset -f _of_surfaceSplitNonManifolds 2>/dev/null
|
|
_of_surfaceSplitNonManifolds()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-debug -noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceSplitNonManifolds surfaceSplitNonManifolds
|
|
|
|
unset -f _of_surfaceSubset 2>/dev/null
|
|
_of_surfaceSubset()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceSubset surfaceSubset
|
|
|
|
unset -f _of_surfaceToPatch 2>/dev/null
|
|
_of_surfaceToPatch()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -faceSet -tol "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceToPatch surfaceToPatch
|
|
|
|
unset -f _of_surfaceTransformPoints 2>/dev/null
|
|
_of_surfaceTransformPoints()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case -rollPitchYaw -rotate -scale -translate -yawPitchRoll "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_surfaceTransformPoints surfaceTransformPoints
|
|
|
|
unset -f _of_temporalInterpolate 2>/dev/null
|
|
_of_temporalInterpolate()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -divisions -fields -interpolationType -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_temporalInterpolate temporalInterpolate
|
|
|
|
unset -f _of_tetgenToFoam 2>/dev/null
|
|
_of_tetgenToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFaceFile -noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_tetgenToFoam tetgenToFoam
|
|
|
|
unset -f _of_thermoFoam 2>/dev/null
|
|
_of_thermoFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_thermoFoam thermoFoam
|
|
|
|
unset -f _of_topoSet 2>/dev/null
|
|
_of_topoSet()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noSync -noZero -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -dict -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_topoSet topoSet
|
|
|
|
unset -f _of_transformPoints 2>/dev/null
|
|
_of_transformPoints()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -rotateFields -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -rollPitchYaw -roots -rotate -scale -translate -yawPitchRoll "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_transformPoints transformPoints
|
|
|
|
unset -f _of_twoLiquidMixingFoam 2>/dev/null
|
|
_of_twoLiquidMixingFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_twoLiquidMixingFoam twoLiquidMixingFoam
|
|
|
|
unset -f _of_twoPhaseEulerFoam 2>/dev/null
|
|
_of_twoPhaseEulerFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_twoPhaseEulerFoam twoPhaseEulerFoam
|
|
|
|
unset -f _of_uncoupledKinematicParcelFoam 2>/dev/null
|
|
_of_uncoupledKinematicParcelFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cloud -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_uncoupledKinematicParcelFoam uncoupledKinematicParcelFoam
|
|
|
|
unset -f _of_viewFactorsGen 2>/dev/null
|
|
_of_viewFactorsGen()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_viewFactorsGen viewFactorsGen
|
|
|
|
unset -f _of_vtkUnstructuredToFoam 2>/dev/null
|
|
_of_vtkUnstructuredToFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -srcDoc -doc -help "
|
|
local optsWithArgs="-case "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_vtkUnstructuredToFoam vtkUnstructuredToFoam
|
|
|
|
unset -f _of_wallFunctionTable 2>/dev/null
|
|
_of_wallFunctionTable()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_wallFunctionTable wallFunctionTable
|
|
|
|
unset -f _of_writeMeshObj 2>/dev/null
|
|
_of_writeMeshObj()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-constant -latestTime -newTimes -noFunctionObjects -noZero -parallel -patchEdges -patchFaces -srcDoc -doc -help "
|
|
local optsWithArgs="-case -cell -cellSet -decomposeParDict -face -faceSet -point -region -roots -time "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
-time)
|
|
COMPREPLY=($(compgen -d -X '![-0-9]*' -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_writeMeshObj writeMeshObj
|
|
|
|
unset -f _of_XiDyMFoam 2>/dev/null
|
|
_of_XiDyMFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_XiDyMFoam XiDyMFoam
|
|
|
|
unset -f _of_XiFoam 2>/dev/null
|
|
_of_XiFoam()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -postProcess -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_XiFoam XiFoam
|
|
|
|
unset -f _of_zipUpMesh 2>/dev/null
|
|
_of_zipUpMesh()
|
|
{
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
local opts="-noFunctionObjects -parallel -srcDoc -doc -help "
|
|
local optsWithArgs="-case -decomposeParDict -region -roots "
|
|
|
|
case ${prev} in
|
|
-case)
|
|
COMPREPLY=($(compgen -d -- ${cur}))
|
|
;;
|
|
*Dict)
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
;;
|
|
-region)
|
|
local regions=$(sed 's#/##g' <<< $([ -d system ] && (\cd system && (\ls -d */ 2>/dev/null))))
|
|
COMPREPLY=($(compgen -W "$regions" -- ${cur}))
|
|
;;
|
|
*)
|
|
if [ "${optsWithArgs/${prev} /}" != "${optsWithArgs}" ]
|
|
then
|
|
# Unknown type of arg follows - set to files.
|
|
# Not always correct but can still navigate path if needed...
|
|
COMPREPLY=($(compgen -f -- ${cur}))
|
|
else
|
|
# Catch-all - present all remaining options
|
|
opts=$(_of_filter_opts "${opts}" "${COMP_LINE}")
|
|
optsWithArgs=$(_of_filter_opts "${optsWithArgs}" "${COMP_LINE}")
|
|
COMPREPLY=($(compgen -W "${opts} ${optsWithArgs}" -- ${cur}))
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return 0
|
|
}
|
|
complete -o nospace -F _of_zipUpMesh zipUpMesh
|
|
|
|
|
|
#------------------------------------------------------------------------------
|