ground-motion-tools 0.1.0__tar.gz

ground_motion_tools-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.3
+Name: ground-motion-tools
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: RichardoGu
+Author-email: xiaopenggu@qq.com
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: geopy (>=2.4.1,<3.0.0)
+Requires-Dist: numpy (>=2.2.4,<3.0.0)
+Requires-Dist: scipy (>=1.15.2,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Ground-Motion-Tools
+
+## Installation
+
+## 

ground_motion_tools-0.1.0/README.md

@@ -0,0 +1,5 @@
+# Ground-Motion-Tools
+
+## Installation
+
+## 

ground_motion_tools-0.1.0/ground_motion_tools/__init__.py

@@ -0,0 +1,3 @@
+from .im import GMIntensityMeasures
+from .io import read_from_peer, read_from_kik, read_from_single, save_to_single
+from .process import length_normalize, down_sample, gm_data_fill, butter_worth_filter, fourier

ground_motion_tools-0.1.0/ground_motion_tools/enums/__init__.py

@@ -0,0 +1,3 @@
+from .gm_data_enum import GMDataEnum
+from .gm_spectrum_enum import GMSpectrumEnum
+from .gm_im_enum import GMIMEnum

ground_motion_tools-0.1.0/ground_motion_tools/enums/gm_data_enum.py

@@ -0,0 +1,15 @@
+from enum import Enum, unique
+
+
+@unique
+class GMDataEnum(Enum):
+    """
+    Type of Ground Motion Data
+    Attributes:
+        ACC: Acceleration
+        VEL: Velocity
+        DISP: Displacement
+    """
+    ACC = 0
+    VEL = 1
+    DISP = 2

ground_motion_tools-0.1.0/ground_motion_tools/enums/gm_im_enum.py

@@ -0,0 +1,42 @@
+from enum import Enum, unique
+
+
+@unique
+class GMIMEnum(Enum):
+    """
+    Type of Ground Motions Intensity Measures.
+
+     ['PGA', 'PGV', 'PGD', 'RMSA', 'RMSV', 'RMSD', 'I_A', 'I_C', 'SED', 'CAV',
+     'ASI', 'VSI', 'HI', 'SMA', 'SMV', 'Ia', 'Id', 'Iv',
+    'If', 'Sa(T1)', 'Sv(T1)', 'Sd(T1)', 'T70', 'T90', 'FFT']
+
+    Attributes:
+        PGA: Peek Ground Acceleration.
+        TODO Add More
+    """
+    PGA = 0
+    PGV = 1
+    PGD = 2
+    RMSA = 3
+    RMSV = 4
+    RMSD = 5
+    I_SUFFIX_A = 6
+    I_SUFFIX_C = 7
+    SED = 8
+    CAV = 9
+    SA_T1 = 10
+    SV_T1 = 11
+    SD_T1 = 12
+    ASI = 13
+    VSI = 14
+    HI = 15
+    SMA = 16
+    SMV = 17
+    I_A = 18
+    I_D = 19
+    I_V = 20
+    I_F = 21
+    MIV = 22
+    DI = 23
+    T70 = 24
+    T90 = 25

ground_motion_tools-0.1.0/ground_motion_tools/enums/gm_spectrum_enum.py

@@ -0,0 +1,20 @@
+from enum import Enum, unique
+
+
+@unique
+class GMSpectrumEnum(Enum):
+    """
+    Type of Ground Motion Spectrum.
+    Each Ground Motion have five different Spectrum types, see Details: http://www.jdcui.com/?p=713.
+    Attributes:
+        ACC: Acceleration response spectrum
+        VEL: Velocity response spectrum
+        DISP: Displacement response spectrum
+        PSE_ACC: Pseudo acceleration response spectrum
+        PSE_VEL: Pseudo velocity response spectrum
+    """
+    ACC = 0
+    VEL = 1
+    DISP = 2
+    PSE_ACC = 3
+    PSE_VEL = 4

ground_motion_tools-0.1.0/ground_motion_tools/im.py

@@ -0,0 +1,368 @@
+# -*- coding:utf-8 -*-
+# @Time:    2025/3/17 17:15
+# @Author:  RichardoGu
+"""
+Intensity measures
+"""
+import numpy as np
+from process import gm_data_fill
+from sbs_integration_linear import segmented_parsing
+from spectrum import SPECTRUM_PERIOD, get_spectrum
+from enums import GMIMEnum, GMDataEnum
+
+IM_ADJUST_DICT = {
+    GMIMEnum.PGA.name: {  # 按照PGA进行调幅的其余IM变化率
+        GMIMEnum.PGA.name: lambda x: x,
+        GMIMEnum.PGV.name: lambda x: x,
+        GMIMEnum.PGD.name: lambda x: x,
+
+        GMIMEnum.RMSA.name: lambda x: x,
+        GMIMEnum.RMSV.name: lambda x: x,
+        GMIMEnum.RMSD.name: lambda x: x,
+
+        GMIMEnum.I_SUFFIX_A.name: lambda x: x,
+        GMIMEnum.I_SUFFIX_C.name: lambda x: x ** (3 / 2),
+
+        GMIMEnum.SED.name: lambda x: x,
+        GMIMEnum.CAV.name: lambda x: x,
+
+        GMIMEnum.ASI.name: lambda x: x,
+        GMIMEnum.VSI.name: lambda x: x,
+        GMIMEnum.HI.name: lambda x: x,
+
+        GMIMEnum.SMA.name: lambda x: x,
+        GMIMEnum.SMV.name: lambda x: x,
+
+        GMIMEnum.I_A.name: lambda x: x,
+        GMIMEnum.I_D.name: lambda x: x,
+        GMIMEnum.I_V.name: lambda x: x ** (2 / 3),
+        GMIMEnum.I_F.name: lambda x: x,
+
+        GMIMEnum.SA_T1.name: lambda x: x,
+        GMIMEnum.SV_T1.name: lambda x: x,
+        GMIMEnum.SD_T1.name: lambda x: x
+    }
+}
+
+
+class GMIntensityMeasures:
+    def __init__(self, gm_acc_data: np.ndarray, time_step: float):
+        self.acc, self.vel, self.disp = gm_data_fill(gm_acc_data, time_step, GMDataEnum.ACC)
+        if self.acc.ndim == 1:
+            self.acc = np.expand_dims(self.acc, axis=0)
+            self.vel = np.expand_dims(self.vel, axis=0)
+            self.disp = np.expand_dims(self.disp, axis=0)
+
+        self.time_step = time_step
+        self.batch_size = self.acc.shape[0]
+        self.seq_len = self.acc.shape[1]
+        self.duration = self.seq_len * self.time_step
+
+        self.spectrum_acc = None
+        self.spectrum_vel = None
+        self.spectrum_disp = None
+
+        self.intensity_measures = {}
+
+    def _get_spectrum(self):
+        self.spectrum_acc, self.spectrum_vel, self.spectrum_disp, _, _ = get_spectrum(
+            self.acc, self.time_step, 0.05
+        )
+        if self.spectrum_acc.ndim == 1:
+            self.spectrum_acc = np.expand_dims(self.spectrum_acc, axis=0)
+            self.spectrum_vel = np.expand_dims(self.spectrum_vel, axis=0)
+            self.spectrum_disp = np.expand_dims(self.spectrum_disp, axis=0)
+
+    def get_im(
+            self,
+            im_list: [list, GMIMEnum],
+            period: float = 1
+    ) -> dict[str, np.ndarray[float]]:
+        """
+        An external query must call this interface to get intensity measures.
+
+        The parameter ``im`` is the intensity measures' name, and this func will output the corresponding result.
+
+        All the input is saved by a dict named ``self.intensity_measures``, and each im will just be calculated once
+        when it is first queried.
+
+        The input im can be both upper and lower, but must be included in :class:`GroundMotionDataIntensityMeasures`.
+        Args:
+            im_list: Intensity measures' name.
+            period: Some intensity measures need param ``period`` to calculate. Default 0.9s
+
+        Returns:
+            A dict ``{str,np.ndarray[float]}`` of ``{im_name, im_value}``
+
+        """
+        if im_list is None or len(im_list) == 0:
+            raise ValueError("Parameter 'im_list' can not be None or empty.")
+
+        result = {}
+        if type(im_list) is GMIMEnum:
+            im_list = [im_list]
+        for im in im_list:
+            im_upper = im.name.upper()
+            im_lower = im.name.lower()
+            try:
+                result[im_upper] = self.intensity_measures[im_upper]
+            except KeyError:
+                self.intensity_measures[im_upper] = eval("self.im_" + im_lower)(period=period)
+                result[im_upper] = self.intensity_measures[im_upper]
+        return result
+
+    def im_pga(self, **kwargs):
+        """
+        PGA
+        .. math:: |max(a(t))|
+        """
+        return np.abs(self.acc).max(1)
+
+    def im_pgv(self, **kwargs):
+        """
+        PGV
+        .. math:: |max(v(t))|
+        """
+        return np.abs(self.vel).max(1)
+
+    def im_pgd(self, **kwargs):
+        """
+        PGD
+        .. math:: |max(d(t))|
+        """
+        return np.abs(self.disp).max(1)
+
+    def im_rmsa(self, **kwargs):
+        """
+        Arms
+        .. math:: \\sqrt{\\frac{1}{t_{tot}} \\int_{0}^{tot}a(t)^2dt}
+        """
+        return ((self.acc ** 2).sum(1) * self.time_step / self.duration) ** 0.5
+
+    def im_rmsv(self, **kwargs):
+        """
+        Vrms
+        .. math:: \\sqrt{\\frac{1}{t_{tot}} \\int_{0}^{tot}v(t)^2dt}
+        """
+        return ((self.vel ** 2).sum(1) * self.time_step / self.duration) ** 0.5
+
+    def im_rmsd(self, **kwargs):
+        """
+        Drms
+        .. math:: \\sqrt{\\frac{1}{t_{tot}} \\int_{0}^{tot}d(t)^2dt}
+        """
+        return ((self.disp ** 2).sum(1) * self.time_step / self.duration) ** 0.5
+
+    def im_i_suffix_a(self, **kwargs):
+        """
+        IA
+        .. math:: \\frac{\\pi}{2g}\\int^{t_{tot}}_{0}{a(t)^2dt}
+        """
+        return (self.acc ** 2).sum(1) * self.time_step * np.pi / (2 * 9.8)
+
+    def im_i_suffix_c(self, **kwargs):
+        """
+        IC
+        .. math:: (Arms)^{3/2}\\sqrt{t_{tot}}
+        """
+        return self.get_im(GMIMEnum.RMSA)[GMIMEnum.RMSA.name.upper()] ** 1.5 * (self.duration ** 0.5)
+
+    def im_sed(self, **kwargs):
+        """
+        SED
+        .. math:: \\int_{0}^{tot}{v(t)^2}dt
+        """
+        return (self.vel ** 2).sum(1) * self.time_step
+
+    def im_cav(self, **kwargs):
+        """
+        CAV
+        .. math:: \\int_{0}^{tot}{|a(t)|}dt
+        """
+        return np.abs(self.acc).sum(1) * self.time_step
+
+    def im_sa_t1(self, **kwargs):
+        """
+        Sa(T1)
+        Spectrum acceleration at the first natural period of vibration.
+        """
+        acc, vel, disp = segmented_parsing(mass=1,
+                                           stiffness=((2 * np.pi) / kwargs["period"]) ** 2,
+                                           damping_ratio=0.05,
+                                           load=self.acc, time_step=self.time_step)
+        self.intensity_measures[GMIMEnum.SV_T1.name.upper()] = np.abs(vel).max(1)
+        self.intensity_measures[GMIMEnum.SD_T1.name.upper()] = np.abs(disp).max(1)
+        return np.abs(acc).max(1)
+
+    def im_sv_t1(self, **kwargs):
+        """
+        Sv(T1)
+        Spectrum velocity at the first natural period of vibration.
+        """
+        acc, vel, disp = segmented_parsing(mass=1,
+                                           stiffness=((2 * np.pi) / kwargs["period"]) ** 2,
+                                           damping_ratio=0.05,
+                                           load=self.acc, time_step=self.time_step)
+        self.intensity_measures[GMIMEnum.SA_T1.name.upper()] = np.abs(acc).max(1)
+        self.intensity_measures[GMIMEnum.SD_T1.name.upper()] = np.abs(disp).max(1)
+        return np.abs(vel).max(1)
+
+    def im_sd_t1(self, **kwargs):
+        """
+        Sd(T1)
+        Spectrum displacement at the first natural period of vibration.
+        """
+        acc, vel, disp = segmented_parsing(mass=1,
+                                           stiffness=((2 * np.pi) / kwargs["period"]) ** 2,
+                                           damping_ratio=0.05,
+                                           load=self.acc, time_step=self.time_step)
+        self.intensity_measures[GMIMEnum.SA_T1.name.upper()] = np.abs(acc).max(1)
+        self.intensity_measures[GMIMEnum.SV_T1.name.upper()] = np.abs(vel).max(1)
+        return np.abs(disp).max(1)
+
+    def im_asi(self, **kwargs):
+        """
+        ASI
+        .. math:: \\int_{0.1}^{0.5}{Sa(\\xi = 0.05, t) dt}
+        """
+        if self.spectrum_acc is None:
+            self._get_spectrum()
+
+        result = np.zeros(self.batch_size)
+        for i in range(len(SPECTRUM_PERIOD)):
+            if SPECTRUM_PERIOD[i] < 0.1:
+                continue
+            if SPECTRUM_PERIOD[i] > 0.5:
+                break
+            result += self.spectrum_acc[:, i] * (SPECTRUM_PERIOD[i] - SPECTRUM_PERIOD[i - 1])
+        return result
+
+    def im_vsi(self, **kwargs):
+        """
+        VSI
+        .. math:: \\int_{0.1}^{2.5}{Sv(\\xi = 0.05, t) dt}
+        """
+        if self.spectrum_vel is None:
+            self._get_spectrum()
+        result = np.zeros(self.batch_size)
+        for i in range(len(SPECTRUM_PERIOD)):
+            if SPECTRUM_PERIOD[i] < 0.1:
+                continue
+            if SPECTRUM_PERIOD[i] > 2.5:
+                break
+            result += self.spectrum_vel[:, i] * (SPECTRUM_PERIOD[i] - SPECTRUM_PERIOD[i - 1])
+        return result
+
+    def im_hi(self, **kwargs):
+        """
+        HI
+        .. math:: \\int_{0.1}^{2.5}{PSv(\\xi = 0.05, t) dt}
+        """
+        if self.spectrum_disp is None:
+            self._get_spectrum()
+        result = np.zeros(self.batch_size)
+        for i in range(len(SPECTRUM_PERIOD)):
+            if SPECTRUM_PERIOD[i] < 0.1:
+                continue
+            if SPECTRUM_PERIOD[i] > 2.5:
+                break
+            result += self.spectrum_disp[:, i] * (SPECTRUM_PERIOD[i] - SPECTRUM_PERIOD[i - 1])
+        return result
+
+    def im_sma(self, **kwargs):
+        """
+        The third peek in acceleration time history.
+        """
+        return np.sort(np.abs(self.acc), axis=1)[:, -3]
+
+    def im_smv(self, **kwargs):
+        """
+        The third peek in velocity time history.
+        """
+        return np.sort(np.abs(self.vel), axis=1)[:, -3]
+
+    def im_i_a(self, **kwargs):
+        """
+        Ia
+        .. math:: PGA{\\dot}t^{1/3}_{tot}
+        """
+        return self.get_im(GMIMEnum.PGA)[GMIMEnum.PGA.name.upper()] * self.duration ** (1 / 3)
+
+    def im_i_d(self, **kwargs):
+        """
+        Id
+        .. math:: PGD{\\dot}t^{1/3}_{tot}
+        """
+        return self.get_im(GMIMEnum.PGD)[GMIMEnum.PGD.name.upper()] * self.duration ** (1 / 3)
+
+    def im_i_v(self, **kwargs):
+        """
+        Iv
+        .. math:: PGV^{2/3}{\\dot}t^{1/3}_{tot}
+        """
+        return self.get_im(GMIMEnum.PGV)[GMIMEnum.PGV.name.upper()] ** (2 / 3) * self.duration ** (1 / 3)
+
+    def im_i_f(self, **kwargs):
+        """
+        IF
+        .. math:: PGV{\\dot}t^{1/4}_{tot}
+        """
+        return self.get_im(GMIMEnum.PGV)[GMIMEnum.PGV.name.upper()] * self.duration ** (1 / 4)
+
+    def im_miv(self, **kwargs):
+        """
+        MIV
+        """
+        # TODO ADD
+        return np.zeros(self.batch_size)
+
+    def im_di(self, **kwargs):
+        """
+        DI
+        """
+        # TODO ADD
+        return np.zeros(self.batch_size)
+
+    def im_t70(self, **kwargs):
+        """
+        T0.75-T0.05
+        """
+        # TODO ADD
+        return np.zeros(self.batch_size)
+
+    def im_t90(self, **kwargs):
+        """
+        T0.95-T0.05
+        """
+        # TODO ADD
+        return np.zeros(self.batch_size)
+
+    @staticmethod
+    def im_adjust(im_data: dict, base_im: GMIMEnum, target_value: float):
+        """
+        对IM指标进行调幅
+        Args:
+            im_data: 需要进行调幅的IM指标
+            base_im: 以哪个IM为基准调幅
+            target_value: 要调幅的值
+
+        Returns:
+
+        """
+        # 初始化一个新数组，不改变原有的数据
+        adjusted_im_data = {}
+
+        # 首先将base_im调幅到target_value,并记录调幅参数
+        base_im_data = im_data[base_im.name.upper()]
+        base_adjust_value = target_value / base_im_data
+        adjusted_im_data[base_im.name.upper()] = im_data[base_im.name.upper()] * base_adjust_value
+
+        # 逐项计算
+        for im_key in im_data.keys():
+            if im_key not in IM_ADJUST_DICT[base_im.name].keys():
+                raise KeyError(f"调幅系数中并未收录IM指标：{im_key}")
+            adjust_func = IM_ADJUST_DICT[base_im.name][GMIMEnum[im_key].name]  # 获取该IM的调幅系数
+            adjust_value = np.array([adjust_func(bav_i) for bav_i in base_adjust_value])  # 计算调幅矩阵
+            adjusted_im_data[im_key] = im_data[im_key] * adjust_value  # 原始值与调幅矩阵逐项相乘
+
+        return adjusted_im_data

ground_motion_tools-0.1.0/ground_motion_tools/io.py

@@ -0,0 +1,123 @@
+# -*- coding:utf-8 -*-
+# @Time:    2025/3/17 16:10
+# @Author:  RichardoGu
+"""
+This file is mainly used to read or write ground motion.
+"""
+import re
+import numpy as np
+
+TIME_RE = r"\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}"
+NUMBER_RE = r"[+-]?(\d+([.]\d*)?([eE][+-]?\d+)?|[.]\d+([eE][+-]?\d+)?)"
+TIME_FORMAT = "%Y/%m/%d %H:%M:%S"
+
+
+def read_from_kik(file_path: str) -> (
+        np.ndarray[np.float64], float
+):
+    """
+    Read ground motion data from KIK format.
+    Args:
+        file_path: File path
+
+    Returns:
+        gm_data, time_step
+    """
+    gm_data = None
+    with open(file_path, 'r') as f:
+        lines = f.readlines()
+        for line in lines:
+            if re.match('^Memo.', line):
+                # if line is begin of "Memo.", it means all the params are read.
+                # The following data is time-history data.
+                idx = lines.index(line) + 1
+                gm_data = []
+                for i in range(idx, len(lines)):
+                    temp = lines[i].split()
+                    for j in temp:
+                        gm_data.append(eval(j) * 0.01)  # Times 0.01 to convert gal(cm/s^2) to SI(m/s^2)
+                break
+            elif re.match("^Scale Factor.", line):
+                match_result = re.search(r'(\d+)\D*(\d+)/?$', line)
+                scale_factor = eval(match_result.group(1)) / eval(match_result.group(2))
+            elif re.match("^Sampling Freq.", line):
+                time_step = 1 / eval(re.search(NUMBER_RE, line).group())
+
+    if gm_data is not None and scale_factor:
+        gm_data = np.array(gm_data, dtype=np.float64)
+        gm_data = (gm_data - gm_data.mean()) * scale_factor
+    else:
+        raise ValueError("Read ground motion data error. Parameter 'scale_factor' or gm_data may be None.")
+    return gm_data, time_step
+
+
+def read_from_peer(file_path: str) -> (
+        np.ndarray[np.float64], float
+):
+    """
+    Read ground motion data from PEER format.
+    Args:
+        file_path:
+
+    Returns:
+        gm_data, time_step
+    """
+    with open(file_path, 'r') as fp:
+        lines = fp.readlines()
+        time_step = eval(re.findall(r"\.[0-9]*", lines[3])[0])
+        gm_data = []
+        for i in range(4, len(lines)):
+            temp = lines[i].split()
+            for j in temp:
+                gm_data.append(eval(j) * 9.8)  # Times 9.8 to convert G(9.8m/s^2) to m/s^2
+    return np.array(gm_data, dtype=np.float64), time_step
+
+
+def read_from_single(file_path: str, start_line: int = 1,
+                     end_line: int = None, time_step: [int, float] = 0) -> (
+        np.ndarray[np.float64], float
+):
+    """
+    Reading seismic wave data from a single column file
+    The default single column file format is: the first row is the sampling interval,
+    the second row to the end of the file is the seismic wave data.
+    Args:
+        file_path: File path
+        start_line: Number of rows of ground motion. Default is the second row.
+        end_line: Number of end rows of ground motion. Default is None
+        time_step:
+            Ground motion Sampling Interval Directly indicates the sampling interval.
+            if it is a floating point number,
+            otherwise it indicates the number of rows where the sampling interval is located.
+
+    Returns:
+        gm_data, time_step
+    """
+    with open(file_path, 'r') as fp:
+        lines = fp.readlines()
+        wave_data = [float(line) for line in lines[start_line:end_line]]
+        if type(time_step) is float:
+            pass
+        elif type(time_step) is int:
+            time_step = float(lines[time_step].split(" ")[-1])
+        else:
+            raise ValueError(f"Type of parameter 'time_step' need to be float or int. But got {type(time_step)}.")
+        return np.array(wave_data, dtype=np.float64), time_step
+
+
+def save_to_single(file_path: str, gm_data: np.ndarray[np.float64], time_step: float = None) -> None:
+    """
+    Save ground motion to single file.
+    Args:
+        gm_data: Data of ground motion.
+        time_step: Time step of ground motion.
+        file_path: Path to save.
+
+    Returns:
+        None
+    """
+    with open(file_path, 'w') as fp:
+        if time_step is not None:
+            fp.write(f"Time Step: {time_step}\n")
+        for data in gm_data:
+            fp.write(f"{data}\n")

ground_motion_tools-0.1.0/ground_motion_tools/process.py

@@ -0,0 +1,155 @@
+# -*- coding:utf-8 -*-
+# @Time:    2025/3/17 16:49
+# @Author:  RichardoGu
+"""
+Some utils for processing ground motion.
+"""
+import numpy as np
+from scipy import signal
+from enums import GMDataEnum
+
+
+def gm_data_fill(gm_data: np.ndarray,
+                 time_step: float = 0.02,
+                 wave_type: GMDataEnum = GMDataEnum.ACC) -> (
+        np.ndarray[np.float64], np.ndarray[np.float64], np.ndarray[np.float64]
+):
+    """
+    Fit wave by input.
+
+    Args:
+        gm_data:
+        wave_type:
+        time_step:
+
+    Returns:
+        None
+    """
+    if gm_data.ndim == 1:
+        # All the wave_array hereafter should have 2 dims as [batch_size, seq_len]
+        gm_data = np.expand_dims(gm_data, axis=0)
+    if wave_type.value == GMDataEnum.ACC.value:
+        acc = gm_data
+        vel = np.cumsum(acc, axis=1) * time_step
+        disp = np.cumsum(vel, axis=1) * time_step
+    elif wave_type.value == GMDataEnum.VEL.value:
+        vel = gm_data
+        disp = np.cumsum(vel, axis=1) * time_step
+        acc = np.gradient(vel, time_step, axis=1)
+    elif wave_type.value == GMDataEnum.DISP.value:
+        disp = gm_data
+        vel = np.gradient(disp, time_step, axis=1)
+        acc = np.gradient(vel, time_step, axis=1)
+    else:
+        raise ValueError("Parameter wave_type must be included in [ACC, VEL, DISP].")
+    return np.squeeze(acc), np.squeeze(vel), np.squeeze(disp)
+
+
+def fourier(gm_data: np.ndarray, time_step: float) -> (
+        np.ndarray, np.ndarray, np.ndarray
+):
+    """
+    Calculate the fourier spectrum of wave.
+    Args:
+        gm_data: Ground motion data.
+        time_step: Time step.
+
+    Returns:
+        x-axis of fourier spectrum(HZ)
+        amp: A
+
+    """
+    x_fourier = np.abs(np.fft.fftfreq(d=time_step, n=len(gm_data))[len(gm_data) // 2:])[::-1]
+    # Take the absolute value of the complex number, i.e., the mode of the complex number (bilateral spectrum)
+    amp = np.abs(np.fft.fft(gm_data)) / len(gm_data)
+    # extract a unilateral spectrum
+    amp = (amp[len(gm_data) // 2:])[::-1]
+    return x_fourier, amp, amp ** 2
+
+
+def butter_worth_filter(
+        gm_data: np.ndarray[np.float64],
+        time_step: float,
+        order: int = 4,
+        start_freq: float = 0.1,
+        end_freq: float = 15,
+        pass_way: str = 'band'):
+    """
+
+    The start frequency and stop frequency are suggested as 0.1HZ and 25HZ.
+    Because commonly the effective frequency in ground motions is range from 0.1hz to 25hz.
+
+    Args:
+        gm_data: Ground motion data.
+        time_step: Time step.
+        order: The order of butterworth filter. Default 4.
+        start_freq: The start freq of filter. Default 0.1.
+        end_freq: The end freq of filter. Default 0.1.
+        pass_way: The pass way of filter. Default bandpass.
+
+    Returns: Filtered waves.
+
+    """
+    b, a = signal.butter(order, [2 * start_freq * time_step, 2 * end_freq * time_step], pass_way)
+    # ! Result by using ``lfilter`` is sample to Seismic Signal, not filtfilt
+    return signal.lfilter(b, a, gm_data)
+
+
+def down_sample(gm_data: np.ndarray, ori_time_step: float, tar_time_step: float) -> np.ndarray:
+    """
+    Down-sample the wave data.
+
+    The method used for down-sampling is mean-down-sampling.
+    Use mean down-samping method can let the calculated displacement and velocity be the same as before.
+
+    Args:
+        gm_data: The input wave data.
+        ori_time_step: Origin time step.
+        tar_time_step: Target time step.
+    Returns:
+        Downsized wave_data. Using scipy.signal.resample
+    """
+
+    # The two lines that are commented out are the previous methods.
+    # tar_data_size = int(ori_time_step / tar_time_step * wave_data.shape[wave_data.ndim - 1])
+    # return signal.resample(wave_data, tar_data_size, axis=axis).mean()
+
+    num_samples = int(gm_data.shape[-1] * ori_time_step / tar_time_step)
+    return signal.resample(gm_data, num_samples, axis=gm_data.ndim - 1)
+
+
+def length_normalize(gm_data: np.ndarray[np.float64], normal_length: int):
+    """
+    Seismic wave length normalisation method.
+
+    Normalisation algorithm:
+        1. If the original seismic wave length l1 is less than the normalised seismic wave length ln,
+            then zero is added directly at the end.
+        2. If the original seismic wave length l1 is greater than the seismic wave length ln to be normalised,
+            the following operation is performed.
+            2.1 Extraction of ground shaking PGA occurrences i1
+            2.2 Calculate the ratio a(0<a<1) of the original length to the normalised length,
+                then the original ground shaking should be extracted int(i1*a) units, before the peak appears.
+                When the peak appears, it is dealt with directly by the truncation and zero filling method.
+    Args:
+        gm_data: Ground motion data.
+        normal_length: 要归一化的长度
+
+    Returns:
+
+    """
+    # 1 The normalised length is greater than the original length
+    if gm_data.shape[0] <= normal_length:
+        return np.pad(
+            gm_data,
+            (0, normal_length - gm_data.shape[0]),
+            'constant',
+            constant_values=(0, 0)
+        )
+    # 2 The normalised length is less than the original length
+    else:
+        cut_rate = normal_length / gm_data.shape[0]
+        pga_loca = np.argmax(np.abs(gm_data))
+        forward_length = int(pga_loca * cut_rate)
+        res = gm_data[pga_loca - forward_length:normal_length - forward_length + pga_loca]
+        return res

ground_motion_tools-0.1.0/ground_motion_tools/sbs_integration_linear.py

@@ -0,0 +1,131 @@
+# -*- coding:utf-8 -*-
+# @FileName  :sbs_integration_linear.py
+# @Time      :2024/8/25 下午7:57
+# @Author    :RichardoGu
+import numpy as np
+
+
+def segmented_parsing(mass: float,
+                      stiffness: float,
+                      load: np.ndarray,
+                      time_step: float,
+                      damping_ratio: float = 0.05,
+                      disp_0: float = 0,
+                      vel_0: float = 0) -> (np.ndarray, np.ndarray, np.ndarray):
+    """
+    This function is Segmented Parsing method, which is generally applicable
+    for solving the dynamic response of single degree of freedom system.
+
+    Args:
+        mass:
+        stiffness:
+        load: The dynamic load array, changeable over time, is often the ground motion.
+            This parameter should have 2 dims as (batch size, sequence length)
+        time_step: The time step of load
+        damping_ratio:
+        disp_0: The init displacement of system, is often 0
+        vel_0: The init velocity of system, is often 0
+
+    Returns:
+        The result is tuple, which consist of the ``(acceleration, velocity, displacement)`` response in order.
+    -------
+
+    """
+    # Array fit
+    if load.ndim == 1:
+        load = np.expand_dims(load, 0)
+    # Data preparation
+    batch_size = load.shape[0]
+    seq_length = load.shape[1]
+
+    omega_n = np.sqrt(stiffness / mass)
+    omega_d = omega_n * np.sqrt(1 - damping_ratio ** 2)
+    temp_1 = np.e ** (-damping_ratio * omega_n * time_step)
+    temp_2 = damping_ratio / np.sqrt(1 - damping_ratio ** 2)
+    temp_3 = 2 * damping_ratio / (omega_n * time_step)
+    temp_4 = (1 - 2 * damping_ratio ** 2) / (omega_d * time_step)
+    temp_5 = omega_n / np.sqrt(1 - damping_ratio ** 2)
+    sin = np.sin(omega_d * time_step)
+    cos = np.cos(omega_d * time_step)
+
+    p_a = temp_1 * (temp_2 * sin + cos)
+    p_b = temp_1 * (sin / omega_d)
+    p_c = 1 / stiffness * (temp_3 + temp_1 * (
+            (temp_4 - temp_2) * sin - (1 + temp_3) * cos
+    ))
+    p_d = 1 / stiffness * (1 - temp_3 + temp_1 * (
+            -temp_4 * sin + temp_3 * cos
+    ))
+    p_a_prime = -temp_1 * (temp_5 * sin)
+    p_b_prime = temp_1 * (cos - temp_2 * sin)
+    p_c_prime = 1 / stiffness * (-1 / time_step + temp_1 * (
+            (temp_5 + temp_2 / time_step) * sin + 1 / time_step * cos
+    ))
+    p_d_prime = 1 / (stiffness * time_step) * (
+            1 - temp_1 * (temp_2 * sin + cos)
+    )
+
+    # Init the start displacement and velocity.
+    disp = np.zeros((batch_size, seq_length))
+    vel = np.zeros((batch_size, seq_length))
+    acc = np.zeros((batch_size, seq_length))
+
+    if type(disp_0) is not np.ndarray:
+        disp_0 = np.zeros(batch_size)
+    if type(vel_0) is not np.ndarray:
+        vel_0 = np.zeros(batch_size)
+    disp[:, 0] = disp_0
+    vel[:, 0] = vel_0
+
+    # Start Iteration
+    for i in range(seq_length - 1):
+        disp[:, i + 1] = p_a * disp[:, i] + p_b * vel[:, i] + p_c * load[:, i] + p_d * load[:, i + 1]
+        vel[:, i + 1] = (p_a_prime * disp[:, i] +
+                         p_b_prime * vel[:, i] + p_c_prime * load[:, i] + p_d_prime * load[:, i + 1])
+        acc[:, i + 1] = -2 * damping_ratio * omega_n * vel[:, i + 1] - stiffness / mass * disp[:, i + 1]
+
+    return acc, vel, disp
+
+
+def newmark_beta_single(mass, stiffness, load, time_step,
+                        damping_ratio=0.05, disp_0=0, vel_0=0,
+                        acc_0=0, beta=0.25, gamma=0.5,
+                        result_length=0):
+    batch_size = load.shape[0]
+    seq_length = load.shape[1]
+    if result_length == 0:
+        result_length = int(1.2 * load.shape[1])  # 计算持时
+    load = np.append(load, np.zeros((batch_size, result_length - seq_length)), axis=1)
+
+    disp = np.zeros((batch_size, result_length))
+    vel = np.zeros((batch_size, result_length))
+    acc = np.zeros((batch_size, result_length))
+    if type(disp_0) is not np.ndarray:
+        disp_0 = np.zeros(batch_size)
+    if type(vel_0) is not np.ndarray:
+        vel_0 = np.zeros(batch_size)
+    if type(acc_0) is not np.ndarray:
+        acc_0 = np.zeros(batch_size)
+    disp[:, 0] = disp_0
+    vel[:, 0] = vel_0
+    acc[:, 0] = acc_0
+    a_0 = 1 / (beta * time_step ** 2)
+    a_1 = gamma / (beta * time_step)
+    a_2 = 1 / (beta * time_step)
+    a_3 = 1 / (2 * beta) - 1
+    a_4 = gamma / beta - 1
+    a_5 = time_step / 2 * (a_4 - 1)
+    a_6 = time_step * (1 - gamma)
+    a_7 = gamma * time_step
+    omega_n = np.sqrt(stiffness / mass)
+    damping = 2 * mass * omega_n * damping_ratio
+    equ_k = stiffness + a_0 * mass + a_1 * damping  # 计算等效刚度
+    # 迭代正式开始
+    for i in range(result_length - 1):
+        equ_p = load[:, i + 1] + mass * (
+                a_0 * disp[:, i] + a_2 * vel[:, i] + a_3 * acc[:, i]) + damping * (
+                        a_1 * disp[:, i] + a_4 * vel[:, i] + a_5 * acc[:, i])  # 计算等效荷载
+        disp[:, i + 1] = equ_p / equ_k  # 计算位移
+        acc[:, i + 1] = a_0 * (disp[:, i + 1] - disp[:, i]) - a_2 * vel[:, i] - a_3 * acc[:, i]  # 计算加速度
+        vel[:, i + 1] = vel[:, i] + a_6 * acc[:, i] + a_7 * acc[:, i + 1]  # 计算速度
+    return acc, vel, disp

ground_motion_tools-0.1.0/ground_motion_tools/spectrum.py

@@ -0,0 +1,113 @@
+# -*- coding:utf-8 -*-
+# @Time:    2025/3/17 17:32
+# @Author:  RichardoGu
+"""
+Ground motion spectrum Calc
+"""
+from typing import Any
+
+import numpy as np
+from numpy import ndarray, float64
+from sbs_integration_linear import newmark_beta_single
+
+SPECTRUM_PERIOD = [
+    0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09,
+    0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.8, 1.0,
+    1.2, 1.4, 1.6, 1.8, 2.0, 2.5, 3.0,
+    3.5, 4.0, 5.0, 6.0
+]  # 反应谱取点，单位秒
+
+
+def get_spectrum(
+        gm_acc_data: np.ndarray,
+        time_step: float,
+        damping_ratio: float = 0.05,
+        # Calculation way options
+        calc_func: any = newmark_beta_single,
+        calc_opt: int = 0,
+        max_process: int = 4) -> (
+        ndarray[float64],
+        ndarray[float64],
+        ndarray[float64],
+        ndarray[float64],
+        ndarray[float64]):
+    """
+    There are three types of response spectrum of ground motion: acceleration, velocity and displacement.
+    Type must in tuple ("ACC", "VEL", "DISP"), and can be both upper and lower.
+
+    Class :class:`GroundMotionData` use ``self.spectrum_acc`` , ``self.spectrum_acc`` , ``self.spectrum_acc``
+    to save. And this three variants will be calculated when they are first used.
+
+    TODO we use default damping ratio 0.05, try to use changeable damping ratio as input.
+
+    Warnings:
+    ------
+    The programme starts multi-threaded calculations by default
+
+    Args:
+        gm_acc_data: Ground motion acc data.
+        time_step: Time step.
+        damping_ratio: Damping ratio.
+        calc_opt: The type of calculation to use.
+
+            - 0 Use single_threaded. Slow
+
+            - 1 Use multi_threaded. Faster TODO This func not completed.
+
+        calc_func: The type of calculation to use.
+            The return of calc_func should be a tuple ``(acc, vel, disp)``.
+
+        max_process: if calc_opt in [1,2], the multi thread will be used.
+            This is the maximum number of threads.
+
+    Returns:
+        Calculated spectrum. np.ndarray[float] (batch size)
+
+    """
+    if gm_acc_data.ndim == 1:
+        gm_acc_data = np.expand_dims(gm_acc_data, axis=0)
+    elif gm_acc_data.ndim == 2:
+        pass
+    else:
+        raise ValueError("ndim of gm_acc_data must be 1 or 2.")
+
+    batch_size = gm_acc_data.shape[0]
+    seq_len = gm_acc_data.shape[1]
+    spectrum_acc = np.zeros((batch_size, len(SPECTRUM_PERIOD)))
+    spectrum_vel = np.zeros((batch_size, len(SPECTRUM_PERIOD)))
+    spectrum_disp = np.zeros((batch_size, len(SPECTRUM_PERIOD)))
+    spectrum_pse_acc = np.zeros((batch_size, len(SPECTRUM_PERIOD)))
+    spectrum_pse_vel = np.zeros((batch_size, len(SPECTRUM_PERIOD)))
+
+    if calc_opt == 0:
+        for i in range(len(SPECTRUM_PERIOD)):
+            acc, vel, disp = calc_func(
+                mass=1,
+                stiffness=(2 * np.pi / SPECTRUM_PERIOD[i]) ** 2,
+                load=gm_acc_data,
+                damping_ratio=damping_ratio,
+                time_step=time_step,
+                result_length=seq_len
+            )
+            spectrum_acc[:, i] = np.abs(acc).max(1)
+            spectrum_vel[:, i] = np.abs(vel).max(1)
+            spectrum_disp[:, i] = np.abs(disp).max(1)
+            spectrum_pse_acc[:, i] = np.abs(disp).max(1) * (2 * np.pi / SPECTRUM_PERIOD[i]) ** 2
+            spectrum_pse_vel[:, i] = np.abs(disp).max(1) * (2 * np.pi / SPECTRUM_PERIOD[i])
+
+    elif calc_opt == 1:
+        # Create Processes
+        # TODO IF really need mutil-process, use cpp dll. Don't use python's mutil-process.
+        pass
+
+    else:
+        raise KeyError("Parameter 'calc_opt' should be 0 or 1.")
+
+    if gm_acc_data.shape[0] == 1:
+        spectrum_acc = spectrum_acc.squeeze()
+        spectrum_vel = spectrum_vel.squeeze()
+        spectrum_disp = spectrum_disp.squeeze()
+        spectrum_pse_acc = spectrum_pse_acc.squeeze()
+        spectrum_pse_acc = spectrum_pse_acc.squeeze()
+
+    return spectrum_acc, spectrum_vel, spectrum_disp, spectrum_pse_acc, spectrum_pse_acc

ground_motion_tools-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "ground-motion-tools"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "RichardoGu",email = "xiaopenggu@qq.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy (>=2.2.4,<3.0.0)",
+    "scipy (>=1.15.2,<2.0.0)",
+    "geopy (>=2.4.1,<3.0.0)"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"