DASPy-toolbox 1.0.0__py3-none-any.whl

daspy/basic_tools/preprocessing.py

@@ -0,0 +1,238 @@
+# Purpose: Some preprocess methods
+# Author: Minzhe Hu
+# Date: 2024.10.25
+# Email: hmz2018@mail.ustc.edu.cn
+import numpy as np
+from scipy.signal import detrend
+from scipy.signal.windows import tukey
+from daspy.basic_tools.filter import lowpass_cheby_2
+
+
+def phase2strain(data, lam, e, n, gl):
+    """
+    Convert the optical phase shift in radians to strain.
+
+    :param data: numpy.ndarray. Data to convert.
+    :param lam: float. Operational optical wavelength in vacuum.
+    :param e: float. photo-slastic scaling factor for logitudinal strain in
+        isotropic material.
+    :param n: float. Refractive index of the sensing fiber.
+    :paran gl: float. Gauge length.
+    :return: Strain data.
+    """
+    return data * (lam * 1e-9) / (e * 4 * np.pi * n * gl)
+
+
+def normalization(data, method='z-score'):
+    """
+    Normalize for each individual channel using Z-score method.
+
+    :param data: numpy.ndarray. Data to normalize.
+    :param method: str. Method for normalization, should be one of 'max',
+        'z-score', or 'one-bit'.
+    :return: Normalized data.
+    """
+    if data.ndim == 1:
+        data = data.reshape(1, len(data))
+    elif data.ndim != 2:
+        raise ValueError("Data should be 1-D or 2-D array")
+
+    if method == 'max':
+        amp = np.max(abs(data), 1, keepdims=True)
+        amp[amp == 0] = amp[amp > 0].min()
+        return data / amp
+
+    if method == 'z-score':
+        mean = np.mean(data, axis=1, keepdims=True)
+        std = np.std(data, axis=1, keepdims=True)
+        std[std == 0] = std[std > 0].min()
+        return (data - mean) / std
+
+    if method == 'one-bit':
+        return np.sign(data)
+
+
+def demeaning(data):
+    """
+    Demean signal by subtracted mean of each channel.
+
+    :param data: numpy.ndarray. Data to demean.
+    :return: Detrended data.
+    """
+    return detrend(data, type='constant')
+
+
+def detrending(data):
+    """
+    Detrend signal by subtracted a linear least-squares fit to data.
+
+    :param data: numpy.ndarray. Data to detrend.
+    :return: Detrended data.
+    """
+    return detrend(data, type='linear')
+
+
+def stacking(data: np.ndarray, N: int, step: int = None, average: bool = False):
+    """
+    Stack several channels to increase the signal-noise ratio(SNR).
+
+    :param data: numpy.ndarray. Data to stack.
+    :param N: int. N adjacent channels stacked into 1.
+    :param step: int. Interval of data stacking.
+    :param average: bool. True for calculating the average.
+    :return: Stacked data.
+    """
+    if N == 1:
+        return data
+    if step is None:
+        step = N
+    nch, nt = data.shape
+    begin = np.arange(0, nch - N + 1, step)
+    end = begin + N
+    nx1 = len(begin)
+    data_stacked = np.zeros((nx1, nt))
+    for i in range(nx1):
+        data_stacked[i, :] = np.sum(data[begin[i]:end[i], :], axis=0)
+    if average:
+        data_stacked /= N
+    return data_stacked
+
+
+def cosine_taper(data, p=0.1):
+    """
+    Taper using Tukey window.
+
+    :param data: numpy.ndarray. Data to taper.
+    :param p: float or sequence of floats. Each float means decimal percentage
+        of Tukey taper for corresponding dimension (ranging from 0 to 1).
+        Default is 0.1 which tapers 5% from the beginning and 5% from the end.
+        If only one float is given, it only do for time dimension.
+    :return: Tapered data.
+    """
+    if len(data.shape) == 1:
+        return data * tukey(len(data), p)
+    nch, nt = data.shape
+    win = np.ones_like(data)
+    if not isinstance(p, (tuple, list, np.ndarray)):
+        p = (0, p)
+
+    win *= np.tile(tukey(nch, p[0]), (nt, 1)).T
+    win *= np.tile(tukey(nt, p[1]), (nch, 1))
+    return data * win
+
+
+def downsampling(data, xint=None, tint=None, stack=True, lowpass_filter=True):
+    """
+    Downsample DAS data.
+
+    :param data: numpy.ndarray. Data to downsample can be 1-D or 2-D.
+    :param xint: int. Spatial downsampling factor.
+    :param tint: int. Time downsampling factor.
+    :param lowpass_filter: bool. Lowpass cheby2 filter before time downsampling
+        or not.
+    :return: Downsampled data.
+    """
+    data_ds = data.copy()
+    if xint and xint > 1:
+        if stack:
+            data_ds = stacking(data, xint)
+        else:
+            data_ds = data_ds[::xint]
+    if tint and tint > 1:
+        if lowpass_filter:
+            data_ds = lowpass_cheby_2(data_ds, 1, 1 / 2 / tint)
+        if len(data_ds.shape) == 1:
+            data_ds = data_ds[::tint]
+        else:
+            data_ds = data_ds[:, ::tint]
+    return data_ds
+
+
+def trimming(data, dx=None, fs=None, xmin=0, xmax=None, tmin=0, tmax=None,
+             mode=0):
+    """
+    Cut data to given start and end distance/channel or time/sampling points.
+
+    :param data: numpy.ndarray. Data to trim can be 1-D or 2-D.
+    :param dx: Channel interval in m.
+    :param fs: Sampling rate in Hz.
+    :param xmin, xmax, tmin, tmax: Boundary for trimming.
+    :param mode: 0 means the unit of boundary is channel number and sampling
+        points; 1 means the unit of boundary is meters and seconds.
+    :return: Trimmed data.
+    """
+    nch, nt = data.shape
+    if mode == 0:
+        if xmax is None:
+            xmax = nch
+        if tmax is None:
+            tmax = nt
+    elif mode == 1:
+        xmin = round(xmin / dx)
+        xmax = (round(xmax / dx), nch)[xmax is None]
+        tmin = round(tmin * fs)
+        tmax = (round(tmax * fs), nt)[tmax is None]
+
+    return data[xmin:xmax, tmin:tmax]
+
+
+def padding(data, dn, reverse=False):
+    """
+    Pad DAS data with 0.
+
+    :param data: numpy.ndarray. 2D DAS data to pad.
+    :param dn: int or sequence of ints. Number of points to pad for both
+        dimensions.
+    :param reverse: bool. Set True to reverse the operation.
+    :return: Padded data.
+    """
+    nch, nt = data.shape
+    if isinstance(dn, int):
+        dn = (dn, dn)
+
+    pad = (dn[0] // 2, dn[0] - dn[0] // 2, dn[1] // 2, dn[1] - dn[1] // 2)
+    if reverse:
+        return data[pad[0]:nch - pad[1], pad[2]:nt - pad[3]]
+    else:
+        data_pd = np.zeros((nch + dn[0], nt + dn[1]))
+        data_pd[pad[0]:nch + pad[0], pad[2]:nt + pad[2]] = data
+        return data_pd
+
+
+def time_integration(data, fs, c=0):
+    """
+    Integrate DAS data in time.
+
+    :param data: numpy.ndarray. 2D DAS data.
+    :param fs: Sampling rate in Hz.
+    :param c: float. A constant added to the result.
+    :return: Integrated data.
+    """
+    return np.cumsum(data, axis=1) / fs + c
+
+
+def time_differential(data, fs, prepend=0):
+    """
+    Differentiate DAS data in time.
+
+    :param data: numpy.ndarray. 2D DAS data.
+    :param fs: Sampling rate in Hz.
+    :param prepend: 'mean' or values to prepend to `data` along axis prior to
+        performing the difference. 
+    :return: Differentiated data.
+    """
+    if prepend == 'mean':
+        prepend = np.mean(data, axis=1).reshape((-1, 1))
+    return np.diff(data, axis=1, prepend=prepend) * fs
+
+
+def distance_integration(data, dx, c=0):
+    """
+    Integrate DAS data in distance.
+
+    :param data: numpy.ndarray. 2D DAS data.
+    :param dx: Channel interval in m.
+    :param c: float. A constant added to the result.
+    :return: Integrated data.
+    """
+    return np.cumsum(data, axis=1) * dx + c

daspy/basic_tools/visualization.py

@@ -0,0 +1,186 @@
+# Purpose: Plot data
+# Author: Minzhe Hu
+# Date: 2024.10.17
+# Email: hmz2018@mail.ustc.edu.cn
+import numpy as np
+import matplotlib.pyplot as plt
+from copy import deepcopy
+from collections.abc import Sequence
+
+
+def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=150,
+         title=None, transpose=False, t0=0, x0=0, pick=None, f=None, k=None,
+         t=None, c=None, cmap=None, vmin=None, vmax=None, xmode='distance',
+         tmode='time', xlim=None, ylim=None, xlog=False, ylog=False, xinv=False,
+         yinv=False, xlabel=True, ylabel=True, xticklabels=True,
+         yticklabels=True, colorbar=True, colorbar_label=None, savefig=None):
+    """
+    Plot several types of 2-D seismological data.
+
+    :param data: numpy.ndarray. Data to plot.
+    :param dx: Channel interval in m.
+    :param fs: Sampling rate in Hz.
+    :param ax: Matplotlib.axes.Axes or tuple. Axes to plot. A tuple for new
+        figsize. If not specified, the function will directly display the image
+        using matplotlib.pyplot.show().
+    :param obj: str. Type of data to plot. It should be one of 'waveform',
+        'phasepick', 'spectrum', 'spectrogram', 'fk', or 'dispersion'.
+    :param dpi: int. The resolution of the figure in dots-per-inch.
+    :param title: str. The title of this axes.
+    :param transpose: bool. Transpose the figure or not.
+    :param t0, x0: The beginning of time and space.
+    :param pick: Sequence of picked phases. Required if obj=='phasepick'.
+    :param f: Sequence of frequency. Required if obj is one of 'spectrum',
+        'spectrogram', 'fk' or 'dispersion'.
+    :param k: Wavenumber sequence. Required if obj=='fk'.
+    :param t: Time sequence. Required if obj=='spectrogram'.
+    :param c: Phase velocity sequence. Required if obj=='dispersion'.
+    :param cmap: str or Colormap. The Colormap instance or registered colormap
+        name used to map scalar data to colors.
+    :param vmin, vmax: Define the data range that the colormap covers.
+    :param xmode: str. 'distance' or 'channel'.
+    :param tmode: str. 'time' or 'sampling'.
+    :param xlim, ylim: Set the x-axis and y-axis view limits.
+    :param xlog, ylog: bool. If True, set the x-axis' or y-axis' scale as log.
+    :param xlabel, yinv: bool. If True, invert x-axis or y-axis.
+    :param xlabel, ylabel: bool or str. Whether to plot a label or what label to
+        plot for x-axis or y-axis.
+    :param xticklabels, yticklabels: bool or sequence of str. Whether to plot
+        ticklabels or what ticklabels to plot for x-axis or y-axis.
+    :param colorbar: bool, str or Matplotlib.axes.Axes. Bool means plot colorbar
+        or not. Str means the location of colorbar. Axes means the Axes into
+        which the colorbar will be drawn.
+    :param savefig: str or bool. Figure name to save if needed. If True,
+        it will be set to parameter obj.
+    """
+    nch, nt = data.shape
+    if ax is None:
+        ax = (6, 5)
+    if isinstance(ax, tuple):
+        fig, ax = plt.subplots(1, figsize=ax, dpi=dpi)
+        show = True
+    else:
+        show = False
+
+    if obj in ['waveform', 'phasepick']:
+        cmap = 'RdBu' if cmap is None else cmap
+        vmax = np.percentile(abs(data), 80) if vmax is None else vmax
+        vmin = -vmax if vmin is None else vmin
+        origin = 'upper'
+        if fs is None or tmode == 'sampling':
+            ylabel_default = 'Sampling points'
+            fs = 1
+        elif tmode == 'time':
+            ylabel_default = 'Time (s)'
+
+        if dx is None or xmode.lower() == 'channel':
+            xlabel_default = 'Channel'
+            extent = [x0, x0 + nch, t0 + nt / fs, t0]
+        elif xmode.lower() == 'distance':
+            xlabel_default = 'Disitance (km)'
+            extent = [x0 * 1e-3, (x0 + nch * dx) * 1e-3, t0 + nt / fs, t0]
+
+        if obj == 'phasepick' and len(pick):
+            pck = np.array(pick).astype(float)
+            if xmode.lower() == 'distance':
+                pck[:, 0] = (x0 + pck[:, 0] * dx) * 1e-3
+            elif xmode.lower() == 'channel':
+                pck[:, 0] = x0 + pck[:, 0]
+            if tmode.lower() == 'sampling':
+                pck[:, 1] = pck[:, 1] / fs
+            ax.scatter(pck[:,0], t0 + pck[:,1], marker=',', s=0.1, c='black')
+
+    elif obj in ['spectrum', 'spectrogram', 'fk', 'dispersion']:
+        if isinstance(data[0,0], (complex, np.complex64)):
+            data = abs(data)
+        cmap = 'jet' if cmap is None else cmap
+        vmax = np.percentile(abs(data), 80) if vmax is None else vmax
+        vmin = np.percentile(abs(data), 20) if vmin is None else vmin
+        if obj == 'spectrum':
+            origin = 'lower'
+            if dx is None or xmode.lower() == 'channel':
+                xlabel_default = 'Channel'
+                extent = [x0, x0 + nch, min(f), max(f)]
+            elif xmode.lower() == 'distance':
+                xlabel_default = 'Disitance (km)'
+                extent = [x0 * 1e-3, (x0 + nch * dx) * 1e-3, min(f), max(f)]
+            ylabel_default = 'Frequency (Hz)'
+        elif obj == 'spectrogram':
+            data = data.T
+            origin = 'lower'
+            xlabel_default = 'Time (s)'
+            ylabel_default = 'Frequency (Hz)'
+            extent = [t0 + min(t), t0 + max(t), min(f), max(f)]
+        elif obj == 'fk':
+            origin = 'lower'
+            xlabel_default = 'Wavenumber (m$^{-1}$)'
+            ylabel_default = 'Frequency (Hz)'
+            extent = [min(k), max(k), min(f), max(f)]
+        elif obj == 'dispersion':
+            data = data.T
+            origin = 'lower'
+            xlabel_default = 'Frequency (Hz)'
+            ylabel_default = 'Phase Velocity (m/s)'
+            extent = [min(f), max(f), min(c), max(c)]
+
+    if transpose:
+        if origin == 'lower':
+            extent = [extent[2], extent[3], extent[0], extent[1]]
+        else:
+            origin = 'lower'
+            extent = [extent[3], extent[2], extent[0], extent[1]]
+        (xlabel_default, ylabel_default) = (ylabel_default, xlabel_default)
+        data = data.T
+
+    xlabel = xlabel if isinstance(xlabel, str) else \
+            xlabel_default if xlabel else None
+    ylabel = ylabel if isinstance(ylabel, str) else \
+            ylabel_default if ylabel else None
+
+    bar = ax.imshow(data.T, vmin=vmin, vmax=vmax, extent=extent, aspect='auto',
+                    origin=origin, cmap=cmap)
+    if title:
+        ax.set_title(title)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    if isinstance(xticklabels, Sequence):
+        ax.set_xticklabels(xticklabels)
+    elif not xticklabels:
+        ax.set_xticklabels([])
+    
+    if isinstance(yticklabels, Sequence):
+        ax.set_yticklabels(yticklabels)
+    elif not yticklabels:
+        ax.set_yticklabels([])
+    if xinv:
+        ax.invert_xaxis()
+    if yinv:
+        ax.invert_yaxis()
+    if ylim:
+        ax.set_ylim(ylim)
+    if xlim:
+        ax.set_xlim(xlim)
+    if xlog:
+        ax.set_xscale('log')
+    if ylog:
+        ax.set_yscale('log')
+    if colorbar:
+        if colorbar is True:
+            cbar = plt.colorbar(bar, ax=ax, location='right')
+        elif isinstance(colorbar, str):
+            cbar = plt.colorbar(bar, ax=ax, location=colorbar)
+        else:
+            cbar = plt.colorbar(bar, cax=colorbar)
+        if colorbar_label is not None:
+            cbar.set_label(colorbar_label)
+
+    if savefig:
+        if not isinstance(savefig, str):
+            savefig = obj + '.png'
+        plt.tight_layout()
+        plt.savefig(savefig)
+        plt.close()
+    elif show:
+        plt.show()
+    else:
+        return ax

daspy/core/__init__.py

@@ -0,0 +1,4 @@
+from daspy.core.section import Section
+from daspy.core.collection import Collection
+from daspy.core.read import read
+from daspy.core.dasdatetime import DASDateTime, local_tz, utc