cape.cfdx.options.rctlopts: Primary case control options

This module provides a class RunControlOpts that defines a CAPE job’s basic phasing and submittal settings. For example, it contains settings for whether a case is submitted as a PBS job, Slurm job, or run in the current shell.

It contains the critical options PhaseSequence and PhaseIters, which define the number of times number of iterations for each phase for which the CFD solver will be run.

This portion of the settings interface also includes command-line options for the various executables that are used in the execution sequence. It specifies command-line options to grid generation tools like aflr3 or other preprocessing tools like intersect. The solver-specific subclasses of RunControlOpts also contain the command-line options to solver commands such as flowCart for Cart3D.

class cape.cfdx.options.runctlopts.RunControlOpts(*args, **kw)

Dictionary-based interface for generic code run control

Call:

>>> opts = RunControlOpts(**kw)

Inputs:

kw: dict

Dictionary of run control options

Outputs:

opts: RunControlOpts

Basic control options interface

Versions:

• 2014-12-01 @ddalle: v1.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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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()

Custom function to run at end of __init__()

This function can be used on subclasses of OptionsDict to do extra special initiation without needing to rewrite the instantiation function.

The OptionsDict.init_post() function performs no actions, but a subclass can redefine this function to do custom tasks for every new instance of that class.

Call:

>>> opts.init_post()

Inputs:

opts: OptionsDict

Options interface

Versions:

• 2022-10-04 @ddalle: v1.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

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