Data

              flowchart TD
              pypalmsens.data.ArrayType[ArrayType]

              

              click pypalmsens.data.ArrayType href "" "pypalmsens.data.ArrayType"
            

Data array type for standard arrays.

Attributes:

• Admittance –

  Admittance.

• AuxInput –

  Auxillary input.

• BipotCurrent –

  Bipot current.

• BipotPotential –

  Bipot potential.

• CEPotential –

  CE potential.

• Charge –

  Charge.

• Concentration –

  Concentration.

• Cs –

  Cs.

• CsIm –

  Cs imaginary.

• CsRe –

  Cs real.

• Current –

  Current / μA.

• CurrentExtraWE –

  Current setpoint measured back on WE.

• DCCurrent –

  DC current.

• Eac –

  E AC values.

• ExtraValue –

  ExtraValue.

• ForwardCurrent –

  Forward current.

• Frequency –

  Frequency.

• Func –

  Func.

• Iac –

  I AC values.

• Index –

  Index.

• Integral –

  Integral.

• InverseDerative_dtdE –

  Inverse derivative dt/dE.

• MeasuredStepStartIndex –

  MeasuredStepStartIndex.

• Phase –

  Phase.

• Potential –

  Potential / V.

• PotentialExtraRE –

  Potential setpoint measured back on RE.

• ReverseCurrent –

  Reverse current.

• SE2vsXPotential –

  SE2 vs XPotential.

• Signal –

  Signal.

• Time –

  Time / s.

• Unspecified –

  Unspecified.

• Y –

  Y.

• YIm –

  Y imaginary.

• YRe –

  Y real.

• Z –

  Z.

• ZIm –

  Z imaginary.

• ZRe –

  Z real.

• mEdc –

  Measured applied DC.

• miDC –

  Measured I DC values.

Admittance = 18

AuxInput = 23

BipotCurrent = 24

BipotPotential = 25

CEPotential = 27

Charge = 3

Concentration = 19

Cs = 14

CsIm = 16

CsRe = 15

Current = 2

CurrentExtraWE = 31

DCCurrent = 28

Eac = 34

ExtraValue = 4

ForwardCurrent = 29

Frequency = 5

Func = 21

Iac = 9

Index = 17

Integral = 22

InverseDerative_dtdE = 32

MeasuredStepStartIndex = 35

Phase = 6

Potential = 1

PotentialExtraRE = 30

ReverseCurrent = 26

SE2vsXPotential = 37

Signal = 20

Time = 0

Unspecified = -1

Y = 11

YIm = 13

YRe = 12

Z = 10

ZIm = 8

ZRe = 7

mEdc = 33

miDC = 36

Data returned by the new data callback.

Methods:

• last_datapoint –

  Return last measured data point.

• new_datapoints –

  Return new data points since last callback.

Attributes:

• index (int) –

  Index of last point.

• start (int) –

  Start index for the new data.

• x_array (DataArray) –

  Data array for the x variable.

• y_array (DataArray) –

  Data array for the y variable.

index: int

start: int

x_array: DataArray

y_array: DataArray

last_datapoint() -> dict[str, float]

41
42
43
44
45
46
47

def last_datapoint(self) -> dict[str, float]:
    """Return last measured data point."""
    return {
        'index': self.index,
        'x': self.x_array[-1],
        'y': self.y_array[-1],
    }

new_datapoints() -> Generator[dict[str, float]]

49
50
51
52
53
54
55
56

def new_datapoints(self) -> Generator[dict[str, float]]:
    """Return new data points since last callback."""
    for i in range(self.start, self.index + 1):
        yield {
            'x': self.x_array[i],
            'y': self.y_array[i],
            'index': i,
        }

Data returned by the EIS new data callback.

Methods:

• last_datapoint –

  Return last measured data point.

• new_datapoints –

  Return new data points since last callback.

Attributes:

• data (DataSet) –

  EIS dataset.

• index (int) –

  Index of last point.

• start (int) –

  Start index for the new data.

data: DataSet

index: int

start: int

last_datapoint() -> dict[str, float]

78
79
80
81
82

def last_datapoint(self) -> dict[str, float]:
    """Return last measured data point."""
    ret = {array.name: array[-1] for array in self.data.arrays()}
    ret['index'] = self.index
    return ret

new_datapoints() -> Generator[dict[str, float]]

84
85
86
87
88
89

def new_datapoints(self) -> Generator[dict[str, float]]:
    """Return new data points since last callback."""
    for i in range(self.start, self.index + 1):
        ret = {array.name: array[i] for array in self.data.arrays()}
        ret['index'] = i
        yield ret

Current reading data class.

Attributes:

• current (float) –

  current in μA.

• current_in_range (float) –

  Raw current value expressed in the active current range.

• current_range (AllowedCurrentRanges) –

  Active current range for this data point.

• reading_status (AllowedReadingStatus) –

  Status of the current reading.

• timing_status (AllowedTimingStatus) –

  Status of the current timing.

current: float

current_in_range: float

current_range: AllowedCurrentRanges

reading_status: AllowedReadingStatus

timing_status: AllowedTimingStatus

Python wrapper for .NET Curve class.

Parameters:

• pscurve

  (Curve) –

  Reference to .NET curve object.

Methods:

• clear_peaks –

  Clear peaks stored on object.

• copy –

  Return a copy of this curve.

• find_peaks –

  Find peaks in a curve in all directions.

• find_peaks_semiderivative –

  Find peaks in a curve using the semi-derivative algorithm.

• linear_slope –

  Calculate linear line parameters for this curve between two indexes.

• plot –

  Generate simple plot for this curve using matplotlib.

• savitsky_golay –

  Smooth the .y_array using a Savitsky-Golay filter with the specified window

• smooth –

  Smooth the .y_array using a Savitsky-Golay filter with the specified smooth

Attributes:

• max_x (float) –

  Maximum X value found in this curve.

• max_y (float) –

  Maximum Y value found in this curve.

• min_x (float) –

  Minimum X value found in this curve.

• min_y (float) –

  Minimum Y value found in this curve.

• mux_channel (int) –

  The corresponding MUX channel number with the curve starting at 0.

• n_points (int) –

  Number of points for this curve.

• ocp_value (float) –

  OCP value for curve.

• peaks (list[Peak]) –

  Return peaks stored on object.

• reference_electrode_name (None | str) –

  The name of the reference electrode. Return None if not set.

• reference_electrode_potential (None | str) –

  The reference electrode potential offset. Return None if not set.

• title (str) –

  Title for the curve.

• x_array (DataArray) –

  Y data for the curve.

• x_label (str) –

  Label for X dimension.

• x_unit (str) –

  Units for X dimension.

• y_array (DataArray) –

  Y data for the curve.

• y_label (str) –

  Label for Y dimension.

• y_unit (str) –

  Units for Y dimension.

• z_label (None | str) –

  Units for Z dimension. Returns None if not set.

• z_unit (None | str) –

  Units for Z dimension. Returns None if not set.

27
28

def __init__(self, *, pscurve: PSCurve):
    self._pscurve = pscurve

max_x: float

max_y: float

min_x: float

min_y: float

mux_channel: int

n_points: int

ocp_value: float

peaks: list[Peak]

reference_electrode_name: None | str

reference_electrode_potential: None | str

title: str

x_array: DataArray

x_label: str

x_unit: str

y_array: DataArray

y_label: str

y_unit: str

z_label: None | str

z_unit: None | str

clear_peaks()

240
241
242

def clear_peaks(self):
    """Clear peaks stored on object."""
    self._pscurve.ClearPeaks()

copy() -> Curve

34
35
36

def copy(self) -> Curve:
    """Return a copy of this curve."""
    return Curve(pscurve=PSCurve(self._pscurve, cloneData=True))

find_peaks(min_peak_width: float = 0.1, min_peak_height: float = 0.0, peak_shoulders: bool = False, merge_overlapping_peaks: bool = True) -> list[Peak]

 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101

def find_peaks(
    self,
    min_peak_width: float = 0.1,
    min_peak_height: float = 0.0,
    peak_shoulders: bool = False,
    merge_overlapping_peaks: bool = True,
) -> list[Peak]:
    """Find peaks in a curve in all directions.

    CV can have 1 or 2 direction changes.

    Parameters
    ----------
    min_peak_width : float
        Minimum width of the peak in V
    min_peak_height : float
        Minimum height of the peak in uA
    peak_shoulders : bool, optional
        Use alternative peak search algorithm optimized for finding peaks on slopes
    merge_overlapping_peaks : bool, optional
        Two or more peaks that overlap will be identified as a single
        base peak and as shoulder peaks on the base peak.

    Returns
    -------
    peak_list : list[Peak]
    """
    pspeaks = self._pscurve.FindPeaks(
        minPeakWidth=min_peak_width,
        minPeakHeight=min_peak_height,
        peakShoulders=peak_shoulders,
        mergeOverlappingPeaks=merge_overlapping_peaks,
    )

    peaks_list = [Peak(pspeak=peak) for peak in pspeaks]

    return peaks_list

find_peaks_semiderivative(min_peak_height: float = 0.0) -> list[Peak]

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

def find_peaks_semiderivative(
    self,
    min_peak_height: float = 0.0,
) -> list[Peak]:
    """
    Find peaks in a curve using the semi-derivative algorithm.

    Used for detecting non-overlapping peaks in LSV and CV curves.
    The peaks are also assigned to the curve, updating `Curve.peaks`.
    Existing peaks are overwritten.

    For more info, see this
    [Wikipedia page](https://en.wikipedia.org/wiki/Neopolarogram).

    Parameters
    ----------
    min_peak_height : float
        Minimum height of the peak in uA

    Returns
    -------
    peak_list : list[Peak]
    """
    dct = System.Collections.Generic.Dictionary[PSCurve, System.Double]()
    dct[self._pscurve] = min_peak_height

    pd = PSAnalysis.SemiDerivativePeakDetection()
    pd.GetNonOverlappingPeaks(dct)

    return self.peaks

linear_slope(start: None | int = None, stop: None | int = None) -> tuple[float, float, float]

254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

def linear_slope(
    self, start: None | int = None, stop: None | int = None
) -> tuple[float, float, float]:
    """Calculate linear line parameters for this curve between two indexes.

    current = a + b * x

    Parameters
    ----------
    start : int, optional
        begin index
    stop : int, optional
        end index

    Returns
    -------
    a : float
    b : float
    coefdet : float
        Coefficient of determination (R2)
    """
    if start and stop:
        return self._pscurve.LLS(start, stop)
    else:
        return self._pscurve.LLS()

plot(ax: None | Axes = None, legend: bool = True, **plot_kwargs) -> Figure | SubFigure

280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318

def plot(
    self,
    ax: None | axes.Axes = None,
    legend: bool = True,
    **plot_kwargs,
) -> figure.Figure | figure.SubFigure:
    """Generate simple plot for this curve using matplotlib.

    Parameters
    ----------
    ax : Optional[axes.Axes]
        Add plot to this ax if specified.
    legend : bool
        If True, add legend.
    plot_kwargs
        These keyword arguments are passed to `ax.plot`.

    Returns
    -------
    fig : fig.Figure
        Matplotlib figure. Use `fig.show()` to render plot.
    """
    import matplotlib.pyplot as plt

    if not ax:
        fig, ax = plt.subplots()

    _ = ax.plot(self.x_array, self.y_array, label=self.title, **plot_kwargs)
    _ = ax.set_xlabel(f'{self.x_label} ({self.x_unit})')
    _ = ax.set_ylabel(f'{self.y_label} ({self.y_unit})')

    if peaks := self.peaks:
        x, y = list(zip(*((peak.x, peak.y) for peak in peaks)))
        _ = ax.scatter(x, y, label='Peaks')

    if legend:
        _ = ax.legend()

    return ax.figure

savitsky_golay(window_size: int = 3)

52
53
54
55
56
57
58
59
60
61
62
63

def savitsky_golay(self, window_size: int = 3):
    """Smooth the .y_array using a Savitsky-Golay filter with the specified window
    size.

    (i.e. window size 2 will filter points based on the values of the next/previous 2 points)

    Parameters
    ----------
    window_size : int
        Size of the window
    """
    self._pscurve.SavitskyGolay(windowSize=window_size)

smooth(smooth_level: int = 0)

38
39
40
41
42
43
44
45
46
47
48
49
50

def smooth(self, smooth_level: int = 0):
    """Smooth the .y_array using a Savitsky-Golay filter with the specified smooth
    level.

    Parameters
    ----------
    smooth_level : int
        The smooth level to be used. -1 = none, 0 = no smooth (spike rejection only),
        1 = 5 points, 2 = 9 points, 3 = 15 points, 4 = 25 points
    """
    success = self._pscurve.Smooth(smoothLevel=smooth_level)
    if not success:
        raise ValueError('Something went wrong.')

              flowchart TD
              pypalmsens.data.DataArray[DataArray]

              

              click pypalmsens.data.DataArray href "" "pypalmsens.data.DataArray"
            

Python wrapper for .NET DataArray class.

Parameters:

• psarray

  (DataArray) –

  Reference to .NET DataArray object.

Methods:

• as_current_range –

  Return current range as list of strings.

• as_reading_status –

  Return reading status as list of strings.

• as_timing_status –

  Return timing status as list of strings.

• copy –

  Return a copy of the array.

• max –

  Return max value.

• min –

  Return min value.

• savitsky_golay –

  Smooth the array using a Savitsky-Golay filter with the window size.

• to_list –

  Export data array to list.

• to_numpy –

  Export data array to numpy.

Attributes:

• name (str) –

  Name of the array.

• ocp_value (float) –

  OCP Value.

• quantity (str) –

  Quantity for array.

• type (ArrayType) –

  ArrayType enum.

• unit (str) –

  Unit for array.

32
33

def __init__(self, *, psarray: PSDataArray):
    self._psarray: PSDataArray = psarray

name: str

ocp_value: float

quantity: str

type: ArrayType

unit: str

as_current_range() -> list[AllowedCurrentRanges]

125
126
127
128
129
130
131
132
133

def as_current_range(self) -> list[AllowedCurrentRanges]:
    """Return current range as list of strings."""
    if self.type is not ArrayType.Current:
        raise ValueError(f'Invalid array type: {self.type}, expected: {ArrayType.Current}')

    clr_type = clr.GetClrType(CurrentReading)
    field_info = clr_type.GetField('CurrentRange')

    return [cr_enum_to_string(field_info.GetValue(val)) for val in self._psarray]

as_reading_status() -> list[AllowedReadingStatus]

135
136
137
138
139
140
141
142
143

def as_reading_status(self) -> list[AllowedReadingStatus]:
    """Return reading status as list of strings."""
    if self.type is not ArrayType.Current:
        raise ValueError(f'Invalid array type: {self.type}, expected: {ArrayType.Current}')

    clr_type = clr.GetClrType(CurrentReading)
    field_info = clr_type.GetField('ReadingStatus')

    return [field_info.GetValue(val).ToString() for val in self._psarray]

as_timing_status() -> list[AllowedTimingStatus]

145
146
147
148
149
150
151
152
153

def as_timing_status(self) -> list[AllowedTimingStatus]:
    """Return timing status as list of strings."""
    if self.type is not ArrayType.Current:
        raise ValueError(f'Invalid array type: {self.type}, expected: {ArrayType.Current}')

    clr_type = clr.GetClrType(CurrentReading)
    field_info = clr_type.GetField('TimingStatus')

    return [field_info.GetValue(val).ToString() for val in self._psarray]

copy() -> DataArray

64
65
66

def copy(self) -> DataArray:
    """Return a copy of the array."""
    return DataArray(psarray=self._psarray.Clone())

max() -> float

72
73
74

def max(self) -> float:
    """Return max value."""
    return self._psarray.MaxValue

min() -> float

68
69
70

def min(self) -> float:
    """Return min value."""
    return self._psarray.MinValue

savitsky_golay(window_size: int = 3) -> DataArray

76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

def savitsky_golay(self, window_size: int = 3) -> DataArray:
    """Smooth the array using a Savitsky-Golay filter with the window size.

    (i.e. window size 2 will filter points based on the values of the next/previous 2 points)

    Parameters
    ----------
    window_size : int
        Size of the window
    """
    new = self.copy()
    success = new._psarray.Smooth(window_size, False)
    if not success:
        raise ValueError('Something went wrong.')
    return new

to_list() -> list[float]

101
102
103

def to_list(self) -> list[float]:
    """Export data array to list."""
    return list(self._psarray.GetValues())

to_numpy() -> ndarray

97
98
99

def to_numpy(self) -> np.ndarray:
    """Export data array to numpy."""
    return np.array(self._psarray.GetValues())

              flowchart TD
              pypalmsens.data.DataSet[DataSet]

              

              click pypalmsens.data.DataSet href "" "pypalmsens.data.DataSet"
            

Python wrapper for .NET DataSet class.

Parameters:

• psdataset

  (DataSet) –

  Reference to .NET DataSet object.

Methods:

• arrays –

  Return list of all arrays. Alias for .to_list()

• arrays_by_name –

  Get arrays by name.

• arrays_by_quantity –

  Get arrays by quantity.

• arrays_by_type –

  Get arrays by data type.

• aux_input_arrays –

  Return all AuxInput arrays.

• current_arrays –

  Return all Current arrays.

• current_range –

  Return current range as list of strings.

• curve –

  Construct a custom curve from x and y keys.

• freq_arrays –

  Return all Frequency arrays.

• hidden_arrays –

  Return 'hidden' arrays used for debugging.

• potential_arrays –

  Return all Potential arrays.

• reading_status –

  Return reading status as list of strings.

• time_arrays –

  Return all Time arrays.

• timing_status –

  Return timing status as list of strings.

• to_dataframe –

  Return dataset as pandas dataframe.

• zim_arrays –

  Return all ZIm arrays.

• zre_arrays –

  Return all ZRe arrays.

Attributes:

• array_names (set[str]) –

  Return unique set of names for arrays in dataset.

• array_quantities (set[str]) –

  Return unique set of quantities for arrays in dataset.

• array_types (set[ArrayType]) –

  Return unique set of array type (enum) for arrays in dataset.

• n_points (int) –

  Number of points in arrays.

54
55
56

def __init__(self, *, psdataset: PSDataSet):
    self._psdataset = psdataset
    self._mapping = _dataset_to_mapping_with_unique_keys(psdataset)

array_names: set[str]

array_quantities: set[str]

array_types: set[ArrayType]

n_points: int

arrays() -> list[DataArray]

119
120
121

def arrays(self) -> list[DataArray]:
    """Return list of all arrays. Alias for `.to_list()`"""
    return list(self.values())

arrays_by_name(name: str) -> list[DataArray]

127
128
129
130
131
132
133
134
135
136
137
138
139

def arrays_by_name(self, name: str) -> list[DataArray]:
    """Get arrays by name.

    Parameters
    ----------
    name : str
        Name of the array.

    Returns
    -------
    arrays : list[DataArray]
    """
    return self._filter(key=lambda array: array.name == name)

arrays_by_quantity(quantity: str) -> list[DataArray]

141
142
143
144
145
146
147
148
149
150
151
152
153

def arrays_by_quantity(self, quantity: str) -> list[DataArray]:
    """Get arrays by quantity.

    Parameters
    ----------
    quantity : str
        Quantity of the array.

    Returns
    -------
    arrays : list[DataArray]
    """
    return self._filter(key=lambda array: array.quantity == quantity)

arrays_by_type(array_type: ArrayType) -> list[DataArray]

155
156
157
158
159
160
161
162
163
164
165
166
167

def arrays_by_type(self, array_type: ArrayType) -> list[DataArray]:
    """Get arrays by data type.

    Parameters
    ----------
    array_type : str
        Type of the array.

    Returns
    -------
    arrays : list[DataArray]
    """
    return self._filter(key=lambda array: array.type == array_type)

aux_input_arrays() -> list[DataArray]

208
209
210

def aux_input_arrays(self) -> list[DataArray]:
    """Return all AuxInput arrays."""
    return self.arrays_by_type(ArrayType.AuxInput)

current_arrays() -> list[DataArray]

184
185
186

def current_arrays(self) -> list[DataArray]:
    """Return all Current arrays."""
    return self.arrays_by_type(ArrayType.Current)

current_range() -> list[AllowedCurrentRanges]

212
213
214
215

def current_range(self) -> list[AllowedCurrentRanges]:
    """Return current range as list of strings."""
    array = self.current_arrays()[-1]
    return array.as_current_range()

curve(x: str, y: str, title: str | None = None) -> Curve

 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

def curve(self, x: str, y: str, title: str | None = None) -> Curve:
    """Construct a custom curve from x and y keys.

    Parameters
    ----------
    x : str
        Key identifying the x array
    y : str
        Key identifying the y array
    title : str
        Set the title. If None, use the $x-$y as title

    Returns
    -------
    curve : Curve
        New Curve with plotting x against y
    """
    xarray = self[x]
    yarray = self[y]

    if not title:
        title = f'{x}-{y}'

    pscurve = PSCurve(xarray._psarray, yarray._psarray, title=title)

    return Curve(pscurve=pscurve)

freq_arrays() -> list[DataArray]

196
197
198

def freq_arrays(self) -> list[DataArray]:
    """Return all Frequency arrays."""
    return self.arrays_by_type(ArrayType.Frequency)

hidden_arrays() -> list[DataArray]

123
124
125

def hidden_arrays(self) -> list[DataArray]:
    """Return 'hidden' arrays used for debugging."""
    return [DataArray(psarray=psarray) for psarray in self._psdataset if psarray.Hidden]

potential_arrays() -> list[DataArray]

188
189
190

def potential_arrays(self) -> list[DataArray]:
    """Return all Potential arrays."""
    return self.arrays_by_type(ArrayType.Potential)

reading_status() -> list[AllowedReadingStatus]

217
218
219
220

def reading_status(self) -> list[AllowedReadingStatus]:
    """Return reading status as list of strings."""
    array = self.current_arrays()[-1]
    return array.as_reading_status()

time_arrays() -> list[DataArray]

192
193
194

def time_arrays(self) -> list[DataArray]:
    """Return all Time arrays."""
    return self.arrays_by_type(ArrayType.Time)

timing_status() -> list[AllowedTimingStatus]

222
223
224
225

def timing_status(self) -> list[AllowedTimingStatus]:
    """Return timing status as list of strings."""
    array = self.current_arrays()[-1]
    return array.as_timing_status()

to_dataframe() -> DataFrame

227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

def to_dataframe(self) -> pd.DataFrame:
    """Return dataset as pandas dataframe.

    Requires pandas.

    Returns
    -------
    df : pd.DataFrame
        pandas dataframe with all arrays in dataset
    """
    import pandas as pd

    cols, arrays = zip(*[(key, arr.to_list()) for key, arr in self.items() if len(arr)])

    arrays_list = list(arrays)
    arrays_list.append(self.current_range())
    arrays_list.append(self.reading_status())

    cols_list = list(cols)
    cols_list.append('CR')
    cols_list.append('ReadingStatus')

    df = pd.DataFrame(arrays_list, index=cols_list).T

    return df

zim_arrays() -> list[DataArray]

204
205
206

def zim_arrays(self) -> list[DataArray]:
    """Return all ZIm arrays."""
    return self.arrays_by_type(ArrayType.ZIm)

zre_arrays() -> list[DataArray]

200
201
202

def zre_arrays(self) -> list[DataArray]:
    """Return all ZRe arrays."""
    return self.arrays_by_type(ArrayType.ZRe)

Dataclass for device information.

Attributes:

• firmware (str) –

  Firmware version.

• id (int) –

  Device ID.

• serial (str) –

  Serial number.

• type (str) –

  Device type.

firmware: str

id: int

serial: str

type: str

Python wrapper for .NET EISdata class.

Parameters:

• pseis

  (EISData) –

  Reference to .NET EISdata object.

Methods:

• arrays –

  Complete list of data arrays.

• current_range –

  Current ranges for the measurement.

• get_data_for_frequency –

  Returns dictionary with data per frequency.

Attributes:

• cdc (str) –

  Gets the CDC circuit for fitting.

• cdc_values (list[float]) –

  Return values for circuit description code (CDC).

• dataset (DataSet) –

  Dataset which contains multiple arrays of values.

• frequency_type (str) –

  Frequency type.

• has_subscans (bool) –

  Return True if data contains subscans.

• mux_channel (int) –

  Mux channel.

• n_frequencies (int) –

  Number of frequencies.

• n_points (int) –

  Number of points (including subscans).

• n_subscans (int) –

  Number of subscans.

• ocp_value (float) –

  OCP Value.

• scan_type (str) –

  Scan type.

• subscans (list[EISData]) –

  Get list of subscans.

• title (str) –

  Tite for EIS data.

• x_quantity (str) –

  Quantity for array.

• x_unit (str) –

  Unit for array.

79
80

def __init__(self, *, pseis: PSEISData):
    self._pseis = pseis

cdc: str

cdc_values: list[float]

dataset: DataSet

frequency_type: str

has_subscans: bool

mux_channel: int

n_frequencies: int

n_points: int

n_subscans: int

ocp_value: float

scan_type: str

subscans: list[EISData]

title: str

x_quantity: str

x_unit: str

arrays() -> list[DataArray]

181
182
183

def arrays(self) -> list[DataArray]:
    """Complete list of data arrays."""
    return list(self.dataset.values())

current_range() -> list[AllowedCurrentRanges]

185
186
187
188
189

def current_range(self) -> list[AllowedCurrentRanges]:
    """Current ranges for the measurement."""
    return [
        cr_enum_to_string(self._pseis.GetCurrentRange(val)) for val in range(self.n_points)
    ]

get_data_for_frequency(frequency: int) -> dict[str, DataArray]

160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

def get_data_for_frequency(self, frequency: int) -> dict[str, DataArray]:
    """Returns dictionary with data per frequency.

    Parameters
    ----------
    frequency : int
        Index of the frequency to retrieve the data for.

    Returns
    -------
    dict[str, DataArray]
        Data are returned as a dictionary keyed by the data type.
    """
    if not (0 <= frequency < self.n_frequencies):
        raise ValueError(f'Frequency must be between 0 and {self.n_frequencies}')

    return {
        str(row.Key): DataArray(psarray=row.Value)
        for row in self._pseis.GetDataArrayVsX(frequency)
    }

Python wrapper for .NET Measurement class.

Parameters:

• psmeasurement

  (Measurement) –

  Reference to .NET measurement object.

Attributes:

• blank_curve (Curve | None) –

  Blank curve.

• channel (float) –

  Get the channel that the measurement was measured on.

• curves (list[Curve]) –

  Get all curves in measurement.

• dataset (DataSet) –

  Dataset containing multiple arrays of values.

• device (DeviceInfo) –

  Return dataclass with measurement device information.

• eis_data (list[EISData]) –

  EIS data in measurement.

• eis_fit (list[FitResult]) –

  Get all EIS fits from measurement

• has_blank_subtracted_curves (bool) –

  Return True if the curve collection contains a blank subtracted curve.

• has_eis_data (bool) –

  Return True if EIS data are is available.

• method (Method) –

  Method related with this Measurement.

• n_curves (int) –

  Number of curves that are part of the Measurement class.

• n_eis_data (int) –

  Number of EISdata curves (channels) that are part of the Measurement class.

• ocp_value (float) –

  First OCP Value from either curves or EISData.

• peaks (list[Peak]) –

  Get peaks from all curves.

• timestamp (str) –

  Date and time of the start of this measurement.

• title (str) –

  Title for the measurement.

53
54

def __init__(self, *, psmeasurement: PSMeasurement):
    self._psmeasurement = psmeasurement

blank_curve: Curve | None

channel: float

curves: list[Curve]

dataset: DataSet

device: DeviceInfo

eis_data: list[EISData]

eis_fit: list[FitResult]

has_blank_subtracted_curves: bool

has_eis_data: bool

method: Method

n_curves: int

n_eis_data: int

ocp_value: float

peaks: list[Peak]

timestamp: str

title: str