DASPy-toolbox 1.1.5__tar.gz → 1.2.0__tar.gz

{daspy_toolbox-1.1.5 → daspy_toolbox-1.2.0}/DASPy_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.5
+Version: 1.2.0
 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.5 → daspy_toolbox-1.2.0}/DASPy_toolbox.egg-info/SOURCES.txt

@@ -25,4 +25,5 @@ daspy/core/dasdatetime.py
 daspy/core/example.pkl
 daspy/core/read.py
 daspy/core/section.py
+daspy/core/util.py
 daspy/core/write.py

{daspy_toolbox-1.1.5 → daspy_toolbox-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.5
+Version: 1.2.0
 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.5 → daspy_toolbox-1.2.0}/daspy/advanced_tools/channel.py

@@ -365,24 +365,6 @@ def turning_points(data, data_type='coordinate', thresh=5, depth_info=False,
         raise ValueError('Data_type should be \'coordinate\' or \'waveform\'.')
 
 
-def _equally_spacing(dist, dx):
-    index = [[], []]
-    residual = [0, abs(dist[0]-dx)]
-    for i in range(2, len(dist)+1):
-        res = []
-        for j in range(i):
-            res.append(residual[j] + abs(dx - sum(dist[j:i])))
-        residual.append(min(res))
-        k = np.argmin(res)
-        if k > 0:
-            index.append(index[k] + [k])
-        else:
-            index.append(index[k])
-        # print(index, residual)
-    
-    return index[-1]
-
-
 def channel_spacing(geometry, depth_info=False):
     nch = len(geometry)
     dist = np.zeros(nch - 1)
@@ -456,6 +438,23 @@ def closest_channel_to_point(geometry, points, verbose=False):
     return channels[closest_index]
 
 
+def _equally_spacing(dist, dx):
+    index = [[], []]
+    residual = [0, abs(dist[0]-dx)]
+    for i in range(2, len(dist)+1):
+        res = []
+        for j in range(i):
+            res.append(residual[j] + abs(dx - sum(dist[j:i])))
+        residual.append(min(res))
+        k = np.argmin(res)
+        if k > 0:
+            index.append(index[k] + [k])
+        else:
+            index.append(index[k])
+    
+    return index[-1]
+
+
 def equally_spaced_channels(geometry, dx, depth_info=False, verbose=False):
     """
     Find equally spaced channel numbers based on known DAS latitude and

{daspy_toolbox-1.1.5 → daspy_toolbox-1.2.0}/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.5 → daspy_toolbox-1.2.0}/daspy/basic_tools/preprocessing.py

@@ -1,7 +1,8 @@
 # Purpose: Some preprocess methods
 # Author: Minzhe Hu
-# Date: 2025.3.10
+# Date: 2025.6.25
 # Email: hmz2018@mail.ustc.edu.cn
+import warnings
 import numpy as np
 from scipy.signal import detrend
 from scipy.signal.windows import tukey
@@ -89,11 +90,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 +116,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 +126,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)
 
 
@@ -145,43 +146,155 @@ def downsampling(data, xint=None, tint=None, stack=True, lowpass_filter=True):
         if stack:
             data_ds = stacking(data, xint)
         else:
-            data_ds = data_ds[::xint]
+            data_ds = data_ds[::xint].copy()
     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]
+            data_ds = data_ds[::tint].copy()
         else:
-            data_ds = data_ds[:, ::tint]
+            data_ds = data_ds[:, ::tint].copy()
     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,16 +307,16 @@ 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
 
 

{daspy_toolbox-1.1.5 → daspy_toolbox-1.2.0}/daspy/basic_tools/visualization.py

@@ -1,6 +1,6 @@
 # Purpose: Plot data
 # Author: Minzhe Hu
-# Date: 2025.1.6
+# Date: 2025.6.17
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 import matplotlib.pyplot as plt
@@ -9,11 +9,11 @@ from collections.abc import Sequence
 
 def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
          title=None, transpose=False, t0=0, x0=0, pick=None, f=None, k=None,
-         t=None, c=None, cmap=None, vmin=None, vmax=None, dB=False,
-         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):
+         t=None, c=None, cmap=None, vmin=None, vmin_per=None, vmax=None,
+         vmax_per=None, dB=False, 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.
 
@@ -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,13 +33,15 @@ 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'.
     :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 vmin_per, vmax_per: float. Define the data range that the colormap
+        covers by percentile.
     :param dB: bool. Transfer data unit to dB and take 1 as the reference value.
     :param xmode: str. 'distance' or 'channel'.
     :param tmode: str. 'time' or 'sampling'.
@@ -67,7 +69,9 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
 
     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
+        if vmax is None:
+            vmax_per = 80 if vmax_per is None else vmax_per
+            vmax = np.percentile(data, vmax_per)
         vmin = -vmax if vmin is None else vmin
         origin = 'upper'
         if fs is None or tmode == 'sampling':
@@ -95,17 +99,26 @@ 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']:
-        if isinstance(data[0,0], (complex, np.complex64)):
+    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
-        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':
+        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
+            vmax = np.percentile(data, vmax_per)
+        if vmin is None:
+            vmin_per = 20 if vmin_per is None else vmin_per
+            vmin = np.percentile(data, vmin_per)
+
+        if obj in ['spectrum', 'psd']:
             origin = 'lower'
             if dx is None or xmode.lower() == 'channel':
                 xlabel_default = 'Channel'