DASPy-toolbox 1.0.0__py3-none-any.whl

DASPy_toolbox-1.0.0.dist-info/LICENSE.txt

@@ -0,0 +1 @@
+daspy/LICENSE.txt

DASPy_toolbox-1.0.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.1
+Name: DASPy-toolbox
+Version: 1.0.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
+Author-email: hmz2018@mail.ustc.edu.cn
+Maintainer: Minzhe Hu
+Maintainer-email: hmz2018@mail.ustc.edu.cn
+License: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.13
+Requires-Dist: matplotlib
+Requires-Dist: geographiclib
+Requires-Dist: pyproj
+Requires-Dist: h5py
+Requires-Dist: segyio
+Requires-Dist: nptdms
+Requires-Dist: tqdm
+
+<img src="./website/USTC.svg" height="170" />&emsp;<img src="./website/DAMS.png" height="150" />
+
+
+## DASPy
+
+DASPy is an open-source project dedicated to provide a python package for DAS (Distributed Acoustic Sensing) data processing.
+
+The goal of the DASPy project is to lower the bar of DAS data processing. DASPy includes:
+* Classic seismic data processing techniques, including preprocessing, filter, spectrum analysis, and visualization
+* Specialized algorithms for DAS applications, including denoising, waveform decomposition, channel attribute analysis, and strain-velocity conversion. 
+
+DASPy is licensed under the MIT License. [An English version of DASPy tutorial](https://daspy-tutorial.readthedocs.io/en/latest/), [a Chinese version of DASPy tutorial](https://daspy-tutorial-cn.readthedocs.io/zh-cn/latest/) and [the DASPy paper](document/srl-2024124.1.pdf) is available. If you have any questions, please contact me via <hmz2018@mail.ustc.edu.cn>.
+
+## Installation
+DASPy is currently running on Linux, Windows and Mac OS.
+DASPy runs on Python 3.9 and up. We recommend you use the latest version of python 3 if possible.
+
+### Pip (recommanded)
+```
+pip install git+https://github.com/HMZ-03/DASPy.git
+```
+
+If you installed DASPy this way, you can upgrade DASPy with the following command:
+
+```
+pip install --upgrade git+https://github.com/HMZ-03/DASPy.git
+```
+
+### Conda
+```
+conda install -c hmz-03 daspy
+```
+
+If an error is reported, please try updating conda:
+
+```
+conda update -n base -c conda-forge conda
+```
+
+### Manual installation
+1. Install dependent packages: numpy, scipy >=1.13, matplotlib, geographiclib, pyproj, h5py, segyio, nptdms, tqdm
+
+2. Add DASPy into your Python path.
+
+## Getting started
+```
+from daspy import read
+sec = read()  # load example waveform
+sec.bandpass(1, 15)
+sec.plot()
+```
+<img src="./website/waveform.png" height="500" />
+
+### Contributing
+
+Please see details on how to contribute to the project [here](CONTRIBUTING.md) and [here](CodingStyleGuide.md).
+
+### Reference
+
+  * Minzhe Hu and Zefeng Li (2024), [DASPy: A Python Toolbox for DAS Seismology](https://pubs.geoscienceworld.org/ssa/srl/article/95/5/3055/645865/DASPy-A-Python-Toolbox-for-DAS-Seismology), *Seismological Research Letters*, 95(5), 3055–3066, doi: `https://doi.org/10.1785/0220240124`.

DASPy_toolbox-1.0.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+daspy/__init__.py,sha256=9ePx1cKAX5SdVk9lCSeu4AjhhzimfIbbwdoeVcosUok,178
+daspy/advanced_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+daspy/advanced_tools/channel.py,sha256=Ymw7B_ZN185_kVhZDFvQHXwycOlvyxQbRB7QOV6qzRU,13903
+daspy/advanced_tools/decomposition.py,sha256=jAth4_xKGaFpemzpci25D4XyZUx0Nl7eGMATBouKmiA,7252
+daspy/advanced_tools/denoising.py,sha256=qpQnuv2JUB7b6hI8MvUHAy0NqFCC0-00uYxd1xhnz2Q,10790
+daspy/advanced_tools/fdct.py,sha256=sCZtBdSFdwcsPsjIPUmHNqUfEUK6GFEp7qVQyVRhzkc,37047
+daspy/advanced_tools/strain2vel.py,sha256=UJpDTqoi8frtBtuxqTbQoiOd9XSHVvNuJ1Gx3eK2Uhg,9936
+daspy/basic_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+daspy/basic_tools/filter.py,sha256=OqfAvSTZWMcqf4gve3-WvKpN_tsmjsz9azBacGpIzvI,10192
+daspy/basic_tools/freqattributes.py,sha256=6Tb_xZ45NU0Kh-eRgzOWPA69oLjDXL7GUbMoKkr1BX4,4397
+daspy/basic_tools/preprocessing.py,sha256=z-YpFWQxtBFrCKqWpxKzaZete0phb3fXzMemQ9SL68E,7175
+daspy/basic_tools/visualization.py,sha256=UCRdCy5MWsBKcg0ELuDPqahCa_vjDWp1rugE-BUgRhY,7568
+daspy/core/__init__.py,sha256=9ePx1cKAX5SdVk9lCSeu4AjhhzimfIbbwdoeVcosUok,178
+daspy/core/collection.py,sha256=kzTR7rQtS15ShfLTsJXh9Jt4bIPJA_nsUG7apxTrJfU,11449
+daspy/core/dasdatetime.py,sha256=ASkPjx5mF0VL4GTrCbKm08NaZsSD_2zn4sHad3yRLaQ,2097
+daspy/core/example.pkl,sha256=cgna7XFux5gSO93y_9GSVUNJa2PKABxD68a_HenzoHc,20000481
+daspy/core/make_example.py,sha256=pfUTZXTzHUIV2bvB197uyQNILXfv6eIACSw3Omt__9Q,994
+daspy/core/read.py,sha256=716YcfMPMaxX4FtkOXNrxjIemup2IiMRkeufl56LXl8,23499
+daspy/core/section.py,sha256=d5Q5x6iwxpOqKFfoi1OgCNd7T1rVZWh_JTzj7em7is8,57401
+daspy/core/write.py,sha256=yZwsuQSJZutBk4gjuCJTm4nAph3VZtTJUYml1lVXHQM,12581
+daspy/seismic_detection/__init__.py,sha256=CwmJ6t6tUu19F15MUAa3A0m-gdevAsbK-XDtlYk_4sw,54
+daspy/seismic_detection/calc_travel_time.py,sha256=DnIQvqACGu35PNwDOeZ1e_aDOi4kIRPbuYU93k-X3nI,716
+daspy/seismic_detection/core.py,sha256=SEReXzTDw3lZkz_IYoBKe8WMRJnOeBM5FxZxRfCWC7c,4817
+daspy/seismic_detection/detection.py,sha256=QNOMIaw_qsxnGZxWEYYUXMEK_NJUSubpiRQEeQK3Pl8,180
+daspy/seismic_detection/location.py,sha256=RVHym2hYOCiohKv6BpJKGYYLGX4j3m5XCcO9gtSIhPU,10375
+daspy/seismic_detection/magnitude.py,sha256=G2FpTtVrxzQ_yaiycMut8R1Cq9gErES4QmWtP9Mzv3c,1181
+daspy/seismic_detection/phase_picking.py,sha256=ggtIT4DXE0S1wHecitNpsnN2xXuUnHXp7X_paxUqy4U,1897
+daspy/seismic_detection/gamma/__init__.py,sha256=fBgNjzcOqyAnA3-oioCzgRxOlKPq_q_QlBl3gmcB2Xw,330
+daspy/seismic_detection/gamma/_base.py,sha256=0MJNNBwImK9AhMhqrABRuHmn1UTZn0mSNJcWNMvgLc4,19235
+daspy/seismic_detection/gamma/_bayesian_mixture.py,sha256=6Fm8d1kYAUj_ZDYGMOQwN_Uvl5-HEniHbQRRE7-nz0w,37508
+daspy/seismic_detection/gamma/_gaussian_mixture.py,sha256=OoeHH6P9Fe0ggaq4X7mUIRThz4dU7RndhaAKB-QYLjw,33646
+daspy/seismic_detection/gamma/app.py,sha256=6udxd6zjU_WOpz6-wQB6zLGR5ExNwkONdSee8dToh60,7104
+daspy/seismic_detection/gamma/seismic_ops.py,sha256=uhqozSdv9zmq6PwMRnEQqOqVXRIroQh7xOQfpZOJaWo,16106
+daspy/seismic_detection/gamma/utils.py,sha256=N4bgksgEMQFIs99VPYKQEJIHpSwsrmqcR-l-LaqIans,20208
+daspy/structure_imaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+daspy/structure_imaging/ambient_noise.py,sha256=S245_h3JeNVN7WyQLnL3ECXPVGZJXfRo28tBO3RcRww,38
+daspy/structure_imaging/dispersion.py,sha256=G7ELTg1tbcfRHIuLzaFiPW0bYQ64qvy-U7pY4R8VhVI,827
+daspy/structure_imaging/fault_zone.py,sha256=yWa-1zAq-Ay0Y8FQGQ_nd-Nf1r-MfWMEuuXwHOY7fm4,1872
+daspy/structure_imaging/inversion.py,sha256=gmaNdqOfLcFiMhZQolXE6M9yJ6jzi_SKKN1KjDX31bA,48
+daspy/traffic_monitoring/JamDetection.py,sha256=gmaNdqOfLcFiMhZQolXE6M9yJ6jzi_SKKN1KjDX31bA,48
+daspy/traffic_monitoring/SpeedMeasurement.py,sha256=gmaNdqOfLcFiMhZQolXE6M9yJ6jzi_SKKN1KjDX31bA,48
+daspy/traffic_monitoring/VehicleDetection.py,sha256=gmaNdqOfLcFiMhZQolXE6M9yJ6jzi_SKKN1KjDX31bA,48
+daspy/traffic_monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+DASPy_toolbox-1.0.0.dist-info/LICENSE.txt,sha256=JQFMMufl9iR-zv6KUSm1HRskwVGj1rLUYaJt_xSYdHU,18
+DASPy_toolbox-1.0.0.dist-info/METADATA,sha256=r62scxU1N8OeNK6dwBUAVcS5wG80bri0JiMBtAo4McA,3208
+DASPy_toolbox-1.0.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+DASPy_toolbox-1.0.0.dist-info/entry_points.txt,sha256=h-kZi48_NB9-2Y985HJ_ZTy343UC8msj-sfqgs8dszs,42
+DASPy_toolbox-1.0.0.dist-info/top_level.txt,sha256=GDX6JX11FYMlTT1iflQkX_daWBA7Vn83fOuOeMXqshM,6
+DASPy_toolbox-1.0.0.dist-info/RECORD,,

DASPy_toolbox-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

DASPy_toolbox-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+daspy = daspy.main:main

DASPy_toolbox-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+daspy

daspy/__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

daspy/advanced_tools/channel.py

@@ -0,0 +1,354 @@
+# Purpose: Several functions for analysis data quality and geometry of channels
+# Author: Minzhe Hu, Zefeng Li
+# Date: 2024.10.11
+# Email: hmz2018@mail.ustc.edu.cn
+import numpy as np
+from copy import deepcopy
+from geographiclib.geodesic import Geodesic
+from pyproj import Proj
+
+
+def robust_polyfit(data, deg, thresh):
+    """
+    Fit a curve with a robust weighted polynomial.
+
+    :param data: 1-dimensional array.
+    :param deg: int. Degree of the fitting polynomial
+    :param thresh: int or float. Defined MAD multiple of outliers.
+    :return: Fitting data
+    """
+    nch = len(data)
+    channels = np.arange(nch)
+    p_coef = np.polyfit(channels, data, deg)
+    p_fit = np.poly1d(p_coef)
+    old_data = p_fit(channels)
+    mse = 1
+
+    # robust fitting until the fitting curve changes < 0.1% at every point.
+    while mse > 0.001:
+        rsl = abs(data - old_data)
+        mad = np.median(rsl)
+        weights = np.zeros(nch)
+        weights[rsl < thresh * mad] = 1
+        p_coef = np.polyfit(channels, data, deg, w=weights)
+        p_fit = np.poly1d(p_coef)
+        new_data = p_fit(channels)
+        mse = np.nanmax(np.abs((new_data - old_data) / old_data))
+        old_data = new_data
+
+    return new_data, weights
+
+
+def _continuity_checking(lst1, lst2, adjacent=2, toleration=2):
+    lst1_raw = deepcopy(lst1)
+    for chn in lst1_raw:
+        discont = [a for a in lst2 if abs(a - chn) <= adjacent]
+        if len(discont) >= adjacent * 2 + 1 - toleration:
+            lst1.remove(chn)
+            lst2.append(chn)
+
+    return lst1, lst2
+
+
+def channel_checking(data, deg=10, thresh=5, continuity=True, adjacent=2,
+                     toleration=2, mode='low', verbose=False):
+    """
+    Use the energy of each channel to determine which channels are bad.
+
+    :param data: 2-dimensional np.ndarray. Axis 0 is channel number and axis 1 is
+        time series
+    :param deg: int. Degree of the fitting polynomial
+    :param thresh: int or float. The MAD multiple of bad channel energy lower
+        than good channels.
+    :param continuity: bool. Perform continuity checks on bad channels and good
+        channels.
+    :param adjacent: int. The number of nearby channels for continuity checks.
+    :param toleration: int. The number of discontinuous channel allowed in each
+        channel (including itself) in the continuity check.
+    :param mode: str. 'low' means bad channels have low amplitude, 'high' means
+        bad channels have high amplitude, and 'both' means bad channels are
+        likely to have low or high amplitude.
+    :return: Good channels and bad channels.
+    """
+    nch = len(data)
+    energy = np.log10(np.sum(data**2, axis=1))
+
+    # Remove abnormal value by robust polynomial fitting.
+    fitted_energy, weights = robust_polyfit(energy, deg, thresh)
+    deviation = energy - fitted_energy
+
+    # Iterate eliminates outliers.
+    mad = np.median(abs(deviation[weights > 0]))
+    if mode == 'low':
+        bad_chn = np.argwhere(deviation < -thresh * mad).ravel().tolist()
+    elif mode == 'high':
+        bad_chn = np.argwhere(deviation > thresh * mad).ravel().tolist()
+    elif mode == 'high':
+        bad_chn = np.argwhere(deviation < -thresh * mad).ravel().tolist() + \
+                np.argwhere(deviation > thresh * mad).ravel().tolist()
+    good_chn = list(set(range(nch)) - set(bad_chn))
+
+    if continuity:
+        # Discontinuous normal value are part of bad channels.
+        good_chn, bad_chn = _continuity_checking(good_chn, bad_chn,
+                                                 adjacent=adjacent,
+                                                 toleration=toleration)
+
+        # Discontinuous outliers are usually not bad channels.
+        bad_chn, good_chn = _continuity_checking(bad_chn, good_chn,
+                                                 adjacent=adjacent,
+                                                 toleration=toleration)
+
+    bad_chn = np.sort(np.array(bad_chn))
+    good_chn = np.sort(np.array(good_chn))
+    if verbose:
+        return good_chn, bad_chn, energy, fitted_energy - thresh * mad
+
+    return good_chn, bad_chn
+
+
+def _channel_location(track_pt):
+    track, tn = track_pt[:, :-1], track_pt[:, -1]
+    dim = track.shape[1]
+    l_track = np.sqrt(np.sum(np.diff(track, axis=0) ** 2, axis=1))
+    l_track_cum = np.hstack(([0], np.cumsum(l_track)))
+    idx_kp = np.where(tn >= 0)[0]
+
+    interp_ch = []
+    chn = np.floor(tn[idx_kp[0]])
+    if abs(chn - tn[idx_kp[0]]) < 1e-6:
+        interp_ch.append([*track[idx_kp[0]], chn])
+
+    seg_interval = []
+    for i in range(1, len(idx_kp)):
+        # calculate actual interval between known-channel points
+        istart, iend = idx_kp[i - 1], idx_kp[i]
+        n_chn_kp = tn[iend] - tn[istart]
+        d_interp = (l_track_cum[iend] - l_track_cum[istart]) / n_chn_kp
+        seg_interval.append([tn[istart], tn[iend], d_interp])
+
+        l_res = 0  # remaining fiber length before counting the next segment
+        # consider if the given channelnumber is not an integer
+        chn_res = tn[istart] - int(tn[istart])
+        for j in range(istart, iend):
+            l_start = l_track[j] + l_res
+
+            # if tp segment length is large for more than one interval, get the
+            # channel loc
+            if l_start >= d_interp * (1 - chn_res):
+                # floor int, num of channel available
+                n_chn_tp = int(l_start / d_interp + chn_res)
+                l_new = (np.arange(n_chn_tp) + 1 - chn_res) * d_interp - \
+                    l_res  # channel distance from segment start
+
+                # interpolate the channel loc
+                t_new = np.zeros((len(l_new), dim))
+                for d in range(dim):
+                    t_new[:, d] = np.interp(l_new, [0, l_track[j]],
+                                            [track[j, d], track[j + 1, d]])
+
+                # remaining length to add to next segment
+                l_res = l_start - n_chn_tp * d_interp
+
+                # write interpolated channel loc
+                for ti in t_new:
+                    chn += 1
+                    interp_ch.append([*ti, chn])
+
+                # handle floor int problem when l_start/d_interp is near an
+                # interger
+                if (d_interp - l_res) / d_interp < 1e-6:
+                    chn += 1
+                    interp_ch.append([*track[j + 1, :], int(tn[j + 1])])
+                    l_res = 0
+                chn_res = 0
+            # if tp segment length is not enough for one interval, simply add
+            # the length to next segment
+            elif l_start < d_interp:
+                l_res = l_start
+
+    return np.array(seg_interval), np.array(interp_ch)
+
+
+def location_interpolation(known_pt, track_pt=None, dx=2, data_type='lonlat',
+                           verbose=False):
+    """
+    Interpolate to obtain the positions of all channels.
+
+    :param known_pt: np.ndarray. Points with known channel numbers. Each row
+        includes 2 or 3 coordinates and a channel number.
+    :param track_pt: np.ndarray. Optional fiber spatial track points without
+        channel numbers. Each row includes 2 or 3 coordinates. Please ensure
+        that the track points are arranged in increasing order of track number.
+        If track points is not dense enough, please insert the coordinates of
+        known points into track points in order.
+    :param dx: Known points far from the track (> dx) will be excluded.
+        Recommended setting is channel interval. The unit is m.
+    :param data_type: str. Coordinate type. 'lonlat' ('lonlatheight') for
+        longitude, latitude in degree (and height in meters), 'xy' ('xyz') for
+        x, y (and z) in meters.
+    :param verbose: bool. If True, return interpoleted channel location and
+        segment interval.
+    :return: Interpoleted channel location if verbose is False.
+    """
+    known_pt = known_pt[known_pt[:,-1].argsort()]
+    dim = known_pt.shape[1] - 1
+    if 'lonlat' in data_type:
+        zone = np.floor((max(known_pt[:,0]) + min(known_pt[:,0])) / 2 / 6)\
+            .astype(int) + 31
+        DASProj = Proj(proj='utm', zone=zone, ellps='WGS84',
+                       preserve_units=False)
+        known_pt[:, 0], known_pt[:, 1] = DASProj(known_pt[:, 0], known_pt[:, 1])
+    else:
+        assert 'xy' in data_type, ('data_type should be \'lonlat\',\''
+                                   'lonlatheight\', \'xy\' or \'xyz\'')
+
+    if track_pt is None:
+        seg_interval, interp_ch = _channel_location(known_pt)
+    else:
+        K = len(known_pt)
+        T = len(track_pt)
+        track_pt = np.c_[track_pt, np.zeros(T) - 1]
+        if 'lonlat' in data_type:
+            track_pt[:, 0], track_pt[:, 1] = DASProj(track_pt[:, 0],
+                                                     track_pt[:, 1])
+
+        # insert the known points into the fiber track data
+        matrix = [np.tile(track_pt[:, d], (K, 1)) -
+                  np.tile(known_pt[:, d], (T, 1)).T for d in range(dim)]
+
+        dist = np.sqrt(np.sum(np.array(matrix) ** 2, axis=0))
+        for k in range(K):
+            if min(dist[k]) < dx:
+                t_list = np.sort(np.where(dist[k] == min(dist[k]))[0])
+                for t in t_list:
+                    if track_pt[t, -1] == -1:
+                        track_pt[t, -1] = known_pt[k, -1]
+                        last_pt = t
+                        break
+
+        # interpolation with regular spacing along the fiber track
+        try:
+            track_pt = track_pt[:last_pt + 1]
+        except NameError:
+            print('All known points are too far away from the track points. If '
+                  'they are reliable, they can be merged in sequence as track '
+                  'points to input')
+            return None
+
+        seg_interval, interp_ch = _channel_location(track_pt)
+
+    if data_type == 'lonlat':
+        interp_ch[:, 0], interp_ch[:, 1] = \
+            DASProj(interp_ch[:, 0], interp_ch[:, 1], inverse=True)
+
+    if verbose:
+        return interp_ch, seg_interval
+    return interp_ch
+
+
+def _xcorr(x, y):
+    N = len(x)
+    meanx = np.mean(x)
+    meany = np.mean(y)
+    stdx = np.std(np.asarray(x))
+    stdy = np.std(np.asarray(y))
+    c = np.sum((y - meany) * (x - meanx)) / (N * stdx * stdy)
+    return c
+
+
+def _horizontal_angle_change(geo, gap=10):
+    nch = len(geo)
+    angle = np.zeros(nch)
+    for i in range(1, nch - 1):
+        lon, lat = geo[i]
+        lon_s, lat_s = geo[max(i - gap, 0)]
+        lon_e, lat_e = geo[min(i + gap, nch - 1)]
+        azi_s = Geodesic.WGS84.Inverse(lat_s, lon_s, lat, lon)['azi1']
+        azi_e = Geodesic.WGS84.Inverse(lat, lon, lat_e, lon_e)['azi1']
+        dazi = azi_e - azi_s
+        if abs(dazi) > 180:
+            dazi = -np.sign(dazi) * (360 - abs(dazi))
+        angle[i] = dazi
+
+    return angle
+
+
+def _vertical_angle_change(geo, gap=10):
+    nch = len(geo)
+    angle = np.zeros(nch)
+    for i in range(1, nch - 1):
+        lon, lat, dep = geo[i]
+        lon_s, lat_s, dep_s = geo[max(i - gap, 0)]
+        lon_e, lat_e, dep_e = geo[min(i + gap, nch - 1)]
+        s12_s = Geodesic.WGS84.Inverse(lat_s, lon_s, lat, lon)['s12']
+        theta_s = np.arctan((dep - dep_s) / s12_s) / np.pi * 180
+        s12_e = Geodesic.WGS84.Inverse(lat, lon, lat_e, lon_e)['s12']
+        theta_e = np.arctan((dep_e - dep) / s12_e) / np.pi * 180
+        angle[i] = theta_e - theta_s
+
+    return angle
+
+
+def _local_maximum_indexes(data, thresh):
+    idx = np.where(data > thresh)[0]
+    if len(idx):
+        i = list(np.where(np.diff(idx) > 1)[0] + 1)
+        if len(idx) - 1 not in i:
+            i.append(len(idx) - 1)
+        b = 0
+        max_idx = []
+        for e in i:
+            max_idx.append(idx[b] + np.argmax(data[idx[b]:idx[e]]))
+            b = e
+        return max_idx
+    else:
+        return []
+
+
+def turning_points(data, data_type='coordinate', thresh=5, depth_info=False,
+                   channel_gap=3):
+    """
+    Seek turning points in the DAS channel.
+
+    :param data: numpy.ndarray. Data used to seek turning points.
+    :param data_type: str. If data_type is 'coordinate', data should include
+        longitude and latitude (first two columns), and can also include depth
+        (last column). If data_type is 'waveform', data should be continuous
+        waveform, preferably containing signal with strong coherence
+        (earthquake, traffic signal, etc.).
+    :param thresh: For coordinate data, when the angle of the optical cables on
+        both sides centered on a certain point exceeds thresh, it is considered
+        an turning point. For waveform, thresh means the MAD multiple of
+        adjacent channel cross-correlation values lower than their median.
+    :param depth_info: bool. Optional if data_type is 'coordinate'. Whether
+        depth (in meters) is included in the coordinate data and need to be
+        used.
+    :param channel_gap: int. Optional if data_type is 'coordinate'. The smaller
+        the value is, the finer the segmentation will be. It is recommended to
+        set it to half the ratio of gauge length and channel interval.
+    :return: list. Channel index of turning points.
+    """
+    if data_type == 'coordinate':
+        angle = _horizontal_angle_change(data[:, :2], gap=channel_gap)
+        turning_h = _local_maximum_indexes(abs(angle), thresh)
+
+        if depth_info:
+            angle = _vertical_angle_change(data, gap=channel_gap)
+            turning_v = _local_maximum_indexes(abs(angle), thresh)
+            return turning_h, turning_v
+
+        return turning_h
+
+    elif data_type == 'waveform':
+        nch = len(data)
+        cc = np.zeros(nch - 1)
+        for i in range(nch - 1):
+            cc[i] = _xcorr(data[i], data[i + 1])
+        median = np.median(cc)
+        mad = np.median(abs(cc - median))
+
+        return np.argwhere(cc < median - thresh * mad)[0]
+
+    else:
+        raise ValueError('Data_type should be \'coordinate\' or \'waveform\'.')

daspy/advanced_tools/decomposition.py

@@ -0,0 +1,165 @@
+# Purpose: Waveform decomposition
+# Author: Minzhe Hu
+# Date: 2024.5.13
+# Email: hmz2018@mail.ustc.edu.cn
+import numpy as np
+from numpy.fft import irfft2, ifftshift
+from daspy.basic_tools.preprocessing import padding, cosine_taper
+from daspy.basic_tools.freqattributes import next_pow_2, fk_transform
+from daspy.advanced_tools.denoising import curvelet_denoising
+
+
+def fk_fan_mask(f, k, fmin=None, fmax=None, kmin=None, kmax=None, vmin=None,
+                vmax=None, edge=0.1, flag=None):
+    """
+    Make a fan mask in f-k domain for f-k filter.
+
+    :param f: Frequency sequence.
+    :param k: Wavenumber sequence.
+    :param fmin, fmax, kmin, kmax, vmin, vmax: float or or sequence of 2 floats.
+        Sequence of 2 floats represents the start and end of taper.
+    :param edge: float. The width of fan mask taper edge.
+    :param flag: -1 keep only negative apparent velocities, 0 keep both postive
+        and negative apparent velocities, 1 keep only positive apparent
+        velocities.
+    :return: Fan mask.
+    """
+    ff = np.tile(f, (len(k), 1))
+    kk = np.tile(k, (len(f), 1)).T
+    vv = - np.divide(ff, kk, out=np.ones_like(ff) * 1e10, where=kk != 0)
+    mask = np.ones(vv.shape)
+    for phy_quan in ['f', 'k', 'v']:
+        p = eval(phy_quan * 2)
+        pmin = eval(phy_quan + 'min')
+        if pmin:
+            if isinstance(pmin, (tuple, list, np.ndarray)):
+                tp_b, tp_e = min(pmin), max(pmin)
+            else:
+                tp_b, tp_e = pmin * max(1 - edge / 2, 0), pmin * (1 + edge / 2)
+            tp_wid = tp_e - tp_b
+            mask[(abs(p) <= tp_b)] = 0
+            area = (abs(p) > tp_b) & (abs(p) < tp_e)
+            mask[area] *= 0.5 - 0.5 * \
+                np.cos(((abs(p[area]) - tp_b) / tp_wid) * np.pi)
+
+        pmax = eval(phy_quan + 'max')
+        if pmax:
+            if isinstance(pmax, (tuple, list, np.ndarray)):
+                tp_b, tp_e = max(pmax), min(pmax)
+            else:
+                tp_b, tp_e = pmax * (1 + edge / 2), pmax * (1 - edge / 2)
+            tp_wid = tp_b - tp_e
+            mask[(abs(p) >= tp_b)] = 0
+            area = (abs(p) > tp_e) & (abs(p) < tp_b)
+            mask[area] *= 0.5 - 0.5 * \
+                np.cos(((tp_b - abs(p[area])) / tp_wid) * np.pi)
+
+    if flag:
+        mask[np.sign(vv) == flag] = 0
+    return mask
+
+
+def fk_filter(data, dx, fs, taper=(0.02, 0.05), pad='default', mode='decompose', 
+              fmin=None, fmax=None, kmin=None, kmax=None, vmin=None, vmax=None,
+              edge=0.1, flag=None, verbose=False):
+    """
+    Transform the data to the f-k domain using 2-D Fourier transform method, and
+    transform back to the x-t domain after filtering.
+
+    :param data: numpy.ndarray. Data to do fk filter.
+    :param dx: Channel interval in m.
+    :param fs: Sampling rate in Hz.
+    :param taper: 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.
+    :param pad: Pad the data or not. It can be float or sequence of floats. Each
+        float means padding percentage before FFT for corresponding dimension.
+        If set to 0.1 will pad 5% before the beginning and after the end.
+        'default' means pad both dimensions to next power of 2. None or False
+        means don't pad data before or during Fast Fourier Transform.
+    :param mode: str. 'remove' for denoising, 'retain' for extraction, and
+        'decompose' for decomposition.
+    :param fmin, fmax, kmin, kmax, vmin, vmax: float or or sequence of 2 floats.
+        Sequence of 2 floats represents the start and end of taper.
+    :param edge: float. The width of fan mask taper edge.
+    :param flag: -1 keep only negative apparent velocities, 0 keep both postive
+        and negative apparent velocities, 1 keep only positive apparent
+        velocities.
+    :param verbose: If True, return filtered data, f-k spectrum, frequency
+        sequence, wavenumber sequence and f-k mask.
+    :return: Filtered data and some variables in the process if verbose==True.
+    """
+    data_tp = cosine_taper(data, taper)
+    if pad == 'default':
+        nch, nt = data.shape
+        dn = (next_pow_2(nch) - nch, next_pow_2(nt) - nt)
+        nfft = None
+    elif pad is None or pad is False:
+        dn = 0
+        nfft = None
+    else:
+        dn = np.round(np.array(pad) * data.shape).astype(int)
+        nfft = 'default'
+
+    data_pd = padding(data_tp, dn)
+    nch, nt = data_pd.shape
+
+    fk, f, k = fk_transform(data_pd, dx, fs, taper=0, nfft=nfft)
+
+    mask = fk_fan_mask(f, k, fmin, fmax, kmin, kmax, vmin, vmax, edge=edge,
+                       flag=flag)
+
+    if mode == 'remove':
+        mask = 1 - mask
+
+    if mode == 'decompose':
+        data_flt1 = irfft2(ifftshift(fk * mask, axes=0)).real[:nch, :nt]
+        data_flt1 = padding(data_flt1, dn, reverse=True)
+        data_flt2 = irfft2(ifftshift(fk * (1 - mask), axes=0)).real[:nch, :nt]
+        data_flt2 = padding(data_flt2, dn, reverse=True)
+        if verbose:
+            return data_flt1, data_flt2, fk, f, k, mask
+        else:
+            return data_flt1, data_flt2
+    else:
+        data_flt = irfft2(ifftshift(fk * mask, axes=0)).real[:nch, :nt]
+        data_flt = padding(data_flt, dn, reverse=True)
+        if verbose:
+            return data_flt, fk, f, k, mask
+        else:
+            return data_flt
+
+
+def curvelet_windowing(data, dx, fs, mode='decompose', vmin=0, vmax=np.inf,
+                       flag=None, pad=0.3, scale_begin=3, nbscales=None,
+                       nbangles=16, finest=1):
+    """
+    Use curevelet transform to keep cooherent signal with certain velocity
+    range. {Atterholt et al., 2022 , Geophys. J. Int.}
+
+    :param data: numpy.ndarray. Data to decomposite.
+    :param dx: Channel interval in m.
+    :param fs: Sampling rate in Hz.
+    :param mode: str. 'remove' for denoising, 'retain' for extraction, and
+        'decompose' for decomposition.
+    :param vmin, vmax: float. Velocity range in m/s.
+    :param flag: -1 keep only negative apparent velocities, 0 keep both postive
+        and negative apparent velocities, 1 keep only positive apparent
+        velocities.
+    :param pad: float or sequence of floats. Each float means padding percentage
+        before FFT for corresponding dimension. If set to 0.1 will pad 5% before
+        the beginning and after the end.
+    :param scale_begin: int. The beginning scale to do coherent denoising.
+    :param nbscales: int. Number of scales including the coarsest wavelet level.
+        Default set to ceil(log2(min(M,N)) - 3).
+    :param nbangles: int. Number of angles at the 2nd coarsest level,
+        minimum 8, must be a multiple of 4.
+    :param finest: int. Objects at the finest scale. 1 for curvelets, 2 for
+        wavelets. Curvelets are more precise while wavelets are more efficient.
+    :return: numpy.ndarray. Decomposed data.
+    """
+    return curvelet_denoising(data, choice=1, pad=pad, vmin=vmin, vmax=vmax,
+                              flag=flag, dx=dx, fs=fs, mode=mode,
+                              scale_begin=scale_begin, nbscales=nbscales,
+                              nbangles=nbangles, finest=finest)