PlasmaCalcs.hookups.eppic.eppic_dimensions.EppicDist

class PlasmaCalcs.hookups.eppic.eppic_dimensions.EppicDist(m, q, n0, *, N=None, name=None, i=None, params=None)

Bases: DictlikeFromKeysAndGetitem, Fluid

info about a single distribution.
see cls.from_dict() to create an instance from a dict of values from an eppic.i file.
units are “raw”. Numerical values equal those from the eppic.i file.
m: real number
mass of a single “real” particle in the distribution
q: real number
charge of a single “real” particle in the distribution
n0: real number
background “physical” number density of this distribution of particles.
N: None, int, or str
distribution number; will be internally stored as int (or None).
Optional because distribution number doesn’t affect distribution physics,
however all distributions from eppic.i files will have a number.
i: None or int
index of this distribution in a DistributionList.
raise NotImplementedError if i and N are incompatible
(i.e. both non-None and representing different values).
params: None or dict
additional parameters.
Provide dict with keys with trailing distN removed,
e.g. “coll_rate” not “coll_rate1” (if dist=’1’)
name: None or str
name of this distribution.
Optional, and probably not found in eppic.i files.
Provide to improve human-readability.
__init__(m, q, n0, *, N=None, name=None, i=None, params=None)

Methods

__init__(m, q, n0, *[, N, name, i, params])

copy(**kw_init)

deserialize(serial)

dists_from_dict(d)

equal_except_i(v)

from_dict(d)

from_dict_and_N(d, N)

get(key[, default])

get_n0()

get_npd(*[, default])

get_v0([x])

get_velocity_coords(units)

get_vth0([x])

is_charged()

is_electron()

is_hybrid()

is_ion()

is_neutral()

items()

keys()

lookup_dict()

register_type(cls_to_register[, ...])

serialize()

to_dict()

values()

with_i(i)

Attributes

SERIAL_TYPES

SPECIAL

name

ndim

precision

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.
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]
classmethod dists_from_dict(d)
return dict of distributions, given a dict of {N: dict of distribution values}.
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.
classmethod from_dict(d)
return cls from dict d.
If ‘d’ contains ‘typename’, result is like cls.deserialize(d) instead,
however, first require that result is an instance of cls (or subclass of cls).
E.g. Fluid.from_dict(dict(typename=’EppicDist’, …)) returns EppicDist,
but Snap.from_dict(dict(typename=’EppicDist’, …)) crashes with InputError.
Subclasses wishing to alter deserialize behavior will probably override this method instead.
classmethod from_dict_and_N(d, N)
return EppicDist from dict and N.
d: dict
result of eppic_io_tools.read_eppic_i_file()[N].
must have keys mdN, qdN, n0dN. E.g. “md1” for N=’1’
other keys must end in N, and one N will be removed from end of each.
e.g. “coll_rate1” –> “coll_rate”.
raise ValueError if any key doesn’t end with N.
if ‘nameN’ appears in d, it will be used as name.
N: None, str or int
distribution number. if int, will be converted to str.
get(key, default=UNSET)
return self[key]. if default is provided and self[key] doesn’t exist, return default.
get_n0()
returns background (mean) density of this distribution. Equivalent: self[‘n0’]
get_npd(*, default=UNSET)
return number of PIC particles for this distribution in each processor.
If that is not possible (due to using alternate option for npd), raise FluidKeyError
Alternate options include: nptotd, npcelld, nptotcelld;
those options tell npd info but scaled by number of cells and/or processors.
number of cells & processors are global parameters not known by EppicDist,
so EppicDist cannot calculate npd from those options.
default: UNSET or any value
return default instead of error when npd not found, if default provided (not UNSET).
get_v0(x=None)
returns original (t=0) velocity, as a tuple of (vx, vy, xz) values,
or the x component if x provided (x should be a string if provided).
get_velocity_coords(units)
Returns a dictionary of vdist coordinates (vx, vy, vz) for this EppicDist.
For example, “vx”: np.linspace(self[“pvxmin”], self[“pvxmax”], num=self[“pnvx”]).
get_vth0(x=None)
returns original (t=0) thermal velocity, as a tuple of (vx, vy, xz) values,
or the x component if x provided (x should be a string if provided).
if x is Ellipsis (i.e., x=…), assert all three components are the same,
and return the one value which they all equal.
is_charged()
tells whether self is a charged fluid. i.e. self.q != 0.
if self.q is None, returns None instead of bool.
is_electron()
tells whether self is an electron. i.e. self.q < 0.
if self.q is None, returns None instead of bool.
is_hybrid()
return whether this distribution is “hybrid”, i.e. fluid model instead of PIC.
as a proxy, guessing hybrid iff self.get(‘method’, 0) != 0.
is_ion()
tells whether self is an ion. i.e. self.q > 0.
if self.q is None, returns None instead of bool.
is_neutral()
tells whether self is a neutral fluid. i.e. self.q == 0.
if self.q is None, returns None instead of bool.
items()
return tuple of (key, value) pairs corresponding to self.keys() and self.values().
keys()
return tuple of keys which are special or in self.params
lookup_dict()
returns dict for looking up self within a DimensionValueList, given int, str, or self.
(used by DimensionValueList.lookup_dict)
property name
alias to s
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.