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.EnvironOpts(*args, **kw)

Class for environment variables

Call:

>>> opts = EnvironOpts(**kw)

Inputs:

kw: dict

Dictionary of environment variables

Outputs:

opts: cape.options.runControl.Environ

System environment variable options interface

Versions:

• 2015-11-10 @ddalle: v1.0 (Environ)

• 2022-10-28 @ddalle: v2.0; OptionsDict

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

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

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

add_ArchiveArchiveFiles(val, **kw)

Get files to copy to archive

Call:

>>> opts.add_ArchiveArchiveFiles(ArchiveFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

ArchiveFiles: {[]} | object

files to copy to archive

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePostDeleteDirs(val, **kw)

Get list of folders to delete after archiving

Call:

>>> opts.add_ArchivePostDeleteDirs(PostDeleteDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

PostDeleteDirs: {[]} | object

list of folders to delete after archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePostDeleteFiles(val, **kw)

Get list of files to delete after archiving

Call:

>>> opts.add_ArchivePostDeleteFiles(PostDeleteFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

PostDeleteFiles: {[]} | object

list of files to delete after archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePostTarDirs(val, **kw)

Get folders to tar after archiving

Call:

>>> opts.add_ArchivePostTarDirs(PostTarDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

PostTarDirs: {[]} | object

folders to tar after archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePostTarGroups(val, **kw)

Get groups of files to tar after archiving

Call:

>>> opts.add_ArchivePostTarGroups(PostTarGroups, **kw)

Inputs:

opts: ArchiveOpts

options interface

PostTarGroups: {[]} | object

groups of files to tar after archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePostUpdateFiles(val, **kw)

Get globs: keep n and rm older, after archiving

Call:

>>> opts.add_ArchivePostUpdateFiles(PostUpdateFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

PostUpdateFiles: {[]} | object

globs: keep n and rm older, after archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePreDeleteDirs(val, **kw)

Get folders to delete before archiving

Call:

>>> opts.add_ArchivePreDeleteDirs(PreDeleteDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

PreDeleteDirs: {[]} | object

folders to delete before archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePreDeleteFiles(val, **kw)

Get files to delete before archiving

Call:

>>> opts.add_ArchivePreDeleteFiles(PreDeleteFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

PreDeleteFiles: {[]} | object

files to delete before archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePreTarDirs(val, **kw)

Get folders to tar before archiving

Call:

>>> opts.add_ArchivePreTarDirs(PreTarDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

PreTarDirs: {[]} | object

folders to tar before archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePreTarGroups(val, **kw)

Get file groups to tar before archiving

Call:

>>> opts.add_ArchivePreTarGroups(PreTarGroups, **kw)

Inputs:

opts: ArchiveOpts

options interface

PreTarGroups: {[]} | object

file groups to tar before archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchivePreUpdateFiles(val, **kw)

Get files to keep n and delete older, b4 archiving

Call:

>>> opts.add_ArchivePreUpdateFiles(PreUpdateFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

PreUpdateFiles: {[]} | object

files to keep n and delete older, b4 archiving

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveProgressArchiveFiles(val, **kw)

Get files to archive at any time

Call:

>>> opts.add_ArchiveProgressArchiveFiles(ProgressArchiveFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

ProgressArchiveFiles: {[]} | object

files to archive at any time

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveProgressDeleteDirs(val, **kw)

Get folders to delete while still running

Call:

>>> opts.add_ArchiveProgressDeleteDirs(ProgressDeleteDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

ProgressDeleteDirs: {[]} | object

folders to delete while still running

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveProgressDeleteFiles(val, **kw)

Get files to delete while still running

Call:

>>> opts.add_ArchiveProgressDeleteFiles(ProgressDeleteFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

ProgressDeleteFiles: {[]} | object

files to delete while still running

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveProgressTarDirs(val, **kw)

Get folders to tar while running

Call:

>>> opts.add_ArchiveProgressTarDirs(ProgressTarDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

ProgressTarDirs: {[]} | object

folders to tar while running

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveProgressTarGroups(val, **kw)

Get list of file groups to tar while running

Call:

>>> opts.add_ArchiveProgressTarGroups(ProgressTarGroups, **kw)

Inputs:

opts: ArchiveOpts

options interface

ProgressTarGroups: {[]} | object

list of file groups to tar while running

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveProgressUpdateFiles(val, **kw)

Get files to delete old versions while running

Call:

>>> opts.add_ArchiveProgressUpdateFiles(ProgressUpdateFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

ProgressUpdateFiles: {[]} | object

files to delete old versions while running

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveSkeletonDirs(val, **kw)

Get folders to keep during skeleton action

Call:

>>> opts.add_ArchiveSkeletonDirs(SkeletonDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

SkeletonDirs: {None} | object

folders to keep during skeleton action

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveSkeletonFiles(val, **kw)

Get files to keep during skeleton action

Call:

>>> opts.add_ArchiveSkeletonFiles(SkeletonFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

SkeletonFiles: {'case.json'} | object

files to keep during skeleton action

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveSkeletonTailFiles(val, **kw)

Get files to tail before deletion during skeleton

Call:

>>> opts.add_ArchiveSkeletonTailFiles(SkeletonTailFiles, **kw)

Inputs:

opts: ArchiveOpts

options interface

SkeletonTailFiles: {[]} | object

files to tail before deletion during skeleton

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

add_ArchiveSkeletonTarDirs(val, **kw)

Get folders to tar before deletion during skeleton

Call:

>>> opts.add_ArchiveSkeletonTarDirs(SkeletonTarDirs, **kw)

Inputs:

opts: ArchiveOpts

options interface

SkeletonTarDirs: {[]} | object

folders to tar before deletion during skeleton

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Get action to take after finishing a case

Call:

>>> ArchiveAction = opts.get_ArchiveAction(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:

ArchiveAction: '' | {'archive'} | 'rm' | 'skeleton'

action to take after finishing a case

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

Get files to copy to archive

Call:

>>> ArchiveFiles = opts.get_ArchiveArchiveFiles(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:

ArchiveFiles: {[]} | object

files to copy to archive

get_ArchiveCmd()

Get archiving command

Call:

>>> cmd = opts.get_ArchiveCmd()

Inputs:

opts: cape.options.Options

Options interface

Outputs:

cmd: list[str]

Tar command and appropriate flags

Versions:

• 2016-03-01 @ddalle: Version 1.0

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

Get archive file extension

Call:

>>> ArchiveExtension = opts.get_ArchiveExtension(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:

ArchiveExtension: 'bz2' | {'tar'} | 'tgz' | 'zip'

archive file extension

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' | {'tar'} | 'tgz' | 'zip'

format for case archives

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

Get list of folders to delete after archiving

Call:

>>> PostDeleteDirs = opts.get_ArchivePostDeleteDirs(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:

PostDeleteDirs: {[]} | object

list of folders to delete after archiving

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

Get list of files to delete after archiving

Call:

>>> PostDeleteFiles = opts.get_ArchivePostDeleteFiles(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:

PostDeleteFiles: {[]} | object

list of files to delete after archiving

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

Get folders to tar after archiving

Call:

>>> PostTarDirs = opts.get_ArchivePostTarDirs(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:

PostTarDirs: {[]} | object

folders to tar after archiving

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

Get groups of files to tar after archiving

Call:

>>> PostTarGroups = opts.get_ArchivePostTarGroups(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:

PostTarGroups: {[]} | object

groups of files to tar after archiving

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

Get globs: keep n and rm older, after archiving

Call:

>>> PostUpdateFiles = opts.get_ArchivePostUpdateFiles(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:

PostUpdateFiles: {[]} | object

globs: keep n and rm older, after archiving

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

Get folders to delete before archiving

Call:

>>> PreDeleteDirs = opts.get_ArchivePreDeleteDirs(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:

PreDeleteDirs: {[]} | object

folders to delete before archiving

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

Get files to delete before archiving

Call:

>>> PreDeleteFiles = opts.get_ArchivePreDeleteFiles(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:

PreDeleteFiles: {[]} | object

files to delete before archiving

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

Get folders to tar before archiving

Call:

>>> PreTarDirs = opts.get_ArchivePreTarDirs(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:

PreTarDirs: {[]} | object

folders to tar before archiving

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

Get file groups to tar before archiving

Call:

>>> PreTarGroups = opts.get_ArchivePreTarGroups(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:

PreTarGroups: {[]} | object

file groups to tar before archiving

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

Get files to keep n and delete older, b4 archiving

Call:

>>> PreUpdateFiles = opts.get_ArchivePreUpdateFiles(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:

PreUpdateFiles: {[]} | object

files to keep n and delete older, b4 archiving

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

Get files to archive at any time

Call:

>>> ProgressArchiveFiles = opts.get_ArchiveProgressArchiveFiles(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:

ProgressArchiveFiles: {[]} | object

files to archive at any time

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

Get folders to delete while still running

Call:

>>> ProgressDeleteDirs = opts.get_ArchiveProgressDeleteDirs(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:

ProgressDeleteDirs: {[]} | object

folders to delete while still running

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

Get files to delete while still running

Call:

>>> ProgressDeleteFiles = opts.get_ArchiveProgressDeleteFiles(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:

ProgressDeleteFiles: {[]} | object

files to delete while still running

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

Get folders to tar while running

Call:

>>> ProgressTarDirs = opts.get_ArchiveProgressTarDirs(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:

ProgressTarDirs: {[]} | object

folders to tar while running

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

Get list of file groups to tar while running

Call:

>>> ProgressTarGroups = opts.get_ArchiveProgressTarGroups(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:

ProgressTarGroups: {[]} | object

list of file groups to tar while running

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

Get files to delete old versions while running

Call:

>>> ProgressUpdateFiles = opts.get_ArchiveProgressUpdateFiles(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:

ProgressUpdateFiles: {[]} | object

files to delete old versions while running

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

Get folders to keep during skeleton action

Call:

>>> SkeletonDirs = opts.get_ArchiveSkeletonDirs(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:

SkeletonDirs: {None} | object

folders to keep during skeleton action

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

Get files to keep during skeleton action

Call:

>>> SkeletonFiles = opts.get_ArchiveSkeletonFiles(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:

SkeletonFiles: {'case.json'} | object

files to keep during skeleton action

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

Get files to tail before deletion during skeleton

Call:

>>> SkeletonTailFiles = opts.get_ArchiveSkeletonTailFiles(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:

SkeletonTailFiles: {[]} | object

files to tail before deletion during skeleton

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

Get folders to tar before deletion during skeleton

Call:

>>> SkeletonTarDirs = opts.get_ArchiveSkeletonTarDirs(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:

SkeletonTarDirs: {[]} | object

folders to tar before deletion during skeleton

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

Get template for default archive settings

Call:

>>> ArchiveTemplate = opts.get_ArchiveTemplate(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:

ArchiveTemplate: {'full'} | str

template for default archive settings

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

Get whether restarts of same phase can use same job

Call:

>>> Continue = opts.get_Continue(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:

Continue: {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_RemoteCopy(j=None, i=None, **kw)

Get command for archive remote copies

Call:

>>> RemoteCopy = opts.get_RemoteCopy(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:

RemoteCopy: {'scp'} | str

command for archive remote copies

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

Get whether or not to submit new job at end of phase j

Call:

>>> Resubmit = opts.get_Resubmit(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:

Resubmit: {False} | True

whether or not to submit new job at end of phase j

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_UnarchiveCmd()

Get command to unarchive

Call:

>>> cmd = opts.get_UnarchiveCmd()

Inputs:

opts: cape.options.Options

Options interface

Outputs:

cmd: list[str]

Untar command and appropriate flags

Versions:

• 2016-03-01 @ddalle: Version 1.0

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} | object

folder from which to get warm-start file

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

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

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

Get action to take after finishing a case

Call:

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

Inputs:

opts: ArchiveOpts

options interface

ArchiveAction: '' | {'archive'} | 'rm' | 'skeleton'

action to take after finishing 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_ArchiveExtension(v, j=None, mode=None)

Get archive file extension

Call:

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

Inputs:

opts: ArchiveOpts

options interface

ArchiveExtension: 'bz2' | {'tar'} | 'tgz' | 'zip'

archive file extension

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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' | {'tar'} | 'tgz' | 'zip'

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

Get template for default archive settings

Call:

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

Inputs:

opts: ArchiveOpts

options interface

ArchiveTemplate: {'full'} | str

template for default archive settings

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

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

Get whether restarts of same phase can use same job

Call:

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

Inputs:

opts: RunControlOpts

options interface

Continue: {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_RemoteCopy(v, j=None, mode=None)

Get command for archive remote copies

Call:

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

Inputs:

opts: ArchiveOpts

options interface

RemoteCopy: {'scp'} | str

command for archive remote copies

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get whether or not to submit new job at end of phase j

Call:

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

Inputs:

opts: RunControlOpts

options interface

Resubmit: {False} | True

whether or not to submit new job at end of 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_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_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} | object

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

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