Frequency Series

Overview

FrequencySeries

Light wrapper of gwpy's FrequencySeries for compatibility and future extension.

FrequencySeries Class

class gwexpy.frequencyseries.FrequencySeries(*args: Any, **kwargs: Any)

Bases: PlotMixin, SignalAnalysisMixin, RegularityMixin, FittingMixin, StatisticalMethodsMixin, FrequencySeries

Light wrapper of gwpy’s FrequencySeries for compatibility and future extension.

Methods

ifft	Inverse FFT returning a gwexpy TimeSeries, supporting transient round-trip.
idct	Compute the Inverse Discrete Cosine Transform (IDCT).
rms	Compute the Root Mean Square (RMS) value.
abs	Return the absolute value of the data in this Array.
angle	Calculate the phase angle of this FrequencySeries.
phase	Calculate the phase of this FrequencySeries.
filter	Apply a filter to this FrequencySeries.

phase(unwrap: bool = False) → FrequencySeries

Calculate the phase of this FrequencySeries.

Parameters:

unwrap (bool, optional) – If True, unwrap the phase to remove discontinuities. Default is False.

Returns:

The phase of the series, in radians.

Return type:

FrequencySeries

angle(unwrap: bool = False) → FrequencySeries

Calculate the phase angle of this FrequencySeries.

Alias for phase(unwrap=unwrap).

Parameters:

unwrap (bool, optional) – If True, unwrap the phase to remove discontinuities. Default is False.

Returns:

The phase of the series, in radians.

Return type:

FrequencySeries

histogram(bins=None, range=None, weights=None, density=False, **kwargs)

Compute a histogram of the values in this FrequencySeries.

Useful for analyzing the distribution of spectral density levels.

Parameters:

• bins (int or sequence or str, optional) – Binning specification (passed to np.histogram).

• range ((float, float), optional) – The lower and upper range of the bins.

• weights (array_like, optional) – Weights for each sample.

• density (bool, optional) – If True, return a probability density histogram.

• **kwargs – Additional arguments passed to np.histogram.

Returns:

A gwexpy.histogram.Histogram object.

Return type:

Histogram

degree(unwrap: bool = False) → FrequencySeries

Calculate the phase of this FrequencySeries in degrees.

Parameters:

unwrap (bool, optional) – If True, unwrap the phase before converting to degrees.

Returns:

The phase of the series, in degrees.

Return type:

FrequencySeries

differentiate(order: int = 1) → FrequencySeries

Differentiate the FrequencySeries in the frequency domain.

Multiplies by (i * 2 * pi * f)^order.

Parameters:

order (int, optional) – Order of differentiation. Default is 1.

Returns:

The differentiated series.

Return type:

FrequencySeries

integrate(order: int = 1) → FrequencySeries

Integrate the FrequencySeries in the frequency domain.

Divides by (i * 2 * pi * f)^order.

Parameters:

order (int, optional) – Order of integration. Default is 1.

Returns:

The integrated series.

Return type:

FrequencySeries

to_db(ref: Any = 1.0, amplitude: bool = True) → FrequencySeries

Convert this series to decibels.

Parameters:

• ref (float or Quantity, optional) – Reference value for 0 dB. Default is 1.0.

• amplitude (bool, optional) – If True (default), treat data as amplitude (20 * log10). If False, treat data as power (10 * log10).

Returns:

The series in dB.

Return type:

FrequencySeries

filterba(*args, **kwargs)

Apply a [b, a] filter to this FrequencySeries. Inherited from gwpy.

to_pandas(index: Literal['frequency'] = 'frequency', *, name: str | None = None, copy: bool = False) → Any

Convert to pandas.Series.

classmethod from_pandas(series: Any, **kwargs: Any) → Any

Create FrequencySeries from pandas.Series.

to_polars(name: str | None = None, as_dataframe: bool = True, frequencies: str = 'frequency') → Any

Convert this series to a polars.DataFrame or polars.Series.

Parameters:

• name (str, optional) – Name for the polars Series/Column.

• as_dataframe (bool, default True) – If True, returns a DataFrame with a ‘frequency’ column. If False, returns a raw Series of values.

• frequencies (str, default "frequency") – Name of the frequency column (only if as_dataframe=True).

Return type:

polars.DataFrame or polars.Series

classmethod from_polars(data: Any, frequencies: str | None = 'frequency', **kwargs: Any) → Any

Create a FrequencySeries from a polars.DataFrame or polars.Series.

Parameters:

• data (polars.DataFrame or polars.Series) – Input data.

• frequencies (str, optional) – If data is a DataFrame, name of the column to use as frequency.

• **kwargs – Additional arguments passed to frequency series constructor.

Return type:

FrequencySeries

to_tgraph(error: Any | None = None) → Any

Convert to ROOT TGraph or TGraphErrors.

to_th1d(error: Any | None = None) → Any

Convert to ROOT TH1D.

classmethod from_root(obj: Any, return_error: bool = False, **kwargs: Any) → Any

Create FrequencySeries from ROOT TGraph or TH1.

to_xarray(freq_coord: Literal['Hz'] = 'Hz') → Any

Convert to xarray.DataArray.

classmethod from_xarray(da: Any, **kwargs: Any) → Any

Create FrequencySeries from xarray.DataArray.

to_hdf5_dataset(group: Any, path: str, *, overwrite: bool = False, compression: str | None = None, compression_opts: Any = None) → Any

Write to HDF5 dataset within a group.

classmethod from_hdf5_dataset(group: Any, path: str) → Any

Read FrequencySeries from HDF5 dataset.

ifft(*, mode: str = 'auto', trim: bool = True, original_n: int | None = None, pad_left: int | None = None, pad_right: int | None = None, **kwargs: Any) → Any

Inverse FFT returning a gwexpy TimeSeries, supporting transient round-trip.

Parameters:

• mode ({"auto", "gwpy", "transient"}) – auto: use transient restoration if _gwex_fft_mode==”transient” is detected, otherwise GWpy compatible.

• trim (bool) – Whether to remove padding and trim to original length during transient mode.

• original_n (int, optional) – Explicitly specify the length after restoration (takes priority).

• pad_right (int, optional) – Specify padding lengths for transient mode to override defaults.

• pad_left (int, optional) – Specify padding lengths for transient mode to override defaults.

idct(type: int = 2, norm: str = 'ortho', *, n: int | None = None) → Any

Compute the Inverse Discrete Cosine Transform (IDCT).

Reconstructs a time-domain signal from DCT coefficients.

Parameters:

• type (int, optional) – DCT type (1, 2, 3, or 4). Should match the type used for the forward DCT. Default is 2.

• norm (str, optional) – Normalization mode: ‘ortho’ for orthonormal, None for standard. Default is ‘ortho’.

• n (int, optional) – Length of the output time series. If None, uses the stored original_n attribute if available.

Returns:

The reconstructed time series.

Return type:

TimeSeries

Notes

For a proper roundtrip, use the same type and norm as the forward DCT transform.

Examples

>>> fs = FrequencySeries(dct_coeffs, ...)
>>> ts = fs.idct()

differentiate_time() → Any

Apply time differentiation in frequency domain.

Multiplies by (2 * pi * i * f). Converting Displacement -> Velocity -> Acceleration.

Return type:

FrequencySeries

integrate_time() → Any

Apply time integration in frequency domain.

Divides by (2 * pi * i * f). Converting Acceleration -> Velocity -> Displacement.

Return type:

FrequencySeries

quadrature_sum(other: Any) → Any

Compute sqrt(self^2 + other^2) assuming checking independence.

Operates on magnitude. Phase information is lost (returns real).

Parameters:

other (FrequencySeries) – The other series to add.

Returns:

Magnitude combined series.

Return type:

FrequencySeries

group_delay() → Any

Calculate the group delay of the series.

Group delay is defined as -d(phase)/d(omega), where omega = 2 * pi * f. It represents the time delay of the envelope of a signal at a given frequency.

Returns:

A new FrequencySeries representing the group delay in seconds.

Return type:

FrequencySeries

rebin(width: float | Quantity) → FrequencySeries

Rebin the FrequencySeries to a new resolution.

Parameters:

width (float or Quantity) – New bin width in Hz.

Returns:

The rebinned series.

Return type:

FrequencySeries

to_control_frd(frequency_unit: Literal['rad/s', 'Hz'] = 'Hz') → Any

Convert to control.FRD.

classmethod from_control_frd(frd: Any, *, frequency_unit: Literal['Hz', 'rad/s'] = 'Hz') → Any

Create from control.FRD.

classmethod from_finesse_frequency_response(sol: Any, *, output: Any | None = None, input_dof: Any | None = None, unit: Any | None = None) → Any

Create from finesse FrequencyResponseSolution.

Parameters:

• sol (finesse.analysis.actions.lti.FrequencyResponseSolution) – The frequency response solution from a Finesse 3 simulation.

• output (str or object, optional) – Output DOF name. Combined with input_dof to select one transfer function.

• input_dof (str or object, optional) – Input DOF name.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data.

Return type:

FrequencySeries or FrequencySeriesMatrix

classmethod from_finesse_noise(sol: Any, *, output: Any | None = None, noise: str | None = None, unit: Any | None = None) → Any

Create from finesse NoiseProjectionSolution.

Parameters:

• sol (finesse.analysis.actions.noise.NoiseProjectionSolution) – The noise projection solution from a Finesse 3 simulation.

• output (str or object, optional) – Output node name.

• noise (str, optional) – Specific noise source name.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data (e.g., "m/sqrt(Hz)").

Return type:

FrequencySeries or FrequencySeriesDict

classmethod from_pyspice_ac(analysis: Any, *, node: str | None = None, branch: str | None = None, unit: Any | None = None) → Any

Create from a PySpice AcAnalysis.

Parameters:

• analysis (PySpice.Spice.Simulation.AcAnalysis) – The AC analysis result from a PySpice simulation.

• node (str, optional) – Node name to extract. If None and branch is also None, all signals are returned as a FrequencySeriesDict.

• branch (str, optional) – Branch name to extract.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the result.

Return type:

FrequencySeries or FrequencySeriesDict

classmethod from_pyspice_noise(analysis: Any, *, node: str | None = None, unit: Any | None = None) → Any

Create from a PySpice NoiseAnalysis.

Parameters:

• analysis (PySpice.Spice.Simulation.NoiseAnalysis) – The noise analysis result from a PySpice simulation.

• node (str, optional) – Node name to extract (e.g. "onoise"). If None, all signals are returned as a FrequencySeriesDict.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the result.

Return type:

FrequencySeries or FrequencySeriesDict

classmethod from_pyspice_distortion(analysis: Any, *, node: str | None = None, unit: Any | None = None) → Any

Create from a PySpice DistortionAnalysis.

Parameters:

• analysis (PySpice.Spice.Simulation.DistortionAnalysis) – The distortion analysis result from a PySpice simulation.

• node (str, optional) – Node name to extract. If None, all signals are returned as a FrequencySeriesDict.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the result.

Return type:

FrequencySeries or FrequencySeriesDict

classmethod from_skrf_network(ntwk: Any, *, parameter: str = 's', port_pair: tuple[int, int] | None = None, unit: Any | None = None) → Any

Create from a scikit-rf Network.

Parameters:

• ntwk (skrf.Network) – The scikit-rf Network object.

• parameter (str, default "s") – Which network parameter to extract ("s", "z", "y", "a", "t", or "h").

• port_pair (tuple[int, int], optional) – Zero-based (row, col) port indices. If None, 1-port networks return a FrequencySeries and multi-port networks return a FrequencySeriesMatrix.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the result.

Return type:

FrequencySeries or FrequencySeriesMatrix

to_skrf_network(*, parameter: str = 's', z0: float = 50.0, port_names: list[str] | None = None, name: str | None = None) → Any

Convert to a scikit-rf Network.

Parameters:

• parameter (str, default "s") – Network parameter the data represents.

• z0 (float, default 50.0) – Reference impedance in Ohms.

• port_names (list[str], optional) – Names for each port.

• name (str, optional) – Name for the resulting Network.

Return type:

skrf.Network

to_torch(device: str | None = None, dtype: Any = None, requires_grad: bool = False, copy: bool = False) → Any

Convert to torch.Tensor.

Parameters:

• device (str or torch.device, optional) – Target device (e.g. ‘cpu’, ‘cuda’).

• dtype (torch.dtype, optional) – Target data type. Defaults to preserving complex64/128 or float32/64.

• requires_grad (bool, optional) – If True, enable gradient tracking.

• copy (bool, optional) – If True, force a copy of the data.

Return type:

torch.Tensor

classmethod from_torch(tensor: Any, frequencies: Any, unit: Any | None = None) → Any

Create FrequencySeries from torch.Tensor.

Parameters:

• tensor (torch.Tensor) – Input tensor.

• frequencies (Array or Quantity) – Frequency array matching the tensor size.

• unit (Unit or str, optional) – Data unit.

Return type:

FrequencySeries

to_tensorflow(dtype: Any = None) → Any

Convert to tensorflow.Tensor.

Return type:

tensorflow.Tensor

classmethod from_tensorflow(tensor: Any, frequencies: Any, unit: Any | None = None) → Any

Create FrequencySeries from tensorflow.Tensor.

to_jax(dtype: Any = None) → Any

Convert to JAX array.

Return type:

jax.Array

classmethod from_jax(array: Any, frequencies: Any, unit: Any | None = None) → Any

Create FrequencySeries from JAX array.

to_cupy(dtype: Any = None) → Any

Convert to CuPy array.

Return type:

cupy.ndarray

classmethod from_cupy(array: Any, frequencies: Any, unit: Any | None = None) → Any

Create FrequencySeries from CuPy array.

to_quantities(units: str | None = None) → Any

Convert to quantities.Quantity (Elephant/Neo compatible).

Parameters:

units (str or quantities.UnitQuantity, optional) – Target units.

Return type:

quantities.Quantity

classmethod from_quantities(q: Any, frequencies: Any) → Any

Create FrequencySeries from quantities.Quantity.

Parameters:

• q (quantities.Quantity) – Input data.

• frequencies (array-like) – Frequencies corresponding to the data.

Return type:

FrequencySeries

to_mne(info: Any | None = None) → Any

Convert to MNE-Python object.

Parameters:

info (mne.Info, optional) – MNE Info object.

Return type:

mne.time_frequency.SpectrumArray

classmethod from_mne(spectrum: Any, **kwargs: Any) → Any

Create FrequencySeries from MNE-Python Spectrum object.

Parameters:

• spectrum (mne.time_frequency.Spectrum) – Input spectrum data.

• **kwargs – Additional arguments passed to constructor.

Return type:

FrequencySeries or FrequencySeriesDict

to_obspy(**kwargs: Any) → Any

Convert to Obspy Trace.

Return type:

obspy.Trace

classmethod from_obspy(trace: Any, **kwargs: Any) → Any

Create FrequencySeries from Obspy Trace.

Parameters:

• trace (obspy.Trace) – Input trace.

• **kwargs – Additional arguments.

Return type:

FrequencySeries

to_simpeg(location=None, rx_type='PointElectricField', orientation='x', **kwargs) → Any

Convert to SimPEG Data object.

Parameters:

• location (array_like, optional) – Rx location (x, y, z). Default is [0, 0, 0].

• rx_type (str, optional) – Receiver class name. Default “PointElectricField”.

• orientation (str, optional) – Receiver orientation (‘x’, ‘y’, ‘z’). Default ‘x’.

Return type:

simpeg.data.Data

classmethod from_simpeg(data_obj: Any, **kwargs: Any) → Any

Create FrequencySeries from SimPEG Data object.

Parameters:

data_obj (simpeg.data.Data) – Input SimPEG Data.

Return type:

FrequencySeries

to_specutils(**kwargs)

Convert to specutils.Spectrum1D.

Parameters:

**kwargs – Arguments passed to Spectrum1D constructor.

Return type:

specutils.Spectrum1D

classmethod from_specutils(spectrum, **kwargs)

Create FrequencySeries from specutils.Spectrum1D.

Parameters:

spectrum (specutils.Spectrum1D) – Input spectrum.

Return type:

FrequencySeries

to_pyspeckit(**kwargs)

Convert to pyspeckit.Spectrum.

Parameters:

**kwargs – Arguments passed to pyspeckit.Spectrum constructor.

Return type:

pyspeckit.Spectrum

classmethod from_pyspeckit(spectrum, **kwargs)

Create FrequencySeries from pyspeckit.Spectrum.

Parameters:

spectrum (pyspeckit.Spectrum) – Input spectrum.

Return type:

FrequencySeries

DictClass

alias of FrequencySeriesDict

dt: Any

Module Contents

class gwexpy.frequencyseries.BifrequencyMap(data: QuantityLike, unit: UnitBase | str | None = None, x0: QuantityLike | None = None, dx: QuantityLike | None = None, xindex: QuantityLike | None = None, xunit: UnitBase | str | None = None, y0: QuantityLike | None = None, dy: QuantityLike | None = None, yindex: QuantityLike | None = None, yunit: UnitBase | str | None = None, **kwargs)

Bases: Array2D

2つの異なる周波数軸を持つマップ（応答関数や相関行列）クラス。

(行, 列) = (周波数2, 周波数1) としてデータを保持します。

convolute(input_spectrum, interpolate=True, fill_value=0)

Convolutes the map with an input spectrum (integration along f1).

Calculates:

S_out(f2) = integral( M(f2, f1) * S_in(f1) * df1 )

This is similar to propagate, but multiplies by the frequency bin width (df) to perform an integration rather than a simple sum.

Parameters:

• input_spectrum (FrequencySeries) – Input spectrum S_in(f1).

• interpolate (bool, optional) – If True, interpolates input spectrum to match map’s f1 axis. Default is True.

• fill_value (float, optional) – Fill value for interpolation. Default is 0.

Returns:

Output spectrum S_out(f2).

Return type:

FrequencySeries

crop(low=None, high=None, low2=None, high2=None) → BifrequencyMap

Crop this BifrequencyMap to a specific frequency range.

Parameters:

• low (float, u.Quantity, optional) – Lower bound for frequency1 (X/cols).

• high (float, u.Quantity, optional) – Upper bound for frequency1 (X/cols).

• low2 (float, u.Quantity, optional) – Lower bound for frequency2 (Y/rows). If None, uses low.

• high2 (float, u.Quantity, optional) – Upper bound for frequency2 (Y/rows). If None, uses high.

Returns:

cropped – The cropped map.

Return type:

BifrequencyMap

diagonal(method='mean', bins=None, absolute=False, **kwargs)

Calculates statistics along the diagonal axis (f2 - f1).

Parameters:

• method (str, optional) – Statistical method to use. Supported: ‘mean’, ‘median’, ‘max’, ‘min’, ‘std’, ‘rms’, ‘percentile’. Default is ‘mean’. All methods ignore NaNs in the data by default.

• bins (int or array-like, optional) – Number of bins or bin edges for the diagonal axis. If None (default), it is automatically determined based on the resolution of frequency axes (max(df1, df2)).

• absolute (bool, optional) – If True, calculates statistics along the absolute difference abs(f2 - f1). Default is False.

• **kwargs – Additional arguments passed to the statistical function. For ‘percentile’, use percentile=….

Returns:

The result of the diagonal projection.

Return type:

FrequencySeries

property frequency1

周波数軸 1 (X軸/Columns)

property frequency2

周波数軸 2 (Y軸/Rows)

classmethod from_points(data, f2, f1, **kwargs)

データと2つの周波数軸からインスタンスを生成します。

Parameters:

• data (array-like) – 形状が (len(f2), len(f1)) の2次元配列

• f2 (array-like) – 周波数軸 2（Y軸/行）

• f1 (array-like) – 周波数軸 1（X軸/列）

get_slice(at, axis='f1')

Extract a 1D slice (FrequencySeries) at a specific frequency on one axis.

Parameters:

• at (float or Quantity) – The frequency value to slice at.

• axis (str, optional) – The axis to slice along (‘f1’ or ‘f2’). ‘f1’: Fix f1=at, return spectrum along f2. ‘f2’: Fix f2=at, return spectrum along f1. Default is ‘f1’.

Returns:

The extracted 1D spectrum.

Return type:

FrequencySeries

inverse(rcond=None) → BifrequencyMap

Calculate the (pseudo-)inverse of the BifrequencyMap.

Parameters:

rcond (float or None) – Cutoff for small singular values. Same as np.linalg.pinv.

Returns:

inv_map – New BifrequencyMap instance representing the inverse matrix.

Return type:

BifrequencyMap

plot(method='imshow', **kwargs)

Plots the data.

Parameters:

• method (str, optional) – ‘imshow’ or ‘pcolormesh’. Default is ‘imshow’.

• **kwargs – Keywork arguments passed to the plotting method or Plot constructor.

plot_lines(xaxis='f1', color='f2', num_lines=None, ax=None, cmap=None, **kwargs)

Plot the map as a set of lines (1D spectra).

Parameters:

• xaxis (str, optional) – The x-axis definition for each line. - ‘f1’: Frequency 1. - ‘f2’: Frequency 2. - ‘diff’, ‘f2-f1’: Frequency 2 - Frequency 1. - ‘diff_inv’, ‘f1-f2’: Frequency 1 - Frequency 2. - ‘abs_diff’, '|f2-f1|': absolute value of (Frequency 2 - Frequency 1). Default is ‘f1’.

• color (str, optional) – The parameter to use for coloring the lines (and defining the slices). - ‘f2’ (default): Iterate over Frequency 2 (rows). Each line is a row at fixed f2. Color is f2. - ‘f1’: Iterate over Frequency 1 (columns). Each line is a column at fixed f1. Color is f1. - ‘diff’, ‘f2-f1’: (Not fully implemented for slicing) Ideally iterate over diagonals.

• num_lines (int, optional) – Maximum number of lines to plot. If None, plot all. Lines are subsampled uniformly if count exceeds num_lines.

• ax (matplotlib.axes.Axes, optional) – Axes to plot on. If None, a new figure is created.

• cmap (str or Colormap, optional) – Colormap to use.

• **kwargs – Additional arguments passed to LineCollection.

Returns:

The figure or axes where the plot was drawn.

Return type:

matplotlib.figure.Figure or matplotlib.axes.Axes

propagate(input_spectrum, interpolate=True, fill_value=0)

入力スペクトルに応答関数を適用し、出力スペクトルを計算します。

入力スペクトルの周波数軸がこのマップの軸1(xindex)と異なる場合、 自動的に線形補間を行って合わせることができます。

Parameters:

• input_spectrum (FrequencySeries) – 入力となるノイズスペクトル。

• interpolate (bool, optional) – Trueの場合、入力スペクトルの周波数軸をマップの軸1に合わせて補間します。 Falseの場合、サイズが一致していないとエラーになります。デフォルトは True。

• fill_value (float, optional) – 補間時に範囲外となった場合の埋め込み値。デフォルトは 0。

Returns:

軸2(frequency2)を持つ計算結果。

Return type:

FrequencySeries

class gwexpy.frequencyseries.SeriesType(value)

Bases: Enum

TIME = 'time'

FREQ = 'freq'

class gwexpy.frequencyseries.FrequencySeriesMatrix(data=None, frequencies=None, df=None, f0=None, **kwargs)

Bases: FrequencySeriesMatrixCoreMixin, FrequencySeriesMatrixAnalysisMixin, SeriesMatrix

2D Matrix container for multiple FrequencySeries objects sharing a common frequency axis.

This class represents a 2-dimensional array (rows x columns) where each element is a FrequencySeries. All elements in the matrix share the same frequency array (same f0, df, and number of frequency bins). It is typically used to represent multi-channel spectral data, such as CSD matrices or multi-channel PSDs.

Inherits from SeriesMatrix and returns FrequencySeries instances when indexed per-channel.

default_xunit = 'Hz'

default_yunit = None

dict_class

alias of FrequencySeriesDict

list_class

alias of FrequencySeriesList

series_class

alias of FrequencySeries

series_type = 'freq'

class gwexpy.frequencyseries.FrequencySeriesBaseDict(*args: Any, **kwargs: Any)

Bases: OrderedDict[str, _FS]

Ordered mapping container for FrequencySeries objects.

This is a lightweight GWpy-inspired container: - enforces EntryClass on insertion/update - provides map-style helpers (copy, crop, plot) - default values for setdefault() must be FrequencySeries (None not allowed)

Non-trivial operations (I/O, fetching, axis coercion, joins) are intentionally out-of-scope for this MVP.

EntryClass

alias of FrequencySeries

copy() → FrequencySeriesBaseDict[_FS]

crop(start: Any = None, end: Any = None, copy: bool = False) → FrequencySeriesBaseDict[_FS]

plot(label: str = 'key', method: str = 'plot', figsize: Any | None = None, **kwargs: Any)

Plot data.

Parameters:

• label (str, optional) –

  labelling method, one of

  • 'key': use dictionary key (default)

  • 'name': use name attribute of each item

• method (str, optional) – method of Plot to call, default: 'plot'

• figsize (tuple, optional) – (width, height) tuple in inches

• **kwargs – other keyword arguments passed to the plot method

plot_all(*args: Any, **kwargs: Any)

Alias for plot(). Plots all series in the dict.

classmethod read(source, *args, **kwargs)

Read data into a FrequencySeriesDict.

Parameters:

• source (str, file-like) – Source of data, either a file path or a file-like object.

• *args – Arguments passed to the underlying reader.

• **kwargs – Keyword arguments passed to the underlying reader.

Returns:

• FrequencySeriesDict – A new dict containing the data read from the source.

• The available built-in formats are

• ======= ==== ===== ============= – Format Read Write Auto-identify

• ======= ==== ===== ============= – li Yes No No lsf Yes No No mem Yes No No orf Yes No No sdb Yes No No

• taffmat Yes No No – wdf Yes No No

  win Yes No No

  win32 Yes No No

  wvf Yes No No

• ======= ==== ===== =============

setdefault(key: str, default: _FS | None = None) → _FS

property span

Frequency extent across all elements (based on xspan).

write(target, *args, **kwargs)

class gwexpy.frequencyseries.FrequencySeriesDict(*args: Any, **kwargs: Any)

Bases: DictMapMixin, FrequencySeriesBaseDict[FrequencySeries]

Ordered mapping of FrequencySeries objects keyed by label.

EntryClass

alias of FrequencySeries

angle(*args, **kwargs) → FrequencySeriesDict

Alias for phase(). Returns a new FrequencySeriesDict.

append(*args, **kwargs) → FrequencySeriesDict

Append to each FrequencySeries in the dict (in-place). Returns self.

apply_response(*args, **kwargs)

Apply response to each FrequencySeries.

crop(*args, **kwargs) → FrequencySeriesDict

Crop each FrequencySeries in the dict. In-place operation (GWpy-compatible). Returns self.

degree(*args, **kwargs)

Compute phase (in degrees) of each FrequencySeries.

differentiate_time(*args, **kwargs)

Apply time differentiation to each item.

filter(*args, **kwargs)

Apply filter to each FrequencySeries.

classmethod from_finesse_frequency_response(sol: Any, *, unit: Any | None = None) → FrequencySeriesDict

Create from finesse FrequencyResponseSolution.

Returns a dict keyed by "output -> input" for all DOF pairs.

Parameters:

• sol (finesse.analysis.actions.lti.FrequencyResponseSolution) – The frequency response solution from a Finesse 3 simulation.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data.

classmethod from_finesse_noise(sol: Any, *, output: Any | None = None, unit: Any | None = None) → FrequencySeriesDict

Create from finesse NoiseProjectionSolution.

Returns a dict keyed by "output: noise_source" strings.

Parameters:

• sol (finesse.analysis.actions.noise.NoiseProjectionSolution) – The noise projection solution from a Finesse 3 simulation.

• output (str or object, optional) – Output node name. If None, all outputs are included.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data (e.g., "m/sqrt(Hz)").

classmethod from_pyspice_ac(analysis: Any, *, unit: Any | None = None) → FrequencySeriesDict

Create from a PySpice AcAnalysis.

Returns a dict keyed by signal name for all nodes and branches.

Parameters:

• analysis (PySpice.Spice.Simulation.AcAnalysis) – The AC analysis result from a PySpice simulation.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data.

classmethod from_pyspice_noise(analysis: Any, *, unit: Any | None = None) → FrequencySeriesDict

Create from a PySpice NoiseAnalysis.

Returns a dict keyed by signal name for all noise nodes.

Parameters:

• analysis (PySpice.Spice.Simulation.NoiseAnalysis) – The noise analysis result from a PySpice simulation.

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data.

classmethod from_skrf_network(ntwk: Any, *, parameter: str = 's', unit: Any | None = None) → FrequencySeriesDict

Create from a scikit-rf Network.

Returns a dict keyed by port-pair labels (e.g. "S11", "S21").

Parameters:

• ntwk (skrf.Network) – The scikit-rf Network object.

• parameter (str, default "s") – Which network parameter to extract ("s", "z", "y", "a", "t", or "h").

• unit (str or astropy.units.Unit, optional) – Unit to assign to the data.

group_delay(*args, **kwargs)

Compute group delay of each item.

histogram(*args, **kwargs)

Compute Histogram for each FrequencySeries. Returns a HistogramDict.

ifft(*args, **kwargs)

Compute IFFT of each FrequencySeries. Returns a TimeSeriesDict.

integrate_time(*args, **kwargs)

Apply time integration to each item.

interpolate(*args, **kwargs)

Interpolate each FrequencySeries in the dict.

pad(*args, **kwargs)

Pad each FrequencySeries in the dict.

phase(*args, **kwargs)

Compute phase of each FrequencySeries.

prepend(*args, **kwargs) → FrequencySeriesDict

Prepend to each FrequencySeries in the dict (in-place). Returns self.

rebin(*args, **kwargs)

Rebin each FrequencySeries in the dict.

smooth(*args, **kwargs)

Smooth each FrequencySeries.

to_control_frd(*args, **kwargs)

Convert each item to control.FRD. Returns a dict.

to_cupy(*args, **kwargs)

Convert each item to cupy.ndarray. Returns a dict.

to_db(*args, **kwargs)

Convert each FrequencySeries to dB.

to_jax(*args, **kwargs)

Convert each item to jax.Array. Returns a dict.

to_matrix()

Convert this FrequencySeriesDict to a FrequencySeriesMatrix (Nx1).

to_pandas(**kwargs)

Convert to pandas.DataFrame. Keys become columns.

to_tensorflow(*args, **kwargs)

Convert each item to tensorflow.Tensor. Returns a dict.

to_tmultigraph(name: str | None = None) → Any

Convert to ROOT TMultiGraph.

to_torch(*args, **kwargs)

Convert each item to torch.Tensor. Returns a dict.

to_xarray()

Convert to xarray.Dataset. Keys become data variables.

write(target: str, *args: Any, **kwargs: Any) → Any

Write dict to file (HDF5, ROOT, etc.).

zpk(*args, **kwargs)

Apply ZPK filter to each FrequencySeries.

class gwexpy.frequencyseries.FrequencySeriesBaseList(*items: _FS | Iterable[_FS])

Bases: PlotMixin, list[_FS]

List container for FrequencySeries objects with type enforcement.

EntryClass

alias of FrequencySeries

append(item: _FS)

copy() → FrequencySeriesBaseList[_FS]

extend(items: Iterable[_FS]) → None

insert(index: int, item: _FS) → None

plot(**kwargs: Any) → Any

Plot this collection using gwexpy Plot.

plot_all(*args: Any, **kwargs: Any)

Alias for plot(). Plots all series.

classmethod read(source, *args, **kwargs)

Read data into a FrequencySeriesList.

Parameters:

• source (str, file-like) – Source of data, either a file path or a file-like object.

• *args – Arguments passed to the underlying reader.

• **kwargs – Keyword arguments passed to the underlying reader.

Returns:

A new list containing the data read from the source.

Return type:

FrequencySeriesList

property segments

Frequency spans of each element (xspan).

write(target, *args, **kwargs)

class gwexpy.frequencyseries.FrequencySeriesList(*items: _FS | Iterable[_FS])

Bases: ListMapMixin, FrequencySeriesBaseList[FrequencySeries]

List of FrequencySeries objects.

EntryClass

alias of FrequencySeries

angle(*args, **kwargs) → FrequencySeriesList

Alias for phase(). Returns a new FrequencySeriesList.

apply_response(*args, **kwargs)

Apply response to each FrequencySeries in the list.

crop(*args, **kwargs)

Crop each FrequencySeries in the list.

degree(*args, **kwargs)

Compute phase (in degrees) of each FrequencySeries.

differentiate_time(*args, **kwargs)

Apply time differentiation to each item.

filter(*args, **kwargs)

Apply filter to each FrequencySeries in the list.

group_delay(*args, **kwargs)

Compute group delay of each item.

histogram(*args, **kwargs)

Compute Histogram for each FrequencySeries. Returns a HistogramList.

ifft(*args, **kwargs)

Compute IFFT of each FrequencySeries. Returns a TimeSeriesList.

integrate_time(*args, **kwargs)

Apply time integration to each item.

interpolate(*args, **kwargs)

Interpolate each FrequencySeries in the list.

pad(*args, **kwargs)

Pad each FrequencySeries in the list.

phase(*args, **kwargs)

Compute phase of each FrequencySeries.

rebin(*args, **kwargs)

Rebin each FrequencySeries in the list.

smooth(*args, **kwargs)

Smooth each FrequencySeries.

to_control_frd(*args, **kwargs) → list

Convert each item to control.FRD. Returns a list of FRD objects.

to_cupy(*args, **kwargs) → list

Convert each item to cupy.ndarray. Returns a list of Arrays.

to_db(*args, **kwargs)

Convert each FrequencySeries to dB.

to_jax(*args, **kwargs) → list

Convert each item to jax.Array. Returns a list of Arrays.

to_pandas(**kwargs)

Convert to pandas.DataFrame. Columns are named by channel name or index.

to_tensorflow(*args, **kwargs) → list

Convert each item to tensorflow.Tensor. Returns a list of Tensors.

to_tmultigraph(name: str | None = None) → Any

Convert to ROOT TMultiGraph.

to_torch(*args, **kwargs) → list

Convert each item to torch.Tensor. Returns a list of Tensors.

to_xarray()

Convert to xarray.DataArray. Concatenates along a new dimension ‘channel’.

write(target: str, *args: Any, **kwargs: Any) → Any

Write list to file (HDF5, ROOT, etc.).

zpk(*args, **kwargs)

Apply ZPK filter to each FrequencySeries in the list.