pygrt-kit 0.2.0__py3-none-win_amd64.whl

pygrt/C_extension/include/layer.h

@@ -0,0 +1,123 @@
+/**
+ * @file   layer.h
+ * @author Zhu Dengda (zhudengda@mail.iggcas.ac.cn)
+ * @date   2024-07-24
+ * 
+ * 以下代码实现的是 反射透射系数矩阵 ，参考：
+ * 
+ *         1. 姚振兴, 谢小碧. 2022/03. 理论地震图及其应用（初稿）.  
+ *         2. Yao Z. X. and D. G. Harkrider. 1983. A generalized refelection-transmission coefficient 
+ *               matrix and discrete wavenumber method for synthetic seismograms. BSSA. 73(6). 1685-1699
+ *            
+ */
+
+#pragma once
+
+#include "model.h"
+#include "const.h"
+
+/**
+ * 计算自由表面的反射系数，公式(5.3.10-14) 
+ * 
+ * @param     xa0        (in)表层的P波归一化垂直波数 \f$ \sqrt{1 - (k_a/k)^2} \f$
+ * @param     xb0        (in)表层的S波归一化垂直波数 \f$ \sqrt{1 - (k_b/k)^2} \f$
+ * @param     kbkb0     (in)表层的S波水平波数的平方 \f$ k_b^2=(\frac{\omega}{V_b})^2 \f$
+ * @param     k         (in)波数
+ * @param     R_tilt[2][2]     (out)P-SV系数矩阵，SH系数为1
+ * 
+ */
+void calc_R_tilt(
+    MYCOMPLEX xa0, MYCOMPLEX xb0, MYCOMPLEX kbkb0, MYREAL k, MYCOMPLEX R_tilt[2][2]);
+
+
+/**
+ * 计算接收点位置的接收矩阵，将波场转为位移，公式(5.2.19) + (5.7.7,25)
+ * 
+ * @param     xa_rcv      (in)接受层的P波归一化垂直波数 \f$ \sqrt{1 - (k_a/k)^2} \f$
+ * @param     xb_rcv      (in)接受层的S波归一化垂直波数 \f$ \sqrt{1 - (k_b/k)^2} \f$
+ * @param     ircvup      (in)接收点是否浅于震源层
+ * @param     k           (in)波数
+ * @param     R[2][2]     (in)P-SV波场
+ * @param     RL          (in)SH波场
+ * @param     R_EV[2][2]  (out)P-SV接收函数矩阵
+ * @param     R_EVL       (out)SH接收函数值
+ * 
+ */
+void calc_R_EV(
+    MYCOMPLEX xa_rcv, MYCOMPLEX xb_rcv, bool ircvup,
+    MYREAL k, 
+    const MYCOMPLEX R[2][2], MYCOMPLEX RL, 
+    MYCOMPLEX R_EV[2][2], MYCOMPLEX *R_EVL);
+
+
+/**
+ * 计算界面的反射系数RD/RDL/RU/RUL, 透射系数TD/TDL/TU/TUL, 包括时间延迟因子，
+ * 后缀L表示SH波的系数, 其余表示P-SV波的系数, 根据公式(5.4.14)和(5.4.31)计算系数   
+ * 
+ * @note   对公式(5.4.14)进行了重新整理。原公式各项之间的数量级差别过大，浮点数计算损失精度严重。
+ * 
+ * @param      Rho1      (in)上层的密度
+ * @param      xa1       (in)上层的P波归一化垂直波数 \f$ \sqrt{1 - (k_a/k)^2} \f$
+ * @param      xb1       (in)上层的S波归一化垂直波数 \f$ \sqrt{1 - (k_b/k)^2} \f$
+ * @param      kbkb1     (in)上层的S波水平波数的平方 \f$ k_b^2=(\frac{\omega}{V_b})^2 \f$
+ * @param      mu1       (in)上层的剪切模量
+ * @param      Rho2      (in)下层的密度
+ * @param      xa2       (in)下层的P波归一化垂直波数 \f$ \sqrt{1 - (k_a/k)^2} \f$
+ * @param      xb2       (in)下层的S波归一化垂直波数 \f$ \sqrt{1 - (k_b/k)^2} \f$
+ * @param      kbkb2     (in)下层的S波水平波数的平方 \f$ k_b^2=(\frac{\omega}{V_b})^2 \f$
+ * @param      mu2       (in)下层的剪切模量
+ * @param      thk       (in)上层层厚
+ * @param      k         (in)波数
+ * @param      RD[2][2]  (out)P-SV 下传反射系数矩阵
+ * @param      RDL       (out)SH 下传反射系数
+ * @param      RU[2][2]  (out)P-SV 上传反射系数矩阵
+ * @param      RUL       (out)SH 上传反射系数
+ * @param      TD[2][2]  (out)P-SV 下传透射系数矩阵
+ * @param      TDL       (out)SH 下传透射系数
+ * @param      TU[2][2]  (out)P-SV 上传透射系数矩阵
+ * @param      TUL       (out)SH 上传透射系数
+ * 
+ */
+void calc_RT_2x2(
+    MYREAL Rho1, MYCOMPLEX xa1, MYCOMPLEX xb1, MYCOMPLEX kbkb1, MYCOMPLEX mu1, 
+    MYREAL Rho2, MYCOMPLEX xa2, MYCOMPLEX xb2, MYCOMPLEX kbkb2, MYCOMPLEX mu2, 
+    MYREAL thk,
+    MYCOMPLEX omega, MYREAL k, 
+    MYCOMPLEX RD[2][2], MYCOMPLEX *RDL, MYCOMPLEX RU[2][2], MYCOMPLEX *RUL, 
+    MYCOMPLEX TD[2][2], MYCOMPLEX *TDL, MYCOMPLEX TU[2][2], MYCOMPLEX *TUL);
+
+
+
+/**
+ * 【未使用】
+ * 被calc_RT_2x2_from_4x4函数调用，生成该层的连接P-SV应力位移矢量与垂直波函数的D矩阵(或其逆矩阵)，
+ * 见公式(5.2.19-20)
+ * 
+ * @param      xa        (in)P波归一化垂直波数 \f$ \sqrt{1 - (k_a/k)^2} \f$
+ * @param      xb        (in)S波归一化垂直波数 \f$ \sqrt{1 - (k_b/k)^2} \f$
+ * @param      kbkb      (in)S波水平波数的平方 \f$ k_b^2=(\frac{\omega}{V_b})^2 \f$
+ * @param      mu        (in)剪切模量
+ * @param      omega     (in)复数频率  \f$ \tilde{\omega} =\omega - i\omega_I \f$ 
+ * @param      k         (in)波数
+ * 
+ * @param      D[4][4]   (out) D矩阵(或其逆矩阵)
+ * @param      inverse   (in)  是否生成逆矩阵
+ * 
+ */
+void get_layer_D(
+    MYCOMPLEX xa, MYCOMPLEX xb, MYCOMPLEX kbkb, MYCOMPLEX mu, 
+    MYCOMPLEX omega, MYREAL k, MYCOMPLEX D[4][4], bool inverse);
+
+
+
+/**
+ *  和calc_RT_2x2函数解决相同问题（但未包含时间延迟因子），但没有使用显式推导的公式，而是直接做矩阵运算，
+ * 暂未加入相位延迟矩阵
+ * 函数接口也和 calc_RT_2x2函数 类似
+ */
+void calc_RT_2x2_from_4x4(
+    MYREAL Rho1, MYCOMPLEX xa1, MYCOMPLEX xb1, MYCOMPLEX kbkb1, MYCOMPLEX mu1, 
+    MYREAL Rho2, MYCOMPLEX xa2, MYCOMPLEX xb2, MYCOMPLEX kbkb2, MYCOMPLEX mu2, 
+    MYCOMPLEX omega, MYREAL k, 
+    MYCOMPLEX RD[2][2], MYCOMPLEX *RDL, MYCOMPLEX RU[2][2], MYCOMPLEX *RUL, 
+    MYCOMPLEX TD[2][2], MYCOMPLEX *TDL, MYCOMPLEX TU[2][2], MYCOMPLEX *TUL);

pygrt/C_extension/include/logo.h

@@ -0,0 +1,57 @@
+/**
+ * @file   logo.h
+ * @author Zhu Dengda (zhudengda@mail.iggcas.ac.cn)
+ * @date   2024-12
+ * 
+ *    logo字符串
+ * 
+ */
+
+#pragma once
+
+
+#include <stdio.h>
+
+#include "const.h"
+#include "version.h"
+#include "colorstr.h"
+
+#if _TEST_WHETHER_WIN32_
+#include <windows.h>
+#endif
+
+
+inline GCC_ALWAYS_INLINE void print_logo(){
+
+#if _TEST_WHETHER_WIN32_
+    // 在Windows上设置控制台代码页为UTF-8，以显示下方由特殊字符组成的logo
+    SetConsoleOutputCP(65001);
+#endif
+
+printf(BOLD_GREEN "\n"
+"╔═══════════════════════════════════════════════════════════════╗\n"
+"║                                                               ║\n"
+"║              ██████╗     ██████╗     ████████╗                ║\n"
+"║             ██╔════╝     ██╔══██╗    ╚══██╔══╝                ║\n"
+"║             ██║  ███╗    ██████╔╝       ██║                   ║\n"
+"║             ██║   ██║    ██╔══██╗       ██║                   ║\n"
+"║             ╚██████╔╝    ██║  ██║       ██║                   ║\n"
+"║              ╚═════╝     ╚═╝  ╚═╝       ╚═╝                   ║\n"
+"║                                                               ║\n"
+"║                                                               ║\n"
+"║               Author: Zhu Dengda                              ║\n"
+"║                Email: zhudengda@mail.iggcas.ac.cn             ║\n"
+"║        Code Homepage: https://github.com/Dengda98/PyGRT       ║\n"
+"║              License: GPL-3.0 license                         ║\n"
+"║              Version: %-20s                    ║\n"
+"║                                                               ║\n"
+"║                                                               ║\n"
+"║    A Command-Line Tool for Computing Synthetic Seismograms    ║\n"
+"║            in Horizontally Layered Halfspace Model,           ║\n"
+"║     using Generalized Reflection-Transmission Method(GRTM)    ║\n"
+"║              and Discrete Wavenumber Method(DWM).             ║\n"
+"║                                                               ║\n"
+"╚═══════════════════════════════════════════════════════════════╝\n" 
+DEFAULT_RESTORE, GRT_VERSION);
+
+}

pygrt/C_extension/include/matrix.h

@@ -0,0 +1,205 @@
+/**
+ * @file   matrix.h
+ * @author Zhu Dengda (zhudengda@mail.iggcas.ac.cn)
+ * @date   2024-07-24
+ * 
+ * 2x2小矩阵的加、减、乘、除、求逆等操作，由于均为小型数组操作，所有函数均为内联函数               
+ */
+
+#pragma once
+
+#include "const.h"
+
+/**
+ * 计算2x2复矩阵的逆  
+ * 
+ * @param      M[2][2]    (in)原矩阵
+ * @param   invM[2][2]    (out)逆矩阵
+ */ 
+inline GCC_ALWAYS_INLINE void cmat2x2_inv(const MYCOMPLEX M[2][2], MYCOMPLEX invM[2][2]) {
+    MYCOMPLEX M00 = M[0][0];
+    MYCOMPLEX M11 = M[1][1];
+    MYCOMPLEX det = M00*M11 - M[0][1]*M[1][0];
+    if ( det == RZERO ){
+        // fprintf(stderr, "%.5e+%.5ej %.5e+%.5ej \n", CREAL(M[0][0]), CIMAG(M[0][0]), CREAL(M[0][1]), CIMAG(M[0][1]));
+        // fprintf(stderr, "%.5e+%.5ej %.5e+%.5ej \n", CREAL(M[1][0]), CIMAG(M[1][0]), CREAL(M[1][1]), CIMAG(M[1][1]));
+        // fprintf(stderr, "matrix2x2 det=0.0, set matrix inv = 0.0.\n");
+        det = RZERO;
+    } else {
+        det = RONE/det;
+    }
+
+    invM[0][0] = M11 * det;
+    invM[0][1] = M[0][1] * (-det);
+    invM[1][0] = M[1][0] * (-det);
+    invM[1][1] = M00 * det;
+}
+
+/**
+ * 计算2x2复矩阵的和  
+ * 
+ * @param     M1[2][2]    (in)矩阵1
+ * @param     M2[2][2]    (in)矩阵2
+ * @param     M[2][2]     (out)和矩阵
+ */ 
+inline GCC_ALWAYS_INLINE void cmat2x2_add(const MYCOMPLEX M1[2][2], const MYCOMPLEX M2[2][2], MYCOMPLEX M[2][2]){
+    M[0][0] = M1[0][0] + M2[0][0];
+    M[0][1] = M1[0][1] + M2[0][1];
+    M[1][0] = M1[1][0] + M2[1][0];
+    M[1][1] = M1[1][1] + M2[1][1];
+}
+
+/**
+ * 计算2x2复矩阵的差  
+ * 
+ * @param     M1[2][2]    (in)矩阵1
+ * @param     M2[2][2]    (in)矩阵2
+ * @param     M[2][2]     (out)差矩阵 M1-M2
+ */ 
+inline GCC_ALWAYS_INLINE void cmat2x2_sub(const MYCOMPLEX M1[2][2], const MYCOMPLEX M2[2][2], MYCOMPLEX M[2][2]){
+    M[0][0] = M1[0][0] - M2[0][0];
+    M[0][1] = M1[0][1] - M2[0][1];
+    M[1][0] = M1[1][0] - M2[1][0];
+    M[1][1] = M1[1][1] - M2[1][1];
+}
+
+/**
+ * 计算单位阵与2x2复矩阵的差  
+ * 
+ * @param     M[2][2]     (inout)差矩阵 I-M2
+ */ 
+inline GCC_ALWAYS_INLINE void cmat2x2_one_sub(MYCOMPLEX M[2][2]){
+    M[0][0] = RONE - M[0][0];
+    M[0][1] = - M[0][1];
+    M[1][0] = - M[1][0];
+    M[1][1] = RONE - M[1][1];
+}
+
+/**
+ * 计算2x2复矩阵的积(矩阵相乘)  
+ * 
+ * @param     M1[2][2]    (in)矩阵1
+ * @param     M2[2][2]    (in)矩阵2
+ * @param     M[2][2]     (out)积矩阵 M1 * M2
+ */ 
+inline GCC_ALWAYS_INLINE void cmat2x2_mul(const MYCOMPLEX M1[2][2], const MYCOMPLEX M2[2][2], MYCOMPLEX M[2][2]){
+    MYCOMPLEX M011, M012, M021, M022;
+    MYCOMPLEX M111, M112, M121, M122;
+    M011 = M1[0][0]; M012 = M1[0][1]; 
+    M021 = M1[1][0]; M022 = M1[1][1]; 
+    M111 = M2[0][0]; M112 = M2[0][1]; 
+    M121 = M2[1][0]; M122 = M2[1][1]; 
+    M[0][0] = M011 * M111 + M012 * M121;
+    M[0][1] = M011 * M112 + M012 * M122;
+    M[1][0] = M021 * M111 + M022 * M121;
+    M[1][1] = M021 * M112 + M022 * M122;
+}
+
+/**
+ * 计算2x2复矩阵和常量的积
+ * 
+ * @param     M1[2][2]    (in)矩阵1
+ * @param     k           (in)常数
+ * @param     M[2][2]     (out)积矩阵 k * M1
+ */
+inline GCC_ALWAYS_INLINE void cmat2x2_k(const MYCOMPLEX M1[2][2], MYCOMPLEX k0, MYCOMPLEX M[2][2]){
+    M[0][0] = M1[0][0] * k0;
+    M[0][1] = M1[0][1] * k0;
+    M[1][0] = M1[1][0] * k0;
+    M[1][1] = M1[1][1] * k0;
+}
+
+/**
+ * 计算2x2复矩阵和2x1的复向量的积
+ * 
+ * @param     M1[2][2]    (in)矩阵1
+ * @param     M2[2]       (in)向量2
+ * @param     M[2][2]     (out)积向量 M1 * M2
+ */
+inline GCC_ALWAYS_INLINE void cmat2x1_mul(const MYCOMPLEX M1[2][2], const MYCOMPLEX M2[2], MYCOMPLEX M[2]){
+    MYCOMPLEX M00, M10;
+    M00 = M1[0][0]*M2[0] + M1[0][1]*M2[1];
+    M10 = M1[1][0]*M2[0] + M1[1][1]*M2[1];
+    M[0] = M00;
+    M[1] = M10;
+}
+
+/** 
+ * 2x2复矩阵赋值 
+ * 
+ * @param     M1[2][2]    (in)源矩阵
+ * @param     M2[2][2]    (out)目标矩阵
+ */
+inline GCC_ALWAYS_INLINE void cmat2x2_assign(const MYCOMPLEX M1[2][2], MYCOMPLEX M2[2][2]){
+    M2[0][0] = M1[0][0];
+    M2[0][1] = M1[0][1];
+    M2[1][0] = M1[1][0];
+    M2[1][1] = M1[1][1];
+}
+
+/** 
+ * 计算nxn复矩阵的积(小矩阵)(最暴力的方式)
+ * 
+ * @param     m1          (in)M1矩阵行数
+ * @param     n1          (in)M1矩阵列数
+ * @param     p1          (in)M2矩阵列数
+ * @param     M1[m1][n1]  (in)M1矩阵 
+ * @param     M2[n1][p1]  (in)M2矩阵 
+ * @param     M[m1][p1]   (out)积矩阵 M1 * M2
+ */
+inline GCC_ALWAYS_INLINE void cmatmxn_mul(MYINT m1, MYINT n1, MYINT p1, const MYCOMPLEX M1[m1][n1], const MYCOMPLEX M2[n1][p1], MYCOMPLEX M[m1][p1]){
+    MYINT m, n, k;
+    MYCOMPLEX M0[m1][p1];
+    for(m=0; m<m1; ++m){
+        for(n=0; n<p1; ++n){
+            M0[m][n] = 0.0;
+            for(k=0; k<n1; ++k){
+                M0[m][n] += M1[m][k] * M2[k][n];
+            }
+        }
+    }
+
+    // memcpy(M, M0, sizeof(MYCOMPLEX)*m1*p1);
+    for(m=0; m<m1; ++m){
+        for(n=0; n<p1; ++n){
+            M[m][n] = M0[m][n];
+        }
+    }
+}
+
+/** 
+ * 从M1大矩阵中划分Q子矩阵
+ * 
+ * @param     m1          (in)M1矩阵行数
+ * @param     n1          (in)M1矩阵列数
+ * @param     M1[m1][n1]  (in)M1矩阵 
+ * @param     im          (in)子矩阵起始行索引
+ * @param     in          (in)子矩阵起始列索引
+ * @param     lm          (in)子矩阵行数
+ * @param     ln          (in)子矩阵列数
+ * @param     Q[lm][ln]   (out)子矩阵
+ */
+inline GCC_ALWAYS_INLINE void cmatmxn_block(MYINT m1, MYINT n1, const MYCOMPLEX M[m1][n1], MYINT im, MYINT in, MYINT lm, MYINT ln, MYCOMPLEX Q[lm][ln]){
+    for(MYINT m=0; m<lm; ++m){
+        for(MYINT n=0; n<ln; ++n){
+            Q[m][n] = M[im+m][in+n];
+        }
+    }
+}
+
+/**
+ * 打印矩阵 
+ * 
+ * @param     m1          (in)M1矩阵行数
+ * @param     n1          (in)M1矩阵列数
+ * @param     M1[m1][n1]  (in)M1矩阵 
+ * 
+ */
+inline GCC_ALWAYS_INLINE void cmatmxn_print(MYINT m1, MYINT n1, const MYCOMPLEX M1[m1][n1]){
+    for(MYINT i=0; i<m1; ++i){
+        for(MYINT j=0; j<n1; ++j){
+            printf(" %15.5e + J%-15.5e ", CREAL(M1[i][j]), CIMAG(M1[i][j]));
+        }
+        printf("\n");
+    }
+}

pygrt/C_extension/include/model.h

@@ -0,0 +1,165 @@
+/**
+ * @file   model.h
+ * @author Zhu Dengda (zhudengda@mail.iggcas.ac.cn)
+ * @date   2024-07-24
+ * 
+ * `MODEL1D` 结构体 以及 `PYMODEL1D` 结构体 的相关操作函数                  
+ */
+
+#pragma once
+
+#include <complex.h>
+#include <stdbool.h>
+#include "const.h"
+
+/**
+ * 单个水平层的结构体
+ */
+typedef struct _LAYER {
+    MYREAL thk;  ///< 层厚，最后一层厚度不使用(当作正无穷), km
+    MYREAL Va;  ///<   P波速度  km/s
+    MYREAL Vb;  ///<   S波速度  km/s
+    MYREAL Rho; ///<   密度  g/cm^3
+    MYREAL Qainv; ///<   1/Q_p
+    MYREAL Qbinv; ///<   1/Q_s
+    MYCOMPLEX mu;   ///< \f$ V_b^2 * \rho \f$
+    MYCOMPLEX kaka;  ///<  \f$ (\omega/V_a)^2 \f$
+    MYCOMPLEX kbkb;  ///<  \f$ (\omega/V_b)^2 \f$
+} LAYER;
+
+/**
+ * 1D模型结构体，包括多个水平层
+ */
+typedef struct _MODEL1D {
+    LAYER * lays; ///< 不同层的物性参数
+    MYINT n;  ///< 层数，注意包括了震源和接收点的虚拟层，(n>=3)
+    MYINT isrc; ///< 震源所在虚拟层位, isrc>=1
+    MYINT ircv; ///< 接收点所在虚拟层位, ircv>=1, ircv != isrc
+    MYINT imin; ///< 较浅的虚拟层位，min(isrc, ircv)
+    MYINT imax; ///< 较深的虚拟层位，max(isrc, ircv)
+    bool ircvup; ///< 接收点是否浅于震源层, ircv < isrc
+    
+} MODEL1D;
+
+
+/**
+ * 用于从Python传递数据的中间结构体
+ */
+typedef struct _PYMODEL1D {
+    MYINT n;  ///< 层数，注意包括了震源和接收点的虚拟层，(n>=3)
+    MYREAL depsrc; ///< 震源深度 km
+    MYREAL deprcv; ///< 接收点深度 km
+    MYINT isrc; ///< 震源所在虚拟层位, isrc>=1
+    MYINT ircv; ///< 接收点所在虚拟层位, ircv>=1, ircv != isrc
+    bool ircvup; ///< 接收点位于浅层, ircv < isrc
+
+    MYREAL *Thk; ///< Thk[n], 最后一层厚度不使用(当作正无穷), km
+    MYREAL *Va;  ///< Va[n]   P波速度  km/s
+    MYREAL *Vb;  ///< Vb[n]   S波速度  km/s
+    MYREAL *Rho; ///< Rho[n]  密度  g/cm^3
+    MYREAL *Qa; ///< Qa[n]     P波Q值
+    MYREAL *Qb; ///< Qb[n]     S波Q值
+} PYMODEL1D;
+
+/**
+ * 格林函数的频谱，仅作为将结果返回至Python使用 
+ */
+typedef struct _GRN {
+    MYINT nf; ///< 频点个数
+    MYREAL *Re; ///< Re[nf] 实部
+    MYREAL *Im; ///< Im[nf] 虚部
+    // float *Re;
+    // float *Im;
+} GRN;
+
+
+
+/**
+ * 打印模型参数信息，主要用于调试程序 
+ * 
+ * @param    mod1d  (in)`MODEL1D` 结构体指针
+ * 
+ */
+void print_mod1d(const MODEL1D *mod1d);
+
+/**
+ * 打印PYMODEL1D模型参数信息，主要用于调试程序 
+ * 
+ * @param    pymod  (in)`PYMODEL1D` 结构体指针
+ * 
+ */
+void print_pymod(const PYMODEL1D *pymod);
+
+/**
+ * 释放 `PYMODEL1D` 结构体指针 
+ * 
+ * @param     pymod   (out)`PYMODEL1D` 结构体指针
+ */
+void free_pymod(PYMODEL1D *pymod);
+
+/**
+ * 初始化模型内存空间 
+ * 
+ * @param    n       (in)模型层数 
+ * 
+ * @return    `MODEL1D` 结构体指针
+ * 
+ */
+MODEL1D * init_mod1d(MYINT n);
+
+/**
+ * 将 `PYMODEL1D` 结构体信息转到 `MODEL1D` 结构体中
+ * 
+ * @param    pymod1d    (in)`PYMODEL1D` 结构体指针
+ * @param    mod1d      (out) `MODEL1D` 结构体指针
+ * 
+ */
+void get_mod1d(const PYMODEL1D *pymod1d, MODEL1D *mod1d);
+
+/**
+ * 复制 `MODEL1D` 结构体，要求都以初始化
+ * 
+ * @param    mod1d1    (in)`MODEL1D` 源结构体指针
+ * @param    mod1d2    (out)`MODEL1D` 目标结构体指针
+ * 
+ */
+void copy_mod1d(const MODEL1D *mod1d1, MODEL1D *mod1d2);
+
+/**
+ * 释放 `MODEL1D` 结构体指针 
+ * 
+ * @param     mod1d   (out)`MODEL1D` 结构体指针
+ */
+void free_mod1d(MODEL1D *mod1d);
+
+
+/**
+ * 根据不同的omega， 更新模型的 \f$ k_a^2, k_b^2 \f$ 参数
+ * 
+ * @param     mod1d     (inout)`MODEL1D` 结构体指针
+ * @param     omega     (in)复数频率
+ */
+void update_mod1d_omega(MODEL1D *mod1d, MYCOMPLEX omega);
+
+/**
+ * 初始化PYMODEL1D模型内存空间 
+ * 
+ * @param    n       (in)模型层数 
+ * 
+ * @return    `PYMODEL1D` 结构体指针
+ * 
+ */
+PYMODEL1D * init_pymod(MYINT n);
+
+/**
+ * 从文件中读取模型文件，以PYMODEL1D结构体形式
+ * 
+ * @param    command       (in)命令名称
+ * @param    modelpath     (in)模型文件路径
+ * @param    depsrc        (in)震源深度
+ * @param    deprcv        (in)接收深度
+ * 
+ * @return    `PYMODEL1D` 结构体指针
+ * 
+ */
+PYMODEL1D * read_pymod_from_file(const char *command, const char *modelpath, double depsrc, double deprcv);

pygrt/C_extension/include/progressbar.h

@@ -0,0 +1,22 @@
+/**
+ * @file   progressbar.h
+ * @author Zhu Dengda (zhudengda@mail.iggcas.ac.cn)
+ * @date   2024-07-24
+ * 
+ * 以下代码实现进度条的输出
+ * 
+ */
+
+#include "const.h"
+
+
+#define _PROGRESSBAR_WIDTH_ 45  ///< 定义进度条的长度
+
+
+/**
+ * 根据百分比打印进度条  
+ * 
+ * @param    prefix     (in)进度条前缀字符串
+ * @param    percentage (in)百分比(整数)
+ */
+void printprogressBar(const char *prefix, MYINT percentage);