cape.cfdx.options.aflr3opts: AFLR3 mesh generation options

This module provides a class to access command-line options to the AFLR3 mesh-generation program. It is specified in the "RunControl" section for modules that utilize the solver, which includes FUN3D.

The options in this module are among the command-line options to AFLR3. Other AFLR3 options that do not have specific methods defined in the AFLR3Opts options class can be accessed using two generic functions:

class cape.cfdx.options.aflr3opts.AFLR3Opts(*args, **kw)

Class for AFLR3 command-line settings

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

Dictionary of AFLR3 command-line options

Outputs:
opts: AFLR3Opts

AFLR3 options interface

Versions:

  • 2016-04-04 @ddalle: Version 1.0 (aflr3)

  • 2022-10-14 @ddalle: Version 2.0

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

Get AFLR3 boundary condition file

Call:
>>> BCFile = opts.get_aflr3_BCFile(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
BCFile: {None} | str

AFLR3 boundary condition file

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

Get AFLR3 max angle b/w BL intersecting faces

Call:
>>> angblisimx = opts.get_aflr3_angblisimx(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
angblisimx: {None} | float

AFLR3 max angle b/w BL intersecting faces

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

Get AFLR3 max angle on surface triangles

Call:
>>> angqbf = opts.get_aflr3_angqbf(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
angqbf: {None} | float

AFLR3 max angle on surface triangles

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

Get AFLR3 prism layer option

Call:
>>> blc = opts.get_aflr3_blc(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
blc: {None} | True | False

AFLR3 prism layer option

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

Get AFLR3 initial boundary-layer spacing

Call:
>>> blds = opts.get_aflr3_blds(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
blds: {None} | float

AFLR3 initial boundary-layer spacing

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

Get number of AFLR3 prism layers

Call:
>>> bli = opts.get_aflr3_bli(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
bli: {None} | int

number of AFLR3 prism layers

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

Get AFLR3 boundary layer stretching ratio

Call:
>>> blr = opts.get_aflr3_blr(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
blr: {None} | float

AFLR3 boundary layer stretching ratio

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

Get AFLR3 max geometric growth rate

Call:
>>> cdfr = opts.get_aflr3_cdfr(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
cdfr: {None} | float

AFLR3 max geometric growth rate

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

Get AFLR3 geometric growth exclusion zone size

Call:
>>> cdfs = opts.get_aflr3_cdfs(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
cdfs: {None} | int | float

AFLR3 geometric growth exclusion zone size

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

Get AFLR3 options using -flag val format

Call:
>>> flags = opts.get_aflr3_flags(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
flags: {{}} | dict

AFLR3 options using -flag val format

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

Get AFLR3 off-body growth rate

Call:
>>> grow = opts.get_aflr3_grow(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
grow: {None} | float

AFLR3 off-body growth rate

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

Get input file for AFLR3

Call:
>>> i = opts.get_aflr3_i(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
i: {None} | str

input file for AFLR3

get_aflr3_key(k, j=0, i=None, vdef=None)

Get AFLR3 AFLR3 option that uses key=val format

Call:
>>> v = opts.get_aflr3_key(k, j=0, vdef=None)
Inputs:
opts: cape.options.Options

Options interface

k: str

Name of key to query

j: {0} | None | int

Phase number

vdef: {None} | any

Manually specified default

Outputs:
v: any

Value of AFLR3 key k

Versions:

  • 2019-05-11 @ddalle: Version 1.0

  • 2022-10-14 @ddalle: Version 1.1; use optdict

  • 2022-10-29 @ddalle: Version 2.0

    • add i

    • use get_subopt()

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

Get AFLR3 options using key=val format

Call:
>>> keys = opts.get_aflr3_keys(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
keys: {{}} | dict

AFLR3 options using key=val format

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

Get AFLR3 volume grid distribution flag

Call:
>>> mdf = opts.get_aflr3_mdf(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
mdf: 1 | {2}

AFLR3 volume grid distribution flag

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

Get AFLR3 BL spacing thickness factor option

Call:
>>> mdsblf = opts.get_aflr3_mdsblf(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
mdsblf: 0 | 1 | 2

AFLR3 BL spacing thickness factor option

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

Get number of AFLR3 mesh quality passes

Call:
>>> nqual = opts.get_aflr3_nqual(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
nqual: {0} | int

number of AFLR3 mesh quality passes

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

Get output file for AFLR3

Call:
>>> o = opts.get_aflr3_o(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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:
o: {None} | str

output file for AFLR3

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

Get whether or not to run AFLR3

Call:
>>> run = opts.get_aflr3_run(j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

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 or not to run AFLR3

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

Get AFLR3 boundary condition file

Call:
>>> opts.set_aflr3_BCFile(BCFile, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

BCFile: {None} | str

AFLR3 boundary condition 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_aflr3_angblisimx(v, j=None, mode=None)

Get AFLR3 max angle b/w BL intersecting faces

Call:
>>> opts.set_aflr3_angblisimx(angblisimx, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

angblisimx: {None} | float

AFLR3 max angle b/w BL intersecting faces

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

Get AFLR3 max angle on surface triangles

Call:
>>> opts.set_aflr3_angqbf(angqbf, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

angqbf: {None} | float

AFLR3 max angle on surface triangles

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

Get AFLR3 prism layer option

Call:
>>> opts.set_aflr3_blc(blc, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

blc: {None} | True | False

AFLR3 prism layer option

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

Get AFLR3 initial boundary-layer spacing

Call:
>>> opts.set_aflr3_blds(blds, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

blds: {None} | float

AFLR3 initial boundary-layer spacing

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

Get number of AFLR3 prism layers

Call:
>>> opts.set_aflr3_bli(bli, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

bli: {None} | int

number of AFLR3 prism 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_aflr3_blr(v, j=None, mode=None)

Get AFLR3 boundary layer stretching ratio

Call:
>>> opts.set_aflr3_blr(blr, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

blr: {None} | float

AFLR3 boundary layer stretching ratio

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

Get AFLR3 max geometric growth rate

Call:
>>> opts.set_aflr3_cdfr(cdfr, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

cdfr: {None} | float

AFLR3 max geometric growth rate

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

Get AFLR3 geometric growth exclusion zone size

Call:
>>> opts.set_aflr3_cdfs(cdfs, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

cdfs: {None} | int | float

AFLR3 geometric growth exclusion zone size

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

Get AFLR3 options using -flag val format

Call:
>>> opts.set_aflr3_flags(flags, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

flags: {{}} | dict

AFLR3 options using -flag val format

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

Get AFLR3 off-body growth rate

Call:
>>> opts.set_aflr3_grow(grow, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

grow: {None} | float

AFLR3 off-body growth rate

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

Get input file for AFLR3

Call:
>>> opts.set_aflr3_i(i, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

i: {None} | str

input file for AFLR3

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_aflr3_key(k, v, j=None)

Get AFLR3 AFLR3 option that uses key=val format

Call:
>>> opts.get_aflr3_key(k, v, j=0)
Inputs:
opts: cape.options.Options

Options interface

k: str

Name of key to query

v: any

Value of AFLR3 key k

j: {None} | int

Phase number

Versions:

  • 2019-05-11 @ddalle: Version 1.0

  • 2022-10-14 @ddalle: Version 1.1; use optdict

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

Get AFLR3 options using key=val format

Call:
>>> opts.set_aflr3_keys(keys, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

keys: {{}} | dict

AFLR3 options using key=val format

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

Get AFLR3 volume grid distribution flag

Call:
>>> opts.set_aflr3_mdf(mdf, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

mdf: 1 | {2}

AFLR3 volume grid distribution flag

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

Get AFLR3 BL spacing thickness factor option

Call:
>>> opts.set_aflr3_mdsblf(mdsblf, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

mdsblf: 0 | 1 | 2

AFLR3 BL spacing thickness factor option

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

Get number of AFLR3 mesh quality passes

Call:
>>> opts.set_aflr3_nqual(nqual, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

nqual: {0} | int

number of AFLR3 mesh quality passes

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

Get output file for AFLR3

Call:
>>> opts.set_aflr3_o(o, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

o: {None} | str

output file for AFLR3

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

Get whether or not to run AFLR3

Call:
>>> opts.set_aflr3_run(run, j=None, i=None, **kw)
Inputs:
opts: AFLR3Opts

options interface

run: {None} | True | False

whether or not to run AFLR3

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