Level_1#

class esis.data.Level_1(inputs=0, outputs=0, instrument=None, *, axis_time='time', axis_channel='channel', axis_x='detector_x', axis_y='detector_y')[source]#

Bases: AbstractChannelData

ESIS images represented in terms of photoelectrons collected by the sensor.

This class is intended to be created from an instance of Level_0 using the :meth:from_level_0` method.

Attributes

`axes`	A `tuple` of `str` representing the names of each dimension of `ndarray`.
`axes_center`	Return keys corresponding to all input axes representing bin centers
`axes_flattened`	Combine `axes` into a single `str`.
`axes_vertex`	Return keys corresponding to all input axes representing bin vertices
`axis_channel`	The name of the logical axis corresponding to the different channels.
`axis_time`	The name of the logical axis corresponding to changing time.
`axis_x`	The name of the horizontal axis of the sensor.
`axis_xy`	A `tuple` containing `axis_x` and `axis_y`.
`axis_y`	The name of the vertical axis of the sensor.
`broadcasted`	if this array has multiple components, broadcast them against each other.
`channel`	The name of each ESIS channel in a human-readable format.
`explicit`	Converts this array to an instance of `named_arrays.AbstractExplicitArray`
`indices`
`inputs`
`instrument`	A model of the optical system associated with these images.
`length`	L2-norm of this array.
`ndim`	Number of dimensions of the array.
`num_x`	The number of pixels along the horizontal axis.
`num_y`	The number of pixels along the vertical axis.
`outputs`
`shape`	Shape of the array.
`size`	Total number of elements in the array.
`type_abstract`	The `AbstractArray` type corresponding to this array
`type_explicit`	The `AbstractExplicitArray` type corresponding to this array
`value`	Returns a new array with its units removed, if they exist

Methods

`__init__`([inputs, outputs, instrument, ...])
`add_axes`(axes)	Add new singleton axes to this array
`all`([axis, where])
`animate`([ax, cmap, norm, vmin, vmax, ...])	Create an animation using the frames in this dataset.
`any`([axis, where])
`astype`(dtype[, order, casting, subok, copy])	Copy of the array cast to a specific data type.
`broadcast_to`(shape[, append])
`cell_centers`([axis, random])	Convert an array from cell vertices to cell centers.
`combine_axes`([axes, axis_new])	Combine some of the axes of the array into a single new axis.
`copy`()
`copy_shallow`()
`from_level_0`(a[, instrument])	Create a new instance of this class from an instance of `Level_0`.
`from_scalar_array`(a[, like])	Constructs a new version of this array using `a` as the underlying data.
`index`(value[, axis])
`index_secant`(value[, axis])
`interp_linear`(item)
`max`([axis, initial, where])
`mean`([axis, where])
`median`([axis])
`min`([axis, initial, where])
`ndindex`([axis_ignored])
`pcolormesh`(axs, input_component_x, ...[, ...])	Plot a `FunctionArray` via `matplotlib.pyplot.pcolormesh()`.
`percentile`(q[, axis, out, overwrite_input, ...])
`ptp`([axis])
`regrid`(inputs[, axis, method, weights])	Resample this function array onto a new set of input coordinates using `named_arrays.regridding.regrid()`.
`replace`(**changes)	A method version of `dataclasses.replace()` for named arrays.
`reshape`(shape)
`rms`([axis, where])
`std`([axis, where])
`sum`([axis, where])
`to`(unit[, equivalencies, copy])	Convert this array to a new unit.
`to_jshtml`([ax, cmap, norm, vmin, vmax, ...])	Create a Javascript animation ready to be displayed in a Jupyter notebook.
`to_string`([prefix, multiline])	Convert this array instance to a string representation.
`to_string_array`([format_value, format_unit, ...])	Convert to an array of strings where each string has an appropriately-formatted unit attached to the value.
`transpose`([axes])
`var`([axis, where])
`vmr`([axis, where])
`volume_cell`(axis)	Computes the n-dimensional volume of each cell formed by interpreting this array as a logically-rectangular grid of vertices.
`weights`(inputs[, axis, method])	Compute the resampling weights of this array using `named_arrays.regridding.weights()`.

Inheritance Diagram

Parameters:

inputs (InputsT)
outputs (OutputsT)
instrument (None | Instrument)
axis_time (str)
axis_channel (str)
axis_x (str)
axis_y (str)

add_axes(axes)#

Add new singleton axes to this array

Parameters:: axes (str | Sequence[str]) – New axes to add to the array
Return type:: Array with new axes added

all(axis=None, where=<no value>)#

Parameters:

self (Self)
axis (None | str | Sequence[str])
where (Self)

Return type:

Self

animate(ax=None, cmap=None, norm=None, vmin=None, vmax=None, cbar_fraction=0.1)#

Create an animation using the frames in this dataset.

Parameters:

ax (None | Axes | AbstractArray) – The Axes instance(s) to use. If None, a new set of axes will be created.
cmap (None | str | Colormap) – The colormap used to map scalar data to colors.
norm (None | str | Normalize) – The normalization method used to scale data into the range [0, 1] before mapping to colors.
vmin (None | int | float | complex | ndarray | Quantity | AbstractArray) – The minimum value of the data range. If norm is None, this parameter will be ignored.
vmax (None | int | float | complex | ndarray | Quantity | AbstractArray) – The maximum value of the data range. If norm is None, this parameter will be ignored.
cbar_fraction (float) – The fraction of the space to use for the colorbar axes.

Return type:

FuncAnimation

any(axis=None, where=<no value>)#

Parameters:

self (Self)
axis (None | str | Sequence[str])
where (Self)

Return type:

Self

astype(dtype, order='K', casting='unsafe', subok=True, copy=True)#

Copy of the array cast to a specific data type.

Equivalent to numpy.ndarray.astype().

Parameters:

dtype (str | dtype | type)
order (str)
subok (bool)
copy (bool)

Return type:

FunctionArray

broadcast_to(shape, append=False)#

Parameters:

self (Self)
shape (dict[str, int])
append (bool)

Return type:

Self

cell_centers(axis=None, random=False)#

Convert an array from cell vertices to cell centers.

Parameters:

axis (None | str | Sequence[str]) – The axes of the array to average over.
random (bool) – If true, select a random point within each cell instead of the geometric center.

Return type:

AbstractExplicitArray

combine_axes(axes=None, axis_new=None)#

Combine some of the axes of the array into a single new axis.

Parameters:

axes (Sequence[str]) – The axes to combine into a new axis
axis_new (str) – The name of the new axis

Return type:

Array with the specified axes combined

copy()#

Parameters:: self (Self)
Return type:: Self

copy_shallow()#

Parameters:: self (Self)
Return type:: Self

classmethod from_level_0(a, instrument=None)[source]#

Create a new instance of this class from an instance of Level_0.

This function applies the following operations to the Level_0 data:

Removes the bias (or pedestal) using unbiased().
Removes the non-active pixels using active().
Converts the signal to electrons using electrons().
Removes the dark signal using dark_subtracted.
Removes the cosmic ray spikes using despiked().

Parameters:

a (Level_0) – An instance of Level_0 to convert.
instrument (None | Instrument) – A model of the ESIS instrument to associate with these observations.

Return type:

Self

classmethod from_scalar_array(a, like=None)#

Constructs a new version of this array using a as the underlying data.

Parameters:

a (float | Quantity | AbstractScalarArray) – Anything that can be coerced into an instance of named_arrays.AbstractScalarArray.
like (None | Self) – Optional reference object. If provided, the result will be defined by this object.

Return type:

Self

index(value, axis=None)#

Parameters:

self (Self)
value (Self)
axis (None | str | Sequence[str])

Return type:

dict[str, Self]

index_secant(value, axis=None)#

Parameters:

self (Self)
value (Self)
axis (None | str | Sequence[str])

Return type:

dict[str, Self]

interp_linear(item)#

Parameters:: item (dict[str, AbstractArray])
Return type:: FunctionArray

max(axis=None, initial=<no value>, where=<no value>)#

Parameters:

self (Self)
axis (None | str | Sequence[str])
initial (_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes])
where (Self)

Return type:

Self

mean(axis=None, where=<no value>)#

Parameters:

self (Self)
axis (None | str | Sequence[str])
where (Self)

Return type:

Self

median(axis=None)#

Parameters:: axis (None | str | Sequence[str])

min(axis=None, initial=<no value>, where=<no value>)#

Parameters:

self (Self)
axis (None | str | Sequence[str])
initial (_SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes])
where (Self)

Return type:

Self

ndindex(axis_ignored=None)#

Parameters:

self (Self)
axis_ignored (None | str | Sequence[str])

Return type:

Iterator[dict[str, int]]

pcolormesh(axs, input_component_x, input_component_y, input_component_row=None, input_component_column=None, index=None, output_component_color=None, **kwargs)#

Plot a FunctionArray via matplotlib.pyplot.pcolormesh().

FunctionArray.pcolormesh() takes in an axes object, or array of axes objects, along with components to be plotted along the x and y plot axes (input_component_x and input_component_y). Additional components can be tiled along subplot row/column and are specified in input_component_row and input_component_column.

import named_arrays as na
import numpy as np
import astropy.units as u
import matplotlib.pyplot as plt

position = na.Cartesian2dVectorLinearSpace(
    start=-10,
    stop=10,
    axis=na.Cartesian2dVectorArray(
        x='position_x',
        y='position_y',
    ),
    num=21,
) * u.m

x_width = 5 * u.m
y_width = 2 * u.m
velocity = 1 * u.m/u.s
time = na.ScalarLinearSpace(
    start=0 * u.s,
    stop=3 * u.s,
    num=4,
    axis='time'
)

intensity = np.exp(-(((position.x + velocity*time)/x_width) ** 2 + ((position.y + 2*velocity*time)/y_width)** 2))
scene = na.FunctionArray(
    inputs=position,
    outputs=intensity,
)

fig, axs = plt.subplots(
    nrows=scene.outputs.shape['time'],
    squeeze=False,
    sharex=True,
    subplot_kw=dict(aspect='equal'),
)
scene.pcolormesh(
    axs=axs,
    input_component_x='x',
    input_component_y='y',
    input_component_row='time',
)

Parameters:

axs (ndarray)
input_component_x (str)
input_component_y (str)
input_component_row (None | str)
input_component_column (None | str)
index (None | dict[str, int])
output_component_color (None | str)
kwargs (Any)

percentile(q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False)#

Parameters:

self (Self)
q (int | float | Quantity | Self)
axis (None | str | Sequence[str])
out (None | Self)
overwrite_input (bool)
method (str)
keepdims (bool)

ptp(axis=None)#

Parameters:

self (Self)
axis (None | str | Sequence[str])

Return type:

Self

regrid(inputs, axis=None, method='multilinear', weights=None)#

Resample this function array onto a new set of input coordinates using named_arrays.regridding.regrid().

Parameters:

inputs (AbstractArray) – The new input coordinates on which to resample the outputs.
axis (None | str | tuple[str]) – The logical axes of the input over which to resample.
method (Literal['multilinear', 'conservative']) – The resampling method to use.
weights (None | tuple[AbstractScalar, dict[str, int], dict[str, int]]) – Optional weights which can be computed in advance using weights() to greatly speed repeated resampling of the same inputs.

Return type:

Self

Level_1#

This Page