cape.cfdx.options.slurmopts: SLURM 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.slurmopts.BatchSlurmOpts(*args, **kw)
get_BatchSlurm_A(j=None, i=None, **kw)

Get Slurm job account name

Call:
>>> A = opts.get_BatchSlurm_A(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
A: {None} | str

Slurm job account name

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

Get constraint(s) on Slurm job

Call:
>>> C = opts.get_BatchSlurm_C(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
C: {None} | str

constraint(s) on Slurm job

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

Get number of Slurm nodes

Call:
>>> N = opts.get_BatchSlurm_N(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
N: {1} | int

number of Slurm nodes

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

Get constraints on when to acllocate job

Call:
>>> b = opts.get_BatchSlurm_b(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
b: {None} | object

constraints on when to acllocate job

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

Get Slurm job group ID

Call:
>>> gid = opts.get_BatchSlurm_gid(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
gid: {None} | str

Slurm job group ID

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

Get number of CPUs per node

Call:
>>> n = opts.get_BatchSlurm_n(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
n: {40} | int

number of CPUs per node

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

Get dict of additional Slurm options using = char

Call:
>>> other = opts.get_BatchSlurm_other(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
other: {None} | dict

dict of additional Slurm options using = char

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

Get Slurm queue name

Call:
>>> p = opts.get_BatchSlurm_p(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
p: {'normal'} | str

Slurm queue name

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

Get Slurm job shell name

Call:
>>> shell = opts.get_BatchSlurm_shell(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
shell: {'/bin/bash'} | str

Slurm job shell name

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

Get max Slurm job wall time

Call:
>>> time = opts.get_BatchSlurm_time(j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
time: {'8:00:00'} | str

max Slurm job wall time

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

Get Slurm job account name

Call:
>>> opts.set_BatchSlurm_A(A, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

A: {None} | str

Slurm job account name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get constraint(s) on Slurm job

Call:
>>> opts.set_BatchSlurm_C(C, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

C: {None} | str

constraint(s) on Slurm job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of Slurm nodes

Call:
>>> opts.set_BatchSlurm_N(N, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

N: {1} | int

number of Slurm nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get constraints on when to acllocate job

Call:
>>> opts.set_BatchSlurm_b(b, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

b: {None} | object

constraints on when to acllocate job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm job group ID

Call:
>>> opts.set_BatchSlurm_gid(gid, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

gid: {None} | str

Slurm job group ID

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of CPUs per node

Call:
>>> opts.set_BatchSlurm_n(n, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

n: {40} | int

number of CPUs per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get dict of additional Slurm options using = char

Call:
>>> opts.set_BatchSlurm_other(other, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

other: {None} | dict

dict of additional Slurm options using = char

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm queue name

Call:
>>> opts.set_BatchSlurm_p(p, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

p: {'normal'} | str

Slurm queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm job shell name

Call:
>>> opts.set_BatchSlurm_shell(shell, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

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

Slurm job shell name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get max Slurm job wall time

Call:
>>> opts.set_BatchSlurm_time(time, j=None, i=None, **kw)
Inputs:
opts: BatchSlurmOpts

options interface

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

max Slurm job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.cfdx.options.slurmopts.PostSlurmOpts(*args, **kw)
get_PostSlurm_A(j=None, i=None, **kw)

Get Slurm job account name

Call:
>>> A = opts.get_PostSlurm_A(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
A: {None} | str

Slurm job account name

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

Get constraint(s) on Slurm job

Call:
>>> C = opts.get_PostSlurm_C(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
C: {None} | str

constraint(s) on Slurm job

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

Get number of Slurm nodes

Call:
>>> N = opts.get_PostSlurm_N(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
N: {1} | int

number of Slurm nodes

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

Get constraints on when to acllocate job

Call:
>>> b = opts.get_PostSlurm_b(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
b: {None} | object

constraints on when to acllocate job

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

Get Slurm job group ID

Call:
>>> gid = opts.get_PostSlurm_gid(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
gid: {None} | str

Slurm job group ID

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

Get number of CPUs per node

Call:
>>> n = opts.get_PostSlurm_n(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
n: {40} | int

number of CPUs per node

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

Get dict of additional Slurm options using = char

Call:
>>> other = opts.get_PostSlurm_other(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
other: {None} | dict

dict of additional Slurm options using = char

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

Get Slurm queue name

Call:
>>> p = opts.get_PostSlurm_p(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
p: {'normal'} | str

Slurm queue name

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

Get Slurm job shell name

Call:
>>> shell = opts.get_PostSlurm_shell(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
shell: {'/bin/bash'} | str

Slurm job shell name

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

Get max Slurm job wall time

Call:
>>> time = opts.get_PostSlurm_time(j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
time: {'8:00:00'} | str

max Slurm job wall time

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

Get Slurm job account name

Call:
>>> opts.set_PostSlurm_A(A, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

A: {None} | str

Slurm job account name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get constraint(s) on Slurm job

Call:
>>> opts.set_PostSlurm_C(C, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

C: {None} | str

constraint(s) on Slurm job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of Slurm nodes

Call:
>>> opts.set_PostSlurm_N(N, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

N: {1} | int

number of Slurm nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get constraints on when to acllocate job

Call:
>>> opts.set_PostSlurm_b(b, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

b: {None} | object

constraints on when to acllocate job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm job group ID

Call:
>>> opts.set_PostSlurm_gid(gid, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

gid: {None} | str

Slurm job group ID

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of CPUs per node

Call:
>>> opts.set_PostSlurm_n(n, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

n: {40} | int

number of CPUs per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get dict of additional Slurm options using = char

Call:
>>> opts.set_PostSlurm_other(other, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

other: {None} | dict

dict of additional Slurm options using = char

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm queue name

Call:
>>> opts.set_PostSlurm_p(p, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

p: {'normal'} | str

Slurm queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm job shell name

Call:
>>> opts.set_PostSlurm_shell(shell, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

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

Slurm job shell name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get max Slurm job wall time

Call:
>>> opts.set_PostSlurm_time(time, j=None, i=None, **kw)
Inputs:
opts: PostSlurmOpts

options interface

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

max Slurm job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.cfdx.options.slurmopts.SlurmOpts(*args, **kw)

Dictionary-based options for Slurm jobs submitted via sbatch

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

Dictionary of Slurm options

Outputs:
opts: SlurmOpts

Slurm options interface

Versions:

  • 2022-10-31 @ddalle: v1.0

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

Get Slurm job account name

Call:
>>> A = opts.get_Slurm_A(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
A: {None} | str

Slurm job account name

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

Get constraint(s) on Slurm job

Call:
>>> C = opts.get_Slurm_C(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
C: {None} | str

constraint(s) on Slurm job

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

Get number of Slurm nodes

Call:
>>> N = opts.get_Slurm_N(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
N: {1} | int

number of Slurm nodes

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

Get constraints on when to acllocate job

Call:
>>> b = opts.get_Slurm_b(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
b: {None} | object

constraints on when to acllocate job

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

Get Slurm job group ID

Call:
>>> gid = opts.get_Slurm_gid(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
gid: {None} | str

Slurm job group ID

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

Get number of CPUs per node

Call:
>>> n = opts.get_Slurm_n(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
n: {40} | int

number of CPUs per node

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

Get dict of additional Slurm options using = char

Call:
>>> other = opts.get_Slurm_other(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
other: {None} | dict

dict of additional Slurm options using = char

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

Get Slurm queue name

Call:
>>> p = opts.get_Slurm_p(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
p: {'normal'} | str

Slurm queue name

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

Get Slurm job shell name

Call:
>>> shell = opts.get_Slurm_shell(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
shell: {'/bin/bash'} | str

Slurm job shell name

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

Get max Slurm job wall time

Call:
>>> time = opts.get_Slurm_time(j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

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

vdef: {None} | object

Manual default

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

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

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

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

sample: {True} | False

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

Outputs:
time: {'8:00:00'} | str

max Slurm job wall time

get_nSlurm() → int

Return the maximum number of unique Slurm inputs

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

Call:
>>> n = opts.get_nSlurm()
Inputs:
opts: cape.cfdx.options.Options

Options interface

Outputs:
n: int

Number of unique Slurm scripts

Versions:

  • 2014-12-01 @ddalle: Version 1.0

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

Get Slurm job account name

Call:
>>> opts.set_Slurm_A(A, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

A: {None} | str

Slurm job account name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get constraint(s) on Slurm job

Call:
>>> opts.set_Slurm_C(C, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

C: {None} | str

constraint(s) on Slurm job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of Slurm nodes

Call:
>>> opts.set_Slurm_N(N, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

N: {1} | int

number of Slurm nodes

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get constraints on when to acllocate job

Call:
>>> opts.set_Slurm_b(b, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

b: {None} | object

constraints on when to acllocate job

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm job group ID

Call:
>>> opts.set_Slurm_gid(gid, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

gid: {None} | str

Slurm job group ID

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get number of CPUs per node

Call:
>>> opts.set_Slurm_n(n, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

n: {40} | int

number of CPUs per node

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get dict of additional Slurm options using = char

Call:
>>> opts.set_Slurm_other(other, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

other: {None} | dict

dict of additional Slurm options using = char

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm queue name

Call:
>>> opts.set_Slurm_p(p, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

p: {'normal'} | str

Slurm queue name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get Slurm job shell name

Call:
>>> opts.set_Slurm_shell(shell, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

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

Slurm job shell name

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

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

Get max Slurm job wall time

Call:
>>> opts.set_Slurm_time(time, j=None, i=None, **kw)
Inputs:
opts: SlurmOpts

options interface

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

max Slurm job wall time

j: {None} | int

Phase index; use None to just return v

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

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar