cape.pycart.options: Cart3D and pyCart Settings

cape.pycart.options: pyCart options interface module

This module provides tools to read, access, modify, and write settings for cape.pycart. It is a fork of

cape.cfdx.options

with several Cart3D-specific options and provides the class

cape.pycart.options.Options

See Also:

• cape.cfdx.options

• cape.pycart.options.runctlopts

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

Options class for cape.pycart

Call:

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

Inputs:

fname: str

File to be read as a JSON file with comments

kw: dict

Dictionary of raw options

Outputs:

opts: cape.cfdx.options.Options

Options interface

Versions:

• 2014-07-28 @ddalle: Version 1.0

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

add_LineSensors(val, **kw)

Get dictionary of line sensor definitions

Call:

>>> opts.add_LineSensors(LineSensors, **kw)

Inputs:

opts: ConfigOpts

options interface

LineSensors: {None} | dict

dictionary of line sensor definitions

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_PointSensors(val, **kw)

Get dictionary of point sensor definitions

Call:

>>> opts.add_PointSensors(PointSensors, **kw)

Inputs:

opts: ConfigOpts

options interface

PointSensors: {None} | object

dictionary of point sensor definitions

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_Xslices(val, **kw)

Get x-slice(s) to export

Call:

>>> opts.add_Xslices(Xslices, **kw)

Inputs:

opts: ConfigOpts

options interface

Xslices: {None} | float | str

x-slice(s) to export

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_Yslices(val, **kw)

Get y-slice(s) to export

Call:

>>> opts.add_Yslices(Yslices, **kw)

Inputs:

opts: ConfigOpts

options interface

Yslices: {None} | float | str

y-slice(s) to export

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_Zslices(val, **kw)

Get z-slice(s) to export

Call:

>>> opts.add_Zslices(Zslices, **kw)

Inputs:

opts: ConfigOpts

options interface

Zslices: {None} | float | str

z-slice(s) to export

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

apply_ArchiveTemplate()

Apply named template to set default files to delete/archive

Call:

>>> opts.apply_ArchiveTemplate()

Inputs:

opts: pyCart.options.Options

Options interface

Versions:

• 2016-02-29 @ddalle: Version 1.0

filter_FunctionalCoeffsByType(typ: str)

Return a subset of function coefficients by type

Call:

>>> copts = opts.filter_FunctionalCoeffsByType(typ)

Inputs:

opts: Options

Options interface

typ: str

Requested functional type

Outputs:

copts: dict[FunctionalCoeffOpts]

Subset of functional options with correct type

Versions:

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

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

Get template aero.csh file

Call:

>>> AeroCsh = opts.get_AeroCsh(j=None, i=None, **kw)

Inputs:

opts: Options

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

AeroCsh: {'aero.csh'} | object

template aero.csh file

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

Get list of bounding boxes for volume mesh creation

This defines bounding boxes using the name of a component taken from a Cart3D Config.xml file. The cape.tri.Tri class automatically finds the smallest bounding box that contains this component, and then the user can specify additional margins beyond this box (margins can also be negative). Separate margins (or “pads”) on theminimum and maximum coordinates can be given following the convention "xm" (short for x-minus) on the minimum coordinate and "xp" for the maximum coordinate.

{
    "compID": "fin2",
    "n": 9,
    "pad": 2.0,
    "xpad": 3.0,
    "ym": -1.0,
    "yp": 3.0
}

Call:

>>> BBox = opts.get_BBox(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

BBox: {None} | BBoxOpts

list of bounding boxes for volume mesh creation

This defines bounding boxes using the name of a component taken from a Cart3D Config.xml file. The cape.tri.Tri class automatically finds the smallest bounding box that contains this component, and then the user can specify additional margins beyond this box (margins can also be negative). Separate margins (or “pads”) on theminimum and maximum coordinates can be given following the convention "xm" (short for x-minus) on the minimum coordinate and "xp" for the maximum coordinate.

{
    "compID": "fin2",
    "n": 9,
    "pad": 2.0,
    "xpad": 3.0,
    "ym": -1.0,
    "yp": 3.0
}

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

Get components to only report force (not moment)

Call:

>>> Force = opts.get_ConfigForce(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Force: {None} | list[str]

components to only report force (not moment)

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

Get option for a specific functional coefficient

Call:

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

Inputs:

opts: OptionsDict

Options interface

coeff: str

Name of coefficient

opt: str

Name of functional option

Outputs:

v: object

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

Versions:

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

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

Get template input.cntl file

Call:

>>> InputCntl = opts.get_InputCntl(j=None, i=None, **kw)

Inputs:

opts: Options

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

InputCntl: {'input.cntl'} | str

template input.cntl file

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

Get dictionary of line sensor definitions

Call:

>>> LineSensors = opts.get_LineSensors(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

LineSensors: {None} | dict

dictionary of line sensor definitions

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

Get dictionary of point sensor definitions

Call:

>>> PointSensors = opts.get_PointSensors(j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

PointSensors: {None} | object

dictionary of point sensor definitions

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

Get list of XLev specs for add’l surface refinements

An XLev specification tells cubes to perform a number of additional refinements on any cut cells that intersect a triangle from a named (or numbered) component. This refinement can violate the maxR command-line input to cubes and is very useful for ensuring that small features of the surface have adequate resolution in the initial volume mesh.

The following example specifies two additional refinements (after the initial run-through by cubes) on all triangles in the component "fins". These instructions are then written to preSpec.c3d.cntl.

{
    "compID": "fins",
    "n": 2
}

Call:

>>> XLev = opts.get_XLev(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

XLev: {None} | XLevOpts

list of XLev specs for add’l surface refinements

An XLev specification tells cubes to perform a number of additional refinements on any cut cells that intersect a triangle from a named (or numbered) component. This refinement can violate the maxR command-line input to cubes and is very useful for ensuring that small features of the surface have adequate resolution in the initial volume mesh.

The following example specifies two additional refinements (after the initial run-through by cubes) on all triangles in the component "fins". These instructions are then written to preSpec.c3d.cntl.

{
    "compID": "fins",
    "n": 2
}

get_Xslices(j=None, **kw)

Return the x-slice(s) to export

Call:

>>> x = opts.get_Xslices(j=None)

Inputs:

opts: cape.cfdx.options.Options

Options interface

j: {None} | int

Index of cut plane coordinate to extract

Outputs:

x: float | np.ndarray

Cut plane coordinate(s)

Versions:

• 2014-10-08 @ddalle: Version 1.0

• 2022-11-01 @ddalle: Version 2.0; optdict

get_Yslices(j=None, **kw)

Return the y-slice(s) to export

Call:

>>> y = opts.get_Yslices(j=None)

Inputs:

opts: cape.cfdx.options.Options

Options interface

j: {None} | int

Index of cut plane coordinate to extract

Outputs:

y: float | np.ndarray

Cut plane coordinate(s)

Versions:

• 2014-10-08 @ddalle: Version 1.0

• 2022-11-01 @ddalle: Version 2.0; optdict

get_Zslices(j=None, **kw)

Return the z-slice(s) to export

Call:

>>> z = opts.get_Zslices(j=None)

Inputs:

opts: cape.cfdx.options.Options

Options interface

j: {None} | int

Index of cut plane coordinate to extract

Outputs:

z: float | np.ndarray

Cut plane coordinate(s)

Versions:

• 2014-10-08 @ddalle: Version 1.0

• 2022-11-01 @ddalle: Version 2.0; 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_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_inputC3d(j=None, i=None, **kw)

Get file name of pre-generated input.c3d

Call:

>>> inputC3d = opts.get_inputC3d(j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

inputC3d: {'input.c3d'} | str

file name of pre-generated input.c3d

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

Get option to build 2D mesh

Call:

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

Inputs:

opts: MeshOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mesh2d: {False} | True

option to build 2D mesh

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

Return the number of multigrid levels

Call:

>>> mg = opts.get_mg(j=None, **kw)

Inputs:

opts: cape.cfdx.options.Options

Options interface

j: {None} | int

Phase number

Outputs:

mg: int

Maximum of mg_fc and mg_ad

Versions:

• 2014-08-01 @ddalle: Version 1.0

• 2022-11-03 @ddalle: Version 1.1; modern type checks

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_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_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

init_post()

Initialization hook for Options

Call:

>>> opts.init_post()

Inputs:

opts: Options

Options interface

Versions:

• 2022-11-03 @ddalle: Version 1.0

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

Get template aero.csh file

Call:

>>> opts.set_AeroCsh(AeroCsh, j=None, i=None, **kw)

Inputs:

opts: Options

options interface

AeroCsh: {'aero.csh'} | object

template aero.csh file

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get list of bounding boxes for volume mesh creation

This defines bounding boxes using the name of a component taken from a Cart3D Config.xml file. The cape.tri.Tri class automatically finds the smallest bounding box that contains this component, and then the user can specify additional margins beyond this box (margins can also be negative). Separate margins (or “pads”) on theminimum and maximum coordinates can be given following the convention "xm" (short for x-minus) on the minimum coordinate and "xp" for the maximum coordinate.

{
    "compID": "fin2",
    "n": 9,
    "pad": 2.0,
    "xpad": 3.0,
    "ym": -1.0,
    "yp": 3.0
}

Call:

>>> opts.set_BBox(BBox, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

BBox: {None} | BBoxOpts

list of bounding boxes for volume mesh creation

This defines bounding boxes using the name of a component taken from a Cart3D Config.xml file. The cape.tri.Tri class automatically finds the smallest bounding box that contains this component, and then the user can specify additional margins beyond this box (margins can also be negative). Separate margins (or “pads”) on theminimum and maximum coordinates can be given following the convention "xm" (short for x-minus) on the minimum coordinate and "xp" for the maximum coordinate.

{
    "compID": "fin2",
    "n": 9,
    "pad": 2.0,
    "xpad": 3.0,
    "ym": -1.0,
    "yp": 3.0
}

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

Get template input.cntl file

Call:

>>> opts.set_InputCntl(InputCntl, j=None, i=None, **kw)

Inputs:

opts: Options

options interface

InputCntl: {'input.cntl'} | str

template input.cntl file

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get dictionary of line sensor definitions

Call:

>>> opts.set_LineSensors(LineSensors, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

LineSensors: {None} | dict

dictionary of line sensor definitions

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

Get dictionary of point sensor definitions

Call:

>>> opts.set_PointSensors(PointSensors, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

PointSensors: {None} | object

dictionary of point sensor definitions

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

Get list of XLev specs for add’l surface refinements

An XLev specification tells cubes to perform a number of additional refinements on any cut cells that intersect a triangle from a named (or numbered) component. This refinement can violate the maxR command-line input to cubes and is very useful for ensuring that small features of the surface have adequate resolution in the initial volume mesh.

The following example specifies two additional refinements (after the initial run-through by cubes) on all triangles in the component "fins". These instructions are then written to preSpec.c3d.cntl.

{
    "compID": "fins",
    "n": 2
}

Call:

>>> opts.set_XLev(XLev, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

XLev: {None} | XLevOpts

list of XLev specs for add’l surface refinements

An XLev specification tells cubes to perform a number of additional refinements on any cut cells that intersect a triangle from a named (or numbered) component. This refinement can violate the maxR command-line input to cubes and is very useful for ensuring that small features of the surface have adequate resolution in the initial volume mesh.

The following example specifies two additional refinements (after the initial run-through by cubes) on all triangles in the component "fins". These instructions are then written to preSpec.c3d.cntl.

{
    "compID": "fins",
    "n": 2
}

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

Get x-slice(s) to export

Call:

>>> opts.set_Xslices(Xslices, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

Xslices: {None} | float | str

x-slice(s) to export

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

Get y-slice(s) to export

Call:

>>> opts.set_Yslices(Yslices, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

Yslices: {None} | float | str

y-slice(s) to export

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

Get z-slice(s) to export

Call:

>>> opts.set_Zslices(Zslices, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

Zslices: {None} | float | str

z-slice(s) to export

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

Get file name of pre-generated input.c3d

Call:

>>> opts.set_inputC3d(inputC3d, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

inputC3d: {'input.c3d'} | str

file name of pre-generated input.c3d

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

Get option to build 2D mesh

Call:

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

Inputs:

opts: MeshOpts

options interface

mesh2d: {False} | True

option to build 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_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_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_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

• cape.pycart.options.archiveopts: Cart3D archiving options
• cape.pycart.options.configopts: Cart3Dcomponent config options
• cape.pycart.options.databookopts: Pycart databook definition options
• cape.pycart.options.functionalopts: Objective Function Options
• cape.pycart.options.meshopts: Cart3D-specific volume meshing options
• cape.pycart.options.runctlopts: Cart3D run control options
• cape.pycart.options.util: Utilities for pyCart Options Module