cape.pycart.options.runctlopts: Cart3D run control options

Options interface for case control for pycart runs of Cart3D. This is mostly a fork of

cape.cfdx.options.runctlopts

but with several special methods, including command-line options to autoInputs, cubes, flowCart, and adjointCart.

Classes:

• cape.pycart.options.runControl.RunControl

• cape.pycart.options.runControl.Adaptation

• cape.pycart.options.runControl.flowCart

• cape.pycart.options.runControl.adjointCart

• cape.pycart.options.runControl.autoInputs

• cape.pycart.options.runControl.cubes

• cape.pycart.options.Archive.Archive

• cape.cfdx.options.runControl.Environ

• cape.cfdx.options.ulimit.ulimit

See Also:

• cape.cfdx.options.runControl

• cape.cfdx.options.ulimit

• cape.pycart.options.Archive

class cape.pycart.options.runctlopts.AdaptationOpts(*args, **kw)

Class for Cart3D mesh adaptation settings

This mostly affects the file aero.csh.

Call:

>>> opts = AdaptationOpts(**kw)

Inputs:

kw: dict

Raw options

Outputs:

opts: AdaptationOpts

Cart3D mesh adaptation settings for pycart

Versions:

• 2014-12-17 @ddalle: v1.0 (Adaptation)

• 2022-11-02 @ddalle: v2.0; use optdict

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

Get number of buffer layers

Call:

>>> abuff = opts.get_abuff(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

buf: {1} | int

number of buffer layers

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

Get adaptation cycle type (adapt/propagate)

Call:

>>> apc = opts.get_apc(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

apc: {'a'} | 'p'

adaptation cycle type (adapt/propagate)

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

Get number of buffer layers

Call:

>>> buf = opts.get_buf(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

buf: {1} | int

number of buffer layers

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

Get target output error tolerance

Call:

>>> etol = opts.get_etol(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

etol: {1e-06} | float

target output error tolerance

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

Get num. of additional adapts using final error map

Call:

>>> final_mesh_xref = opts.get_final_mesh_xref(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

final_mesh_xref: {0} | int

num. of additional adapts using final error map

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

Get whether to create meshes b4 running aero.csh

Call:

>>> jumpstart = opts.get_jumpstart(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

jumpstart: {False} | True

whether to create meshes b4 running aero.csh

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

Get maximum cell count

Call:

>>> max_nCells = opts.get_max_nCells(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

max_nCells: {5000000.0} | int

maximum cell count

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

Get mesh growth ratio between cycles of aero.csh

Call:

>>> mesh_growth = opts.get_mesh_growth(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

mesh_growth: {1.5} | float

mesh growth ratio between cycles of aero.csh

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

Get number of Cart3D adaptation cycles in phase

Call:

>>> n_adapt_cycles = opts.get_n_adapt_cycles(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

n_adapt_cycles: {0} | int

number of Cart3D adaptation cycles in phase

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

Get number of flowCart iters for aero.csh cycles

Call:

>>> ws_it = opts.get_ws_it(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

ws_it: {50} | int

number of flowCart iters for aero.csh cycles

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

Get number of buffer layers

Call:

>>> opts.set_abuff(abuff, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

buf: {1} | int

number of buffer layers

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

Get adaptation cycle type (adapt/propagate)

Call:

>>> opts.set_apc(apc, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

apc: {'a'} | 'p'

adaptation cycle type (adapt/propagate)

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

Get number of buffer layers

Call:

>>> opts.set_buf(buf, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

buf: {1} | int

number of buffer layers

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

Get target output error tolerance

Call:

>>> opts.set_etol(etol, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

etol: {1e-06} | float

target output error tolerance

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

Get num. of additional adapts using final error map

Call:

>>> opts.set_final_mesh_xref(final_mesh_xref, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

final_mesh_xref: {0} | int

num. of additional adapts using final error map

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

Get whether to create meshes b4 running aero.csh

Call:

>>> opts.set_jumpstart(jumpstart, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

jumpstart: {False} | True

whether to create meshes b4 running aero.csh

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

Get maximum cell count

Call:

>>> opts.set_max_nCells(max_nCells, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

max_nCells: {5000000.0} | int

maximum cell count

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

Get mesh growth ratio between cycles of aero.csh

Call:

>>> opts.set_mesh_growth(mesh_growth, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

mesh_growth: {1.5} | float

mesh growth ratio between cycles of aero.csh

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

Get number of Cart3D adaptation cycles in phase

Call:

>>> opts.set_n_adapt_cycles(n_adapt_cycles, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

n_adapt_cycles: {0} | int

number of Cart3D adaptation cycles in 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_ws_it(v, j=None, mode=None)

Get number of flowCart iters for aero.csh cycles

Call:

>>> opts.set_ws_it(ws_it, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

ws_it: {50} | int

number of flowCart iters for aero.csh cycles

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.pycart.options.runctlopts.AdjointCartOpts(*args, **kw)

Class for adjointCart settings

Call:

>>> opts = AdjointCartOpts(**kw)

Inputs:

kw: dict

Raw options

Outputs:

opts: AdjointCartOpts

CLI options for adjointCart

Versions:

• 2014-12-17 @ddalle: v1.0 (adjointCart)

• 2022-11-02 @ddalle: v2.0; use optdict

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

Get value of option “adj_first_order”

Call:

>>> adj_first_order = opts.get_adj_first_order(j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

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:

adj_first_order: {False} | True

value of option “adj_first_order”

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

Get value of option “it_ad”

Call:

>>> it_ad = opts.get_it_ad(j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

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:

it_ad: {120} | int

value of option “it_ad”

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

Get value of option “mg_ad”

Call:

>>> mg_ad = opts.get_mg_ad(j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

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:

mg_ad: {3} | int

value of option “mg_ad”

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

Get value of option “adj_first_order”

Call:

>>> opts.set_adj_first_order(adj_first_order, j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

options interface

adj_first_order: {False} | True

value of option “adj_first_order”

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

Get value of option “it_ad”

Call:

>>> opts.set_it_ad(it_ad, j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

options interface

it_ad: {120} | int

value of option “it_ad”

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

Get value of option “mg_ad”

Call:

>>> opts.set_mg_ad(mg_ad, j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

options interface

mg_ad: {3} | int

value of option “mg_ad”

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.pycart.options.runctlopts.AutoInputsOpts(*args, **kw)

Class for cart3D autoInputs settings

Call:

>>> opts = AdjointCartOpts(**kw)

Inputs:

kw: dict

Raw options

Outputs:

opts: AutoInputsOpts

CLI options for autoInputs

Versions:

• 2014-12-17 @ddalle: v1.0 (autoInputs)

• 2022-11-03 @ddalle: v2.0; use optdict

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

Get whether to create a symmetric half-body mesh

Call:

>>> halfBody = opts.get_autoInputs_halfBody(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

halfBody: {None} | True | False

whether to create a symmetric half-body mesh

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

Get maximum number of cell refinements

Call:

>>> maxR = opts.get_autoInputs_maxR(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

maxR: {10} | int

maximum number of cell refinements

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

Get option to make 2D mesh

Call:

>>> mesh2d = opts.get_autoInputs_mesh2d(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

mesh2d: {None} | True | False

option to make 2D mesh

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

Get number of divisions in background mesh

Call:

>>> nDiv = opts.get_autoInputs_nDiv(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

nDiv: {4} | int

number of divisions in background mesh

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

Get nominal autoInputs mesh radius

Call:

>>> r = opts.get_autoInputs_r(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

r: {30.0} | int | float

nominal autoInputs mesh radius

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

Get whether to execute program

Call:

>>> run = opts.get_autoInputs_run(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

run: {None} | True | False

whether to execute program

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

Get use yz-plane as symmetry plane with halfBody

Call:

>>> symmX = opts.get_autoInputs_symmX(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

symmX: {None} | True | False

use yz-plane as symmetry plane with halfBody

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

Get use xz-plane as symmetry plane with halfBody

Call:

>>> symmY = opts.get_autoInputs_symmY(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

symmY: {None} | True | False

use xz-plane as symmetry plane with halfBody

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

Get use xy-plane as symmetry plane with halfBody

Call:

>>> symmZ = opts.get_autoInputs_symmZ(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

symmZ: {None} | True | False

use xy-plane as symmetry plane with halfBody

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

Get whether to create a symmetric half-body mesh

Call:

>>> opts.set_autoInputs_halfBody(halfBody, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

halfBody: {None} | True | False

whether to create a symmetric half-body mesh

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

Get maximum number of cell refinements

Call:

>>> opts.set_autoInputs_maxR(maxR, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

maxR: {10} | int

maximum number of cell refinements

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

Get option to make 2D mesh

Call:

>>> opts.set_autoInputs_mesh2d(mesh2d, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

mesh2d: {None} | True | False

option to make 2D mesh

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

Get number of divisions in background mesh

Call:

>>> opts.set_autoInputs_nDiv(nDiv, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

nDiv: {4} | int

number of divisions in background mesh

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

Get nominal autoInputs mesh radius

Call:

>>> opts.set_autoInputs_r(r, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

r: {30.0} | int | float

nominal autoInputs mesh radius

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

Get whether to execute program

Call:

>>> opts.set_autoInputs_run(run, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

run: {None} | True | False

whether to execute program

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

Get use yz-plane as symmetry plane with halfBody

Call:

>>> opts.set_autoInputs_symmX(symmX, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

symmX: {None} | True | False

use yz-plane as symmetry plane with halfBody

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

Get use xz-plane as symmetry plane with halfBody

Call:

>>> opts.set_autoInputs_symmY(symmY, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

symmY: {None} | True | False

use xz-plane as symmetry plane with halfBody

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

Get use xy-plane as symmetry plane with halfBody

Call:

>>> opts.set_autoInputs_symmZ(symmZ, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

symmZ: {None} | True | False

use xy-plane as symmetry plane with halfBody

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.pycart.options.runctlopts.CubesOpts(*args, **kw)

Class for Cart3D cubes settings

Call:

>>> opts = CubesOpts(**kw)

Inputs:

kw: dict

Raw options

Outputs:

opts: CubesOpts

CLI options for cubes

Versions:

• 2014-12-17 @ddalle: v1.0 (cubes)

• 2022-11-03 @ddalle: v2.0; use optdict

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

Get angle threshold [deg] for geom refinement

Call:

>>> a = opts.get_cubes_a(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

a: {10.0} | int | float

angle threshold [deg] for geom refinement

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

Get number of layers of buffer cells

Call:

>>> b = opts.get_cubes_b(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

b: {2} | int

number of layers of buffer cells

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

Get whether to execute program

Call:

>>> run = opts.get_cubes_run(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

run: {None} | True | False

whether to execute program

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

Get maximum number of refinements in cubes mesh

Call:

>>> maxR = opts.get_maxR(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

maxR: {11} | int

maximum number of refinements in cubes mesh

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

Get value of option “pre”

Call:

>>> preSpecCntl = opts.get_preSpecCntl(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

pre: {'preSpec.c3d.cntl'} | str

value of option “pre”

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

Get whether to reorder output mesh

Call:

>>> reorder = opts.get_reorder(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

reorder: {True} | False

whether to reorder output mesh

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

Get additional levels at sharp edges

Call:

>>> sf = opts.get_sf(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

sf: {0} | int

additional levels at sharp edges

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

Get angle threshold [deg] for geom refinement

Call:

>>> opts.set_cubes_a(a, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

a: {10.0} | int | float

angle threshold [deg] for geom refinement

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

Get number of layers of buffer cells

Call:

>>> opts.set_cubes_b(b, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

b: {2} | int

number of layers of buffer cells

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

Get whether to execute program

Call:

>>> opts.set_cubes_run(run, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

run: {None} | True | False

whether to execute program

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

Get maximum number of refinements in cubes mesh

Call:

>>> opts.set_maxR(maxR, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

maxR: {11} | int

maximum number of refinements in cubes mesh

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

Get value of option “pre”

Call:

>>> opts.set_preSpecCntl(preSpecCntl, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

pre: {'preSpec.c3d.cntl'} | str

value of option “pre”

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

Get whether to reorder output mesh

Call:

>>> opts.set_reorder(reorder, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

reorder: {True} | False

whether to reorder output mesh

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

Get additional levels at sharp edges

Call:

>>> opts.set_sf(sf, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

sf: {0} | int

additional levels at sharp edges

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.pycart.options.runctlopts.FlowCartOpts(*args, **kw)

Class for flowCart settings

Call:

>>> opts = FlowCartOpts(**kw)

Inputs:

kw: dict

Raw options

Outputs:

opts: FlowCartOpts

CLI options for flowCart or mpi_flowCart

Versions:

• 2014-12-17 @ddalle: v1.0 (flowCart)

• 2022-11-01 @ddalle: v2.0; use optdict

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

Get the Runge-Kutta scheme for a phase

Call:

>>> RKScheme = opts.get_RKScheme(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

RKScheme: {None} | list | str

the Runge-Kutta scheme for a phase

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

Get whether flowCart is set for binary I/O

Call:

>>> binaryIO = opts.get_binaryIO(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

binaryIO: {True} | False

whether flowCart is set for binary I/O

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

Get whether flowCart will use buffer limits

Call:

>>> buffLim = opts.get_buffLim(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

buffLim: {False} | True

whether flowCart will use buffer limits

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

Get nominal CFL number for flowCart

Call:

>>> cfl = opts.get_cfl(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

cfl: {1.1} | float

nominal CFL number for flowCart

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

Get min CFL number for flowCart

Call:

>>> cflmin = opts.get_cflmin(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

cflmin: {0.8} | float

min CFL number for flowCart

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

Get steps between unsteady flowCart checkpoints

Call:

>>> checkptTD = opts.get_checkptTD(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

checkptTD: {None} | int

steps between unsteady flowCart checkpoints

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

Get whether to write Components.i.triq

Call:

>>> clic = opts.get_clic(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

clic: {True} | False

whether to write Components.i.triq

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

Get nondimensional physical time step

Call:

>>> dt = opts.get_dt(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

dt: {0.1} | float

nondimensional physical time step

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

Get whether to run relaxation step before time-accurate step

Call:

>>> fc_clean = opts.get_fc_clean(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

fc_clean: {False} | True

whether to run relaxation step before time-accurate step

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

Get number of iters for iterative or time averaging

Call:

>>> fc_stats = opts.get_fc_stats(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

fc_stats: {0} | int

number of iters for iterative or time averaging

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

Get whether flowCart should be run first-order

Call:

>>> first_order = opts.get_first_order(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

first_order: {False} | True

whether flowCart should be run first-order

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

Get whether to run flowCart w/ full multigrid

Call:

>>> fmg = opts.get_fmg(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

fmg: {True} | False

whether to run flowCart w/ full multigrid

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

Get number of flowCart iters b/w .triq outputs

Call:

>>> it_avg = opts.get_it_avg(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_avg: {0} | int

number of flowCart iters b/w .triq outputs

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

Get number of flowCart iterations

Call:

>>> it_fc = opts.get_it_fc(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_fc: {200} | int

number of flowCart iterations

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

Get number of flowCart iters b4 .triq outputs

Call:

>>> it_start = opts.get_it_start(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_start: {100} | int

number of flowCart iters b4 .triq outputs

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

Get number of subiters for each flowCart time step

Call:

>>> it_sub = opts.get_it_sub(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_sub: {10} | int

number of subiters for each flowCart time step

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

Get limiter for flowCart

Call:

>>> limiter = opts.get_limiter(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

limiter: {2} | int

limiter for flowCart

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

Get multigrid levels for flowCart

Call:

>>> mg_fc = opts.get_mg_fc(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

mg_fc: {3} | int

multigrid levels for flowCart

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

Get whether or not to run mpi_flowCart

Call:

>>> mpi_fc = opts.get_mpi_fc(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

mpi_fc: {False} | True | int

whether or not to run mpi_flowCart

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

Get convergence drop orders of magnitude for early exit

Call:

>>> nOrders = opts.get_nOrders(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

nOrders: {12} | int

convergence drop orders of magnitude for early exit

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

Get whether to run flowCart w/ poly multigrid

Call:

>>> pmg = opts.get_pmg(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

pmg: {False} | True

whether to run flowCart w/ poly multigrid

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

Get whether flowCart should be run in robust mode

Call:

>>> robust_mode = opts.get_robust_mode(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

robust_mode: {False} | True

whether flowCart should be run in robust mode

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

Get whether flowCart dumps Tecplot triangulations

Call:

>>> tecO = opts.get_tecO(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

tecO: {True} | False

whether flowCart dumps Tecplot triangulations

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

Get whether flowCart is set for cut cell gradient

Call:

>>> tm = opts.get_tm(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

tm: {False} | True

whether flowCart is set for cut cell gradient

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

Get whether to run time-accurate flowCart

Call:

>>> unsteady = opts.get_unsteady(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

unsteady: {False} | True

whether to run time-accurate flowCart

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

Get steps between flowCart visualization outputs

Call:

>>> vizTD = opts.get_vizTD(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

vizTD: {None} | int

steps between flowCart visualization outputs

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

Get whether y is spanwise axis for flowCart

Call:

>>> y_is_spanwise = opts.get_y_is_spanwise(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

y_is_spanwise: {True} | False

whether y is spanwise axis for flowCart

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

Get the Runge-Kutta scheme for a phase

Call:

>>> opts.set_RKScheme(RKScheme, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

RKScheme: {None} | list | str

the Runge-Kutta scheme for a 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_binaryIO(v, j=None, mode=None)

Get whether flowCart is set for binary I/O

Call:

>>> opts.set_binaryIO(binaryIO, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

binaryIO: {True} | False

whether flowCart is set for binary I/O

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

Get whether flowCart will use buffer limits

Call:

>>> opts.set_buffLim(buffLim, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

buffLim: {False} | True

whether flowCart will use buffer limits

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

Get nominal CFL number for flowCart

Call:

>>> opts.set_cfl(cfl, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

cfl: {1.1} | float

nominal CFL number for flowCart

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

Get min CFL number for flowCart

Call:

>>> opts.set_cflmin(cflmin, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

cflmin: {0.8} | float

min CFL number for flowCart

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

Get steps between unsteady flowCart checkpoints

Call:

>>> opts.set_checkptTD(checkptTD, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

checkptTD: {None} | int

steps between unsteady flowCart checkpoints

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

Get whether to write Components.i.triq

Call:

>>> opts.set_clic(clic, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

clic: {True} | False

whether to write Components.i.triq

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

Get nondimensional physical time step

Call:

>>> opts.set_dt(dt, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

dt: {0.1} | float

nondimensional physical time step

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

Get whether to run relaxation step before time-accurate step

Call:

>>> opts.set_fc_clean(fc_clean, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

fc_clean: {False} | True

whether to run relaxation step before time-accurate step

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

Get number of iters for iterative or time averaging

Call:

>>> opts.set_fc_stats(fc_stats, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

fc_stats: {0} | int

number of iters for iterative or time averaging

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

Get whether flowCart should be run first-order

Call:

>>> opts.set_first_order(first_order, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

first_order: {False} | True

whether flowCart should be run first-order

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

Get whether to run flowCart w/ full multigrid

Call:

>>> opts.set_fmg(fmg, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

fmg: {True} | False

whether to run flowCart w/ full multigrid

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

Get number of flowCart iters b/w .triq outputs

Call:

>>> opts.set_it_avg(it_avg, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_avg: {0} | int

number of flowCart iters b/w .triq outputs

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

Get number of flowCart iterations

Call:

>>> opts.set_it_fc(it_fc, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_fc: {200} | int

number of flowCart 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_it_start(v, j=None, mode=None)

Get number of flowCart iters b4 .triq outputs

Call:

>>> opts.set_it_start(it_start, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_start: {100} | int

number of flowCart iters b4 .triq outputs

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

Get number of subiters for each flowCart time step

Call:

>>> opts.set_it_sub(it_sub, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_sub: {10} | int

number of subiters for each flowCart time step

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

Get limiter for flowCart

Call:

>>> opts.set_limiter(limiter, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

limiter: {2} | int

limiter for flowCart

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

Get multigrid levels for flowCart

Call:

>>> opts.set_mg_fc(mg_fc, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

mg_fc: {3} | int

multigrid levels for flowCart

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

Get whether or not to run mpi_flowCart

Call:

>>> opts.set_mpi_fc(mpi_fc, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

mpi_fc: {False} | True | int

whether or not to run mpi_flowCart

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

Get convergence drop orders of magnitude for early exit

Call:

>>> opts.set_nOrders(nOrders, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

nOrders: {12} | int

convergence drop orders of magnitude for early exit

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

Get whether to run flowCart w/ poly multigrid

Call:

>>> opts.set_pmg(pmg, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

pmg: {False} | True

whether to run flowCart w/ poly multigrid

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

Get whether flowCart should be run in robust mode

Call:

>>> opts.set_robust_mode(robust_mode, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

robust_mode: {False} | True

whether flowCart should be run in robust 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_tecO(v, j=None, mode=None)

Get whether flowCart dumps Tecplot triangulations

Call:

>>> opts.set_tecO(tecO, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

tecO: {True} | False

whether flowCart dumps Tecplot triangulations

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

Get whether flowCart is set for cut cell gradient

Call:

>>> opts.set_tm(tm, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

tm: {False} | True

whether flowCart is set for cut cell gradient

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

Get whether to run time-accurate flowCart

Call:

>>> opts.set_unsteady(unsteady, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

unsteady: {False} | True

whether to run time-accurate flowCart

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

Get steps between flowCart visualization outputs

Call:

>>> opts.set_vizTD(vizTD, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

vizTD: {None} | int

steps between flowCart visualization outputs

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

Get whether y is spanwise axis for flowCart

Call:

>>> opts.set_y_is_spanwise(y_is_spanwise, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

y_is_spanwise: {True} | False

whether y is spanwise axis for flowCart

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.pycart.options.runctlopts.RunControlOpts(*args, **kw)

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

Get whether or not to use aero.csh in phase

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 use aero.csh in phase

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

Get number of check point files to keep

Call:

>>> NCheckPoint = opts.get_NCheckPoint(j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

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:

NCheckPoint: {2} | int

number of check point files to keep

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

Get the Runge-Kutta scheme for a phase

Call:

>>> RKScheme = opts.get_RKScheme(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

RKScheme: {None} | list | str

the Runge-Kutta scheme for a phase

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

Get archive option for adapt folders

Call:

>>> TarAdapt = opts.get_TarAdapt(j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

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:

TarAdapt: 'full' | 'none' | {'restart'}

archive option for adapt folders

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

Get archive option for visualization files

Call:

>>> TarViz = opts.get_TarViz(j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

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:

TarViz: 'full' | 'none' | {'restart'}

archive option for visualization files

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

Get number of buffer layers

Call:

>>> abuff = opts.get_abuff(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

buf: {1} | int

number of buffer layers

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

Get value of option “adj_first_order”

Call:

>>> adj_first_order = opts.get_adj_first_order(j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

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:

adj_first_order: {False} | True

value of option “adj_first_order”

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

Get adaptation cycle type (adapt/propagate)

Call:

>>> apc = opts.get_apc(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

apc: {'a'} | 'p'

adaptation cycle type (adapt/propagate)

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

Get whether to create a symmetric half-body mesh

Call:

>>> halfBody = opts.get_autoInputs_halfBody(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

halfBody: {None} | True | False

whether to create a symmetric half-body mesh

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

Get maximum number of cell refinements

Call:

>>> maxR = opts.get_autoInputs_maxR(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

maxR: {10} | int

maximum number of cell refinements

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

Get option to make 2D mesh

Call:

>>> mesh2d = opts.get_autoInputs_mesh2d(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

mesh2d: {None} | True | False

option to make 2D mesh

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

Get number of divisions in background mesh

Call:

>>> nDiv = opts.get_autoInputs_nDiv(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

nDiv: {4} | int

number of divisions in background mesh

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

Get nominal autoInputs mesh radius

Call:

>>> r = opts.get_autoInputs_r(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

r: {30.0} | int | float

nominal autoInputs mesh radius

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

Get whether to execute program

Call:

>>> run = opts.get_autoInputs_run(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

run: {None} | True | False

whether to execute program

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

Get use yz-plane as symmetry plane with halfBody

Call:

>>> symmX = opts.get_autoInputs_symmX(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

symmX: {None} | True | False

use yz-plane as symmetry plane with halfBody

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

Get use xz-plane as symmetry plane with halfBody

Call:

>>> symmY = opts.get_autoInputs_symmY(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

symmY: {None} | True | False

use xz-plane as symmetry plane with halfBody

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

Get use xy-plane as symmetry plane with halfBody

Call:

>>> symmZ = opts.get_autoInputs_symmZ(j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

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:

symmZ: {None} | True | False

use xy-plane as symmetry plane with halfBody

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

Get whether flowCart is set for binary I/O

Call:

>>> binaryIO = opts.get_binaryIO(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

binaryIO: {True} | False

whether flowCart is set for binary I/O

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

Get number of buffer layers

Call:

>>> buf = opts.get_buf(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

buf: {1} | int

number of buffer layers

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

Get whether flowCart will use buffer limits

Call:

>>> buffLim = opts.get_buffLim(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

buffLim: {False} | True

whether flowCart will use buffer limits

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

Get nominal CFL number for flowCart

Call:

>>> cfl = opts.get_cfl(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

cfl: {1.1} | float

nominal CFL number for flowCart

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

Get min CFL number for flowCart

Call:

>>> cflmin = opts.get_cflmin(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

cflmin: {0.8} | float

min CFL number for flowCart

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

Get steps between unsteady flowCart checkpoints

Call:

>>> checkptTD = opts.get_checkptTD(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

checkptTD: {None} | int

steps between unsteady flowCart checkpoints

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

Get whether to write Components.i.triq

Call:

>>> clic = opts.get_clic(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

clic: {True} | False

whether to write Components.i.triq

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

Get angle threshold [deg] for geom refinement

Call:

>>> a = opts.get_cubes_a(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

a: {10.0} | int | float

angle threshold [deg] for geom refinement

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

Get number of layers of buffer cells

Call:

>>> b = opts.get_cubes_b(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

b: {2} | int

number of layers of buffer cells

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

Get whether to execute program

Call:

>>> run = opts.get_cubes_run(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

run: {None} | True | False

whether to execute program

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

Get nondimensional physical time step

Call:

>>> dt = opts.get_dt(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

dt: {0.1} | float

nondimensional physical time step

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

Get target output error tolerance

Call:

>>> etol = opts.get_etol(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

etol: {1e-06} | float

target output error tolerance

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

Get whether to run relaxation step before time-accurate step

Call:

>>> fc_clean = opts.get_fc_clean(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

fc_clean: {False} | True

whether to run relaxation step before time-accurate step

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

Get number of iters for iterative or time averaging

Call:

>>> fc_stats = opts.get_fc_stats(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

fc_stats: {0} | int

number of iters for iterative or time averaging

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

Get num. of additional adapts using final error map

Call:

>>> final_mesh_xref = opts.get_final_mesh_xref(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

final_mesh_xref: {0} | int

num. of additional adapts using final error map

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

Get whether flowCart should be run first-order

Call:

>>> first_order = opts.get_first_order(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

first_order: {False} | True

whether flowCart should be run first-order

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

Get whether to run flowCart w/ full multigrid

Call:

>>> fmg = opts.get_fmg(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

fmg: {True} | False

whether to run flowCart w/ full multigrid

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

Get value of option “it_ad”

Call:

>>> it_ad = opts.get_it_ad(j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

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:

it_ad: {120} | int

value of option “it_ad”

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

Get number of flowCart iters b/w .triq outputs

Call:

>>> it_avg = opts.get_it_avg(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_avg: {0} | int

number of flowCart iters b/w .triq outputs

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

Get number of flowCart iterations

Call:

>>> it_fc = opts.get_it_fc(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_fc: {200} | int

number of flowCart iterations

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

Get number of flowCart iters b4 .triq outputs

Call:

>>> it_start = opts.get_it_start(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_start: {100} | int

number of flowCart iters b4 .triq outputs

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

Get number of subiters for each flowCart time step

Call:

>>> it_sub = opts.get_it_sub(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

it_sub: {10} | int

number of subiters for each flowCart time step

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

Get whether to create meshes b4 running aero.csh

Call:

>>> jumpstart = opts.get_jumpstart(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

jumpstart: {False} | True

whether to create meshes b4 running aero.csh

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

Get limiter for flowCart

Call:

>>> limiter = opts.get_limiter(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

limiter: {2} | int

limiter for flowCart

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

Get maximum number of refinements in cubes mesh

Call:

>>> maxR = opts.get_maxR(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

maxR: {11} | int

maximum number of refinements in cubes mesh

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

Get maximum cell count

Call:

>>> max_nCells = opts.get_max_nCells(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

max_nCells: {5000000.0} | int

maximum cell count

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

Get mesh growth ratio between cycles of aero.csh

Call:

>>> mesh_growth = opts.get_mesh_growth(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

mesh_growth: {1.5} | float

mesh growth ratio between cycles of aero.csh

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

Get value of option “mg_ad”

Call:

>>> mg_ad = opts.get_mg_ad(j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

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:

mg_ad: {3} | int

value of option “mg_ad”

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

Get multigrid levels for flowCart

Call:

>>> mg_fc = opts.get_mg_fc(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

mg_fc: {3} | int

multigrid levels for flowCart

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

Get whether or not to run mpi_flowCart

Call:

>>> mpi_fc = opts.get_mpi_fc(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

mpi_fc: {False} | True | int

whether or not to run mpi_flowCart

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

Get convergence drop orders of magnitude for early exit

Call:

>>> nOrders = opts.get_nOrders(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

nOrders: {12} | int

convergence drop orders of magnitude for early exit

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

Get number of Cart3D adaptation cycles in phase

Call:

>>> n_adapt_cycles = opts.get_n_adapt_cycles(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

n_adapt_cycles: {0} | int

number of Cart3D adaptation cycles in phase

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

Get whether to run flowCart w/ poly multigrid

Call:

>>> pmg = opts.get_pmg(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

pmg: {False} | True

whether to run flowCart w/ poly multigrid

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

Get value of option “pre”

Call:

>>> preSpecCntl = opts.get_preSpecCntl(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

pre: {'preSpec.c3d.cntl'} | str

value of option “pre”

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

Get whether to reorder output mesh

Call:

>>> reorder = opts.get_reorder(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

reorder: {True} | False

whether to reorder output mesh

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

Get whether flowCart should be run in robust mode

Call:

>>> robust_mode = opts.get_robust_mode(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

robust_mode: {False} | True

whether flowCart should be run in robust mode

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

Get additional levels at sharp edges

Call:

>>> sf = opts.get_sf(j=None, i=None, **kw)

Inputs:

opts: CubesOpts

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:

sf: {0} | int

additional levels at sharp edges

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

Get whether flowCart dumps Tecplot triangulations

Call:

>>> tecO = opts.get_tecO(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

tecO: {True} | False

whether flowCart dumps Tecplot triangulations

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

Get whether flowCart is set for cut cell gradient

Call:

>>> tm = opts.get_tm(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

tm: {False} | True

whether flowCart is set for cut cell gradient

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

Get whether to run time-accurate flowCart

Call:

>>> unsteady = opts.get_unsteady(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

unsteady: {False} | True

whether to run time-accurate flowCart

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

Get steps between flowCart visualization outputs

Call:

>>> vizTD = opts.get_vizTD(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

vizTD: {None} | int

steps between flowCart visualization outputs

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

Get number of flowCart iters for aero.csh cycles

Call:

>>> ws_it = opts.get_ws_it(j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

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:

ws_it: {50} | int

number of flowCart iters for aero.csh cycles

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

Get whether y is spanwise axis for flowCart

Call:

>>> y_is_spanwise = opts.get_y_is_spanwise(j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

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:

y_is_spanwise: {True} | False

whether y is spanwise axis for flowCart

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

Get whether or not to use aero.csh in phase

Call:

>>> opts.set_Adaptive(Adaptive, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

Adaptive: {False} | True

whether or not to use aero.csh in 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_NCheckPoint(v, j=None, mode=None)

Get number of check point files to keep

Call:

>>> opts.set_NCheckPoint(NCheckPoint, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

NCheckPoint: {2} | int

number of check point files to keep

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

Get the Runge-Kutta scheme for a phase

Call:

>>> opts.set_RKScheme(RKScheme, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

RKScheme: {None} | list | str

the Runge-Kutta scheme for a 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_TarAdapt(v, j=None, mode=None)

Get archive option for adapt folders

Call:

>>> opts.set_TarAdapt(TarAdapt, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

TarAdapt: 'full' | 'none' | {'restart'}

archive option for adapt folders

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

Get archive option for visualization files

Call:

>>> opts.set_TarViz(TarViz, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

TarViz: 'full' | 'none' | {'restart'}

archive option for visualization 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_abuff(v, j=None, mode=None)

Get number of buffer layers

Call:

>>> opts.set_abuff(abuff, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

buf: {1} | int

number of buffer layers

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

Get value of option “adj_first_order”

Call:

>>> opts.set_adj_first_order(adj_first_order, j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

options interface

adj_first_order: {False} | True

value of option “adj_first_order”

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

Get adaptation cycle type (adapt/propagate)

Call:

>>> opts.set_apc(apc, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

apc: {'a'} | 'p'

adaptation cycle type (adapt/propagate)

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

Get whether to create a symmetric half-body mesh

Call:

>>> opts.set_autoInputs_halfBody(halfBody, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

halfBody: {None} | True | False

whether to create a symmetric half-body mesh

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

Get maximum number of cell refinements

Call:

>>> opts.set_autoInputs_maxR(maxR, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

maxR: {10} | int

maximum number of cell refinements

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

Get option to make 2D mesh

Call:

>>> opts.set_autoInputs_mesh2d(mesh2d, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

mesh2d: {None} | True | False

option to make 2D mesh

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

Get number of divisions in background mesh

Call:

>>> opts.set_autoInputs_nDiv(nDiv, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

nDiv: {4} | int

number of divisions in background mesh

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

Get nominal autoInputs mesh radius

Call:

>>> opts.set_autoInputs_r(r, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

r: {30.0} | int | float

nominal autoInputs mesh radius

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

Get whether to execute program

Call:

>>> opts.set_autoInputs_run(run, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

run: {None} | True | False

whether to execute program

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

Get use yz-plane as symmetry plane with halfBody

Call:

>>> opts.set_autoInputs_symmX(symmX, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

symmX: {None} | True | False

use yz-plane as symmetry plane with halfBody

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

Get use xz-plane as symmetry plane with halfBody

Call:

>>> opts.set_autoInputs_symmY(symmY, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

symmY: {None} | True | False

use xz-plane as symmetry plane with halfBody

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

Get use xy-plane as symmetry plane with halfBody

Call:

>>> opts.set_autoInputs_symmZ(symmZ, j=None, i=None, **kw)

Inputs:

opts: AutoInputsOpts

options interface

symmZ: {None} | True | False

use xy-plane as symmetry plane with halfBody

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

Get whether flowCart is set for binary I/O

Call:

>>> opts.set_binaryIO(binaryIO, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

binaryIO: {True} | False

whether flowCart is set for binary I/O

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

Get number of buffer layers

Call:

>>> opts.set_buf(buf, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

buf: {1} | int

number of buffer layers

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

Get whether flowCart will use buffer limits

Call:

>>> opts.set_buffLim(buffLim, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

buffLim: {False} | True

whether flowCart will use buffer limits

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

Get nominal CFL number for flowCart

Call:

>>> opts.set_cfl(cfl, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

cfl: {1.1} | float

nominal CFL number for flowCart

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

Get min CFL number for flowCart

Call:

>>> opts.set_cflmin(cflmin, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

cflmin: {0.8} | float

min CFL number for flowCart

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

Get steps between unsteady flowCart checkpoints

Call:

>>> opts.set_checkptTD(checkptTD, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

checkptTD: {None} | int

steps between unsteady flowCart checkpoints

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

Get whether to write Components.i.triq

Call:

>>> opts.set_clic(clic, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

clic: {True} | False

whether to write Components.i.triq

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

Get angle threshold [deg] for geom refinement

Call:

>>> opts.set_cubes_a(a, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

a: {10.0} | int | float

angle threshold [deg] for geom refinement

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

Get number of layers of buffer cells

Call:

>>> opts.set_cubes_b(b, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

b: {2} | int

number of layers of buffer cells

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

Get whether to execute program

Call:

>>> opts.set_cubes_run(run, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

run: {None} | True | False

whether to execute program

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

Get nondimensional physical time step

Call:

>>> opts.set_dt(dt, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

dt: {0.1} | float

nondimensional physical time step

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

Get target output error tolerance

Call:

>>> opts.set_etol(etol, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

etol: {1e-06} | float

target output error tolerance

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

Get whether to run relaxation step before time-accurate step

Call:

>>> opts.set_fc_clean(fc_clean, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

fc_clean: {False} | True

whether to run relaxation step before time-accurate step

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

Get number of iters for iterative or time averaging

Call:

>>> opts.set_fc_stats(fc_stats, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

fc_stats: {0} | int

number of iters for iterative or time averaging

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

Get num. of additional adapts using final error map

Call:

>>> opts.set_final_mesh_xref(final_mesh_xref, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

final_mesh_xref: {0} | int

num. of additional adapts using final error map

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

Get whether flowCart should be run first-order

Call:

>>> opts.set_first_order(first_order, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

first_order: {False} | True

whether flowCart should be run first-order

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

Get whether to run flowCart w/ full multigrid

Call:

>>> opts.set_fmg(fmg, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

fmg: {True} | False

whether to run flowCart w/ full multigrid

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

Get value of option “it_ad”

Call:

>>> opts.set_it_ad(it_ad, j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

options interface

it_ad: {120} | int

value of option “it_ad”

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

Get number of flowCart iters b/w .triq outputs

Call:

>>> opts.set_it_avg(it_avg, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_avg: {0} | int

number of flowCart iters b/w .triq outputs

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

Get number of flowCart iterations

Call:

>>> opts.set_it_fc(it_fc, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_fc: {200} | int

number of flowCart 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_it_start(v, j=None, mode=None)

Get number of flowCart iters b4 .triq outputs

Call:

>>> opts.set_it_start(it_start, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_start: {100} | int

number of flowCart iters b4 .triq outputs

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

Get number of subiters for each flowCart time step

Call:

>>> opts.set_it_sub(it_sub, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

it_sub: {10} | int

number of subiters for each flowCart time step

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

Get whether to create meshes b4 running aero.csh

Call:

>>> opts.set_jumpstart(jumpstart, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

jumpstart: {False} | True

whether to create meshes b4 running aero.csh

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

Get limiter for flowCart

Call:

>>> opts.set_limiter(limiter, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

limiter: {2} | int

limiter for flowCart

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

Get maximum number of refinements in cubes mesh

Call:

>>> opts.set_maxR(maxR, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

maxR: {11} | int

maximum number of refinements in cubes mesh

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

Get maximum cell count

Call:

>>> opts.set_max_nCells(max_nCells, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

max_nCells: {5000000.0} | int

maximum cell count

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

Get mesh growth ratio between cycles of aero.csh

Call:

>>> opts.set_mesh_growth(mesh_growth, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

mesh_growth: {1.5} | float

mesh growth ratio between cycles of aero.csh

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

Get value of option “mg_ad”

Call:

>>> opts.set_mg_ad(mg_ad, j=None, i=None, **kw)

Inputs:

opts: AdjointCartOpts

options interface

mg_ad: {3} | int

value of option “mg_ad”

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

Get multigrid levels for flowCart

Call:

>>> opts.set_mg_fc(mg_fc, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

mg_fc: {3} | int

multigrid levels for flowCart

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

Get whether or not to run mpi_flowCart

Call:

>>> opts.set_mpi_fc(mpi_fc, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

mpi_fc: {False} | True | int

whether or not to run mpi_flowCart

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

Get convergence drop orders of magnitude for early exit

Call:

>>> opts.set_nOrders(nOrders, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

nOrders: {12} | int

convergence drop orders of magnitude for early exit

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

Get number of Cart3D adaptation cycles in phase

Call:

>>> opts.set_n_adapt_cycles(n_adapt_cycles, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

n_adapt_cycles: {0} | int

number of Cart3D adaptation cycles in 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_pmg(v, j=None, mode=None)

Get whether to run flowCart w/ poly multigrid

Call:

>>> opts.set_pmg(pmg, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

pmg: {False} | True

whether to run flowCart w/ poly multigrid

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

Get value of option “pre”

Call:

>>> opts.set_preSpecCntl(preSpecCntl, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

pre: {'preSpec.c3d.cntl'} | str

value of option “pre”

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

Get whether to reorder output mesh

Call:

>>> opts.set_reorder(reorder, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

reorder: {True} | False

whether to reorder output mesh

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

Get whether flowCart should be run in robust mode

Call:

>>> opts.set_robust_mode(robust_mode, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

robust_mode: {False} | True

whether flowCart should be run in robust 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_sf(v, j=None, mode=None)

Get additional levels at sharp edges

Call:

>>> opts.set_sf(sf, j=None, i=None, **kw)

Inputs:

opts: CubesOpts

options interface

sf: {0} | int

additional levels at sharp edges

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

Get whether flowCart dumps Tecplot triangulations

Call:

>>> opts.set_tecO(tecO, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

tecO: {True} | False

whether flowCart dumps Tecplot triangulations

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

Get whether flowCart is set for cut cell gradient

Call:

>>> opts.set_tm(tm, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

tm: {False} | True

whether flowCart is set for cut cell gradient

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

Get whether to run time-accurate flowCart

Call:

>>> opts.set_unsteady(unsteady, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

unsteady: {False} | True

whether to run time-accurate flowCart

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

Get steps between flowCart visualization outputs

Call:

>>> opts.set_vizTD(vizTD, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

vizTD: {None} | int

steps between flowCart visualization outputs

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

Get number of flowCart iters for aero.csh cycles

Call:

>>> opts.set_ws_it(ws_it, j=None, i=None, **kw)

Inputs:

opts: AdaptationOpts

options interface

ws_it: {50} | int

number of flowCart iters for aero.csh cycles

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

Get whether y is spanwise axis for flowCart

Call:

>>> opts.set_y_is_spanwise(y_is_spanwise, j=None, i=None, **kw)

Inputs:

opts: FlowCartOpts

options interface

y_is_spanwise: {True} | False

whether y is spanwise axis for flowCart

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