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

{daspy_toolbox-1.2.1 → 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.1
+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.1 → daspy_toolbox-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DASPy-toolbox
-Version: 1.2.1
+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.1 → 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.1 → 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.1 → daspy_toolbox-1.2.2}/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'):

{daspy_toolbox-1.2.1 → daspy_toolbox-1.2.2}/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,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):
@@ -290,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
@@ -356,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/
@@ -500,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.1 → daspy_toolbox-1.2.2}/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))
@@ -1132,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.1 → 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.1 → 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.18
+# Date: 2025.11.19
 # Email: hmz2018@mail.ustc.edu.cn
 import os
 import warnings
@@ -192,9 +192,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 +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 \
@@ -463,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] != \
@@ -538,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.1 → daspy_toolbox-1.2.2}/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.2',
     description=(
         'DASPy is an open-source project dedicated to provide a python package '
         'for DAS (Distributed Acoustic Sensing) data processing, which '