PlasmaCalcs.dimensions.snaps.ParamsSnap

class PlasmaCalcs.dimensions.snaps.ParamsSnap(s=None, i=None, *, t=None, params=None)

Bases: DictlikeFromKeysAndGetitem, Snap

single snapshot with associated parameters, saved in self.params;

self also behaves like a dict with params keys & values.

(Useful if each snapshot has a possibly-different set of parameters.)

s: the label (str) of the snapshot. if None, cannot convert to str. i: the “index” (int) of the snapshot (within a SnapList). if None, cannot convert to int. t: time at this snapshot [‘raw’ units] params: dict of parameters at this snapshot. if None, make empty dict.

The “index” should only be meaningful in the context of a SnapList

The “label” should be the str name for this snapshot

- unique within context (e.g. there’s only one “snapshot 1” in a simulation)

- easiest to use str int labels (e.g. “snapshot 1” –> label=”1”)

__init__(s=None, i=None, *, t=None, params=None)

Methods

__init__([s, i, t, params])
copy(**kw_init)
copy_add_t(t_add)
deserialize(serial)
equal_except_i(v)
exists_for(calculator)
file_path(calculator)
file_s(calculator)
file_snap(calculator)
from_dict(d, *[, ignore_dt])
get(key[, default])
items()
keys()
lookup_dict()
register_type(cls_to_register[, ...])
serialize()
to_dict()
values()
with_i(i)

Attributes

SERIAL_TYPES
ndim
size

copy(**kw_init)

return a copy of self. Can provide new kwargs here to override old values in result.

E.g. self.copy(i=7) makes a copy of self but with i=7 instead of self.i.

copy_add_t(t_add)

create a copy of self but with t increased by t_add.

Equivalent to self.copy(t=self.t + t_add).

Provided separately for convenience; shifting t can be quite useful.

static deserialize(serial)

creates an XarrayIoSerializable object from a serialized representation.

serial: dict or str

str –> convert to dict via ast.literal_eval.

dict must contain ‘typename’ key.

The output here will be an instance of XarrayIoSerializable.SERIAL_TYPES[typename]

equal_except_i(v)

returns whether self == v (another DimensionValue), ignoring i.

equal if v is an instance of type(self) and

all kw from both self._kw_eq and v._kw_eq have the same values.

(any kw missing attrs will be treated as UNSET.)

For DimensionValue: self.s==v.s and self.i==v.i. Subclasses may add more.

exists_for(calculator)

returns whether this snap exists for this calculator.

Here, just return self is not MISSING_SNAP. subclass should override if desired.

file_path(calculator)

returns the abspath to the file associated with this snap for this calculator.

Here, just return calculator.snap_filepath(self).

file_s(calculator)

returns the str used when determining file related to this snap.

Here, just return str(self). subclass should override if desired.

file_snap(calculator)

returns the snap used when determining file related to this snap.

Here, just returns self. Subclasses might override.

classmethod from_dict(d, *, ignore_dt=True)

return cls from dict d. d should NOT have ‘typename’ key.

Use cls.deserialize(d) instead if d has ‘typname’ key.

ignore_dt: bool

whether to ignore ‘dt’ key from d.

This exists for backwards compatibility when reading older files;

Snap previously accepted ‘dt’ key but doesn’t anymore.

get(key, default=UNSET)

return self[key]. if default is provided and self[key] doesn’t exist, return default.

items()

return tuple of (key, value) pairs corresponding to self.keys() and self.values().

keys()

return tuple of keys of self.params

lookup_dict()

returns dict for looking up self within a DimensionValueList, given int, str, or self.

(used by DimensionValueList.lookup_dict)

static register_type(cls_to_register, _serial_typename=None)

register cls_to_register as a serializable subclass of XarrayIoSerializable.

_serial_typename: str or None

name to use for serialization. if None, use cls_to_register.__name__.

serialize()

return dict of info about self, including ‘typename’ key.

to_dict()

return dictionary of info about self. Attribute values for keys in self._kw_def.

e.g. if _kw_def={‘s’, ‘i’}: result = {‘s’: self.s, ‘i’: self.i}

values()

return tuple of values corresponding to self.keys().

with_i(i)

return copy of self with i=i, or self if self.i==i already.