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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.2
+Version: 1.1.5
 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
@@ -28,6 +28,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: maintainer
 Dynamic: maintainer-email
 Dynamic: requires-dist

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.1.2
+Version: 1.1.5
 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
@@ -28,6 +28,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: maintainer
 Dynamic: maintainer-email
 Dynamic: requires-dist

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/daspy/advanced_tools/channel.py

@@ -1,6 +1,6 @@
 # Purpose: Several functions for analysis data quality and geometry of channels
 # Author: Minzhe Hu, Zefeng Li
-# Date: 2024.11.18
+# Date: 2025.3.31
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from copy import deepcopy
@@ -365,62 +365,95 @@ def turning_points(data, data_type='coordinate', thresh=5, depth_info=False,
         raise ValueError('Data_type should be \'coordinate\' or \'waveform\'.')
 
 
-def _equally_spacing(channels, dist, dx):
-    if len(channels) > 20:
-        return _equally_spacing_2(channels, dist, dx)
+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)
+    for i in range(nch - 1):
+        lon0, lat0 = geometry[i, :2]
+        lon1, lat1 = geometry[i+1, :2]
+        d = Geodesic.WGS84.Inverse(lat0, lon0, lat1, lon1)['s12']
+        if depth_info:
+            dist[i] = np.sqrt(d**2 + (geometry[i+1, 2] - geometry[i, 2]) ** 2)
+        else:
+            dist[i] = d
+
+    return dist
+
+
+def distance_to_channels(geometry, points):
+    """
+    Calculate the distance from a point to each channel.
+
+    :param geometry: numpy.ndarray. It needs to consist of two columns (
+        longitude, latitude), three columns (longitude, latitude and depth).
+    :param points: numpy.ndarray. A array consisting of longitude and
+        latitude or longitude, latitude and depth.
+    :return: numpy.ndarray. The distance from the given point to each channel.
+    """
+    if geometry.shape[1] == 3:
+        depth_info = True
     else:
-        return _equally_spacing_1(channels, dist, dx)
-
-
-def _equally_spacing_1(channels, dist, dx):
-    nch = len(channels)
-    residual = np.inf
-    for i in range(2 ** (nch - 2)):
-        state = bin(i)[2:].rjust(nch - 2, '0')
-        dist_new = [dist[0]]
-        channels_new = [channels[0]]
-        idx = 0
-        for j, s in enumerate(state):
-            if s == '0':
-                dist_new[idx] += dist[j+1]
-            else:
-                dist_new.append(dist[j+1])
-                channels_new.append(channels[j+1])
-                idx += 1
-        res = sum([abs(d - dx) for d in dist_new])    
-        if res < residual:
-            residual = res
-            dist_equal = dist_new
-            channels_equal = channels_new
-    channels_equal.append(channels[-1])
-    return channels_equal, dist_equal
-
-
-def _equally_spacing_2(channels, dist, dx):
-    channels_equal = [channels[0]]
-    dist_equal = []
-    i = 0
-    while i < len(dist):
-        d = dist[i]
-        if d < dx and i < len(dist) - 1:
-            d1 = d + dist[i + 1]
-            while d1 < dx and i < len(dist) - 2:
-                d = d1
-                i += 1
-                d1 += dist[i + 1]
-            if abs(d - dx) <= abs(d1 - dx):
-                channels_equal.append(channels[i + 1])
-                dist_equal.append(d)
+        depth_info = False
+
+    nch = len(geometry)
+    points = np.array(points)
+    if points.ndim == 1:
+        points = points.reshape(1, -1)
+    npt = len(points)
+    dist = np.zeros((npt, nch))
+    for i, pt in enumerate(points):
+        for j, geo in enumerate(geometry):
+            d = Geodesic.WGS84.Inverse(pt[1], pt[0], geo[1], geo[0])['s12']
+            if depth_info:
+                dist[i, j] = np.sqrt(d**2 + (pt[2] - geo[2]) ** 2)
             else:
-                i += 1
-                channels_equal.append(channels[i + 1])
-                dist_equal.append(d1)
-        else:
-            channels_equal.append(channels[i + 1])
-            dist_equal.append(d)
-        i += 1
+                dist[i, j] = d
+    return dist
 
-    return channels_equal, dist_equal
+
+def closest_channel_to_point(geometry, points, verbose=False):
+    """
+    Find the channel number closest to a given point.
+
+    :param geometry: numpy.ndarray. It needs to consist of longitude, latitude
+        (and depth) or channel number, longitude, latitude (and depth).
+    :param points: numpy.ndarray. A tuple consisting of longitude and
+        latitude (and depth).
+    :param verbose: bool. Return the channel and the distance to the closest
+        channel if True.
+    :return: int. The channel number closest to the given point.
+    """
+    nch = len(geometry)
+    if points.shape[1] == geometry.shape[1]:
+        channels = np.arange(nch).astype(int)
+    else:
+        geometry = geometry[geometry[:, 0].argsort()]
+        channels = geometry[:, 0].astype(int)
+        geometry = geometry[:, 1:]
+
+    dist = distance_to_channels(points, geometry)
+    closest_index = np.argmin(dist, axis=1)
+    if verbose:
+        return channels[closest_index], np.min(dist, axis=1)
+    return channels[closest_index]
 
 
 def equally_spaced_channels(geometry, dx, depth_info=False, verbose=False):
@@ -446,53 +479,36 @@ def equally_spaced_channels(geometry, dx, depth_info=False, verbose=False):
         channels = geometry[:, 0].astype(int)
         geometry = geometry[:, 1:]
 
-    dist = np.zeros(nch - 1)
-    for i in range(nch - 1):
-        lon0, lat0 = geometry[i, :2]
-        lon1, lat1 = geometry[i+1, :2]
-        d = Geodesic.WGS84.Inverse(lat0, lon0, lat1, lon1)['s12']
-        if depth_info:
-            dist[i] = np.sqrt(d**2 + (geometry[i+1, 2] - geometry[i, 2]) ** 2)
-        else:
-            dist[i] = d
-
-    channels_equal = [channels[0]]
-    dist_equal = []
-    channels_seg = []
-    dist_seg = []
-    flag = False
-    for i in range(1, nch-1):
-        if dist[i-1] + dist[i] <= dx * 1.5:
-            channels_seg.append(channels[i-1])
-            dist_seg.append(dist[i-1])
-        else:
-            if len(channels_seg):
-                channels_seg.extend(channels[i-1:i+1])
-                dist_seg.append(dist[i-1])
-                channels_seg, dist_seg = _equally_spacing(channels_seg,
-                                                          dist_seg, dx)
-                dist_equal.extend(dist_seg)
-                channels_equal.extend(channels_seg[1:])
-                channels_seg = []
-                dist_seg = []
-                flag = False
-            else:
-                if flag:
-                    channels_equal.append(channels[i-1])
-                    dist_equal.append(dist[i-1])
-                else:
-                    flag = True
-
-    if len(channels_seg):
-        channels_seg.extend(channels[i:i+2])
-        dist_seg.append(dist[i])
-        channels_seg, dist_seg = _equally_spacing(channels_seg, dist_seg, dx)
-        dist_equal.extend(dist_seg)
-        channels_equal.extend(channels_seg[1:])
-    else:
-        channels_equal.extend(channels[-2:])
-        dist_equal.extend(dist[-2:])
-
-    if verbose:
-        return channels_equal, dist_equal
-    return channels_equal
+    dist = channel_spacing(geometry, depth_info=False)
+
+    s = 0
+    idx_equal = [0]
+    for i in range(nch-2):
+        if dist[i] > dx * 2:
+            e = i
+            if e == s + 1:
+                idx_equal.append(e)
+            elif e >= s + 2:
+                idx_equal.extend([idx + s for idx in
+                                  _equally_spacing(dist[s:e], dx)])
+                idx_equal.append(e)
+            s = e + 1
+            idx_equal.append(s)
+        elif dist[i] + dist[i+1] > dx * 1.5:
+            e = i + 1
+            if e == s + 1:
+                idx_equal.append(e)
+            elif e >= s + 2:
+                idx_equal.extend([idx + s for idx in
+                                  _equally_spacing(dist[s:e], dx)])
+                idx_equal.append(e)
+            s = e
+    e = nch - 1
+    if e == s + 1:
+        idx_equal.append(e)
+    elif e >= s + 2:
+        idx_equal.extend([idx + s for idx in
+                        _equally_spacing(dist[s:e], dx)])
+        idx_equal.append(e)
+
+    return channels[idx_equal]

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/daspy/advanced_tools/strain2vel.py

@@ -1,6 +1,6 @@
 # Purpose: Convert strain rate data to velocity
 # Author: Minzhe Hu
-# Date: 2024.6.8
+# Date: 2024.3.10
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from numpy.fft import irfft2, ifftshift
@@ -103,7 +103,6 @@ def curvelet_conversion(data, dx, fs, pad=0.3, scale_begin=2, nbscales=None,
     :return: numpy.ndarray. Converted data.
     """
     if turning is not None:
-        print(1)
         data_vel = np.zeros_like(data)
         start_ch = [0, *turning]
         end_ch = [*turning, len(data)]

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/daspy/basic_tools/preprocessing.py

@@ -1,6 +1,6 @@
 # Purpose: Some preprocess methods
 # Author: Minzhe Hu
-# Date: 2024.10.25
+# Date: 2025.3.10
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from scipy.signal import detrend
@@ -23,13 +23,13 @@ def phase2strain(data, lam, e, n, gl):
     return data * (lam * 1e-9) / (e * 4 * np.pi * n * gl)
 
 
-def normalization(data, method='z-score', **kwargs):
+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'.
+        'z-score', 'MAD' or 'one-bit'.
     :return: Normalized data.
     """
     if data.ndim == 1:
@@ -37,21 +37,21 @@ def normalization(data, method='z-score', **kwargs):
     elif data.ndim != 2:
         raise ValueError("Data should be 1-D or 2-D array")
 
-    if method == 'max':
+    if method.lower() == 'max':
         amp = np.max(abs(data), 1, keepdims=True)
         amp[amp == 0] = amp[amp > 0].min()
         return data / amp
-
-    if method == 'z-score':
+    elif method.lower() == '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()
-        if 'p' in kwargs.keys():
-            thresh = np.percentile(std, kwargs['p'])
-            std[std > thresh] = thresh
         return (data - mean) / std
-
-    if method == 'one-bit':
+    elif method.lower() == 'mad':
+        median = np.median(data, axis=1, keepdims=True)
+        mad = np.median(abs(data - median), axis=1, keepdims=True)
+        mad[mad == 0] = mad[mad > 0].min()
+        return (data - median) / mad
+    elif method.lower() == 'one-bit':
         return np.sign(data)
 
 

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/daspy/core/collection.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Collection objects.
 # Author: Minzhe Hu
-# Date: 2025.1.23
+# Date: 2025.3.30
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -18,7 +18,8 @@ cascade_method = ['time_integration', 'time_differential', 'downsampling',
 
 class Collection(object):
     def __init__(self, fpath, ftype=None, flength=None, meta_from_file=True,
-                 timeinfo_format=None, timeinfo_from_basename=True, **kwargs):
+                 timeinfo_slice=slice(None), timeinfo_format=None, 
+                 timeinfo_tz=None, timeinfo_from_basename=True, **kwargs):
         """
         :param fpath: str or Sequence of str. File path(s) containing data.
         :param ftype: None or str. None for automatic detection, or 'pkl',
@@ -28,7 +29,11 @@ class Collection(object):
             and gauge_length. True for extracting dt, dx, fs and gauge_length
             from first 2 file. 'all' for exracting and checking these metadata
             from all file.
-        :param timeinfo_format: str or (slice, str). Format for extracting start
+        :param timeinfo_slice: slice. Slice for extracting start time from file
+            name.
+        :param timeinfo_format: str. Format for extracting start time from file
+            name.
+        :param timeinfo_tz: datetime.timezone. Time zone for extracting start
             time from file name.
         :param timeinfo_from_basename: bool. If True, timeinfo_format will use
             DASDateTime.strptime to basename of fpath.
@@ -90,17 +95,22 @@ class Collection(object):
                     setattr(self, key, metadata[i])
 
         if not hasattr(self, 'ftime'):
-            if isinstance(timeinfo_format, tuple):
-                timeinfo_slice, timeinfo_format = timeinfo_format
-            else:
-                timeinfo_slice = slice(None)
             if timeinfo_from_basename:
-                self.ftime = [DASDateTime.strptime(
-                    os.path.basename(f)[timeinfo_slice], timeinfo_format)
-                    for f in self.flist]
+                flist_use = [os.path.basename(f) for f in self.flist]
             else:
+                flist_use = self.flist
+            if timeinfo_tz is None:
                 self.ftime = [DASDateTime.strptime(f[timeinfo_slice],
-                    timeinfo_format) for f in self.flist]
+                    timeinfo_format) for f in flist_use]
+            else:
+                if '%z' in timeinfo_format.lower():
+                    self.ftime = [DASDateTime.strptime(f[timeinfo_slice],
+                        timeinfo_format).astimezone(timeinfo_tz) for f in
+                        flist_use]
+                else:
+                    self.ftime = [DASDateTime.strptime(f[timeinfo_slice],
+                        timeinfo_format).replace(tzinfo=timeinfo_tz) for f in
+                        flist_use]
 
         self._sort()
         if flength is None:

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/daspy/core/dasdatetime.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling DASDateTime objects.
 # Author: Minzhe Hu
-# Date: 2025.2.11
+# Date: 2025.3.29
 # Email: hmz2018@mail.ustc.edu.cn
 import time
 from typing import Iterable
@@ -12,8 +12,6 @@ local_tz = timezone(timedelta(seconds=-time.altzone))
 
 
 class DASDateTime(datetime):
-
-
     def __add__(self, other):
         if isinstance(other, Iterable):
             out = []
@@ -48,10 +46,10 @@ class DASDateTime(datetime):
     def __gt__(self, other):
         return datetime.__gt__(*self._unify_tz(other))
 
-    def _unify_tz(self, other):
-        if self.tzinfo and not other.tzinfo:
+    def _unify_tz(self, other: datetime):
+        if self.tzinfo and (not other.tzinfo):
             return self, other.replace(tzinfo=self.tzinfo)
-        elif not self.tzinfo and other.tzinfo:
+        elif (not self.tzinfo) and other.tzinfo:
             return self.replace(tzinfo=other.tzinfo), other
         return self, other
 

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/daspy/core/section.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Section objects.
 # Author: Minzhe Hu
-# Date: 2025.2.25
+# Date: 2025.4.2
 # Email: hmz2018@mail.ustc.edu.cn
 import warnings
 import os
@@ -169,6 +169,10 @@ class Section(object):
     @property
     def distance(self):
         return self.nch * self.dx
+    
+    @property
+    def channel_distance(self):
+        return self.dx * np.arange(self.nch) + self.start_channel
 
     @property
     def end_distance(self):
@@ -497,7 +501,10 @@ class Section(object):
         :param xlog, ylog: bool. If True, set the x-axis' or y-axis' scale as
             log.
         :param xinv, yinv: bool. If True, invert x-axis or y-axis.
-        :param xaxis, yaxis: bool. Show ticks and labels for 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.
@@ -617,7 +624,7 @@ class Section(object):
         Normalize for each individual channel using Z-score method.
 
         :param method: str. Method for normalization, should be one of 'max',
-            'z-score', or 'one-bit'.
+            'z-score', 'MAD' or 'one-bit'.
         """
         self.data = normalization(self.data, method=method)
         if hasattr(self, 'data_type'):

{daspy_toolbox-1.1.2 → daspy_toolbox-1.1.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 
 setup(
-    name='DASPy-toolbox', version='1.1.2',
+    name='DASPy-toolbox', version='1.1.5',
     description=(
         'DASPy is an open-source project dedicated to provide a python package '
         'for DAS (Distributed Acoustic Sensing) data processing, which '