Transformations

In DASCore, transformations are operations which change the units of a patch. Transforms can be found in the transform module or accessed as Patch methods.

Discrete Fourier Transforms

The Discrete Fourier Transform (dft) is commonly used in many signal processing workflows. DASCore implements this as the dft patch method.

import numpy as np
import dascore as dc

# Get example patch, set unit to velocity (for demonstration)
patch = dc.get_example_patch().set_units("m/s")

transformed = patch.dft(dim="time")

# Note how the dimension name has changed
print(f"old_dims: {patch.dims} new dims: {transformed.dims}")

# As have the units
old_units = patch.attrs.data_units
new_units = transformed.attrs.data_units
print(f"old units: {old_units}, new units: {new_units}")

old_dims: ('distance', 'time') new dims: ('distance', 'ft_time')
old units: 1.0 m / s, new units: 1 m

Note

The transformed dimension names change; “time” becomes “ft_time” indicating the domain of the dimension has changed. The units are also updated. See the note on Fourier transforms in DASCore for more details.

In many cases, it is advantageous to only calculate the fourier transform corresponding to the positive frequencies (since the Fourier transform of a real signal is symmetric).

# Transform distance axis to Fourier domain using real fourier transform
real_transform = patch.dft(dim='distance', real=True)
print(real_transform.get_coord("ft_distance"))

CoordRange( min: 0.0 max: 0.5 step: 0.00333 shape: (151,) dtype: float64 units: 1 / m )

The Inverse Discrete Fourier Transform idft undoes the transformation.

Short Time Fourier Transform

Related to the Discrete Fourier Transform, the Short Term Fourier Transform is useful for analyzing the time-dependent frequency content. DASCore implements this as stft and the corresponding istft.

import numpy as np
import dascore as dc
from dascore.units import second, percent

# Get example patch, set unit to velocity (for demonstration)
patch = (
    dc.get_example_patch("chirp", channel_count=3)
    .set_units("m/s")
)

patch.viz.waterfall();

# Perform the transform, visualize the amplitude spectra, for the first
# channel then invert.
transformed = (
    patch.stft(time=1*second, overlap=50*percent)
)
inverse =  transformed.istft()

transformed.abs().select(distance=0, samples=True).squeeze().viz.waterfall();