cape.cfdx.options.pbsopts: PBS script options

This portion of the options is universal, and so it is only encoded in the cape module. The cape.pycart module, for example, does not have a modified version. It contains options for specifying which architecture to use, how many nodes to request, etc.

class cape.cfdx.options.pbsopts.BatchPBSOpts(*args, **kw)

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

Get account name(s) or number(s)

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

A: {None} | object

account name(s) or number(s)

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

Get shell to execute PBS job

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

S: {'/bin/bash'} | str

shell to execute PBS job

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

Get PBS W setting, usually for setting group

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

W: {''} | str

PBS W setting, usually for setting group

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

Get architecture operating environment

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

aoe: {None} | str

architecture operating environment

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

Get explicit STDERR file name

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object

explicit STDERR file name

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

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

j: {'oe'} | str

PBS ‘join’ setting

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

Get Requested cpu memory (on gpu node)

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mem: {None} | int

Requested cpu memory (on gpu node)

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

Get model type/architecture

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

model: {None} | str

model type/architecture

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

Get number of MPI processes per node

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mpiprocs: {None} | int

number of MPI processes per node

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

Get number of cores (roughly CPUs) per node

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ncpus: {None} | int

number of cores (roughly CPUs) per node

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

Get number of gpus per node

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ngpus: {None} | int

number of gpus per node

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

Get explicit STDOUT file name

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

o: {None} | object

explicit STDOUT file name

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

Get number of OMP threads

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ompthreads: {None} | int

number of OMP threads

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

Get PBS priority

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object

PBS priority

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

Get Share or exclusive access to requested gpu nodes

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

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

Get PBS queue name

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {'normal'} | str

PBS queue name

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

Get rerun-able setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

r: {'n'} | 'y'

rerun-able setting

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

Get number of nodes

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

select: {1} | int

number of nodes

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

Get list of manually requested hard drives to mount

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

site_needed: {None} | list[str]

list of manually requested hard drives to mount

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

Get maximum job wall time

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

walltime: {'8:00:00'} | str

maximum job wall time

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

Get account name(s) or number(s)

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

A: {None} | object

account name(s) or number(s)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get shell to execute PBS job

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

S: {'/bin/bash'} | str

shell to execute PBS job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS W setting, usually for setting group

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

W: {''} | str

PBS W setting, usually for setting group

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get architecture operating environment

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

aoe: {None} | str

architecture operating environment

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get explicit STDERR file name

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

e: {None} | object

explicit STDERR file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

j: {'oe'} | str

PBS ‘join’ setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Requested cpu memory (on gpu node)

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

mem: {None} | int

Requested cpu memory (on gpu node)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get model type/architecture

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

model: {None} | str

model type/architecture

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of MPI processes per node

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

mpiprocs: {None} | int

number of MPI processes per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of cores (roughly CPUs) per node

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

ncpus: {None} | int

number of cores (roughly CPUs) per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of gpus per node

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

ngpus: {None} | int

number of gpus per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get explicit STDOUT file name

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

o: {None} | object

explicit STDOUT file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of OMP threads

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

ompthreads: {None} | int

number of OMP threads

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS priority

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

p: {None} | object

PBS priority

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Share or exclusive access to requested gpu nodes

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS queue name

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

q: {'normal'} | str

PBS queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get rerun-able setting

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

r: {'n'} | 'y'

rerun-able setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of nodes

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

select: {1} | int

number of nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get list of manually requested hard drives to mount

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

site_needed: {None} | list[str]

list of manually requested hard drives to mount

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get maximum job wall time

Call:

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

Inputs:

opts: BatchPBSOpts

options interface

walltime: {'8:00:00'} | str

maximum job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.cfdx.options.pbsopts.PBSOpts(*args, **kw)

Options class for PBS jobs

Call:

>>> opts = PBS(**kw)

Inputs:

kw: dict

Dictionary of PBS options

Outputs:

opts: cape.options.pbs.PBS

PBS options interface

Versions:

• 2014-12-01 @ddalle: v1.0

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

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

Get account name(s) or number(s)

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

A: {None} | object

account name(s) or number(s)

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

Get shell to execute PBS job

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

S: {'/bin/bash'} | str

shell to execute PBS job

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

Get PBS W setting, usually for setting group

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

W: {''} | str

PBS W setting, usually for setting group

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

Get architecture operating environment

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

aoe: {None} | str

architecture operating environment

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

Get explicit STDERR file name

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object

explicit STDERR file name

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

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

j: {'oe'} | str

PBS ‘join’ setting

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

Get Requested cpu memory (on gpu node)

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mem: {None} | int

Requested cpu memory (on gpu node)

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

Get model type/architecture

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

model: {None} | str

model type/architecture

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

Get number of MPI processes per node

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mpiprocs: {None} | int

number of MPI processes per node

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

Get number of cores (roughly CPUs) per node

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ncpus: {None} | int

number of cores (roughly CPUs) per node

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

Get number of gpus per node

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ngpus: {None} | int

number of gpus per node

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

Get explicit STDOUT file name

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

o: {None} | object

explicit STDOUT file name

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

Get number of OMP threads

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ompthreads: {None} | int

number of OMP threads

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

Get PBS priority

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object

PBS priority

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

Get Share or exclusive access to requested gpu nodes

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

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

Get PBS queue name

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {'normal'} | str

PBS queue name

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

Get rerun-able setting

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

r: {'n'} | 'y'

rerun-able setting

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

Get number of nodes

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

select: {1} | int

number of nodes

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

Get list of manually requested hard drives to mount

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

site_needed: {None} | list[str]

list of manually requested hard drives to mount

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

Get maximum job wall time

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

walltime: {'8:00:00'} | str

maximum job wall time

get_nPBS() → int

Return the maximum number of unique PBS inputs

For example, if a case is set up to be run in two parts, and the first phase needs only one node (select=1) while the second phase needs 10 nodes (select=10), then the input file should have "select": [1, 10], and the output of this function will be 2.

Call:

>>> n = opts.get_nPBS()

Inputs:

opts: cape.options.Options

Options interface

Outputs:

n: int

Number of unique PBS scripts

Versions:

• 2014-12-01 @ddalle: First version

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

Get account name(s) or number(s)

Call:

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

Inputs:

opts: PBSOpts

options interface

A: {None} | object

account name(s) or number(s)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get shell to execute PBS job

Call:

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

Inputs:

opts: PBSOpts

options interface

S: {'/bin/bash'} | str

shell to execute PBS job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS W setting, usually for setting group

Call:

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

Inputs:

opts: PBSOpts

options interface

W: {''} | str

PBS W setting, usually for setting group

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get architecture operating environment

Call:

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

Inputs:

opts: PBSOpts

options interface

aoe: {None} | str

architecture operating environment

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get explicit STDERR file name

Call:

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

Inputs:

opts: PBSOpts

options interface

e: {None} | object

explicit STDERR file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PBSOpts

options interface

j: {'oe'} | str

PBS ‘join’ setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Requested cpu memory (on gpu node)

Call:

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

Inputs:

opts: PBSOpts

options interface

mem: {None} | int

Requested cpu memory (on gpu node)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get model type/architecture

Call:

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

Inputs:

opts: PBSOpts

options interface

model: {None} | str

model type/architecture

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of MPI processes per node

Call:

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

Inputs:

opts: PBSOpts

options interface

mpiprocs: {None} | int

number of MPI processes per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of cores (roughly CPUs) per node

Call:

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

Inputs:

opts: PBSOpts

options interface

ncpus: {None} | int

number of cores (roughly CPUs) per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of gpus per node

Call:

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

Inputs:

opts: PBSOpts

options interface

ngpus: {None} | int

number of gpus per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get explicit STDOUT file name

Call:

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

Inputs:

opts: PBSOpts

options interface

o: {None} | object

explicit STDOUT file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of OMP threads

Call:

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

Inputs:

opts: PBSOpts

options interface

ompthreads: {None} | int

number of OMP threads

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS priority

Call:

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

Inputs:

opts: PBSOpts

options interface

p: {None} | object

PBS priority

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Share or exclusive access to requested gpu nodes

Call:

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

Inputs:

opts: PBSOpts

options interface

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS queue name

Call:

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

Inputs:

opts: PBSOpts

options interface

q: {'normal'} | str

PBS queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get rerun-able setting

Call:

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

Inputs:

opts: PBSOpts

options interface

r: {'n'} | 'y'

rerun-able setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of nodes

Call:

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

Inputs:

opts: PBSOpts

options interface

select: {1} | int

number of nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get list of manually requested hard drives to mount

Call:

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

Inputs:

opts: PBSOpts

options interface

site_needed: {None} | list[str]

list of manually requested hard drives to mount

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get maximum job wall time

Call:

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

Inputs:

opts: PBSOpts

options interface

walltime: {'8:00:00'} | str

maximum job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.cfdx.options.pbsopts.PostPBSOpts(*args, **kw)

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

Get account name(s) or number(s)

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

A: {None} | object

account name(s) or number(s)

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

Get shell to execute PBS job

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

S: {'/bin/bash'} | str

shell to execute PBS job

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

Get PBS W setting, usually for setting group

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

W: {''} | str

PBS W setting, usually for setting group

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

Get architecture operating environment

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

aoe: {None} | str

architecture operating environment

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

Get explicit STDERR file name

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

e: {None} | object

explicit STDERR file name

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

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

j: {'oe'} | str

PBS ‘join’ setting

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

Get Requested cpu memory (on gpu node)

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mem: {None} | int

Requested cpu memory (on gpu node)

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

Get model type/architecture

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

model: {None} | str

model type/architecture

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

Get number of MPI processes per node

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

mpiprocs: {None} | int

number of MPI processes per node

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

Get number of cores (roughly CPUs) per node

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ncpus: {None} | int

number of cores (roughly CPUs) per node

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

Get number of gpus per node

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ngpus: {None} | int

number of gpus per node

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

Get explicit STDOUT file name

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

o: {None} | object

explicit STDOUT file name

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

Get number of OMP threads

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

ompthreads: {None} | int

number of OMP threads

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

Get PBS priority

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

p: {None} | object

PBS priority

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

Get Share or exclusive access to requested gpu nodes

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

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

Get PBS queue name

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

q: {'normal'} | str

PBS queue name

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

Get rerun-able setting

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

r: {'n'} | 'y'

rerun-able setting

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

Get number of nodes

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

select: {1} | int

number of nodes

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

Get list of manually requested hard drives to mount

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

site_needed: {None} | list[str]

list of manually requested hard drives to mount

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

Get maximum job wall time

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:

walltime: {'8:00:00'} | str

maximum job wall time

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

Get account name(s) or number(s)

Call:

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

Inputs:

opts: PostPBSOpts

options interface

A: {None} | object

account name(s) or number(s)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get shell to execute PBS job

Call:

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

Inputs:

opts: PostPBSOpts

options interface

S: {'/bin/bash'} | str

shell to execute PBS job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS W setting, usually for setting group

Call:

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

Inputs:

opts: PostPBSOpts

options interface

W: {''} | str

PBS W setting, usually for setting group

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get architecture operating environment

Call:

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

Inputs:

opts: PostPBSOpts

options interface

aoe: {None} | str

architecture operating environment

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get explicit STDERR file name

Call:

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

Inputs:

opts: PostPBSOpts

options interface

e: {None} | object

explicit STDERR file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS ‘join’ setting

Call:

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

Inputs:

opts: PostPBSOpts

options interface

j: {'oe'} | str

PBS ‘join’ setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Requested cpu memory (on gpu node)

Call:

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

Inputs:

opts: PostPBSOpts

options interface

mem: {None} | int

Requested cpu memory (on gpu node)

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get model type/architecture

Call:

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

Inputs:

opts: PostPBSOpts

options interface

model: {None} | str

model type/architecture

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of MPI processes per node

Call:

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

Inputs:

opts: PostPBSOpts

options interface

mpiprocs: {None} | int

number of MPI processes per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of cores (roughly CPUs) per node

Call:

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

Inputs:

opts: PostPBSOpts

options interface

ncpus: {None} | int

number of cores (roughly CPUs) per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of gpus per node

Call:

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

Inputs:

opts: PostPBSOpts

options interface

ngpus: {None} | int

number of gpus per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get explicit STDOUT file name

Call:

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

Inputs:

opts: PostPBSOpts

options interface

o: {None} | object

explicit STDOUT file name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of OMP threads

Call:

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

Inputs:

opts: PostPBSOpts

options interface

ompthreads: {None} | int

number of OMP threads

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS priority

Call:

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

Inputs:

opts: PostPBSOpts

options interface

p: {None} | object

PBS priority

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Share or exclusive access to requested gpu nodes

Call:

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

Inputs:

opts: PostPBSOpts

options interface

place: {'excl'} | 'shared'

Share or exclusive access to requested gpu nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get PBS queue name

Call:

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

Inputs:

opts: PostPBSOpts

options interface

q: {'normal'} | str

PBS queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get rerun-able setting

Call:

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

Inputs:

opts: PostPBSOpts

options interface

r: {'n'} | 'y'

rerun-able setting

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of nodes

Call:

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

Inputs:

opts: PostPBSOpts

options interface

select: {1} | int

number of nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get list of manually requested hard drives to mount

Call:

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

Inputs:

opts: PostPBSOpts

options interface

site_needed: {None} | list[str]

list of manually requested hard drives to mount

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get maximum job wall time

Call:

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

Inputs:

opts: PostPBSOpts

options interface

walltime: {'8:00:00'} | str

maximum job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar