cape.pyfun.options: FUN3D and pyFun settings

cape.pyfun.options: FUN3D options interface module

This module provides the options interface for cape.pyfun. Many settings are inherited from cape.cfdx.options, and there are some additional options specific to FUN3D for pyfun.

See also:

• cape.cfdx.options

class cape.pyfun.options.Options(*args, **kw)

Options interface for cape.pyfun

Call:

>>> opts = Options(fname=None, **kw)

Inputs:

fname: str

File to be read as a JSON file with comments

kw: dict

Dictionary to be transformed into pyCart.options.Options

Versions:

• 2014-07-28 @ddalle: Version 1.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_ConfigInput(comp)

Return the input for a particular component

Call:

>>> inp = opts.get_ConfigInput(comp)

Inputs:

opts: Options

Options interface

Outputs:

inp: str | list[int]

List of BCs in this component

Versions:

• 2015-10-20 @ddalle: Version 1.0

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_Faux(comp=None)

Get the geometry information for a faux_input component

Call:

>>> faux = opts.get_Faux(comp=None)

Inputs:

opts: cape.cfdx.options.Options

Options interface

comp: {None} | str

Name or number of component to process (all if None)

Outputs:

faux: dict | float | list

faux_input plane definition(s)

Versions:

• 2017-02-23 @ddalle: v1.0

• 2023-03-17 @ddalle: v2.0; use OptionsDict

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

Get name of faux_input template file

Call:

>>> FauxFile = opts.get_FauxFile(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

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:

FauxFile: {None} | str

name of faux_input template file

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

Get value of option “FreezeComponents”

Call:

>>> FreezeComponents = opts.get_FreezeComponents(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

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:

FreezeComponents: {None} | object

value of option “FreezeComponents”

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

Get name of file w/ compIDs to freeze during adaptation

Call:

>>> FreezeFile = opts.get_FreezeFile(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

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:

FreezeFile: {None} | str

name of file w/ compIDs to freeze during adaptation

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

Get template fun3d.nml file

Call:

>>> Fun3DNamelist = opts.get_Fun3DNamelist(j=None, i=None, **kw)

Inputs:

opts: Options

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:

Fun3DNamelist: {'fun3d.nml'} | str

template fun3d.nml file

get_FunctionalAdaptCoeffs()

Get list of coefficients in any adaptation function

Call:

>>> coeffs = opts.get_AdaptCoeffs()

Inputs:

opts: pyFun.options.Options

Options interface

Ouutputs:

coeffs: list[str]

List of coefficients in the adaptive function

Versions:

• 2016-04-26 @ddalle: v1.0

get_FunctionalCoeffOpt(coeff: str, opt: str, j=None, **kw)

Get option for a specific functional coefficient

Call:

>>> v = opts.get_FunctionalCoeffOpt(coeff, opt, j=None, **kw)

Inputs:

opts: OptionsDict

Options interface

coeff: str

Name of coefficient

opt: str

Name of functional option

Outputs:

v: object

Value of opts[fn][opt] or as appropriate

Versions:

• 2023-05-16 @ddalle: v1.0

get_FunctionalFuncOpt(fn: str, opt: str, j=None, **kw)

Get option for a specific functional function

Call:

>>> v = opts.get_FunctionalFuncOpt(fn, opt, j=None, **kw)

Inputs:

opts: OptionsDict

Options interface

fn: str

Name of function

opt: str

Name of functional option

Outputs:

v: object

Value of opts[fn][opt] or as appropriate

Versions:

• 2023-05-16 @ddalle: v1.0

get_FunctionalFuncsByType(typ: str)

Get list of functions by type

Call:

>>> funcs = opts.get_FunctionalFuncsByType(typ)

Inputs:

opts: OptionsDict

Options interface

typ: str

Requested type

Outputs:

funcs: list[str]

List of function names

Versions:

• 2016-04-25 @ddalle: v1.0

• 2023-05-16 @ddalle: v2.0

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

Get dictionary of component indices for named comps

Call:

>>> Inputs = opts.get_Inputs(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

Inputs: {None} | dict

dictionary of component indices for named comps

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_KeepTemplateComponents(j=None, i=None, **kw)

Get add to template component_parameters

Call:

>>> KeepTemplateComponents = opts.get_KeepTemplateComponents(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

KeepTemplateComponents: {False} | object

add to template component_parameters

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

Get template kinetic_data file

Call:

>>> KineticDataFile = opts.get_KineticDataFile(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

KineticDataFile: {'inputs/kinetic_data'} | str

template kinetic_data file

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

Get name of the boundary condition map file

Call:

>>> MapBCFile = opts.get_MapBCFile(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

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:

MapBCFile: {None} | str

name of the boundary condition map file

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

Get template moving_body.input file

Call:

>>> MovingBodyInputFile = opts.get_MovingBodyInputFile(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

MovingBodyInputFile: {'inputs/moving_body.input'} | str

template moving_body.input file

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

Get template for rubber.data file

Call:

>>> RubberDataFile = opts.get_RubberDataFile(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

RubberDataFile: {'inputs/rubber.data'} | str

template for rubber.data file

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

Get template species_thermo_data file

Call:

>>> SpeciesThermoDataFile = opts.get_SpeciesThermoDataFile(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

SpeciesThermoDataFile: {'inputs/species_thermo_data'} | str

template species_thermo_data file

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

Get template for tdata file

Call:

>>> TDataFile = opts.get_TDataFile(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

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:

TDataFile: {'inputs/tdata'} | str

template for tdata file

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_grid_format(j=None, **kw)

Return the grid format

Call:

>>> fmat = opts.get_grid_format(i=None)

Inputs:

opts: Options

Options interface

j: {None} | int

Phase index

Outputs:

fmat: str

Grid format

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-13 @ddalle: v2.0; use OptionsDict

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_namelist_var(sec, key, j=None, **kw)

Select a namelist key from a specified section

Roughly, this returns opts[sec][key].

Call:

>>> val = opts.get_namelist_var(sec, key, j=None, **kw)

Inputs:

opts: Options

Options interface

sec: str

Section name

key: str

Variable name

j: {None} | int

Phase index

Outputs:

val: object

Value from JSON options

Versions:

• 2015-10-19 @ddalle: v1.0

• 2023-05-16 @ddalle: v2.0; OptionsDict tools

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_project()

Return the project namelist

Call:

>>> d = opts.get_project(i=None)

Inputs:

opts: Options

Options interface

Outputs:

d: pyFun.options.odict

Project namelist

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-13 @ddalle: v2.0; use OptionsDict

get_project_rootname(j=None, **kw)

Return the project root name

Call:

>>> rname = opts.get_project_rootname(j=None, **kw)

Inputs:

opts: Options

Options interface

j: {None} | int

Phase index

Outputs:

rname: str

Project root name

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-13 @ddalle: v2.0; use OptionsDict

get_raw_grid()

Return the raw_grid namelist

Call:

>>> d = opts.get_raw_grid(i=None)

Inputs:

opts: Options

Options interface

Outputs:

d: pyFun.options.odict

Grid namelist

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-13 @ddalle: v2.0; use OptionsDict

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

init_post()

Initialization hook for Options

Call:

>>> opts.init_post()

Inputs:

opts: Options

Options interface

Versions:

• 2022-10-23 @ddalle: v1.0

• 2024-12-25 @ddalle: v1.1; remove template JSON

select_dual_namelist(j=0, **kw)

Sample “dual” namelist at particular conditions

Call:

>>> d = opts.select_dual_namelist(i)

Inputs:

opts: Options

Options interface

j: {0} | int

Phase index

Outputs:

d: dict

Namelist sampled for phase and case indices

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-16 @ddalle: v2.0; OptionsDict tools

• 2023-05-18 @ddalle: v2.1; fork get_namelist()

select_moving_body_input(j=0, **kw)

Sample “dual” namelist at particular conditions

Call:

>>> d = opts.select_moving_body_input(i)

Inputs:

opts: Options

Options interface

j: {0} | int

Phase index

Outputs:

d: dict

Namelist sampled for phase and case indices

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-16 @ddalle: v2.0; OptionsDict tools

• 2023-05-18 @ddalle: v2.1; fork get_namelist()

select_namelist(j=0, **kw)

Sample namelist at particular conditions

Call:

>>> d = opts.select_namelist(i)

Inputs:

opts: Options

Options interface

j: {0} | int

Phase index

Outputs:

d: dict

Namelist sampled for phase and case indices

Versions:

• 2015-10-18 @ddalle: v1.0

• 2023-05-16 @ddalle: v2.0; OptionsDict tools

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_ConfigInput(comp, inp)

Set the input for a particular component

Call:

>>> opts.set_ConfigInput(comp, nip)

Inputs:

opts: Options

Options interface

inp: str | list[int]

List of BCs in this component

Versions:

• 2015-10-20 @ddalle: Version 1.0

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_FauxFile(v, j=None, mode=None)

Get name of faux_input template file

Call:

>>> opts.set_FauxFile(FauxFile, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

FauxFile: {None} | str

name of faux_input template file

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_FreezeComponents(v, j=None, mode=None)

Get value of option “FreezeComponents”

Call:

>>> opts.set_FreezeComponents(FreezeComponents, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

FreezeComponents: {None} | object

value of option “FreezeComponents”

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_FreezeFile(v, j=None, mode=None)

Get name of file w/ compIDs to freeze during adaptation

Call:

>>> opts.set_FreezeFile(FreezeFile, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

FreezeFile: {None} | str

name of file w/ compIDs to freeze during 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_Fun3DNamelist(v, j=None, mode=None)

Get template fun3d.nml file

Call:

>>> opts.set_Fun3DNamelist(Fun3DNamelist, j=None, i=None, **kw)

Inputs:

opts: Options

options interface

Fun3DNamelist: {'fun3d.nml'} | str

template fun3d.nml file

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_Inputs(v, j=None, mode=None)

Get dictionary of component indices for named comps

Call:

>>> opts.set_Inputs(Inputs, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

Inputs: {None} | dict

dictionary of component indices for named comps

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_KeepTemplateComponents(v, j=None, mode=None)

Get add to template component_parameters

Call:

>>> opts.set_KeepTemplateComponents(KeepTemplateComponents, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

KeepTemplateComponents: {False} | object

add to template component_parameters

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_KineticDataFile(v, j=None, mode=None)

Get template kinetic_data file

Call:

>>> opts.set_KineticDataFile(KineticDataFile, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

KineticDataFile: {'inputs/kinetic_data'} | str

template kinetic_data file

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_MapBCFile(v, j=None, mode=None)

Get name of the boundary condition map file

Call:

>>> opts.set_MapBCFile(MapBCFile, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

MapBCFile: {None} | str

name of the boundary condition map file

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_MovingBodyInputFile(v, j=None, mode=None)

Get template moving_body.input file

Call:

>>> opts.set_MovingBodyInputFile(MovingBodyInputFile, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

MovingBodyInputFile: {'inputs/moving_body.input'} | str

template moving_body.input file

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_RubberDataFile(v, j=None, mode=None)

Get template for rubber.data file

Call:

>>> opts.set_RubberDataFile(RubberDataFile, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

RubberDataFile: {'inputs/rubber.data'} | str

template for rubber.data file

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_SpeciesThermoDataFile(v, j=None, mode=None)

Get template species_thermo_data file

Call:

>>> opts.set_SpeciesThermoDataFile(SpeciesThermoDataFile, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

SpeciesThermoDataFile: {'inputs/species_thermo_data'} | str

template species_thermo_data file

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_TDataFile(v, j=None, mode=None)

Get template for tdata file

Call:

>>> opts.set_TDataFile(TDataFile, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

TDataFile: {'inputs/tdata'} | str

template for tdata file

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_namelist_var(sec, key, val, j=None)

Set a namelist key for a specified phase or phases

Roughly, this sets opts["Fun3D"][sec][key] or opts["Fun3D"][sec][key][i] equal to val

Call:

>>> opts.set_namelist_var(sec, key, val, i=None)

Inputs:

opts: Options

Options interface

sec: str

Section name

key: str

Variable name

val: int | float | str | list

Value from JSON options

j: {None} | int

Phase index

Versions:

• 2017-04-05 @ddalle: v1.0

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

• cape.pyfun.options.archiveopts
• cape.pyfun.options.configopts: FUn3D surface config opts
• cape.pyfun.options.databookopts
• cape.pyfun.options.fun3dnmlopts: FUN3D namelist options
• cape.pyfun.options.functionalopts: rubber.data settings
• cape.pyfun.options.meshopts
• cape.pyfun.options.runctlopts: FUN3D run control options
• cape.pyfun.options.util: Utilities for pyFun options module