cape.pyfun.options.runctlopts: FUN3D run control options

Options interface for aspects of running a case of FUN3D. The settings are read from the "RunControl" of a JSON file, and the contents of this section are written to case.json within each run folder.

The FUN3D-specific options include adaptation settings and command-line arguments for both nodet and dual.

See Also:
class cape.pyfun.options.runctlopts.DualOpts(*args, **kw)

Class for FUN3D dual settings

Call:
>>> opts = DualOpts(**kw)
Inputs:
kw: dict

Raw options

Outputs:
opts: DualOpts

CLI options for dual from FUN3D

Versions:

  • 2015-11-24 @ddalle: Version 1.0 (dual)

  • 2022-11-03 @ddalle: Version 2.0; use optdict

get_dual_adapt(j=None, i=None, **kw)

Get whether to adapt when running FUN3D dual

Call:
>>> adapt = opts.get_dual_adapt(j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
adapt: {True} | False

whether to adapt when running FUN3D dual

get_dual_outer_loop_krylov(j=None, i=None, **kw)

Get option to use Krylov method in outer loop

Call:
>>> outer_loop_krylov = opts.get_dual_outer_loop_krylov(j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
outer_loop_krylov: {True} | False

option to use Krylov method in outer loop

get_dual_rad(j=None, i=None, **kw)

Get option to use residual adjoint dot product

Call:
>>> rad = opts.get_dual_rad(j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
rad: {True} | False

option to use residual adjoint dot product

set_dual_adapt(v, j=None, mode=None)

Get whether to adapt when running FUN3D dual

Call:
>>> opts.set_dual_adapt(adapt, j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

adapt: {True} | False

whether to adapt when running FUN3D dual

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_dual_outer_loop_krylov(v, j=None, mode=None)

Get option to use Krylov method in outer loop

Call:
>>> opts.set_dual_outer_loop_krylov(outer_loop_krylov, j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

outer_loop_krylov: {True} | False

option to use Krylov method in outer loop

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_dual_rad(v, j=None, mode=None)

Get option to use residual adjoint dot product

Call:
>>> opts.set_dual_rad(rad, j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

rad: {True} | False

option to use residual adjoint dot product

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.pyfun.options.runctlopts.NodetOpts(*args, **kw)

Class for nodet settings

Call:
>>> opts = NodetOpts(**kw)
Inputs:
kw: dict

Raw options

Outputs:
opts: NodetOpts

CLI options for nodet or mpi_nodet

Versions:

  • 2015-11-24 @ddalle: Version 1.0 (nodet)

  • 2022-11-03 @ddalle: Version 2.0; use optdict

get_nodet_adapt(j=None, i=None, **kw)

Get whether to run nodet in grid adaptation mode

Call:
>>> adapt = opts.get_nodet_adapt(j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
adapt: {None} | True | False

whether to run nodet in grid adaptation mode

get_nodet_animation_freq(j=None, i=None, **kw)

Get animation frequency for nodet

Call:
>>> animation_freq = opts.get_nodet_animation_freq(j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
animation_freq: {None} | int

animation frequency for nodet

get_nodet_plt_tecplot_output(j=None, i=None, **kw)

Get option to write .plt files

Call:
>>> plt_tecplot_output = opts.get_nodet_plt_tecplot_output(j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
plt_tecplot_output: {False} | True

option to write .plt files

set_nodet_adapt(v, j=None, mode=None)

Get whether to run nodet in grid adaptation mode

Call:
>>> opts.set_nodet_adapt(adapt, j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

adapt: {None} | True | False

whether to run nodet in grid adaptation mode

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_nodet_animation_freq(v, j=None, mode=None)

Get animation frequency for nodet

Call:
>>> opts.set_nodet_animation_freq(animation_freq, j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

animation_freq: {None} | int

animation frequency for nodet

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_nodet_plt_tecplot_output(v, j=None, mode=None)

Get option to write .plt files

Call:
>>> opts.set_nodet_plt_tecplot_output(plt_tecplot_output, j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

plt_tecplot_output: {False} | True

option to write .plt files

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.pyfun.options.runctlopts.RunControlOpts(*args, **kw)

FUN3D-specific “RunControl” options interface

Call:
>>> opts = RunControl(**kw)
Inputs:
kw: dict

Dictionary of “RunControl” settings

Outputs:
opts: Options

Options interface

Versions:

  • 2015-09-28 @ddalle: Version 1.0

  • 2022-10-24 @ddalle: Version 2.0

get_AdaptMethod(j=None, i=None, **kw)

Get version of REFINE to use for adaptation

Call:
>>> AdaptMethod = opts.get_AdaptMethod(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
AdaptMethod: {'refine/one'} | 'refine/three'

version of REFINE to use for adaptation

get_AdaptPhase(j=None, i=None, **kw)

Get whether or not to adapt mesh at end of phase

Call:
>>> AdaptPhase = opts.get_AdaptPhase(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
AdaptPhase: {True} | False

whether or not to adapt mesh at end of phase

get_AdaptationNumber(j=None)

Get the adaptation number for a given phase

Call:
>>> nadapt = opts.get_AdaptationNumber(j=None)
Inputs:
opts: cape.pyfun.options.Options

Options interface

j: {None} | int

Phase number

Outputs:
nadapt: int | None

Number of adaptations prior to phase j

Versions:

  • 2015-12-31 @ddalle: Version 1.0

  • 2022-10-24 @ddalle: Version 1.1; use PhaseSequence

get_Adaptive(j=None, i=None, **kw)

Get whether or not to run adaptively

Call:
>>> Adaptive = opts.get_Adaptive(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
Adaptive: {False} | True

whether or not to run adaptively

get_Dual(j=None, i=None, **kw)

Get whether or not to run all adaptations with adjoint

Call:
>>> Dual = opts.get_Dual(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
Dual: {False} | True

whether or not to run all adaptations with adjoint

get_DualPhase(j=None, i=None, **kw)

Get whether or not to run phase in dual mode

Call:
>>> DualPhase = opts.get_DualPhase(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
DualPhase: {True} | False

whether or not to run phase in dual mode

get_KeepRestarts(j=None, i=None, **kw)

Get whether or not to keep restart files

Call:
>>> KeepRestarts = opts.get_KeepRestarts(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
KeepRestarts: {False} | True

whether or not to keep restart files

get_dual_adapt(j=None, i=None, **kw)

Get whether to adapt when running FUN3D dual

Call:
>>> adapt = opts.get_dual_adapt(j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
adapt: {True} | False

whether to adapt when running FUN3D dual

get_dual_outer_loop_krylov(j=None, i=None, **kw)

Get option to use Krylov method in outer loop

Call:
>>> outer_loop_krylov = opts.get_dual_outer_loop_krylov(j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
outer_loop_krylov: {True} | False

option to use Krylov method in outer loop

get_dual_rad(j=None, i=None, **kw)

Get option to use residual adjoint dot product

Call:
>>> rad = opts.get_dual_rad(j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
rad: {True} | False

option to use residual adjoint dot product

get_nIterAdjoint(j=None, i=None, **kw)

Get number of iterations for adjoint solver

Call:
>>> nIterAdjoint = opts.get_nIterAdjoint(j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
nIterAdjoint: {200} | int

number of iterations for adjoint solver

get_nodet_adapt(j=None, i=None, **kw)

Get whether to run nodet in grid adaptation mode

Call:
>>> adapt = opts.get_nodet_adapt(j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
adapt: {None} | True | False

whether to run nodet in grid adaptation mode

get_nodet_animation_freq(j=None, i=None, **kw)

Get animation frequency for nodet

Call:
>>> animation_freq = opts.get_nodet_animation_freq(j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
animation_freq: {None} | int

animation frequency for nodet

get_nodet_plt_tecplot_output(j=None, i=None, **kw)

Get option to write .plt files

Call:
>>> plt_tecplot_output = opts.get_nodet_plt_tecplot_output(j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
plt_tecplot_output: {False} | True

option to write .plt files

get_refine_complexity(j=None, i=None, **kw)

Get value of option “complexity”

Call:
>>> complexity = opts.get_refine_complexity(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
complexity: {None} | object

value of option “complexity”

get_refine_initial_complexity(j=None, i=None, **kw)

Get starting projected grid complexity

Call:
>>> initial_complexity = opts.get_refine_initial_complexity(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
initial_complexity: {None} | str

starting projected grid complexity

get_refine_input(j=None, i=None, **kw)

Get value of option “input”

Call:
>>> input = opts.get_refine_input(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
input: {None} | object

value of option “input”

get_refine_interpolant(j=None, i=None, **kw)

Get value of option “interpolant”

Call:
>>> interpolant = opts.get_refine_interpolant(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
interpolant: {None} | object

value of option “interpolant”

get_refine_mapbc(j=None, i=None, **kw)

Get value of option “mapbc”

Call:
>>> mapbc = opts.get_refine_mapbc(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
mapbc: {None} | object

value of option “mapbc”

get_refine_output(j=None, i=None, **kw)

Get value of option “output”

Call:
>>> output = opts.get_refine_output(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
output: {None} | object

value of option “output”

get_refine_ramp_complexity(j=None, i=None, **kw)

Get amount to increase complexity between iterations

Call:
>>> ramp_complexity = opts.get_refine_ramp_complexity(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
ramp_complexity: {None} | str

amount to increase complexity between iterations

get_refine_sweeps(j=None, i=None, **kw)

Get value of option “sweeps”

Call:
>>> sweeps = opts.get_refine_sweeps(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
sweeps: {5} | object

value of option “sweeps”

get_refine_target_complexity(j=None, i=None, **kw)

Get final complexity

Call:
>>> target_complexity = opts.get_refine_target_complexity(j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
target_complexity: {None} | str

final complexity

set_AdaptMethod(v, j=None, mode=None)

Get version of REFINE to use for adaptation

Call:
>>> opts.set_AdaptMethod(AdaptMethod, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

AdaptMethod: {'refine/one'} | 'refine/three'

version of REFINE to use for adaptation

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_AdaptPhase(v, j=None, mode=None)

Get whether or not to adapt mesh at end of phase

Call:
>>> opts.set_AdaptPhase(AdaptPhase, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

AdaptPhase: {True} | False

whether or not to adapt mesh at end of phase

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_Adaptive(v, j=None, mode=None)

Get whether or not to run adaptively

Call:
>>> opts.set_Adaptive(Adaptive, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

Adaptive: {False} | True

whether or not to run adaptively

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_Dual(v, j=None, mode=None)

Get whether or not to run all adaptations with adjoint

Call:
>>> opts.set_Dual(Dual, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

Dual: {False} | True

whether or not to run all adaptations with adjoint

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_DualPhase(v, j=None, mode=None)

Get whether or not to run phase in dual mode

Call:
>>> opts.set_DualPhase(DualPhase, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

DualPhase: {True} | False

whether or not to run phase in dual mode

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_KeepRestarts(v, j=None, mode=None)

Get whether or not to keep restart files

Call:
>>> opts.set_KeepRestarts(KeepRestarts, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

KeepRestarts: {False} | True

whether or not to keep restart files

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_dual_adapt(v, j=None, mode=None)

Get whether to adapt when running FUN3D dual

Call:
>>> opts.set_dual_adapt(adapt, j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

adapt: {True} | False

whether to adapt when running FUN3D dual

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_dual_outer_loop_krylov(v, j=None, mode=None)

Get option to use Krylov method in outer loop

Call:
>>> opts.set_dual_outer_loop_krylov(outer_loop_krylov, j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

outer_loop_krylov: {True} | False

option to use Krylov method in outer loop

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_dual_rad(v, j=None, mode=None)

Get option to use residual adjoint dot product

Call:
>>> opts.set_dual_rad(rad, j=None, i=None, **kw)
Inputs:
opts: DualOpts

options interface

rad: {True} | False

option to use residual adjoint dot product

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_nIterAdjoint(v, j=None, mode=None)

Get number of iterations for adjoint solver

Call:
>>> opts.set_nIterAdjoint(nIterAdjoint, j=None, i=None, **kw)
Inputs:
opts: RunControlOpts

options interface

nIterAdjoint: {200} | int

number of iterations for adjoint solver

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_nodet_adapt(v, j=None, mode=None)

Get whether to run nodet in grid adaptation mode

Call:
>>> opts.set_nodet_adapt(adapt, j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

adapt: {None} | True | False

whether to run nodet in grid adaptation mode

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_nodet_animation_freq(v, j=None, mode=None)

Get animation frequency for nodet

Call:
>>> opts.set_nodet_animation_freq(animation_freq, j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

animation_freq: {None} | int

animation frequency for nodet

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_nodet_plt_tecplot_output(v, j=None, mode=None)

Get option to write .plt files

Call:
>>> opts.set_nodet_plt_tecplot_output(plt_tecplot_output, j=None, i=None, **kw)
Inputs:
opts: NodetOpts

options interface

plt_tecplot_output: {False} | True

option to write .plt files

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_complexity(v, j=None, mode=None)

Get value of option “complexity”

Call:
>>> opts.set_refine_complexity(complexity, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

complexity: {None} | object

value of option “complexity”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_initial_complexity(v, j=None, mode=None)

Get starting projected grid complexity

Call:
>>> opts.set_refine_initial_complexity(initial_complexity, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

initial_complexity: {None} | str

starting projected grid complexity

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_input(v, j=None, mode=None)

Get value of option “input”

Call:
>>> opts.set_refine_input(input, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

input: {None} | object

value of option “input”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_interpolant(v, j=None, mode=None)

Get value of option “interpolant”

Call:
>>> opts.set_refine_interpolant(interpolant, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

interpolant: {None} | object

value of option “interpolant”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_mapbc(v, j=None, mode=None)

Get value of option “mapbc”

Call:
>>> opts.set_refine_mapbc(mapbc, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

mapbc: {None} | object

value of option “mapbc”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_output(v, j=None, mode=None)

Get value of option “output”

Call:
>>> opts.set_refine_output(output, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

output: {None} | object

value of option “output”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_ramp_complexity(v, j=None, mode=None)

Get amount to increase complexity between iterations

Call:
>>> opts.set_refine_ramp_complexity(ramp_complexity, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

ramp_complexity: {None} | str

amount to increase complexity between iterations

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_sweeps(v, j=None, mode=None)

Get value of option “sweeps”

Call:
>>> opts.set_refine_sweeps(sweeps, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

sweeps: {5} | object

value of option “sweeps”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_refine_target_complexity(v, j=None, mode=None)

Get final complexity

Call:
>>> opts.set_refine_target_complexity(target_complexity, j=None, i=None, **kw)
Inputs:
opts: RefineOpts

options interface

target_complexity: {None} | str

final complexity

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar