`cape.cfdx.options`: Options package¶

`cape.cfdx.options`: CAPE options interface module¶

The cape.cfdx.options provides tools to read, access, modify, and write settings for cape. The class is based off of the built-in dict class, so its default behaviors, such as opts['RunControl'] or opts.get('RunControl') are also present. In addition, many convenience methods, such as opts.set_PhaseIters(n), which sets the number of iterations to run, are provided.

In addition, this module controls default values of each CAPE parameter in a two-step process. The precedence used to determine what the value of a given parameter should be is below.

Values directly specified in the input file, e.g. cape.json

Values specified in the default control file, $CAPE/settings/cape.default.json

Hard-coded defaults from this module

See Also:

cape.optdict

class cape.cfdx.options.Options(*args, **kw)¶

Options structure, subclass of dict

Call:

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

Inputs:

fname: str: File to be read as a JSON file with comments
kw: dict: Options added into opts

Outputs:

opts: Options: Options interface

AddPythonPath()¶

Add requested locations to the Python path

Call:

>>> opts.AddPythonPath()

Inputs:

opts: cape.options.Options: Options interface

Versions:

2014-10-08 @ddalle: Version 1.0

WritePBSHeader(f, lbl, j=0, typ=None, wd=None)¶

Write common part of PBS script

Call:

>>> opts.WritePBSHeader(f, i=None, j=0, typ=None, wd=None)

Inputs:

opts: cape.options.Options: Options interface
f: file: Open file handle
lbl: str: Name of the PBS job
j: int: Phase number
typ: {None} | "batch" | "post": Group of PBS options to use
wd: {None} | str: Folder to enter when starting the job

Versions:

2015-09-30 @ddalle: v1.0; from WritePBS
2016-09-25 @ddalle: v2.0; “BatchPBS” and “PostPBS”
2016-12-20 @ddalle: v2.1; move from Cntl
2023-05-18 @ddalle: v3.0; subsec opts i/o self.get_

WriteSlurmHeader(f, lbl, j=0, typ=None, wd=None)¶

Write common part of Slurm script

Call:

>>> opts.WriteSlurmHeader(f, i=None, j=0, typ=None, wd=None)

Inputs:

opts: cape.options.Options: Options interface
f: file: Open file handle
lbl: str: Name of the Slurm job
j: int: Phase number
typ: {None} | "batch" | "post": Group of PBS options to use
wd: {None} | str: Folder to enter when starting the job

Versions:

2018-10-10 @ddalle: Forked from WritePBSHeader()
2022-12-02 @ddalle: Add C

add_MeshFile(val, **kw)¶

Get original mesh file name(s)

Call:

>>> opts.add_MeshFile(MeshFile, **kw)

Inputs:

opts: MeshOpts

options interface

MeshFile: {None} | str

original mesh file name(s)

mode: {None} | 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_TriFile(val, **kw)¶

Get original surface triangulation file(s)

Call:

>>> opts.add_TriFile(TriFile, **kw)

Inputs:

opts: MeshOpts

options interface

TriFile: {None} | str

original surface triangulation file(s)

mode: {None} | 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_umask(sys=True)¶

Apply the permissions filter

Call:

>>> opts.apply_umask(sys=True)

Inputs:

opts pyCart.options.Options: Options interface
sys: {True} | False: Whether or not to use system setting as default

Versions:

2015-09-27 @ddalle: Version 1.0
2017-09-05 @ddalle: Version 1.1; add sys kwarg

assert_DataBookComponent(comp: str)¶

Ensure comp is in the list of "DataBook" components

Call:

>>> opts.assert_DataBookComponent(comp)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str: Name of databook component

Versions:

2023-03-10 @ddalle: v1.0

assert_DataBookTarget(targ: str)¶

Ensure comp is in the list of "DataBook" components

Call:

>>> opts.assert_DataBookTarget(comp)

Inputs:

opts: cape.cfdx.options.Options: Options interface
targ: str: Name of databook target

Versions:

2023-03-12 @ddalle: v1.0

expand_Point(x)¶

Expand points that are specified by name instead of value

Call:

>>> x = opts.expand_Point(x)
>>> x = opts.expand_Point(s)
>>> X = opts.expand_Point(d)

Inputs:

opts: cape.cfdx.options.Options: Options interface
x: list[float]: Point
s: str: Point name
d: dict: Dictionary of points and point names

Outputs:

x: [float, float, float]: Point
X: dict: Dictionary of points

Versions:

2015-09-12 @ddalle: Version 1.0

get_ArchiveExtension() → str¶

Get file extension for [compressed] archive groups

Call:

>>> ext = opts.get_ArchiveExtension()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

ext: str: File extension based on compression type

Versions:

2024-09-14 @ddalle: v1.0
2024-09-17 @ddalle: v1.1; fewer lines to test

get_ArchiveFolder(j=None, i=None, **kw)¶

Get path to the archive root

Call:

>>> ArchiveFolder = opts.get_ArchiveFolder(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:

ArchiveFolder: {''} | str: path to the archive root

get_ArchiveFormat(j=None, i=None, **kw)¶

Get format for case archives

Call:

>>> ArchiveFormat = opts.get_ArchiveFormat(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:

ArchiveFormat: '' | 'bz2' | 'gz' | 'lzma' | {'tar'} | 'xz' | 'zip' | 'zst': format for case archives

get_ArchiveType(j=None, i=None, **kw)¶

Get flag for single (full) or multi (sub) archive files

Call:

>>> ArchiveType = opts.get_ArchiveType(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:

ArchiveType: {'full'} | 'partial': flag for single (full) or multi (sub) archive files

get_BatchPBS_A(j=None, i=None, **kw)¶

Get account name(s) or number(s)

Call:

>>> A = opts.get_BatchPBS_A(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: account name(s) or number(s)

get_BatchPBS_S(j=None, i=None, **kw)¶

Get shell to execute PBS job

Call:

>>> S = opts.get_BatchPBS_S(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

S: {'/bin/bash'} | str: shell to execute PBS job

get_BatchPBS_W(j=None, i=None, **kw)¶

Get PBS W setting, usually for setting group

Call:

>>> W = opts.get_BatchPBS_W(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

W: {''} | str: PBS W setting, usually for setting group

get_BatchPBS_aoe(j=None, i=None, **kw)¶

Get architecture operating environment

Call:

>>> aoe = opts.get_BatchPBS_aoe(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

aoe: {None} | str: architecture operating environment

get_BatchPBS_e(j=None, i=None, **kw)¶

Get explicit STDERR file name

Call:

>>> e = opts.get_BatchPBS_e(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object: explicit STDERR file name

get_BatchPBS_j(j=None, i=None, **kw)¶

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

j: {'oe'} | str: PBS ‘join’ setting

get_BatchPBS_mem(j=None, i=None, **kw)¶

Get Requested cpu memory (on gpu node)

Call:

>>> mem = opts.get_BatchPBS_mem(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mem: {None} | int: Requested cpu memory (on gpu node)

get_BatchPBS_model(j=None, i=None, **kw)¶

Get model type/architecture

Call:

>>> model = opts.get_BatchPBS_model(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

model: {None} | str: model type/architecture

get_BatchPBS_mpiprocs(j=None, i=None, **kw)¶

Get number of MPI processes per node

Call:

>>> mpiprocs = opts.get_BatchPBS_mpiprocs(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mpiprocs: {None} | int: number of MPI processes per node

get_BatchPBS_ncpus(j=None, i=None, **kw)¶

Get number of cores (roughly CPUs) per node

Call:

>>> ncpus = opts.get_BatchPBS_ncpus(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ncpus: {None} | int: number of cores (roughly CPUs) per node

get_BatchPBS_ngpus(j=None, i=None, **kw)¶

Get number of gpus per node

Call:

>>> ngpus = opts.get_BatchPBS_ngpus(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ngpus: {None} | int: number of gpus per node

get_BatchPBS_o(j=None, i=None, **kw)¶

Get explicit STDOUT file name

Call:

>>> o = opts.get_BatchPBS_o(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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} | object: explicit STDOUT file name

get_BatchPBS_ompthreads(j=None, i=None, **kw)¶

Get number of OMP threads

Call:

>>> ompthreads = opts.get_BatchPBS_ompthreads(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ompthreads: {None} | int: number of OMP threads

get_BatchPBS_p(j=None, i=None, **kw)¶

Get PBS priority

Call:

>>> p = opts.get_BatchPBS_p(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object: PBS priority

get_BatchPBS_place(j=None, i=None, **kw)¶

Get Share or exclusive access to requested gpu nodes

Call:

>>> place = opts.get_BatchPBS_place(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

place: {'excl'} | 'shared': Share or exclusive access to requested gpu nodes

get_BatchPBS_q(j=None, i=None, **kw)¶

Get PBS queue name

Call:

>>> q = opts.get_BatchPBS_q(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {'normal'} | str: PBS queue name

get_BatchPBS_r(j=None, i=None, **kw)¶

Get rerun-able setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {'n'} | 'y': rerun-able setting

get_BatchPBS_select(j=None, i=None, **kw)¶

Get number of nodes

Call:

>>> select = opts.get_BatchPBS_select(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

select: {1} | int: number of nodes

get_BatchPBS_site_needed(j=None, i=None, **kw)¶

Get list of manually requested hard drives to mount

Call:

>>> site_needed = opts.get_BatchPBS_site_needed(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

site_needed: {None} | list[str]: list of manually requested hard drives to mount

get_BatchPBS_walltime(j=None, i=None, **kw)¶

Get maximum job wall time

Call:

>>> walltime = opts.get_BatchPBS_walltime(j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

walltime: {'8:00:00'} | str: maximum job wall time

get_BatchShellCmds(j=None, i=None, **kw)¶

Get additional shell commands for batch jobs

Call:

>>> BatchShellCmds = opts.get_BatchShellCmds(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:

BatchShellCmds: {None} | list[str]: additional shell commands for batch jobs

get_BatchSlurm_A(j=None, i=None, **kw)¶

Get Slurm job account name

Call:

>>> A = opts.get_BatchSlurm_A(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | str: Slurm job account name

get_BatchSlurm_C(j=None, i=None, **kw)¶

Get constraint(s) on Slurm job

Call:

>>> C = opts.get_BatchSlurm_C(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

C: {None} | str: constraint(s) on Slurm job

get_BatchSlurm_N(j=None, i=None, **kw)¶

Get number of Slurm nodes

Call:

>>> N = opts.get_BatchSlurm_N(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {1} | int: number of Slurm nodes

get_BatchSlurm_b(j=None, i=None, **kw)¶

Get constraints on when to acllocate job

Call:

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

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: constraints on when to acllocate job

get_BatchSlurm_gid(j=None, i=None, **kw)¶

Get Slurm job group ID

Call:

>>> gid = opts.get_BatchSlurm_gid(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

gid: {None} | str: Slurm job group ID

get_BatchSlurm_n(j=None, i=None, **kw)¶

Get number of CPUs per node

Call:

>>> n = opts.get_BatchSlurm_n(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {40} | int: number of CPUs per node

get_BatchSlurm_other(j=None, i=None, **kw)¶

Get dict of additional Slurm options using = char

Call:

>>> other = opts.get_BatchSlurm_other(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

other: {None} | dict: dict of additional Slurm options using = char

get_BatchSlurm_p(j=None, i=None, **kw)¶

Get Slurm queue name

Call:

>>> p = opts.get_BatchSlurm_p(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {'normal'} | str: Slurm queue name

get_BatchSlurm_shell(j=None, i=None, **kw)¶

Get Slurm job shell name

Call:

>>> shell = opts.get_BatchSlurm_shell(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

shell: {'/bin/bash'} | str: Slurm job shell name

get_BatchSlurm_time(j=None, i=None, **kw)¶

Get max Slurm job wall time

Call:

>>> time = opts.get_BatchSlurm_time(j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

time: {'8:00:00'} | str: max Slurm job wall time

get_CompTargets(comp: str)¶

Get the list of targets for a specific data book component

Call:

>>> targs = opts.get_CompTargets(comp)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str: Name of component

Outputs:

targs: list[str]: List of targets for that component

Versions:

2014-12-21 @ddalle: v1.0

get_ConfigComponents(j=None, i=None, **kw)¶

Get list of components to request from solver

Call:

>>> Components = opts.get_ConfigComponents(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:

Components: {[]} | list[str]: list of components to request from solver

get_ConfigFile(j=None, i=None, **kw)¶

Get configuration file name

Call:

>>> ConfigFile = opts.get_ConfigFile(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:

ConfigFile: {'Config.xml'} | str: configuration file name

get_ContinuePhase(j=None, i=None, **kw)¶

Get whether restarts of same phase can use same job

Call:

>>> ContinuePhase = opts.get_ContinuePhase(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:

ContinuePhase: {None} | True | False: whether restarts of same phase can use same job

get_DataBookAbsProjTol(comp=None, j=None, i=None, **kw)¶

Get absolute projection tolerance

Call:

>>> AbsProjTol = opts.get_DataBookAbsProjTol(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

AbsProjTol: {None} | object: absolute projection tolerance

get_DataBookAbsTol(comp=None, j=None, i=None, **kw)¶

Get absolute tangent tolerance for surface mapping

Call:

>>> AbsTol = opts.get_DataBookAbsTol(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

AbsTol: {None} | object: absolute tangent tolerance for surface mapping

get_DataBookByGlob(typ, pat=None)¶

Get list of components by type and list of wild cards

Call:

>>> comps = opts.get_DataBookByGlob(typ, pat=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
typ: "FM" | str: Target value for "Type" of matching components
pat: {None} | str | list: List of component name patterns

Outputs:

comps: str: All components meeting one or more wild cards

Versions:

2017-04-25 @ddalle: v1.0
2023-02-06 @ddalle: v1.1; improved naming
2023-03-09 @ddalle: v1.2; validate typ

get_DataBookByType(typ: str) → list¶

Get the list of data book components with a given type

Call:

>>> comps = opts.get_DataBookByType(typ)

Inputs:

opts: cape.cfdx.options.Options: Options interface
typ: "FM" | "LineLoad" | str: Data book type

Outputs:

comps: list[str]: List of components with "Type" matching typ

Versions:

2016-06-07 @ddalle: v1.0
2023-03-09 @ddalle: v1.1; validate typ

get_DataBookColStats(comp: str, col: str) → list¶

Get list of statistical properties for a databook column

Call:

>>> sts = opts.get_DataBookColStats(comp, col)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str: Name of data book component
col: str: Name of data book col, "CA", "CY", etc.

Outputs:

sts: list[str]: List of statistical properties for this col; values include mu (mean), min, max, std, and err

Versions:

2016-03-15 @ddalle: v1.0
2023-03-12 @ddalle: v1.1; optdict; needs override

get_DataBookCols(comp=None, j=None, i=None, **kw)¶

Get value of option “Cols”

Call:

>>> Cols = opts.get_DataBookCols(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Cols: {None} | object: value of option “Cols”

get_DataBookCompID(comp: str, **kw)¶

Get CompID opton for a component

Call:

>>> compid = opts.get_DataBookCompID(comp, **kw)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str: Name of databook component

Outputs:

compid: int | str | list: Value of opt from either opts or opts[comp]

Versions:

2023-01-22 @ddalle: v1.0

get_DataBookCompProjTol(comp=None, j=None, i=None, **kw)¶

Get projection tolerance relative to size of component

Call:

>>> CompProjTol = opts.get_DataBookCompProjTol(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

CompProjTol: {None} | object: projection tolerance relative to size of component

get_DataBookCompTol(comp=None, j=None, i=None, **kw)¶

Get tangent tolerance relative to component

Call:

>>> CompTol = opts.get_DataBookCompTol(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

CompTol: {None} | object: tangent tolerance relative to component

get_DataBookComponents(j=None, i=None, **kw)¶

Get list of databook components

Call:

>>> Components = opts.get_DataBookComponents(j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Components: {None} | str: list of databook components

get_DataBookConfigCompID(comp=None, j=None, i=None, **kw)¶

Get value of option “ConfigCompID”

Call:

>>> ConfigCompID = opts.get_DataBookConfigCompID(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

ConfigCompID: {None} | object: value of option “ConfigCompID”

get_DataBookConfigFile(comp=None, j=None, i=None, **kw)¶

Get value of option “ConfigFile”

Call:

>>> ConfigFile = opts.get_DataBookConfigFile(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

ConfigFile: {None} | object: value of option “ConfigFile”

get_DataBookDNStats(comp=None, j=None, i=None, **kw)¶

Get increment for candidate window sizes

Call:

>>> DNStats = opts.get_DataBookDNStats(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

DNStats: {None} | int: increment for candidate window sizes

get_DataBookDataCols(comp: str)¶

Get the list of data book columns for a specific component

This includes the list of coefficients, e.g. ['CA', 'CY', 'CN']; statistics such as 'CA_min' if nStats is greater than 0.

Call:

>>> cols = opts.get_DataBookDataCols(comp)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str: Name of component

Outputs:

cols: list[str]: List of coefficients and other columns for that coefficient

Versions:

2014-12-21 @ddalle: v1.0
2022-04-08 @ddalle: v2.0; cooeff-spec suffixes
2023-03-12 @ddalle: v3.0; use optdict

get_DataBookDelimiter(comp=None, j=None, i=None, **kw)¶

Get delimiter to use in databook files

Call:

>>> Delimiter = opts.get_DataBookDelimiter(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Delimiter: {','} | str: delimiter to use in databook files

get_DataBookFloatCols(comp=None, j=None, i=None, **kw)¶

Get additional databook cols with floating-point values

Call:

>>> FloatCols = opts.get_DataBookFloatCols(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

FloatCols: {None} | object: additional databook cols with floating-point values

get_DataBookFolder(j=None, i=None, **kw)¶

Get folder for root of databook

Call:

>>> Folder = opts.get_DataBookFolder(j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Folder: {'data'} | str: folder for root of databook

get_DataBookFunction(comp=None, j=None, i=None, **kw)¶

Get value of option “Function”

Call:

>>> Function = opts.get_DataBookFunction(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Function: {None} | object: value of option “Function”

get_DataBookGauge(comp=None, j=None, i=None, **kw)¶

Get option to use gauge pressures in computations

Call:

>>> Gauge = opts.get_DataBookGauge(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Gauge: {None} | object: option to use gauge pressures in computations

get_DataBookIntCols(comp=None, j=None, i=None, **kw)¶

Get value of option “IntCols”

Call:

>>> IntCols = opts.get_DataBookIntCols(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

IntCols: {None} | object: value of option “IntCols”

get_DataBookMapTri(comp=None, j=None, i=None, **kw)¶

Get name of a tri file to use for remapping CFD surface comps

Call:

>>> MapTri = opts.get_DataBookMapTri(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

MapTri: {None} | object: name of a tri file to use for remapping CFD surface comps

get_DataBookMomentum(comp=None, j=None, i=None, **kw)¶

Get whether to use momentum flux in force computations

Call:

>>> Momentum = opts.get_DataBookMomentum(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Momentum: {None} | object: whether to use momentum flux in force computations

get_DataBookNCut(comp=None, j=None, i=None, **kw)¶

Get number of 'LineLoad' cuts for triload

Call:

>>> NCut = opts.get_DataBookNCut(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

NCut: {None} | object: number of 'LineLoad' cuts for triload

get_DataBookNMaxStats(comp=None, j=None, i=None, **kw)¶

Get max number of iters to include in averaging window

Call:

>>> NMaxStats = opts.get_DataBookNMaxStats(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

NMaxStats: {None} | int: max number of iters to include in averaging window

get_DataBookNMin(comp=None, j=None, i=None, **kw)¶

Get first iter to consider for use in databook [for a comp]

Call:

>>> NMin = opts.get_DataBookNMin(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

NMin: {0} | int: first iter to consider for use in databook [for a comp]

get_DataBookNStats(comp=None, j=None, i=None, **kw)¶

Get iterations to use in averaging window [for a comp]

Call:

>>> NStats = opts.get_DataBookNStats(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

NStats: {0} | int: iterations to use in averaging window [for a comp]

get_DataBookOpt(comp: str, opt: str, check=True, **kw)¶

Get an option for a specific component

Call:

>>> v = opts.get_DataBookOpt(comp, opt, **kw)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str: Name of specific databook component
opt: str: Name of option to access
check: {True} | False: Option to fail if comp not present

Outputs:

v: object: Value of opt from either opts or opts[comp]

Versions:

2024-01-19 @ddalle: v1.0
2024-05-20 @ddalle: v1.1; add check

get_DataBookOutputFormat(comp=None, j=None, i=None, **kw)¶

Get value of option “OutputFormat”

Call:

>>> OutputFormat = opts.get_DataBookOutputFormat(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

OutputFormat: {None} | object: value of option “OutputFormat”

get_DataBookPatches(comp=None, j=None, i=None, **kw)¶

Get list of patches for a databook component

Call:

>>> Patches = opts.get_DataBookPatches(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Patches: {None} | object: list of patches for a databook component

get_DataBookPoints(comp=None, j=None, i=None, **kw)¶

Get list of individual point sensors

Call:

>>> Points = opts.get_DataBookPoints(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Points: {None} | object: list of individual point sensors

get_DataBookPrefix(comp=None, j=None, i=None, **kw)¶

Get value of option “Prefix”

Call:

>>> Prefix = opts.get_DataBookPrefix(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Prefix: {None} | object: value of option “Prefix”

get_DataBookRelProjTol(comp=None, j=None, i=None, **kw)¶

Get projection tolerance relative to size of geometry

Call:

>>> RelProjTol = opts.get_DataBookRelProjTol(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

RelProjTol: {None} | object: projection tolerance relative to size of geometry

get_DataBookRelTol(comp=None, j=None, i=None, **kw)¶

Get tangent tolerance relative to overall geometry scale

Call:

>>> RelTol = opts.get_DataBookRelTol(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

RelTol: {None} | object: tangent tolerance relative to overall geometry scale

get_DataBookSectionType(comp=None, j=None, i=None, **kw)¶

Get line load section type

Call:

>>> SectionType = opts.get_DataBookSectionType(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

SectionType: {None} | object: line load section type

get_DataBookTargetByName(name: str)¶

Get a data book target by Name, using user-defined name

Call:

>>> topts = opts.get_DataBookTargetByName(name)

Inputs:

opts: cape.cfdx.options.Options: Options interface
name: str: Name of the data book target

Outputs:

topts: DBTargetOpts: Databook target options

Versions:

2015-12-15 @ddalle: v1.0
2023-03-12 @ddalle: v2.0; use optdict

get_DataBookTargetCommentChar(targ: str, j=None, i=None, **kw)¶

Get value of option “CommentChar”

Call:

>>> CommentChar = opts.get_DataBookTargetCommentChar(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

CommentChar: {None} | object: value of option “CommentChar”

get_DataBookTargetComponents(targ: str, j=None, i=None, **kw)¶

Get value of option “Components”

Call:

>>> Components = opts.get_DataBookTargetComponents(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

Components: {None} | object: value of option “Components”

get_DataBookTargetDelimiter(targ: str, j=None, i=None, **kw)¶

Get value of option “Delimiter”

Call:

>>> Delimiter = opts.get_DataBookTargetDelimiter(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

Delimiter: {None} | object: value of option “Delimiter”

get_DataBookTargetFile(targ: str, j=None, i=None, **kw)¶

Get value of option “File”

Call:

>>> File = opts.get_DataBookTargetFile(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

File: {None} | object: value of option “File”

get_DataBookTargetFolder(targ: str, j=None, i=None, **kw)¶

Get value of option “Folder”

Call:

>>> Folder = opts.get_DataBookTargetFolder(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

Folder: {None} | object: value of option “Folder”

get_DataBookTargetLabel(targ: str, **kw)¶

Get Label from databook target, falling back to Name

Call:

>>> lbl = opts.get_DataBookTargetLabel(targ, **kw)

Inputs:

opts: cape.cfdx.options.Options: Options interface
targ: str: Name of databook target

Outputs:

lbl: targ | str: User-defined Label of target or Name or targ

Versions:

2023-03-12 @ddalle: v1.0

get_DataBookTargetName(targ: str, **kw)¶

Get Name from databook target, falling back to targ

Call:

>>> name = opts.get_DataBookTargetName(targ, **kw)

Inputs:

opts: cape.cfdx.options.Options: Options interface
targ: str: Name of databook target

Outputs:

name: targ | str: User-defined Name of target or targ

Versions:

2023-03-12 @ddalle: v1.0

get_DataBookTargetTolerances(targ: str, j=None, i=None, **kw)¶

Get value of option “Tolerances”

Call:

>>> Tolerances = opts.get_DataBookTargetTolerances(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

Tolerances: {None} | object: value of option “Tolerances”

get_DataBookTargetTranslations(targ: str, j=None, i=None, **kw)¶

Get value of option “Translations”

Call:

>>> Translations = opts.get_DataBookTargetTranslations(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

Translations: {None} | object: value of option “Translations”

get_DataBookTargetType(targ: str, j=None, i=None, **kw)¶

Get value of option “Type”

Call:

>>> Type = opts.get_DataBookTargetType(targ, i=None, **kw)

Inputs:

opts: DBTargetCollectionOpts: options interface
targ: str: Name of databook target
i: {None} | int: Case index

Outputs:

Type: {None} | object: value of option “Type”

get_DataBookTargets(j=None, i=None, **kw)¶

Get value of option “Targets”

Call:

>>> Targets = opts.get_DataBookTargets(j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Targets: {None} | object: value of option “Targets”

get_DataBookTransformations(comp=None, j=None, i=None, **kw)¶

Get value of option “Transformations”

Call:

>>> Transformations = opts.get_DataBookTransformations(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Transformations: {None} | object: value of option “Transformations”

get_DataBookTrim(comp=None, j=None, i=None, **kw)¶

Get trim flag to triload

Call:

>>> Trim = opts.get_DataBookTrim(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Trim: {None} | object: trim flag to triload

get_DataBookTriqFormat(comp=None, j=None, i=None, **kw)¶

Get file format for any .triq files to read

Call:

>>> TriqFormat = opts.get_DataBookTriqFormat(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

TriqFormat: {None} | object: file format for any .triq files to read

get_DataBookType(comp=None, j=None, i=None, **kw)¶

Get Default component type

Call:

>>> Type = opts.get_DataBookType(comp=None, i=None, **kw)

Inputs:

opts: DataBookOpts: options interface
comp: {None} | str: Name of databook component
i: {None} | int: Case index

Outputs:

Type: 'CaseProp' | {'FM'} | 'IterPoint' | 'LineLoad' | 'PyFunc' | 'TriqFM' | 'TriqPoint': Default component type

get_Environ(opt, j=0, i=None)¶

Get an environment variable setting by name

Call:

>>> val = opts.get_Environ(opt, j=0)

Inputs:

opts: cape.options.Options: Options interface
opt: str: Name of the environment variable
i: {None} | int: Case index
j: {0} | None | int: Phase number

Outputs:

val: str: Value to set the environment variable to

Versions:

2015-11-10 @ddalle: v1.0
2022-10-29 @ddalle: v2.0; OptionsDict methods

get_FigList() → list¶

Get list of figures for a report

Call:

>>> figs = opts.get_FigList()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

figs: list[str]: List of figures by name

Versions:

2015-03-08 @ddalle: v1.0
2023-04-20 @ddalle: v2.0; Updates for OptionsDict

get_FigOpt(fig: str, opt: str, **kw)¶

Retrieve an option for a figure

Call:

>>> val = opts.get_FigOpt(fig, opt)

Inputs:

opts: cape.options.Options: Options interface
fig: str: Name of figure
opt: str: Name of option to retrieve

Outputs:

val: object: Sweep option value

Versions:

2023-04-27 @ddalle: v1.0

get_GroupMesh()¶

Determine whether or not groups have common meshes

Call:

>>> qGM = opts.get_GroupMesh()

Inputs:

opts pyCart.options.Options: Options interface

Outputs:

qGM: bool: Whether cases in a group use the same (starting) mesh

Versions:

2014-10-06 @ddalle: Version 1.0
2022-10-23 @ddalle: Version 1.1; hard-code default

get_JSONFile(j=None, i=None, **kw)¶

Get name of JSON file from which settings originated

Call:

>>> JSONFile = opts.get_JSONFile(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:

JSONFile: {None} | str: name of JSON file from which settings originated

get_LastIter(i=None)¶

Return the minimum number of iterations for case to be done

Call:

>>> nIter = opts.get_LastIter(i=None)

Inputs:

opts: cape.options.Options: Options interface
i: {None} | int: Case index

Outputs:

nIter: int: Number of required iterations for case

Versions:

2014-10-02 @ddalle: v1.0

get_MPI(j=None, i=None, **kw)¶

Get whether or not to run MPI in phase

Call:

>>> MPI = opts.get_MPI(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:

MPI: {False} | True: whether or not to run MPI in phase

get_MeshFile(j=None, i=None, **kw)¶

Get original mesh file name(s)

Call:

>>> MeshFile = opts.get_MeshFile(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:

MeshFile: {None} | str: original mesh file name(s)

get_NJob(j=None, i=None, **kw)¶

Get number of jobs to run concurrently

Call:

>>> NJob = opts.get_NJob(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:

NJob: {0} | int: number of jobs to run concurrently

get_NSubmit(j=None, i=None, **kw)¶

Get maximum number of jobs to submit at one time

Call:

>>> NSubmit = opts.get_NSubmit(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:

NSubmit: {10} | object: maximum number of jobs to submit at one time

get_PBS_A(j=None, i=None, **kw)¶

Get account name(s) or number(s)

Call:

>>> A = opts.get_PBS_A(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: account name(s) or number(s)

get_PBS_S(j=None, i=None, **kw)¶

Get shell to execute PBS job

Call:

>>> S = opts.get_PBS_S(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

S: {'/bin/bash'} | str: shell to execute PBS job

get_PBS_W(j=None, i=None, **kw)¶

Get PBS W setting, usually for setting group

Call:

>>> W = opts.get_PBS_W(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

W: {''} | str: PBS W setting, usually for setting group

get_PBS_aoe(j=None, i=None, **kw)¶

Get architecture operating environment

Call:

>>> aoe = opts.get_PBS_aoe(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

aoe: {None} | str: architecture operating environment

get_PBS_e(j=None, i=None, **kw)¶

Get explicit STDERR file name

Call:

>>> e = opts.get_PBS_e(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object: explicit STDERR file name

get_PBS_j(j=None, i=None, **kw)¶

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

j: {'oe'} | str: PBS ‘join’ setting

get_PBS_mem(j=None, i=None, **kw)¶

Get Requested cpu memory (on gpu node)

Call:

>>> mem = opts.get_PBS_mem(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mem: {None} | int: Requested cpu memory (on gpu node)

get_PBS_model(j=None, i=None, **kw)¶

Get model type/architecture

Call:

>>> model = opts.get_PBS_model(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

model: {None} | str: model type/architecture

get_PBS_mpiprocs(j=None, i=None, **kw)¶

Get number of MPI processes per node

Call:

>>> mpiprocs = opts.get_PBS_mpiprocs(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mpiprocs: {None} | int: number of MPI processes per node

get_PBS_ncpus(j=None, i=None, **kw)¶

Get number of cores (roughly CPUs) per node

Call:

>>> ncpus = opts.get_PBS_ncpus(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ncpus: {None} | int: number of cores (roughly CPUs) per node

get_PBS_ngpus(j=None, i=None, **kw)¶

Get number of gpus per node

Call:

>>> ngpus = opts.get_PBS_ngpus(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ngpus: {None} | int: number of gpus per node

get_PBS_o(j=None, i=None, **kw)¶

Get explicit STDOUT file name

Call:

>>> o = opts.get_PBS_o(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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} | object: explicit STDOUT file name

get_PBS_ompthreads(j=None, i=None, **kw)¶

Get number of OMP threads

Call:

>>> ompthreads = opts.get_PBS_ompthreads(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ompthreads: {None} | int: number of OMP threads

get_PBS_p(j=None, i=None, **kw)¶

Get PBS priority

Call:

>>> p = opts.get_PBS_p(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object: PBS priority

get_PBS_place(j=None, i=None, **kw)¶

Get Share or exclusive access to requested gpu nodes

Call:

>>> place = opts.get_PBS_place(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

place: {'excl'} | 'shared': Share or exclusive access to requested gpu nodes

get_PBS_q(j=None, i=None, **kw)¶

Get PBS queue name

Call:

>>> q = opts.get_PBS_q(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {'normal'} | str: PBS queue name

get_PBS_r(j=None, i=None, **kw)¶

Get rerun-able setting

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {'n'} | 'y': rerun-able setting

get_PBS_select(j=None, i=None, **kw)¶

Get number of nodes

Call:

>>> select = opts.get_PBS_select(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

select: {1} | int: number of nodes

get_PBS_site_needed(j=None, i=None, **kw)¶

Get list of manually requested hard drives to mount

Call:

>>> site_needed = opts.get_PBS_site_needed(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

site_needed: {None} | list[str]: list of manually requested hard drives to mount

get_PBS_walltime(j=None, i=None, **kw)¶

Get maximum job wall time

Call:

>>> walltime = opts.get_PBS_walltime(j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

walltime: {'8:00:00'} | str: maximum job wall time

get_PhaseIters(j=None, i=None, **kw)¶

Get check-point iterations for phase j

Call:

>>> PhaseIters = opts.get_PhaseIters(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:

PhaseIters: {None} | int: check-point iterations for phase j

get_PhaseSequence(j=None, i=None, **kw)¶

Get list of phase indices to run

Call:

>>> PhaseSequence = opts.get_PhaseSequence(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:

PhaseSequence: {None} | int: list of phase indices to run

get_Point(name=None)¶

Return the coordinates of a point by name

If the input is a point, it is simply returned

Call:

>>> x = opts.get_Point(name=None)
>>> x = opts.get_Point(x)

Inputs:

opts: cape.cfdx.options.Options: Options interface
name: str: Point name

Outputs:

x: [float, float, float]: Coordinates of that point

Versions:

2015-09-11 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 1.1; ARRAY_TYPES

get_PostPBS_A(j=None, i=None, **kw)¶

Get account name(s) or number(s)

Call:

>>> A = opts.get_PostPBS_A(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: account name(s) or number(s)

get_PostPBS_S(j=None, i=None, **kw)¶

Get shell to execute PBS job

Call:

>>> S = opts.get_PostPBS_S(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

S: {'/bin/bash'} | str: shell to execute PBS job

get_PostPBS_W(j=None, i=None, **kw)¶

Get PBS W setting, usually for setting group

Call:

>>> W = opts.get_PostPBS_W(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

W: {''} | str: PBS W setting, usually for setting group

get_PostPBS_aoe(j=None, i=None, **kw)¶

Get architecture operating environment

Call:

>>> aoe = opts.get_PostPBS_aoe(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

aoe: {None} | str: architecture operating environment

get_PostPBS_e(j=None, i=None, **kw)¶

Get explicit STDERR file name

Call:

>>> e = opts.get_PostPBS_e(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object: explicit STDERR file name

get_PostPBS_j(j=None, i=None, **kw)¶

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

j: {'oe'} | str: PBS ‘join’ setting

get_PostPBS_mem(j=None, i=None, **kw)¶

Get Requested cpu memory (on gpu node)

Call:

>>> mem = opts.get_PostPBS_mem(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mem: {None} | int: Requested cpu memory (on gpu node)

get_PostPBS_model(j=None, i=None, **kw)¶

Get model type/architecture

Call:

>>> model = opts.get_PostPBS_model(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

model: {None} | str: model type/architecture

get_PostPBS_mpiprocs(j=None, i=None, **kw)¶

Get number of MPI processes per node

Call:

>>> mpiprocs = opts.get_PostPBS_mpiprocs(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mpiprocs: {None} | int: number of MPI processes per node

get_PostPBS_ncpus(j=None, i=None, **kw)¶

Get number of cores (roughly CPUs) per node

Call:

>>> ncpus = opts.get_PostPBS_ncpus(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ncpus: {None} | int: number of cores (roughly CPUs) per node

get_PostPBS_ngpus(j=None, i=None, **kw)¶

Get number of gpus per node

Call:

>>> ngpus = opts.get_PostPBS_ngpus(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ngpus: {None} | int: number of gpus per node

get_PostPBS_o(j=None, i=None, **kw)¶

Get explicit STDOUT file name

Call:

>>> o = opts.get_PostPBS_o(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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} | object: explicit STDOUT file name

get_PostPBS_ompthreads(j=None, i=None, **kw)¶

Get number of OMP threads

Call:

>>> ompthreads = opts.get_PostPBS_ompthreads(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ompthreads: {None} | int: number of OMP threads

get_PostPBS_p(j=None, i=None, **kw)¶

Get PBS priority

Call:

>>> p = opts.get_PostPBS_p(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object: PBS priority

get_PostPBS_place(j=None, i=None, **kw)¶

Get Share or exclusive access to requested gpu nodes

Call:

>>> place = opts.get_PostPBS_place(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

place: {'excl'} | 'shared': Share or exclusive access to requested gpu nodes

get_PostPBS_q(j=None, i=None, **kw)¶

Get PBS queue name

Call:

>>> q = opts.get_PostPBS_q(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {'normal'} | str: PBS queue name

get_PostPBS_r(j=None, i=None, **kw)¶

Get rerun-able setting

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {'n'} | 'y': rerun-able setting

get_PostPBS_select(j=None, i=None, **kw)¶

Get number of nodes

Call:

>>> select = opts.get_PostPBS_select(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

select: {1} | int: number of nodes

get_PostPBS_site_needed(j=None, i=None, **kw)¶

Get list of manually requested hard drives to mount

Call:

>>> site_needed = opts.get_PostPBS_site_needed(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

site_needed: {None} | list[str]: list of manually requested hard drives to mount

get_PostPBS_walltime(j=None, i=None, **kw)¶

Get maximum job wall time

Call:

>>> walltime = opts.get_PostPBS_walltime(j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

walltime: {'8:00:00'} | str: maximum job wall time

get_PostShellCmds(j=None, i=None, **kw)¶

Get list of commands to run after each cycle

Call:

>>> PostShellCmds = opts.get_PostShellCmds(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:

PostShellCmds: {None} | list[str]: list of commands to run after each cycle

get_PostSlurm_A(j=None, i=None, **kw)¶

Get Slurm job account name

Call:

>>> A = opts.get_PostSlurm_A(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | str: Slurm job account name

get_PostSlurm_C(j=None, i=None, **kw)¶

Get constraint(s) on Slurm job

Call:

>>> C = opts.get_PostSlurm_C(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

C: {None} | str: constraint(s) on Slurm job

get_PostSlurm_N(j=None, i=None, **kw)¶

Get number of Slurm nodes

Call:

>>> N = opts.get_PostSlurm_N(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {1} | int: number of Slurm nodes

get_PostSlurm_b(j=None, i=None, **kw)¶

Get constraints on when to acllocate job

Call:

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

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: constraints on when to acllocate job

get_PostSlurm_gid(j=None, i=None, **kw)¶

Get Slurm job group ID

Call:

>>> gid = opts.get_PostSlurm_gid(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

gid: {None} | str: Slurm job group ID

get_PostSlurm_n(j=None, i=None, **kw)¶

Get number of CPUs per node

Call:

>>> n = opts.get_PostSlurm_n(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {40} | int: number of CPUs per node

get_PostSlurm_other(j=None, i=None, **kw)¶

Get dict of additional Slurm options using = char

Call:

>>> other = opts.get_PostSlurm_other(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

other: {None} | dict: dict of additional Slurm options using = char

get_PostSlurm_p(j=None, i=None, **kw)¶

Get Slurm queue name

Call:

>>> p = opts.get_PostSlurm_p(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {'normal'} | str: Slurm queue name

get_PostSlurm_shell(j=None, i=None, **kw)¶

Get Slurm job shell name

Call:

>>> shell = opts.get_PostSlurm_shell(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

shell: {'/bin/bash'} | str: Slurm job shell name

get_PostSlurm_time(j=None, i=None, **kw)¶

Get max Slurm job wall time

Call:

>>> time = opts.get_PostSlurm_time(j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

time: {'8:00:00'} | str: max Slurm job wall time

get_PreMesh(j=None, i=None, **kw)¶

Get whether or not to generate volume mesh before submitting

Call:

>>> PreMesh = opts.get_PreMesh(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:

PreMesh: {False} | True: whether or not to generate volume mesh before submitting

get_PythonExec(j=None, i=None, **kw)¶

Get specific Python executable to use for jobs

Call:

>>> PythonExec = opts.get_PythonExec(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:

PythonExec: {None} | str: specific Python executable to use for jobs

get_RefArea(comp=None)¶

Return the reference area [for a component]

The comp input has an affect if the "RefArea" option is a dict. Otherwise all values of comp wil return the same Aref

Call:

>>> Aref = opts.get_RefArea()
>>> Aref = opts.get_RefArea(comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: {None} | str: Name of component

Outputs:

Aref: float: Reference area [for comp]

Versions:

2014-09-29 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 2.0; get_refcol()

get_RefLength(comp=None)¶

Return the reference length [for a component]

The comp argument has an effect if the``”RefLength”`` option is a dict

Call:

>>> Lref = opts.get_RefLength()
>>> Lref = opts.get_RefLength(comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: {None} | str: Name of component

Outputs:

Lref: float: Reference length [of comp]

Versions:

2014-09-29 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 2.0; get_refcol()

get_RefPoint(comp=None)¶

Return the moment reference point [for a component]

Call:

>>> x = opts.get_RefPoint()
>>> x = opts.get_RefPoint(comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: str or int: Name of component or component index

Outputs:

x: [float, float, float]: Moment reference point [for comp]

Versions:

2014-09-29 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 2.0; get_refcol()

get_RefSpan(comp=None)¶

Return the reference span [for a component]

This falls back to "RefLength" if appropriate

Call:

>>> bref = opts.get_RefSpan()
>>> bref = opts.get_RefSpan(comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
comp: {None} | str: Name of component

Outputs:

bref: float: Reference span [for comp]

Versions:

2017-02-19 @ddalle: Version 1.0; from get_RefLength
2022-11-01 @ddalle: Version 2.0; get_refcol()

get_ReportErrorFigures(report: str)¶

Get list of figures for cases with ERROR status

Call:

>>> figs = opts.get_ReportErrorFigList(report)

Inputs:

opts: cape.options.Options: Options interface
report: str: Name of report

Outputs:

figs: list[str]: List of figures in the report

Versions:

2015-03-08 @ddalle: v1.0

get_ReportList(j=None, **kw)¶

Get list of reports available to create

Call:

>>> reps = opts.get_ReportList()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

reps: list[str]: List of reports by name

Versions:

2015-03-08 @ddalle: v1.0
2023-04-20 @ddalle: v2.0; simple OptionsDict method

get_ReportOpt(report: str, opt: str, **kw)¶

Get named option for a specific report

Call:

>>> val = opts.get_ReportOpt(report, opt, **kw)

Inputs:

opts: cape.options.Options: Options interface
report: str: Name of report
opt: str: Name of option

Outputs:

val: object: Value of opt

Versions:

2023-04-27 @ddalle: v1.0

get_RestartSamePhase(j=None, i=None, **kw)¶

Get whether to restart same phase if needed

Call:

>>> RestartSamePhase = opts.get_RestartSamePhase(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:

RestartSamePhase: {True} | False: whether to restart same phase if needed

get_ResubmitNextPhase(j=None, i=None, **kw)¶

Get whether new job submits at end of phase

Call:

>>> ResubmitNextPhase = opts.get_ResubmitNextPhase(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:

ResubmitNextPhase: {False} | True: whether new job submits at end of phase

get_ResubmitSamePhase(j=None, i=None, **kw)¶

Get whether same-phase repeats need new job

Call:

>>> ResubmitSamePhase = opts.get_ResubmitSamePhase(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:

ResubmitSamePhase: {False} | True: whether same-phase repeats need new job

get_RootDir(j=None, i=None, **kw)¶

Get (absolute) base folder from which CAPE settings were read

Call:

>>> RootDir = opts.get_RootDir(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:

RootDir: {None} | str: (absolute) base folder from which CAPE settings were read

get_RunControlOpt(opt: str, j=None, **kw)¶

Get a general option from the “RunControl” section

Call:

>>> val = opts.get_RunControlOpt(opt, j=None, **kw)

Inputs:

opts: Options: Options interface
opt: str: Name of option to get or sample
j: {None} | int: Phase index

Outputs:

val: object: Value of opts[opt], sampled as appropriate

Versions:

2023-07-17 @ddalle: v1.0

get_RunMatrixDefinitions(j=None, i=None, **kw)¶

Get definitions for each run matrix variable

Call:

>>> Definitions = opts.get_RunMatrixDefinitions(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Definitions: {None} | dict: definitions for each run matrix variable

get_RunMatrixFile(j=None, i=None, **kw)¶

Get run matrix data file name

Call:

>>> File = opts.get_RunMatrixFile(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

File: {None} | str: run matrix data file name

get_RunMatrixFreestream(j=None, i=None, **kw)¶

Get properties of freestream gas model

Call:

>>> Freestream = opts.get_RunMatrixFreestream(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Freestream: {{}} | dict: properties of freestream gas model

get_RunMatrixGroupMesh(j=None, i=None, **kw)¶

Get value of option “GroupMesh”

Call:

>>> GroupMesh = opts.get_RunMatrixGroupMesh(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

GroupMesh: {False} | True: value of option “GroupMesh”

get_RunMatrixGroupPrefix(j=None, i=None, **kw)¶

Get default prefix for group folders

Call:

>>> GroupPrefix = opts.get_RunMatrixGroupPrefix(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

GroupPrefix: {'Grid'} | str: default prefix for group folders

get_RunMatrixKeys(j=None, i=None, **kw)¶

Get list of run matrix variables

Call:

>>> Keys = opts.get_RunMatrixKeys(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {['mach', 'alpha', 'beta']} | list[str]: list of run matrix variables

get_RunMatrixMaxJobNameLength(j=None, i=None, **kw)¶

Get maximum length of PBS/Slurm job name

Call:

>>> MaxJobNameLength = opts.get_RunMatrixMaxJobNameLength(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

MaxJobNameLength: {32} | int: maximum length of PBS/Slurm job name

get_RunMatrixPrefix(j=None, i=None, **kw)¶

Get default prefix for case folders

Call:

>>> Prefix = opts.get_RunMatrixPrefix(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Prefix: {''} | str: default prefix for case folders

get_RunMatrixValues(j=None, i=None, **kw)¶

Get value of option “Values”

Call:

>>> Values = opts.get_RunMatrixValues(j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

Values: {{}} | dict: value of option “Values”

get_SearchMethod(j=None, i=None, **kw)¶

Get method for declaring multiple files with one string

Call:

>>> SearchMethod = opts.get_SearchMethod(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:

SearchMethod: {'glob'} | 'regex': method for declaring multiple files with one string

get_ShellCmds(typ=None)¶

Get shell commands, if any

Call:

>>> cmds = opts.get_ShellCmds(typ=None)

Inputs:

opts: cape.options.Options: Options interface
typ: {None} | "batch" | "post": Add additional commands for batch or post-processing jobs

Outputs:

cmds: list[str]: List of initialization commands

Versions:

2015-11-08 @ddalle: Moved to “RunControl”

get_Slurm_A(j=None, i=None, **kw)¶

Get Slurm job account name

Call:

>>> A = opts.get_Slurm_A(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | str: Slurm job account name

get_Slurm_C(j=None, i=None, **kw)¶

Get constraint(s) on Slurm job

Call:

>>> C = opts.get_Slurm_C(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

C: {None} | str: constraint(s) on Slurm job

get_Slurm_N(j=None, i=None, **kw)¶

Get number of Slurm nodes

Call:

>>> N = opts.get_Slurm_N(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {1} | int: number of Slurm nodes

get_Slurm_b(j=None, i=None, **kw)¶

Get constraints on when to acllocate job

Call:

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

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: constraints on when to acllocate job

get_Slurm_gid(j=None, i=None, **kw)¶

Get Slurm job group ID

Call:

>>> gid = opts.get_Slurm_gid(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

gid: {None} | str: Slurm job group ID

get_Slurm_n(j=None, i=None, **kw)¶

Get number of CPUs per node

Call:

>>> n = opts.get_Slurm_n(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {40} | int: number of CPUs per node

get_Slurm_other(j=None, i=None, **kw)¶

Get dict of additional Slurm options using = char

Call:

>>> other = opts.get_Slurm_other(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

other: {None} | dict: dict of additional Slurm options using = char

get_Slurm_p(j=None, i=None, **kw)¶

Get Slurm queue name

Call:

>>> p = opts.get_Slurm_p(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {'normal'} | str: Slurm queue name

get_Slurm_shell(j=None, i=None, **kw)¶

Get Slurm job shell name

Call:

>>> shell = opts.get_Slurm_shell(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

shell: {'/bin/bash'} | str: Slurm job shell name

get_Slurm_time(j=None, i=None, **kw)¶

Get max Slurm job wall time

Call:

>>> time = opts.get_Slurm_time(j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

time: {'8:00:00'} | str: max Slurm job wall time

get_StartNextPhase(j=None, i=None, **kw)¶

Get whether to start next phase or stop CAPE

Call:

>>> StartNextPhase = opts.get_StartNextPhase(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:

StartNextPhase: {True} | False: whether to start next phase or stop CAPE

get_SubfigBaseType(sfig: str)¶

Get root type for an individual subfigure

Call:

>>> t = opts.get_SubfigBaseType(sfig)

Inputs:

opts: cape.options.Options: Options interface
sfig: str: Name of subfigure

Outputs:

t: str: Subfigure parent type

Versions:

2015-03-08 @ddalle: v1.0

get_SubfigCascade(sfig: str)¶

Return full set of optsion from subfig and its parents

Call:

>>> sfigopts = opts.get_SubfigCasecasde(sfig)

Inputs:

opts: cape.options.Options: Options interface
sfig: str: Name of subfigure

Outputs:

sfigopts: dict: Options for subfigure sfig

Versions:

2015-03-08 @ddalle: v1.0
2023-05-10 @ddalle: v2.0; optdict rewrites

get_SubfigList() → list¶

Get list of available subfigures for a report

Call:

>>> figs = opts.get_SubfigList()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

sfigs: list[str]: List of subfigures by name

Versions:

2015-03-08 @ddalle: v1.0
2023-04-20 @ddalle: v2.0; Updates for OptionsDict

get_SubfigOpt(sfig: str, opt: str, j=None, **kw)¶

Retrieve an option for a subfigure

Call:

>>> val = opts.get_SubfigOpt(sfig, opt, j=None, **kw)

Inputs:

opts: cape.options.Options: Options interface
sfig: str: Name of subfigure
opt: str: Name of option to retrieve
j: {None} | int: Phase index

Outputs:

val: object: Sweep option value

Versions:

2023-04-27 @ddalle: v1.0

get_SweepList() → list¶

Get list of sweeps for a report

Call:

>>> fswps = opts.get_SweepList()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

figs: list[str]: List of figures by name

Versions:

2015-05-28 @ddalle: v1.0
2023-04-20 @ddalle: v2.0; Updates for OptionsDict

get_SweepOpt(sweep: str, opt: str, **kw)¶

Retrieve an option for a sweep

Call:

>>> val = opts.get_SweepOpt(sweep, opt)

Inputs:

opts: cape.options.Options: Options interface
sweep: str: Name of sweep
opt: str: Name of option to retrieve

Outputs:

val: object: Sweep option value

Versions:

2015-05-28 @ddalle: v1.0
2023-04-27 @ddalle: v2.0; use optdict

get_TriFile(j=None, i=None, **kw)¶

Get original surface triangulation file(s)

Call:

>>> TriFile = opts.get_TriFile(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:

TriFile: {None} | str: original surface triangulation file(s)

get_Verbose(j=None, i=None, **kw)¶

Get “RunControl” verbosity flag

Call:

>>> Verbose = opts.get_Verbose(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:

Verbose: {False} | True: “RunControl” verbosity flag

get_WarmStart(j=None, i=None, **kw)¶

Get whether to warm start a case

Call:

>>> WarmStart = opts.get_WarmStart(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:

WarmStart: {False} | True: whether to warm start a case

get_WarmStartFolder(j=None, i=None, **kw)¶

Get folder from which to get warm-start file

Call:

>>> WarmStartFolder = opts.get_WarmStartFolder(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:

WarmStartFolder: {None} | str: folder from which to get warm-start file

get_WarmStartPhase(j=None, i=None, **kw)¶

Get phase from which to warm-start a case

Call:

>>> WarmStartPhase = opts.get_WarmStartPhase(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:

WarmStartPhase: {None} | int: phase from which to warm-start a case

get_aflr3()¶

Return whether or not to run AFLR3 to create mesh

Call:

>>> q = opts.get_aflr3()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

q: True | {False}: Whether or not there are nontrivial AFLR3 settings

Versions:

2016-04-05 @ddalle: v1.0
2022-10-14 @ddalle: v1.1; use bool()

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

get_c(j=None, i=None, **kw)¶

Get core file size limit, ulimit -c

Call:

>>> c = opts.get_c(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

c: {None} | object: core file size limit, ulimit -c

get_core_file_size(j=None, i=None, **kw)¶

Get core file size limit, ulimit -c

Call:

>>> core_file_size = opts.get_core_file_size(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

core_file_size: {None} | object: value of option “core_file_size”

get_d(j=None, i=None, **kw)¶

Get process data segment limit, ulimit -d

Call:

>>> d = opts.get_d(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

d: {None} | object: process data segment limit, ulimit -d

get_data_segment(j=None, i=None, **kw)¶

Get process data segment limit, ulimit -d

Call:

>>> data_segment = opts.get_data_segment(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

data_segment: {None} | object: value of option “data_segment”

get_dmask(sys=True)¶

Get the permissions to assign to new folders

Call:

>>> dmask = opts.get_dmask(sys=True)

Inputs:

opts pyCart.options.Options: Options interface
sys: {True} | False: Whether or not to use system setting as default

Outputs:

dmask: int | None: New folder permissions mask

Versions:

2015-09-27 @ddalle: Version 1.0

get_e(j=None, i=None, **kw)¶

Get max scheduling priority, ulimit -e

Call:

>>> e = opts.get_e(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object: max scheduling priority, ulimit -e

get_f(j=None, i=None, **kw)¶

Get max size of files written by shell, ulimit -f

Call:

>>> f = opts.get_f(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

f: {None} | object: max size of files written by shell, ulimit -f

get_file_locks(j=None, i=None, **kw)¶

Get max number of file locks, ulimit -x

Call:

>>> file_locks = opts.get_file_locks(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

file_locks: {None} | object: value of option “file_locks”

get_file_size(j=None, i=None, **kw)¶

Get max size of files written by shell, ulimit -f

Call:

>>> file_size = opts.get_file_size(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

file_size: {None} | object: value of option “file_size”

get_i(j=None, i=None, **kw)¶

Get max number of pending signals, ulimit -i

Call:

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

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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} | object: max number of pending signals, ulimit -i

get_intersect()¶

Return whether or not to run intersect on triangulations

Call:

>>> q = opts.get_intersect()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

q: True | {False}: Whether or not to run intersect

Versions:

2016-04-05 @ddalle: v1.0
2022-10-23 @ddalle: v1.1; use bool()

get_intersect_T(j=None, i=None, **kw)¶

Get option to also write Tecplot file Components.i.plt

Call:

>>> T = opts.get_intersect_T(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

T: {False} | True: option to also write Tecplot file Components.i.plt

get_intersect_ascii(j=None, i=None, **kw)¶

Get flag that input file is ASCII

Call:

>>> ascii = opts.get_intersect_ascii(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ascii: {None} | True | False: flag that input file is ASCII

get_intersect_cutout(j=None, i=None, **kw)¶

Get number of component to subtract

Call:

>>> cutout = opts.get_intersect_cutout(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

cutout: {None} | int: number of component to subtract

get_intersect_fast(j=None, i=None, **kw)¶

Get also write unformatted FAST file Components.i.fast

Call:

>>> fast = opts.get_intersect_fast(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

fast: {False} | True: also write unformatted FAST file Components.i.fast

get_intersect_i(j=None, i=None, **kw)¶

Get input file to intersect

Call:

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

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {'Components.tri'} | str: input file to intersect

get_intersect_intersections(j=None, i=None, **kw)¶

Get option to write intersections to intersect.dat

Call:

>>> intersections = opts.get_intersect_intersections(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

intersections: {False} | True: option to write intersections to intersect.dat

get_intersect_o(j=None, i=None, **kw)¶

Get output file for intersect

Call:

>>> o = opts.get_intersect_o(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {'Components.i.tri'} | str: output file for intersect

get_intersect_overlap(j=None, i=None, **kw)¶

Get perform boolean intersection of this comp number

Call:

>>> overlap = opts.get_intersect_overlap(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

overlap: {None} | int: perform boolean intersection of this comp number

get_intersect_rm(j=None, i=None, **kw)¶

Get option to remove small triangles from results

Call:

>>> rm = opts.get_intersect_rm(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

rm: {False} | True: option to remove small triangles from results

get_intersect_smalltri(j=None, i=None, **kw)¶

Get cutoff size for small triangles with rm

Call:

>>> smalltri = opts.get_intersect_smalltri(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

smalltri: {0.0001} | float: cutoff size for small triangles with rm

get_intersect_triged(j=None, i=None, **kw)¶

Get option to use CGT triged to clean output file

Call:

>>> triged = opts.get_intersect_triged(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

triged: {True} | False: option to use CGT triged to clean output file

get_intersect_v(j=None, i=None, **kw)¶

Get verbose mode

Call:

>>> v = opts.get_intersect_v(j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

v: {False} | True: verbose mode

get_l(j=None, i=None, **kw)¶

Get max size that may be locked into memory, ulimit -l

Call:

>>> l = opts.get_l(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

l: {None} | object: max size that may be locked into memory, ulimit -l

get_locked_memory(j=None, i=None, **kw)¶

Get max size that may be locked into memory, ulimit -l

Call:

>>> locked_memory = opts.get_locked_memory(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

locked_memory: {None} | object: value of option “locked_memory”

get_m(j=None, i=None, **kw)¶

Get max resident set size, ulimit -m

Call:

>>> m = opts.get_m(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

m: {None} | object: max resident set size, ulimit -m

get_max_processes(j=None, i=None, **kw)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> max_processes = opts.get_max_processes(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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_processes: {None} | object: value of option “max_processes”

get_message_queue_size(j=None, i=None, **kw)¶

Get max bytes in POSIX message queues, ulimit -q

Call:

>>> message_queue_size = opts.get_message_queue_size(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

message_queue_size: {None} | object: value of option “message_queue_size”

get_mpi_args(j=None, i=None, **kw)¶

Get value of option “args”

Call:

>>> args = opts.get_mpi_args(j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

args: {None} | list[str]: value of option “args”

get_mpi_executable(j=None, i=None, **kw)¶

Get executable to launch MPI

Call:

>>> executable = opts.get_mpi_executable(j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

executable: {'mpiexec'} | str: executable to launch MPI

get_mpi_flags(j=None, i=None, **kw)¶

Get options to mpiexec using -flag val format

Call:

>>> flags = opts.get_mpi_flags(j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | dict: options to mpiexec using -flag val format

get_mpi_np(j=None, i=None, **kw)¶

Get explicit number of MPI processes

Call:

>>> np = opts.get_mpi_np(j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

np: {None} | int: explicit number of MPI processes

get_mpi_perhost(j=None, i=None, **kw)¶

Get value of option “perhost”

Call:

>>> perhost = opts.get_mpi_perhost(j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

perhost: {None} | int: value of option “perhost”

get_mpicmd(j=None, i=None, **kw)¶

Get MPI executable name

Call:

>>> mpicmd = opts.get_mpicmd(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:

mpicmd: 'mpiexec' | 'mpirun': MPI executable name

get_n(j=None, i=None, **kw)¶

Get max number of open files, ulimit -n

Call:

>>> n = opts.get_n(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: max number of open files, ulimit -n

get_nIter(j=None, i=None, **kw)¶

Get number of iterations to run in phase j

Call:

>>> nIter = opts.get_nIter(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:

nIter: {None} | int: number of iterations to run in phase j

get_nPBS() → int¶

Return the maximum number of unique PBS inputs

For example, if a case is set up to be run in two parts, and the first phase needs only one node (select=1) while the second phase needs 10 nodes (select=10), then the input file should have "select": [1, 10], and the output of this function will be 2.

Call:

>>> n = opts.get_nPBS()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

n: int: Number of unique PBS scripts

Versions:

2014-12-01 @ddalle: First version

get_nProc(j=None, i=None, **kw)¶

Get number of cores/threads to use per case

Call:

>>> nProc = opts.get_nProc(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:

nProc: {None} | int: number of cores/threads to use per case

get_nSeq(i=None)¶

Return the number of phases in the sequence

Call:

>>> nSeq = opts.get_nSeq(i=None)

Inputs:

opts: cape.options.Options: Options interface
i: {None} | int: Case index

Outputs:

nSeq: int: Number of input sets in the sequence

Versions:

2014-10-02 @ddalle: v1.0
2015-02-02 @ddalle: v1.1; add nPhase override
2022-10-23 @ddalle: v2.0; OptionsDict
2022-10-28 @ddalle: v2.1; add i
2023-03-10 @ddalle: v2.2; no scalar sequence check

get_nSlurm() → int¶

Return the maximum number of unique Slurm inputs

For example, if a case is set up to be run in two parts, and the first phase needs only one node (N=1) while the second phase needs 10 nodes (N=10), then the input file should have "N": [1, 10], and the output of this function will be 2.

Call:

>>> n = opts.get_nSlurm()

Inputs:

opts: cape.cfdx.options.Options: Options interface

Outputs:

n: int: Number of unique Slurm scripts

Versions:

2014-12-01 @ddalle: Version 1.0

get_open_files(j=None, i=None, **kw)¶

Get max number of open files, ulimit -n

Call:

>>> open_files = opts.get_open_files(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

open_files: {None} | object: value of option “open_files”

get_p(j=None, i=None, **kw)¶

Get pipe size in 512-byte blocks, ulimit -p

Call:

>>> p = opts.get_p(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object: pipe size in 512-byte blocks, ulimit -p

get_pending_signals(j=None, i=None, **kw)¶

Get max number of pending signals, ulimit -i

Call:

>>> pending_signals = opts.get_pending_signals(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

pending_signals: {None} | object: value of option “pending_signals”

get_pipe_size(j=None, i=None, **kw)¶

Get pipe size in 512-byte blocks, ulimit -p

Call:

>>> pipe_size = opts.get_pipe_size(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

pipe_size: {None} | object: value of option “pipe_size”

get_processes(j=None, i=None, **kw)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> processes = opts.get_processes(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

processes: {None} | object: value of option “processes”

get_q(j=None, i=None, **kw)¶

Get max bytes in POSIX message queues, ulimit -q

Call:

>>> q = opts.get_q(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {None} | object: max bytes in POSIX message queues, ulimit -q

get_qsub(j=None, i=None, **kw)¶

Get whether or not to submit jobs with PBS

Call:

>>> qsub = opts.get_qsub(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:

qsub: {False} | True: whether or not to submit jobs with PBS

get_r(j=None, i=None, **kw)¶

Get max real-time scheduling priority, ulimit -r

Call:

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

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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: {None} | object: max real-time scheduling priority, ulimit -r

get_real_time_priority(j=None, i=None, **kw)¶

Get max real-time scheduling priority, ulimit -r

Call:

>>> real_time_priority = opts.get_real_time_priority(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

real_time_priority: {None} | object: value of option “real_time_priority”

get_refcol(col: str, comp=None, j=None)¶

Get value of a dictionary option like "RefArea"

Call:

>>> vref = opts.get_refcol(col, comp=None)

Inputs:

opts: ConfigOpts: CFD component configuration option interface
col: str: Name of "Config" option
comp: {None} | str: Name of component
j: {None} | int: Phase index

Outputs:

vref: float: Reference quantity [for comp]

Versions:

2022-11-01 @ddalle: v1.0
2023-05-19 @ddalle: v1.1; mod for OptionsDict
2023-10-16 @ddalle: v1.2; add j

get_s(j=None, i=None, **kw)¶

Get stack size limit, ulimit -s

Call:

>>> s = opts.get_s(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

s: {None} | object: stack size limit, ulimit -s

get_scheduling_priority(j=None, i=None, **kw)¶

Get max scheduling priority, ulimit -e

Call:

>>> scheduling_priority = opts.get_scheduling_priority(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

scheduling_priority: {None} | object: value of option “scheduling_priority”

get_set_size(j=None, i=None, **kw)¶

Get max resident set size, ulimit -m

Call:

>>> set_size = opts.get_set_size(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

set_size: {None} | object: value of option “set_size”

get_slurm(j=None, i=None, **kw)¶

Get whether or not to submit jobs with Slurm

Call:

>>> slurm = opts.get_slurm(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:

slurm: {False} | True: whether or not to submit jobs with Slurm

get_stack_size(j=None, i=None, **kw)¶

Get stack size limit, ulimit -s

Call:

>>> stack_size = opts.get_stack_size(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

stack_size: {None} | object: value of option “stack_size”

get_t(j=None, i=None, **kw)¶

Get max amount of cpu time in s, ulimit -t

Call:

>>> t = opts.get_t(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

t: {None} | object: max amount of cpu time in s, ulimit -t

get_time_limit(j=None, i=None, **kw)¶

Get max amount of cpu time in s, ulimit -t

Call:

>>> time_limit = opts.get_time_limit(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

time_limit: {None} | object: value of option “time_limit”

get_u(j=None, i=None, **kw)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> u = opts.get_u(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

u: {None} | object: max number of procs avail to one user, ulimit -u

get_ulimit(u, j=0, i=None)¶

Get a resource limit (ulimit) setting by name

Call:

>>> l = opts.get_ulimit(u, i=0)

Inputs:

opts: cape.cfdx.options.Options: Options interface
u: str: Name of the ulimit flag
j: None | {0} | int: Phase index
i: {None} | int: Case number

Outputs:

l: int: Value of the resource limit

Versions:

2015-11-10 @ddalle: v1.0
2022-10-30 @ddalle: v2.0; use optdict

get_umask(sys=True)¶

Get the current file permissions mask

The default value is the read from the system

Call:

>>> umask = opts.get_umask(sys=True)

Inputs:

opts pyCart.options.Options: Options interface
sys: {True} | False: Whether or not to use system setting as default

Outputs:

umask: None | oct: File permissions mask (None only if sys is False)

Versions:

2015-09-27 @ddalle: Version 1.0

get_user_processes(j=None, i=None, **kw)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> user_processes = opts.get_user_processes(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

user_processes: {None} | object: value of option “user_processes”

get_v(j=None, i=None, **kw)¶

Get max virtual memory avail to shell, ulimit -v

Call:

>>> v = opts.get_v(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

v: {None} | object: max virtual memory avail to shell, ulimit -v

get_verify()¶

Return whether or not to run verify on triangulations

Call:

>>> q = opts.get_verify()

Inputs:

opts: cape.options.Options: Options interface

Outputs:

q: True | {False}: Whether or not to run verify

Versions:

2016-04-05 @ddalle: v1.0
2022-10-23 @ddalle: v1.1; use bool()

get_verify_ascii(j=None, i=None, **kw)¶

Get option for ASCII input file to verify

Call:

>>> ascii = opts.get_verify_ascii(j=None, i=None, **kw)

Inputs:

opts: VerifyOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ascii: {True} | False: option for ASCII input file to verify

get_verify_i(j=None, i=None, **kw)¶

Get input file for verify

Call:

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

Inputs:

opts: VerifyOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run 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 verify

get_virtual_memory(j=None, i=None, **kw)¶

Get max virtual memory avail to shell, ulimit -v

Call:

>>> virtual_memory = opts.get_virtual_memory(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

virtual_memory: {None} | object: value of option “virtual_memory”

get_x(j=None, i=None, **kw)¶

Get max number of file locks, ulimit -x

Call:

>>> x = opts.get_x(j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

x: {None} | object: max number of file locks, ulimit -x

init_post()¶

Initialization hook for Options

Call:

>>> opts.init_post()

Inputs:

opts: Options: Options interface

Versions:

2022-10-23 @ddalle: Version 1.0

mkdir(fdir, sys=False)¶

Make a directory with the correct permissions

Call:

>>> opts.mkdir(fdir, sys=False)

Inputs:

opts: cape.options.Options: Options interface
fdir: str: Directory to create
sys: True | {False}: Whether or not to replace None with system setting

Versions:

2015-09-27 @ddalle: Version 1.0

read_old(**kw)¶

Convert CAPE 1.x ArchiveOptions to newer standard

Call:

>>> kw_new = opts.read_old(**kw)

Inputs:

opts: ArchiveOpts: Archiving options instance
kw: dict: Options suitable for previous archiving options class

Outputs:

kw_new: dict: Filtered and mapped version of kw

Versions:

2024-09-17 @ddalle: v1.0

reset_Points()¶

Reset all points to original locations

Call:

>>> opts.reset_Points()

Inptus:

opts: cape.cfdx.options.Options: Options interface

Versions:

2016-04-18 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 1.1; deepcopy()

set_ArchiveFolder(v, j=None, mode=None)¶

Get path to the archive root

Call:

>>> opts.set_ArchiveFolder(ArchiveFolder, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

ArchiveFolder: {''} | str

path to the archive root

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_ArchiveFormat(v, j=None, mode=None)¶

Get format for case archives

Call:

>>> opts.set_ArchiveFormat(ArchiveFormat, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

ArchiveFormat: '' | 'bz2' | 'gz' | 'lzma' | {'tar'} | 'xz' | 'zip' | 'zst'

format for case archives

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_ArchiveType(v, j=None, mode=None)¶

Get flag for single (full) or multi (sub) archive files

Call:

>>> opts.set_ArchiveType(ArchiveType, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

ArchiveType: {'full'} | 'partial'

flag for single (full) or multi (sub) archive 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_BatchPBS_A(v, j=None, mode=None)¶

Get account name(s) or number(s)

Call:

>>> opts.set_BatchPBS_A(A, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

A: {None} | object

account name(s) or number(s)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_S(v, j=None, mode=None)¶

Get shell to execute PBS job

Call:

>>> opts.set_BatchPBS_S(S, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

S: {'/bin/bash'} | str

shell to execute PBS job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_W(v, j=None, mode=None)¶

Get PBS W setting, usually for setting group

Call:

>>> opts.set_BatchPBS_W(W, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

W: {''} | str

PBS W setting, usually for setting group

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_aoe(v, j=None, mode=None)¶

Get architecture operating environment

Call:

>>> opts.set_BatchPBS_aoe(aoe, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

aoe: {None} | str

architecture operating environment

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_e(v, j=None, mode=None)¶

Get explicit STDERR file name

Call:

>>> opts.set_BatchPBS_e(e, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

e: {None} | object

explicit STDERR file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_j(v, j=None, mode=None)¶

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {'oe'} | str

PBS ‘join’ setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_mem(v, j=None, mode=None)¶

Get Requested cpu memory (on gpu node)

Call:

>>> opts.set_BatchPBS_mem(mem, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

mem: {None} | int

Requested cpu memory (on gpu node)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_model(v, j=None, mode=None)¶

Get model type/architecture

Call:

>>> opts.set_BatchPBS_model(model, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

model: {None} | str

model type/architecture

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_mpiprocs(v, j=None, mode=None)¶

Get number of MPI processes per node

Call:

>>> opts.set_BatchPBS_mpiprocs(mpiprocs, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

mpiprocs: {None} | int

number of MPI processes per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_ncpus(v, j=None, mode=None)¶

Get number of cores (roughly CPUs) per node

Call:

>>> opts.set_BatchPBS_ncpus(ncpus, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

ncpus: {None} | int

number of cores (roughly CPUs) per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_ngpus(v, j=None, mode=None)¶

Get number of gpus per node

Call:

>>> opts.set_BatchPBS_ngpus(ngpus, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

ngpus: {None} | int

number of gpus per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_o(v, j=None, mode=None)¶

Get explicit STDOUT file name

Call:

>>> opts.set_BatchPBS_o(o, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

o: {None} | object

explicit STDOUT file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_ompthreads(v, j=None, mode=None)¶

Get number of OMP threads

Call:

>>> opts.set_BatchPBS_ompthreads(ompthreads, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

ompthreads: {None} | int

number of OMP threads

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_p(v, j=None, mode=None)¶

Get PBS priority

Call:

>>> opts.set_BatchPBS_p(p, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

p: {None} | object

PBS priority

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_place(v, j=None, mode=None)¶

Get Share or exclusive access to requested gpu nodes

Call:

>>> opts.set_BatchPBS_place(place, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_q(v, j=None, mode=None)¶

Get PBS queue name

Call:

>>> opts.set_BatchPBS_q(q, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

q: {'normal'} | str

PBS queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_r(v, j=None, mode=None)¶

Get rerun-able setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

r: {'n'} | 'y'

rerun-able setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_select(v, j=None, mode=None)¶

Get number of nodes

Call:

>>> opts.set_BatchPBS_select(select, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

select: {1} | int

number of nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_site_needed(v, j=None, mode=None)¶

Get list of manually requested hard drives to mount

Call:

>>> opts.set_BatchPBS_site_needed(site_needed, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

site_needed: {None} | list[str]

list of manually requested hard drives to mount

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchPBS_walltime(v, j=None, mode=None)¶

Get maximum job wall time

Call:

>>> opts.set_BatchPBS_walltime(walltime, j=None, i=None, **kw)

Inputs:

opts: BatchPBSOpts

options interface

walltime: {'8:00:00'} | str

maximum job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchShellCmds(v, j=None, mode=None)¶

Get additional shell commands for batch jobs

Call:

>>> opts.set_BatchShellCmds(BatchShellCmds, j=None, i=None, **kw)

Inputs:

opts: Options

options interface

BatchShellCmds: {None} | list[str]

additional shell commands for batch jobs

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_A(v, j=None, mode=None)¶

Get Slurm job account name

Call:

>>> opts.set_BatchSlurm_A(A, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

A: {None} | str

Slurm job account name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_C(v, j=None, mode=None)¶

Get constraint(s) on Slurm job

Call:

>>> opts.set_BatchSlurm_C(C, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

C: {None} | str

constraint(s) on Slurm job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_N(v, j=None, mode=None)¶

Get number of Slurm nodes

Call:

>>> opts.set_BatchSlurm_N(N, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

N: {1} | int

number of Slurm nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_b(v, j=None, mode=None)¶

Get constraints on when to acllocate job

Call:

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

Inputs:

opts: BatchSlurmOpts

options interface

b: {None} | object

constraints on when to acllocate job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_gid(v, j=None, mode=None)¶

Get Slurm job group ID

Call:

>>> opts.set_BatchSlurm_gid(gid, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

gid: {None} | str

Slurm job group ID

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_n(v, j=None, mode=None)¶

Get number of CPUs per node

Call:

>>> opts.set_BatchSlurm_n(n, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

n: {40} | int

number of CPUs per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_other(v, j=None, mode=None)¶

Get dict of additional Slurm options using = char

Call:

>>> opts.set_BatchSlurm_other(other, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

other: {None} | dict

dict of additional Slurm options using = char

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_p(v, j=None, mode=None)¶

Get Slurm queue name

Call:

>>> opts.set_BatchSlurm_p(p, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

p: {'normal'} | str

Slurm queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_shell(v, j=None, mode=None)¶

Get Slurm job shell name

Call:

>>> opts.set_BatchSlurm_shell(shell, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

shell: {'/bin/bash'} | str

Slurm job shell name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_BatchSlurm_time(v, j=None, mode=None)¶

Get max Slurm job wall time

Call:

>>> opts.set_BatchSlurm_time(time, j=None, i=None, **kw)

Inputs:

opts: BatchSlurmOpts

options interface

time: {'8:00:00'} | str

max Slurm job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_ConfigComponents(v, j=None, mode=None)¶

Get list of components to request from solver

Call:

>>> opts.set_ConfigComponents(Components, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

Components: {[]} | list[str]

list of components to request from solver

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_ConfigFile(v, j=None, mode=None)¶

Get configuration file name

Call:

>>> opts.set_ConfigFile(ConfigFile, j=None, i=None, **kw)

Inputs:

opts: ConfigOpts

options interface

ConfigFile: {'Config.xml'} | str

configuration file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_ContinuePhase(v, j=None, mode=None)¶

Get whether restarts of same phase can use same job

Call:

>>> opts.set_ContinuePhase(ContinuePhase, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

ContinuePhase: {None} | True | False

whether restarts of same phase can use same job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_DataBookComponents(v, j=None, mode=None)¶

Get list of databook components

Call:

>>> opts.set_DataBookComponents(Components, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

Components: {None} | str

list of databook components

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_DataBookDNStats(v, j=None, mode=None)¶

Get increment for candidate window sizes

Call:

>>> opts.set_DataBookDNStats(DNStats, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

DNStats: {None} | int

increment for candidate window sizes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_DataBookDelimiter(v, j=None, mode=None)¶

Get delimiter to use in databook files

Call:

>>> opts.set_DataBookDelimiter(Delimiter, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

Delimiter: {','} | str

delimiter to use in databook 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_DataBookFolder(v, j=None, mode=None)¶

Get folder for root of databook

Call:

>>> opts.set_DataBookFolder(Folder, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

Folder: {'data'} | str

folder for root of databook

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_DataBookNMaxStats(v, j=None, mode=None)¶

Get max number of iters to include in averaging window

Call:

>>> opts.set_DataBookNMaxStats(NMaxStats, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

NMaxStats: {None} | int

max number of iters to include in averaging window

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_DataBookNMin(v, j=None, mode=None)¶

Get first iter to consider for use in databook [for a comp]

Call:

>>> opts.set_DataBookNMin(NMin, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

NMin: {0} | int

first iter to consider for use in databook [for a comp]

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_DataBookNStats(v, j=None, mode=None)¶

Get iterations to use in averaging window [for a comp]

Call:

>>> opts.set_DataBookNStats(NStats, j=None, i=None, **kw)

Inputs:

opts: DataBookOpts

options interface

NStats: {0} | int

iterations to use in averaging window [for a comp]

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_Environ(opt, val, j=None)¶

Set an environment variable setting by name

Call:

>>> val = opts.get_Environ(opts, j=0)

Inputs:

opts: cape.options.Options: Options interface
opt: str: Name of the environment variable
val: str: Value to set the environment variable to
j: {None} | int: Phase index

Versions:

2015-11-10 @ddalle: v1.0
2022-10-29 @ddalle: v2.0; OptionsDict methods

set_GroupMesh(qGM=False)¶

Specify that groups do or do not use common meshes

Call:

>>> opts.get_GroupMesh(qGM)

Inputs:

opts pyCart.options.Options: Options interface
qGM: True | {False}: Whether cases in a group use the same (starting) mesh

Versions:

2014-10-06 @ddalle: Version 1.0
2022-10-23 @ddalle: Version 1.1; hard-code default

set_JSONFile(v, j=None, mode=None)¶

Get name of JSON file from which settings originated

Call:

>>> opts.set_JSONFile(JSONFile, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

JSONFile: {None} | str

name of JSON file from which settings originated

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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(v, j=None, mode=None)¶

Get whether or not to run MPI in phase

Call:

>>> opts.set_MPI(MPI, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

MPI: {False} | True

whether or not to run MPI 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_MeshFile(v, j=None, mode=None)¶

Get original mesh file name(s)

Call:

>>> opts.set_MeshFile(MeshFile, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

MeshFile: {None} | str

original mesh file name(s)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_NJob(v, j=None, mode=None)¶

Get number of jobs to run concurrently

Call:

>>> opts.set_NJob(NJob, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

NJob: {0} | int

number of jobs to run concurrently

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_NSubmit(v, j=None, mode=None)¶

Get maximum number of jobs to submit at one time

Call:

>>> opts.set_NSubmit(NSubmit, j=None, i=None, **kw)

Inputs:

opts: Options

options interface

NSubmit: {10} | object

maximum number of jobs to submit at one time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_A(v, j=None, mode=None)¶

Get account name(s) or number(s)

Call:

>>> opts.set_PBS_A(A, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

A: {None} | object

account name(s) or number(s)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_S(v, j=None, mode=None)¶

Get shell to execute PBS job

Call:

>>> opts.set_PBS_S(S, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

S: {'/bin/bash'} | str

shell to execute PBS job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_W(v, j=None, mode=None)¶

Get PBS W setting, usually for setting group

Call:

>>> opts.set_PBS_W(W, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

W: {''} | str

PBS W setting, usually for setting group

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_aoe(v, j=None, mode=None)¶

Get architecture operating environment

Call:

>>> opts.set_PBS_aoe(aoe, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

aoe: {None} | str

architecture operating environment

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_e(v, j=None, mode=None)¶

Get explicit STDERR file name

Call:

>>> opts.set_PBS_e(e, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

e: {None} | object

explicit STDERR file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_j(v, j=None, mode=None)¶

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {'oe'} | str

PBS ‘join’ setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_mem(v, j=None, mode=None)¶

Get Requested cpu memory (on gpu node)

Call:

>>> opts.set_PBS_mem(mem, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

mem: {None} | int

Requested cpu memory (on gpu node)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_model(v, j=None, mode=None)¶

Get model type/architecture

Call:

>>> opts.set_PBS_model(model, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

model: {None} | str

model type/architecture

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_mpiprocs(v, j=None, mode=None)¶

Get number of MPI processes per node

Call:

>>> opts.set_PBS_mpiprocs(mpiprocs, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

mpiprocs: {None} | int

number of MPI processes per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_ncpus(v, j=None, mode=None)¶

Get number of cores (roughly CPUs) per node

Call:

>>> opts.set_PBS_ncpus(ncpus, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

ncpus: {None} | int

number of cores (roughly CPUs) per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_ngpus(v, j=None, mode=None)¶

Get number of gpus per node

Call:

>>> opts.set_PBS_ngpus(ngpus, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

ngpus: {None} | int

number of gpus per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_o(v, j=None, mode=None)¶

Get explicit STDOUT file name

Call:

>>> opts.set_PBS_o(o, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

o: {None} | object

explicit STDOUT file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_ompthreads(v, j=None, mode=None)¶

Get number of OMP threads

Call:

>>> opts.set_PBS_ompthreads(ompthreads, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

ompthreads: {None} | int

number of OMP threads

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_p(v, j=None, mode=None)¶

Get PBS priority

Call:

>>> opts.set_PBS_p(p, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

p: {None} | object

PBS priority

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_place(v, j=None, mode=None)¶

Get Share or exclusive access to requested gpu nodes

Call:

>>> opts.set_PBS_place(place, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_q(v, j=None, mode=None)¶

Get PBS queue name

Call:

>>> opts.set_PBS_q(q, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

q: {'normal'} | str

PBS queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_r(v, j=None, mode=None)¶

Get rerun-able setting

Call:

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

Inputs:

opts: PBSOpts

options interface

r: {'n'} | 'y'

rerun-able setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_select(v, j=None, mode=None)¶

Get number of nodes

Call:

>>> opts.set_PBS_select(select, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

select: {1} | int

number of nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_site_needed(v, j=None, mode=None)¶

Get list of manually requested hard drives to mount

Call:

>>> opts.set_PBS_site_needed(site_needed, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

site_needed: {None} | list[str]

list of manually requested hard drives to mount

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PBS_walltime(v, j=None, mode=None)¶

Get maximum job wall time

Call:

>>> opts.set_PBS_walltime(walltime, j=None, i=None, **kw)

Inputs:

opts: PBSOpts

options interface

walltime: {'8:00:00'} | str

maximum job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:: no checks
1:: validate 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_PhaseIters(v, j=None, mode=None)¶

Get check-point iterations for phase j

Call:

>>> opts.set_PhaseIters(PhaseIters, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

PhaseIters: {None} | int

check-point iterations for phase j

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PhaseSequence(v, j=None, mode=None)¶

Get list of phase indices to run

Call:

>>> opts.set_PhaseSequence(PhaseSequence, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

PhaseSequence: {None} | int

list of phase indices to run

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Point(x, name: str)¶

Set or alter the coordinates of a point by name

Call:

>>> opts.set_Point(x, name)

Inputs:

opts: cape.cfdx.options.Options: Options interface
x: [float, float, float]: Coordinates of that point
name: str: Point name

Versions:

2015-09-11 @ddalle: Version 1.0
2022-11-01 @ddalle: Versoin 1.1; ARRAY_TYPES

set_PostPBS_A(v, j=None, mode=None)¶

Get account name(s) or number(s)

Call:

>>> opts.set_PostPBS_A(A, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

A: {None} | object

account name(s) or number(s)

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_S(v, j=None, mode=None)¶

Get shell to execute PBS job

Call:

>>> opts.set_PostPBS_S(S, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

S: {'/bin/bash'} | str

shell to execute PBS job

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_W(v, j=None, mode=None)¶

Get PBS W setting, usually for setting group

Call:

>>> opts.set_PostPBS_W(W, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

W: {''} | str

PBS W setting, usually for setting group

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_aoe(v, j=None, mode=None)¶

Get architecture operating environment

Call:

>>> opts.set_PostPBS_aoe(aoe, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

aoe: {None} | str

architecture operating environment

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_e(v, j=None, mode=None)¶

Get explicit STDERR file name

Call:

>>> opts.set_PostPBS_e(e, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

e: {None} | object

explicit STDERR file name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_j(v, j=None, mode=None)¶

Get PBS ‘join’ setting

Call:

>>> opts.set_PostPBS_j(j, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

j: {'oe'} | str

PBS ‘join’ setting

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_mem(v, j=None, mode=None)¶

Get Requested cpu memory (on gpu node)

Call:

>>> opts.set_PostPBS_mem(mem, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

mem: {None} | int

Requested cpu memory (on gpu node)

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_model(v, j=None, mode=None)¶

Get model type/architecture

Call:

>>> opts.set_PostPBS_model(model, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

model: {None} | str

model type/architecture

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_mpiprocs(v, j=None, mode=None)¶

Get number of MPI processes per node

Call:

>>> opts.set_PostPBS_mpiprocs(mpiprocs, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

mpiprocs: {None} | int

number of MPI processes per node

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_ncpus(v, j=None, mode=None)¶

Get number of cores (roughly CPUs) per node

Call:

>>> opts.set_PostPBS_ncpus(ncpus, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

ncpus: {None} | int

number of cores (roughly CPUs) per node

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_ngpus(v, j=None, mode=None)¶

Get number of gpus per node

Call:

>>> opts.set_PostPBS_ngpus(ngpus, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

ngpus: {None} | int

number of gpus per node

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_o(v, j=None, mode=None)¶

Get explicit STDOUT file name

Call:

>>> opts.set_PostPBS_o(o, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

o: {None} | object

explicit STDOUT file name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_ompthreads(v, j=None, mode=None)¶

Get number of OMP threads

Call:

>>> opts.set_PostPBS_ompthreads(ompthreads, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

ompthreads: {None} | int

number of OMP threads

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_p(v, j=None, mode=None)¶

Get PBS priority

Call:

>>> opts.set_PostPBS_p(p, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

p: {None} | object

PBS priority

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_place(v, j=None, mode=None)¶

Get Share or exclusive access to requested gpu nodes

Call:

>>> opts.set_PostPBS_place(place, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_q(v, j=None, mode=None)¶

Get PBS queue name

Call:

>>> opts.set_PostPBS_q(q, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

q: {'normal'} | str

PBS queue name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_r(v, j=None, mode=None)¶

Get rerun-able setting

Call:

>>> opts.set_PostPBS_r(r, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

r: {'n'} | 'y'

rerun-able setting

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_select(v, j=None, mode=None)¶

Get number of nodes

Call:

>>> opts.set_PostPBS_select(select, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

select: {1} | int

number of nodes

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_site_needed(v, j=None, mode=None)¶

Get list of manually requested hard drives to mount

Call:

>>> opts.set_PostPBS_site_needed(site_needed, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

site_needed: {None} | list[str]

list of manually requested hard drives to mount

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostPBS_walltime(v, j=None, mode=None)¶

Get maximum job wall time

Call:

>>> opts.set_PostPBS_walltime(walltime, j=None, i=None, **kw)

Inputs:

opts: PostPBSOpts

options interface

walltime: {'8:00:00'} | str

maximum job wall time

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostShellCmds(v, j=None, mode=None)¶

Get list of commands to run after each cycle

Call:

>>> opts.set_PostShellCmds(PostShellCmds, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

PostShellCmds: {None} | list[str]

list of commands to run after each cycle

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_A(v, j=None, mode=None)¶

Get Slurm job account name

Call:

>>> opts.set_PostSlurm_A(A, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

A: {None} | str

Slurm job account name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_C(v, j=None, mode=None)¶

Get constraint(s) on Slurm job

Call:

>>> opts.set_PostSlurm_C(C, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

C: {None} | str

constraint(s) on Slurm job

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_N(v, j=None, mode=None)¶

Get number of Slurm nodes

Call:

>>> opts.set_PostSlurm_N(N, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

N: {1} | int

number of Slurm nodes

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_b(v, j=None, mode=None)¶

Get constraints on when to acllocate job

Call:

>>> opts.set_PostSlurm_b(b, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

b: {None} | object

constraints on when to acllocate job

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_gid(v, j=None, mode=None)¶

Get Slurm job group ID

Call:

>>> opts.set_PostSlurm_gid(gid, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

gid: {None} | str

Slurm job group ID

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_n(v, j=None, mode=None)¶

Get number of CPUs per node

Call:

>>> opts.set_PostSlurm_n(n, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

n: {40} | int

number of CPUs per node

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_other(v, j=None, mode=None)¶

Get dict of additional Slurm options using = char

Call:

>>> opts.set_PostSlurm_other(other, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

other: {None} | dict

dict of additional Slurm options using = char

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_p(v, j=None, mode=None)¶

Get Slurm queue name

Call:

>>> opts.set_PostSlurm_p(p, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

p: {'normal'} | str

Slurm queue name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_shell(v, j=None, mode=None)¶

Get Slurm job shell name

Call:

>>> opts.set_PostSlurm_shell(shell, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

shell: {'/bin/bash'} | str

Slurm job shell name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PostSlurm_time(v, j=None, mode=None)¶

Get max Slurm job wall time

Call:

>>> opts.set_PostSlurm_time(time, j=None, i=None, **kw)

Inputs:

opts: PostSlurmOpts

options interface

time: {'8:00:00'} | str

max Slurm job wall time

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PreMesh(v, j=None, mode=None)¶

Get whether or not to generate volume mesh before submitting

Call:

>>> opts.set_PreMesh(PreMesh, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

PreMesh: {False} | True

whether or not to generate volume mesh before submitting

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_PythonExec(v, j=None, mode=None)¶

Get specific Python executable to use for jobs

Call:

>>> opts.set_PythonExec(PythonExec, j=None, i=None, **kw)

Inputs:

opts: Options

options interface

PythonExec: {None} | str

specific Python executable to use for jobs

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RefArea(Aref, comp=None)¶

Set the reference area [of a component]

Call:

>>> opts.set_RefArea(Aref)
>>> opts.set_RefArea(Aref, comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
Aref: float: Reference area [for comp]
comp: {None} | str: Name of component

Versions:

2014-09-29 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 2.0; set_refcol()

set_RefLength(Lref, comp=None)¶

Set the reference length [of a component]

Call:

>>> opts.set_RefLength(Lref)
>>> opts.set_RefLength(Lref, comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
Lref: float: Reference length [of comp]
comp: {None} | str: Name of component

Versions:

2014-09-29 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 2.0; set_refcol()

set_RefPoint(x, comp=None)¶

Set the moment reference point [for a component]

Call:

>>> opts.set_RefPoint(x)
>>> opts.set_RefPoint(x, comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
x: [float, float, float]: Global moment reference point or that for a component
comp: str or int: Name of component or component index

Versions:

2014-09-29 @ddalle: Version 1.0
2022-11-01 @ddalle: Version 2.0; set_refcol()

set_RefSpan(bref, comp=None)¶

Set the reference span [for a component]

Call:

>>> opts.set_RefSpan(bref)
>>> opts.set_RefSpan(bref, comp=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
bref: float: Reference span [for comp]
comp: {None} | str: Name of component

Versions:

2017-02-19 @ddalle: Copied from set_RefLength()
2022-11-01 @ddalle: Version 2.0; set_refcol()

set_RestartSamePhase(v, j=None, mode=None)¶

Get whether to restart same phase if needed

Call:

>>> opts.set_RestartSamePhase(RestartSamePhase, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

RestartSamePhase: {True} | False

whether to restart same phase if needed

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_ResubmitNextPhase(v, j=None, mode=None)¶

Get whether new job submits at end of phase

Call:

>>> opts.set_ResubmitNextPhase(ResubmitNextPhase, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

ResubmitNextPhase: {False} | True

whether new job submits at end of phase

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_ResubmitSamePhase(v, j=None, mode=None)¶

Get whether same-phase repeats need new job

Call:

>>> opts.set_ResubmitSamePhase(ResubmitSamePhase, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

ResubmitSamePhase: {False} | True

whether same-phase repeats need new job

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RootDir(v, j=None, mode=None)¶

Get (absolute) base folder from which CAPE settings were read

Call:

>>> opts.set_RootDir(RootDir, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

RootDir: {None} | str

(absolute) base folder from which CAPE settings were read

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunControlOpt(opt: str, val, j=None, **kw)¶

Get a general option from the “RunControl” section

Call:

>>> opts.set_RunControlOpt(opt, val, j=None, **kw)

Inputs:

opts: Options: Options interface
opt: str: Name of option to get or sample
v: object: Value to set in opts[opt]
j: {None} | int: Phase index

Versions:

2023-07-17 @ddalle: v1.0

set_RunMatrixDefinitions(v, j=None, mode=None)¶

Get definitions for each run matrix variable

Call:

>>> opts.set_RunMatrixDefinitions(Definitions, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

Definitions: {None} | dict

definitions for each run matrix variable

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunMatrixFile(v, j=None, mode=None)¶

Get run matrix data file name

Call:

>>> opts.set_RunMatrixFile(File, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

File: {None} | str

run matrix data file name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunMatrixFreestream(v, j=None, mode=None)¶

Get properties of freestream gas model

Call:

>>> opts.set_RunMatrixFreestream(Freestream, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

Freestream: {{}} | dict

properties of freestream gas model

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunMatrixGroupMesh(v, j=None, mode=None)¶

Get value of option “GroupMesh”

Call:

>>> opts.set_RunMatrixGroupMesh(GroupMesh, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

GroupMesh: {False} | True

value of option “GroupMesh”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunMatrixGroupPrefix(v, j=None, mode=None)¶

Get default prefix for group folders

Call:

>>> opts.set_RunMatrixGroupPrefix(GroupPrefix, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

GroupPrefix: {'Grid'} | str

default prefix for group 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_RunMatrixKeys(v, j=None, mode=None)¶

Get list of run matrix variables

Call:

>>> opts.set_RunMatrixKeys(Keys, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

Keys: {['mach', 'alpha', 'beta']} | list[str]

list of run matrix variables

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunMatrixMaxJobNameLength(v, j=None, mode=None)¶

Get maximum length of PBS/Slurm job name

Call:

>>> opts.set_RunMatrixMaxJobNameLength(MaxJobNameLength, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

MaxJobNameLength: {32} | int

maximum length of PBS/Slurm job name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_RunMatrixPrefix(v, j=None, mode=None)¶

Get default prefix for case folders

Call:

>>> opts.set_RunMatrixPrefix(Prefix, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

Prefix: {''} | str

default prefix for case 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_RunMatrixValues(v, j=None, mode=None)¶

Get value of option “Values”

Call:

>>> opts.set_RunMatrixValues(Values, j=None, i=None, **kw)

Inputs:

opts: RunMatrixOpts

options interface

Values: {{}} | dict

value of option “Values”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_SearchMethod(v, j=None, mode=None)¶

Get method for declaring multiple files with one string

Call:

>>> opts.set_SearchMethod(SearchMethod, j=None, i=None, **kw)

Inputs:

opts: ArchiveOpts

options interface

SearchMethod: {'glob'} | 'regex'

method for declaring multiple files with one string

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_ShellCmds(cmds)¶

Set shell commands

Call:

>>> opts.set_ChellCmds(cmds=[])

Inputs:

opts: pyCart.options.Options: Options interface
cmds: list[str]: List of initialization commands

Versions:

2015-11-08 @ddalle: Version 1.0

set_Slurm_A(v, j=None, mode=None)¶

Get Slurm job account name

Call:

>>> opts.set_Slurm_A(A, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

A: {None} | str

Slurm job account name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_C(v, j=None, mode=None)¶

Get constraint(s) on Slurm job

Call:

>>> opts.set_Slurm_C(C, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

C: {None} | str

constraint(s) on Slurm job

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_N(v, j=None, mode=None)¶

Get number of Slurm nodes

Call:

>>> opts.set_Slurm_N(N, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

N: {1} | int

number of Slurm nodes

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_b(v, j=None, mode=None)¶

Get constraints on when to acllocate job

Call:

>>> opts.set_Slurm_b(b, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

b: {None} | object

constraints on when to acllocate job

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_gid(v, j=None, mode=None)¶

Get Slurm job group ID

Call:

>>> opts.set_Slurm_gid(gid, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

gid: {None} | str

Slurm job group ID

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_n(v, j=None, mode=None)¶

Get number of CPUs per node

Call:

>>> opts.set_Slurm_n(n, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

n: {40} | int

number of CPUs per node

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_other(v, j=None, mode=None)¶

Get dict of additional Slurm options using = char

Call:

>>> opts.set_Slurm_other(other, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

other: {None} | dict

dict of additional Slurm options using = char

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_p(v, j=None, mode=None)¶

Get Slurm queue name

Call:

>>> opts.set_Slurm_p(p, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

p: {'normal'} | str

Slurm queue name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_shell(v, j=None, mode=None)¶

Get Slurm job shell name

Call:

>>> opts.set_Slurm_shell(shell, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

shell: {'/bin/bash'} | str

Slurm job shell name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Slurm_time(v, j=None, mode=None)¶

Get max Slurm job wall time

Call:

>>> opts.set_Slurm_time(time, j=None, i=None, **kw)

Inputs:

opts: SlurmOpts

options interface

time: {'8:00:00'} | str

max Slurm job wall time

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_StartNextPhase(v, j=None, mode=None)¶

Get whether to start next phase or stop CAPE

Call:

>>> opts.set_StartNextPhase(StartNextPhase, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

StartNextPhase: {True} | False

whether to start next phase or stop CAPE

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_TriFile(v, j=None, mode=None)¶

Get original surface triangulation file(s)

Call:

>>> opts.set_TriFile(TriFile, j=None, i=None, **kw)

Inputs:

opts: MeshOpts

options interface

TriFile: {None} | str

original surface triangulation file(s)

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_Verbose(v, j=None, mode=None)¶

Get “RunControl” verbosity flag

Call:

>>> opts.set_Verbose(Verbose, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

Verbose: {False} | True

“RunControl” verbosity 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_WarmStart(v, j=None, mode=None)¶

Get whether to warm start a case

Call:

>>> opts.set_WarmStart(WarmStart, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

WarmStart: {False} | True

whether to warm start a case

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_WarmStartFolder(v, j=None, mode=None)¶

Get folder from which to get warm-start file

Call:

>>> opts.set_WarmStartFolder(WarmStartFolder, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

WarmStartFolder: {None} | str

folder from which to get warm-start 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_WarmStartPhase(v, j=None, mode=None)¶

Get phase from which to warm-start a case

Call:

>>> opts.set_WarmStartPhase(WarmStartPhase, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

WarmStartPhase: {None} | int

phase from which to warm-start a case

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_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

set_c(v, j=None, mode=None)¶

Get core file size limit, ulimit -c

Call:

>>> opts.set_c(c, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

c: {None} | object

core file size limit, ulimit -c

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_core_file_size(v, j=None, mode=None)¶

Get core file size limit, ulimit -c

Call:

>>> opts.set_core_file_size(core_file_size, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

core_file_size: {None} | object

value of option “core_file_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_d(v, j=None, mode=None)¶

Get process data segment limit, ulimit -d

Call:

>>> opts.set_d(d, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

d: {None} | object

process data segment limit, ulimit -d

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_data_segment(v, j=None, mode=None)¶

Get process data segment limit, ulimit -d

Call:

>>> opts.set_data_segment(data_segment, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

data_segment: {None} | object

value of option “data_segment”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_e(v, j=None, mode=None)¶

Get max scheduling priority, ulimit -e

Call:

>>> opts.set_e(e, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

e: {None} | object

max scheduling priority, ulimit -e

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_f(v, j=None, mode=None)¶

Get max size of files written by shell, ulimit -f

Call:

>>> opts.set_f(f, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

f: {None} | object

max size of files written by shell, ulimit -f

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_file_locks(v, j=None, mode=None)¶

Get max number of file locks, ulimit -x

Call:

>>> opts.set_file_locks(file_locks, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

file_locks: {None} | object

value of option “file_locks”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_file_size(v, j=None, mode=None)¶

Get max size of files written by shell, ulimit -f

Call:

>>> opts.set_file_size(file_size, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

file_size: {None} | object

value of option “file_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_i(v, j=None, mode=None)¶

Get max number of pending signals, ulimit -i

Call:

>>> opts.set_i(i, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

i: {None} | object

max number of pending signals, ulimit -i

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_T(v, j=None, mode=None)¶

Get option to also write Tecplot file Components.i.plt

Call:

>>> opts.set_intersect_T(T, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

T: {False} | True

option to also write Tecplot file Components.i.plt

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_ascii(v, j=None, mode=None)¶

Get flag that input file is ASCII

Call:

>>> opts.set_intersect_ascii(ascii, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

ascii: {None} | True | False

flag that input file is ASCII

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_cutout(v, j=None, mode=None)¶

Get number of component to subtract

Call:

>>> opts.set_intersect_cutout(cutout, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

cutout: {None} | int

number of component to subtract

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_fast(v, j=None, mode=None)¶

Get also write unformatted FAST file Components.i.fast

Call:

>>> opts.set_intersect_fast(fast, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

fast: {False} | True

also write unformatted FAST file Components.i.fast

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_i(v, j=None, mode=None)¶

Get input file to intersect

Call:

>>> opts.set_intersect_i(i, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

i: {'Components.tri'} | str

input file to intersect

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_intersections(v, j=None, mode=None)¶

Get option to write intersections to intersect.dat

Call:

>>> opts.set_intersect_intersections(intersections, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

intersections: {False} | True

option to write intersections to intersect.dat

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_o(v, j=None, mode=None)¶

Get output file for intersect

Call:

>>> opts.set_intersect_o(o, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

o: {'Components.i.tri'} | str

output file for intersect

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_overlap(v, j=None, mode=None)¶

Get perform boolean intersection of this comp number

Call:

>>> opts.set_intersect_overlap(overlap, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

overlap: {None} | int

perform boolean intersection of this comp number

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_rm(v, j=None, mode=None)¶

Get option to remove small triangles from results

Call:

>>> opts.set_intersect_rm(rm, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

rm: {False} | True

option to remove small triangles from results

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_smalltri(v, j=None, mode=None)¶

Get cutoff size for small triangles with rm

Call:

>>> opts.set_intersect_smalltri(smalltri, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

smalltri: {0.0001} | float

cutoff size for small triangles with rm

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_intersect_triged(v, j=None, mode=None)¶

Get option to use CGT triged to clean output file

Call:

>>> opts.set_intersect_triged(triged, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

triged: {True} | False

option to use CGT triged to clean output 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_intersect_v(v, j=None, mode=None)¶

Get verbose mode

Call:

>>> opts.set_intersect_v(v, j=None, i=None, **kw)

Inputs:

opts: IntersectOpts

options interface

v: {False} | True

verbose 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_l(v, j=None, mode=None)¶

Get max size that may be locked into memory, ulimit -l

Call:

>>> opts.set_l(l, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

l: {None} | object

max size that may be locked into memory, ulimit -l

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_locked_memory(v, j=None, mode=None)¶

Get max size that may be locked into memory, ulimit -l

Call:

>>> opts.set_locked_memory(locked_memory, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

locked_memory: {None} | object

value of option “locked_memory”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_m(v, j=None, mode=None)¶

Get max resident set size, ulimit -m

Call:

>>> opts.set_m(m, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

m: {None} | object

max resident set size, ulimit -m

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_processes(v, j=None, mode=None)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> opts.set_max_processes(max_processes, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

max_processes: {None} | object

value of option “max_processes”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_message_queue_size(v, j=None, mode=None)¶

Get max bytes in POSIX message queues, ulimit -q

Call:

>>> opts.set_message_queue_size(message_queue_size, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

message_queue_size: {None} | object

value of option “message_queue_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_mpi_args(v, j=None, mode=None)¶

Get value of option “args”

Call:

>>> opts.set_mpi_args(args, j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

args: {None} | list[str]

value of option “args”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_executable(v, j=None, mode=None)¶

Get executable to launch MPI

Call:

>>> opts.set_mpi_executable(executable, j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

executable: {'mpiexec'} | str

executable to launch MPI

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_flags(v, j=None, mode=None)¶

Get options to mpiexec using -flag val format

Call:

>>> opts.set_mpi_flags(flags, j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

flags: {None} | dict

options to mpiexec 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_mpi_np(v, j=None, mode=None)¶

Get explicit number of MPI processes

Call:

>>> opts.set_mpi_np(np, j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

np: {None} | int

explicit number of MPI processes

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_perhost(v, j=None, mode=None)¶

Get value of option “perhost”

Call:

>>> opts.set_mpi_perhost(perhost, j=None, i=None, **kw)

Inputs:

opts: MPIOpts

options interface

perhost: {None} | int

value of option “perhost”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_mpicmd(v, j=None, mode=None)¶

Get MPI executable name

Call:

>>> opts.set_mpicmd(mpicmd, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

mpicmd: 'mpiexec' | 'mpirun'

MPI executable name

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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(v, j=None, mode=None)¶

Get max number of open files, ulimit -n

Call:

>>> opts.set_n(n, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

n: {None} | object

max number of open files, ulimit -n

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_nIter(v, j=None, mode=None)¶

Get number of iterations to run in phase j

Call:

>>> opts.set_nIter(nIter, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

nIter: {None} | int

number of iterations to run in phase j

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_nProc(v, j=None, mode=None)¶

Get number of cores/threads to use per case

Call:

>>> opts.set_nProc(nProc, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

nProc: {None} | int

number of cores/threads to use per case

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_open_files(v, j=None, mode=None)¶

Get max number of open files, ulimit -n

Call:

>>> opts.set_open_files(open_files, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

open_files: {None} | object

value of option “open_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_p(v, j=None, mode=None)¶

Get pipe size in 512-byte blocks, ulimit -p

Call:

>>> opts.set_p(p, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

p: {None} | object

pipe size in 512-byte blocks, ulimit -p

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_pending_signals(v, j=None, mode=None)¶

Get max number of pending signals, ulimit -i

Call:

>>> opts.set_pending_signals(pending_signals, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

pending_signals: {None} | object

value of option “pending_signals”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_pipe_size(v, j=None, mode=None)¶

Get pipe size in 512-byte blocks, ulimit -p

Call:

>>> opts.set_pipe_size(pipe_size, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

pipe_size: {None} | object

value of option “pipe_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_processes(v, j=None, mode=None)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> opts.set_processes(processes, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

processes: {None} | object

value of option “processes”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_q(v, j=None, mode=None)¶

Get max bytes in POSIX message queues, ulimit -q

Call:

>>> opts.set_q(q, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

q: {None} | object

max bytes in POSIX message queues, ulimit -q

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_qsub(v, j=None, mode=None)¶

Get whether or not to submit jobs with PBS

Call:

>>> opts.set_qsub(qsub, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

qsub: {False} | True

whether or not to submit jobs with PBS

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_r(v, j=None, mode=None)¶

Get max real-time scheduling priority, ulimit -r

Call:

>>> opts.set_r(r, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

r: {None} | object

max real-time scheduling priority, ulimit -r

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_real_time_priority(v, j=None, mode=None)¶

Get max real-time scheduling priority, ulimit -r

Call:

>>> opts.set_real_time_priority(real_time_priority, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

real_time_priority: {None} | object

value of option “real_time_priority”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_refcol(col, v, comp=None)¶

Set value of a dictionary option like "RefArea"

Call:

>>> opts.set_refcol(col, v, comp=None)

Inputs:

opts: ConfigOpts: CFD component configuration option interface
col: str: Name of "Config" option
v: object: Reference quantity [for comp]
comp: {None} | str: Name of component

Versions:

2022-11-01 @ddalle: Version 1.0

set_s(v, j=None, mode=None)¶

Get stack size limit, ulimit -s

Call:

>>> opts.set_s(s, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

s: {None} | object

stack size limit, ulimit -s

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_scheduling_priority(v, j=None, mode=None)¶

Get max scheduling priority, ulimit -e

Call:

>>> opts.set_scheduling_priority(scheduling_priority, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

scheduling_priority: {None} | object

value of option “scheduling_priority”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_set_size(v, j=None, mode=None)¶

Get max resident set size, ulimit -m

Call:

>>> opts.set_set_size(set_size, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

set_size: {None} | object

value of option “set_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_slurm(v, j=None, mode=None)¶

Get whether or not to submit jobs with Slurm

Call:

>>> opts.set_slurm(slurm, j=None, i=None, **kw)

Inputs:

opts: RunControlOpts

options interface

slurm: {False} | True

whether or not to submit jobs with Slurm

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_stack_size(v, j=None, mode=None)¶

Get stack size limit, ulimit -s

Call:

>>> opts.set_stack_size(stack_size, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

stack_size: {None} | object

value of option “stack_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_t(v, j=None, mode=None)¶

Get max amount of cpu time in s, ulimit -t

Call:

>>> opts.set_t(t, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

t: {None} | object

max amount of cpu time in s, ulimit -t

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_time_limit(v, j=None, mode=None)¶

Get max amount of cpu time in s, ulimit -t

Call:

>>> opts.set_time_limit(time_limit, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

time_limit: {None} | object

value of option “time_limit”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_u(v, j=None, mode=None)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> opts.set_u(u, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

u: {None} | object

max number of procs avail to one user, ulimit -u

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_ulimit(u, l=None, j=None)¶

Set a resource limit (ulimit) by name and value

Call:

>>> opts.set_ulimit(u, l=None, i=None)

Inputs:

opts: cape.cfdx.options.Options: Options interface
u: str: Name of the ulimit flag
l: int: Value of the limit
j: {None} | int: Phase index

Versions:

2015-11-10 @ddalle: v1.0
2022-10-30 @ddalle: v2.0; use optdict
2023-03-10 @ddalle: v2.1; remove i input

set_user_processes(v, j=None, mode=None)¶

Get max number of procs avail to one user, ulimit -u

Call:

>>> opts.set_user_processes(user_processes, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

user_processes: {None} | object

value of option “user_processes”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_v(v, j=None, mode=None)¶

Get max virtual memory avail to shell, ulimit -v

Call:

>>> opts.set_v(v, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

v: {None} | object

max virtual memory avail to shell, ulimit -v

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_verify_ascii(v, j=None, mode=None)¶

Get option for ASCII input file to verify

Call:

>>> opts.set_verify_ascii(ascii, j=None, i=None, **kw)

Inputs:

opts: VerifyOpts

options interface

ascii: {True} | False

option for ASCII input file to verify

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_verify_i(v, j=None, mode=None)¶

Get input file for verify

Call:

>>> opts.set_verify_i(i, j=None, i=None, **kw)

Inputs:

opts: VerifyOpts

options interface

i: {None} | str

input file for verify

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_virtual_memory(v, j=None, mode=None)¶

Get max virtual memory avail to shell, ulimit -v

Call:

>>> opts.set_virtual_memory(virtual_memory, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

virtual_memory: {None} | object

value of option “virtual_memory”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate 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_x(v, j=None, mode=None)¶

Get max number of file locks, ulimit -x

Call:

>>> opts.set_x(x, j=None, i=None, **kw)

Inputs:

opts: ULimitOpts

options interface

x: {None} | object

max number of file locks, ulimit -x

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:: no checks
1:: validate silently
2:: validate and show warnings
3:: raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

validate_DataBookType(typ: str)¶

Ensure that typ is a recognized DataBook Type

Call:

>>> opts.validate_DataBookType(typ)

Inputs:

opts: cape.cfdx.options.Options: Options interface
typ: "FM" | str: Target value for "Type" of matching components

Raises:

ValueError

Versions:

2023-03-09 @ddalle: v1.0

`cape.cfdx.options`: Options package¶

`cape.cfdx.options`: CAPE options interface module¶

Table of Contents

Previous topic

Next topic

This Page

cape.cfdx.options: Options package¶

cape.cfdx.options: CAPE options interface module¶

`cape.cfdx.options`: Options package¶

`cape.cfdx.options`: CAPE options interface module¶