DecoratingVars

class PlasmaCalcs.quantities.quantity_tools.DecoratingVars(known_calcs=None)

Bases: DecoratingCalcs

Decorating functions to put loadable vars into a dict (self.known_calcs).

(e.g., self.known_calcs will be QuantityLoader.KNOWN_VARS; see MetaQuantTracking for details.)

known_calcs: None or dict

will store known calcs; dict of {name: LoadableVar} pairs.

Example: known_var = DecoratingCalcs(storage_dict)

@known_var

def get_var1(…):

…

@known_var(deps=[‘var1’])

def get_var2(…):

…

# at this point, we have:

# known_var.known_calcs == {‘var1’: LoadableQuantity(‘get_var1’),

# ‘var2’: LoadableQuantity(‘get_var2’, deps=[‘var1’])}.

Methods

`__call__`([f, deps, aliases, dims, ...])	if f is provided, return self.decorator(**kw)(f).
`decorator`(*[, name, aliases, deps, ...])	returns decorator for quant calculator f(self, args, *kw), which returns f unchanged...
`track_f`(f, *[, name, aliases, deps, ...])	add f to self.known_calcs as a LoadableQuantity.

__call__(f=None, *, deps=[], aliases=[], dims=None, load_across_dims=None, ignores_dims=[], reduces_dims=[], partition_across_dim=None, partition_deps=None, **kw_decorator): if f is provided, return self.decorator(**kw)(f). Otherwise, return self.decorator(**kw).

This enables instances to be used as decorators directly, i.e. “@self”,

or used as decorators after providing kwargs, e.g. “@self(deps=[‘var2’])”

See help(type(self)) for examples.

decorator(*, name=None, aliases=[], deps=[], attr_deps=[], value_deps=[], dims=None, load_across_dims=None, ignores_dims=[], reduces_dims=[], partition_across_dim=None, partition_deps=None): returns decorator for quant calculator f(self, *args, **kw), which returns f unchanged…

but also sets self.known_calcs[name] = LoadableQuantity(f.__name__, deps=deps)

(note - actually uses self.loadable_quantity_cls instead of LoadableQuantity)

name: None or str

if provided, tells name of this quantity (i.e., the key in self.known_calcs)

None –> use {name} from f.__name__ which looks like “get_{name}”.

aliases: list

if any aliases are provided, also add, for alias in aliases:

self.known_calcs[alias] = self.known_calcs[name]

deps: list of str/int/tuple/dict/callable

list of dependencies for this quant. Each dependency is one of the following:

- a str, indicating a known var or pattern name,

- an int, indicating a group index from a pattern match,

- a 2-tuple of (non-tuple-dep, dict),

where dict tells any values essential to set via quantity_loader.using(**dict),

in order to properly determine deps.

E.g. (‘n’, {‘fluid’: ELECTRON}) for ‘depends on n when self.fluid=electron’.

Note: mostly intended for internal use (in value_deps). It’s usually preferable to

just define a different variable, e.g. ‘ne’ which will set values appropriately.

- a dict with length 1, with

key = int or tuple of ints, specifying which groups are relevant.

dep will utilize info about groups = _match.groups().

val = str, or callable f -> str or iterable.

str –> val.format(**group_info), where

group_info = {f’group{i}’: groups[i] for i in key},

replacing groups[i] with ‘’ if groups[i] is None.

callable f –> f(group_info), where

group_info = {i: groups[i] for i in key}

- a callable of the form f(quantity_loader, var, groups) -> str or iterable,

which tells the var name(s) associated with this dependency,

where: quantity_loader is a QuantityLoader instance,

var is the matched var,

and groups=_match.groups() if _match provided else None.

attr_deps: list of 2-tuples of (str, dict or str)

list of attr-based dependencies for this quant. Each dependency is:

(attr, lookup), where lookup.get(v, []) tells str or list of deps associated with v,

where v=quantity_loader.attr.

if ‘__default__’ in lookup, use lookup.get(v, lookup[‘__default__’]) instead.

str lookup –> lookup = getattr(quantity_loader, lookup).

value_deps: list of 2-tuples of (str, dict or str)

list of value-based dependencies for this quant. Each dependency is:

(var, lookup), where lookup.get(val, []) tells str or list of deps associated with val,

for all unique vals in quantity_loader(var).

Each dep associated with val may be str/int/callable, similar to deps.

if ‘__default__’ in lookup, use lookup.get(v, lookup[‘__default__’]) instead.

str lookup –> lookup = getattr(quantity_loader, lookup).

dims: None or list of strings

dimensions associated directly with this quantity. E.g. [‘fluid’, ‘snap’]

None –> this quant is not directly associated with any dims.

load_across_dims: None or list of strings

if provided, the returned decorator(f) will actually wrap f to use load_across_dims:

result(f)(self, …) returns self.load_across_dims(f, …, dims=load_across_dims).

To indicate dim dependencies without adjusting f, use kwarg dims, instead.

ignores_dims: list of strings

dimensions which the result ignores, even if the dependencies don’t ignore.

E.g. ‘mod_(.+)’ has ignores_dims=[‘component’],

because it provides the same result regardless of obj.component.

reduces_dims: list of strings

dimensions which the result reduces along.

E.g. ‘ldebye_subset’ has reduces_dims=[‘fluid’],

because the result doesn’t have ‘fluid’ dim even though it depends on obj.fluid.

partition_across_dim: None or 2-tuple of (dim, partitioner)

if provided, the returned decorator(f) will actually wrap f:

result(f)(self, …) partitions across dim and provides partitioner as kwarg input,

then rejoins along dim afterwards.

currently, only supports partitioning across 1 dim per f.

partitioner should be a string, and will be added to deps.

partition_deps: None, str, or dict

if provided, tells lookup from partitioner value to additional dep var name(s).

(only allowed if partition_across_dim is provided.)

Equivalent to using value_deps=[(partitioner, partition_deps)].

str –> will use lookup = getattr(quantity_loader, partition_deps).

E.g. {‘saha’: ‘ionfrac_saha’, ‘SINGLE_FLUID’: [‘ne’, ‘SF_n’]},

when partition_across_dim=(‘fluid’, ‘ionfrac_type’),

–> add ‘ionfrac_saha’ to deps if ‘saha’ in self(‘ionfrac_type’),

and add ‘ne’ and ‘SF_n’ to deps if ‘SINGLE_FLUID’ in self(‘ionfrac_type’).

and, this example is equivalent to using value_deps=

[(‘ionfrac_type’, {‘saha’: ‘ionfrac_saha’, ‘SINGLE_FLUID’: [‘ne’, ‘SF_n’]})]

loadable_quantity_cls: alias of LoadableVar

track_f(f, *, name=None, aliases=[], deps=[], attr_deps=[], value_deps=[], dims=None, ignores_dims=[], reduces_dims=[]): add f to self.known_calcs as a LoadableQuantity.

See help(self.decorator) for details on parameters.