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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.2.1
+Version: 1.2.3
 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.2.1 → daspy_toolbox-1.2.3}/PKG-INFO

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

@@ -181,7 +181,7 @@ def _channel_location(track_pt):
     return np.array(seg_interval), np.array(interp_ch)
 
 
-def location_interpolation(known_pt, track_pt=None, dx=2, data_type='lonlat',
+def location_interpolation(known_pt, track_pt=None, dx=1, data_type='lonlat',
                            verbose=False):
     """
     Interpolate to obtain the positions of all channels.
@@ -209,7 +209,8 @@ def location_interpolation(known_pt, track_pt=None, dx=2, data_type='lonlat',
             .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])
+        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\'')

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/advanced_tools/strain2vel.py

@@ -23,14 +23,14 @@ def fk_rescaling(data, dx, fs, taper=(0.02, 0.05), pad='default', fmax=None,
     :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.
+        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 fmax, kmin, vmax: float or or sequence of 2 floats. Sequence of 2
         floats represents the start and end of taper. Setting these parameters
         can reduce artifacts.
@@ -71,7 +71,8 @@ def fk_rescaling(data, dx, fs, taper=(0.02, 0.05), pad='default', fmax=None,
         kk = np.tile(k, (len(f), 1)).T
         vv = - np.divide(ff, kk, out=np.ones_like(ff) * 1e10, where=kk != 0)
 
-        mask = fk_fan_mask(f, k, fmax=fmax, kmin=kmin, vmax=vmax, edge=edge) * vv
+        mask = fk_fan_mask(f, k, fmax=fmax, kmin=kmin, vmax=vmax, edge=edge) \
+            * vv
         mask[kk == 0] = 0
 
         data_vel = irfft2(ifftshift(fk * mask, axes=0)).real[:nch, :nt]
@@ -91,12 +92,12 @@ def curvelet_conversion(data, dx, fs, pad=0.3, scale_begin=2, nbscales=None,
     :param data: numpy.ndarray. Data to convert.
     :param dx: Channel interval in m.
     :param fs: Sampling rate in Hz.
-    :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 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 conversion.
-    :param nbscales: int. Number of scales including the coarsest wavelet level.
-        Default set to ceil(log2(min(M,N)) - 3).
+    :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 turning: Sequence of int. Channel number of turning points.
@@ -110,7 +111,8 @@ def curvelet_conversion(data, dx, fs, pad=0.3, scale_begin=2, nbscales=None,
             data_vel[s:e] = curvelet_conversion(data[s:e], dx, fs, pad=pad,
                                                 scale_begin=scale_begin,
                                                 nbscales=nbscales,
-                                                nbangles=nbangles, turning=None)
+                                                nbangles=nbangles,
+                                                turning=None)
     else:
         if pad is None or pad is False:
             pad = 0
@@ -227,8 +229,8 @@ def slant_stacking(data, dx, fs, L=None, slm=0.01,
         for (s, e) in zip(start_ch, end_ch):
             channel_seg = [ch-s for ch in range(s,e) if ch in channel]
             if len(channel_seg):
-                d_vel = slant_stacking(data[s:e], dx, fs, L=L, slm=slm, sls=sls,
-                                       frqlow=frqlow, frqhigh=frqhigh,
+                d_vel = slant_stacking(data[s:e], dx, fs, L=L, slm=slm,
+                                       sls=sls, frqlow=frqlow, frqhigh=frqhigh,
                                        turning=None, channel=channel_seg)
                 data_vel = np.vstack((data_vel, d_vel))
     else:

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

@@ -1,6 +1,6 @@
 # Purpose: Analyze frequency attribute and transform in frequency domain
 # Author: Minzhe Hu
-# Date: 2024.6.17
+# Date: 2025.11.12
 # Email: hmz2018@mail.ustc.edu.cn
 import numpy as np
 from numpy.fft import rfft, rfft2, fftshift, fftfreq, rfftfreq
@@ -147,3 +147,13 @@ def fk_transform(data, dx, fs, taper=(0, 0.05), nfft='default'):
     f = rfftfreq(nfft[1], d=1. / fs)
     k = fftshift(fftfreq(nfft[0], d=dx))
     return fk, f, k
+
+
+def power(data):
+    """
+    Calculate the power of each channel.
+
+    :param data: numpy.ndarray. Data to calculate the power.
+    :return: numpy.ndarray. Power of each channel.
+    """
+    return np.sqrt(np.mean(data ** 2, axis=-1))

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

@@ -19,10 +19,10 @@ def phase2strain(data, lam, e, n, gl):
     :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.
+    :paran guage_length: float. Gauge length.
     :return: Strain data.
     """
-    return data * (lam * 1e-9) / (e * 4 * np.pi * n * gl)
+    return data * lam / (e * 4 * np.pi * n * gl)
 
 
 def normalization(data, method='z-score'):
@@ -121,9 +121,9 @@ def cosine_taper(data, p=0.1, side='both'):
     if not isinstance(p, (tuple, list, np.ndarray)):
         win = tukey(nsp, p)
         if side == 'left':
-            win[round(nch/2):] = 1
+            win[round(nsp/2):] = 1
         elif side == 'right':
-            win[:round(len(win)/2)] = 1
+            win[:round(nsp/2)] = 1
         return data * np.tile(win, (nch, 1))
     else:
         if p[0] > 0:

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

@@ -11,9 +11,9 @@ 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, 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):
+         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.
 
@@ -42,19 +42,20 @@ def plot(data: np.ndarray, dx=None, fs=None, ax=None, obj='waveform', dpi=300,
     :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 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'.
     :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 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 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.
     """

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/core/collection.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Collection objects.
 # Author: Minzhe Hu
-# Date: 2025.9.18
+# Date: 2025.11.26
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -228,6 +228,8 @@ class Collection(object):
         :param spmin, spmax: int. Sampling point range. Only used when
             readsec=True.
         """
+        if start is None:
+            start = 0
         if end is None:
             end = len(self.flist)
         if 'stime' in kwargs.keys():
@@ -239,10 +241,16 @@ class Collection(object):
             warnings.warn('In future versions, the parameter \'etime\' will be '
                           'replaced by \'end\'.')
 
-        if start is None and 'tmin' in kwargs.keys():
-            start = kwargs['tmin']
-        if end is None and 'tmax' in kwargs.keys():
-            end = kwargs['tmax']
+        if start is None:
+            if 'tmin' in kwargs.keys():
+                start = kwargs['tmin']
+            else:
+                start = 0
+        if end is None:
+            if 'tmax' in kwargs.keys():
+                end = kwargs['tmax']
+            else:
+                end = len(self)
 
         if isinstance(start, datetime):
             for i, ftime in enumerate(self.ftime):
@@ -288,6 +296,18 @@ class Collection(object):
             self.ftime = self.ftime[s:e]
             return self
 
+    def read(self, **kwargs):
+        return self.select(readsec=True, **kwargs)
+
+    def continuous_acquisition(self):
+        index = self.file_interruption()
+        index = [-1] + index.tolist() + [len(self)-1]
+        coll_list = []
+        for i in range(len(index) - 1):
+            coll = self.copy().select(start=index[i]+1, end=index[i+1]+1)
+            coll_list.append(coll)
+        return coll_list
+
     def _optimize_for_continuity(self, operations):
         method_list = []
         kwargs_list = []
@@ -296,8 +316,10 @@ class Collection(object):
         for opera in operations:
             method, kwargs = opera
             if method == 'downsampling':
-                if ('lowpass_filter' in kwargs.keys() and not\
-                    kwargs['lowpass_filter']) or 'tint' not in kwargs.keys():
+                if_filter = ('tint' not in kwargs.keys() and 'fs' not in
+                    kwargs.keys()) or ('lowpass_filter' in kwargs.keys() and
+                    not kwargs['lowpass_filter'])
+                if if_filter:
                     method_list.append('downsampling')
                     kwargs_list.append(kwargs)
                 else:
@@ -356,9 +378,9 @@ class Collection(object):
                 (not os.path.exists(kwargs_file)):
                 raise ValueError('No operations input and no method_list.pkl '
                                  'and kwargs_list.pkl found in savepath.')
-            with open(os.path.join(savepath, 'method_list.pkl'), 'wb') as f:
+            with open(os.path.join(savepath, 'method_list.pkl'), 'rb') as f:
                 method_list = pickle.load(f)
-            with open(os.path.join(savepath, 'kwargs_list.pkl'), 'wb') as f:
+            with open(os.path.join(savepath, 'kwargs_list.pkl'), 'rb') as f:
                 kwargs_list = pickle.load(f)
         else:
             method_list, kwargs_list = self._optimize_for_continuity(operations)

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/core/dasdatetime.py

@@ -9,7 +9,7 @@ from datetime import datetime, timedelta, timezone
 
 
 utc = timezone.utc
-local_tz = timezone(timedelta(seconds=-time.altzone))
+local_tz = timezone(timedelta(seconds=-time.timezone))
 
 
 class DASDateTime(datetime):
@@ -69,7 +69,7 @@ class DASDateTime(datetime):
 
     @classmethod
     def from_obspy_UTCDateTime(cls, dt):
-        return cls.from_datetime(dt.datetime)
+        return cls.from_datetime(dt.datetime).replace(tzinfo=utc)
 
     def to_datetime(self):
         return datetime.fromtimestamp(self.timestamp(), tz=self.tzinfo)

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/core/read.py

@@ -1,15 +1,17 @@
 # Purpose: Module for reading DAS data.
-# Author: Minzhe Hu
-# Date: 2025.10.30
+# Author: Minzhe Hu, Ji Zhang
+# Date: 2025.11.19
 # Email: hmz2018@mail.ustc.edu.cn
 # Partially modified from
 # https://github.com/RobbinLuo/das-toolkit/blob/main/DasTools/DasPrep.py
 import warnings
+import inspect
 import json
 import pickle
 import numpy as np
 import h5py
 import segyio
+from functools import wraps
 from typing import Union
 from pathlib import Path
 from nptdms import TdmsFile
@@ -73,13 +75,8 @@ def read(fname=None, output_type='section', ftype=None, file_format='auto',
         kwargs['chmin'] = kwargs.pop('ch1', None)
         kwargs['chmax'] = kwargs.pop('ch2', None)
     if callable(ftype):
-        try:
-            data, metadata = ftype(fname, headonly=headonly, **kwargs)
-        except TypeError:
-            data, metadata = ftype(fname)
-            si, sj, metadata = _trimming_slice_metadata(data.shape,
-                metadata=metadata, **kwargs)
-            data = data[si, sj]
+        ftype = with_trimming(ftype)
+        data, metadata = ftype(fname, headonly=headonly, **kwargs)
     else:
         for rtp in [('pickle', 'pkl'), ('hdf5', 'h5'), ('segy', 'sgy')]:
             ftype = ftype.replace(*rtp)
@@ -97,6 +94,60 @@ def read(fname=None, output_type='section', ftype=None, file_format='auto',
         return data, metadata
 
 
+def with_trimming(func):
+    """
+    Decorator that wraps a custom reader so it automatically supports
+    trimming parameters (chmin, chmax, dch, xmin, xmax, tmin, tmax, spmin, spmax).
+    """
+
+    @wraps(func)
+    def wrapper(fname, headonly=False, **kwargs):
+        # trimming-related parameters
+        trim_keys = ['chmin', 'chmax', 'dch', 'xmin', 'xmax', 'tmin', 'tmax',
+                     'spmin', 'spmax']
+        sig = inspect.signature(func)
+        reader_params = set(sig.parameters.keys())
+        trim_for_reader = {k: kwargs.pop(k) for k in trim_keys if k in kwargs \
+                           and k in reader_params}
+        trim_for_trimming = {k: kwargs.pop(k) for k in trim_keys if k in \
+                             kwargs and k not in reader_params}
+        try:
+            data, metadata = func(fname, headonly=headonly, **trim_for_reader,
+                                  **kwargs)
+        except TypeError:
+            headonly = False
+            data, metadata = func(fname, **trim_for_reader)
+
+        shape = data.shape
+        si, sj, metadata = _trimming_slice_metadata(shape, metadata=metadata,
+                                                    **trim_for_trimming)
+        if headonly:
+            data = np.zeros(shape)[si, sj]
+        else:
+            data = data[si, sj]
+
+        return data, metadata
+
+    return wrapper
+
+
+class DummyObject:
+    def __init__(self, *args, **kwargs):
+        pass
+
+
+class SafeUnpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        try:
+            return super().find_class(module, name)
+        except ModuleNotFoundError:
+            print(f"Skip missing module: {module}.{name}")
+            return DummyObject
+        except AttributeError:
+            print(f"Skip missing class: {module}.{name}")
+            return DummyObject
+
+
 def _read_pkl(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
               dch=1, xmin=None, xmax=None, tmin=None, tmax=None, spmin=None,
               spmax=None):
@@ -104,7 +155,8 @@ def _read_pkl(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
     Read data and metadata from a pickle file.
     """
     with open(fname, 'rb') as f:
-        pkl_data = pickle.load(f)
+        # pkl_data = pickle.load(f)
+        pkl_data = SafeUnpickler(f).load()
         if isinstance(pkl_data, np.ndarray):
             warnings.warn('This data format doesn\'t include channel interval'
                           'and sampling rate. Please set manually')
@@ -290,6 +342,34 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
                         'start_time': stime,
                         'gauge_length': attrs['GaugeLength']}
 
+        elif file_format == 'Puniu Tech HiFi-DAS':
+            dataset = h5_file['default']
+            if 'time,channel' in attrs.get('row_major_order', 'time, channel')\
+                .replace(' ', '').lower():
+                transpose = True
+
+            attrs = {k: (v.decode() if isinstance(v, bytes) else v) for k, v
+                     in dataset.attrs.items()}
+            step = int(attrs['step'])
+            dx = step * attrs.get('spatial_sampling_rate', 1.0)
+            start_channel = int(attrs['start_channel'])
+            if step != 1:
+                if chmin:
+                    chmin = (chmin - start_channel) / step + start_channel
+                if chmax:
+                    chmax = (chmin - start_channel) / step + start_channel
+            t0 = int(attrs.get('epoch', 0)) + int(attrs.get('ns', 0)) * 1e-9
+            data_type = 'strain rate' if attrs.get('format', '') == \
+                'differential' else 'strain',
+            metadata = {'dx': dx, 'fs': float(attrs['sampling_rate']),
+                        'start_channel': start_channel,
+                        'start_distance': start_channel * dx,
+                        'start_time': DASDateTime.fromtimestamp(t0, tz=utc),
+                        'scale': 110.37, 'data_type': data_type,
+                        'cid': attrs.get('cid', '')}
+            if 'spatial_resolution' in attrs.keys():
+                metadata['gauge_length'] = float(attrs['spatial_resolution'])
+
         elif file_format == 'Silixa iDAS':
             dataset = h5_file['Acquisition/Raw[0]/RawData/']
             attrs = h5_file['Acquisition/Raw[0]'].attrs
@@ -356,13 +436,36 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
             metadata = {'dx': h5_file['Sampling_interval_in_space'][0],
                         'fs': 1 / h5_file['Sampling_interval_in_time'][0]}
 
+        elif file_format == 'NEC':
+            dataset = h5_file['data']
+            dx = dataset.attrs['Interval of monitor point']
+            fs = 1.0 / (dataset.attrs['Interval time of data'] / 1000.0) # Hz
+            if dataset.shape[0] != \
+                dataset.attrs['Number of requested location points']:
+                transpose = True
+            try:
+                scale = dataset.attrs['Radians peer digital value']
+            except KeyError:
+                try:
+                    scale = dataset.attrs['Radians per digital value']
+                except KeyError:
+                    scale = 1
+            # start_time = datetime(1970, 1, 1) + \
+            # timedelta(milliseconds=start_unix_epoch_in_ms)
+            start_time = DASDateTime.fromtimestamp(
+                np.float64(dataset.attrs['Time of sending request']) / 1e3
+                ).utc()
+            metadata = {'fs': fs, 'dx': dx, 'start_time': start_time,
+                        'gauge_length': dataset.attrs['Gauge length'],
+                        'scale': scale, 'data_type':'strain rate'}
+
         elif file_format == 'FORESEE':
             dataset = h5_file['raw']
             fs = round(1 / np.diff(h5_file['timestamp']).mean())
             start_time = DASDateTime.fromtimestamp(
                 h5_file['timestamp'][0]).astimezone(utc)
-            warnings.warn('This data format doesn\'t include channel interval. '
-                            'Please set manually')
+            warnings.warn('This data format doesn\'t include channel interval.'
+                          ' Please set manually')
             metadata = {'dx': None, 'fs': fs, 'start_time': start_time}
 
         elif file_format == 'AI4EPS': # https://ai4eps.github.io/homepage/ml4earth/seismic_event_format_das/
@@ -399,7 +502,13 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
         metadata['headers'] = _read_h5_headers(h5_file)
         shape = dataset.shape
         if len(shape) == 3:
-            shape = (shape[0] * shape[1], shape[2])
+            if headonly:
+                fs = int(metadata['fs'])
+                fs_b = attrs.get('BlockRate', [1000])[0] / 1e3
+                nsp_b = round(fs/fs_b)
+                shape = (shape[0] * nsp_b, shape[2])
+            else:
+                shape = (shape[0] * shape[1], shape[2])
         if transpose:
             shape = shape[::-1]
         si, sj, metadata = _trimming_slice_metadata(shape, metadata=metadata,
@@ -500,7 +609,6 @@ def _read_tdms(fname, headonly=False, file_format='auto', chmin=None,
                 data = np.asarray([tdms_file[key][str(ch)][sj] for ch in
                                    range(si.start, si.stop, si.step)])
         elif file_format == 'Institute of Semiconductors, CAS':
-
             try:
                 start_channel = int(properties['Initial Channel'])
             except KeyError:

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/core/section.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Section objects.
 # Author: Minzhe Hu
-# Date: 2025.10.31
+# Date: 2025.11.19
 # Email: hmz2018@mail.ustc.edu.cn
 import warnings
 import os
@@ -21,7 +21,7 @@ from daspy.basic_tools.preprocessing import (phase2strain, normalization,
 from daspy.basic_tools.filter import (bandpass, bandstop, lowpass,
                                       lowpass_cheby_2, highpass, envelope)
 from daspy.basic_tools.freqattributes import (spectrum, spectrogram, psd,
-                                              fk_transform)
+                                              fk_transform, power)
 from daspy.advanced_tools.channel import channel_checking, turning_points
 from daspy.advanced_tools.denoising import (curvelet_denoising,
                                             common_mode_noise_removal,
@@ -68,6 +68,7 @@ class Section(object):
         opt_attrs = ['origin_time', 'gauge_length', 'data_type', 'scale',
                      'geometry', 'turning_channels', 'headers', 'source',
                      'source_type', 'file_format']
+        kwargs.setdefault('scale', 1)
         for attr in opt_attrs:
             if attr in kwargs:
                 setattr(self, attr, kwargs.pop(attr))
@@ -195,7 +196,7 @@ class Section(object):
 
     @property
     def end_channel(self):
-        return self.start_channel + self.nch - 1
+        return self.start_channel + self.nch
 
     @property
     def distance(self):
@@ -462,8 +463,8 @@ class Section(object):
         :param ftype: None or str. None for automatic detection), or 'pkl',
             'pickle', 'tdms', 'h5', 'hdf5', 'segy', 'sgy', 'npy'.
         :param keep_format: bool. If True, we will make a copy of the
-            self.source file and make changes to it. This will strictly preserve
-            the original format, but will cost more IO resources.
+            self.source file and make changes to it. This will strictly
+            preserve the original format, but will cost more IO resources.
         :param dtype: str. The data type of the saved data.
         :param file_format: Format in which the file is saved. Only works when
             keep_format == False. 'auto' for raw file format or the most common
@@ -646,9 +647,11 @@ class Section(object):
                 if hasattr(self, 'origin_time'):
                     kwargs['t0'] -= self.origin_time
                     if ('transpose' in kwargs.keys()) and kwargs['transpose']:
-                        kwargs.setdefault('xlabel', 'Times(s) after occurance')
+                        kwargs.setdefault('xlabel',
+                                          'Times after occurance (s)')
                     else:
-                        kwargs.setdefault('ylabel', 'Times(s) after occurance')
+                        kwargs.setdefault('ylabel',
+                                          'Times after occurance (s)')
                 else:
                     tmode == 'start'
             if tmode == 'start':
@@ -1096,12 +1099,13 @@ class Section(object):
         if ('ch1' in kwargs.keys()) or ('ch2' in kwargs.keys()):
             kwargs['chmin'] = kwargs.pop('ch1', 0)
             kwargs['chmax'] = kwargs.pop('ch2', self.nch)
-            warnings.warn("'ch1' and 'ch2' attribute will be renamed to 'chmin'"
-                          " and 'chmax' in a future release.", FutureWarning)
+            warnings.warn("'ch1' and 'ch2' attribute will be renamed to "
+                          "'chmin' and 'chmax' in a future release.",
+                          FutureWarning)
         if 'nch' in kwargs.keys():
             kwargs['dch'] = kwargs.pop('nch', 1)
-            warnings.warn("'nch' attribute will be renamed to 'dch' in a future"
-                          " release.", FutureWarning)
+            warnings.warn("'nch' attribute will be renamed to 'dch' in a "
+                          "future release.", FutureWarning)
 
         if 'chmin' in kwargs.keys():
             chmin = int(kwargs.pop('chmin') - self.start_channel)
@@ -1132,6 +1136,14 @@ class Section(object):
         """
         return fk_transform(self.data, self.dx, self.fs, **kwargs)
 
+    def power(self):
+        """
+        Calculate the power of each channel.
+
+        :return: numpy.ndarray. Power of each channel.
+        """
+        return power(self.data)
+
     def channel_checking(self, use=False, **kwargs):
         """
         Use the energy of each channel to determine which channels are bad.

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/core/util.py

@@ -21,13 +21,16 @@ def _device_standardized_name(file_format: str) -> str:
         'OptaSense ODH4+': ['optasenseodh4+', 'odh4+', 'optasenseodh4plus',
                             'odh4plus'],
         'OptaSense QuantX': ['optasensequantx', 'quantx'],
+        'Puniu Tech HiFi-DAS': ['puniutechhifidas, puniu, puniutech, hifidas',
+                                'puniuhifidas', 'puniudas'],
         'Silixa iDAS': ['silixaidas', 'silixaidasv1', 'idasv1', 'idas'],
         'Silixa iDAS-v2': ['silixaidasv2', 'idasv2'],
         'Silixa iDAS-v3': ['silixaidasv3', 'idasv3'],
         'Silixa iDAS-MG': ['silixaidasmg', 'idasmg'],
         'Silixa Carina': ['silixacarina', 'carina'],
-        'Sintela Onyx v1.0': ['sintelaonyxv1.0', 'sintelaonyxv1', 'sintalaonyx',
-                              'sintela', 'onyxv1.0', 'onyxv1', 'onyx'],
+        'Sintela Onyx v1.0': ['sintelaonyxv1.0', 'sintelaonyxv1',
+                              'sintalaonyx', 'sintela', 'onyxv1.0', 'onyxv1',
+                              'onyx'],
         'T8 Sensor': ['t8sensor', 't8'],
         'Smart Earth ZD-DAS': ['smartearthzddas', 'smartearth', 'zddas',
                                'smartearthsensingzddas', 'smartearthsensing',
@@ -37,7 +40,9 @@ def _device_standardized_name(file_format: str) -> str:
                                              'instituteofsemiconductorscas'],
         'AI4EPS': ['ai4eps', 'daseventdata'],
         'INGV': ['ingv', 'istitutonazionaledigeofisicaevulcanologia'],
-        'JAMSTEC': ['jamstec', 'japanagencyformarineearthscienceandtechnology'],
+        'JAMSTEC': ['jamstec',
+                    'japanagencyformarineearthscienceandtechnology'],
+        'NEC': ['nec', 'nipponelectriccompany'],
         'FORESEE': ['forsee', 'fiberopticforenvironmentsenseing'],
         'Unknown0': ['unknown0'],
         'Unknown': ['unknown', 'other']
@@ -88,16 +93,22 @@ def _h5_file_format(h5_file):
                 file_format = 'Sintela Onyx v1.0'
         except KeyError:
             pass
+    elif 'default' in keys:
+        file_format = 'Puniu Tech HiFi-DAS'
     elif set(keys) == {'Mapping', 'Acquisition'}:
         file_format = 'Silixa iDAS'
-    elif list(keys) == ['data']:
-        file_format == 'AI4EPS'
     elif set(keys) == {'ChannelMap', 'Fiber', 'cm', 't', 'x'}:
         file_format = 'INGV'
     elif set(keys) == {'DAS_record', 'Sampling_interval_in_space',
                        'Sampling_interval_in_time', 'Sampling_points_in_space',
                        'Sampling_points_in_time'}:
         file_format = 'JAMSTEC'
+    elif list(keys) == ['data']:
+        if 'Interval of monitor point' in \
+            list(h5_file['data'].attrs['Interval of monitor point'].keys()):
+            file_format = 'NEC'
+        else:
+            file_format = 'AI4EPS'
     elif set(keys) == {'raw', 'timestamp'}:
         file_format = 'FORESEE'
     elif list(keys) == ['ProcessedData']:

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/daspy/core/write.py

@@ -1,6 +1,6 @@
 # Purpose: Module for writing DAS data.
 # Author: Minzhe Hu
-# Date: 2025.9.18
+# Date: 2025.11.19
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -35,8 +35,10 @@ def write(sec, fname, ftype=None, raw_fname=None, dtype=None,
 
 
 def write_pkl(sec, fname):
+    save_dict = sec.__dict__
+    save_dict.pop('source', None)
     with open(fname, 'wb') as f:
-        pickle.dump(sec.__dict__, f)
+        pickle.dump(save_dict, f)
     return None
 
 
@@ -192,9 +194,39 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                 h5_file.get('Acquisition/Raw[0]/').\
                     create_dataset('RawDataTime', data=datatime)
                 h5_file['Acquisition/Raw[0]'].attrs['OutputDataRate'] = sec.fs
-                h5_file['Acquisition'].attrs['SpatialSamplingInterval'] = sec.dx
-                h5_file['Acquisition'].attrs['GaugeLength'] = sec.gauge_length \
-                    if hasattr(sec, 'gauge_length') else -1
+                h5_file['Acquisition'].attrs['SpatialSamplingInterval'] = \
+                    sec.dx
+                h5_file['Acquisition'].attrs['GaugeLength'] = \
+                    sec.gauge_length if hasattr(sec, 'gauge_length') else -1
+
+            elif file_format == 'Puniu Tech HiFi-DAS':
+                h5_file.create_dataset('default', data=sec.data)
+                h5_file['default'].attrs['row_major_order'] = 'channel, time'
+                h5_file['default'].attrs['spatial_sampling_rate'] = sec.dx
+                h5_file['default'].attrs['step'] = 1
+                h5_file['default'].attrs['sampling_rate'] = sec.fs
+                h5_file['default'].attrs['start_channel'] = sec.start_channel
+                if isinstance(sec.start_time, datetime):
+                    t0 = sec.start_time.timestamp()
+                else:
+                    t0 = sec.start_time
+                epoch = int(t0)
+                h5_file['default'].attrs['epoch'] = epoch
+                h5_file['default'].attrs['ns'] = int(round((t0 - epoch) * 1e9))
+                if hasattr(sec, 'data_type'):
+                    h5_file['default'].attrs['format'] = 'differential' if \
+                        sec.data_type == 'strain rate' else sec.data_type
+                else:
+                    h5_file['default'].attrs['format'] = 'unknown'
+                
+                if hasattr(sec, 'gauge_length'):
+                    h5_file['default'].attrs['spatial_resolution'] = \
+                        sec.gauge_length
+                try:
+                    h5_file['default'].attrs['cid'] = \
+                        sec.headers['default']['attrs']['cid']
+                except KeyError:
+                    h5_file['default'].attrs['cid'] = 'unknown'
 
             elif file_format == 'Silixa iDAS':
                 h5_file.create_group('Acquisition/Raw[0]')
@@ -273,7 +305,6 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                 h5_file.attrs['FilterGain'] = 116e-9 * sec.fs / gauge_length / \
                     8192 / scale
 
-
             elif file_format in 'JAMSTEC':
                 h5_file.create_dataset('DAS_record', data=sec.data)
                 h5_file.create_dataset('Sampling_interval_in_space',
@@ -281,6 +312,23 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                 h5_file.create_dataset('Sampling_interval_in_time',
                                        data=[1/sec.fs])
 
+            elif file_format == 'NEC':
+                h5_file.create_dataset('data', data=sec.data)
+                h5_file['data'].attrs['Interval of monitor point'] = sec.dx
+                h5_file['data'].attrs['Number of requested location points'] \
+                    = sec.nch
+                h5_file['data'].attrs['Interval time of data'] = \
+                    1 / sec.fs * 1e3
+                h5_file['data'].attrs['Radians per digital value'] = \
+                    sec.scale if hasattr(sec, 'scale') else 1
+                if isinstance(sec.start_time, datatime):
+                    t0 = sec.start_time.timestamp()
+                else:
+                    t0 = sec.start_time
+                h5_file['data'].attrs['Time of sending request'] = t0 * 1e3
+                h5_file['data'].attrs['Gauge length'] = sec.gauge_length if \
+                    hasattr(sec, 'gauge_length') else -1
+
             elif file_format == 'FORESEE':
                 h5_file.create_dataset('raw', data=sec.data)
                 start_time = sec.start_time.timestamp() if \
@@ -463,9 +511,42 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                 _update_h5_dataset(h5_file, 'Acquisition/Raw[0]/',
                                     'RawDataTime', DataTime)
                 h5_file['Acquisition/Raw[0]'].attrs['OutputDataRate'] = sec.fs
-                h5_file['Acquisition'].attrs['SpatialSamplingInterval'] = sec.dx
-                h5_file['Acquisition'].attrs['GaugeLength'] = sec.gauge_length \
-                    if hasattr(sec, 'gauge_length') else -1
+                h5_file['Acquisition'].attrs['SpatialSamplingInterval'] = \
+                    sec.dx
+                h5_file['Acquisition'].attrs['GaugeLength'] = \
+                    sec.gauge_length if hasattr(sec, 'gauge_length') else -1
+
+            elif file_format == 'Puniu Tech HiFi-DAS':
+                attrs = {k: (v.decode() if isinstance(v, bytes) else v) for k,
+                         v in h5_file['default'].attrs.items()}
+                if 'time,channel' in attrs.get('row_major_order',
+                    'time, channel').replace(' ', '').lower():
+                    _update_h5_dataset(h5_file, '/', 'default', sec.data.T)
+                else:
+                    _update_h5_dataset(h5_file, '/', 'default', sec.data)
+
+                h5_file['default'].attrs['spatial_sampling_rate'] = sec.dx / \
+                    attrs['step']
+                h5_file['default'].attrs['sampling_rate'] = sec.fs
+                h5_file['default'].attrs['start_channel'] = sec.start_channel
+                if isinstance(sec.start_time, datetime):
+                    t0 = sec.start_time.timestamp()
+                else:
+                    t0 = sec.start_time
+                epoch = int(t0)
+                h5_file['default'].attrs['epoch'] = epoch
+                h5_file['default'].attrs['ns'] = int(round((t0 - epoch) * 1e9))
+                if hasattr(sec, 'data_type'):
+                    h5_file['default'].attrs['format'] = 'differential' if \
+                        sec.data_type == 'strain rate' else sec.data_type
+                if hasattr(sec, 'gauge_length'):
+                    h5_file['default'].attrs['spatial_resolution'] = \
+                        sec.gauge_length
+                try:
+                    h5_file['default'].attrs['cid'] = \
+                        sec.headers['default']['attrs']['cid']
+                except KeyError:
+                    pass
 
             elif file_format == 'Silixa iDAS':
                 if h5_file['Acquisition/Raw[0]/RawData/'].shape[0] != \
@@ -538,6 +619,24 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                 _update_h5_dataset(h5_file, '/', 'Sampling_interval_in_time',
                                    [1/sec.fs])
 
+            elif file_format == 'NEC':
+                _update_h5_dataset(h5_file, '/', 'data', sec.data)
+                h5_file['data'].attrs['Interval of monitor point'] = sec.dx
+                h5_file['data'].attrs['Number of requested location points'] \
+                    = sec.nch
+                h5_file['data'].attrs['Interval time of data'] = \
+                    1 / sec.fs * 1e3
+                if hasattr(sec, scale):
+                    h5_file['data'].attrs['Radians per digital value'] = \
+                        sec.scale
+                if isinstance(sec.start_time, datatime):
+                    t0 = sec.start_time.timestamp()
+                else:
+                    t0 = sec.start_time
+                h5_file['data'].attrs['Time of sending request'] = t0 * 1e3
+                if hasattr(sec, 'gauge_length'):
+                    h5_file['data'].attrs['Gauge length'] = sec.gauge_length
+
             elif file_format == 'FORESEE':
                 _update_h5_dataset(h5_file, '/', 'raw', sec.data)
                 DataTime = sec.start_time.timestamp() + \

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.3}/setup.py

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