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

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

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

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

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

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

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

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

@@ -1,9 +1,10 @@
 # Purpose: Some preprocess methods
 # Author: Minzhe Hu
-# Date: 2025.6.25
+# Date: 2025.10.30
 # Email: hmz2018@mail.ustc.edu.cn
 import warnings
 import numpy as np
+from numpy.fft import rfft, irfft, rfftfreq
 from scipy.signal import detrend
 from scipy.signal.windows import tukey
 from daspy.basic_tools.filter import lowpass_cheby_2
@@ -18,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'):
@@ -320,7 +321,7 @@ def padding(data, dn, reverse=False):
         return data_pd
 
 
-def time_integration(data, fs, c=0):
+def time_integration(data, fs, domain='time', c=0):
     """
     Integrate DAS data in time.
 
@@ -329,10 +330,19 @@ def time_integration(data, fs, c=0):
     :param c: float. A constant added to the result.
     :return: Integrated data.
     """
-    return np.cumsum(data, axis=1) / fs + c
-
-
-def time_differential(data, fs, prepend=0):
+    if domain == 'time':
+        return np.cumsum(data, axis=1) / fs + c
+    elif domain in ['frequency', 'freq']:
+        nsp = data.shape[1]
+        freqs = rfftfreq(nsp, d=1/fs)
+        spectrum = rfft(data, axis=1)
+        H = np.zeros_like(freqs, dtype=complex)
+        nonzero = freqs != 0
+        H[nonzero] = 1 / (1j * 2 * np.pi * freqs[nonzero])
+        return np.real(irfft(spectrum * H))
+
+
+def time_differential(data, fs, domain='time', prepend=0):
     """
     Differentiate DAS data in time.
 
@@ -342,9 +352,16 @@ def time_differential(data, fs, prepend=0):
         performing the difference. 
     :return: Differentiated data.
     """
-    if prepend == 'mean':
-        prepend = np.mean(data, axis=1).reshape((-1, 1))
-    return np.diff(data, axis=1, prepend=prepend) * fs
+    if domain == 'time':
+        if prepend == 'mean':
+            prepend = np.mean(data, axis=1).reshape((-1, 1))
+        return np.diff(data, axis=1, prepend=prepend) * fs
+    elif domain in ['frequency', 'freq']:
+        nsp = data.shape[1]
+        freqs = rfftfreq(nsp, d=1./fs)
+        spectrum = rfft(data, axis=1)
+        H = 1j * 2 * np.pi * freqs
+        return np.real(irfft(spectrum * H))
 
 
 def distance_integration(data, dx, c=0):

{daspy_toolbox-1.2.0 → daspy_toolbox-1.2.2}/daspy/core/collection.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Collection objects.
 # Author: Minzhe Hu
-# Date: 2025.9.15
+# Date: 2025.9.18
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -277,10 +277,11 @@ class Collection(object):
             if len(flist) == 1:
                 sec = read(flist[0], tmin=tmin, tmax=tmax, **kwargs)
             else:
-                sec = read(flist[0], tmin=tmin, **kwargs)
+                sec = read(flist[0], tmin=tmin-tolerance, **kwargs)
                 for f in flist[1:-1]:
                     sec += read(f, **kwargs)
-                sec += read(flist[-1], tmax=tmax, **kwargs)
+                sec += read(flist[-1], tmax=tmax+tolerance, **kwargs)
+                sec.trimming(tmin=tmin, tmax=tmax)
             return sec
         else:
             self.flist = flist
@@ -326,8 +327,8 @@ class Collection(object):
                 kwargs_list[j]['zi'] = 0
 
     def process(self, operations, savepath='./processed', merge=1,
-                suffix='_pro', ftype=None, dtype=None, save_operations=False,
-                tolerance=0.5, **read_kwargs):
+                suffix='_pro', ftype=None, dtype=None, file_format='auto',
+                save_operations=False, tolerance=0.5, **read_kwargs):
         """
         :param operations: list or None. Each element of operations list
             should be [str of method name, dict of kwargs]. None for read
@@ -339,6 +340,8 @@ class Collection(object):
         :param ftype: None or str. File format for saving. None for automatic
             detection, or 'pkl', 'pickle', 'tdms', 'h5', 'hdf5', 'segy', 'sgy',
             'npy'.
+        :param file_format: Format in which the file is saved.
+        :type file_format: str or function
         :param dtype: str. The data type of the saved data.
         :parma save_operations: bool. If True, save the operations to
             method_list.pkl and kwargs_list.pkl in savepath.
@@ -369,7 +372,8 @@ class Collection(object):
                     warnings.warn(f'{f} is an empty file. Continuous data is '
                                   'interrupted here.')
                     if m > 0:
-                        sec_merge.save(filepath, dtype=dtype)
+                        sec_merge.save(filepath, file_format=file_format,
+                                       dtype=dtype)
                         m = 0
                     self._kwargs_initialization(method_list, kwargs_list)
                     continue
@@ -377,7 +381,8 @@ class Collection(object):
                     sec = read(f, ftype=self.ftype, **read_kwargs)
                     if sec.data.size == 0:
                         if m > 0:
-                            sec_merge.save(filepath, dtype=dtype)
+                            sec_merge.save(filepath, ftype=ftype,
+                                           file_format=file_format, dtype=dtype)
                             m = 0
                         self._kwargs_initialization(method_list, kwargs_list)
                         continue
@@ -385,23 +390,24 @@ class Collection(object):
                     warnings.warn(f'Error reading {f}: {e}. Continuous data is '
                                   'interrupted here.')
                     if m > 0:
-                        sec_merge.save(filepath, dtype=dtype)
+                        sec_merge.save(filepath, ftype=ftype,
+                                       file_format=file_format, dtype=dtype)
                         m = 0
                     self._kwargs_initialization(method_list, kwargs_list)
                     continue
                 for j, method in enumerate(method_list):
                     if method in ['taper', 'cosine_taper']:
                         if not ((i==0 and kwargs_list[j]['side'] != 'right') or
-                                (i == len(self) - 1 and kwargs_list[j]['side'] !=
-                                'left')):
+                                (i == len(self) - 1 and kwargs_list[j]['side']
+                                 != 'left')):
                             continue
                     out = getattr(sec, method)(**kwargs_list[j])
                     if method == 'time_integration':
                         kwargs_list[j]['c'] = sec.data[:, -1].copy()
                     elif method == 'time_differential':
                         kwargs_list[j]['prepend'] = sec.data[:, -1].copy()
-                    elif method in ['bandpass', 'bandstop', 'lowpass', 'highpass',
-                                    'lowpass_cheby_2']:
+                    elif method in ['bandpass', 'bandstop', 'lowpass',
+                                    'highpass', 'lowpass_cheby_2']:
                         kwargs_list[j]['zi'] = out
                 
                 if m == 0:
@@ -415,7 +421,8 @@ class Collection(object):
                     warnings.warn(f'The start time of {f} does not correspond '
                                   'to the end time of the previous file. '
                                   'Continuous data is interrupted here.')
-                    sec_merge.save(filepath, dtype=dtype)
+                    sec_merge.save(filepath, ftype=ftype,
+                                   file_format=file_format, dtype=dtype)
                     sec_merge = sec
                     f0, f1 = os.path.splitext(os.path.basename(f))
                     f1 = f1 if ftype is None else ftype
@@ -423,10 +430,12 @@ class Collection(object):
                     m = 0
                 m += 1
                 if m == merge:
-                    sec_merge.save(filepath, dtype=dtype)
+                    sec_merge.save(filepath, ftype=ftype,
+                                   file_format=file_format, dtype=dtype)
                     m = 0
             if m > 0:
-                sec_merge.save(filepath, dtype=dtype)
+                sec_merge.save(filepath, ftype=ftype, file_format=file_format,
+                               dtype=dtype)
         except KeyboardInterrupt as e:
             with open(method_file, 'wb') as f:
                 pickle.dump(method_list, f)
@@ -452,25 +461,16 @@ class Collection(object):
 def _create_cascade_method(method_name):
     def cascade_method(self, savepath='./processed', merge=1,
                        suffix=f'_{method_name}', ftype=None, dtype=None,
-                       save_operations=False, **kwargs):
+                       file_format='auto', save_operations=False, tolerance=0.5,
+                       **kwargs):
         """
         Automatically generated method for {method_name}.
         Applies the {method_name} operation to the data and saves the result.
-
-        :param savepath: str. Path to save processed files.
-        :param merge: int or str. int for merge several processed files into 1.
-            'all' for merge all files.
-        :param suffix: str. Suffix for processed files.
-        :param ftype: None or str. None for automatic detection, or 'pkl',
-            'pickle', 'tdms', 'h5', 'hdf5', 'segy', 'sgy', 'npy'.
-        :param dtype: str. The data type of the saved data.
-        :parma save_operations: bool. If True, save the operations to
-            method_list.pkl and kwargs_list.pkl in savepath.
-        :param kwargs: dict. Parameters for the {method_name} operation.
         """
         operations = [[method_name, kwargs]]
         self.process(operations, savepath=savepath, merge=merge, suffix=suffix,
-                     ftype=ftype, dtype=dtype, save_operations=save_operations)
+                     ftype=ftype, dtype=dtype, file_format=file_format,
+                     save_operations=save_operations, tolerance=tolerance)
     return cascade_method
 
 

{daspy_toolbox-1.2.0 → daspy_toolbox-1.2.2}/daspy/core/dasdatetime.py

@@ -84,7 +84,7 @@ class DASDateTime(datetime):
             match = re.match(r'(.*)(UTC|GMT)([+-]?\d{1,2})(.*)', date_string,
                              re.IGNORECASE)
             if match:
-                dt1, tz_prefix, offset, dt2 = match.groups()
+                dt1, _, offset, dt2 = match.groups()
                 offset_hours = int(offset)
                 tz = timezone(timedelta(hours=offset_hours))
                 return cls.strptime(dt1 + dt2, format.replace('%Z', '')).\

daspy_toolbox-1.2.2/daspy/core/make_example.py

@@ -0,0 +1,32 @@
+import h5py
+import numpy as np
+from daspy import read, Section, DASDateTime
+from daspy.core.dasdatetime import utc
+
+
+origin_time = DASDateTime(2016, 3, 21, 7, 37, 10, 535000, tzinfo=utc)
+
+# read DAS data
+dx, fs = 1, 1000
+sec = Section(np.zeros((8721, 0)), dx, fs, data_type='Strain rate')
+filename = ['PoroTomo_iDAS16043_160321073651.h5',
+            'PoroTomo_iDAS16043_160321073721.h5',
+            'PoroTomo_iDAS16043_160321073751.h5',
+            'PoroTomo_iDAS16043_160321073821.h5']
+
+first = True
+for fn in filename:
+    with h5py.File(fn,'r') as fp:
+        if first:
+            sec.start_time = DASDateTime.fromtimestamp(fp['t'][0]).astimezone(utc)
+            sec.start_channel = fp['channel'][0]
+            first = False
+        sec += fp['das'][()].T
+
+sec.origin_time = origin_time
+sec.trimming(mode=0, xmin=2500, xmax=3000)
+sec.trimming(tmin=origin_time, tmax=origin_time+90)
+sec.downsampling(tint=10)
+sec.trimming(tmin=origin_time+20, tmax=origin_time+70)
+
+sec.save('example.py')

{daspy_toolbox-1.2.0 → daspy_toolbox-1.2.2}/daspy/core/read.py

@@ -1,15 +1,17 @@
 # Purpose: Module for reading DAS data.
-# Author: Minzhe Hu
-# Date: 2025.9.15
+# 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,43 @@ 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
+
+
 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):
@@ -188,7 +222,8 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
                 start_time = DASDateTime.fromisoformat(h5_file[data_key].
                                                        attrs['start_time'])
             else:
-                start_time = DASDateTime.fromtimestamp(float(header[100])).utc()
+                start_time = DASDateTime.fromtimestamp(float(header[100])).\
+                    utc()
                 transpose = True
             metadata = {'dx': header[1],
                         'fs': header[6] / header[15] / header[98],
@@ -216,13 +251,9 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
                 fs = float(attrs['FreqRes'])
             except KeyError:
                 try:
-                    fs = (attrs['PulseRateFreq'][0] /
-                            attrs['SamplingRes'][0]) / 1000
+                    fs = float(1000 / attrs['Spacing'][1])
                 except KeyError:
-                    try:
-                        fs = 1000 / attrs['Spacing'][1]
-                    except KeyError:
-                        fs = attrs['SamplingRate'][0]
+                    fs = attrs['PulseRateFreq'][0]
             time = h5_file[f'{group}/Source1/time']
             if len(time.shape) == 2: # Febus A1-R
                 start_time = DASDateTime.fromtimestamp(time[0, 0]).utc()
@@ -260,11 +291,9 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
                              'Smart Earth ZD-DAS', 'Unknown']:
             dataset = h5_file['Acquisition/Raw[0]/RawData/']
             attrs = h5_file['Acquisition'].attrs
-            try:
+            if 'NumberOfLoci' in attrs.keys():
                 if dataset.shape[0] != attrs['NumberOfLoci']:
                     transpose = True
-            except KeyError:
-                pass
 
             try:
                 fs = h5_file['Acquisition/Raw[0]'].attrs['OutputDataRate']
@@ -282,7 +311,7 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
                         stime = h5_file['Acquisition/Raw[0]/RawDataTime/'][0]
                     except KeyError:
                         stime = 0
-                        
+
             if isinstance(stime, bytes):
                 stime = stime.decode('ascii')
 
@@ -295,6 +324,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
@@ -361,13 +418,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/
@@ -415,11 +495,14 @@ def _read_h5(fname, headonly=False, file_format='auto', chmin=None, chmax=None,
         elif transpose:
             if len(dataset.shape) == 3:
                 fs = int(metadata['fs'])
-                j0, k0 = divmod(sj.start, fs)
-                j1, k1 = divmod(sj.stop, fs)
-                k1 = (j1 - j0) * fs + k1
+                fs_b = attrs.get('BlockRate', [1000])[0] / 1e3
+                nsp_b = round(fs/fs_b)
+                half_ol = round((dataset.shape[1] - nsp_b) / 2)
+                j0, k0 = divmod(sj.start, nsp_b)
+                j1, k1 = divmod(sj.stop, nsp_b)
+                k1 = (j1 - j0) * nsp_b + k1
                 j1 += 1
-                data = dataset[j0:j1, :, si]
+                data = dataset[j0:j1, half_ol:half_ol+nsp_b, si]
                 data = data.reshape((-1, data.shape[-1]))[k0:k1, :].T
             else:
                 data = dataset[sj, si].T
@@ -444,9 +527,9 @@ def _read_tdms(fname, headonly=False, file_format='auto', chmin=None,
                 version = float(properties['iDASVersion'][:3])
                 if version < 2.3:
                     file_format = 'Silixa iDAS'
-                elif 2.3 <= version < 2.6:
+                elif 2.3 <= version < 2.7:
                     file_format = 'Silixa iDAS-v2'
-                elif version >= 2.6:
+                elif version >= 2.7:
                     file_format = 'Silixa iDAS-v3'
             elif group_name == ['DAS']:
                 key = 'DAS'
@@ -483,12 +566,11 @@ def _read_tdms(fname, headonly=False, file_format='auto', chmin=None,
                         if isinstance(properties[time_key], str):
                             start_time = DASDateTime.fromisoformat(
                                 properties[time_key])
+                            break
                         elif isinstance(properties[time_key], np.datetime64):
                             start_time = DASDateTime.from_datetime(
                                 properties[time_key].item())
-                        else:
-                            continue
-                        break
+                            break
                 metadata['start_time'] = start_time
             if 'GaugeLength' in properties.keys():
                 metadata['gauge_length'] = properties['GaugeLength']
@@ -503,7 +585,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.0 → daspy_toolbox-1.2.2}/daspy/core/section.py

@@ -1,6 +1,6 @@
 # Purpose: Module for handling Section objects.
 # Author: Minzhe Hu
-# Date: 2025.9.15
+# 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))
@@ -150,15 +151,15 @@ class Section(object):
         else:
             raise TypeError('The input should be Section or np.ndarray.')
 
-        if len(data) != self.nch:
-            if len(data[0]) == self.nch:
-                data = data.T
-            else:
-                raise ValueError('These two Sections have different number of '
-                                 'channels, please check.')
-        if out.data is None:
+        if (out.data is None) or (out.nch * out.nsp == 0):
             out.data = data
         else:
+            if len(data) != self.nch:
+                if len(data[0]) == self.nch:
+                    data = data.T
+                else:
+                    raise ValueError('These two Sections have different number '
+                                     'of channels, please check.')
             out.data = np.hstack((out.data, data))
 
         return out
@@ -548,7 +549,7 @@ class Section(object):
             self.start_distance += channel[0] * self.dx
             return self
         else:
-            return data
+            return data * self.scale
 
     def plot(self, xmode='distance', tmode='origin', obj='waveform',
              kwargs_pro={}, **kwargs):
@@ -645,7 +646,10 @@ class Section(object):
             if tmode == 'origin':
                 if hasattr(self, 'origin_time'):
                     kwargs['t0'] -= self.origin_time
-                    kwargs.setdefault('ylabel', 'Times(s) after occurance')
+                    if ('transpose' in kwargs.keys()) and kwargs['transpose']:
+                        kwargs.setdefault('xlabel', 'Times(s) after occurance')
+                    else:
+                        kwargs.setdefault('ylabel', 'Times(s) after occurance')
                 else:
                     tmode == 'start'
             if tmode == 'start':
@@ -765,18 +769,26 @@ class Section(object):
         self.data = cosine_taper(self.data, p=p, side=side)
         return self
 
-    def downsampling(self, xint=None, tint=None, stack=True,
+    def downsampling(self, xint=None, tint=None, fs=None, dx=None, stack=True,
                      lowpass_filter=True):
         """
         Downsample DAS data.
 
         :param xint: int. Spatial downsampling factor.
         :param tint: int. Time downsampling factor.
+        :param fs: float. Target sampling rate after downsampling. It is used
+            if tint is None.
+        :param dx: float. Target channel interval after downsampling. It is
+            used if xint is None.
         :param stack: bool. If True, stacking will replace decimation.
         :param lowpass_filter: bool. Lowpass cheby2 filter before time
             downsampling or not.
         :return: Downsampled data.
         """
+        if xint is None and dx is not None:
+            xint = round(dx / self.dx)
+        if tint is None and fs is not None:
+            tint = round(self.fs / fs)
         self.data = downsampling(self.data, xint=xint, tint=tint, stack=stack,
                                  lowpass_filter=lowpass_filter)
         if xint and xint > 1:
@@ -851,25 +863,26 @@ class Section(object):
                     return self
         warnings.warn('Unable to convert data type.')
 
-    def time_integration(self, c=0):
+    def time_integration(self, domain='time', c=0):
         """
         Integrate DAS data in time.
 
         :param c: float. A constant added to the result.
         """
-        self.data = time_integration(self.data, self.fs, c=c)
+        self.data = time_integration(self.data, self.fs, domain=domain, c=c)
         if hasattr(self, 'data_type'):
             self._time_int_dif_attr(mode=1)
         return self
 
-    def time_differential(self, prepend=0):
+    def time_differential(self, domain='time', prepend=0):
         """
         Differentiate DAS data in time.
 
-        :param prepend: 'mean' or values to prepend to `data` along axis prior to
-            performing the difference. 
+        :param prepend: 'mean' or values to prepend to `data` along axis prior
+            to performing the difference. 
         """
-        self.data = time_differential(self.data, self.fs, prepend=prepend)
+        self.data = time_differential(self.data, self.fs, domain=domain,
+                                      prepend=prepend)
         if hasattr(self, 'data_type'):
             self._time_int_dif_attr(mode=-1)
         return self
@@ -901,7 +914,8 @@ class Section(object):
             None.
         """
         if zi is None:
-            self.data = bandpass(self.data, self.fs, freqmin, freqmax, **kwargs)
+            self.data = bandpass(self.data, self.fs, freqmin, freqmax,
+                                 **kwargs)
             return self
         else:
             self.data, zf = bandpass(self.data, self.fs, freqmin, freqmax,
@@ -1119,6 +1133,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.0 → daspy_toolbox-1.2.2}/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.0 → daspy_toolbox-1.2.2}/daspy/core/write.py

@@ -1,6 +1,6 @@
 # Purpose: Module for writing DAS data.
 # Author: Minzhe Hu
-# Date: 2025.9.15
+# Date: 2025.11.19
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -168,7 +168,6 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                 start_time = sec.start_time.utc() if \
                     isinstance(sec.start_time, datetime) else \
                     DASDateTime.fromtimestamp(sec.start_time)
-
                 if file_format in ['OptaSense ODH4+', 'OptaSense QuantX',
                                    'Unknown']:
                     h5_file.get('Acquisition/Raw[0]/').create_dataset('RawData',
@@ -186,15 +185,46 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
                         attrs['PartStartTime'] = stime_str
                     h5_file['Acquisition'].attrs['MeasurementStartTime'] = \
                         stime_str
+                h5_file['Acquisition'].attrs['NumberOfLoci'] = sec.nch
                 stimestamp = start_time.timestamp()
                 datatime = (np.arange(stimestamp, stimestamp + sec.nsp /
                     sec.fs, 1 / sec.fs) * 1e6).astype(int)
                 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 +303,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 +310,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 \
@@ -434,9 +480,14 @@ def _write_h5(sec, fname, raw_fname=None, file_format='auto'):
             elif file_format in ['OptaSense ODH4+', 'OptaSense QuantX',
                                 'Silixa iDAS-MG', 'Sintela Onyx v1.0',
                                 'Smart Earth ZD-DAS', 'Unknown']:
+                if file_format in ['Silixa iDAS-MG', 'Sintela Onyx v1.0',
+                                   'Smart Earth ZD-DAS']:
+                    _update_h5_dataset(h5_file, 'Acquisition/Raw[0]/',
+                                       'RawData', sec.data.T)
+                else:
+                    _update_h5_dataset(h5_file, 'Acquisition/Raw[0]/',
+                                       'RawData', sec.data)
                 h5_file['Acquisition'].attrs['NumberOfLoci'] = sec.nch
-                _update_h5_dataset(h5_file, 'Acquisition/Raw[0]/', 'RawData',
-                                    sec.data)
                 if isinstance(sec.start_time, datetime):
                     if isinstance(h5_file['Acquisition/Raw[0]/RawData'].
                                     attrs['PartStartTime'], bytes):
@@ -458,9 +509,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] != \
@@ -533,6 +617,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.0 → daspy_toolbox-1.2.2}/setup.py

@@ -2,14 +2,14 @@ from setuptools import setup, find_packages
 
 
 setup(
-    name='DASPy-toolbox', version='1.2.0',
+    name='DASPy-toolbox', version='1.2.2',
     description=(
         '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.'
         ),
-    long_description=open('README.md').read(),
+    long_description=open('README.md', encoding="utf-8").read(),
     author='Minzhe Hu, Zefeng Li',
     author_email='hmz2018@mail.ustc.edu.cn',
     maintainer='Minzhe Hu',
@@ -17,7 +17,7 @@ setup(
     license='MIT License',
     url='https://github.com/HMZ-03/DASPy',
     packages=find_packages(),
-    entry_points={  
+    entry_points={
         'console_scripts': [
             'daspy = daspy.main:main',
             ]