DASPy-toolbox 1.1.6__tar.gz → 1.2.1__tar.gz

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/DASPy_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.6
+Version: 1.2.1
 Summary: DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing, which comprises classic seismic data processing techniques and Specialized algorithms for DAS applications.
 Home-page: https://github.com/HMZ-03/DASPy
 Author: Minzhe Hu, Zefeng Li

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/DASPy_toolbox.egg-info/SOURCES.txt

@@ -23,6 +23,8 @@ daspy/core/__init__.py
 daspy/core/collection.py
 daspy/core/dasdatetime.py
 daspy/core/example.pkl
+daspy/core/make_example.py
 daspy/core/read.py
 daspy/core/section.py
+daspy/core/util.py
 daspy/core/write.py

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.6
+Version: 1.2.1
 Summary: DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing, which comprises classic seismic data processing techniques and Specialized algorithms for DAS applications.
 Home-page: https://github.com/HMZ-03/DASPy
 Author: Minzhe Hu, Zefeng Li

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/daspy/advanced_tools/denoising.py

@@ -1,6 +1,6 @@
 # Purpose: Remove noise from data
 # Author: Minzhe Hu, Zefeng Li
-# Date: 2024.5.13
+# Date: 2025.9.18
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from copy import deepcopy
@@ -57,7 +57,7 @@ def common_mode_noise_removal(data, method='median'):
         common = np.mean(data, 0)
 
     xx = np.sum(common ** 2)
-    data_dn = np.zeros((nch, nt))
+    data_dn = np.zeros((nch, nt), dtype=data.dtype)
     for i in range(nch):
         xc = np.sum(common * data[i])
         data_dn[i] = data[i] - xc / xx * common

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/daspy/basic_tools/freqattributes.py

@@ -1,10 +1,10 @@
 # Purpose: Analyze frequency attribute and transform in frequency domain
 # Author: Minzhe Hu
-# Date: 2024.6.8
+# Date: 2024.6.17
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from numpy.fft import rfft, rfft2, fftshift, fftfreq, rfftfreq
-from scipy.signal import stft
+from scipy.signal import stft, welch
 from daspy.basic_tools.preprocessing import demeaning, detrending, cosine_taper
 
 
@@ -47,6 +47,38 @@ def spectrum(data, fs, taper=0.05, nfft='default'):
     return spec, f
 
 
+def psd(data, fs, nperseg=256, noverlap=None, nfft=None, detrend=False,
+        average='mean'):
+    """
+    Computes the power spectral density of the given data.
+
+    :param data: numpy.ndarray. Data to make spectrum of.
+    :param fs: Sampling rate in Hz.
+    :param nperseg: int. Length of each segment. Defaults to None, but if window
+        is str or tuple, is set to 256, and if window is array_like, is set to
+        the length of the window.
+    :param noverlap: int. Number of points to overlap between segments. If None,
+        noverlap = nperseg // 2. Defaults to None.
+    :param nfft: int. Length of the FFT used, if a zero padded FFT is desired.
+        If None, the FFT length is nperseg. Defaults to None.
+    :param detrend: str or bool. Specifies whether and how to detrend each
+        segment.  'linear' or 'detrend' or True = detrend, 'constant' or
+        'demean' = demean.
+    :param average: 'mean' or 'median. Method to use when averaging
+        periodograms. Defaults to 'mean'.
+    :return: Power spectral density or power spectrum and array of sample
+        frequencies.
+    """
+    if len(data.shape) == 1:
+        data = data.reshape(1, len(data))
+    elif len(data.shape) != 2:
+        raise ValueError("Data should be 1-D or 2-D array")
+
+    f, psd = welch(data, fs=fs, nperseg=nperseg, noverlap=noverlap,
+                       nfft=nfft, detrend=detrend, axis=1, average=average)
+    return psd, f
+
+
 def spectrogram(data, fs, nperseg=256, noverlap=None, nfft=None, detrend=False,
                 boundary='zeros'):
     """

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/daspy/basic_tools/preprocessing.py

@@ -1,8 +1,10 @@
 # Purpose: Some preprocess methods
 # Author: Minzhe Hu
-# Date: 2025.3.10
+# Date: 2025.10.30
 # Email: hmz2018@mail.ustc.edu.cn
+import warnings
 import numpy as np
+from numpy.fft import rfft, irfft, rfftfreq
 from scipy.signal import detrend
 from scipy.signal.windows import tukey
 from daspy.basic_tools.filter import lowpass_cheby_2
@@ -89,11 +91,11 @@ def stacking(data: np.ndarray, N: int, step: int = None, average: bool = True):
         return data
     if step is None:
         step = N
-    nch, nt = data.shape
+    nch, nsp = data.shape
     begin = np.arange(0, nch - N + 1, step)
     end = begin + N
     nx1 = len(begin)
-    data_stacked = np.zeros((nx1, nt))
+    data_stacked = np.zeros((nx1, nsp))
     for i in range(nx1):
         data_stacked[i, :] = np.sum(data[begin[i]:end[i], :], axis=0)
     if average:
@@ -115,9 +117,9 @@ def cosine_taper(data, p=0.1, side='both'):
     """
     if data.ndim == 1:
         data = data.reshape(1, -1)
-    nch, nt = data.shape
+    nch, nsp = data.shape
     if not isinstance(p, (tuple, list, np.ndarray)):
-        win = tukey(nt, p)
+        win = tukey(nsp, p)
         if side == 'left':
             win[round(nch/2):] = 1
         elif side == 'right':
@@ -125,7 +127,7 @@ def cosine_taper(data, p=0.1, side='both'):
         return data * np.tile(win, (nch, 1))
     else:
         if p[0] > 0:
-            data = data * np.tile(tukey(nch, p[0]), (nt, 1)).T
+            data = data * np.tile(tukey(nch, p[0]), (nsp, 1)).T
         return cosine_taper(data, p[1], side=side)
 
 
@@ -156,32 +158,144 @@ def downsampling(data, xint=None, tint=None, stack=True, lowpass_filter=True):
     return data_ds
 
 
-def trimming(data, dx=None, fs=None, xmin=0, xmax=None, tmin=0, tmax=None,
-             mode=0):
+def _trimming_index(nch, nsp, dx=None, fs=None, start_channel=0,
+                    start_distance=0, start_time=0, xmin=None, xmax=None,
+                    chmin=None, chmax=None, tmin=None, tmax=None, spmin=None,
+                    spmax=None):
+    assert None in [tmin, spmin], \
+        "Please do not set tmin and spmin at the same time."
+    assert None in [tmax, spmax], \
+        "Please do not set tmax and spmax at the same time."
+    assert None in [xmin, chmin], \
+        "Please do not set xmin and chmin at the same time."
+    assert None in [xmax, chmax], \
+        "Please do not set xmax and chmax at the same time."
+    if dx is None:
+        assert xmin is None and xmax is None, "Please set dx"
+    if fs is None:
+        assert tmin is None and tmax is None, "Please set fs"
+
+    if xmin is None:
+        if chmin is None:
+            i0 = 0
+        else:
+            i0 = int(chmin - start_channel)
+            if i0 < 0:
+                warnings.warn('chmin < start_channel . Set chmin to '
+                                'start_channel.')
+                i0 = 0
+            elif i0 >= nch:
+                raise ValueError('chmin >= end_channel.')
+    else:
+        i0 = round((xmin - start_distance) / dx)
+        if i0 < 0:
+            warnings.warn('xmin is smaller than start_distance. Set xmin '
+                            'to 0.')
+            i0 = 0
+        elif i0 >= nch:
+            raise ValueError('xmin is later than end_distance.')
+
+    if xmax is None:
+        if chmax is None:
+            i1 = nch
+        else:
+            i1 = int(chmax - start_channel)
+            if i1 <= 0:
+                raise ValueError('chmax <= start_channel.')
+            elif i1 > nch:
+                warnings.warn('chmax > end_channel. Set chmax to '
+                                'end_channel.')
+                i1 = nch
+    else:
+        i1 = round((xmax - start_distance) / dx)
+        if i1 <= 0:
+            raise ValueError('xmax is smaller than start_distance.')
+        if i1 > nch:
+            warnings.warn('xmax is later than end_distance. Set xmax '
+                            'to the array length.')
+            i1 = nch
+
+    if tmin is None:
+        if spmin is None:
+            j0 = 0
+        else:
+            j0 = int(spmin)
+            if j0 < 0:
+                warnings.warn('spmin < 0. Set spmin to 0.')
+                j0 = 0
+            elif j0 >= nsp:
+                raise ValueError('spmin > nsp.')
+    else:
+        try:
+            j0 = round((tmin - start_time) * fs)
+        except TypeError:
+            j0 = round(tmin * fs)
+        if j0 < 0:
+            warnings.warn('tmin is earlier than start_time. Set tmin '
+                            'to start_time.')
+            j0 = 0
+        elif j0 >= nsp:
+            raise ValueError('tmin is later than end_time.')
+
+    if tmax is None:
+        if spmax is None:
+            j1 = nsp
+        else:
+            j1 = int(spmax)
+            if j1 <= 0:
+                raise ValueError('spmax < 0.')
+            elif j1 > nsp:
+                warnings.warn('spmax > nsp. Set spmax to nsp.')
+                j1 = nsp
+    else:
+        try:
+            j1 = round((tmax - start_time) * fs)
+        except TypeError:
+            j1 = round(tmax * fs)
+        if j1 <= 0:
+            raise ValueError('tmax is earlier than start_time.')
+        if j1 > nsp:
+            warnings.warn('tmax is later than end_time. Set tmax to the'
+                            ' end_time.')
+            j1 = nsp
+    return i0, i1, j0, j1
+
+
+def trimming(data, dx=None, fs=None, xmin=None, xmax=None, chmin=None,
+             chmax=None, tmin=None, tmax=None, spmin=None, spmax=None,
+             **kwargs):
     """
     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.
+    :param xmin, xmax: float. Range of distance.
+    :param chmin, chmax: int. Channel number range.
+    :param tmin, tmax: float or DASDateTime. Range of time.
+    :param spmin, spmax: int. Sampling point range.
     :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]
+    # Compatible with old interfaces and remind users
+    if 'mode' in kwargs:
+        warnings.warn('In future versions, the mode parameter will be '
+                        'deprecated. xmin/xmax will only control the distance'
+                        ' range, tmin/tmax will only control the time range; '
+                        'please use chmin/chmax to control the channel number'
+                        ' range, and spmin/spmax to control the sampling '
+                        'point range', FutureWarning)
+        if kwargs['mode'] == 0:
+            chmin, chmax = xmin, xmax
+            xmin, xmax = None, None
+            spmin, spmax = tmin, tmax
+            tmin, tmax = None, None
+    nch, nsp = data.shape
+    i0, i1, j0, j1 = _trimming_index(nch, nsp, dx=dx, fs=fs, xmin=xmin,
+                                     xmax=xmax, chmin=chmin, chmax=chmax,
+                                     tmin=tmin, tmax=tmax, spmin=spmin,
+                                     spmax=spmax)
+
+    return data[i0:i1, j0:j1].copy()
 
 
 def padding(data, dn, reverse=False):
@@ -194,20 +308,20 @@ def padding(data, dn, reverse=False):
     :param reverse: bool. Set True to reverse the operation.
     :return: Padded data.
     """
-    nch, nt = data.shape
+    nch, nsp = 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]]
+        return data[pad[0]:nch - pad[1], pad[2]:nsp - 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
+        data_pd = np.zeros((nch + dn[0], nsp + dn[1]))
+        data_pd[pad[0]:nch + pad[0], pad[2]:nsp + pad[2]] = data
         return data_pd
 
 
-def time_integration(data, fs, c=0):
+def time_integration(data, fs, domain='time', c=0):
     """
     Integrate DAS data in time.
 
@@ -216,10 +330,19 @@ def time_integration(data, fs, c=0):
     :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):
+    if domain == 'time':
+        return np.cumsum(data, axis=1) / fs + c
+    elif domain in ['frequency', 'freq']:
+        nsp = data.shape[1]
+        freqs = rfftfreq(nsp, d=1/fs)
+        spectrum = rfft(data, axis=1)
+        H = np.zeros_like(freqs, dtype=complex)
+        nonzero = freqs != 0
+        H[nonzero] = 1 / (1j * 2 * np.pi * freqs[nonzero])
+        return np.real(irfft(spectrum * H))
+
+
+def time_differential(data, fs, domain='time', prepend=0):
     """
     Differentiate DAS data in time.
 
@@ -229,9 +352,16 @@ def time_differential(data, fs, prepend=0):
         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
+    if domain == 'time':
+        if prepend == 'mean':
+            prepend = np.mean(data, axis=1).reshape((-1, 1))
+        return np.diff(data, axis=1, prepend=prepend) * fs
+    elif domain in ['frequency', 'freq']:
+        nsp = data.shape[1]
+        freqs = rfftfreq(nsp, d=1./fs)
+        spectrum = rfft(data, axis=1)
+        H = 1j * 2 * np.pi * freqs
+        return np.real(irfft(spectrum * H))
 
 
 def distance_integration(data, dx, c=0):

{daspy_toolbox-1.1.6 → daspy_toolbox-1.2.1}/daspy/basic_tools/visualization.py

@@ -1,6 +1,6 @@
 # Purpose: Plot data
 # Author: Minzhe Hu
-# Date: 2025.5.20
+# Date: 2025.6.17
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 import matplotlib.pyplot as plt
@@ -24,7 +24,7 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
         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'.
+        'phasepick', 'spectrum', 'psd', '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.
@@ -33,7 +33,7 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
         P phase, 'S' for S phase and 'N' for unknown phase type. Required if
         obj=='phasepick'.
     :param f: Sequence of frequency. Required if obj is one of 'spectrum',
-        'spectrogram', 'fk' or 'dispersion'.
+        'psd', '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'.
@@ -99,14 +99,17 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
                     if tmode.lower() == 'sampling':
                         pck[:, 1] = pck[:, 1] / fs
                     ax.scatter(pck[:,0], t0 + pck[:,1], marker=',', s=0.1,
-                            c=pick_color[phase])
+                               c=pick_color[phase])
 
-    elif obj in ['spectrum', 'spectrogram', 'fk', 'dispersion']:
+    elif obj in ['spectrum', 'spectrogram', 'psd', 'fk', 'dispersion']:
         if np.iscomplex(data).any():
             data = abs(data)
         if dB:
             data = 20 * np.log10(data)
-        cmap = 'jet' if cmap is None else cmap
+        if obj == 'psd':
+            cmap = 'viridis' if cmap is None else cmap
+        else:
+            cmap = 'jet' if cmap is None else cmap
 
         if vmax is None:
             vmax_per = 80 if vmax_per is None else vmax_per
@@ -115,7 +118,7 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
             vmin_per = 20 if vmin_per is None else vmin_per
             vmin = np.percentile(data, vmin_per)
 
-        if obj == 'spectrum':
+        if obj in ['spectrum', 'psd']:
             origin = 'lower'
             if dx is None or xmode.lower() == 'channel':
                 xlabel_default = 'Channel'