From f0bb97ac6796414984ba3bde86eba33f997157f2 Mon Sep 17 00:00:00 2001
From: Dengda98 <zhudengda21@mails.ucas.ac.cn>
Date: Wed, 3 Sep 2025 12:14:29 +0800
Subject: [PATCH 1/5] BUILD: update dependency

---
 pygrt/C_extension/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pygrt/C_extension/Makefile b/pygrt/C_extension/Makefile
index 1c92f3cb..99ceea79 100644
--- a/pygrt/C_extension/Makefile
+++ b/pygrt/C_extension/Makefile
@@ -89,7 +89,7 @@ endif
 $(BUILD_DIR)/%.d: $(SRC_DIR)/%.c
 	@mkdir -p $(shell dirname $@)
 	@$(CC) $(CFLAGS) -MM $< > $@.$$$$; \
-	sed 's,\($*\)\.o[ :]*,$(BUILD_DIR)/\1.o $@ : ,g' < $@.$$$$ > $@; \
+	sed 's,\($(notdir $*)\)\.o[ :]*,$(shell dirname $@)/\1.o $@ : ,g' < $@.$$$$ > $@; \
 	rm -f $@.$$$$
 
 # ----------------------------------------------------------------------

From 84d349e010023c2e00f12b071778f14eb9f97ec1 Mon Sep 17 00:00:00 2001
From: Dengda98 <zhudengda21@mails.ucas.ac.cn>
Date: Wed, 3 Sep 2025 13:13:16 +0800
Subject: [PATCH 2/5] REFAC: rename macros and global variables with prefix
 `GRT`

---
 pygrt/C_extension/include/grt/common/const.h  |  79 ++++----
 pygrt/C_extension/include/grt/common/dwm.h    |   6 +-
 pygrt/C_extension/include/grt/common/fim.h    |   6 +-
 .../C_extension/include/grt/common/integral.h |  14 +-
 .../C_extension/include/grt/common/iostats.h  |   6 +-
 pygrt/C_extension/include/grt/common/kernel.h |   4 +-
 pygrt/C_extension/include/grt/common/matrix.h |  12 +-
 pygrt/C_extension/include/grt/common/ptam.h   |   8 +-
 .../include/grt/common/radiation.h            |   4 +-
 .../include/grt/common/recursion.h            |  13 +-
 pygrt/C_extension/include/grt/common/safim.h  |   6 +-
 pygrt/C_extension/include/grt/common/util.h   |   6 +-
 pygrt/C_extension/include/grt/dynamic/grn.h   |   6 +-
 .../include/grt/dynamic/propagate.h           |   4 +-
 .../C_extension/include/grt/dynamic/source.h  |   4 +-
 .../include/grt/static/static_grn.h           |   6 +-
 .../include/grt/static/static_propagate.h     |   4 +-
 .../include/grt/static/static_source.h        |   4 +-
 pygrt/C_extension/src/common/attenuation.c    |   4 +-
 pygrt/C_extension/src/common/bessel.c         |   4 +-
 pygrt/C_extension/src/common/const.c          |  13 +-
 pygrt/C_extension/src/common/dwm.c            |  38 ++--
 pygrt/C_extension/src/common/fim.c            |  82 ++++----
 pygrt/C_extension/src/common/integral.c       |  68 +++----
 pygrt/C_extension/src/common/iostats.c        |  56 +++---
 pygrt/C_extension/src/common/model.c          |  12 +-
 pygrt/C_extension/src/common/ptam.c           | 137 +++++++------
 pygrt/C_extension/src/common/quadratic.c      |   2 +-
 pygrt/C_extension/src/common/radiation.c      |   4 +-
 pygrt/C_extension/src/common/recursion.c      |  56 +++---
 pygrt/C_extension/src/common/safim.c          | 114 +++++------
 pygrt/C_extension/src/common/util.c           |  30 +--
 pygrt/C_extension/src/dynamic/grn.c           |  68 +++----
 pygrt/C_extension/src/dynamic/grt_greenfn.c   |  22 +--
 pygrt/C_extension/src/dynamic/grt_rotation.c  |   2 +-
 pygrt/C_extension/src/dynamic/grt_strain.c    |   2 +-
 pygrt/C_extension/src/dynamic/grt_stress.c    |   2 +-
 pygrt/C_extension/src/dynamic/grt_syn.c       |  20 +-
 pygrt/C_extension/src/dynamic/layer.c         | 182 +++++++++---------
 pygrt/C_extension/src/dynamic/propagate.c     | 142 +++++++-------
 pygrt/C_extension/src/dynamic/source.c        |  26 +--
 .../src/static/grt_static_greenfn.c           |  34 ++--
 .../src/static/grt_static_rotation.c          |   2 +-
 .../src/static/grt_static_strain.c            |   2 +-
 .../src/static/grt_static_stress.c            |   2 +-
 pygrt/C_extension/src/static/grt_static_syn.c |  40 ++--
 pygrt/C_extension/src/static/static_grn.c     |  54 +++---
 pygrt/C_extension/src/static/static_layer.c   |  38 ++--
 .../C_extension/src/static/static_propagate.c |  94 ++++-----
 pygrt/C_extension/src/static/static_source.c  |  38 ++--
 50 files changed, 797 insertions(+), 785 deletions(-)

diff --git a/pygrt/C_extension/include/grt/common/const.h b/pygrt/C_extension/include/grt/common/const.h
index 8d429668..6233c769 100755
--- a/pygrt/C_extension/include/grt/common/const.h
+++ b/pygrt/C_extension/include/grt/common/const.h
@@ -10,6 +10,7 @@
 
 #include <complex.h> 
 #include <tgmath.h>
+#include <omp.h>
 
 #include "grt/common/checkerror.h"
 
@@ -46,13 +47,6 @@ typedef int MYINT;  ///< 整数
 #endif
 
 // 常数
-#define RZERO 0.0            ///< 0.0
-#define RQUART 0.25          ///< 0.25
-#define RHALF 0.5             ///< 0.5
-#define RONE 1.0            ///< 1.0
-#define RTWO 2.0            ///< 2.0
-#define RTHREE 3.0            ///< 3.0
-#define RFOUR 4.0            ///< 4.0
 #define RTWOTHIRD 0.6666666666666667  ///< 2/3
 #define PI  3.141592653589793        ///< \f$ \pi \f$
 #define PI2 6.283185307179586        ///< \f$ 2\pi \f$
@@ -63,21 +57,25 @@ typedef int MYINT;  ///< 整数
 #define SEVENQUARTERPI  5.497787143782138   ///< \f$ \frac{7\pi}{4} \f$
 #define INV_SQRT_TWO 0.7071067811865475   ///< \f$ \frac{1}{\sqrt{2}} \f$ 
 #define DEG1 0.017453292519943295  ///< \f$ \frac{\pi}{180} \f$ 
+#define GOLDEN_RATIO 0.6180339887498949  ///< \f$ \frac{\sqrt{5}-1}{2} \f$
 
-#define CZERO CMPLX(RZERO, RZERO)  ///< 0.0 + j0.0
-#define CONE  CMPLX(RONE,  RZERO)  ///< 1.0 + j0.0
-#define INIT_C_ZERO_2x2_MATRIX {{CZERO, CZERO}, {CZERO, CZERO}}   ///< 初始化复数0矩阵
-#define INIT_C_IDENTITY_2x2_MATRIX {{CONE, CZERO}, {CZERO, CONE}}  ///< 初始化复数单位阵
+#define GRT_INIT_ZERO_2x2_MATRIX {{0, 0}, {0, 0}}   ///< 初始化复数0矩阵
+#define GRT_INIT_IDENTITY_2x2_MATRIX {{1, 0}, {0, 1}}  ///< 初始化复数单位阵
 
-#define MIN_DEPTH_GAP_SRC_RCV  1.0  ///< 震源和台站的最小深度差（不做绝对限制，仅用于参考波数积分上限）
+#define GRT_MIN_DEPTH_GAP_SRC_RCV  1.0  ///< 震源和台站的最小深度差（不做绝对限制，仅用于参考波数积分上限，以及判断是否需要其它收敛方法）
 #define GCC_ALWAYS_INLINE __attribute__((always_inline))  ///< gcc编译器不改动内联函数
 
 #define GRT_SWAP(type, a, b) { type temp = a; a = b; b = temp; } ///< 交换两个变量的值
 
 #define GRT_STRING_FMT "%18s"  ///< 字符串输出格式
 #define GRT_REAL_FMT "%18.8e"  ///< 浮点数输出格式
-#define GRT_CMPLX_FMT "%18.8e%-+14.8ej"   ///< 复数输出格式
+#define GRT_CMPLX_FMT "%18.8e%16.8e"   ///< 复数输出格式
 #define GRT_STR_CMPLX_FMT "%34s"    ///< 与复数格式同长度的字符串输出格式
+#define GRT_STRING_LONG_FMT "%25s"  ///< 字符串输出格式（更长）
+#define GRT_REAL_LONG_FMT "%25.16e"  ///< 浮点数输出格式（更长）
+#define GRT_CMPLX_LONG_FMT "%25.16e %25.16e"   ///< 复数输出格式（更长）
+#define GRT_STR_CMPLX_LONG_FMT "%51s"    ///< 与复数格式同长度的字符串输出格式（更长）
+#define GRT_CMPLX_SPLIT(x)  creal(x), cimag(x)   ///< 用于打印复数时将实部虚部分开
 
 #define GRT_MAX(a, b) ((a) > (b) ? (a) : (b))  ///< 求两者较大值
 #define GRT_MIN(a, b) ((a) < (b) ? (a) : (b))  ///< 求两者较小值
@@ -89,6 +87,7 @@ typedef int MYINT;  ///< 整数
 #define GRT_SAFE_FREE_PTR(ptr) ({\
     if(ptr!=NULL) {\
         free(ptr);\
+        ptr=NULL;\
     }\
 })
 
@@ -96,9 +95,11 @@ typedef int MYINT;  ///< 整数
 #define GRT_SAFE_FREE_PTR_ARRAY(ptr, count) ({\
     if(ptr!=NULL){\
         for(MYINT i=0; i<count; ++i){\
-            GRT_SAFE_FREE_PTR(ptr[i]);\
+            GRT_SAFE_FREE_PTR((ptr)[i]);\
+            (ptr)[i] = NULL;\
         }\
         GRT_SAFE_FREE_PTR(ptr);\
+        ptr=NULL;\
     }\
 })
 
@@ -110,50 +111,50 @@ typedef int MYINT;  ///< 整数
 })
 
 // -----------------------------------------------------------------------------
-#define CHANNEL_NUM    3     ///< 3, 代码中分量个数（ZRT，ZNE）
+#define GRT_CHANNEL_NUM    3     ///< 3, 代码中分量个数（ZRT，ZNE）
 
-#define QWV_NUM     3   ///< 3, 代码中核函数类型个数(q, w, v)
-#define INTEG_NUM   4    ///< 4, 代码中积分类型个数
-#define MORDER_MAX   2    ///< 2, 代码中阶数m的最大值
-#define SRC_M_NUM    6   ///< 6, 代码中不同震源、不同阶数的个数
-#define MECHANISM_NUM   6   ///<  6, 描述震源机制的最多参数
+#define GRT_QWV_NUM     3   ///< 3, 代码中核函数类型个数(q, w, v)
+#define GRT_INTEG_NUM   4    ///< 4, 代码中积分类型个数
+#define GRT_MORDER_MAX   2    ///< 2, 代码中阶数m的最大值
+#define GRT_SRC_M_NUM    6   ///< 6, 代码中不同震源、不同阶数的个数
+#define GRT_MECHANISM_NUM   6   ///<  6, 描述震源机制的最多参数
 
-#define PTAM_MAX_PT   36         ///< 36， 最后统计波峰波谷的目标数量
-#define PTAM_WINDOW_SIZE  3      ///< 3，  使用连续点数判断是否为波峰或波谷
-#define PTAM_MAX_WAITS    9      ///< 9,   判断波峰或波谷的最大等待次数，不能太小
+#define GRT_PTAM_PT_MAX   36         ///< 36， 最后统计波峰波谷的目标数量
+#define GRT_PTAM_WINDOW_SIZE  3      ///< 3，  使用连续点数判断是否为波峰或波谷
+#define GRT_PTAM_WAITS_MAX    9      ///< 9,   判断波峰或波谷的最大等待次数，不能太小
 
-#define INVERSE_SUCCESS   0      ///< 求逆或除法没有遇到除0错误
-#define INVERSE_FAILURE   -1     ///< 求逆或除法遇到除0错误
+#define GRT_INVERSE_SUCCESS   0      ///< 求逆或除法没有遇到除0错误
+#define GRT_INVERSE_FAILURE   -1     ///< 求逆或除法遇到除0错误
 
-#define GTYPES_MAX   2      ///< 2, 所有震源根据是否使用格林函数导数分为两类
+#define GRT_GTYPES_MAX   2      ///< 2, 所有震源根据是否使用格林函数导数分为两类
 
-/** 不同震源类型在全局数组中的索引 */
+/** 不同震源类型在大小为 GRT_SRC_M_NUM 的数组中的索引 */
 enum {
-    SRC_M_EX_INDEX = 0,
-    SRC_M_VF_INDEX = 1,
-    SRC_M_HF_INDEX = 2,
-    SRC_M_DD_INDEX = 3,
-    SRC_M_DS_INDEX = 4,
-    SRC_M_SS_INDEX = 5,
+    GRT_SRC_M_EX_INDEX = 0,
+    GRT_SRC_M_VF_INDEX = 1,
+    GRT_SRC_M_HF_INDEX = 2,
+    GRT_SRC_M_DD_INDEX = 3,
+    GRT_SRC_M_DS_INDEX = 4,
+    GRT_SRC_M_SS_INDEX = 5,
 };
 
 /** 分别对应爆炸源(0阶)，垂直力源(0阶)，水平力源(1阶)，剪切源(0,1,2阶) */ 
-extern const MYINT SRC_M_ORDERS[SRC_M_NUM];
+extern const MYINT GRT_SRC_M_ORDERS[GRT_SRC_M_NUM];
 
 /** 不同震源类型使用的格林函数类型，0为Gij，1为格林函数导数Gij,k */
-extern const MYINT SRC_M_GTYPES[SRC_M_NUM];
+extern const MYINT GRT_SRC_M_GTYPES[GRT_SRC_M_NUM];
 
 /** 不同震源，不同阶数的名称简写，用于命名 */
-extern const char *SRC_M_NAME_ABBR[SRC_M_NUM];
+extern const char *GRT_SRC_M_NAME_ABBR[GRT_SRC_M_NUM];
 
 /** q, w, v 名称代号 */
-extern const char qwvchs[];
+extern const char GRT_QWV_CODES[];
 
 /** ZRT三分量代号 */
-extern const char ZRTchs[];
+extern const char GRT_ZRT_CODES[];
 
 /** ZNE三分量代号 */
-extern const char ZNEchs[];
+extern const char GRT_ZNE_CODES[];
 
 
 /**
diff --git a/pygrt/C_extension/include/grt/common/dwm.h b/pygrt/C_extension/include/grt/common/dwm.h
index f40f992b..21bcc988 100644
--- a/pygrt/C_extension/include/grt/common/dwm.h
+++ b/pygrt/C_extension/include/grt/common/dwm.h
@@ -46,8 +46,8 @@
 MYREAL grt_discrete_integ(
     const GRT_MODEL1D *mod1d, MYREAL dk, MYREAL kmax, MYREAL keps, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *fstats, GRT_KernelFunc kerfunc, MYINT *stats);
diff --git a/pygrt/C_extension/include/grt/common/fim.h b/pygrt/C_extension/include/grt/common/fim.h
index 10e744c9..6e53ba9f 100755
--- a/pygrt/C_extension/include/grt/common/fim.h
+++ b/pygrt/C_extension/include/grt/common/fim.h
@@ -53,10 +53,10 @@
 MYREAL grt_linear_filon_integ(
     const GRT_MODEL1D *mod1d, MYREAL k0, MYREAL dk0, MYREAL filondk, MYREAL kmax, MYREAL keps, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *fstats, GRT_KernelFunc kerfunc, MYINT *stats);
 
 
diff --git a/pygrt/C_extension/include/grt/common/integral.h b/pygrt/C_extension/include/grt/common/integral.h
index e8e13881..0d368799 100644
--- a/pygrt/C_extension/include/grt/common/integral.h
+++ b/pygrt/C_extension/include/grt/common/integral.h
@@ -26,9 +26,9 @@
  */
 void grt_int_Pk(
     MYREAL k, MYREAL r, 
-    const MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
+    const MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
     bool calc_uir,
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM]);
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM]);
 
 
 
@@ -40,7 +40,7 @@ void grt_int_Pk(
  * @param[out]    tol             Z、R、T分量结果
  */
 void grt_merge_Pk(
-    const MYCOMPLEX sum_J[SRC_M_NUM][INTEG_NUM], MYCOMPLEX tol[SRC_M_NUM][CHANNEL_NUM]);
+    const MYCOMPLEX sum_J[GRT_SRC_M_NUM][GRT_INTEG_NUM], MYCOMPLEX tol[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]);
 
 
 
@@ -60,9 +60,9 @@ void grt_merge_Pk(
  */
 void grt_int_Pk_filon(
     MYREAL k, MYREAL r, bool iscos,
-    const MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
+    const MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
     bool calc_uir,
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM]);
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM]);
 
 
 /**
@@ -79,6 +79,6 @@ void grt_int_Pk_filon(
  */
 void grt_int_Pk_sa_filon(
     const MYREAL k3[3], MYREAL r, 
-    const MYCOMPLEX QWV3[3][SRC_M_NUM][QWV_NUM],
+    const MYCOMPLEX QWV3[3][GRT_SRC_M_NUM][GRT_QWV_NUM],
     bool calc_uir,
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM]);
\ No newline at end of file
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM]);
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/common/iostats.h b/pygrt/C_extension/include/grt/common/iostats.h
index 56de1e8f..36ced6e5 100755
--- a/pygrt/C_extension/include/grt/common/iostats.h
+++ b/pygrt/C_extension/include/grt/common/iostats.h
@@ -27,7 +27,7 @@
  *           记录其值主要用于参考其变化趋势。
  */
 void grt_write_stats(
-    FILE *f0, MYREAL k, const MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM]);
+    FILE *f0, MYREAL k, const MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM]);
 
 
 /**
@@ -55,8 +55,8 @@ MYINT grt_extract_stats(FILE *bf0, FILE *af0);
  */
 void grt_write_stats_ptam(
     FILE *f0, 
-    MYREAL Kpt[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT],
-    MYCOMPLEX Fpt[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT]);
+    MYREAL Kpt[GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX],
+    MYCOMPLEX Fpt[GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX]);
 
 
 /**
diff --git a/pygrt/C_extension/include/grt/common/kernel.h b/pygrt/C_extension/include/grt/common/kernel.h
index 11829196..aa631650 100644
--- a/pygrt/C_extension/include/grt/common/kernel.h
+++ b/pygrt/C_extension/include/grt/common/kernel.h
@@ -17,5 +17,5 @@
  * 计算核函数的函数指针，动态与静态的接口一致
  */
 typedef void (*GRT_KernelFunc) (
-    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
-    bool calc_uiz, MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM], MYINT *stats);
\ No newline at end of file
+    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
+    bool calc_uiz, MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM], MYINT *stats);
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/common/matrix.h b/pygrt/C_extension/include/grt/common/matrix.h
index 5596b118..abc11b2b 100755
--- a/pygrt/C_extension/include/grt/common/matrix.h
+++ b/pygrt/C_extension/include/grt/common/matrix.h
@@ -23,12 +23,12 @@ inline GCC_ALWAYS_INLINE void grt_cmat2x2_inv(const MYCOMPLEX M[2][2], MYCOMPLEX
     MYCOMPLEX M10 = M[1][0];
     MYCOMPLEX M11 = M[1][1];
     MYCOMPLEX det = M00*M11 - M01*M10;
-    if ( det == RZERO ){
+    if ( det == 0.0 ){
         // 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;
-        *stats = INVERSE_FAILURE;
+        // det = 0.0;
+        *stats = GRT_INVERSE_FAILURE;
         return;
     }
 
@@ -36,7 +36,7 @@ inline GCC_ALWAYS_INLINE void grt_cmat2x2_inv(const MYCOMPLEX M[2][2], MYCOMPLEX
     invM[0][1] = - M01 / det;
     invM[1][0] = - M10 / det;
     invM[1][1] = M00 / det;
-    *stats = INVERSE_SUCCESS;
+    *stats = GRT_INVERSE_SUCCESS;
 }
 
 /**
@@ -73,10 +73,10 @@ inline GCC_ALWAYS_INLINE void grt_cmat2x2_sub(const MYCOMPLEX M1[2][2], const MY
  * @param[in,out]     M       差矩阵 I-M2
  */ 
 inline GCC_ALWAYS_INLINE void grt_cmat2x2_one_sub(MYCOMPLEX M[2][2]){
-    M[0][0] = RONE - M[0][0];
+    M[0][0] = 1.0 - M[0][0];
     M[0][1] = - M[0][1];
     M[1][0] = - M[1][0];
-    M[1][1] = RONE - M[1][1];
+    M[1][1] = 1.0 - M[1][1];
 }
 
 /**
diff --git a/pygrt/C_extension/include/grt/common/ptam.h b/pygrt/C_extension/include/grt/common/ptam.h
index 30d48b28..3302a7f1 100755
--- a/pygrt/C_extension/include/grt/common/ptam.h
+++ b/pygrt/C_extension/include/grt/common/ptam.h
@@ -49,10 +49,10 @@
 void grt_PTA_method(
     const GRT_MODEL1D *mod1d, MYREAL k0, MYREAL predk, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J0[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *ptam_fstatsnr[nr][2], GRT_KernelFunc kerfunc, MYINT *stats);
 
 
@@ -74,7 +74,7 @@ void grt_PTA_method(
  *  
  */
 MYINT grt_cplx_peak_or_trough(
-    MYINT idx1, MYINT idx2, const MYCOMPLEX arr[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM], 
+    MYINT idx1, MYINT idx2, const MYCOMPLEX arr[GRT_PTAM_WINDOW_SIZE][GRT_SRC_M_NUM][GRT_INTEG_NUM], 
     MYREAL k, MYREAL dk, MYREAL *pk, MYCOMPLEX *value);
 
 
diff --git a/pygrt/C_extension/include/grt/common/radiation.h b/pygrt/C_extension/include/grt/common/radiation.h
index 0d0dc0a4..15a54f80 100644
--- a/pygrt/C_extension/include/grt/common/radiation.h
+++ b/pygrt/C_extension/include/grt/common/radiation.h
@@ -34,6 +34,6 @@
  *                                   对于张量源，mchn={Mxx, Mxy, Mxz, Myy, Myz, Mzz}
  */
 void grt_set_source_radiation(
-    double srcRadi[SRC_M_NUM][CHANNEL_NUM], const int computeType, const bool par_theta,
-    const double M0, const double coef, const double azrad, const double mchn[MECHANISM_NUM]
+    double srcRadi[GRT_SRC_M_NUM][GRT_CHANNEL_NUM], const int computeType, const bool par_theta,
+    const double M0, const double coef, const double azrad, const double mchn[GRT_MECHANISM_NUM]
 );
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/common/recursion.h b/pygrt/C_extension/include/grt/common/recursion.h
index 698c1df9..5a80a3ca 100644
--- a/pygrt/C_extension/include/grt/common/recursion.h
+++ b/pygrt/C_extension/include/grt/common/recursion.h
@@ -35,15 +35,6 @@
     TUL_##suffix = TUL;\
 })
 
-/*
-#define CMAT_ASSIGN(suffix) ({\
-    cmat2x2_assign(RD, RD_##suffix);  RDL_##suffix = RDL; \
-    cmat2x2_assign(RU, RU_##suffix);  RUL_##suffix = RUL; \
-    cmat2x2_assign(TD, TD_##suffix);  TDL_##suffix = TDL; \
-    cmat2x2_assign(TU, TU_##suffix);  TUL_##suffix = TUL; \
-})
-*/
-
 
 /** 合并 recursion_RD_PSV(SH) */
 void grt_recursion_RD(
@@ -362,5 +353,5 @@ void grt_get_qwv(
     bool ircvup, 
     const MYCOMPLEX R1[2][2], MYCOMPLEX RL1, 
     const MYCOMPLEX R2[2][2], MYCOMPLEX RL2, 
-    const MYCOMPLEX coef_PSV[QWV_NUM-1][2], const MYCOMPLEX coef_SH[2], 
-    MYCOMPLEX qwv[QWV_NUM]);
+    const MYCOMPLEX coef_PSV[GRT_QWV_NUM-1][2], const MYCOMPLEX coef_SH[2], 
+    MYCOMPLEX qwv[GRT_QWV_NUM]);
diff --git a/pygrt/C_extension/include/grt/common/safim.h b/pygrt/C_extension/include/grt/common/safim.h
index 38b788d7..4e1023d1 100755
--- a/pygrt/C_extension/include/grt/common/safim.h
+++ b/pygrt/C_extension/include/grt/common/safim.h
@@ -54,10 +54,10 @@
 MYREAL grt_sa_filon_integ(
     const GRT_MODEL1D *mod1d, MYREAL vmin, MYREAL k0, MYREAL dk0, MYREAL tol, MYREAL kmax, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J0[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *fstats, GRT_KernelFunc kerfunc, MYINT *stats);
 
 
diff --git a/pygrt/C_extension/include/grt/common/util.h b/pygrt/C_extension/include/grt/common/util.h
index d4c6dd88..4016950a 100644
--- a/pygrt/C_extension/include/grt/common/util.h
+++ b/pygrt/C_extension/include/grt/common/util.h
@@ -78,6 +78,6 @@ void grt_GF_freq2time_write_to_file(
     const MYREAL delayT0, const MYREAL delayV0, const bool calc_upar,
     const bool doEX, const bool doVF, const bool doHF, const bool doDC, 
     const char *chalst,
-    MYCOMPLEX *grn[nr][SRC_M_NUM][CHANNEL_NUM], 
-    MYCOMPLEX *grn_uiz[nr][SRC_M_NUM][CHANNEL_NUM], 
-    MYCOMPLEX *grn_uir[nr][SRC_M_NUM][CHANNEL_NUM]);
\ No newline at end of file
+    MYCOMPLEX *grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM], 
+    MYCOMPLEX *grn_uiz[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM], 
+    MYCOMPLEX *grn_uir[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM]);
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/dynamic/grn.h b/pygrt/C_extension/include/grt/dynamic/grn.h
index 7c08306c..df870eb3 100755
--- a/pygrt/C_extension/include/grt/dynamic/grn.h
+++ b/pygrt/C_extension/include/grt/dynamic/grn.h
@@ -55,11 +55,11 @@ void grt_integ_grn_spec(
     bool print_progressbar, 
 
     // 返回值，代表Z、R、T分量
-    MYCOMPLEX *grn[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYCOMPLEX *grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     bool calc_upar,
-    MYCOMPLEX *grn_uiz[nr][SRC_M_NUM][CHANNEL_NUM],
-    MYCOMPLEX *grn_uir[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYCOMPLEX *grn_uiz[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
+    MYCOMPLEX *grn_uir[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     const char *statsstr, // 积分过程输出
     MYINT  nstatsidxs, // 仅输出特定频点
diff --git a/pygrt/C_extension/include/grt/dynamic/propagate.h b/pygrt/C_extension/include/grt/dynamic/propagate.h
index c6422df5..b54397f3 100755
--- a/pygrt/C_extension/include/grt/dynamic/propagate.h
+++ b/pygrt/C_extension/include/grt/dynamic/propagate.h
@@ -88,8 +88,8 @@
  * 
  */
 void grt_kernel(
-    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
-    bool calc_uiz, MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM], MYINT *stats);
+    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
+    bool calc_uiz, MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM], MYINT *stats);
 
 
 
diff --git a/pygrt/C_extension/include/grt/dynamic/source.h b/pygrt/C_extension/include/grt/dynamic/source.h
index 6ca736c1..36a0c392 100755
--- a/pygrt/C_extension/include/grt/dynamic/source.h
+++ b/pygrt/C_extension/include/grt/dynamic/source.h
@@ -31,10 +31,10 @@
 void grt_source_coef_PSV(
     MYCOMPLEX src_xa, MYCOMPLEX src_xb, MYCOMPLEX src_kaka, MYCOMPLEX src_kbkb, 
     MYREAL k,
-    MYCOMPLEX coef[SRC_M_NUM][QWV_NUM-1][2]);
+    MYCOMPLEX coef[GRT_SRC_M_NUM][GRT_QWV_NUM-1][2]);
 
 /* SH 波的震源系数，参数见 source_coef_PSV  */
 void grt_source_coef_SH(
     MYCOMPLEX src_xb, MYCOMPLEX src_kbkb, 
     MYREAL k,
-    MYCOMPLEX coef[SRC_M_NUM][2]);
+    MYCOMPLEX coef[GRT_SRC_M_NUM][2]);
diff --git a/pygrt/C_extension/include/grt/static/static_grn.h b/pygrt/C_extension/include/grt/static/static_grn.h
index c3b10fc6..363e7f29 100644
--- a/pygrt/C_extension/include/grt/static/static_grn.h
+++ b/pygrt/C_extension/include/grt/static/static_grn.h
@@ -46,11 +46,11 @@ void grt_integ_static_grn(
     MYREAL filonLength, MYREAL safilonTol, MYREAL filonCut, 
 
     // 返回值，代表Z、R、T分量
-    MYREAL grn[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYREAL grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     bool calc_upar,
-    MYREAL grn_uiz[nr][SRC_M_NUM][CHANNEL_NUM],
-    MYREAL grn_uir[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYREAL grn_uiz[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
+    MYREAL grn_uir[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     const char *statsstr // 积分结果输出
 );
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/static/static_propagate.h b/pygrt/C_extension/include/grt/static/static_propagate.h
index 7badf1ef..ee5f5667 100644
--- a/pygrt/C_extension/include/grt/static/static_propagate.h
+++ b/pygrt/C_extension/include/grt/static/static_propagate.h
@@ -23,5 +23,5 @@
  * 
  */
 void grt_static_kernel(
-    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
-    bool calc_uiz, MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM], MYINT *stats);
\ No newline at end of file
+    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
+    bool calc_uiz, MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM], MYINT *stats);
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/static/static_source.h b/pygrt/C_extension/include/grt/static/static_source.h
index 5bf2644d..5ac512c9 100644
--- a/pygrt/C_extension/include/grt/static/static_source.h
+++ b/pygrt/C_extension/include/grt/static/static_source.h
@@ -22,7 +22,7 @@
  * @param[in]     k        波数
  * @param[out]    coef     震源系数 \f$ P_m, SV_m, SH_m \f$
  */
-void grt_static_source_coef_PSV(MYCOMPLEX delta, MYREAL k, MYCOMPLEX coef[SRC_M_NUM][QWV_NUM-1][2]);
+void grt_static_source_coef_PSV(MYCOMPLEX delta, MYREAL k, MYCOMPLEX coef[GRT_SRC_M_NUM][GRT_QWV_NUM-1][2]);
 
 /* SH 波的静态震源系数，参数见 static_source_coef_PSV */
-void grt_static_source_coef_SH(MYREAL k, MYCOMPLEX coef[SRC_M_NUM][2]);
\ No newline at end of file
+void grt_static_source_coef_SH(MYREAL k, MYCOMPLEX coef[GRT_SRC_M_NUM][2]);
\ No newline at end of file
diff --git a/pygrt/C_extension/src/common/attenuation.c b/pygrt/C_extension/src/common/attenuation.c
index 69c66970..3dd07d36 100755
--- a/pygrt/C_extension/src/common/attenuation.c
+++ b/pygrt/C_extension/src/common/attenuation.c
@@ -13,8 +13,8 @@
 
 
 MYCOMPLEX grt_attenuation_law(MYREAL Qinv, MYCOMPLEX omega){
-    return RONE + Qinv/PI * log(omega/PI2) + RHALF*Qinv*I;
-    // return RONE;
+    return 1.0 + Qinv/PI * log(omega/PI2) + 0.5*Qinv*I;
+    // return 1.0;
 }
 
 void grt_py_attenuation_law(MYREAL Qinv, MYREAL omg[2], MYREAL atte[2]){
diff --git a/pygrt/C_extension/src/common/bessel.c b/pygrt/C_extension/src/common/bessel.c
index d3f3d5b0..05cd7a8b 100755
--- a/pygrt/C_extension/src/common/bessel.c
+++ b/pygrt/C_extension/src/common/bessel.c
@@ -21,6 +21,6 @@ void grt_besselp012(MYREAL x, MYREAL *bj0, MYREAL *bj1, MYREAL *bj2){
     MYREAL j1=*bj1;
     MYREAL j2=*bj2;
     *bj0 = -j1;
-    *bj1 = j0 - RONE/x * j1;
-    *bj2 = j1 - RTWO/x * j2;
+    *bj1 = j0 - 1.0/x * j1;
+    *bj2 = j1 - 2.0/x * j2;
 }
diff --git a/pygrt/C_extension/src/common/const.c b/pygrt/C_extension/src/common/const.c
index 1141ac9d..49723735 100644
--- a/pygrt/C_extension/src/common/const.c
+++ b/pygrt/C_extension/src/common/const.c
@@ -7,26 +7,25 @@
  */
 
 #include "grt/common/const.h"
-#include <omp.h>
 
 
 /** 分别对应爆炸源(0阶)，垂直力源(0阶)，水平力源(1阶)，剪切源(0,1,2阶) */ 
-const MYINT SRC_M_ORDERS[SRC_M_NUM] = {0, 0, 1, 0, 1, 2};
+const MYINT GRT_SRC_M_ORDERS[GRT_SRC_M_NUM] = {0, 0, 1, 0, 1, 2};
 
 /** 不同震源类型使用的格林函数类型，0为Gij，1为格林函数导数Gij,k */
-const MYINT SRC_M_GTYPES[SRC_M_NUM] = {1, 0, 0, 1, 1, 1};
+const MYINT GRT_SRC_M_GTYPES[GRT_SRC_M_NUM] = {1, 0, 0, 1, 1, 1};
 
 /** 不同震源，不同阶数的名称简写，用于命名 */
-const char *SRC_M_NAME_ABBR[SRC_M_NUM] = {"EX", "VF", "HF", "DD", "DS", "SS"};
+const char *GRT_SRC_M_NAME_ABBR[GRT_SRC_M_NUM] = {"EX", "VF", "HF", "DD", "DS", "SS"};
 
 /** q, w, v 名称代号 */
-const char qwvchs[] = {'q', 'w', 'v'};
+const char GRT_QWV_CODES[] = {'q', 'w', 'v'};
 
 /** ZRT三分量代号 */
-const char ZRTchs[] = {'Z', 'R', 'T'};
+const char GRT_ZRT_CODES[] = {'Z', 'R', 'T'};
 
 /** ZNE三分量代号 */
-const char ZNEchs[] = {'Z', 'N', 'E'};
+const char GRT_ZNE_CODES[] = {'Z', 'N', 'E'};
 
 
 
diff --git a/pygrt/C_extension/src/common/dwm.c b/pygrt/C_extension/src/common/dwm.c
index d151d552..c0445409 100644
--- a/pygrt/C_extension/src/common/dwm.c
+++ b/pygrt/C_extension/src/common/dwm.c
@@ -26,17 +26,17 @@
 MYREAL grt_discrete_integ(
     const GRT_MODEL1D *mod1d, MYREAL dk, MYREAL kmax, MYREAL keps, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *fstats, GRT_KernelFunc kerfunc, MYINT *stats)
 {
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM];
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM];
 
     // 不同震源不同阶数的核函数 F(k, w) 
-    MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM];
-    MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM];
+    MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM];
+    MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM];
     
     MYREAL k = 0.0;
     MYINT ik = 0;
@@ -59,7 +59,7 @@ MYREAL grt_discrete_integ(
         // printf("w=%15.5e, ik=%d\n", creal(omega), ik);
         // 计算核函数 F(k, w)
         kerfunc(mod1d, omega, k, QWV, calc_upar, QWV_uiz, stats); 
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
         
         // 记录积分核函数
         if(fstats!=NULL)  grt_write_stats(fstats, k, QWV);
@@ -69,9 +69,9 @@ MYREAL grt_discrete_integ(
         for(MYINT ir=0; ir<nr; ++ir){
             if(iendkrs[ir]) continue; // 该震中距下的波数k积分已收敛
 
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                for(MYINT v=0; v<INTEG_NUM; ++v){
-                    SUM[i][v] = CZERO;
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
+                    SUM[i][v] = 0.0;
                 }
             }
             
@@ -79,20 +79,20 @@ MYREAL grt_discrete_integ(
             grt_int_Pk(k, rs[ir], QWV, false, SUM);
             
             iendk0 = true;
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                MYINT modr = SRC_M_ORDERS[i];
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                MYINT modr = GRT_SRC_M_ORDERS[i];
 
-                for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                     sum_J[ir][i][v] += SUM[i][v];
                     
                     // 是否提前判断达到收敛
-                    if(keps <= RZERO || (modr==0 && v!=0 && v!=2))  continue;
+                    if(keps <= 0.0 || (modr==0 && v!=0 && v!=2))  continue;
                     
                     iendk0 = iendk0 && (fabs(SUM[i][v])/ fabs(sum_J[ir][i][v]) <= keps);
                 }
             }
             
-            if(keps > RZERO){
+            if(keps > 0.0){
                 iendkrs[ir] = iendk0;
                 iendk = iendk && iendkrs[ir];
             } else {
@@ -107,8 +107,8 @@ MYREAL grt_discrete_integ(
                 grt_int_Pk(k, rs[ir], QWV_uiz, false, SUM);
                 
                 // keps不参与计算位移空间导数的积分，背后逻辑认为u收敛，则uiz也收敛
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                         sum_uiz_J[ir][i][v] += SUM[i][v];
                     }
                 }
@@ -118,8 +118,8 @@ MYREAL grt_discrete_integ(
                 grt_int_Pk(k, rs[ir], QWV, true, SUM);
                 
                 // keps不参与计算位移空间导数的积分，背后逻辑认为u收敛，则uiz也收敛
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                         sum_uir_J[ir][i][v] += SUM[i][v];
                     }
                 }
diff --git a/pygrt/C_extension/src/common/fim.c b/pygrt/C_extension/src/common/fim.c
index b05cc67d..8167fb94 100755
--- a/pygrt/C_extension/src/common/fim.c
+++ b/pygrt/C_extension/src/common/fim.c
@@ -25,22 +25,22 @@
 MYREAL grt_linear_filon_integ(
     const GRT_MODEL1D *mod1d, MYREAL k0, MYREAL dk0, MYREAL dk, MYREAL kmax, MYREAL keps, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J0[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *fstats, GRT_KernelFunc kerfunc, MYINT *stats)
 {   
     // 从0开始，存储第二部分Filon积分的结果
-    MYCOMPLEX (*sum_J)[SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_J));
-    MYCOMPLEX (*sum_uiz_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
-    MYCOMPLEX (*sum_uir_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
+    MYCOMPLEX (*sum_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_J));
+    MYCOMPLEX (*sum_uiz_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
+    MYCOMPLEX (*sum_uir_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
 
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM];
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM];
 
     // 不同震源不同阶数的核函数 F(k, w) 
-    MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM];
-    MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM];
+    MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM];
+    MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM];
 
     MYREAL k=k0; 
     MYINT ik=0;
@@ -60,7 +60,7 @@ MYREAL grt_linear_filon_integ(
 
         // 计算核函数 F(k, w)
         kerfunc(mod1d, omega, k, QWV, calc_upar, QWV_uiz, stats); 
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
 
         // 记录积分结果
         if(fstats!=NULL)  grt_write_stats(fstats, k, QWV);
@@ -70,9 +70,9 @@ MYREAL grt_linear_filon_integ(
         for(MYINT ir=0; ir<nr; ++ir){
             if(iendkrs[ir]) continue; // 该震中距下的波数k积分已收敛
 
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                for(MYINT v=0; v<INTEG_NUM; ++v){
-                    SUM[i][v] = CZERO;
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
+                    SUM[i][v] = 0.0;
                 }
             }
             
@@ -80,14 +80,14 @@ MYREAL grt_linear_filon_integ(
             grt_int_Pk_filon(k, rs[ir], true, QWV, false, SUM);
 
             iendk0 = true;
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                MYINT modr = SRC_M_ORDERS[i];
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                MYINT modr = GRT_SRC_M_ORDERS[i];
 
-                for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                     sum_J[ir][i][v] += SUM[i][v];
                     
                     // 是否提前判断达到收敛
-                    if(keps <= RZERO || (modr==0 && v!=0 && v!=2))  continue;
+                    if(keps <= 0.0 || (modr==0 && v!=0 && v!=2))  continue;
                     
                     iendk0 = iendk0 && (fabs(SUM[i][v])/ fabs(sum_J[ir][i][v]) <= keps);
                 }
@@ -108,8 +108,8 @@ MYREAL grt_linear_filon_integ(
                 grt_int_Pk_filon(k, rs[ir], true, QWV_uiz, false, SUM);
                 
                 // keps不参与计算位移空间导数的积分，背后逻辑认为u收敛，则uiz也收敛
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                         sum_uiz_J[ir][i][v] += SUM[i][v];
                     }
                 }
@@ -119,8 +119,8 @@ MYREAL grt_linear_filon_integ(
                 grt_int_Pk_filon(k, rs[ir], true, QWV, true, SUM);
                 
                 // keps不参与计算位移空间导数的积分，背后逻辑认为u收敛，则uir也收敛
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                         sum_uir_J[ir][i][v] += SUM[i][v];
                     }
                 }
@@ -140,10 +140,10 @@ MYREAL grt_linear_filon_integ(
     // ------------------------------------------------------------------------------
     // 为累计项乘系数
     for(MYINT ir=0; ir<nr; ++ir){
-        MYREAL tmp = RTWO*(RONE - cos(dk*rs[ir])) / (rs[ir]*rs[ir]*dk);
+        MYREAL tmp = 2.0*(1.0 - cos(dk*rs[ir])) / (rs[ir]*rs[ir]*dk);
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 sum_J[ir][i][v] *= tmp;
 
                 if(calc_upar){
@@ -157,16 +157,16 @@ MYREAL grt_linear_filon_integ(
 
     // -------------------------------------------------------------------------------
     // 计算余项, [2]表示k积分的第一个点和最后一个点
-    MYCOMPLEX SUM_Gc[2][SRC_M_NUM][INTEG_NUM] = {0};
-    MYCOMPLEX SUM_Gs[2][SRC_M_NUM][INTEG_NUM] = {0};
+    MYCOMPLEX SUM_Gc[2][GRT_SRC_M_NUM][GRT_INTEG_NUM] = {0};
+    MYCOMPLEX SUM_Gs[2][GRT_SRC_M_NUM][GRT_INTEG_NUM] = {0};
 
 
     // 计算来自第一个点和最后一个点的余项
     for(MYINT iik=0; iik<2; ++iik){ 
         MYREAL k0N;
         MYINT sgn;
-        if(0==iik)       {k0N = k0+dk; sgn =  RONE;}
-        else if(1==iik)  {k0N = k;     sgn = -RONE;}
+        if(0==iik)       {k0N = k0+dk; sgn =  1.0;}
+        else if(1==iik)  {k0N = k;     sgn = -1.0;}
         else {
             fprintf(stderr, "Filon error.\n");
             exit(EXIT_FAILURE);
@@ -174,7 +174,7 @@ MYREAL grt_linear_filon_integ(
 
         // 计算核函数 F(k, w)
         kerfunc(mod1d, omega, k0N, QWV, calc_upar, QWV_uiz, stats);
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN; 
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN; 
 
         for(MYINT ir=0; ir<nr; ++ir){
             // Gc
@@ -184,12 +184,12 @@ MYREAL grt_linear_filon_integ(
             grt_int_Pk_filon(k0N, rs[ir], false, QWV, false, SUM_Gs[iik]);
 
             
-            MYREAL tmp = RONE / (rs[ir]*rs[ir]*dk);
-            MYREAL tmpc = tmp * (RONE - cos(dk*rs[ir]));
+            MYREAL tmp = 1.0 / (rs[ir]*rs[ir]*dk);
+            MYREAL tmpc = tmp * (1.0 - cos(dk*rs[ir]));
             MYREAL tmps = sgn * tmp * sin(dk*rs[ir]);
 
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                for(MYINT v=0; v<INTEG_NUM; ++v){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                     sum_J[ir][i][v] += (- tmpc*SUM_Gc[iik][i][v] + tmps*SUM_Gs[iik][i][v] - sgn*SUM_Gs[iik][i][v]/rs[ir]);
                 }
             }
@@ -204,8 +204,8 @@ MYREAL grt_linear_filon_integ(
                 // Gs
                 grt_int_Pk_filon(k0N, rs[ir], false, QWV_uiz, false, SUM_Gs[iik]);
 
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                         sum_uiz_J[ir][i][v] += (- tmpc*SUM_Gc[iik][i][v] + tmps*SUM_Gs[iik][i][v] - sgn*SUM_Gs[iik][i][v]/rs[ir]);
                     }
                 }
@@ -219,8 +219,8 @@ MYREAL grt_linear_filon_integ(
                 // Gs
                 grt_int_Pk_filon(k0N, rs[ir], false, QWV, true, SUM_Gs[iik]);
 
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                         sum_uir_J[ir][i][v] += (- tmpc*SUM_Gc[iik][i][v] + tmps*SUM_Gs[iik][i][v] - sgn*SUM_Gs[iik][i][v]/rs[ir]);
                     }
                 }
@@ -230,11 +230,11 @@ MYREAL grt_linear_filon_integ(
     
     }  // END k 2-points loop
 
-    // 乘上总系数 sqrt(RTWO/(PI*r)) / dk0,  除dks0是在该函数外还会再乘dk0, 并将结果加到原数组中
+    // 乘上总系数 sqrt(2.0/(PI*r)) / dk0,  除dks0是在该函数外还会再乘dk0, 并将结果加到原数组中
     for(MYINT ir=0; ir<nr; ++ir){
-        MYREAL tmp = sqrt(RTWO/(PI*rs[ir])) / dk0;
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        MYREAL tmp = sqrt(2.0/(PI*rs[ir])) / dk0;
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 sum_J0[ir][i][v] += sum_J[ir][i][v] * tmp;
 
                 if(calc_upar){
diff --git a/pygrt/C_extension/src/common/integral.c b/pygrt/C_extension/src/common/integral.c
index 6f869c93..95339e02 100644
--- a/pygrt/C_extension/src/common/integral.c
+++ b/pygrt/C_extension/src/common/integral.c
@@ -22,39 +22,39 @@
 void grt_int_Pk(
     MYREAL k, MYREAL r, 
     // F(ki,w)， 第一个维度表示不同震源，不同阶数，第二个维度3代表三类系数qm,wm,vm 
-    const MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
+    const MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
     // F(ki,w)Jm(ki*r)ki，第一个维度表示不同震源，不同阶数，第二个维度代表4种类型的F(k,w)Jm(kr)k的类型
     bool calc_uir,
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM])
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM])
 {
-    MYREAL bjmk[MORDER_MAX+1] = {0};
+    MYREAL bjmk[GRT_MORDER_MAX+1] = {0};
     MYREAL kr = k*r;
-    MYREAL kr_inv = RONE/kr;
+    MYREAL kr_inv = 1.0/kr;
     MYREAL kcoef = k;
 
-    MYREAL Jmcoef[MORDER_MAX+1] = {0};
+    MYREAL Jmcoef[GRT_MORDER_MAX+1] = {0};
 
     grt_bessel012(kr, &bjmk[0], &bjmk[1], &bjmk[2]); 
     if(calc_uir){
-        MYREAL bjmk0[MORDER_MAX+1] = {0};
-        for(MYINT i=0; i<=MORDER_MAX; ++i)  bjmk0[i] = bjmk[i];
+        MYREAL bjmk0[GRT_MORDER_MAX+1] = {0};
+        for(MYINT i=0; i<=GRT_MORDER_MAX; ++i)  bjmk0[i] = bjmk[i];
 
         grt_besselp012(kr, &bjmk[0], &bjmk[1], &bjmk[2]); 
         kcoef = k*k;
 
-        for(MYINT i=1; i<=MORDER_MAX; ++i)  Jmcoef[i] = kr_inv * (-kr_inv * bjmk0[i] + bjmk[i]);
+        for(MYINT i=1; i<=GRT_MORDER_MAX; ++i)  Jmcoef[i] = kr_inv * (-kr_inv * bjmk0[i] + bjmk[i]);
     } 
     else {
-        for(MYINT i=1; i<=MORDER_MAX; ++i)  Jmcoef[i] = bjmk[i]*kr_inv;
+        for(MYINT i=1; i<=GRT_MORDER_MAX; ++i)  Jmcoef[i] = bjmk[i]*kr_inv;
     }
 
-    for(MYINT i=1; i<=MORDER_MAX; ++i)  Jmcoef[i] *= kcoef;
-    for(MYINT i=0; i<=MORDER_MAX; ++i)  bjmk[i] *= kcoef;
+    for(MYINT i=1; i<=GRT_MORDER_MAX; ++i)  Jmcoef[i] *= kcoef;
+    for(MYINT i=0; i<=GRT_MORDER_MAX; ++i)  bjmk[i] *= kcoef;
 
 
     // 公式(5.6.22), 将公式分解为F(k,w)Jm(kr)k的形式
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        MYINT modr = SRC_M_ORDERS[i];  // 对应m阶数
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        MYINT modr = GRT_SRC_M_ORDERS[i];  // 对应m阶数
         if(modr == 0){
             SUM[i][0] = - QWV[i][0] * bjmk[1];   // - q0*J1*k
             SUM[i][2] =   QWV[i][1] * bjmk[0];   //   w0*J0*k
@@ -72,16 +72,16 @@ void grt_int_Pk(
 
 void grt_int_Pk_filon(
     MYREAL k, MYREAL r, bool iscos,
-    const MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
+    const MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
     bool calc_uir,
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM])
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM])
 {
     MYREAL phi0 = 0.0;
     if(! iscos)  phi0 = - HALFPI;  // 在cos函数中添加的相位差，用于计算sin函数
 
     MYREAL kr = k*r;
     MYREAL kcoef = sqrt(k);
-    MYREAL bjmk[MORDER_MAX+1] = {0};
+    MYREAL bjmk[GRT_MORDER_MAX+1] = {0};
 
     if(calc_uir){
         kcoef *= k;
@@ -96,11 +96,11 @@ void grt_int_Pk_filon(
         bjmk[2] = cos(kr - FIVEQUARTERPI - phi0);
     }
 
-    for(MYINT i=0; i<=MORDER_MAX; ++i)  bjmk[i] *= kcoef;
+    for(MYINT i=0; i<=GRT_MORDER_MAX; ++i)  bjmk[i] *= kcoef;
     
     // 公式(5.6.22), 将公式分解为F(k,w)Jm(kr)k的形式，忽略近场项
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        MYINT modr = SRC_M_ORDERS[i];  // 对应m阶数
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        MYINT modr = GRT_SRC_M_ORDERS[i];  // 对应m阶数
         if(modr == 0){
             SUM[i][0] = - QWV[i][0] * bjmk[1];   // - q0*J1*k
             SUM[i][2] =   QWV[i][1] * bjmk[0];   //   w0*J0*k
@@ -161,9 +161,9 @@ static MYCOMPLEX interg_quad_cos(
 
 void grt_int_Pk_sa_filon(
     const MYREAL k3[3], MYREAL r, 
-    const MYCOMPLEX QWV3[3][SRC_M_NUM][QWV_NUM],
+    const MYCOMPLEX QWV3[3][GRT_SRC_M_NUM][GRT_QWV_NUM],
     bool calc_uir,
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM])
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM])
 {
     // 使用bessel递推公式 Jm'(x) = m/x * Jm(x) - J_{m+1}(x)
     // 考虑大震中距，忽略第一项，再使用bessel渐近公式
@@ -173,13 +173,13 @@ void grt_int_Pk_sa_filon(
 
     // 对sqrt(k)*F(k,w)进行二次曲线拟合，再计算 (a*k^2 + b*k + c) * cos(kr - (2m+1)/4) 的积分
     // 拟合二次函数的参数
-    MYCOMPLEX quad_a[SRC_M_NUM][QWV_NUM]={0};
-    MYCOMPLEX quad_b[SRC_M_NUM][QWV_NUM]={0};
-    MYCOMPLEX quad_c[SRC_M_NUM][QWV_NUM]={0};
-    for(MYINT im=0; im<SRC_M_NUM; ++im){
-        MYINT modr = SRC_M_ORDERS[im];
-        for(MYINT c=0; c<QWV_NUM; ++c){
-            if(modr==0 && qwvchs[c] == 'v')  continue;
+    MYCOMPLEX quad_a[GRT_SRC_M_NUM][GRT_QWV_NUM]={0};
+    MYCOMPLEX quad_b[GRT_SRC_M_NUM][GRT_QWV_NUM]={0};
+    MYCOMPLEX quad_c[GRT_SRC_M_NUM][GRT_QWV_NUM]={0};
+    for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+        MYINT modr = GRT_SRC_M_ORDERS[im];
+        for(MYINT c=0; c<GRT_QWV_NUM; ++c){
+            if(modr==0 && GRT_QWV_CODES[c] == 'v')  continue;
 
             MYCOMPLEX F3[3];
             for(MYINT d=0; d<3; ++d)  F3[d] = QWV3[d][im][c] * sqrt(k3[d]) * sgn;
@@ -191,8 +191,8 @@ void grt_int_Pk_sa_filon(
 
     MYREAL kmin = k3[0], kmax = k3[2];
     // 公式(5.6.22), 将公式分解为F(k,w)Jm(kr)k的形式
-    for(MYINT im=0; im<SRC_M_NUM; ++im){
-        MYINT modr = SRC_M_ORDERS[im];  // 对应m阶数
+    for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+        MYINT modr = GRT_SRC_M_ORDERS[im];  // 对应m阶数
         if(modr == 0){
             SUM[im][0] = - interg_quad_cos(quad_a[im][0],quad_b[im][0],quad_c[im][0],1+modr0,r,kmin,kmax,kodr0);   // - q0*J1*k
             SUM[im][2] =   interg_quad_cos(quad_a[im][1],quad_b[im][1],quad_c[im][1],0+modr0,r,kmin,kmax,kodr0);   //   w0*J0*k
@@ -210,12 +210,12 @@ void grt_int_Pk_sa_filon(
 
 void grt_merge_Pk(
     // F(ki,w)Jm(ki*r)ki，
-    const MYCOMPLEX sum_J[SRC_M_NUM][INTEG_NUM], 
+    const MYCOMPLEX sum_J[GRT_SRC_M_NUM][GRT_INTEG_NUM], 
     // 累积求和，Z、R、T分量 
-    MYCOMPLEX tol[SRC_M_NUM][CHANNEL_NUM])
+    MYCOMPLEX tol[GRT_SRC_M_NUM][GRT_CHANNEL_NUM])
 {   
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        MYINT modr = SRC_M_ORDERS[i];
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        MYINT modr = GRT_SRC_M_ORDERS[i];
         if(modr==0){
             tol[i][0] = sum_J[i][2];
             tol[i][1] = sum_J[i][0];
diff --git a/pygrt/C_extension/src/common/iostats.c b/pygrt/C_extension/src/common/iostats.c
index e612ae6a..fe455a23 100755
--- a/pygrt/C_extension/src/common/iostats.c
+++ b/pygrt/C_extension/src/common/iostats.c
@@ -18,14 +18,14 @@
 
 
 void grt_write_stats(
-    FILE *f0, MYREAL k, const MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM])
+    FILE *f0, MYREAL k, const MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM])
 {
     fwrite(&k, sizeof(MYREAL), 1, f0);
 
-    for(MYINT im=0; im<SRC_M_NUM; ++im){
-        MYINT modr = SRC_M_ORDERS[im];
-        for(MYINT c=0; c<QWV_NUM; ++c){
-            if(modr == 0 && qwvchs[c] == 'v')   continue;
+    for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+        MYINT modr = GRT_SRC_M_ORDERS[im];
+        for(MYINT c=0; c<GRT_QWV_NUM; ++c){
+            if(modr == 0 && GRT_QWV_CODES[c] == 'v')   continue;
 
             fwrite(&QWV[im][c], sizeof(MYCOMPLEX), 1, f0);
         }
@@ -40,12 +40,12 @@ MYINT grt_extract_stats(FILE *bf0, FILE *af0){
         snprintf(K, sizeof(K), GRT_STRING_FMT, "k");  K[0]='#';
         fprintf(af0, "%s", K);
 
-        for(MYINT im=0; im<SRC_M_NUM; ++im){
-            MYINT modr = SRC_M_ORDERS[im];
-            for(MYINT c=0; c<QWV_NUM; ++c){
-                if(modr == 0 && qwvchs[c] == 'v')   continue;
+        for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+            MYINT modr = GRT_SRC_M_ORDERS[im];
+            for(MYINT c=0; c<GRT_QWV_NUM; ++c){
+                if(modr == 0 && GRT_QWV_CODES[c] == 'v')   continue;
 
-                snprintf(K, sizeof(K), "%s_%c", SRC_M_NAME_ABBR[im], qwvchs[c]);
+                snprintf(K, sizeof(K), "%s_%c", GRT_SRC_M_NAME_ABBR[im], GRT_QWV_CODES[c]);
                 fprintf(af0, GRT_STR_CMPLX_FMT, K);
             }
         }
@@ -59,10 +59,10 @@ MYINT grt_extract_stats(FILE *bf0, FILE *af0){
     if(1 != fread(&k, sizeof(MYREAL), 1, bf0))  return -1;
     fprintf(af0, GRT_REAL_FMT, k);
 
-    for(MYINT im=0; im<SRC_M_NUM; ++im){
-        MYINT modr = SRC_M_ORDERS[im];
-        for(MYINT c=0; c<QWV_NUM; ++c){
-            if(modr == 0 && qwvchs[c] == 'v')   continue;
+    for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+        MYINT modr = GRT_SRC_M_ORDERS[im];
+        for(MYINT c=0; c<GRT_QWV_NUM; ++c){
+            if(modr == 0 && GRT_QWV_CODES[c] == 'v')   continue;
 
             if(1 != fread(&val, sizeof(MYCOMPLEX), 1, bf0))  return -1;
             fprintf(af0, GRT_CMPLX_FMT, creal(val), cimag(val));
@@ -75,14 +75,14 @@ MYINT grt_extract_stats(FILE *bf0, FILE *af0){
 
 void grt_write_stats_ptam(
     FILE *f0, 
-    MYREAL Kpt[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT],
-    MYCOMPLEX Fpt[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT]
+    MYREAL Kpt[GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX],
+    MYCOMPLEX Fpt[GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX]
 ){
 
-    for(MYINT i=0; i<PTAM_MAX_PT; ++i){
-        for(MYINT im=0; im<SRC_M_NUM; ++im){
-            MYINT modr = SRC_M_ORDERS[im];
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+    for(MYINT i=0; i<GRT_PTAM_PT_MAX; ++i){
+        for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+            MYINT modr = GRT_SRC_M_ORDERS[im];
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 if(modr == 0 && v!=0 && v!=2)  continue;
                 
                 fwrite(&Kpt[im][v][i], sizeof(MYREAL),  1, f0);
@@ -100,19 +100,19 @@ MYINT grt_extract_stats_ptam(FILE *bf0, FILE *af0){
         char K[20], K2[20];
         MYINT icol=0;
 
-        for(MYINT im=0; im<SRC_M_NUM; ++im){
-            MYINT modr = SRC_M_ORDERS[im];
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+            MYINT modr = GRT_SRC_M_ORDERS[im];
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 if(modr == 0 && v!=0 && v!=2)  continue;
 
-                snprintf(K2, sizeof(K2), "sum_%s_%d_k", SRC_M_NAME_ABBR[im], v);
+                snprintf(K2, sizeof(K2), "sum_%s_%d_k", GRT_SRC_M_NAME_ABBR[im], v);
                 if(icol==0){
                     snprintf(K, sizeof(K), GRT_STRING_FMT, K2);  K2[0]='#';
                     fprintf(af0, "%s", K);
                 } else {
                     fprintf(af0, GRT_STRING_FMT, K2);
                 }
-                snprintf(K2, sizeof(K2), "sum_%s_%d", SRC_M_NAME_ABBR[im], v);
+                snprintf(K2, sizeof(K2), "sum_%s_%d", GRT_SRC_M_NAME_ABBR[im], v);
                 fprintf(af0, GRT_STR_CMPLX_FMT, K2);
                 
                 icol++;
@@ -126,9 +126,9 @@ MYINT grt_extract_stats_ptam(FILE *bf0, FILE *af0){
     MYREAL k;
     MYCOMPLEX val;
 
-    for(MYINT im=0; im<SRC_M_NUM; ++im){
-        MYINT modr = SRC_M_ORDERS[im];
-        for(MYINT v=0; v<INTEG_NUM; ++v){
+    for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+        MYINT modr = GRT_SRC_M_ORDERS[im];
+        for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
             if(modr == 0 && v!=0 && v!=2)  continue;
 
             if(1 != fread(&k, sizeof(MYREAL), 1, bf0))  return -1;
diff --git a/pygrt/C_extension/src/common/model.c b/pygrt/C_extension/src/common/model.c
index 7454c930..d1e686c8 100755
--- a/pygrt/C_extension/src/common/model.c
+++ b/pygrt/C_extension/src/common/model.c
@@ -157,7 +157,7 @@ void grt_update_mod1d_omega(GRT_MODEL1D *mod1d, MYCOMPLEX omega){
         atnb = (mod1d->Qbinv[i] > 0.0)? grt_attenuation_law(mod1d->Qbinv[i], omega) : 1.0;
         
         ka0 = omega/(Va0*atna);
-        kb0 = (Vb0>RZERO)? omega/(Vb0*atnb) : CZERO;
+        kb0 = (Vb0>0.0)? omega/(Vb0*atnb) : 0.0;
         mod1d->kaka[i] = ka0*ka0;
         mod1d->kbkb[i] = kb0*kb0;
         
@@ -376,15 +376,15 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
 }
 
 
-void grt_get_mod1d_vmin_vmax(const GRT_MODEL1D *mod1d, double *vmin, double *vmax){
-    *vmin = __DBL_MAX__;
-    *vmax = RZERO;
+void grt_get_mod1d_vmin_vmax(const GRT_MODEL1D *mod1d, MYREAL *vmin, MYREAL *vmax){
+    *vmin = 9.0e30;
+    *vmax = 0.0;
     const MYREAL *Va = mod1d->Va;
     const MYREAL *Vb = mod1d->Vb;
     for(MYINT i=0; i<mod1d->n; ++i){
         if(Va[i] < *vmin) *vmin = Va[i];
         if(Va[i] > *vmax) *vmax = Va[i];
-        if(Vb[i] < *vmin && Vb[i] > RZERO) *vmin = Vb[i];
-        if(Vb[i] > *vmax && Vb[i] > RZERO) *vmax = Vb[i];
+        if(Vb[i] < *vmin && Vb[i] > 0.0) *vmin = Vb[i];
+        if(Vb[i] > *vmax && Vb[i] > 0.0) *vmax = Vb[i];
     }
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/src/common/ptam.c b/pygrt/C_extension/src/common/ptam.c
index e7cb1d5e..069c4a8c 100755
--- a/pygrt/C_extension/src/common/ptam.c
+++ b/pygrt/C_extension/src/common/ptam.c
@@ -43,21 +43,21 @@
  */
 static void process_peak_or_trough(
     MYINT ir, MYINT im, MYINT v, MYREAL k, MYREAL dk, 
-    MYCOMPLEX (*J3)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM], MYREAL (*Kpt)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT], 
-    MYCOMPLEX (*Fpt)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT], MYINT (*Ipt)[SRC_M_NUM][INTEG_NUM], MYINT (*Gpt)[SRC_M_NUM][INTEG_NUM], bool *iendk0)
+    MYCOMPLEX (*J3)[GRT_PTAM_WINDOW_SIZE][GRT_SRC_M_NUM][GRT_INTEG_NUM], MYREAL (*Kpt)[GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX], 
+    MYCOMPLEX (*Fpt)[GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX], MYINT (*Ipt)[GRT_SRC_M_NUM][GRT_INTEG_NUM], MYINT (*Gpt)[GRT_SRC_M_NUM][GRT_INTEG_NUM], bool *iendk0)
 {
     MYCOMPLEX tmp0;
-    if (Gpt[ir][im][v] >= PTAM_WINDOW_SIZE-1 && Ipt[ir][im][v] < PTAM_MAX_PT) {
+    if (Gpt[ir][im][v] >= GRT_PTAM_WINDOW_SIZE-1 && Ipt[ir][im][v] < GRT_PTAM_PT_MAX) {
         if (grt_cplx_peak_or_trough(im, v, J3[ir], k, dk, &Kpt[ir][im][v][Ipt[ir][im][v]], &tmp0) != 0) {
             Fpt[ir][im][v][Ipt[ir][im][v]++] = tmp0;
             Gpt[ir][im][v] = 0;
-        } else if (Gpt[ir][im][v] >= PTAM_MAX_WAITS) {  // 不再等待，直接取中点作为波峰波谷
+        } else if (Gpt[ir][im][v] >= GRT_PTAM_WAITS_MAX) {  // 不再等待，直接取中点作为波峰波谷
             Kpt[ir][im][v][Ipt[ir][im][v]] = k - dk;
             Fpt[ir][im][v][Ipt[ir][im][v]++] = J3[ir][1][im][v];
             Gpt[ir][im][v] = 0;
         }
     }
-    *iendk0 = *iendk0 && (Ipt[ir][im][v] == PTAM_MAX_PT);
+    *iendk0 = *iendk0 && (Ipt[ir][im][v] == GRT_PTAM_PT_MAX);
 }
 
 
@@ -82,30 +82,30 @@ static void process_peak_or_trough(
  */
 static void ptam_once(
     const MYINT ir, const MYINT nr, const MYREAL precoef, MYREAL k, MYREAL dk, 
-    MYCOMPLEX SUM3[nr][PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYREAL Kpt[nr][SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT],
-    MYCOMPLEX Fpt[nr][SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT],
-    MYINT Ipt[nr][SRC_M_NUM][INTEG_NUM],
-    MYINT Gpt[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX SUM3[nr][GRT_PTAM_WINDOW_SIZE][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYREAL Kpt[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX],
+    MYCOMPLEX Fpt[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX],
+    MYINT Ipt[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYINT Gpt[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool *iendk0)
 {
     *iendk0 = true;
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        MYINT modr = SRC_M_ORDERS[i];
-        for(MYINT v=0; v<INTEG_NUM; ++v){
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        MYINT modr = GRT_SRC_M_ORDERS[i];
+        for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
             if(modr == 0 && v!=0 && v!= 2)  continue;
 
             // 赋更新量
             // SUM3转为求和结果
-            sum_J[ir][i][v] += SUM3[ir][PTAM_WINDOW_SIZE-1][i][v] * precoef;
-            SUM3[ir][PTAM_WINDOW_SIZE-1][i][v] = sum_J[ir][i][v];         
+            sum_J[ir][i][v] += SUM3[ir][GRT_PTAM_WINDOW_SIZE-1][i][v] * precoef;
+            SUM3[ir][GRT_PTAM_WINDOW_SIZE-1][i][v] = sum_J[ir][i][v];         
             
             // 3点以上，判断波峰波谷 
             process_peak_or_trough(ir, i, v, k, dk, SUM3, Kpt, Fpt, Ipt, Gpt, iendk0);
 
             // 左移动点, 
-            for(MYINT jj=0; jj<PTAM_WINDOW_SIZE-1; ++jj){
+            for(MYINT jj=0; jj<GRT_PTAM_WINDOW_SIZE-1; ++jj){
                 SUM3[ir][jj][i][v] = SUM3[ir][jj+1][i][v];
             }
 
@@ -119,10 +119,10 @@ static void ptam_once(
 void grt_PTA_method(
     const GRT_MODEL1D *mod1d, MYREAL k0, MYREAL predk, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J0[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *ptam_fstatsnr[nr][2], GRT_KernelFunc kerfunc, MYINT *stats)
 {   
     // 需要兼容对正常收敛而不具有规律波峰波谷的序列
@@ -132,42 +132,58 @@ void grt_PTA_method(
     MYREAL k=0.0;
 
     // 不同震源不同阶数的核函数 F(k, w) 
-    MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM];
-    MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM];
+    MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM];
+    MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM];
+
+    // 使用宏函数，方便定义
+    #define __CALLOC_ARRAY(VAR, TYP, __ARR) \
+        TYP (*VAR)__ARR = (TYP (*)__ARR)calloc(nr, sizeof(*VAR));
 
     // 用于接收F(ki,w)Jm(ki*r)ki
     // 存储采样的值，维度3表示通过连续3个点来判断波峰或波谷
     // 既用于存储被积函数，也最后用于存储求和的结果
-    MYCOMPLEX (*SUM3)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX (*)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*SUM3));
-    MYCOMPLEX (*SUM3_uiz)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX (*)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*SUM3_uiz));
-    MYCOMPLEX (*SUM3_uir)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX (*)[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*SUM3_uir));
+    #define __ARR [GRT_PTAM_WINDOW_SIZE][GRT_SRC_M_NUM][GRT_INTEG_NUM]
+        __CALLOC_ARRAY(SUM3, MYCOMPLEX, __ARR);
+        __CALLOC_ARRAY(SUM3_uiz, MYCOMPLEX, __ARR);
+        __CALLOC_ARRAY(SUM3_uir, MYCOMPLEX, __ARR);
+    #undef __ARR
 
     // 之前求和的值
-    MYCOMPLEX (*sum_J)[SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_J));
-    MYCOMPLEX (*sum_uiz_J)[SRC_M_NUM][INTEG_NUM] =  (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J));
-    MYCOMPLEX (*sum_uir_J)[SRC_M_NUM][INTEG_NUM] =  (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uir_J));
+    #define __ARR [GRT_SRC_M_NUM][GRT_INTEG_NUM]
+        __CALLOC_ARRAY(sum_J, MYCOMPLEX, __ARR);
+        __CALLOC_ARRAY(sum_uiz_J, MYCOMPLEX, __ARR);
+        __CALLOC_ARRAY(sum_uir_J, MYCOMPLEX, __ARR);
+    #undef __ARR
 
     // 存储波峰波谷的位置和值
-    MYREAL (*Kpt)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT] = (MYREAL (*)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT])calloc(nr, sizeof(*Kpt));
-    MYCOMPLEX (*Fpt)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT] = (MYCOMPLEX (*)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT])calloc(nr, sizeof(*Fpt));
-    MYINT (*Ipt)[SRC_M_NUM][INTEG_NUM] = (MYINT (*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*Ipt));
+    #define __ARR [GRT_SRC_M_NUM][GRT_INTEG_NUM][GRT_PTAM_PT_MAX]
+        __CALLOC_ARRAY(Kpt, MYREAL, __ARR);
+        __CALLOC_ARRAY(Fpt, MYCOMPLEX, __ARR);
+
+        __CALLOC_ARRAY(Kpt_uiz, MYREAL, __ARR);
+        __CALLOC_ARRAY(Fpt_uiz, MYCOMPLEX, __ARR);
 
-    MYREAL (*Kpt_uiz)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT] = (MYREAL (*)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT])calloc(nr, sizeof(*Kpt_uiz));
-    MYCOMPLEX (*Fpt_uiz)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT] = (MYCOMPLEX (*)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT])calloc(nr, sizeof(*Fpt_uiz));
-    MYINT (*Ipt_uiz)[SRC_M_NUM][INTEG_NUM] = (MYINT (*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*Ipt_uiz));
+        __CALLOC_ARRAY(Kpt_uir, MYREAL, __ARR);
+        __CALLOC_ARRAY(Fpt_uir, MYCOMPLEX, __ARR);
+    #undef __ARR
 
-    MYREAL (*Kpt_uir)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT] = (MYREAL (*)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT])calloc(nr, sizeof(*Kpt_uir));
-    MYCOMPLEX (*Fpt_uir)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT] = (MYCOMPLEX (*)[SRC_M_NUM][INTEG_NUM][PTAM_MAX_PT])calloc(nr, sizeof(*Fpt_uir));
-    MYINT (*Ipt_uir)[SRC_M_NUM][INTEG_NUM] = (MYINT (*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*Ipt_uir));
+    #define __ARR [GRT_SRC_M_NUM][GRT_INTEG_NUM]
+        // 存储波峰波谷的总个数
+        __CALLOC_ARRAY(Ipt, MYINT, __ARR);
+        __CALLOC_ARRAY(Ipt_uiz, MYINT, __ARR);
+        __CALLOC_ARRAY(Ipt_uir, MYINT, __ARR);
+
+        // 记录点数，当峰谷找到后，清零
+        __CALLOC_ARRAY(Gpt, MYINT, __ARR);
+        __CALLOC_ARRAY(Gpt_uiz, MYINT, __ARR);
+        __CALLOC_ARRAY(Gpt_uir, MYINT, __ARR);
+    #undef __ARR
+    #undef __CALLOC_ARRAY
 
-    // 记录点数，当峰谷找到后，清零
-    MYINT (*Gpt)[SRC_M_NUM][INTEG_NUM] = (MYINT (*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*Gpt));
-    MYINT (*Gpt_uiz)[SRC_M_NUM][INTEG_NUM] = (MYINT (*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*Gpt_uiz));
-    MYINT (*Gpt_uir)[SRC_M_NUM][INTEG_NUM] = (MYINT (*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*Gpt_uir));
 
     for(MYINT ir=0; ir<nr; ++ir){
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 sum_J[ir][i][v] = sum_J0[ir][i][v];
 
                 if(calc_upar){
@@ -185,10 +201,10 @@ void grt_PTA_method(
 
     // 对于PTAM，不同震中距使用不同dk
     for(MYINT ir=0; ir<nr; ++ir){
-        MYREAL dk = PI/((PTAM_MAX_WAITS-1)*rs[ir]); 
+        MYREAL dk = PI/((GRT_PTAM_WAITS_MAX-1)*rs[ir]); 
         MYREAL precoef = dk/predk; // 提前乘dk系数，以抵消格林函数主函数计算时最后乘dk
         // 根据波峰波谷的目标也给出一个kmax，+5以防万一 
-        MYREAL kmax = k0 + (PTAM_MAX_PT+5)*PI/rs[ir];
+        MYREAL kmax = k0 + (GRT_PTAM_PT_MAX+5)*PI/rs[ir];
 
         bool iendk0=false;
 
@@ -202,13 +218,13 @@ void grt_PTA_method(
 
             // 计算核函数 F(k, w)
             kerfunc(mod1d, omega, k, QWV, calc_upar, QWV_uiz, stats); 
-            if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+            if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
 
             // 记录核函数
             if(fstatsK!=NULL)  grt_write_stats(fstatsK, k, QWV);
 
             // 计算被积函数一项 F(k,w)Jm(kr)k
-            grt_int_Pk(k, rs[ir], QWV, false, SUM3[ir][PTAM_WINDOW_SIZE-1]);  // [PTAM_WINDOW_SIZE-1]表示把新点值放在最后
+            grt_int_Pk(k, rs[ir], QWV, false, SUM3[ir][GRT_PTAM_WINDOW_SIZE-1]);  // [GRT_PTAM_WINDOW_SIZE-1]表示把新点值放在最后
             // 判断和记录波峰波谷
             ptam_once( ir, nr, precoef, k, dk,  SUM3, sum_J, Kpt, Fpt, Ipt, Gpt, &iendk0);
             
@@ -216,13 +232,13 @@ void grt_PTA_method(
             if(calc_upar){
                 // ------------------------------- ui_z -----------------------------------
                 // 计算被积函数一项 F(k,w)Jm(kr)k
-                grt_int_Pk(k, rs[ir], QWV_uiz, false, SUM3_uiz[ir][PTAM_WINDOW_SIZE-1]);  // [PTAM_WINDOW_SIZE-1]表示把新点值放在最后
+                grt_int_Pk(k, rs[ir], QWV_uiz, false, SUM3_uiz[ir][GRT_PTAM_WINDOW_SIZE-1]);  // [GRT_PTAM_WINDOW_SIZE-1]表示把新点值放在最后
                 // 判断和记录波峰波谷
                 ptam_once(ir, nr, precoef, k, dk, SUM3_uiz, sum_uiz_J, Kpt_uiz, Fpt_uiz, Ipt_uiz, Gpt_uiz, &iendk0);
 
                 // ------------------------------- ui_r -----------------------------------
                 // 计算被积函数一项 F(k,w)Jm(kr)k
-                grt_int_Pk(k, rs[ir], QWV, true, SUM3_uir[ir][PTAM_WINDOW_SIZE-1]);  // [PTAM_WINDOW_SIZE-1]表示把新点值放在最后
+                grt_int_Pk(k, rs[ir], QWV, true, SUM3_uir[ir][GRT_PTAM_WINDOW_SIZE-1]);  // [GRT_PTAM_WINDOW_SIZE-1]表示把新点值放在最后
                 // 判断和记录波峰波谷
                 ptam_once(ir, nr, precoef, k, dk, SUM3_uir, sum_uir_J, Kpt_uir, Fpt_uir, Ipt_uir, Gpt_uir, &iendk0);
             
@@ -242,8 +258,8 @@ void grt_PTA_method(
         // 记录到文件
         if(fstatsP!=NULL)  grt_write_stats_ptam(fstatsP, Kpt[ir], Fpt[ir]);
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 grt_cplx_shrink(Ipt[ir][i][v], Fpt[ir][i][v]);  
                 sum_J0[ir][i][v] = Fpt[ir][i][v][0];
 
@@ -259,19 +275,24 @@ void grt_PTA_method(
     }
 
     BEFORE_RETURN:
-    GRT_SAFE_FREE_PTR(SUM3); GRT_SAFE_FREE_PTR(SUM3_uiz); GRT_SAFE_FREE_PTR(SUM3_uir);
-    GRT_SAFE_FREE_PTR(sum_J); GRT_SAFE_FREE_PTR(sum_uiz_J); GRT_SAFE_FREE_PTR(sum_uir_J); 
-
-    GRT_SAFE_FREE_PTR(Kpt);  GRT_SAFE_FREE_PTR(Fpt);  GRT_SAFE_FREE_PTR(Ipt);  GRT_SAFE_FREE_PTR(Gpt);
-    GRT_SAFE_FREE_PTR(Kpt_uiz);  GRT_SAFE_FREE_PTR(Fpt_uiz);  GRT_SAFE_FREE_PTR(Ipt_uiz);  GRT_SAFE_FREE_PTR(Gpt_uiz);
-    GRT_SAFE_FREE_PTR(Kpt_uir);  GRT_SAFE_FREE_PTR(Fpt_uir);  GRT_SAFE_FREE_PTR(Ipt_uir);  GRT_SAFE_FREE_PTR(Gpt_uir);
 
+    #define __FREE_ALL_ARRAY \
+        X(SUM3)    X(SUM3_uiz)    X(SUM3_uir) \
+        X(sum_J)   X(sum_uiz_J)   X(sum_uir_J) \
+        X(Kpt)     X(Fpt)         X(Ipt)       X(Gpt) \
+        X(Kpt_uiz)     X(Fpt_uiz)         X(Ipt_uiz)       X(Gpt_uiz) \
+        X(Kpt_uir)     X(Fpt_uir)         X(Ipt_uir)       X(Gpt_uir) \
+
+    #define X(A)  GRT_SAFE_FREE_PTR(A);
+        __FREE_ALL_ARRAY
+    #undef X
+    #undef __FREE_ALL_ARRAY
 }
 
 
 
 
-MYINT grt_cplx_peak_or_trough(MYINT idx1, MYINT idx2, const MYCOMPLEX arr[PTAM_WINDOW_SIZE][SRC_M_NUM][INTEG_NUM], MYREAL k, MYREAL dk, MYREAL *pk, MYCOMPLEX *value){
+MYINT grt_cplx_peak_or_trough(MYINT idx1, MYINT idx2, const MYCOMPLEX arr[GRT_PTAM_WINDOW_SIZE][GRT_SRC_M_NUM][GRT_INTEG_NUM], MYREAL k, MYREAL dk, MYREAL *pk, MYCOMPLEX *value){
     MYCOMPLEX f1, f2, f3;
     MYREAL rf1, rf2, rf3;
     MYINT stat=0;
diff --git a/pygrt/C_extension/src/common/quadratic.c b/pygrt/C_extension/src/common/quadratic.c
index 90b83e12..d9cdace4 100755
--- a/pygrt/C_extension/src/common/quadratic.c
+++ b/pygrt/C_extension/src/common/quadratic.c
@@ -53,7 +53,7 @@ MYCOMPLEX grt_quad_integral(MYREAL x1, MYREAL x2, MYCOMPLEX a, MYCOMPLEX b, MYCO
     MYREAL xx1, xx2, xxx1, xxx2;
     xx1 = x1*x1;    xx2 = x2*x2;
     xxx1 = xx1*x1;  xxx2 = xx2*x2; 
-    return a/RTHREE*(xxx2 - xxx1) + b/RTWO*(xx2 - xx1) + c*(x2 - x1);
+    return a/3.0*(xxx2 - xxx1) + b/2.0*(xx2 - xx1) + c*(x2 - x1);
 }
 
 
diff --git a/pygrt/C_extension/src/common/radiation.c b/pygrt/C_extension/src/common/radiation.c
index 1a06d401..28a49ec5 100644
--- a/pygrt/C_extension/src/common/radiation.c
+++ b/pygrt/C_extension/src/common/radiation.c
@@ -13,8 +13,8 @@
 #include "grt/common/const.h"
 
 void grt_set_source_radiation(
-    double srcRadi[SRC_M_NUM][CHANNEL_NUM], const int computeType, const bool par_theta,
-    const double M0, const double coef, const double azrad, const double mchn[MECHANISM_NUM]
+    double srcRadi[GRT_SRC_M_NUM][GRT_CHANNEL_NUM], const int computeType, const bool par_theta,
+    const double M0, const double coef, const double azrad, const double mchn[GRT_MECHANISM_NUM]
 ){
     double mult;
     if(computeType == GRT_SYN_COMPUTE_SF){
diff --git a/pygrt/C_extension/src/common/recursion.c b/pygrt/C_extension/src/common/recursion.c
index 3d228fb3..dc199a41 100644
--- a/pygrt/C_extension/src/common/recursion.c
+++ b/pygrt/C_extension/src/common/recursion.c
@@ -46,7 +46,7 @@ void grt_recursion_RD_PSV(
     // RD, RDL
     grt_cmat2x2_mul(RU1, RD2, tmp1);
     grt_cmat2x2_one_sub(tmp1);
-    grt_cmat2x2_inv(tmp1, tmp1, stats);  if(*stats==INVERSE_FAILURE)  return;
+    grt_cmat2x2_inv(tmp1, tmp1, stats);  if(*stats==GRT_INVERSE_FAILURE)  return;
     grt_cmat2x2_mul(tmp1, TD1, tmp2);
     if(inv_2x2T!=NULL) grt_cmat2x2_assign(tmp2, inv_2x2T);
 
@@ -62,12 +62,12 @@ void grt_recursion_RD_SH(
 {
     MYCOMPLEX inv1;
 
-    inv1 = RONE - RUL1*RDL2;
-    if(inv1 == CZERO){
-        *stats=INVERSE_FAILURE;
+    inv1 = 1.0 - RUL1*RDL2;
+    if(inv1 == 0.0){
+        *stats=GRT_INVERSE_FAILURE;
         return;
     }
-    inv1 = RONE / inv1 * TDL1;
+    inv1 = 1.0 / inv1 * TDL1;
     *RDL = RDL1 + TUL1*RDL2*inv1;
     if(invT!=NULL)  *invT = inv1;
 }
@@ -98,7 +98,7 @@ void grt_recursion_TD_PSV(
     // TD, TDL
     grt_cmat2x2_mul(RU1, RD2, tmp2);
     grt_cmat2x2_one_sub(tmp2);
-    grt_cmat2x2_inv(tmp2, tmp1, stats);  if(*stats==INVERSE_FAILURE)  return;
+    grt_cmat2x2_inv(tmp2, tmp1, stats);  if(*stats==GRT_INVERSE_FAILURE)  return;
     grt_cmat2x2_mul(tmp1, TD1, tmp2);
     if(inv_2x2T!=NULL)  grt_cmat2x2_assign(tmp2, inv_2x2T);
     grt_cmat2x2_mul(TD2, tmp2, TD);
@@ -111,12 +111,12 @@ void grt_recursion_TD_SH(
 {
     MYCOMPLEX inv1;
 
-    inv1 = RONE - RUL1*RDL2;
-    if(inv1 == CZERO){
-        *stats=INVERSE_FAILURE;
+    inv1 = 1.0 - RUL1*RDL2;
+    if(inv1 == 0.0){
+        *stats=GRT_INVERSE_FAILURE;
         return;
     }
-    inv1 = RONE / inv1 * TDL1;
+    inv1 = 1.0 / inv1 * TDL1;
     *TDL = TDL2 * inv1;
     if(invT!=NULL) *invT = inv1;
 }
@@ -148,7 +148,7 @@ void grt_recursion_RU_PSV(
     // RU, RUL
     grt_cmat2x2_mul(RD2, RU1, tmp2);
     grt_cmat2x2_one_sub(tmp2);
-    grt_cmat2x2_inv(tmp2, tmp1, stats);  if(*stats==INVERSE_FAILURE)  return;
+    grt_cmat2x2_inv(tmp2, tmp1, stats);  if(*stats==GRT_INVERSE_FAILURE)  return;
     grt_cmat2x2_mul(tmp1, TU2, tmp2);
     if(inv_2x2T!=NULL)  grt_cmat2x2_assign(tmp2, inv_2x2T);
 
@@ -166,12 +166,12 @@ void grt_recursion_RU_SH(
 {
     MYCOMPLEX inv1;
 
-    inv1 = RONE - RUL1*RDL2;
-    if(inv1 == CZERO){
-        *stats=INVERSE_FAILURE;
+    inv1 = 1.0 - RUL1*RDL2;
+    if(inv1 == 0.0){
+        *stats=GRT_INVERSE_FAILURE;
         return;
     }
-    inv1 = RONE / inv1 * TUL2;
+    inv1 = 1.0 / inv1 * TUL2;
     *RUL = RUL2 + TDL2*RUL1*inv1; 
     if(invT!=NULL)  *invT = inv1;
 }
@@ -203,7 +203,7 @@ void grt_recursion_TU_PSV(
     // TU, TUL
     grt_cmat2x2_mul(RD2, RU1, tmp2);
     grt_cmat2x2_one_sub(tmp2);
-    grt_cmat2x2_inv(tmp2, tmp1, stats);  if(*stats==INVERSE_FAILURE)  return;
+    grt_cmat2x2_inv(tmp2, tmp1, stats);  if(*stats==GRT_INVERSE_FAILURE)  return;
     grt_cmat2x2_mul(tmp1, TU2, tmp2);
     if(inv_2x2T!=NULL) grt_cmat2x2_assign(tmp2, inv_2x2T);
     grt_cmat2x2_mul(TU1, tmp2, TU);
@@ -218,12 +218,12 @@ void grt_recursion_TU_SH(
 {
     MYCOMPLEX inv1;
 
-    inv1 = RONE - RUL1*RDL2;
-    if(inv1 == CZERO){
-        *stats=INVERSE_FAILURE;
+    inv1 = 1.0 - RUL1*RDL2;
+    if(inv1 == 0.0){
+        *stats=GRT_INVERSE_FAILURE;
         return;
     }
-    inv1 = RONE / inv1 * TUL2;
+    inv1 = 1.0 / inv1 * TUL2;
     *TUL = TUL1 * inv1;
     if(invT!=NULL)  *invT = inv1;
 }
@@ -261,7 +261,7 @@ void grt_recursion_RT_PSV(
 
     grt_cmat2x2_mul(RU1, RD2, tmp1);
     grt_cmat2x2_one_sub(tmp1);
-    grt_cmat2x2_inv(tmp1, tmp1, stats);  if(*stats==INVERSE_FAILURE)  return;
+    grt_cmat2x2_inv(tmp1, tmp1, stats);  if(*stats==GRT_INVERSE_FAILURE)  return;
     grt_cmat2x2_mul(tmp1, TD1, tmp2);
 
     // TD
@@ -274,7 +274,7 @@ void grt_recursion_RT_PSV(
 
     grt_cmat2x2_mul(RD2, RU1, tmp1);
     grt_cmat2x2_one_sub(tmp1);
-    grt_cmat2x2_inv(tmp1, tmp1, stats);  if(*stats==INVERSE_FAILURE)  return;
+    grt_cmat2x2_inv(tmp1, tmp1, stats);  if(*stats==GRT_INVERSE_FAILURE)  return;
     grt_cmat2x2_mul(tmp1, TU2, tmp2);
 
     // TU
@@ -298,12 +298,12 @@ void grt_recursion_RT_SH(
     // 临时
     MYCOMPLEX inv0, inv1T;
 
-    inv0 = RONE - RUL1*RDL2;
-    if(inv0 == CZERO){
-        *stats=INVERSE_FAILURE;
+    inv0 = 1.0 - RUL1*RDL2;
+    if(inv0 == 0.0){
+        *stats=GRT_INVERSE_FAILURE;
         return;
     }
-    inv0 = RONE / inv0;
+    inv0 = 1.0 / inv0;
 
     inv1T = inv0 * TDL1;
     // TDL
@@ -380,8 +380,8 @@ void grt_get_qwv(
     bool ircvup, 
     const MYCOMPLEX R1[2][2], MYCOMPLEX RL1, 
     const MYCOMPLEX R2[2][2], MYCOMPLEX RL2, 
-    const MYCOMPLEX coef_PSV[QWV_NUM-1][2], const MYCOMPLEX coef_SH[2], 
-    MYCOMPLEX qwv[QWV_NUM])
+    const MYCOMPLEX coef_PSV[GRT_QWV_NUM-1][2], const MYCOMPLEX coef_SH[2], 
+    MYCOMPLEX qwv[GRT_QWV_NUM])
 {
     MYCOMPLEX qw0[2], qw1[2], v0;
     MYCOMPLEX coefD[2] = {coef_PSV[0][0], coef_PSV[1][0]};
diff --git a/pygrt/C_extension/src/common/safim.c b/pygrt/C_extension/src/common/safim.c
index a2594aa5..f51371a0 100644
--- a/pygrt/C_extension/src/common/safim.c
+++ b/pygrt/C_extension/src/common/safim.c
@@ -51,8 +51,8 @@ typedef enum {
 // 区间结构体
 typedef struct { 
     MYREAL k3[3];
-    MYCOMPLEX F3[3][SRC_M_NUM][QWV_NUM]; 
-    MYCOMPLEX F3_uiz[3][SRC_M_NUM][QWV_NUM]; 
+    MYCOMPLEX F3[3][GRT_SRC_M_NUM][GRT_QWV_NUM]; 
+    MYCOMPLEX F3_uiz[3][GRT_SRC_M_NUM][GRT_QWV_NUM]; 
 } KInterval;
 
 // 区间栈结构体
@@ -104,7 +104,7 @@ static KInterval stack_pop(KIntervalStack *stack) {
 static MYCOMPLEX simpson(const KInterval *item_pt, MYINT im, MYINT iqwv, bool isuiz, SIMPSON_INTV stats) {
     MYCOMPLEX Fint = 0.0;
     MYREAL klen = item_pt->k3[2] -  item_pt->k3[0];
-    const MYCOMPLEX (*F3)[SRC_M_NUM][QWV_NUM] = (isuiz)? item_pt->F3_uiz : item_pt->F3;
+    const MYCOMPLEX (*F3)[GRT_SRC_M_NUM][GRT_QWV_NUM] = (isuiz)? item_pt->F3_uiz : item_pt->F3;
     
     // 使用F(k)*sqrt(k)来衡量积分值，这可以平衡后续计算F(k)*Jm(kr)k积分时的系数
     MYREAL sk[3];
@@ -136,13 +136,13 @@ static MYCOMPLEX simpson(const KInterval *item_pt, MYINT im, MYINT iqwv, bool is
 }
 
 /** 比较QWV的最大绝对值 */
-static void get_maxabsQWV(const MYCOMPLEX F[SRC_M_NUM][QWV_NUM], MYREAL maxabsF[GTYPES_MAX]){
+static void get_maxabsQWV(const MYCOMPLEX F[GRT_SRC_M_NUM][GRT_QWV_NUM], MYREAL maxabsF[GRT_GTYPES_MAX]){
     MYREAL tmp;
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        for(MYINT c=0; c<QWV_NUM; ++c){
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        for(MYINT c=0; c<GRT_QWV_NUM; ++c){
             tmp = fabs(F[i][c]);
-            if(tmp > maxabsF[SRC_M_GTYPES[i]]){
-                maxabsF[SRC_M_GTYPES[i]] = tmp;
+            if(tmp > maxabsF[GRT_SRC_M_GTYPES[i]]){
+                maxabsF[GRT_SRC_M_GTYPES[i]] = tmp;
             }
         }
     }
@@ -152,14 +152,14 @@ static void get_maxabsQWV(const MYCOMPLEX F[SRC_M_NUM][QWV_NUM], MYREAL maxabsF[
 /** 检查区间是否符合要求，返回True表示通过 */
 static bool check_fit(
     const KInterval *ptKitv, const KInterval *ptKitvL, const KInterval *ptKitvR, MYREAL kref,
-    bool isuiz, MYREAL maxabsQWV[GTYPES_MAX], MYREAL tol)
+    bool isuiz, MYREAL maxabsQWV[GRT_GTYPES_MAX], MYREAL tol)
 {
     // 计算积分差异
     MYCOMPLEX S11, S12, S21, S22;
 
     // 核函数
-    const MYCOMPLEX (*F3L)[SRC_M_NUM][QWV_NUM] = (isuiz)? ptKitvL->F3_uiz : ptKitvL->F3;
-    const MYCOMPLEX (*F3R)[SRC_M_NUM][QWV_NUM] = (isuiz)? ptKitvR->F3_uiz : ptKitvR->F3;
+    const MYCOMPLEX (*F3L)[GRT_SRC_M_NUM][GRT_QWV_NUM] = (isuiz)? ptKitvL->F3_uiz : ptKitvL->F3;
+    const MYCOMPLEX (*F3R)[GRT_SRC_M_NUM][GRT_QWV_NUM] = (isuiz)? ptKitvR->F3_uiz : ptKitvR->F3;
 
     // 取近似积分 \int_k1^k2 k^0.5 dk
     MYREAL kcoef13 = RTWOTHIRD*( ptKitv->k3[2]*sqrt(ptKitv->k3[2]) - ptKitv->k3[0]*sqrt(ptKitv->k3[0]) );
@@ -168,16 +168,16 @@ static bool check_fit(
 
     MYREAL S_dif, S_ref;
     bool badtol = false;
-    for(MYINT im=0; im<SRC_M_NUM; ++im){
-        MYINT igtyp = SRC_M_GTYPES[im];
-        for(MYINT c=0; c<QWV_NUM; ++c){
-            if(SRC_M_ORDERS[im]==0 && qwvchs[c]=='v')  continue;
+    for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
+        MYINT igtyp = GRT_SRC_M_GTYPES[im];
+        for(MYINT c=0; c<GRT_QWV_NUM; ++c){
+            if(GRT_SRC_M_ORDERS[im]==0 && GRT_QWV_CODES[c]=='v')  continue;
             // qw和v分开采样?
-            // if(isqw && qwvchs[c]=='v')  continue;
-            // if(!isqw && qwvchs[c]!='v') continue;
+            // if(isqw && GRT_QWV_CODES[c]=='v')  continue;
+            // if(!isqw && GRT_QWV_CODES[c]!='v') continue;
 
             // k值在后段，只根据数值稳定的v分量判断是否拟合好
-            if(ptKitv->k3[0] > kref && qwvchs[c]!='v')  continue;
+            if(ptKitv->k3[0] > kref && GRT_QWV_CODES[c]!='v')  continue;
 
             S11 = simpson(ptKitv, im, c, isuiz, SIMPSON_A_ApH);
             S12 = simpson(ptKitv, im, c, isuiz, SIMPSON_ApH_Ap2H);
@@ -239,26 +239,26 @@ static bool check_fit(
 static void interv_integ(
     const KInterval *ptKitv,
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J[nr][SRC_M_NUM][INTEG_NUM])
+    MYCOMPLEX sum_uiz_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM])
 {
-    MYCOMPLEX SUM[SRC_M_NUM][INTEG_NUM]={0};
+    MYCOMPLEX SUM[GRT_SRC_M_NUM][GRT_INTEG_NUM]={0};
 
     // 震中距rs循环
     for(MYINT ir=0; ir<nr; ++ir){
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            for(MYINT v=0; v<INTEG_NUM; ++v){
-                SUM[i][v] = CZERO;
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
+                SUM[i][v] = 0.0;
             }
         }
 
         // 该分段内的积分
         grt_int_Pk_sa_filon(ptKitv->k3, rs[ir], ptKitv->F3, false, SUM);
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            MYINT modr = SRC_M_ORDERS[i];
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            MYINT modr = GRT_SRC_M_ORDERS[i];
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 if((modr==0 && v!=0 && v!=2))  continue;
                 sum_J[ir][i][v] += SUM[i][v];
             }
@@ -267,9 +267,9 @@ static void interv_integ(
         if(calc_upar){
             //----------------------------- ui_z --------------------------------------
             grt_int_Pk_sa_filon(ptKitv->k3, rs[ir], ptKitv->F3_uiz, false, SUM);
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                MYINT modr = SRC_M_ORDERS[i];
-                for(MYINT v=0; v<INTEG_NUM; ++v){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                MYINT modr = GRT_SRC_M_ORDERS[i];
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                     if((modr==0 && v!=0 && v!=2))  continue;
                     sum_uiz_J[ir][i][v] += SUM[i][v];
                 }
@@ -277,9 +277,9 @@ static void interv_integ(
 
             //----------------------------- ui_r --------------------------------------
             grt_int_Pk_sa_filon(ptKitv->k3, rs[ir], ptKitv->F3, true, SUM);
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                MYINT modr = SRC_M_ORDERS[i];
-                for(MYINT v=0; v<INTEG_NUM; ++v){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                MYINT modr = GRT_SRC_M_ORDERS[i];
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                     if((modr==0 && v!=0 && v!=2))  continue;
                     sum_uir_J[ir][i][v] += SUM[i][v];
                 }
@@ -295,19 +295,19 @@ static void interv_integ(
 MYREAL grt_sa_filon_integ(
     const GRT_MODEL1D *mod1d, MYREAL vmin, MYREAL k0, MYREAL dk0, MYREAL tol, MYREAL kmax, MYCOMPLEX omega, 
     MYINT nr, MYREAL *rs,
-    MYCOMPLEX sum_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     bool calc_upar,
-    MYCOMPLEX sum_uiz_J0[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX sum_uir_J0[nr][SRC_M_NUM][INTEG_NUM],
+    MYCOMPLEX sum_uiz_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX sum_uir_J0[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
     FILE *fstats, GRT_KernelFunc kerfunc, MYINT *stats)
 {   
     // 将k区间整体分为[dk0, kref]和[kref, kmax]，后一段使用更宽松的拟合规则
     MYREAL kref = creal(omega)/fabs(vmin);
 
     // 从0开始，存储第二部分Filon积分的结果
-    MYCOMPLEX (*sum_J)[SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_J));
-    MYCOMPLEX (*sum_uiz_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
-    MYCOMPLEX (*sum_uir_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
+    MYCOMPLEX (*sum_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_J));
+    MYCOMPLEX (*sum_uiz_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
+    MYCOMPLEX (*sum_uir_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
 
     MYREAL kmin = k0;
     
@@ -327,15 +327,15 @@ MYREAL grt_sa_filon_integ(
     };
     for(MYINT i=0; i<3; ++i) {
         kerfunc(mod1d, omega, Kitv.k3[i], Kitv.F3[i], calc_upar, Kitv.F3_uiz[i], stats);
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
     }
     stack_push(&stack, Kitv);
 
     // 以下采样过程中的遇到的QWV最大绝对值，注意其会动态变化
     // 其中VF,HF使用一套，EX,DD,DS,SS使用一套，分别对应格林函数Gij和格林函数空间导数Gij,k
     // 仅用于对积分幅度进行参考
-    MYREAL maxabsQWV[GTYPES_MAX]={0};
-    MYREAL maxabsQWV_uiz[GTYPES_MAX]={0};
+    MYREAL maxabsQWV[GRT_GTYPES_MAX]={0};
+    MYREAL maxabsQWV_uiz[GRT_GTYPES_MAX]={0};
 
     // 记录第一个值
     if(fstats!=NULL)  grt_write_stats(fstats, Kitv.k3[0], Kitv.F3[0]);
@@ -363,21 +363,21 @@ MYREAL grt_sa_filon_integ(
             .F3 = {{{0}}}, 
             .F3_uiz = {{{0}}} 
         };
-        memcpy(Kitv_left.F3[0], Kitv.F3[0], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
-        memcpy(Kitv_left.F3[2], Kitv.F3[1], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
-        memcpy(Kitv_right.F3[0], Kitv.F3[1], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
-        memcpy(Kitv_right.F3[2], Kitv.F3[2], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
+        memcpy(Kitv_left.F3[0], Kitv.F3[0], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
+        memcpy(Kitv_left.F3[2], Kitv.F3[1], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
+        memcpy(Kitv_right.F3[0], Kitv.F3[1], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
+        memcpy(Kitv_right.F3[2], Kitv.F3[2], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
         if(calc_upar){
-            memcpy(Kitv_left.F3_uiz[0], Kitv.F3_uiz[0], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
-            memcpy(Kitv_left.F3_uiz[2], Kitv.F3_uiz[1], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
-            memcpy(Kitv_right.F3_uiz[0], Kitv.F3_uiz[1], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
-            memcpy(Kitv_right.F3_uiz[2], Kitv.F3_uiz[2], sizeof(MYCOMPLEX)*SRC_M_NUM*QWV_NUM);
+            memcpy(Kitv_left.F3_uiz[0], Kitv.F3_uiz[0], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
+            memcpy(Kitv_left.F3_uiz[2], Kitv.F3_uiz[1], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
+            memcpy(Kitv_right.F3_uiz[0], Kitv.F3_uiz[1], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
+            memcpy(Kitv_right.F3_uiz[2], Kitv.F3_uiz[2], sizeof(MYCOMPLEX)*GRT_SRC_M_NUM*GRT_QWV_NUM);
         }
         kerfunc(mod1d, omega, Kitv_left.k3[1], Kitv_left.F3[1], calc_upar, Kitv_left.F3_uiz[1], stats);
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
 
         kerfunc(mod1d, omega, Kitv_right.k3[1], Kitv_right.F3[1], calc_upar, Kitv_right.F3_uiz[1], stats);
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
 
 
         // 增加新值，并比较QWV最大绝对值
@@ -418,11 +418,11 @@ MYREAL grt_sa_filon_integ(
         }
     } // END sampling
 
-    // 乘上总系数 sqrt(RTWO/(PI*r)) / dk0,  除dks0是在该函数外还会再乘dk0, 并将结果加到原数组中
+    // 乘上总系数 sqrt(2.0/(PI*r)) / dk0,  除dks0是在该函数外还会再乘dk0, 并将结果加到原数组中
     for(MYINT ir=0; ir<nr; ++ir){
-        MYREAL tmp = sqrt(RTWO/(PI*rs[ir])) / dk0;
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
-            for(MYINT v=0; v<INTEG_NUM; ++v){
+        MYREAL tmp = sqrt(2.0/(PI*rs[ir])) / dk0;
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+            for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
                 sum_J0[ir][i][v] += sum_J[ir][i][v] * tmp;
                 if(calc_upar){
                     sum_uiz_J0[ir][i][v] += sum_uiz_J[ir][i][v] * tmp;
diff --git a/pygrt/C_extension/src/common/util.c b/pygrt/C_extension/src/common/util.c
index 729c02db..31b92190 100644
--- a/pygrt/C_extension/src/common/util.c
+++ b/pygrt/C_extension/src/common/util.c
@@ -163,9 +163,9 @@ static void single_freq2time_write_to_file(
     const MYREAL delayT0, const MYREAL delayV0, const bool calc_upar,
     const bool doEX, const bool doVF, const bool doHF, const bool doDC, 
     SACHEAD *pt_hd, const char *chalst,
-    MYCOMPLEX *grn[SRC_M_NUM][CHANNEL_NUM], 
-    MYCOMPLEX *grn_uiz[SRC_M_NUM][CHANNEL_NUM], 
-    MYCOMPLEX *grn_uir[SRC_M_NUM][CHANNEL_NUM])
+    MYCOMPLEX *grn[GRT_SRC_M_NUM][GRT_CHANNEL_NUM], 
+    MYCOMPLEX *grn_uiz[GRT_SRC_M_NUM][GRT_CHANNEL_NUM], 
+    MYCOMPLEX *grn_uir[GRT_SRC_M_NUM][GRT_CHANNEL_NUM])
 {
     // 文件保存子目录
     char *s_output_subdir = NULL;
@@ -185,38 +185,38 @@ static void single_freq2time_write_to_file(
     pt_hd->t1 = grt_compute_travt1d(mod1d->Thk, mod1d->Vb, mod1d->n, mod1d->isrc, mod1d->ircv, dist);
     strcpy(pt_hd->kt1, "S");
 
-    for(int im=0; im<SRC_M_NUM; ++im){
+    for(int im=0; im<GRT_SRC_M_NUM; ++im){
         if(! doEX  && im==0)  continue;
         if(! doVF  && im==1)  continue;
         if(! doHF  && im==2)  continue;
         if(! doDC  && im>=3)  continue;
 
-        int modr = SRC_M_ORDERS[im];
+        int modr = GRT_SRC_M_ORDERS[im];
         int sgn=1;  // 用于反转Z分量
-        for(int c=0; c<CHANNEL_NUM; ++c){
-            if(modr==0 && ZRTchs[c]=='T')  continue;  // 跳过输出0阶的T分量
+        for(int c=0; c<GRT_CHANNEL_NUM; ++c){
+            if(modr==0 && GRT_ZRT_CODES[c]=='T')  continue;  // 跳过输出0阶的T分量
 
             // 判断是否为所需的分量
-            if(strchr(chalst, ZRTchs[c]) == NULL)  continue;
+            if(strchr(chalst, GRT_ZRT_CODES[c]) == NULL)  continue;
 
             // Z分量反转
-            sgn = (ZRTchs[c]=='Z') ? -1 : 1;
+            sgn = (GRT_ZRT_CODES[c]=='Z') ? -1 : 1;
 
             write_one_to_sac(
-                SRC_M_NAME_ABBR[im], ZRTchs[c], delayT, 
+                GRT_SRC_M_NAME_ABBR[im], GRT_ZRT_CODES[c], delayT, 
                 wI, pt_fh,
                 pt_hd, s_output_subdir, "", sgn, 
                 grn[im][c]);
 
             if(calc_upar){
                 write_one_to_sac(
-                    SRC_M_NAME_ABBR[im], ZRTchs[c], delayT, 
+                    GRT_SRC_M_NAME_ABBR[im], GRT_ZRT_CODES[c], delayT, 
                     wI, pt_fh,
                     pt_hd, s_output_subdir, "z", sgn*(-1), 
                     grn_uiz[im][c]);
 
                 write_one_to_sac(
-                    SRC_M_NAME_ABBR[im], ZRTchs[c], delayT, 
+                    GRT_SRC_M_NAME_ABBR[im], GRT_ZRT_CODES[c], delayT, 
                     wI, pt_fh,
                     pt_hd, s_output_subdir, "r", sgn, 
                     grn_uir[im][c]);
@@ -240,9 +240,9 @@ void grt_GF_freq2time_write_to_file(
     const MYREAL delayT0, const MYREAL delayV0, const bool calc_upar,
     const bool doEX, const bool doVF, const bool doHF, const bool doDC, 
     const char *chalst,
-    MYCOMPLEX *grn[nr][SRC_M_NUM][CHANNEL_NUM], 
-    MYCOMPLEX *grn_uiz[nr][SRC_M_NUM][CHANNEL_NUM], 
-    MYCOMPLEX *grn_uir[nr][SRC_M_NUM][CHANNEL_NUM])
+    MYCOMPLEX *grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM], 
+    MYCOMPLEX *grn_uiz[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM], 
+    MYCOMPLEX *grn_uir[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM])
 {
     // 建立SAC头文件，包含必要的头变量
     SACHEAD hd = new_sac_head(pt_fh->dt, pt_fh->nt, delayT0);
diff --git a/pygrt/C_extension/src/dynamic/grn.c b/pygrt/C_extension/src/dynamic/grn.c
index b9a8a0c2..303fe509 100755
--- a/pygrt/C_extension/src/dynamic/grn.c
+++ b/pygrt/C_extension/src/dynamic/grn.c
@@ -44,20 +44,20 @@
  * @param[out]   grn            三分量频谱
  */
 static void recordin_GRN(
-    MYINT iw, MYINT nr, MYCOMPLEX coef, MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYCOMPLEX *grn[nr][SRC_M_NUM][CHANNEL_NUM]
+    MYINT iw, MYINT nr, MYCOMPLEX coef, MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYCOMPLEX *grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM]
 )
 {
     // 局部变量，将某个频点的格林函数谱临时存放
-    MYCOMPLEX (*tmp_grn)[SRC_M_NUM][CHANNEL_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][CHANNEL_NUM])calloc(nr, sizeof(*tmp_grn));
+    MYCOMPLEX (*tmp_grn)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM])calloc(nr, sizeof(*tmp_grn));
 
     for(MYINT ir=0; ir<nr; ++ir){
         grt_merge_Pk(sum_J[ir], tmp_grn[ir]);
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i) {
-            MYINT modr = SRC_M_ORDERS[i];
-            for(MYINT c=0; c<CHANNEL_NUM; ++c){
-                if(modr == 0 && ZRTchs[c] == 'T')  continue;
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i) {
+            MYINT modr = GRT_SRC_M_ORDERS[i];
+            for(MYINT c=0; c<GRT_CHANNEL_NUM; ++c){
+                if(modr == 0 && GRT_ZRT_CODES[c] == 'T')  continue;
 
                 grn[ir][i][c][iw] = coef * tmp_grn[ir][i][c];
             }
@@ -77,11 +77,11 @@ void grt_integ_grn_spec(
     bool print_progressbar, 
 
     // 返回值，代表Z、R、T分量
-    MYCOMPLEX *grn[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYCOMPLEX *grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     bool calc_upar,
-    MYCOMPLEX *grn_uiz[nr][SRC_M_NUM][CHANNEL_NUM],
-    MYCOMPLEX *grn_uir[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYCOMPLEX *grn_uiz[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
+    MYCOMPLEX *grn_uir[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     const char *statsstr, // 积分结果输出
     MYINT  nstatsidxs, // 仅输出特定频点
@@ -96,26 +96,26 @@ void grt_integ_grn_spec(
     MYREAL rmax=rs[irmax];   
 
     const MYREAL Rho = mod1d->Rho[mod1d->isrc]; // 震源区密度
-    const MYREAL fac = RONE/(RFOUR*PI*Rho);
-    const MYREAL hs = GRT_MAX(fabs(mod1d->depsrc - mod1d->deprcv), MIN_DEPTH_GAP_SRC_RCV); // hs=max(震源和台站深度差,1.0)
+    const MYREAL fac = 1.0/(4.0*PI*Rho);
+    const MYREAL hs = GRT_MAX(fabs(mod1d->depsrc - mod1d->deprcv), GRT_MIN_DEPTH_GAP_SRC_RCV); // hs=max(震源和台站深度差,1.0)
 
     // 乘相应系数
     k0 *= PI/hs;
     const MYREAL k02 = k0*k0;
     const MYREAL ampk2 = ampk*ampk;
 
-    if(vmin_ref < RZERO)  keps = RZERO;  // 若使用峰谷平均法，则不使用keps进行收敛判断
+    if(vmin_ref < 0.0)  keps = 0.0;  // 若使用峰谷平均法，则不使用keps进行收敛判断
 
-    bool useFIM = (filonLength > RZERO) || (safilonTol > RZERO) ;    // 是否使用Filon积分（包括自适应Filon）
+    bool useFIM = (filonLength > 0.0) || (safilonTol > 0.0) ;    // 是否使用Filon积分（包括自适应Filon）
     const MYREAL dk=PI2/(Length*rmax);     // 波数积分间隔
-    const MYREAL filondk = (filonLength > RZERO) ? PI2/(filonLength*rmax) : RZERO;  // Filon积分间隔
+    const MYREAL filondk = (filonLength > 0.0) ? PI2/(filonLength*rmax) : 0.0;  // Filon积分间隔
     const MYREAL filonK = filonCut/rmax;  // 波数积分和Filon积分的分割点
 
 
     // PTAM的积分中间结果, 每个震中距两个文件，因为PTAM对不同震中距使用不同的dk
     // 在文件名后加后缀，区分不同震中距
     char **ptam_fstatsdir = (char**)calloc(nr, sizeof(char*));
-    if(statsstr!=NULL && nstatsidxs > 0 && vmin_ref < RZERO){
+    if(statsstr!=NULL && nstatsidxs > 0 && vmin_ref < 0.0){
         for(MYINT ir=0; ir<nr; ++ir){
             // 新建文件夹目录 
             GRT_SAFE_ASPRINTF(&ptam_fstatsdir[ir], "%s/PTAM_%04d_%.5e", statsstr, ir, rs[ir]);
@@ -139,18 +139,18 @@ void grt_integ_grn_spec(
     // schedule语句可以动态调度任务，最大程度地使用计算资源
     #pragma omp parallel for schedule(guided) default(shared) 
     for(MYINT iw=nf1; iw<=nf2; ++iw){
-        MYREAL k=RZERO;               // 波数
+        MYREAL k=0.0;               // 波数
         MYREAL w = freqs[iw]*PI2;     // 实频率
         MYCOMPLEX omega = w - wI*I; // 复数频率 omega = w - i*wI
-        MYCOMPLEX omega2_inv = RONE/omega; // 1/omega^2
+        MYCOMPLEX omega2_inv = 1.0/omega; // 1/omega^2
         omega2_inv = omega2_inv*omega2_inv; 
         MYCOMPLEX coef = -dk*fac*omega2_inv; // 最终要乘上的系数
 
         // 局部变量，用于求和 sum F(ki,w)Jm(ki*r)ki 
         // 关于形状详见int_Pk()函数内的注释
-        MYCOMPLEX (*sum_J)[SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_J));
-        MYCOMPLEX (*sum_uiz_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
-        MYCOMPLEX (*sum_uir_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
+        MYCOMPLEX (*sum_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_J));
+        MYCOMPLEX (*sum_uiz_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
+        MYCOMPLEX (*sum_uir_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
 
         GRT_MODEL1D *local_mod1d = NULL;
     #ifdef _OPENMP 
@@ -175,18 +175,18 @@ void grt_integ_grn_spec(
                 fstats = fopen(fname, "wb");
             }
             for(MYINT ir=0; ir<nr; ++ir){
-                for(MYINT i=0; i<SRC_M_NUM; ++i){
-                    for(MYINT v=0; v<INTEG_NUM; ++v){
-                        sum_J[ir][i][v] = CZERO;
+                for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                    for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
+                        sum_J[ir][i][v] = 0.0;
                         if(calc_upar){
-                            sum_uiz_J[ir][i][v] = CZERO;
-                            sum_uir_J[ir][i][v] = CZERO;
+                            sum_uiz_J[ir][i][v] = 0.0;
+                            sum_uir_J[ir][i][v] = 0.0;
                         }
                     }
                 }
     
                 ptam_fstatsnr[ir][0] = ptam_fstatsnr[ir][1] = NULL;
-                if(needfstats && vmin_ref < RZERO){
+                if(needfstats && vmin_ref < 0.0){
                     // 峰谷平均法
                     GRT_SAFE_ASPRINTF(&fname, "%s/K_%04d_%.5e", ptam_fstatsdir[ir], iw, freqs[iw]);
                     ptam_fstatsnr[ir][0] = fopen(fname, "wb");
@@ -205,7 +205,7 @@ void grt_integ_grn_spec(
         kmax = sqrt(k02 + ampk2*(w/vmin_ref)*(w/vmin_ref));
 
         // 计算核函数过程中是否有遇到除零错误
-        freq_invstats[iw]=INVERSE_SUCCESS;
+        freq_invstats[iw]=GRT_INVERSE_SUCCESS;
 
         // 常规的波数积分
         k = grt_discrete_integ(
@@ -214,15 +214,15 @@ void grt_integ_grn_spec(
             fstats, grt_kernel, &freq_invstats[iw]);
     
         // 使用Filon积分
-        if(useFIM && freq_invstats[iw]==INVERSE_SUCCESS){
-            if(filondk > RZERO){
+        if(useFIM && freq_invstats[iw]==GRT_INVERSE_SUCCESS){
+            if(filondk > 0.0){
                 // 基于线性插值的Filon积分，固定采样间隔
                 k = grt_linear_filon_integ(
                     local_mod1d, k, dk, filondk, kmax, keps, omega, nr, rs, 
                     sum_J, calc_upar, sum_uiz_J, sum_uir_J,
                     fstats, grt_kernel, &freq_invstats[iw]);
             }
-            else if(safilonTol > RZERO){
+            else if(safilonTol > 0.0){
                 // 基于自适应采样的Filon积分
                 k = grt_sa_filon_integ(
                     local_mod1d, fabs(vmin_ref)/ampk, k, dk, safilonTol, kmax, omega, nr, rs, 
@@ -232,7 +232,7 @@ void grt_integ_grn_spec(
         }
 
         // k之后的部分使用峰谷平均法进行显式收敛，建议在浅源地震的时候使用   
-        if(vmin_ref < RZERO && freq_invstats[iw]==INVERSE_SUCCESS){
+        if(vmin_ref < 0.0 && freq_invstats[iw]==GRT_INVERSE_SUCCESS){
             grt_PTA_method(
                 local_mod1d, k, dk, omega, nr, rs, 
                 sum_J, calc_upar, sum_uiz_J, sum_uir_J,
@@ -244,7 +244,7 @@ void grt_integ_grn_spec(
 
         // 记录到格林函数结构体内
         // 如果计算核函数过程中存在除零错误，则放弃该频率【通常在大震中距的低频段】
-        if(freq_invstats[iw]==INVERSE_SUCCESS){ 
+        if(freq_invstats[iw]==GRT_INVERSE_SUCCESS){ 
             recordin_GRN(iw, nr, coef, sum_J, grn);
             if(calc_upar){
                 recordin_GRN(iw, nr, coef, sum_uiz_J, grn_uiz);
@@ -287,7 +287,7 @@ void grt_integ_grn_spec(
 
     // 打印freq_invstats
     for(MYINT iw=nf1; iw<=nf2; ++iw){
-        if(freq_invstats[iw]==INVERSE_FAILURE){
+        if(freq_invstats[iw]==GRT_INVERSE_FAILURE){
             fprintf(stderr, "iw=%d, freq=%e(Hz), meet Zero Divison Error, results are filled with 0.\n", iw, freqs[iw]);
         }
     }
diff --git a/pygrt/C_extension/src/dynamic/grt_greenfn.c b/pygrt/C_extension/src/dynamic/grt_greenfn.c
index 9e2e49ff..7fcef708 100644
--- a/pygrt/C_extension/src/dynamic/grt_greenfn.c
+++ b/pygrt/C_extension/src/dynamic/grt_greenfn.c
@@ -356,7 +356,7 @@ printf("\n"
 "                   <vmin_ref> will be the minimum velocity\n"
 "                   of model, but limited to %.1f. and if the \n", GRT_GREENFN_V_VMIN_REF); printf(
 "                   depth gap between source and receiver is \n"
-"                   thinner than %.1f km, PTAM will be appled\n", MIN_DEPTH_GAP_SRC_RCV); printf(
+"                   thinner than %.1f km, PTAM will be appled\n", GRT_MIN_DEPTH_GAP_SRC_RCV); printf(
 "                   automatically.\n"
 "                 + manually set POSITIVE value. \n"
 "                 + manually set NEGATIVE value, \n"
@@ -380,7 +380,7 @@ printf("\n"
 "                 <k0>:   designed to give residual k at\n"
 "                         0 frequency, default is %.1f, and \n", GRT_GREENFN_K_K0); printf(
 "                         multiply PI/hs in program, \n"
-"                         where hs = max(fabs(depsrc-deprcv), %.1f).\n", MIN_DEPTH_GAP_SRC_RCV); printf(
+"                         where hs = max(fabs(depsrc-deprcv), %.1f).\n", GRT_MIN_DEPTH_GAP_SRC_RCV); printf(
 "                 <ampk>: amplification factor, default is %.2f.\n", GRT_GREENFN_K_AMPK); printf(
 "                 <keps>: a threshold for break wavenumber \n"
 "                         integration in advance. See \n"
@@ -725,7 +725,7 @@ int greenfn_main(int argc, char **argv) {
     } 
 
     // 如果没有主动设置vmin_ref，则判断是否要自动使用PTAM
-    if( !Ctrl->V.active && fabs(Ctrl->D.deprcv - Ctrl->D.depsrc) <= MIN_DEPTH_GAP_SRC_RCV) {
+    if( !Ctrl->V.active && fabs(Ctrl->D.deprcv - Ctrl->D.depsrc) <= GRT_MIN_DEPTH_GAP_SRC_RCV) {
         Ctrl->V.vmin_ref = - fabs(Ctrl->V.vmin_ref);
     }
 
@@ -782,13 +782,13 @@ int greenfn_main(int argc, char **argv) {
     }
 
     // 建立格林函数的complex数组
-    MYCOMPLEX *(*grn)[SRC_M_NUM][CHANNEL_NUM] = (MYCOMPLEX*(*)[SRC_M_NUM][CHANNEL_NUM]) calloc(Ctrl->R.nr, sizeof(*grn));
-    MYCOMPLEX *(*grn_uiz)[SRC_M_NUM][CHANNEL_NUM] = (Ctrl->e.active)? (MYCOMPLEX*(*)[SRC_M_NUM][CHANNEL_NUM]) calloc(Ctrl->R.nr, sizeof(*grn_uiz)) : NULL;
-    MYCOMPLEX *(*grn_uir)[SRC_M_NUM][CHANNEL_NUM] = (Ctrl->e.active)? (MYCOMPLEX*(*)[SRC_M_NUM][CHANNEL_NUM]) calloc(Ctrl->R.nr, sizeof(*grn_uir)) : NULL;
+    MYCOMPLEX *(*grn)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (MYCOMPLEX*(*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]) calloc(Ctrl->R.nr, sizeof(*grn));
+    MYCOMPLEX *(*grn_uiz)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (Ctrl->e.active)? (MYCOMPLEX*(*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]) calloc(Ctrl->R.nr, sizeof(*grn_uiz)) : NULL;
+    MYCOMPLEX *(*grn_uir)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (Ctrl->e.active)? (MYCOMPLEX*(*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]) calloc(Ctrl->R.nr, sizeof(*grn_uir)) : NULL;
 
     for(int ir=0; ir<Ctrl->R.nr; ++ir){
-        for(int i=0; i<SRC_M_NUM; ++i){
-            for(int c=0; c<CHANNEL_NUM; ++c){
+        for(int i=0; i<GRT_SRC_M_NUM; ++i){
+            for(int c=0; c<GRT_CHANNEL_NUM; ++c){
                 grn[ir][i][c] = (MYCOMPLEX*)calloc(Ctrl->N.nf, sizeof(MYCOMPLEX));
                 if(grn_uiz)  grn_uiz[ir][i][c] = (MYCOMPLEX*)calloc(Ctrl->N.nf, sizeof(MYCOMPLEX));
                 if(grn_uir)  grn_uir[ir][i][c] = (MYCOMPLEX*)calloc(Ctrl->N.nf, sizeof(MYCOMPLEX));
@@ -826,7 +826,7 @@ int greenfn_main(int argc, char **argv) {
         Ctrl->R.nr, Ctrl->R.s_rs, Ctrl->R.rs, travtPS,
         Ctrl->D.depsrc, Ctrl->D.deprcv, Ctrl->E.delayT0, Ctrl->E.delayV0, Ctrl->e.active,
         Ctrl->G.doEX, Ctrl->G.doVF, Ctrl->G.doHF, Ctrl->G.doDC, 
-        ZRTchs, grn, grn_uiz, grn_uir);
+        GRT_ZRT_CODES, grn, grn_uiz, grn_uir);
 
     
     // 打印走时
@@ -843,8 +843,8 @@ int greenfn_main(int argc, char **argv) {
 
     // 释放内存
     for(int ir=0; ir<Ctrl->R.nr; ++ir){
-        for(int i=0; i<SRC_M_NUM; ++i){
-            for(int c=0; c<CHANNEL_NUM; ++c){
+        for(int i=0; i<GRT_SRC_M_NUM; ++i){
+            for(int c=0; c<GRT_CHANNEL_NUM; ++c){
                 GRT_SAFE_FREE_PTR(grn[ir][i][c]);
                 if(grn_uiz) GRT_SAFE_FREE_PTR(grn_uiz[ir][i][c]);
                 if(grn_uir) GRT_SAFE_FREE_PTR(grn_uir[ir][i][c]);
diff --git a/pygrt/C_extension/src/dynamic/grt_rotation.c b/pygrt/C_extension/src/dynamic/grt_rotation.c
index 09579725..c7268678 100644
--- a/pygrt/C_extension/src/dynamic/grt_rotation.c
+++ b/pygrt/C_extension/src/dynamic/grt_rotation.c
@@ -100,7 +100,7 @@ int rotation_main(int argc, char **argv){
     rot2ZNE = (access(s_filepath, F_OK) == 0);
 
     // 指示特定的通道名
-    chs = (rot2ZNE)? ZNEchs : ZRTchs;
+    chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
 
     // 读取一个头段变量，获得基本参数，分配数组内存
diff --git a/pygrt/C_extension/src/dynamic/grt_strain.c b/pygrt/C_extension/src/dynamic/grt_strain.c
index 87a44c7f..a3e8cfd0 100644
--- a/pygrt/C_extension/src/dynamic/grt_strain.c
+++ b/pygrt/C_extension/src/dynamic/grt_strain.c
@@ -99,7 +99,7 @@ int strain_main(int argc, char **argv){
     rot2ZNE = (access(s_filepath, F_OK) == 0);
 
     // 指示特定的通道名
-    chs = (rot2ZNE)? ZNEchs : ZRTchs;
+    chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
 
     // 读取一个头段变量，获得基本参数，分配数组内存
diff --git a/pygrt/C_extension/src/dynamic/grt_stress.c b/pygrt/C_extension/src/dynamic/grt_stress.c
index 598d6794..52591e72 100644
--- a/pygrt/C_extension/src/dynamic/grt_stress.c
+++ b/pygrt/C_extension/src/dynamic/grt_stress.c
@@ -101,7 +101,7 @@ int stress_main(int argc, char **argv){
     rot2ZNE = (access(s_filepath, F_OK) == 0);
 
     // 指示特定的通道名
-    chs = (rot2ZNE)? ZNEchs : ZRTchs;
+    chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
 
     // 读取一个头段变量，获得基本参数，分配数组内存
diff --git a/pygrt/C_extension/src/dynamic/grt_syn.c b/pygrt/C_extension/src/dynamic/grt_syn.c
index c465887f..6799fd9a 100644
--- a/pygrt/C_extension/src/dynamic/grt_syn.c
+++ b/pygrt/C_extension/src/dynamic/grt_syn.c
@@ -100,10 +100,10 @@ typedef struct {
     } e;
 
     // 存储不同震源的震源机制相关参数的数组
-    MYREAL mchn[MECHANISM_NUM];
+    MYREAL mchn[GRT_MECHANISM_NUM];
 
     // 方向因子数组
-    MYREAL srcRadi[SRC_M_NUM][CHANNEL_NUM];
+    MYREAL srcRadi[GRT_SRC_M_NUM][GRT_CHANNEL_NUM];
 
     // 最终要计算的震源类型
     MYINT computeType;
@@ -640,7 +640,7 @@ int syn_main(int argc, char **argv){
     bool rot2ZNE = Ctrl->N.active;
 
     // 根据参数设置，选择分量名
-    const char *chs = (rot2ZNE)? ZNEchs : ZRTchs;
+    const char *chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
     float **ptarrout=NULL, *arrout=NULL;
     float *arrsyn[3] = {NULL, NULL, NULL};
@@ -686,8 +686,8 @@ int syn_main(int argc, char **argv){
         // 重新计算方向因子
         grt_set_source_radiation(Ctrl->srcRadi, Ctrl->computeType, (ityp==3), Ctrl->S.M0, upar_scale, Ctrl->A.azrad, Ctrl->mchn);
 
-        for(int c=0; c<CHANNEL_NUM; ++c){
-            ch = ZRTchs[c];
+        for(int c=0; c<GRT_CHANNEL_NUM; ++c){
+            ch = GRT_ZRT_CODES[c];
             
             // 定义SACHEAD指针
             if(ityp==0){
@@ -699,15 +699,15 @@ int syn_main(int argc, char **argv){
             }
             arrout = *ptarrout;
 
-            for(int k=0; k<SRC_M_NUM; ++k){
+            for(int k=0; k<GRT_SRC_M_NUM; ++k){
                 coef = Ctrl->srcRadi[k][c];
                 if(coef == 0.0) continue;
 
                 char *buffer = NULL;
                 if(ityp==0 || ityp==3){
-                    GRT_SAFE_ASPRINTF(&buffer, "%s/%s%c.sac", Ctrl->G.s_grnpath, SRC_M_NAME_ABBR[k], ch);
+                    GRT_SAFE_ASPRINTF(&buffer, "%s/%s%c.sac", Ctrl->G.s_grnpath, GRT_SRC_M_NAME_ABBR[k], ch);
                 } else {
-                    GRT_SAFE_ASPRINTF(&buffer, "%s/%c%s%c.sac", Ctrl->G.s_grnpath, tolower(ZRTchs[ityp-1]), SRC_M_NAME_ABBR[k], ch);
+                    GRT_SAFE_ASPRINTF(&buffer, "%s/%c%s%c.sac", Ctrl->G.s_grnpath, tolower(GRT_ZRT_CODES[ityp-1]), GRT_SRC_M_NAME_ABBR[k], ch);
                 }
                 
                 float *arr = grt_read_SAC(command, buffer, pthd, NULL);
@@ -795,11 +795,11 @@ int syn_main(int argc, char **argv){
     }
 
     // 保存到SAC文件
-    for(int i1=0; i1<CHANNEL_NUM; ++i1){
+    for(int i1=0; i1<GRT_CHANNEL_NUM; ++i1){
         char pfx[20]="";
         save_to_sac(Ctrl, pfx, chs[i1], arrsyn[i1], hdsyn[i1]);
         if(Ctrl->e.active){
-            for(int i2=0; i2<CHANNEL_NUM; ++i2){
+            for(int i2=0; i2<GRT_CHANNEL_NUM; ++i2){
                 sprintf(pfx, "%c", tolower(chs[i1]));
                 save_to_sac(Ctrl, pfx, chs[i2], arrsyn_upar[i1][i2], hdsyn_upar[i1][i2]);
             }
diff --git a/pygrt/C_extension/src/dynamic/layer.c b/pygrt/C_extension/src/dynamic/layer.c
index 97ca0a14..00081d90 100644
--- a/pygrt/C_extension/src/dynamic/layer.c
+++ b/pygrt/C_extension/src/dynamic/layer.c
@@ -25,29 +25,29 @@
 
 void grt_calc_R_tilt_PSV(MYCOMPLEX xa0, MYCOMPLEX xb0, MYCOMPLEX kbkb0, MYREAL k, MYCOMPLEX R_tilt[2][2], MYINT *stats)
 {
-    if(kbkb0 != CZERO){
+    if(kbkb0 != 0.0){
         // 固体表面
         // 公式(5.3.10-14)
-        MYCOMPLEX Delta = RZERO;
+        MYCOMPLEX Delta = 0.0;
         MYREAL kk = k*k; 
         MYCOMPLEX kbkb_k2inv = kbkb0/kk;
-        MYCOMPLEX kbkb_k4inv = RQUART*kbkb_k2inv*kbkb_k2inv;
+        MYCOMPLEX kbkb_k4inv = 0.25*kbkb_k2inv*kbkb_k2inv;
 
         // 对公式(5.3.10-14)进行重新整理，对浮点数友好一些
-        Delta = -RONE + xa0*xb0 + kbkb_k2inv - kbkb_k4inv;
-        if(Delta == CZERO){
-            *stats = INVERSE_FAILURE;
+        Delta = -1.0 + xa0*xb0 + kbkb_k2inv - kbkb_k4inv;
+        if(Delta == 0.0){
+            *stats = GRT_INVERSE_FAILURE;
             return;
         }
-        R_tilt[0][0] = (RONE + xa0*xb0 - kbkb_k2inv + kbkb_k4inv) / Delta;
-        R_tilt[0][1] = RTWO * xb0 * (RONE - RHALF*kbkb_k2inv) / Delta;
-        R_tilt[1][0] = RTWO * xa0 * (RONE - RHALF*kbkb_k2inv) / Delta;
+        R_tilt[0][0] = (1.0 + xa0*xb0 - kbkb_k2inv + kbkb_k4inv) / Delta;
+        R_tilt[0][1] = 2.0 * xb0 * (1.0 - 0.5*kbkb_k2inv) / Delta;
+        R_tilt[1][0] = 2.0 * xa0 * (1.0 - 0.5*kbkb_k2inv) / Delta;
         R_tilt[1][1] = R_tilt[0][0];
     }
     else {
         // 液体表面
-        R_tilt[0][0] = -RONE;
-        R_tilt[1][1] = R_tilt[0][1] = R_tilt[1][0] = CZERO;
+        R_tilt[0][0] = -1.0;
+        R_tilt[1][1] = R_tilt[0][1] = R_tilt[1][0] = 0.0;
     }
 }
 
@@ -57,7 +57,7 @@ void grt_calc_R_EV_PSV(
     const MYCOMPLEX R[2][2], MYCOMPLEX R_EV[2][2])
 {
     MYCOMPLEX D11[2][2], D12[2][2];
-    if(xb_rcv != CONE){
+    if(xb_rcv != 1.0){
         // 位于固体层
         // 公式(5.2.19)
         D11[0][0] = k;         D11[0][1] = k*xb_rcv;
@@ -66,10 +66,10 @@ void grt_calc_R_EV_PSV(
         D12[1][0] = -k*xa_rcv; D12[1][1] = k;
     } else {
         // 位于液体层
-        D11[0][0] = k;         D11[0][1] = RZERO;
-        D11[1][0] = k*xa_rcv;  D11[1][1] = RZERO;
-        D12[0][0] = k;         D12[0][1] = RZERO;
-        D12[1][0] = -k*xa_rcv; D12[1][1] = RZERO;
+        D11[0][0] = k;         D11[0][1] = 0.0;
+        D11[1][0] = k*xa_rcv;  D11[1][1] = 0.0;
+        D12[0][0] = k;         D12[0][1] = 0.0;
+        D12[1][0] = -k*xa_rcv; D12[1][1] = 0.0;
     }
 
     // 公式(5.7.7,25)
@@ -85,13 +85,13 @@ void grt_calc_R_EV_PSV(
 
 void grt_calc_R_EV_SH(MYCOMPLEX xb_rcv, MYREAL k, MYCOMPLEX RL, MYCOMPLEX *R_EVL)
 {
-    if(xb_rcv != CONE){
+    if(xb_rcv != 1.0){
         // 位于固体层
         // 公式(5.2.19)
-        *R_EVL = (RONE + (RL))*k;
+        *R_EVL = (1.0 + (RL))*k;
     } else {
         // 位于液体层
-        *R_EVL = RZERO;
+        *R_EVL = 0.0;
     }
 }
 
@@ -101,7 +101,7 @@ void grt_calc_uiz_R_EV_PSV(
     MYREAL k, 
     const MYCOMPLEX R[2][2], MYCOMPLEX R_EV[2][2])
 {
-    // 将势函数转为ui,z在(B_m, P_m, C_m)系下的分量
+    // 将垂直波函数转为ui,z在(B_m, P_m, C_m)系下的分量
     // 新推导的公式
     MYCOMPLEX ak = k*k*xa_rcv;
     MYCOMPLEX bk = k*k*xb_rcv;
@@ -111,8 +111,8 @@ void grt_calc_uiz_R_EV_PSV(
     MYCOMPLEX D12[2][2] = {{-ak, bb}, {aa, -bk}};
 
     // 位于液体层
-    if(xb_rcv == CONE){
-        D11[0][1] = D11[1][1] = D12[0][1] = D12[1][1] = RZERO;
+    if(xb_rcv == 1.0){
+        D11[0][1] = D11[1][1] = D12[0][1] = D12[1][1] = 0.0;
     }
 
     // 公式(5.7.7,25)
@@ -128,20 +128,20 @@ void grt_calc_uiz_R_EV_PSV(
 
 void grt_calc_uiz_R_EV_SH(MYCOMPLEX xb_rcv, bool ircvup, MYREAL k, MYCOMPLEX RL, MYCOMPLEX *R_EVL)
 {
-    // 将势函数转为ui,z在(B_m, P_m, C_m)系下的分量
+    // 将垂直波函数转为ui,z在(B_m, P_m, C_m)系下的分量
     // 新推导的公式
     MYCOMPLEX bk = k*k*xb_rcv;
 
-    if(xb_rcv != CONE){
+    if(xb_rcv != 1.0){
         // 位于固体层
         if(ircvup){// 震源更深
-            *R_EVL = (RONE - (RL))*bk;
+            *R_EVL = (1.0 - (RL))*bk;
         } else { // 接收点更深
-            *R_EVL = (RL - RONE)*bk;
+            *R_EVL = (RL - 1.0)*bk;
         }
     } else {
         // 位于液体层
-        *R_EVL = RZERO;
+        *R_EVL = 0.0;
     }
 }    
 
@@ -160,31 +160,31 @@ void grt_calc_RT_ll_PSV(
     ex2a = exa * exa;
 
     MYCOMPLEX A = xa1*Rho2 + xa2*Rho1;
-    if(A==CZERO){
-        *stats = INVERSE_FAILURE;
+    if(A==0.0){
+        *stats = GRT_INVERSE_FAILURE;
         return;
     }
 
     RD[0][0] = (xa1*Rho2 - xa2*Rho1)/A * ex2a;  
-    RD[0][1] = RD[1][0] = RD[1][1] = CZERO;
+    RD[0][1] = RD[1][0] = RD[1][1] = 0.0;
     
     RU[0][0] = (xa2*Rho1 - xa1*Rho2)/A;
-    RU[0][1] = RU[1][0] = RU[1][1] = CZERO;
+    RU[0][1] = RU[1][0] = RU[1][1] = 0.0;
 
-    TD[0][0] = RTWO*xa1*Rho1/A * exa;
-    TD[0][1] = TD[1][0] = TD[1][1] = CZERO;
+    TD[0][0] = 2.0*xa1*Rho1/A * exa;
+    TD[0][1] = TD[1][0] = TD[1][1] = 0.0;
 
-    TU[0][0] = RTWO*xa2*Rho2/A * exa;
-    TU[0][1] = TU[1][0] = TU[1][1] = CZERO;
+    TU[0][0] = 2.0*xa2*Rho2/A * exa;
+    TU[0][1] = TU[1][0] = TU[1][1] = 0.0;
 
 }
 
 void grt_calc_RT_ll_SH(MYCOMPLEX *RDL, MYCOMPLEX *RUL, MYCOMPLEX *TDL, MYCOMPLEX *TUL)
 {
-    *RDL = RZERO;
-    *RUL = RZERO;
-    *TDL = RZERO;
-    *TUL = RZERO;
+    *RDL = 0.0;
+    *RUL = 0.0;
+    *TDL = 0.0;
+    *TUL = 0.0;
 }
 
 
@@ -211,9 +211,9 @@ void grt_calc_RT_ls_PSV(
     ex2b = exb * exb;
 
     // 讨论液-固 or 固-液
-    bool isfluidUp = (mu1 == CZERO);  // 上层是否为液体
+    bool isfluidUp = (mu1 == 0.0);  // 上层是否为液体
     MYINT sgn = 1;
-    if(isfluidUp && mu2 == CZERO){
+    if(isfluidUp && mu2 == 0.0){
         fprintf(stderr, BOLD_RED "Error: fluid-fluid interface is not allowed in calc_RT_ls_2x2\n" DEFAULT_RESTORE);
         exit(EXIT_FAILURE);
     }
@@ -240,32 +240,32 @@ void grt_calc_RT_ls_PSV(
     MYREAL k2 = k*k;
     MYCOMPLEX lamka1k = Rho1*omega*omega/k2;
     MYCOMPLEX kb2k = kbkb2/k2;
-    MYCOMPLEX Og2k = RONE - RHALF*kb2k;
+    MYCOMPLEX Og2k = 1.0 - 0.5*kb2k;
     MYCOMPLEX Og2k2 = Og2k*Og2k;
-    MYCOMPLEX A = RTWO*Og2k2*xa1*mu2 + RHALF*lamka1k*kb2k*xa2 - RTWO*mu2*xa1*xa2*xb2;
-    MYCOMPLEX B = RTWO*Og2k2*xa1*mu2 - RHALF*lamka1k*kb2k*xa2 + RTWO*mu2*xa1*xa2*xb2;
-    MYCOMPLEX C = RTWO*Og2k2*xa1*mu2 + RHALF*lamka1k*kb2k*xa2 + RTWO*mu2*xa1*xa2*xb2;
-    MYCOMPLEX D = RTWO*Og2k2*xa1*mu2 - RHALF*lamka1k*kb2k*xa2 - RTWO*mu2*xa1*xa2*xb2;
+    MYCOMPLEX A = 2.0*Og2k2*xa1*mu2 + 0.5*lamka1k*kb2k*xa2 - 2.0*mu2*xa1*xa2*xb2;
+    MYCOMPLEX B = 2.0*Og2k2*xa1*mu2 - 0.5*lamka1k*kb2k*xa2 + 2.0*mu2*xa1*xa2*xb2;
+    MYCOMPLEX C = 2.0*Og2k2*xa1*mu2 + 0.5*lamka1k*kb2k*xa2 + 2.0*mu2*xa1*xa2*xb2;
+    MYCOMPLEX D = 2.0*Og2k2*xa1*mu2 - 0.5*lamka1k*kb2k*xa2 - 2.0*mu2*xa1*xa2*xb2;
 
-    if(A == CZERO){
-        *stats = INVERSE_FAILURE;
+    if(A == 0.0){
+        *stats = GRT_INVERSE_FAILURE;
         return;
     }
     
     // 按液体层在上层处理
     pRD[0][0] = D/A; 
-    pRD[0][1] = pRD[1][0] = pRD[1][1] = CZERO;
+    pRD[0][1] = pRD[1][0] = pRD[1][1] = 0.0;
 
     pRU[0][0] = - B/A;
-    pRU[0][1] = - RFOUR*Og2k*xa1*xb2*mu2/A * sgn;
+    pRU[0][1] = - 4.0*Og2k*xa1*xb2*mu2/A * sgn;
     pRU[1][0] = pRU[0][1]/xb2 * xa2;
     pRU[1][1] = - C/A;
 
-    pTD[0][0] = - RTWO*Og2k*xa1*lamka1k/A;      pTD[0][1] = CZERO;
-    pTD[1][0] = pTD[0][0]/Og2k*xa2 * sgn;       pTD[1][1] = CZERO;
+    pTD[0][0] = - 2.0*Og2k*xa1*lamka1k/A;      pTD[0][1] = 0.0;
+    pTD[1][0] = pTD[0][0]/Og2k*xa2 * sgn;       pTD[1][1] = 0.0;
 
-    pTU[0][0] = - RTWO*Og2k*xa2*mu2*kb2k/A;     pTU[0][1] = pTU[0][0]/Og2k*xb2 * sgn;
-    pTU[1][0] = pTU[1][1] = CZERO;
+    pTU[0][0] = - 2.0*Og2k*xa2*mu2*kb2k/A;     pTU[0][1] = pTU[0][0]/Og2k*xb2 * sgn;
+    pTU[1][0] = pTU[1][1] = 0.0;
 
     // 回归数组，增加时移
     RD[0][0] *= ex2a;   RD[0][1] *= exab;
@@ -297,8 +297,8 @@ void grt_calc_RT_ls_SH(
     ex2b = exb * exb;
 
     // 讨论液-固 or 固-液
-    bool isfluidUp = (mu1 == CZERO);  // 上层是否为液体
-    if(isfluidUp && mu2 == CZERO){
+    bool isfluidUp = (mu1 == 0.0);  // 上层是否为液体
+    if(isfluidUp && mu2 == 0.0){
         fprintf(stderr, BOLD_RED "Error: fluid-fluid interface is not allowed in calc_RT_ls_2x2\n" DEFAULT_RESTORE);
         exit(EXIT_FAILURE);
     }
@@ -314,10 +314,10 @@ void grt_calc_RT_ls_SH(
         pTDL = TUL; pTUL = TDL;
     }
 
-    *pRDL = RZERO;
-    *pRUL = RONE;
-    *pTDL = RZERO;
-    *pTUL = RZERO;
+    *pRDL = 0.0;
+    *pRUL = 1.0;
+    *pTDL = 0.0;
+    *pTUL = 0.0;
 
     // 回归数组，增加时移
     // 特殊数值，仅需为潜在的RDL添加
@@ -348,7 +348,7 @@ void grt_calc_RT_ss_PSV(
 
     // 定义一些中间变量来简化运算和书写
     MYREAL kk = k*k;
-    MYCOMPLEX dmu = mu1/mu2 - RONE; // mu1 - mu2; 分子分母同除mu2
+    MYCOMPLEX dmu = mu1/mu2 - 1.0; // mu1 - mu2; 分子分母同除mu2
     MYCOMPLEX dmu2 = dmu*dmu;
 
     MYCOMPLEX mu1kb1_k2 = mu1/mu2*kbkb1/kk;// mu1*kb1_k2;
@@ -364,49 +364,49 @@ void grt_calc_RT_ss_PSV(
     // 
     // 以下对公式重新整理，提出k的高阶项，以避免上述问题
     MYCOMPLEX Delta;
-    Delta =   dmu2*(RONE-xa1*xb1)*(RONE-xa2*xb2) + mu1kb1_k2*dmu*(rho21*(RONE-xa1*xb1) - (RONE-xa2*xb2)) 
-            + RQUART*mu1kb1_k2*mu2kb2_k2*(rho12*(RONE-xa2*xb2) + rho21*(RONE-xa1*xb1) - RTWO - (xa1*xb2+xa2*xb1));
+    Delta =   dmu2*(1.0-xa1*xb1)*(1.0-xa2*xb2) + mu1kb1_k2*dmu*(rho21*(1.0-xa1*xb1) - (1.0-xa2*xb2)) 
+            + 0.25*mu1kb1_k2*mu2kb2_k2*(rho12*(1.0-xa2*xb2) + rho21*(1.0-xa1*xb1) - 2.0 - (xa1*xb2+xa2*xb1));
 
-    if( Delta == CZERO ){
+    if( Delta == 0.0 ){
         // printf("# zero Delta_inv=%e+%eJ\n", creal(Delta_inv), cimag(Delta_inv));
-        *stats = INVERSE_FAILURE;
+        *stats = GRT_INVERSE_FAILURE;
         return;
     } 
 
     // REFELCTION
     //------------------ RD -----------------------------------
     // rpp+
-    RD[0][0] = ( - dmu2*(RONE+xa1*xb1)*(RONE-xa2*xb2) - mu1kb1_k2*dmu*(rho21*(RONE+xa1*xb1) - (RONE-xa2*xb2))
-                    - RQUART*mu1kb1_k2*mu2kb2_k2*(rho12*(RONE-xa2*xb2) + rho21*(RONE+xa1*xb1) - RTWO + (xa1*xb2-xa2*xb1))) / Delta * ex2a;
+    RD[0][0] = ( - dmu2*(1.0+xa1*xb1)*(1.0-xa2*xb2) - mu1kb1_k2*dmu*(rho21*(1.0+xa1*xb1) - (1.0-xa2*xb2))
+                    - 0.25*mu1kb1_k2*mu2kb2_k2*(rho12*(1.0-xa2*xb2) + rho21*(1.0+xa1*xb1) - 2.0 + (xa1*xb2-xa2*xb1))) / Delta * ex2a;
     // rsp+
-    RD[0][1] = ( - dmu2*(RONE-xa2*xb2) + RHALF*mu1kb1_k2*dmu*((RONE-xa2*xb2) - RTWO*rho21) 
-                    + RQUART*mu1kb1_k2*mu2kb2_k2*(RONE-rho21)) / Delta * (-RTWO*xb1) * exab;
+    RD[0][1] = ( - dmu2*(1.0-xa2*xb2) + 0.5*mu1kb1_k2*dmu*((1.0-xa2*xb2) - 2.0*rho21) 
+                    + 0.25*mu1kb1_k2*mu2kb2_k2*(1.0-rho21)) / Delta * (-2.0*xb1) * exab;
     // rps+
     RD[1][0] = RD[0][1]*(xa1/xb1);
     // rss+
-    RD[1][1] = ( - dmu2*(RONE+xa1*xb1)*(RONE-xa2*xb2) - mu1kb1_k2*dmu*(rho21*(RONE+xa1*xb1) - (RONE-xa2*xb2))
-                    - RQUART*mu1kb1_k2*mu2kb2_k2*(rho12*(RONE-xa2*xb2) + rho21*(RONE+xa1*xb1) - RTWO - (xa1*xb2-xa2*xb1))) / Delta * ex2b;
+    RD[1][1] = ( - dmu2*(1.0+xa1*xb1)*(1.0-xa2*xb2) - mu1kb1_k2*dmu*(rho21*(1.0+xa1*xb1) - (1.0-xa2*xb2))
+                    - 0.25*mu1kb1_k2*mu2kb2_k2*(rho12*(1.0-xa2*xb2) + rho21*(1.0+xa1*xb1) - 2.0 - (xa1*xb2-xa2*xb1))) / Delta * ex2b;
     //------------------ RU -----------------------------------
     // rpp-
-    RU[0][0] = ( - dmu2*(RONE-xa1*xb1)*(RONE+xa2*xb2) - mu1kb1_k2*dmu*(rho21*(RONE-xa1*xb1) - (RONE+xa2*xb2))
-                    - RQUART*mu1kb1_k2*mu2kb2_k2*(rho12*(RONE+xa2*xb2) + rho21*(RONE-xa1*xb1) - RTWO - (xa1*xb2-xa2*xb1))) / Delta;
+    RU[0][0] = ( - dmu2*(1.0-xa1*xb1)*(1.0+xa2*xb2) - mu1kb1_k2*dmu*(rho21*(1.0-xa1*xb1) - (1.0+xa2*xb2))
+                    - 0.25*mu1kb1_k2*mu2kb2_k2*(rho12*(1.0+xa2*xb2) + rho21*(1.0-xa1*xb1) - 2.0 - (xa1*xb2-xa2*xb1))) / Delta;
     // rsp-
-    RU[0][1] = ( - dmu2*(RONE-xa1*xb1) - RHALF*mu1kb1_k2*dmu*(rho21*(RONE-xa1*xb1) - RTWO)
-                    + RQUART*mu1kb1_k2*mu2kb2_k2*(RONE-rho12)) / Delta * (RTWO*xb2);
+    RU[0][1] = ( - dmu2*(1.0-xa1*xb1) - 0.5*mu1kb1_k2*dmu*(rho21*(1.0-xa1*xb1) - 2.0)
+                    + 0.25*mu1kb1_k2*mu2kb2_k2*(1.0-rho12)) / Delta * (2.0*xb2);
     // rps-
     RU[1][0] = RU[0][1]*(xa2/xb2);
     // rss-
-    RU[1][1] = ( - dmu2*(RONE-xa1*xb1)*(RONE+xa2*xb2) - mu1kb1_k2*dmu*(rho21*(RONE-xa1*xb1) - (RONE+xa2*xb2))
-                    - RQUART*mu1kb1_k2*mu2kb2_k2*(rho12*(RONE+xa2*xb2) + rho21*(RONE-xa1*xb1) - RTWO + (xa1*xb2-xa2*xb1))) / Delta;
+    RU[1][1] = ( - dmu2*(1.0-xa1*xb1)*(1.0+xa2*xb2) - mu1kb1_k2*dmu*(rho21*(1.0-xa1*xb1) - (1.0+xa2*xb2))
+                    - 0.25*mu1kb1_k2*mu2kb2_k2*(rho12*(1.0+xa2*xb2) + rho21*(1.0-xa1*xb1) - 2.0 + (xa1*xb2-xa2*xb1))) / Delta;
 
     // REFRACTION
-    tmp = mu1kb1_k2*xa1*(dmu*(xb2-xb1) - RHALF*mu1kb1_k2*(rho21*xb1+xb2)) / Delta * exa;
+    tmp = mu1kb1_k2*xa1*(dmu*(xb2-xb1) - 0.5*mu1kb1_k2*(rho21*xb1+xb2)) / Delta * exa;
     TD[0][0] = tmp;     TU[0][0] = (rho21*xa2/xa1) * tmp;
-    tmp = mu1kb1_k2*xb1*(dmu*(RONE-xa1*xb2) - RHALF*mu1kb1_k2*(RONE-rho21)) / Delta * exb;
+    tmp = mu1kb1_k2*xb1*(dmu*(1.0-xa1*xb2) - 0.5*mu1kb1_k2*(1.0-rho21)) / Delta * exb;
     TD[0][1] = tmp;     TU[1][0] = (rho21*xa2/xb1) * tmp;
-    tmp = mu1kb1_k2*xa1*(dmu*(RONE-xa2*xb1) - RHALF*mu1kb1_k2*(RONE-rho21)) / Delta * exa;
+    tmp = mu1kb1_k2*xa1*(dmu*(1.0-xa2*xb1) - 0.5*mu1kb1_k2*(1.0-rho21)) / Delta * exa;
     TD[1][0] = tmp;     TU[0][1] = (rho21*xb2/xa1) * tmp;
-    tmp = mu1kb1_k2*xb1*(dmu*(xa2-xa1) - RHALF*mu1kb1_k2*(rho21*xa1+xa2)) / Delta * exb;
+    tmp = mu1kb1_k2*xb1*(dmu*(xa2-xa1) - 0.5*mu1kb1_k2*(rho21*xa1+xa2)) / Delta * exb;
     TD[1][1] = tmp;     TU[1][1] = (rho21*xb2/xb1) * tmp;
 }
 
@@ -430,7 +430,7 @@ void grt_calc_RT_ss_SH(
     *RDL = - (*RUL) * ex2b;
 
     // REFRACTION
-    tmp = RTWO / (mu2*xb2 + mu1*xb1)  * exb;
+    tmp = 2.0 / (mu2*xb2 + mu1*xb1)  * exb;
     *TDL = mu1*xb1 * tmp;
     *TUL = mu2*xb2 * tmp;
 }
@@ -446,14 +446,14 @@ void grt_calc_RT_PSV(
     MYCOMPLEX TD[2][2], MYCOMPLEX TU[2][2], MYINT *stats)
 {
     // 根据界面两侧的具体情况选择函数
-    if(mu1 != CZERO && mu2 != CZERO){
+    if(mu1 != 0.0 && mu2 != 0.0){
         grt_calc_RT_ss_PSV(
             Rho1, xa1, xb1, kbkb1, mu1, 
             Rho2, xa2, xb2, kbkb2, mu2, 
             thk, omega, k, 
             RD, RU, TD, TU, stats);
     }
-    else if(mu1 == CZERO && mu2 == CZERO){
+    else if(mu1 == 0.0 && mu2 == 0.0){
         grt_calc_RT_ll_PSV(
             Rho1, xa1,
             Rho2, xa2,
@@ -479,14 +479,14 @@ void grt_calc_RT_SH(
     MYCOMPLEX *TDL, MYCOMPLEX *TUL)
 {
     // 根据界面两侧的具体情况选择函数
-    if(mu1 != CZERO && mu2 != CZERO){
+    if(mu1 != 0.0 && mu2 != 0.0){
         grt_calc_RT_ss_SH(
             xb1, mu1, 
             xb2, mu2, 
             thk, omega, k, 
             RDL, RUL, TDL, TUL);
     }
-    else if(mu1 == CZERO && mu2 == CZERO){
+    else if(mu1 == 0.0 && mu2 == 0.0){
         grt_calc_RT_ll_SH(
             RDL, RUL, TDL, TUL);
     }
@@ -507,7 +507,7 @@ void grt_get_layer_D(
 {
     // 第iy层物理量
     MYCOMPLEX Omg;
-    Omg = k*k - RHALF*kbkb;
+    Omg = k*k - 0.5*kbkb;
 
     if( ! inverse ){
         D[0][0] = k;            D[0][1] = k*xb;             D[0][2] = k;            D[0][3] = -k*xb;     
@@ -571,7 +571,7 @@ void grt_get_layer_D21(
 {
     // 第iy层物理量
     MYCOMPLEX Omg;
-    Omg = k*k - RHALF*kbkb;
+    Omg = k*k - 0.5*kbkb;
 
     D[0][0] = 2*mu*Omg;        D[0][1] = 2*k*mu*k*xb;
     D[1][0] = 2*k*mu*k*xa;     D[1][1] = 2*mu*Omg;   
@@ -583,7 +583,7 @@ void grt_get_layer_D22(
 {
     // 第iy层物理量
     MYCOMPLEX Omg;
-    Omg = k*k - RHALF*kbkb;
+    Omg = k*k - 0.5*kbkb;
 
     D[0][0] = 2*mu*Omg;        D[0][1] = -2*k*mu*k*xb;
     D[1][0] = -2*k*mu*k*xa;    D[1][1] = 2*mu*Omg;   
@@ -694,8 +694,8 @@ void grt_calc_RT_from_4x4(
 
     *RDL = (mu1*xb1 - mu2*xb2) / (mu1*xb1 + mu2*xb2) * exa*exa;
     *RUL = - (*RDL);
-    *TDL = RTWO*mu1*xb1/(mu1*xb1 + mu2*xb2) * exb;
-    *TUL = RTWO*mu2*xb2/(mu1*xb1 + mu2*xb2) * exb;
+    *TDL = 2.0*mu1*xb1/(mu1*xb1 + mu2*xb2) * exb;
+    *TUL = 2.0*mu2*xb2/(mu1*xb1 + mu2*xb2) * exb;
 
     
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/src/dynamic/propagate.c b/pygrt/C_extension/src/dynamic/propagate.c
index e0c0ac40..bfe554d5 100755
--- a/pygrt/C_extension/src/dynamic/propagate.c
+++ b/pygrt/C_extension/src/dynamic/propagate.c
@@ -25,15 +25,15 @@
 
 
 void grt_kernel(
-    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
+    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
     bool calc_uiz,
-    MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM], MYINT *stats)
+    MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM], MYINT *stats)
 {
     // 初始化qwv为0
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        for(MYINT j=0; j<QWV_NUM; ++j){
-            QWV[i][j] = CZERO;
-            if(calc_uiz)  QWV_uiz[i][j] = CZERO;
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        for(MYINT j=0; j<GRT_QWV_NUM; ++j){
+            QWV[i][j] = 0.0;
+            if(calc_uiz)  QWV_uiz[i][j] = 0.0;
         }
     }
 
@@ -51,51 +51,51 @@ void grt_kernel(
 
     // 初始化广义反射透射系数矩阵
     // BL
-    MYCOMPLEX RD_BL[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_BL = CZERO;
-    MYCOMPLEX RU_BL[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_BL = CZERO;
-    MYCOMPLEX TD_BL[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL_BL = CONE;
-    MYCOMPLEX TU_BL[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL_BL = CONE;
+    MYCOMPLEX RD_BL[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_BL = 0.0;
+    MYCOMPLEX RU_BL[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_BL = 0.0;
+    MYCOMPLEX TD_BL[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL_BL = 1.0;
+    MYCOMPLEX TU_BL[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL_BL = 1.0;
     // AL
-    MYCOMPLEX RD_AL[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_AL = CZERO;
+    MYCOMPLEX RD_AL[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_AL = 0.0;
     // RS
-    MYCOMPLEX RD_RS[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_RS = CZERO;
-    MYCOMPLEX RU_RS[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_RS = CZERO;
-    MYCOMPLEX TD_RS[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL_RS = CONE;
-    MYCOMPLEX TU_RS[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL_RS = CONE;
+    MYCOMPLEX RD_RS[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_RS = 0.0;
+    MYCOMPLEX RU_RS[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_RS = 0.0;
+    MYCOMPLEX TD_RS[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL_RS = 1.0;
+    MYCOMPLEX TU_RS[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL_RS = 1.0;
     // FA (实际先计算ZA，再递推到FA)
-    MYCOMPLEX RD_FA[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_FA = CZERO;
-    MYCOMPLEX RU_FA[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_FA = CZERO;
-    MYCOMPLEX TD_FA[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL_FA = CONE;
-    MYCOMPLEX TU_FA[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL_FA = CONE;
+    MYCOMPLEX RD_FA[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_FA = 0.0;
+    MYCOMPLEX RU_FA[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_FA = 0.0;
+    MYCOMPLEX TD_FA[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL_FA = 1.0;
+    MYCOMPLEX TU_FA[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL_FA = 1.0;
     // FB (实际先计算ZB，再递推到FB)
-    MYCOMPLEX RU_FB[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_FB = CZERO;
+    MYCOMPLEX RU_FB[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_FB = 0.0;
     
     // 定义物理层内的反射透射系数矩阵，相对于界面上的系数矩阵增加了时间延迟因子
-    MYCOMPLEX RD[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL = CZERO;
-    MYCOMPLEX RU[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL = CZERO;
-    MYCOMPLEX TD[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL = CONE;
-    MYCOMPLEX TU[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL = CONE;
+    MYCOMPLEX RD[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL = 0.0;
+    MYCOMPLEX RU[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL = 0.0;
+    MYCOMPLEX TD[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL = 1.0;
+    MYCOMPLEX TU[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL = 1.0;
 
     // 自由表面的反射系数
-    MYCOMPLEX R_tilt[2][2] = INIT_C_ZERO_2x2_MATRIX; // SH波在自由表面的反射系数为1，不必定义变量
+    MYCOMPLEX R_tilt[2][2] = GRT_INIT_ZERO_2x2_MATRIX; // SH波在自由表面的反射系数为1，不必定义变量
 
     // 接收点处的接收矩阵(转为位移u的(B_m, C_m, P_m)系分量)
     MYCOMPLEX R_EV[2][2], R_EVL;
@@ -109,9 +109,9 @@ void grt_kernel(
     MYCOMPLEX mod1d_mu0, mod1d_mu1;
     MYCOMPLEX mod1d_kaka1, mod1d_kbkb0, mod1d_kbkb1;
     MYCOMPLEX mod1d_xa0, mod1d_xb0, mod1d_xa1, mod1d_xb1;
-    MYCOMPLEX top_xa=RZERO, top_xb=RZERO, top_kbkb=RZERO;
-    MYCOMPLEX rcv_xa=RZERO, rcv_xb=RZERO;
-    MYCOMPLEX src_xa=RZERO, src_xb=RZERO, src_kaka=RZERO, src_kbkb=RZERO;
+    MYCOMPLEX top_xa=0.0, top_xb=0.0, top_kbkb=0.0;
+    MYCOMPLEX rcv_xa=0.0, rcv_xb=0.0;
+    MYCOMPLEX src_xa=0.0, src_xb=0.0, src_kaka=0.0, src_kbkb=0.0;
 
 
     // 从顶到底进行矩阵递推, 公式(5.5.3)
@@ -131,8 +131,8 @@ void grt_kernel(
         mod1d_mu1 = mod1d->mu[iy];
         mod1d_kaka1 = mod1d->kaka[iy];
         mod1d_kbkb1 = mod1d->kbkb[iy];
-        mod1d_xa1 = sqrt(RONE - mod1d_kaka1/(k*k));
-        mod1d_xb1 = sqrt(RONE - mod1d_kbkb1/(k*k));
+        mod1d_xa1 = sqrt(1.0 - mod1d_kaka1/(k*k));
+        mod1d_xb1 = sqrt(1.0 - mod1d_kbkb1/(k*k));
         // mod1d_xa1 = sqrt(k*k - mod1d_kaka1)/k;
         // mod1d_xb1 = sqrt(k*k - mod1d_kbkb1)/k;
 
@@ -173,7 +173,7 @@ void grt_kernel(
             //     omega, k, 
             //     RD, pRDL, RU, pRUL, 
             //     TD, pTDL, TU, pTUL, stats);
-            if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+            if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
         }
 
 #if Print_GRTCOEF == 1
@@ -214,7 +214,7 @@ void grt_kernel(
                     TD, TDL, TU, TUL,
                     RD_FA, &RDL_FA, RU_FA, &RUL_FA, 
                     TD_FA, &TDL_FA, TU_FA, &TUL_FA, stats);  
-                if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+                if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
             }
         } 
         else if(iy==imin){ // 虚拟层位，可对递推公式简化
@@ -236,7 +236,7 @@ void grt_kernel(
                     TD, TDL, TU, TUL,
                     RD_RS, &RDL_RS, RU_RS, &RUL_RS, 
                     TD_RS, &TDL_RS, TU_RS, &TUL_RS, stats);  // 写入原地址
-                if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+                if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
             }
         } 
         else if(iy==imax){ // 虚拟层位，可对递推公式简化
@@ -259,7 +259,7 @@ void grt_kernel(
                     TD, TDL, TU, TUL,
                     RD_BL, &RDL_BL, RU_BL, &RUL_BL, 
                     TD_BL, &TDL_BL, TU_BL, &TUL_BL, stats);  // 写入原地址
-                if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+                if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
             }
         } // END if
 
@@ -271,8 +271,8 @@ void grt_kernel(
 
 
     // 计算震源系数
-    MYCOMPLEX src_coef_PSV[SRC_M_NUM][QWV_NUM-1][2] = {0};
-    MYCOMPLEX src_coef_SH[SRC_M_NUM][2] = {0};
+    MYCOMPLEX src_coef_PSV[GRT_SRC_M_NUM][GRT_QWV_NUM-1][2] = {0};
+    MYCOMPLEX src_coef_SH[GRT_SRC_M_NUM][2] = {0};
     grt_source_coef_PSV(src_xa, src_xb, src_kaka, src_kbkb, k, src_coef_PSV);
     grt_source_coef_SH(src_xb, src_kbkb, k, src_coef_SH);
 
@@ -282,15 +282,15 @@ void grt_kernel(
 
     // 递推RU_FA
     grt_calc_R_tilt_PSV(top_xa, top_xb, top_kbkb, k, R_tilt, stats);
-    if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+    if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
     grt_recursion_RU(
-        R_tilt, RONE, 
+        R_tilt, 1.0, 
         RD_FA, RDL_FA,
         RU_FA, RUL_FA, 
         TD_FA, TDL_FA,
         TU_FA, TUL_FA,
         RU_FA, &RUL_FA, NULL, NULL, stats);
-    if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+    if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
     
     // 根据震源和台站相对位置，计算最终的系数
     if(ircvup){ // A接收  B震源
@@ -307,7 +307,7 @@ void grt_kernel(
             TD_RS, TDL_RS,
             TU_RS, TUL_RS,
             RU_FB, &RUL_FB, inv_2x2T, &invT, stats);
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
         
 #if Print_GRTCOEF == 1
         // TEST-------------------------------------------------------------
@@ -347,16 +347,16 @@ void grt_kernel(
         grt_cmat2x2_mul(RD_BL, RU_FB, tmpR2);
         grt_cmat2x2_one_sub(tmpR2);
         grt_cmat2x2_inv(tmpR2, tmpR2, stats);// (I - xx)^-1
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
         grt_cmat2x2_mul(inv_2x2T, tmpR2, tmp2x2);
 
         if(calc_uiz) grt_cmat2x2_assign(tmp2x2, tmp2x2_uiz); // 为后续计算空间导数备份
 
         grt_cmat2x2_mul(R_EV, tmp2x2, tmp2x2);
-        tmpRL = invT  / (RONE - RDL_BL * RUL_FB);
+        tmpRL = invT  / (1.0 - RDL_BL * RUL_FB);
         tmpRL2 = R_EVL * tmpRL;
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
             grt_get_qwv(ircvup, tmp2x2, tmpRL2, RD_BL, RDL_BL, src_coef_PSV[i], src_coef_SH[i], QWV[i]);
         }
 
@@ -367,7 +367,7 @@ void grt_kernel(
             grt_cmat2x2_mul(uiz_R_EV, tmp2x2_uiz, tmp2x2_uiz);
             tmpRL2 = uiz_R_EVL * tmpRL;
 
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
                 grt_get_qwv(ircvup, tmp2x2_uiz, tmpRL2, RD_BL, RDL_BL, src_coef_PSV[i], src_coef_SH[i], QWV_uiz[i]);
             }    
         }
@@ -386,22 +386,22 @@ void grt_kernel(
             TU_RS, TUL_RS,
             RD_BL, RDL_BL,
             RD_AL, &RDL_AL, inv_2x2T, &invT, stats);
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
         
         // 公式(5.7.26-27)
         grt_cmat2x2_mul(RU_FA, RD_AL, tmpR2);
         grt_cmat2x2_one_sub(tmpR2);
         grt_cmat2x2_inv(tmpR2, tmpR2, stats);// (I - xx)^-1
-        if(*stats==INVERSE_FAILURE)  goto BEFORE_RETURN;
+        if(*stats==GRT_INVERSE_FAILURE)  goto BEFORE_RETURN;
         grt_cmat2x2_mul(inv_2x2T, tmpR2, tmp2x2);
 
         if(calc_uiz) grt_cmat2x2_assign(tmp2x2, tmp2x2_uiz); // 为后续计算空间导数备份
 
         grt_cmat2x2_mul(R_EV, tmp2x2, tmp2x2);
-        tmpRL = invT / (RONE - RUL_FA * RDL_AL);
+        tmpRL = invT / (1.0 - RUL_FA * RDL_AL);
         tmpRL2 = R_EVL * tmpRL;
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
             grt_get_qwv(ircvup, tmp2x2, tmpRL2, RU_FA, RUL_FA, src_coef_PSV[i], src_coef_SH[i], QWV[i]);
         }
 
@@ -412,7 +412,7 @@ void grt_kernel(
             grt_cmat2x2_mul(uiz_R_EV, tmp2x2_uiz, tmp2x2_uiz);
             tmpRL2 = uiz_R_EVL * tmpRL;
             
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
                 grt_get_qwv(ircvup, tmp2x2_uiz, tmpRL2, RU_FA, RUL_FA, src_coef_PSV[i], src_coef_SH[i], QWV_uiz[i]);
             }
         }
@@ -425,11 +425,11 @@ void grt_kernel(
 
     // 对一些特殊情况的修正
     // 当震源和场点均位于地表时，可理论验证DS分量恒为0，这里直接赋0以避免后续的精度干扰
-    if(mod1d->Dep[mod1d->isrc] == RZERO && mod1d->Dep[mod1d->ircv] == RZERO)
+    if(mod1d->Dep[mod1d->isrc] == 0.0 && mod1d->Dep[mod1d->ircv] == 0.0)
     {
-        for(MYINT c=0; c<QWV_NUM; ++c){
-            QWV[SRC_M_DS_INDEX][c] = CZERO;
-            if(calc_uiz)  QWV_uiz[SRC_M_DS_INDEX][c] = CZERO;
+        for(MYINT c=0; c<GRT_QWV_NUM; ++c){
+            QWV[GRT_SRC_M_DS_INDEX][c] = 0.0;
+            if(calc_uiz)  QWV_uiz[GRT_SRC_M_DS_INDEX][c] = 0.0;
         }
     }
 
diff --git a/pygrt/C_extension/src/dynamic/source.c b/pygrt/C_extension/src/dynamic/source.c
index ba01e71a..35510d50 100755
--- a/pygrt/C_extension/src/dynamic/source.c
+++ b/pygrt/C_extension/src/dynamic/source.c
@@ -21,13 +21,13 @@
 void grt_source_coef_PSV(
     MYCOMPLEX src_xa, MYCOMPLEX src_xb, MYCOMPLEX src_kaka, MYCOMPLEX src_kbkb, 
     MYREAL k,
-    MYCOMPLEX coef[SRC_M_NUM][QWV_NUM-1][2])
+    MYCOMPLEX coef[GRT_SRC_M_NUM][GRT_QWV_NUM-1][2])
 {
     // 先全部赋0 
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        for(MYINT j=0; j<QWV_NUM-1; ++j){
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        for(MYINT j=0; j<GRT_QWV_NUM-1; ++j){
             for(MYINT p=0; p<2; ++p){
-                coef[i][j][p] = CZERO;
+                coef[i][j][p] = 0.0;
             }
         }
     }
@@ -42,22 +42,22 @@ void grt_source_coef_PSV(
     coef[0][0][0] = tmp = src_kaka / a;         coef[0][0][1] = tmp;    
     
     // 垂直力源 (4.6.15)
-    coef[1][0][0] = tmp = -RONE;                 coef[1][0][1] = - tmp;
+    coef[1][0][0] = tmp = -1.0;                 coef[1][0][1] = - tmp;
     coef[1][1][0] = tmp = -k / b;                coef[1][1][1] = tmp;
 
     // 水平力源 (4.6.21,26), 这里可以把x1,x2方向的力转到r,theta方向
     // 推导可发现，r方向的力形成P,SV波, theta方向的力形成SH波
     // 方向性因子包含水平力方向与震源台站连线方向的夹角
     coef[2][0][0] = tmp = -k / a;              coef[2][0][1] = tmp;
-    coef[2][1][0] = tmp = -RONE;               coef[2][1][1] = - tmp;
+    coef[2][1][0] = tmp = -1.0;               coef[2][1][1] = - tmp;
 
     // 剪切位错 (4.8.34)
     // m=0
-    coef[3][0][0] = tmp = (RTWO*src_kaka - RTHREE*kk) / a;    coef[3][0][1] = tmp;
-    coef[3][1][0] = tmp = -RTHREE*k;                          coef[3][1][1] = - tmp;
+    coef[3][0][0] = tmp = (2.0*src_kaka - 3.0*kk) / a;    coef[3][0][1] = tmp;
+    coef[3][1][0] = tmp = -3.0*k;                          coef[3][1][1] = - tmp;
     // m=1
-    coef[4][0][0] = tmp = RTWO*k;                      coef[4][0][1] = - tmp;
-    coef[4][1][0] = tmp = (RTWO*kk - src_kbkb) / b;    coef[4][1][1] = tmp;
+    coef[4][0][0] = tmp = 2.0*k;                      coef[4][0][1] = - tmp;
+    coef[4][1][0] = tmp = (2.0*kk - src_kbkb) / b;    coef[4][1][1] = tmp;
 
     // m=2
     coef[5][0][0] = tmp = - kk / a;                    coef[5][0][1] = tmp;
@@ -69,12 +69,12 @@ void grt_source_coef_PSV(
 void grt_source_coef_SH(
     MYCOMPLEX src_xb, MYCOMPLEX src_kbkb, 
     MYREAL k,
-    MYCOMPLEX coef[SRC_M_NUM][2])
+    MYCOMPLEX coef[GRT_SRC_M_NUM][2])
 {
     // 先全部赋0 
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
         for(MYINT p=0; p<2; ++p){
-            coef[i][p] = CZERO;
+            coef[i][p] = 0.0;
         }
     }
 
diff --git a/pygrt/C_extension/src/static/grt_static_greenfn.c b/pygrt/C_extension/src/static/grt_static_greenfn.c
index 109f288b..b4bcbcc5 100644
--- a/pygrt/C_extension/src/static/grt_static_greenfn.c
+++ b/pygrt/C_extension/src/static/grt_static_greenfn.c
@@ -185,7 +185,7 @@ printf("\n"
 "                   <vmin_ref> will be the minimum velocity\n"
 "                   of model, but limited to %.1f. and if the \n", GRT_GREENFN_V_VMIN_REF); printf(
 "                   depth gap between source and receiver is \n"
-"                   thinner than %.1f km, PTAM will be appled\n", MIN_DEPTH_GAP_SRC_RCV); printf(
+"                   thinner than %.1f km, PTAM will be appled\n", GRT_MIN_DEPTH_GAP_SRC_RCV); printf(
 "                   automatically.\n"
 "                 + manually set POSITIVE value. \n"
 "                 + manually set NEGATIVE value, \n"
@@ -197,7 +197,7 @@ printf("\n"
 "                 bound is k0,\n"
 "                 <k0>:   default is %.1f, and \n", GRT_GREENFN_K_K0); printf(
 "                         multiply PI/hs in program, \n"
-"                         where hs = max(fabs(depsrc-deprcv), %.1f).\n", MIN_DEPTH_GAP_SRC_RCV); printf(
+"                         where hs = max(fabs(depsrc-deprcv), %.1f).\n", GRT_MIN_DEPTH_GAP_SRC_RCV); printf(
 "                 <keps>: a threshold for break wavenumber \n"
 "                         integration in advance. See \n"
 "                         (Yao and Harkrider, 1983) for details.\n"
@@ -399,13 +399,13 @@ static void getopt_from_command(GRT_MODULE_CTRL *Ctrl, int argc, char **argv){
  * @param[in]   prefix    前缀字符串
  */
 static void print_grn_title(const char *prefix){
-    for(int i=0; i<SRC_M_NUM; ++i){
-        int modr = SRC_M_ORDERS[i];
+    for(int i=0; i<GRT_SRC_M_NUM; ++i){
+        int modr = GRT_SRC_M_ORDERS[i];
         char s_title[10+strlen(prefix)];
-        for(int c=0; c<CHANNEL_NUM; ++c){
-            if(modr==0 && ZRTchs[c]=='T')  continue;
+        for(int c=0; c<GRT_CHANNEL_NUM; ++c){
+            if(modr==0 && GRT_ZRT_CODES[c]=='T')  continue;
 
-            snprintf(s_title, sizeof(s_title), "%s%s%c", prefix, SRC_M_NAME_ABBR[i], ZRTchs[c]);
+            snprintf(s_title, sizeof(s_title), "%s%s%c", prefix, GRT_SRC_M_NAME_ABBR[i], GRT_ZRT_CODES[c]);
             fprintf(stdout, GRT_STRING_FMT, s_title);
         }
     }
@@ -417,14 +417,14 @@ static void print_grn_title(const char *prefix){
  * @param      grn       静态格林函数结果
  * @param      sgn0      全局符号
  */
-static void print_grn_value(const MYREAL grn[SRC_M_NUM][CHANNEL_NUM], const int sgn0){
-    for(int i=0; i<SRC_M_NUM; ++i){
-        int modr = SRC_M_ORDERS[i];
+static void print_grn_value(const MYREAL grn[GRT_SRC_M_NUM][GRT_CHANNEL_NUM], const int sgn0){
+    for(int i=0; i<GRT_SRC_M_NUM; ++i){
+        int modr = GRT_SRC_M_ORDERS[i];
         int sgn = 1;
-        for(int c=0; c<CHANNEL_NUM; ++c){
-            if(modr==0 && ZRTchs[c]=='T')  continue;
+        for(int c=0; c<GRT_CHANNEL_NUM; ++c){
+            if(modr==0 && GRT_ZRT_CODES[c]=='T')  continue;
 
-            sgn = (ZRTchs[c]=='Z') ? -sgn0 : sgn0;
+            sgn = (GRT_ZRT_CODES[c]=='Z') ? -sgn0 : sgn0;
 
             fprintf(stdout, GRT_REAL_FMT, sgn * grn[i][c]);
         }
@@ -458,7 +458,7 @@ int static_greenfn_main(int argc, char **argv){
     } 
 
     // 如果没有主动设置vmin_ref，则判断是否要自动使用PTAM
-    if( !Ctrl->V.active && fabs(Ctrl->D.deprcv - Ctrl->D.depsrc) <= MIN_DEPTH_GAP_SRC_RCV) {
+    if( !Ctrl->V.active && fabs(Ctrl->D.deprcv - Ctrl->D.depsrc) <= GRT_MIN_DEPTH_GAP_SRC_RCV) {
         Ctrl->V.vmin_ref = - fabs(Ctrl->V.vmin_ref);
     }
     
@@ -476,9 +476,9 @@ int static_greenfn_main(int argc, char **argv){
     }
 
     // 建立格林函数的浮点数
-    MYREAL (*grn)[SRC_M_NUM][CHANNEL_NUM] = (MYREAL (*)[SRC_M_NUM][CHANNEL_NUM]) calloc(Ctrl->nr, sizeof(*grn));
-    MYREAL (*grn_uiz)[SRC_M_NUM][CHANNEL_NUM] = (Ctrl->e.active)? (MYREAL (*)[SRC_M_NUM][CHANNEL_NUM]) calloc(Ctrl->nr, sizeof(*grn_uiz)) : NULL;
-    MYREAL (*grn_uir)[SRC_M_NUM][CHANNEL_NUM] = (Ctrl->e.active)? (MYREAL (*)[SRC_M_NUM][CHANNEL_NUM]) calloc(Ctrl->nr, sizeof(*grn_uir)) : NULL;
+    MYREAL (*grn)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (MYREAL (*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]) calloc(Ctrl->nr, sizeof(*grn));
+    MYREAL (*grn_uiz)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (Ctrl->e.active)? (MYREAL (*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]) calloc(Ctrl->nr, sizeof(*grn_uiz)) : NULL;
+    MYREAL (*grn_uir)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (Ctrl->e.active)? (MYREAL (*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]) calloc(Ctrl->nr, sizeof(*grn_uir)) : NULL;
 
 
     //==============================================================================
diff --git a/pygrt/C_extension/src/static/grt_static_rotation.c b/pygrt/C_extension/src/static/grt_static_rotation.c
index 2587c6a1..498f7b5d 100644
--- a/pygrt/C_extension/src/static/grt_static_rotation.c
+++ b/pygrt/C_extension/src/static/grt_static_rotation.c
@@ -128,7 +128,7 @@ int static_rotation_main(int argc, char **argv){
             GRT_SAFE_FREE_PTR(copyline);
 
             // 指示特定的通道名
-            chs = (rot2ZNE)? ZNEchs : ZRTchs;
+            chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
             // 想合成位移空间导数但输入的格林函数没有
             if(ncols < 14){
diff --git a/pygrt/C_extension/src/static/grt_static_strain.c b/pygrt/C_extension/src/static/grt_static_strain.c
index 6d16ffe3..d68e8213 100644
--- a/pygrt/C_extension/src/static/grt_static_strain.c
+++ b/pygrt/C_extension/src/static/grt_static_strain.c
@@ -126,7 +126,7 @@ int static_strain_main(int argc, char **argv){
             GRT_SAFE_FREE_PTR(copyline);
 
             // 指示特定的通道名
-            chs = (rot2ZNE)? ZNEchs : ZRTchs;
+            chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
             // 想合成位移空间导数但输入的格林函数没有
             if(ncols < 14){
diff --git a/pygrt/C_extension/src/static/grt_static_stress.c b/pygrt/C_extension/src/static/grt_static_stress.c
index 84256520..4f4c784e 100644
--- a/pygrt/C_extension/src/static/grt_static_stress.c
+++ b/pygrt/C_extension/src/static/grt_static_stress.c
@@ -137,7 +137,7 @@ int static_stress_main(int argc, char **argv){
             GRT_SAFE_FREE_PTR(copyline);
 
             // 指示特定的通道名
-            chs = (rot2ZNE)? ZNEchs : ZRTchs;
+            chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
             // 想合成位移空间导数但输入的格林函数没有
             if(ncols < 14){
diff --git a/pygrt/C_extension/src/static/grt_static_syn.c b/pygrt/C_extension/src/static/grt_static_syn.c
index 840e7146..87b07206 100644
--- a/pygrt/C_extension/src/static/grt_static_syn.c
+++ b/pygrt/C_extension/src/static/grt_static_syn.c
@@ -46,10 +46,10 @@ typedef struct {
     } e;
 
     // 存储不同震源的震源机制相关参数的数组
-    MYREAL mchn[MECHANISM_NUM];
+    MYREAL mchn[GRT_MECHANISM_NUM];
 
     // 方向因子数组
-    MYREAL srcRadi[SRC_M_NUM][CHANNEL_NUM];
+    MYREAL srcRadi[GRT_SRC_M_NUM][GRT_CHANNEL_NUM];
 
     // 最终要计算的震源类型
     MYINT computeType;
@@ -265,17 +265,17 @@ int static_syn_main(int argc, char **argv){
     getopt_from_command(Ctrl, argc, argv);
 
     // 辐射因子
-    // double srcRadi[SRC_M_NUM][CHANNEL_NUM]={0};
+    // double srcRadi[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]={0};
 
     // 从标准输入中读取静态格林函数表
-    double x0, y0, grn[SRC_M_NUM][CHANNEL_NUM]={0}, syn[CHANNEL_NUM]={0}, syn_upar[CHANNEL_NUM][CHANNEL_NUM]={0};
-    double grn_uiz[SRC_M_NUM][CHANNEL_NUM]={0}, grn_uir[SRC_M_NUM][CHANNEL_NUM]={0};
+    double x0, y0, grn[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]={0}, syn[GRT_CHANNEL_NUM]={0}, syn_upar[GRT_CHANNEL_NUM][GRT_CHANNEL_NUM]={0};
+    double grn_uiz[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]={0}, grn_uir[GRT_SRC_M_NUM][GRT_CHANNEL_NUM]={0};
 
     // 输出分量格式，即是否需要旋转到ZNE
     bool rot2ZNE = Ctrl->N.active;
 
     // 根据参数设置，选择分量名
-    const char *chs = (rot2ZNE)? ZNEchs : ZRTchs;
+    const char *chs = (rot2ZNE)? GRT_ZNE_CODES : GRT_ZRT_CODES;
 
 
     // 建立一个指针数组，方便读取多列数据
@@ -287,9 +287,9 @@ int static_syn_main(int argc, char **argv){
         *(pt++) = &x0;
         *(pt++) = &y0;
         for(int m=0; m<3; ++m){
-            for(int k=0; k<SRC_M_NUM; ++k){
-                for(int c=0; c<CHANNEL_NUM; ++c){
-                    if(SRC_M_ORDERS[k]==0 && ZRTchs[c] == 'T')  continue;
+            for(int k=0; k<GRT_SRC_M_NUM; ++k){
+                for(int c=0; c<GRT_CHANNEL_NUM; ++c){
+                    if(GRT_SRC_M_ORDERS[k]==0 && GRT_ZRT_CODES[c] == 'T')  continue;
 
                     if(m==0){
                         *pt = &grn[k][c];
@@ -400,14 +400,14 @@ int static_syn_main(int argc, char **argv){
             fprintf(stdout, "%s", XX);
             fprintf(stdout, GRT_STRING_FMT, "Y(km)");
             char s_channel[5];
-            for(int i=0; i<CHANNEL_NUM; ++i){
+            for(int i=0; i<GRT_CHANNEL_NUM; ++i){
                 sprintf(s_channel, "%s%c", Ctrl->s_computeType, toupper(chs[i])); 
                 fprintf(stdout, GRT_STRING_FMT, s_channel);
             }
 
             if(Ctrl->e.active){
-                for(int k=0; k<CHANNEL_NUM; ++k){
-                    for(int i=0; i<CHANNEL_NUM; ++i){
+                for(int k=0; k<GRT_CHANNEL_NUM; ++k){
+                    for(int i=0; i<GRT_CHANNEL_NUM; ++i){
                         sprintf(s_channel, "%c%s%c", tolower(chs[k]), Ctrl->s_computeType, toupper(chs[i])); 
                         fprintf(stdout, GRT_STRING_FMT, s_channel);
                     }
@@ -418,8 +418,8 @@ int static_syn_main(int argc, char **argv){
             printHead = true;
         }
 
-        double (*grn3)[CHANNEL_NUM];  // 使用对应类型的格林函数
-        double tmpsyn[CHANNEL_NUM];
+        double (*grn3)[GRT_CHANNEL_NUM];  // 使用对应类型的格林函数
+        double tmpsyn[GRT_CHANNEL_NUM];
         for(int ityp=0; ityp<calcUTypes; ++ityp){
             // 求位移空间导数时，需调整比例系数
             switch (ityp){
@@ -456,14 +456,14 @@ int static_syn_main(int argc, char **argv){
             // 计算震源辐射因子
             grt_set_source_radiation(Ctrl->srcRadi, Ctrl->computeType, ityp==3, Ctrl->S.M0, upar_scale, azrad, Ctrl->mchn);
 
-            for(int i=0; i<CHANNEL_NUM; ++i){
-                for(int k=0; k<SRC_M_NUM; ++k){
+            for(int i=0; i<GRT_CHANNEL_NUM; ++i){
+                for(int k=0; k<GRT_SRC_M_NUM; ++k){
                     tmpsyn[i] += grn3[k][i] * Ctrl->srcRadi[k][i];
                 }
             }
 
             // 保存数据
-            for(int i=0; i<CHANNEL_NUM; ++i){
+            for(int i=0; i<GRT_CHANNEL_NUM; ++i){
                 if(ityp == 0){
                     syn[i] = tmpsyn[i];
                 } else {
@@ -483,12 +483,12 @@ int static_syn_main(int argc, char **argv){
 
         // 输出数据
         fprintf(stdout, GRT_REAL_FMT GRT_REAL_FMT, x0, y0);
-        for(int i=0; i<CHANNEL_NUM; ++i){
+        for(int i=0; i<GRT_CHANNEL_NUM; ++i){
             fprintf(stdout, GRT_REAL_FMT, syn[i]);
         }
         if(Ctrl->e.active){
-            for(int i=0; i<CHANNEL_NUM; ++i){
-                for(int k=0; k<CHANNEL_NUM; ++k){
+            for(int i=0; i<GRT_CHANNEL_NUM; ++i){
+                for(int k=0; k<GRT_CHANNEL_NUM; ++k){
                     fprintf(stdout, GRT_REAL_FMT, syn_upar[i][k]);
                 }
             }
diff --git a/pygrt/C_extension/src/static/static_grn.c b/pygrt/C_extension/src/static/static_grn.c
index 982e45d3..ca7f2f1b 100644
--- a/pygrt/C_extension/src/static/static_grn.c
+++ b/pygrt/C_extension/src/static/static_grn.c
@@ -41,17 +41,17 @@
  * @param[out]   grn            三分量结果，浮点数数组
  */
 static void recordin_GRN(
-    MYINT nr, MYCOMPLEX coef, MYCOMPLEX sum_J[nr][SRC_M_NUM][INTEG_NUM],
-    MYREAL grn[nr][SRC_M_NUM][CHANNEL_NUM]
+    MYINT nr, MYCOMPLEX coef, MYCOMPLEX sum_J[nr][GRT_SRC_M_NUM][GRT_INTEG_NUM],
+    MYREAL grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM]
 ){
     // 局部变量，将某个频点的格林函数谱临时存放
-    MYCOMPLEX (*tmp_grn)[SRC_M_NUM][CHANNEL_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][CHANNEL_NUM])calloc(nr, sizeof(*tmp_grn));
+    MYCOMPLEX (*tmp_grn)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM] = (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_CHANNEL_NUM])calloc(nr, sizeof(*tmp_grn));
 
     for(MYINT ir=0; ir<nr; ++ir){
         grt_merge_Pk(sum_J[ir], tmp_grn[ir]);
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i) {
-            for(MYINT c=0; c<CHANNEL_NUM; ++c){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i) {
+            for(MYINT c=0; c<GRT_CHANNEL_NUM; ++c){
                 grn[ir][i][c] = creal(coef * tmp_grn[ir][i][c]);
             }
 
@@ -68,35 +68,35 @@ void grt_integ_static_grn(
     MYREAL filonLength, MYREAL safilonTol, MYREAL filonCut, 
 
     // 返回值，代表Z、R、T分量
-    MYREAL grn[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYREAL grn[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     bool calc_upar,
-    MYREAL grn_uiz[nr][SRC_M_NUM][CHANNEL_NUM],
-    MYREAL grn_uir[nr][SRC_M_NUM][CHANNEL_NUM],
+    MYREAL grn_uiz[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
+    MYREAL grn_uir[nr][GRT_SRC_M_NUM][GRT_CHANNEL_NUM],
 
     const char *statsstr // 积分结果输出
 ){
     MYREAL rmax=rs[grt_findMinMax_MYREAL(rs, nr, true)];   // 最大震中距
 
-    const MYREAL hs = GRT_MAX(fabs(mod1d->depsrc - mod1d->deprcv), MIN_DEPTH_GAP_SRC_RCV); // hs=max(震源和台站深度差,1.0)
+    const MYREAL hs = GRT_MAX(fabs(mod1d->depsrc - mod1d->deprcv), GRT_MIN_DEPTH_GAP_SRC_RCV); // hs=max(震源和台站深度差,1.0)
 
     // 乘相应系数
     k0 *= PI/hs;
 
-    if(vmin_ref < RZERO)  keps = -RONE;  // 若使用峰谷平均法，则不使用keps进行收敛判断
+    if(vmin_ref < 0.0)  keps = -1.0;  // 若使用峰谷平均法，则不使用keps进行收敛判断
 
     MYREAL k=0.0;
-    bool useFIM = (filonLength > RZERO) || (safilonTol > RZERO) ;    // 是否使用Filon积分（包括自适应Filon）
+    bool useFIM = (filonLength > 0.0) || (safilonTol > 0.0) ;    // 是否使用Filon积分（包括自适应Filon）
     const MYREAL dk=fabs(PI2/(Length*rmax));     // 波数积分间隔
-    const MYREAL filondk = (filonLength > RZERO) ? PI2/(filonLength*rmax) : RZERO;  // Filon积分间隔
+    const MYREAL filondk = (filonLength > 0.0) ? PI2/(filonLength*rmax) : 0.0;  // Filon积分间隔
     const MYREAL filonK = filonCut/rmax;  // 波数积分和Filon积分的分割点
 
     const MYREAL kmax = k0;
     // 求和 sum F(ki,w)Jm(ki*r)ki 
     // 关于形状详见int_Pk()函数内的注释
-    MYCOMPLEX (*sum_J)[SRC_M_NUM][INTEG_NUM] = (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_J));
-    MYCOMPLEX (*sum_uiz_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
-    MYCOMPLEX (*sum_uir_J)[SRC_M_NUM][INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[SRC_M_NUM][INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
+    MYCOMPLEX (*sum_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_J));
+    MYCOMPLEX (*sum_uiz_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uiz_J)) : NULL;
+    MYCOMPLEX (*sum_uir_J)[GRT_SRC_M_NUM][GRT_INTEG_NUM] = (calc_upar)? (MYCOMPLEX(*)[GRT_SRC_M_NUM][GRT_INTEG_NUM])calloc(nr, sizeof(*sum_uir_J)) : NULL;
 
     // 是否要输出积分过程文件
     bool needfstats = (statsstr!=NULL);
@@ -104,7 +104,7 @@ void grt_integ_static_grn(
     // PTAM的积分中间结果, 每个震中距两个文件，因为PTAM对不同震中距使用不同的dk
     // 在文件名后加后缀，区分不同震中距
     char **ptam_fstatsdir = (char**)calloc(nr, sizeof(char*));
-    if(needfstats && vmin_ref < RZERO){
+    if(needfstats && vmin_ref < 0.0){
         for(MYINT ir=0; ir<nr; ++ir){
             // 新建文件夹目录 
             GRT_SAFE_ASPRINTF(&ptam_fstatsdir[ir], "%s/PTAM_%04d_%.5e", statsstr, ir, rs[ir]);
@@ -128,18 +128,18 @@ void grt_integ_static_grn(
             fstats = fopen(fname, "wb");
         }
         for(MYINT ir=0; ir<nr; ++ir){
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
-                for(MYINT v=0; v<INTEG_NUM; ++v){
-                    sum_J[ir][i][v] = CZERO;
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+                for(MYINT v=0; v<GRT_INTEG_NUM; ++v){
+                    sum_J[ir][i][v] = 0.0;
                     if(calc_upar){
-                        sum_uiz_J[ir][i][v] = CZERO;
-                        sum_uir_J[ir][i][v] = CZERO;
+                        sum_uiz_J[ir][i][v] = 0.0;
+                        sum_uir_J[ir][i][v] = 0.0;
                     }
                 }
             }
     
             ptam_fstatsnr[ir][0] = ptam_fstatsnr[ir][1] = NULL;
-            if(needfstats && vmin_ref < RZERO){
+            if(needfstats && vmin_ref < 0.0){
                 // 峰谷平均法
                 GRT_SAFE_ASPRINTF(&fname, "%s/K", ptam_fstatsdir[ir]);
                 ptam_fstatsnr[ir][0] = fopen(fname, "wb");
@@ -152,7 +152,7 @@ void grt_integ_static_grn(
 
     // 计算核函数过程中是否有遇到除零错误
     //【静态解理论上不会有除零错误，这里是对应动态解的函数接口，作为一个占位符】
-    MYINT inv_stats=INVERSE_SUCCESS;
+    MYINT inv_stats=GRT_INVERSE_SUCCESS;
 
     // 常规的波数积分
     k = grt_discrete_integ(
@@ -162,14 +162,14 @@ void grt_integ_static_grn(
     
     // 基于线性插值的Filon积分
     if(useFIM){
-        if(filondk > RZERO){
+        if(filondk > 0.0){
             // 基于线性插值的Filon积分，固定采样间隔
             k = grt_linear_filon_integ(
                 mod1d, k, dk, filondk, kmax, keps, 0.0, nr, rs, 
                 sum_J, calc_upar, sum_uiz_J, sum_uir_J,
                 fstats, grt_static_kernel, &inv_stats);
         }
-        else if(safilonTol > RZERO){
+        else if(safilonTol > 0.0){
             // 基于自适应采样的Filon积分
             k = grt_sa_filon_integ(
                 mod1d, kmax, k, dk, safilonTol, kmax, 0.0, nr, rs, 
@@ -179,7 +179,7 @@ void grt_integ_static_grn(
     }
 
     // k之后的部分使用峰谷平均法进行显式收敛，建议在浅源地震的时候使用   
-    if(vmin_ref < RZERO){
+    if(vmin_ref < 0.0){
         grt_PTA_method(
             mod1d, k, dk, 0.0, nr, rs, 
             sum_J, calc_upar, sum_uiz_J, sum_uir_J,
@@ -189,7 +189,7 @@ void grt_integ_static_grn(
 
     
     MYCOMPLEX src_mu = mod1d->mu[mod1d->isrc];
-    MYCOMPLEX fac = dk * RONE/(RFOUR*PI * src_mu);
+    MYCOMPLEX fac = dk * 1.0/(4.0*PI * src_mu);
     
     // 将积分结果记录到浮点数数组中
     recordin_GRN(nr, fac, sum_J, grn);
diff --git a/pygrt/C_extension/src/static/static_layer.c b/pygrt/C_extension/src/static/static_layer.c
index 2091f76b..509cd2b7 100644
--- a/pygrt/C_extension/src/static/static_layer.c
+++ b/pygrt/C_extension/src/static/static_layer.c
@@ -21,15 +21,15 @@
 
 void grt_calc_static_R_tilt_PSV(MYCOMPLEX delta1, MYCOMPLEX R_tilt[2][2]){
     // 公式(6.3.12)
-    R_tilt[0][0] = R_tilt[1][1] = CZERO;
+    R_tilt[0][0] = R_tilt[1][1] = 0.0;
     R_tilt[0][1] = -delta1;
-    R_tilt[1][0] = -RONE/delta1;
+    R_tilt[1][0] = -1.0/delta1;
 }
 
 void grt_calc_static_R_EV_PSV(bool ircvup, const MYCOMPLEX R[2][2], MYCOMPLEX R_EV[2][2])
 {
-    MYCOMPLEX D11[2][2] = {{RONE, -RONE}, {RONE, RONE}};
-    MYCOMPLEX D12[2][2] = {{RONE, -RONE}, {-RONE, -RONE}};
+    MYCOMPLEX D11[2][2] = {{1.0, -1.0}, {1.0, 1.0}};
+    MYCOMPLEX D12[2][2] = {{1.0, -1.0}, {-1.0, -1.0}};
 
     // 公式(6.3.35,37)
     if(ircvup){// 震源更深
@@ -43,7 +43,7 @@ void grt_calc_static_R_EV_PSV(bool ircvup, const MYCOMPLEX R[2][2], MYCOMPLEX R_
 
 void grt_calc_static_R_EV_SH(MYCOMPLEX RL, MYCOMPLEX *R_EVL)
 {
-    *R_EVL = (RONE + (RL));
+    *R_EVL = (1.0 + (RL));
 }
 
 void grt_calc_static_uiz_R_EV_PSV(
@@ -51,7 +51,7 @@ void grt_calc_static_uiz_R_EV_PSV(
     const MYCOMPLEX R[2][2], MYCOMPLEX R_EV[2][2])
 {
     // 新推导公式
-    MYCOMPLEX kd2 = RTWO*k*delta1;
+    MYCOMPLEX kd2 = 2.0*k*delta1;
     MYCOMPLEX D11[2][2] = {{k, -k-kd2}, {k, k-kd2}};
     MYCOMPLEX D12[2][2] = {{-k, k+kd2}, {k, k-kd2}};
     if(ircvup){// 震源更深
@@ -67,9 +67,9 @@ void grt_calc_static_uiz_R_EV_SH(bool ircvup, MYREAL k, MYCOMPLEX RL, MYCOMPLEX
 {
     // 新推导公式
     if(ircvup){// 震源更深
-        *R_EVL = (RONE - (RL))*k;
+        *R_EVL = (1.0 - (RL))*k;
     } else { // 接收点更深
-        *R_EVL = (RL - RONE)*k;
+        *R_EVL = (RL - 1.0)*k;
     }
 }
 
@@ -96,26 +96,26 @@ void grt_calc_static_RT_PSV(
 
     // REFELCTION
     //------------------ RD -----------------------------------
-    RD[0][0] = -RTWO*delta1*k*thk*dmu/A112 * ex2;
-    RD[0][1] = - ( RFOUR*del11*k2*thk2*A221*dmu + A112*B ) / (A221*A112) * ex2;
+    RD[0][0] = -2.0*delta1*k*thk*dmu/A112 * ex2;
+    RD[0][1] = - ( 4.0*del11*k2*thk2*A221*dmu + A112*B ) / (A221*A112) * ex2;
     RD[1][0] = - dmu/A112 * ex2;
     RD[1][1] = RD[0][0];
     //------------------ RU -----------------------------------
-    RU[0][0] = RZERO;
+    RU[0][0] = 0.0;
     RU[0][1] = B/A112;
     RU[1][0] = dmu/A221;
-    RU[1][1] = RZERO;
+    RU[1][1] = 0.0;
 
     // Transmission
     //------------------ TD -----------------------------------
-    TD[0][0] = mu1*(RONE+delta1)/(A112) * ex;
-    TD[0][1] = RTWO*mu1*delta1*k*thk*(RONE+delta1)/(A112) * ex;
-    TD[1][0] = RZERO;
+    TD[0][0] = mu1*(1.0+delta1)/(A112) * ex;
+    TD[0][1] = 2.0*mu1*delta1*k*thk*(1.0+delta1)/(A112) * ex;
+    TD[1][0] = 0.0;
     TD[1][1] = TD[0][0]*A112/A221;
     //------------------ TU -----------------------------------
-    TU[0][0] = mu2*(RONE+delta2)/A221 * ex;
-    TU[0][1] = RTWO*delta1*k*thk*mu2*(RONE+delta2)/A112 * ex;
-    TU[1][0] = RZERO;
+    TU[0][0] = mu2*(1.0+delta2)/A221 * ex;
+    TU[0][1] = 2.0*delta1*k*thk*mu2*(1.0+delta2)/A112 * ex;
+    TU[1][0] = 0.0;
     TU[1][1] = TU[0][0]*A221/A112;
 
     // printf("delta1=%.5e%+.5ej, delta2=%.5e%+.5ej, mu1=%.5e%+.5ej, mu2=%.5e%+.5ej, thk=%e, k=%e\n", 
@@ -147,6 +147,6 @@ void grt_calc_static_RT_SH(
     *RUL = - dmu/amu;
 
     // Transmission
-    *TDL = RTWO*mu1/amu * ex;
+    *TDL = 2.0*mu1/amu * ex;
     *TUL = (*TDL)*mu2/mu1;
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/src/static/static_propagate.c b/pygrt/C_extension/src/static/static_propagate.c
index 65774176..49dfce64 100644
--- a/pygrt/C_extension/src/static/static_propagate.c
+++ b/pygrt/C_extension/src/static/static_propagate.c
@@ -25,14 +25,14 @@
 
 
 void grt_static_kernel(
-    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[SRC_M_NUM][QWV_NUM],
-    bool calc_uiz, MYCOMPLEX QWV_uiz[SRC_M_NUM][QWV_NUM], MYINT *stats)
+    const GRT_MODEL1D *mod1d, MYCOMPLEX omega, MYREAL k, MYCOMPLEX QWV[GRT_SRC_M_NUM][GRT_QWV_NUM],
+    bool calc_uiz, MYCOMPLEX QWV_uiz[GRT_SRC_M_NUM][GRT_QWV_NUM], MYINT *stats)
 {   
     // 初始化qwv为0
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        for(MYINT j=0; j<QWV_NUM; ++j){
-            QWV[i][j] = CZERO;
-            if(calc_uiz)  QWV_uiz[i][j] = CZERO;
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        for(MYINT j=0; j<GRT_QWV_NUM; ++j){
+            QWV[i][j] = 0.0;
+            if(calc_uiz)  QWV_uiz[i][j] = 0.0;
         }
     }
 
@@ -46,45 +46,45 @@ void grt_static_kernel(
 
     // 初始化广义反射透射系数矩阵
     // BL
-    MYCOMPLEX RD_BL[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_BL = CZERO;
-    MYCOMPLEX RU_BL[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_BL = CZERO;
-    MYCOMPLEX TD_BL[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL_BL = CONE;
-    MYCOMPLEX TU_BL[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL_BL = CONE;
+    MYCOMPLEX RD_BL[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_BL = 0.0;
+    MYCOMPLEX RU_BL[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_BL = 0.0;
+    MYCOMPLEX TD_BL[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL_BL = 1.0;
+    MYCOMPLEX TU_BL[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL_BL = 1.0;
     // AL
-    MYCOMPLEX RD_AL[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_AL = CZERO;
+    MYCOMPLEX RD_AL[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_AL = 0.0;
     // RS
-    MYCOMPLEX RD_RS[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_RS = CZERO;
-    MYCOMPLEX RU_RS[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_RS = CZERO;
-    MYCOMPLEX TD_RS[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL_RS = CONE;
-    MYCOMPLEX TU_RS[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL_RS = CONE;
+    MYCOMPLEX RD_RS[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_RS = 0.0;
+    MYCOMPLEX RU_RS[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_RS = 0.0;
+    MYCOMPLEX TD_RS[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL_RS = 1.0;
+    MYCOMPLEX TU_RS[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL_RS = 1.0;
     // FA (实际先计算ZA，再递推到FA)
-    MYCOMPLEX RD_FA[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RDL_FA = CZERO;
-    MYCOMPLEX RU_FA[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_FA = CZERO;
-    MYCOMPLEX TD_FA[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TDL_FA = CONE;
-    MYCOMPLEX TU_FA[2][2] = INIT_C_IDENTITY_2x2_MATRIX;
-    MYCOMPLEX TUL_FA = CONE;
+    MYCOMPLEX RD_FA[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RDL_FA = 0.0;
+    MYCOMPLEX RU_FA[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_FA = 0.0;
+    MYCOMPLEX TD_FA[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TDL_FA = 1.0;
+    MYCOMPLEX TU_FA[2][2] = GRT_INIT_IDENTITY_2x2_MATRIX;
+    MYCOMPLEX TUL_FA = 1.0;
     // FB (实际先计算ZB，再递推到FB)
-    MYCOMPLEX RU_FB[2][2] = INIT_C_ZERO_2x2_MATRIX;
-    MYCOMPLEX RUL_FB = CZERO;
+    MYCOMPLEX RU_FB[2][2] = GRT_INIT_ZERO_2x2_MATRIX;
+    MYCOMPLEX RUL_FB = 0.0;
 
     // 定义物理层内的反射透射系数矩阵，相对于界面上的系数矩阵增加了时间延迟因子
     MYCOMPLEX RD[2][2], RDL, TD[2][2], TDL;
     MYCOMPLEX RU[2][2], RUL, TU[2][2], TUL;
 
     // 自由表面的反射系数
-    MYCOMPLEX R_tilt[2][2] = INIT_C_ZERO_2x2_MATRIX; // SH波在自由表面的反射系数为1，不必定义变量
+    MYCOMPLEX R_tilt[2][2] = GRT_INIT_ZERO_2x2_MATRIX; // SH波在自由表面的反射系数为1，不必定义变量
 
     // 接收点处的接收矩阵
     MYCOMPLEX R_EV[2][2], R_EVL;
@@ -97,9 +97,9 @@ void grt_static_kernel(
     MYREAL mod1d_thk0, mod1d_thk1;
     MYCOMPLEX mod1d_mu0, mod1d_mu1;
     MYCOMPLEX mod1d_delta0, mod1d_delta1;
-    MYCOMPLEX top_delta = CZERO;
-    MYCOMPLEX src_delta = CZERO;
-    MYCOMPLEX rcv_delta = CZERO;
+    MYCOMPLEX top_delta = 0.0;
+    MYCOMPLEX src_delta = 0.0;
+    MYCOMPLEX rcv_delta = 0.0;
     
 
     // 从顶到底进行矩阵递推, 公式(5.5.3)
@@ -190,8 +190,8 @@ void grt_static_kernel(
 
 
     // 计算震源系数
-    MYCOMPLEX src_coef_PSV[SRC_M_NUM][QWV_NUM-1][2] = {0};
-    MYCOMPLEX src_coef_SH[SRC_M_NUM][2] = {0};
+    MYCOMPLEX src_coef_PSV[GRT_SRC_M_NUM][GRT_QWV_NUM-1][2] = {0};
+    MYCOMPLEX src_coef_SH[GRT_SRC_M_NUM][2] = {0};
     grt_static_source_coef_PSV(src_delta, k, src_coef_PSV);
     grt_static_source_coef_SH(k, src_coef_SH);
 
@@ -202,7 +202,7 @@ void grt_static_kernel(
     // 递推RU_FA
     grt_calc_static_R_tilt_PSV(top_delta, R_tilt);
     grt_recursion_RU(
-        R_tilt, RONE, 
+        R_tilt, 1.0, 
         RD_FA, RDL_FA,
         RU_FA, RUL_FA, 
         TD_FA, TDL_FA,
@@ -233,9 +233,9 @@ void grt_static_kernel(
         if(calc_uiz) grt_cmat2x2_assign(tmp2x2, tmp2x2_uiz); // 为后续计算空间导数备份
 
         grt_cmat2x2_mul(R_EV, tmp2x2, tmp2x2);
-        tmpRL = R_EVL * invT  / (RONE - RDL_BL * RUL_FB);
+        tmpRL = R_EVL * invT  / (1.0 - RDL_BL * RUL_FB);
 
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
             grt_get_qwv(ircvup, tmp2x2, tmpRL, RD_BL, RDL_BL, src_coef_PSV[i], src_coef_SH[i], QWV[i]);
         }
         
@@ -246,7 +246,7 @@ void grt_static_kernel(
             grt_cmat2x2_mul(uiz_R_EV, tmp2x2_uiz, tmp2x2_uiz);
             tmpRL_uiz = tmpRL / R_EVL * uiz_R_EVL;
             
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
                 grt_get_qwv(ircvup, tmp2x2_uiz, tmpRL_uiz, RD_BL, RDL_BL, src_coef_PSV[i], src_coef_SH[i], QWV_uiz[i]);
             }    
         }
@@ -275,9 +275,9 @@ void grt_static_kernel(
         if(calc_uiz) grt_cmat2x2_assign(tmp2x2, tmp2x2_uiz); // 为后续计算空间导数备份
 
         grt_cmat2x2_mul(R_EV, tmp2x2, tmp2x2);
-        tmpRL = R_EVL * invT / (RONE - RUL_FA * RDL_AL);
+        tmpRL = R_EVL * invT / (1.0 - RUL_FA * RDL_AL);
         
-        for(MYINT i=0; i<SRC_M_NUM; ++i){
+        for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
             grt_get_qwv(ircvup, tmp2x2, tmpRL, RU_FA, RUL_FA, src_coef_PSV[i], src_coef_SH[i], QWV[i]);
         }
 
@@ -287,7 +287,7 @@ void grt_static_kernel(
             grt_cmat2x2_mul(uiz_R_EV, tmp2x2_uiz, tmp2x2_uiz);
             tmpRL_uiz = tmpRL / R_EVL * uiz_R_EVL;
             
-            for(MYINT i=0; i<SRC_M_NUM; ++i){
+            for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
                 grt_get_qwv(ircvup, tmp2x2_uiz, tmpRL_uiz, RU_FA, RUL_FA, src_coef_PSV[i], src_coef_SH[i], QWV_uiz[i]);
             }
         }
diff --git a/pygrt/C_extension/src/static/static_source.c b/pygrt/C_extension/src/static/static_source.c
index 134d27ea..f24f9c43 100644
--- a/pygrt/C_extension/src/static/static_source.c
+++ b/pygrt/C_extension/src/static/static_source.c
@@ -16,63 +16,63 @@
 #include "grt/static/static_source.h"
 #include "grt/common/const.h"
 
-void grt_static_source_coef_PSV(MYCOMPLEX delta, MYREAL k, MYCOMPLEX coef[SRC_M_NUM][QWV_NUM-1][2])
+void grt_static_source_coef_PSV(MYCOMPLEX delta, MYREAL k, MYCOMPLEX coef[GRT_SRC_M_NUM][GRT_QWV_NUM-1][2])
 {
     // 先全部赋0 
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
-        for(MYINT j=0; j<QWV_NUM-1; ++j){
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
+        for(MYINT j=0; j<GRT_QWV_NUM-1; ++j){
             for(MYINT p=0; p<2; ++p){
-                coef[i][j][p] = CZERO;
+                coef[i][j][p] = 0.0;
             }
         }
     }
 
     MYCOMPLEX tmp;
-    MYCOMPLEX A = RONE+delta;
+    MYCOMPLEX A = 1.0+delta;
 
     // 爆炸源
-    coef[0][0][0] = tmp = (delta-RONE)/A;         coef[0][0][1] = tmp;    
+    coef[0][0][0] = tmp = (delta-1.0)/A;         coef[0][0][1] = tmp;    
 
     // 垂直力源
-    coef[1][0][0] = tmp = -RONE/(RTWO*A*k);        coef[1][0][1] = - tmp;   
+    coef[1][0][0] = tmp = -1.0/(2.0*A*k);        coef[1][0][1] = - tmp;   
     coef[1][1][0] = tmp;                           coef[1][1][1] = - tmp;
 
     // 水平力源
-    coef[2][0][0] = tmp = RONE/(RTWO*A*k);        coef[2][0][1] = tmp;   
+    coef[2][0][0] = tmp = 1.0/(2.0*A*k);        coef[2][0][1] = tmp;   
     coef[2][1][0] = - tmp;                        coef[2][1][1] = - tmp;
 
     // 剪切位错
     // m=0
-    coef[3][0][0] = tmp = (-RONE+RFOUR*delta)/(RTWO*A);    coef[3][0][1] = tmp;
-    coef[3][1][0] = tmp = -RTHREE/(RTWO*A);                coef[3][1][1] = tmp;
+    coef[3][0][0] = tmp = (-1.0+4.0*delta)/(2.0*A);    coef[3][0][1] = tmp;
+    coef[3][1][0] = tmp = -3.0/(2.0*A);                coef[3][1][1] = tmp;
     // m=1
     coef[4][0][0] = tmp = -delta/A;                        coef[4][0][1] = -tmp;
-    coef[4][1][0] = tmp = RONE/A;                          coef[4][1][1] = -tmp;
+    coef[4][1][0] = tmp = 1.0/A;                          coef[4][1][1] = -tmp;
     // m=2
-    coef[5][0][0] = tmp = RONE/(RTWO*A);                   coef[5][0][1] = tmp;
-    coef[5][1][0] = tmp = -RONE/(RTWO*A);                  coef[5][1][1] = tmp;
+    coef[5][0][0] = tmp = 1.0/(2.0*A);                   coef[5][0][1] = tmp;
+    coef[5][1][0] = tmp = -1.0/(2.0*A);                  coef[5][1][1] = tmp;
 }
 
 
-void grt_static_source_coef_SH(MYREAL k, MYCOMPLEX coef[SRC_M_NUM][2])
+void grt_static_source_coef_SH(MYREAL k, MYCOMPLEX coef[GRT_SRC_M_NUM][2])
 {
     // 先全部赋0 
-    for(MYINT i=0; i<SRC_M_NUM; ++i){
+    for(MYINT i=0; i<GRT_SRC_M_NUM; ++i){
         for(MYINT p=0; p<2; ++p){
-            coef[i][p] = CZERO;
+            coef[i][p] = 0.0;
         }
     }
 
     MYCOMPLEX tmp;
 
     // 水平力源
-    coef[2][0] = tmp = -RONE/k;                coef[2][1] = tmp;
+    coef[2][0] = tmp = -1.0/k;                coef[2][1] = tmp;
 
     // 剪切位错
     // m=1
-    coef[4][0] = tmp = RONE;                            coef[4][1] = -tmp;
+    coef[4][0] = tmp = 1.0;                            coef[4][1] = -tmp;
     // m=2
-    coef[5][0] = tmp = -RONE;                           coef[5][1] = tmp;
+    coef[5][0] = tmp = -1.0;                           coef[5][1] = tmp;
 }
 
 

From f2e2759324080291954a612a40a6b5afb3d8f19b Mon Sep 17 00:00:00 2001
From: Dengda98 <zhudengda21@mails.ucas.ac.cn>
Date: Wed, 3 Sep 2025 13:52:57 +0800
Subject: [PATCH 3/5] REFAC: use macro for comment head '#', and add related
 helper function

---
 pygrt/C_extension/include/grt/common/const.h  |  2 +
 pygrt/C_extension/include/grt/common/model.h  | 21 +++++++++
 pygrt/C_extension/include/grt/common/sacio2.h | 14 +++---
 pygrt/C_extension/include/grt/common/util.h   | 26 ++++++++++-
 pygrt/C_extension/src/common/iostats.c        |  4 +-
 pygrt/C_extension/src/common/model.c          | 35 ++++++++++++++-
 pygrt/C_extension/src/common/util.c           | 43 +++++++++++++++++++
 pygrt/C_extension/src/dynamic/signals.c       | 13 +++---
 .../src/static/grt_static_greenfn.c           |  2 +-
 .../src/static/grt_static_rotation.c          |  6 ++-
 .../src/static/grt_static_strain.c            |  6 ++-
 .../src/static/grt_static_stress.c            |  6 ++-
 pygrt/C_extension/src/static/grt_static_syn.c |  6 ++-
 13 files changed, 156 insertions(+), 28 deletions(-)

diff --git a/pygrt/C_extension/include/grt/common/const.h b/pygrt/C_extension/include/grt/common/const.h
index 6233c769..0e0d02f6 100755
--- a/pygrt/C_extension/include/grt/common/const.h
+++ b/pygrt/C_extension/include/grt/common/const.h
@@ -77,6 +77,8 @@ typedef int MYINT;  ///< 整数
 #define GRT_STR_CMPLX_LONG_FMT "%51s"    ///< 与复数格式同长度的字符串输出格式（更长）
 #define GRT_CMPLX_SPLIT(x)  creal(x), cimag(x)   ///< 用于打印复数时将实部虚部分开
 
+#define GRT_COMMENT_HEAD  '#'   ///< # 号， 作为注释的字符
+
 #define GRT_MAX(a, b) ((a) > (b) ? (a) : (b))  ///< 求两者较大值
 #define GRT_MIN(a, b) ((a) < (b) ? (a) : (b))  ///< 求两者较小值
 
diff --git a/pygrt/C_extension/include/grt/common/model.h b/pygrt/C_extension/include/grt/common/model.h
index f6fbfcd0..e6034a59 100755
--- a/pygrt/C_extension/include/grt/common/model.h
+++ b/pygrt/C_extension/include/grt/common/model.h
@@ -99,6 +99,27 @@ void grt_update_mod1d_omega(GRT_MODEL1D *mod1d, MYCOMPLEX omega);
 GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpath, double depsrc, double deprcv, bool allowLiquid);
 
 
+/**
+ * 从模型文件中判断各个量的大致精度（字符串长度），以确定浮点数输出位数
+ * 
+ * @param[in]    command        命令名称
+ * @param[in]    modelpath      模型文件路径
+ * @param[out]   diglen         每一列的最大字符串长度
+ * 
+ */
+void grt_get_model_diglen_from_file(const char *command, const char *modelpath, MYINT diglen[6]);
+
+/**
+ * 浮点数比较，检查模型中是否存在该速度（不论Vp,Vs）
+ * 
+ * @param[in]   mod1d    模型
+ * @param[in]   vel      输入速度
+ * @param[in]   tol      浮点数比较精度
+ * 
+ * @return    是否存在
+ */
+bool grt_check_vel_in_mod(const GRT_MODEL1D *mod1d, const MYREAL vel, const MYREAL tol);
+
 /**
  * 计算最大最小速度（非零值）
  * 
diff --git a/pygrt/C_extension/include/grt/common/sacio2.h b/pygrt/C_extension/include/grt/common/sacio2.h
index 1ab43f40..abd1aae1 100644
--- a/pygrt/C_extension/include/grt/common/sacio2.h
+++ b/pygrt/C_extension/include/grt/common/sacio2.h
@@ -14,9 +14,9 @@
 /**
  * 读取SAC头段变量
  * 
- * @param      command        (in)当前程序命令名称
- * @param      name           (in)SAC文件路径
- * @param      hd             (out)SAC头段变量结构体
+ * @param[in]       command        当前程序命令名称
+ * @param[in]       name           SAC文件路径
+ * @param[out]      hd             SAC头段变量结构体
  */
 void grt_read_SAC_HEAD(const char *command, const char *name, SACHEAD *hd);
 
@@ -24,10 +24,10 @@ void grt_read_SAC_HEAD(const char *command, const char *name, SACHEAD *hd);
 /**
  * 读取SAC文件
  * 
- * @param      command        (in)当前程序命令名称
- * @param      name           (in)SAC文件路径
- * @param      hd             (out)SAC头段变量结构体
- * @param      arrout         (inout)预分配内存，不需要则设为NULL
+ * @param[in]       command       当前程序命令名称
+ * @param[in]       name          SAC文件路径
+ * @param[out]      hd            SAC头段变量结构体
+ * @param[in,out]   arrout        预分配内存，不需要则设为NULL
  * 
  * @return     浮点数指针
  */
diff --git a/pygrt/C_extension/include/grt/common/util.h b/pygrt/C_extension/include/grt/common/util.h
index 4016950a..bb701cad 100644
--- a/pygrt/C_extension/include/grt/common/util.h
+++ b/pygrt/C_extension/include/grt/common/util.h
@@ -26,17 +26,41 @@
  */
 char ** grt_string_split(const char *string, const char *delim, int *size);
 
+/**
+ * 指定分隔符，获得字符串的分割出的子字符串数。
+ * 相当于是 grt_string_split 函数的简化版本
+ * 
+ * @param[in]     string     原字符串
+ * @param[in]     delim      分隔符
+ * 
+ * @return   子字符串数
+ */
+int grt_string_ncols(const char *string, const char* delim);
 
 /**
  * 从路径字符串中找到用/或\\分隔的最后一项
  * 
- * @param    path     路径字符串指针
+ * @param[in]    path     路径字符串指针
  * 
  * @return   指向最后一项字符串的指针
  */
 const char* grt_get_basename(const char* path);
 
 
+/**
+ * 去除字符串首尾空白
+ * 
+ * @param[in,out]     str    字符串
+ */
+void grt_trim_whitespace(char* str);
+
+
+/**
+ * 检查是否为注释行或空行
+ * 
+ * @param[in]     line    读入一行的字符串
+ */
+bool grt_is_comment_or_empty(const char* line);
 
 /**
  * 处理单个震中距对应的数据逆变换和SAC保存
diff --git a/pygrt/C_extension/src/common/iostats.c b/pygrt/C_extension/src/common/iostats.c
index fe455a23..4ae2ab54 100755
--- a/pygrt/C_extension/src/common/iostats.c
+++ b/pygrt/C_extension/src/common/iostats.c
@@ -37,7 +37,7 @@ MYINT grt_extract_stats(FILE *bf0, FILE *af0){
     // 打印标题
     if(bf0 == NULL){
         char K[20];
-        snprintf(K, sizeof(K), GRT_STRING_FMT, "k");  K[0]='#';
+        snprintf(K, sizeof(K), GRT_STRING_FMT, "k");  K[0]=GRT_COMMENT_HEAD;
         fprintf(af0, "%s", K);
 
         for(MYINT im=0; im<GRT_SRC_M_NUM; ++im){
@@ -107,7 +107,7 @@ MYINT grt_extract_stats_ptam(FILE *bf0, FILE *af0){
 
                 snprintf(K2, sizeof(K2), "sum_%s_%d_k", GRT_SRC_M_NAME_ABBR[im], v);
                 if(icol==0){
-                    snprintf(K, sizeof(K), GRT_STRING_FMT, K2);  K2[0]='#';
+                    snprintf(K, sizeof(K), GRT_STRING_FMT, K2);  K2[0]=GRT_COMMENT_HEAD;
                     fprintf(af0, "%s", K);
                 } else {
                     fprintf(af0, GRT_STRING_FMT, K2);
diff --git a/pygrt/C_extension/src/common/model.c b/pygrt/C_extension/src/common/model.c
index d1e686c8..9feadb17 100755
--- a/pygrt/C_extension/src/common/model.c
+++ b/pygrt/C_extension/src/common/model.c
@@ -16,6 +16,7 @@
 #include "grt/common/prtdbg.h"
 #include "grt/common/attenuation.h"
 #include "grt/common/colorstr.h"
+#include "grt/common/util.h"
 
 #include "grt/common/checkerror.h"
 
@@ -222,7 +223,7 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
         iline++;
         
         // 注释行
-        if(line[0]=='#')  continue;
+        if(grt_is_comment_or_empty(line))  continue;
 
         h = va = vb = rho = qa = qb = 0.0;
         MYINT nscan = sscanf(line, "%lf %lf %lf %lf %lf %lf\n", &h, &va, &vb, &rho, &qa, &qb);
@@ -376,6 +377,38 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
 }
 
 
+void grt_get_model_diglen_from_file(const char *command, const char *modelpath, MYINT diglen[6]){
+    FILE *fp = GRTCheckOpenFile(command, modelpath, "r");
+    ssize_t read;
+    size_t len;
+    char *line = NULL;
+
+    memset(diglen, 0, sizeof(MYINT)*6);
+
+    while((read = getline(&line, &len, fp) != -1)){
+        char *token = strtok(line, " \n");
+        for(MYINT i=0; i<6; ++i){
+            if(token == NULL) break;
+            diglen[i] = GRT_MAX(diglen[i], (MYINT)strlen(token));
+            token = strtok(NULL, " \n");
+        }
+    }
+
+    GRT_SAFE_FREE_PTR(line);
+    fclose(fp);
+}
+
+
+bool grt_check_vel_in_mod(const GRT_MODEL1D *mod1d, const MYREAL vel, const MYREAL tol){
+    // 浮点数比较，检查是否存在该速度值
+    for(MYINT i=0; i<mod1d->n; ++i){
+        if(fabs(vel - mod1d->Va[i])<tol || fabs(vel - mod1d->Vb[i])<tol)  return true;
+    }
+    return false;
+}
+
+
+
 void grt_get_mod1d_vmin_vmax(const GRT_MODEL1D *mod1d, MYREAL *vmin, MYREAL *vmax){
     *vmin = 9.0e30;
     *vmax = 0.0;
diff --git a/pygrt/C_extension/src/common/util.c b/pygrt/C_extension/src/common/util.c
index 31b92190..4ab1863d 100644
--- a/pygrt/C_extension/src/common/util.c
+++ b/pygrt/C_extension/src/common/util.c
@@ -10,6 +10,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 
 #include "grt/common/util.h"
 #include "grt/common/model.h"
@@ -41,6 +42,23 @@ char ** grt_string_split(const char *string, const char *delim, int *size)
 }
 
 
+int grt_string_ncols(const char *string, const char* delim){
+    int count = 0;
+    
+    const char *str = string;
+    while (*str) {
+        // 跳过所有分隔符
+        while (*str && strchr(delim, *str)) str++;
+        // 如果还有非分隔符字符，增加计数
+        if (*str) count++;
+        // 跳过所有非分隔符字符
+        while (*str && !strchr(delim, *str)) str++;
+    }
+    
+    return count;
+}
+
+
 const char* grt_get_basename(const char* path) {
     // 找到最后一个 '/'
     char* last_slash = strrchr(path, '/'); 
@@ -60,6 +78,31 @@ const char* grt_get_basename(const char* path) {
 }
 
 
+void grt_trim_whitespace(char* str) {
+    char* end;
+    
+    // 去除首部空白
+    while (isspace((unsigned char)*str)) str++;
+    
+    // 去除尾部空白
+    end = str + strlen(str) - 1;
+    while (end > str && isspace((unsigned char)*end)) end--;
+    
+    // 写入终止符
+    *(end + 1) = '\0';
+}
+
+
+bool grt_is_comment_or_empty(const char* line) {
+    // 跳过前导空白
+    while (isspace((unsigned char)*line)) line++;
+    
+    // 检查是否为空行或注释行
+    return (*line == '\0' || *line == GRT_COMMENT_HEAD);
+}
+
+
+
 
 /**
  * 将一条数据反变换回时间域再进行处理，保存到SAC文件
diff --git a/pygrt/C_extension/src/dynamic/signals.c b/pygrt/C_extension/src/dynamic/signals.c
index efd668e4..1edb9c68 100644
--- a/pygrt/C_extension/src/dynamic/signals.c
+++ b/pygrt/C_extension/src/dynamic/signals.c
@@ -22,6 +22,7 @@
 #include "grt/dynamic/signals.h"
 #include "grt/common/const.h"
 #include "grt/common/colorstr.h"
+#include "grt/common/util.h"
 
 
 bool grt_check_tftype_tfparams(const char tftype, const char *tfparams){
@@ -324,16 +325,10 @@ float * grt_get_custom_wave(int *Nt, const char *tfparams){
 
     // 逐行读入
     char line[1024];
-    char first_char = '\0';
     int nt = 0;
     while(fgets(line, sizeof(line), fp)) {
-        first_char = '\0';
-        // 读入第一个非空字符，判断是否是注释行
-        if(sscanf(line, " %c", &first_char) == 1){
-            if(first_char == '#')  continue;
-        } else {
-            continue;  // 空行，跳过
-        }
+        // 注释行
+        if(grt_is_comment_or_empty(line))  continue;
 
         tfarr = (float*)realloc(tfarr, sizeof(float)*(nt+1));
         if(sscanf(line, " %f", &tfarr[nt]) < 1){
@@ -348,6 +343,8 @@ float * grt_get_custom_wave(int *Nt, const char *tfparams){
         return NULL;
     }
 
+    fclose(fp);
+
     *Nt = nt;
     return tfarr;
 }
diff --git a/pygrt/C_extension/src/static/grt_static_greenfn.c b/pygrt/C_extension/src/static/grt_static_greenfn.c
index b4bcbcc5..417ed4b5 100644
--- a/pygrt/C_extension/src/static/grt_static_greenfn.c
+++ b/pygrt/C_extension/src/static/grt_static_greenfn.c
@@ -504,7 +504,7 @@ int static_greenfn_main(int argc, char **argv){
 
     // 输出标题
     char XX[20];
-    sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]='#';
+    sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]=GRT_COMMENT_HEAD;
     fprintf(stdout, "%s", XX);
     fprintf(stdout, GRT_STRING_FMT, "Y(km)");
     print_grn_title("");
diff --git a/pygrt/C_extension/src/static/grt_static_rotation.c b/pygrt/C_extension/src/static/grt_static_rotation.c
index 498f7b5d..30a65b77 100644
--- a/pygrt/C_extension/src/static/grt_static_rotation.c
+++ b/pygrt/C_extension/src/static/grt_static_rotation.c
@@ -9,6 +9,7 @@
 
 
 #include "grt/common/const.h"
+#include "grt/common/util.h"
 
 #include "grt.h"
 
@@ -135,7 +136,8 @@ int static_rotation_main(int argc, char **argv){
                 GRTRaiseError("[%s] Error! The input has no spatial derivatives. \n", command);
             }
         }
-        if(line[0] == '#')  continue;
+        // 注释行
+        if(grt_is_comment_or_empty(line))  continue;
 
         // 读取该行数据
         char *copyline = strdup(line);
@@ -156,7 +158,7 @@ int static_rotation_main(int argc, char **argv){
             fprintf(stdout, "# "GRT_REAL_FMT" "GRT_REAL_FMT" "GRT_REAL_FMT"\n", rcv_va, rcv_vb, rcv_rho);
             
             char XX[20];
-            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]='#';
+            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]=GRT_COMMENT_HEAD;
             fprintf(stdout, "%s", XX);
             fprintf(stdout, GRT_STRING_FMT, "Y(km)");
             char s_channel[15];
diff --git a/pygrt/C_extension/src/static/grt_static_strain.c b/pygrt/C_extension/src/static/grt_static_strain.c
index d68e8213..94b67f3e 100644
--- a/pygrt/C_extension/src/static/grt_static_strain.c
+++ b/pygrt/C_extension/src/static/grt_static_strain.c
@@ -8,6 +8,7 @@
  */
 
 #include "grt/common/const.h"
+#include "grt/common/util.h"
 
 #include "grt.h"
 
@@ -133,7 +134,8 @@ int static_strain_main(int argc, char **argv){
                 GRTRaiseError("[%s] Error! The input has no spatial derivatives. \n", command);
             }
         }
-        if(line[0] == '#')  continue;
+        // 注释行
+        if(grt_is_comment_or_empty(line))  continue;
 
         // 读取该行数据
         char *copyline = strdup(line);
@@ -154,7 +156,7 @@ int static_strain_main(int argc, char **argv){
             fprintf(stdout, "# "GRT_REAL_FMT" "GRT_REAL_FMT" "GRT_REAL_FMT"\n", rcv_va, rcv_vb, rcv_rho);
             
             char XX[20];
-            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]='#';
+            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]=GRT_COMMENT_HEAD;
             fprintf(stdout, "%s", XX);
             fprintf(stdout, GRT_STRING_FMT, "Y(km)");
             char s_channel[15];
diff --git a/pygrt/C_extension/src/static/grt_static_stress.c b/pygrt/C_extension/src/static/grt_static_stress.c
index 4f4c784e..6fe285ef 100644
--- a/pygrt/C_extension/src/static/grt_static_stress.c
+++ b/pygrt/C_extension/src/static/grt_static_stress.c
@@ -8,6 +8,7 @@
  */
 
 #include "grt/common/const.h"
+#include "grt/common/util.h"
 
 #include "grt.h"
 
@@ -144,7 +145,8 @@ int static_stress_main(int argc, char **argv){
                 GRTRaiseError("[%s] Error! The input has no spatial derivatives. \n", command);
             }
         }
-        if(line[0] == '#')  continue;
+        // 注释行
+        if(grt_is_comment_or_empty(line))  continue;
 
         // 读取该行数据
         char *copyline = strdup(line);
@@ -169,7 +171,7 @@ int static_stress_main(int argc, char **argv){
             fprintf(stdout, "# "GRT_REAL_FMT" "GRT_REAL_FMT" "GRT_REAL_FMT"\n", rcv_va, rcv_vb, rcv_rho);
             
             char XX[20];
-            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]='#';
+            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]=GRT_COMMENT_HEAD;
             fprintf(stdout, "%s", XX);
             fprintf(stdout, GRT_STRING_FMT, "Y(km)");
             char s_channel[15];
diff --git a/pygrt/C_extension/src/static/grt_static_syn.c b/pygrt/C_extension/src/static/grt_static_syn.c
index 87b07206..81232f7c 100644
--- a/pygrt/C_extension/src/static/grt_static_syn.c
+++ b/pygrt/C_extension/src/static/grt_static_syn.c
@@ -11,6 +11,7 @@
 #include "grt/common/const.h"
 #include "grt/common/radiation.h"
 #include "grt/common/coord.h"
+#include "grt/common/util.h"
 
 #include "grt.h"
 
@@ -372,7 +373,8 @@ int static_syn_main(int argc, char **argv){
                 GRTRaiseError("[%s] Error! The input has no spatial derivatives. \n", command);
             }
         }
-        if(line[0] == '#')  continue;
+        // 注释行
+        if(grt_is_comment_or_empty(line))  continue;
 
         // 读取该行数据
         char *copyline = strdup(line);
@@ -396,7 +398,7 @@ int static_syn_main(int argc, char **argv){
             fprintf(stdout, "# "GRT_REAL_FMT" "GRT_REAL_FMT" "GRT_REAL_FMT"\n", rcv_va, rcv_vb, rcv_rho);
             
             char XX[20];
-            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]='#';
+            sprintf(XX, GRT_STRING_FMT, "X(km)"); XX[0]=GRT_COMMENT_HEAD;
             fprintf(stdout, "%s", XX);
             fprintf(stdout, GRT_STRING_FMT, "Y(km)");
             char s_channel[5];

From 5835f2d59dc81ff6c0984d9690eb48f5db1a14bb Mon Sep 17 00:00:00 2001
From: Dengda98 <zhudengda21@mails.ucas.ac.cn>
Date: Wed, 3 Sep 2025 14:54:26 +0800
Subject: [PATCH 4/5] FEAT: add `grt_getline` function

---
 pygrt/C_extension/include/grt/common/util.h   |  8 +++
 pygrt/C_extension/src/common/model.c          | 10 ++--
 pygrt/C_extension/src/common/util.c           | 56 +++++++++++++++++++
 pygrt/C_extension/src/dynamic/signals.c       |  7 ++-
 .../src/static/grt_static_rotation.c          |  7 ++-
 .../src/static/grt_static_strain.c            |  7 ++-
 .../src/static/grt_static_stress.c            |  7 ++-
 pygrt/C_extension/src/static/grt_static_syn.c |  8 ++-
 8 files changed, 96 insertions(+), 14 deletions(-)

diff --git a/pygrt/C_extension/include/grt/common/util.h b/pygrt/C_extension/include/grt/common/util.h
index bb701cad..7af79f5f 100644
--- a/pygrt/C_extension/include/grt/common/util.h
+++ b/pygrt/C_extension/include/grt/common/util.h
@@ -62,6 +62,14 @@ void grt_trim_whitespace(char* str);
  */
 bool grt_is_comment_or_empty(const char* line);
 
+
+/**
+ * 由于 Windows MSYS2 环境没有 getline 函数（即使定义了 _GNU_SOURCE）
+ * 所以这里需要使用自定义的 getline 函数，参数与 POSIX 定义相同
+ */
+ssize_t grt_getline(char **lineptr, size_t *n, FILE *stream);
+
+
 /**
  * 处理单个震中距对应的数据逆变换和SAC保存
  * 
diff --git a/pygrt/C_extension/src/common/model.c b/pygrt/C_extension/src/common/model.c
index 9feadb17..e36a0567 100755
--- a/pygrt/C_extension/src/common/model.c
+++ b/pygrt/C_extension/src/common/model.c
@@ -211,7 +211,6 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
 
     const int ncols = 6; // 模型文件有6列，或除去qa qb有四列
     const int ncols_noQ = 4;
-    char line[1024];
     int iline = 0;
     double h, va, vb, rho, qa, qb;
     double (*modarr)[ncols] = NULL;
@@ -219,7 +218,10 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
     int nlay = 0;
     mod1d->io_depth = false;
 
-    while(fgets(line, sizeof(line), fp)) {
+    size_t len;
+    char *line = NULL;
+
+    while(grt_getline(&line, &len, fp) != -1) {
         iline++;
         
         // 注释行
@@ -372,6 +374,7 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
 
     fclose(fp);
     GRT_SAFE_FREE_PTR(modarr);
+    GRT_SAFE_FREE_PTR(line);
     
     return mod1d;
 }
@@ -379,13 +382,12 @@ GRT_MODEL1D * grt_read_mod1d_from_file(const char *command, const char *modelpat
 
 void grt_get_model_diglen_from_file(const char *command, const char *modelpath, MYINT diglen[6]){
     FILE *fp = GRTCheckOpenFile(command, modelpath, "r");
-    ssize_t read;
     size_t len;
     char *line = NULL;
 
     memset(diglen, 0, sizeof(MYINT)*6);
 
-    while((read = getline(&line, &len, fp) != -1)){
+    while(grt_getline(&line, &len, fp) != -1){
         char *token = strtok(line, " \n");
         for(MYINT i=0; i<6; ++i){
             if(token == NULL) break;
diff --git a/pygrt/C_extension/src/common/util.c b/pygrt/C_extension/src/common/util.c
index 4ab1863d..fadaa9e3 100644
--- a/pygrt/C_extension/src/common/util.c
+++ b/pygrt/C_extension/src/common/util.c
@@ -102,6 +102,62 @@ bool grt_is_comment_or_empty(const char* line) {
 }
 
 
+ssize_t grt_getline(char **lineptr, size_t *n, FILE *stream){
+    if (!lineptr || !n || !stream) {
+        return -1;
+    }
+    
+    char *buf = *lineptr;
+    size_t size = *n;
+    size_t len = 0;
+    int c;
+    
+    // 如果缓冲区为空，分配初始缓冲区
+    if (buf == NULL || size == 0) {
+        size = 128;
+        buf = malloc(size);
+        if (buf == NULL) {
+            return -1;
+        }
+    }
+    
+    // 逐字符读取直到换行符或EOF
+    while ((c = fgetc(stream)) != EOF) {
+        // 检查是否需要扩展缓冲区
+        if (len + 1 >= size) {
+            size_t new_size = size * 2;
+            char *new_buf = realloc(buf, new_size);
+            if (new_buf == NULL) {
+                free(buf);
+                return -1;
+            }
+            buf = new_buf;
+            size = new_size;
+        }
+        
+        buf[len++] = c;
+        
+        // 遇到换行符停止读取
+        if (c == '\n') {
+            break;
+        }
+    }
+    
+    // 如果没有读取到任何字符且遇到EOF
+    if (len == 0 && c == EOF) {
+        return -1;
+    }
+    
+    // 添加字符串终止符
+    buf[len] = '\0';
+    
+    *lineptr = buf;
+    *n = size;
+    
+    return len;
+}
+
+
 
 
 /**
diff --git a/pygrt/C_extension/src/dynamic/signals.c b/pygrt/C_extension/src/dynamic/signals.c
index 1edb9c68..b481d21f 100644
--- a/pygrt/C_extension/src/dynamic/signals.c
+++ b/pygrt/C_extension/src/dynamic/signals.c
@@ -324,9 +324,11 @@ float * grt_get_custom_wave(int *Nt, const char *tfparams){
     }
 
     // 逐行读入
-    char line[1024];
+    size_t len;
+    char *line = NULL;
+
     int nt = 0;
-    while(fgets(line, sizeof(line), fp)) {
+    while(grt_getline(&line, &len, fp) != -1) {
         // 注释行
         if(grt_is_comment_or_empty(line))  continue;
 
@@ -344,6 +346,7 @@ float * grt_get_custom_wave(int *Nt, const char *tfparams){
     }
 
     fclose(fp);
+    GRT_SAFE_FREE_PTR(line);
 
     *Nt = nt;
     return tfarr;
diff --git a/pygrt/C_extension/src/static/grt_static_rotation.c b/pygrt/C_extension/src/static/grt_static_rotation.c
index 30a65b77..04e7822f 100644
--- a/pygrt/C_extension/src/static/grt_static_rotation.c
+++ b/pygrt/C_extension/src/static/grt_static_rotation.c
@@ -100,9 +100,11 @@ int static_rotation_main(int argc, char **argv){
     bool rot2ZNE = false;
 
     // 逐行读入
-    char line[1024];
+    size_t len;
+    char *line = NULL;
+
     int iline = 0;
-    while(fgets(line, sizeof(line), stdin)){
+    while(grt_getline(&line, &len, stdin) != -1){
         iline++;
         if(iline == 1){
             // 读取震源物性参数
@@ -203,6 +205,7 @@ int static_rotation_main(int argc, char **argv){
         GRTRaiseError("[%s] Error! Empty input. \n", command);
     }
 
+    GRT_SAFE_FREE_PTR(line);
     free_Ctrl(Ctrl);
     return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/src/static/grt_static_strain.c b/pygrt/C_extension/src/static/grt_static_strain.c
index 94b67f3e..b3457691 100644
--- a/pygrt/C_extension/src/static/grt_static_strain.c
+++ b/pygrt/C_extension/src/static/grt_static_strain.c
@@ -98,9 +98,11 @@ int static_strain_main(int argc, char **argv){
     bool rot2ZNE = false;
 
     // 逐行读入
-    char line[1024];
+    size_t len;
+    char *line = NULL;
+
     int iline = 0;
-    while(fgets(line, sizeof(line), stdin)){
+    while(grt_getline(&line, &len, stdin) != -1){
         iline++;
         if(iline == 1){
             // 读取震源物性参数
@@ -203,6 +205,7 @@ int static_strain_main(int argc, char **argv){
         GRTRaiseError("[%s] Error! Empty input. \n", command);
     }
 
+    GRT_SAFE_FREE_PTR(line);
     free_Ctrl(Ctrl);
     return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/src/static/grt_static_stress.c b/pygrt/C_extension/src/static/grt_static_stress.c
index 6fe285ef..e4753fa6 100644
--- a/pygrt/C_extension/src/static/grt_static_stress.c
+++ b/pygrt/C_extension/src/static/grt_static_stress.c
@@ -101,9 +101,11 @@ int static_stress_main(int argc, char **argv){
     double lam_ukk=0.0;
 
     // 逐行读入
-    char line[1024];
+    size_t len;
+    char *line = NULL;
+
     int iline = 0;
-    while(fgets(line, sizeof(line), stdin)){
+    while(grt_getline(&line, &len, stdin) != -1){
         iline++;
         if(iline == 1){
             // 读取震源物性参数
@@ -221,6 +223,7 @@ int static_stress_main(int argc, char **argv){
         GRTRaiseError("[%s] Error! Empty input. \n", command);
     }
 
+    GRT_SAFE_FREE_PTR(line);
     free_Ctrl(Ctrl);
     return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/src/static/grt_static_syn.c b/pygrt/C_extension/src/static/grt_static_syn.c
index 81232f7c..50ba1d56 100644
--- a/pygrt/C_extension/src/static/grt_static_syn.c
+++ b/pygrt/C_extension/src/static/grt_static_syn.c
@@ -327,9 +327,12 @@ int static_syn_main(int argc, char **argv){
     // 震中距
     double dist = 0.0;
 
-    char line[1024];
+    // 逐行读入
+    size_t len;
+    char *line = NULL;
+
     int iline = 0;
-    while(fgets(line, sizeof(line), stdin)){
+    while(grt_getline(&line, &len, stdin) != -1){
         iline++;
         if(iline == 1){
             // 读取震源物性参数
@@ -505,6 +508,7 @@ int static_syn_main(int argc, char **argv){
         GRTRaiseError("[%s] Error! Empty input. \n", command);
     }
 
+    GRT_SAFE_FREE_PTR(line);
     free_Ctrl(Ctrl);
     return EXIT_SUCCESS;
 }
\ No newline at end of file

From 3972d5474e4b7be69fc869981d2e92759a26661d Mon Sep 17 00:00:00 2001
From: Dengda98 <zhudengda21@mails.ucas.ac.cn>
Date: Wed, 3 Sep 2025 16:06:55 +0800
Subject: [PATCH 5/5] FEAT: rearange fnctions in `search.h/c` and `matrix.h`,
 with X macros

---
 pygrt/C_extension/include/grt/common/matrix.h |  72 +++++++-
 pygrt/C_extension/include/grt/common/search.h |  87 +++++++--
 pygrt/C_extension/src/common/search.c         | 173 +++++++++++++-----
 pygrt/C_extension/src/dynamic/grn.c           |   2 +-
 pygrt/C_extension/src/dynamic/grt_greenfn.c   |   2 +-
 pygrt/C_extension/src/static/static_grn.c     |   2 +-
 6 files changed, 279 insertions(+), 59 deletions(-)

diff --git a/pygrt/C_extension/include/grt/common/matrix.h b/pygrt/C_extension/include/grt/common/matrix.h
index abc11b2b..2aa72827 100755
--- a/pygrt/C_extension/include/grt/common/matrix.h
+++ b/pygrt/C_extension/include/grt/common/matrix.h
@@ -3,7 +3,7 @@
  * @author Zhu Dengda (zhudengda@mail.iggcas.ac.cn)
  * @date   2024-07-24
  * 
- * 2x2小矩阵的加、减、乘、除、求逆等操作，由于均为小型数组操作，所有函数均为内联函数               
+ * 小矩阵的加、减、乘、除、求逆等操作，由于均为小型数组操作，所有函数均为内联函数               
  */
 
 #pragma once
@@ -142,7 +142,7 @@ inline GCC_ALWAYS_INLINE void grt_cmat2x2_assign(const MYCOMPLEX M1[2][2], MYCOM
 }
 
 /** 
- * 计算nxn复矩阵的积(小矩阵)(最暴力的方式)
+ * 计算mxn复矩阵的积(小矩阵)(最暴力的方式)
  * 
  * @param[in]     m1            M1矩阵行数
  * @param[in]     n1            M1矩阵列数
@@ -171,6 +171,31 @@ inline GCC_ALWAYS_INLINE void grt_cmatmxn_mul(MYINT m1, MYINT n1, MYINT p1, cons
     }
 }
 
+/** 
+ * 计算mxn复矩阵的转置矩阵(不共轭)
+ * 
+ * @param[in]     m1            M1矩阵行数
+ * @param[in]     n1            M1矩阵列数
+ * @param[in]     M1            M1矩阵 
+ * @param[out]    M2            M2矩阵 (M1^T)
+ */
+inline GCC_ALWAYS_INLINE void grt_cmatmxn_transpose(MYINT m1, MYINT n1, const MYCOMPLEX M1[m1][n1], MYCOMPLEX M2[n1][m1]){
+    MYINT m, n;
+    MYCOMPLEX M0[n1][m1];
+    for(m=0; m<m1; ++m){
+        for(n=0; n<n1; ++n){
+            M0[n][m] = M1[m][n];
+        }
+    }
+
+    // memcpy(M, M0, sizeof(MYCOMPLEX)*m1*p1);
+    for(m=0; m<m1; ++m){
+        for(n=0; n<n1; ++n){
+            M2[n][m] = M0[n][m];
+        }
+    }
+}
+
 /** 
  * 从M1大矩阵中划分Q子矩阵
  * 
@@ -191,6 +216,28 @@ inline GCC_ALWAYS_INLINE void grt_cmatmxn_block(MYINT m1, MYINT n1, const MYCOMP
     }
 }
 
+
+/** 
+ * 将小矩阵Q填充到M1大矩阵中
+ * 
+ * @param[in]     m1           M1矩阵行数
+ * @param[in]     n1           M1矩阵列数
+ * @param[in]     M1           M1矩阵 
+ * @param[in]     im           子矩阵起始行索引
+ * @param[in]     in           子矩阵起始列索引
+ * @param[in]     lm           子矩阵行数
+ * @param[in]     ln           子矩阵列数
+ * @param[out]    Q            子矩阵
+ */
+inline GCC_ALWAYS_INLINE void grt_cmatmxn_block_assign(MYINT m1, MYINT n1, MYCOMPLEX M[m1][n1], MYINT im, MYINT in, MYINT lm, MYINT ln, const MYCOMPLEX Q[lm][ln]){
+    for(MYINT m=0; m<lm; ++m){
+        for(MYINT n=0; n<ln; ++n){
+            M[im+m][in+n] = Q[m][n];
+        }
+    }
+}
+
+
 /**
  * 打印矩阵 
  * 
@@ -206,4 +253,25 @@ inline GCC_ALWAYS_INLINE void grt_cmatmxn_print(MYINT m1, MYINT n1, const MYCOMP
         }
         fprintf(stderr, "\n");
     }
+}
+
+
+/**
+ * 计算mxn复矩阵和nx1的复向量的积
+ * 
+ * @param[in]      M1     矩阵1
+ * @param[in]      M2     向量
+ * @param[out]     M      积矩阵, M1 * M2
+ */
+inline GCC_ALWAYS_INLINE void grt_cmatmx1_mul(MYINT m1, MYINT n1, const MYCOMPLEX M1[m1][n1], const MYCOMPLEX M2[n1], MYCOMPLEX M[n1]){
+    MYCOMPLEX M0[n1];
+    for(MYINT i=0; i<m1; ++i){
+        M0[i] = 0.0;
+        for(MYINT j=0; j<n1; ++j){
+            M0[i] += M1[i][j] * M2[j];
+        }
+    }
+    for(MYINT i=0; i<n1; ++i){
+        M[i] = M0[i];
+    }
 }
\ No newline at end of file
diff --git a/pygrt/C_extension/include/grt/common/search.h b/pygrt/C_extension/include/grt/common/search.h
index 2143eb22..8f2df742 100644
--- a/pygrt/C_extension/include/grt/common/search.h
+++ b/pygrt/C_extension/include/grt/common/search.h
@@ -11,11 +11,16 @@
 #include <stdbool.h>
 #include "grt/common/const.h"
 
+// 定义 X 宏，为多个类型定义查找函数
+#define __FOR_EACH_TYPE \
+    X(MYINT)  X(MYREAL)  X(float)  X(double)
+
+
 /**
- * 该函数对输入的整数数组进行线性搜索，找到目标值时返回其索引。
+ * 该函数对输入数组进行线性搜索，找到目标值时返回其索引。
  * 如果目标值在数组中未找到，则返回 -1。
  *
- * @param[in] array   要搜索的整数数组。
+ * @param[in] array   要搜索的数组。
  * @param[in] size    数组的大小（元素个数）。
  * @param[in] target  要查找的目标值。
  * 
@@ -24,13 +29,19 @@
  * @note 如果数组中存在多个目标值，该函数返回第一个匹配的索引。
  * 
  */
-MYINT grt_findElement_MYINT(const MYINT array[], MYINT size, MYINT target);
+#define X(T) \
+MYINT grt_findElement_##T(const T *array, MYINT size, T target);
+
+__FOR_EACH_TYPE
+#undef X
+
+
 
 /**
- * 搜索浮点数数组中最接近目标值且小于目标值的索引。
+ * 搜索数组中最接近目标值且小于目标值的索引。
  * 如果目标值在数组中未找到，则返回 -1。
  *
- * @param[in] array   要搜索的浮点数数组。
+ * @param[in] array   要搜索的数组。
  * @param[in] size    数组的大小（元素个数）。
  * @param[in] target  要查找的目标值。
  * 
@@ -39,12 +50,18 @@ MYINT grt_findElement_MYINT(const MYINT array[], MYINT size, MYINT target);
  * @note 如果数组中存在多个目标值，该函数返回第一个匹配的索引。
  * 
  */
-MYINT grt_findLessEqualClosest_MYREAL(const MYREAL array[], MYINT size, MYREAL target);
+#define X(T) \
+MYINT grt_findLessEqualClosest_##T(const T *array, MYINT size, T target);
+
+__FOR_EACH_TYPE
+#undef X
+
+
 
 /**
- * 搜索浮点数数组中最接近目标值的索引。
+ * 搜索数组中最接近目标值的索引。
  *
- * @param[in] array   要搜索的浮点数数组。
+ * @param[in] array   要搜索的数组。
  * @param[in] size    数组的大小（元素个数）。
  * @param[in] target  要查找的目标值。
  * 
@@ -53,18 +70,62 @@ MYINT grt_findLessEqualClosest_MYREAL(const MYREAL array[], MYINT size, MYREAL t
  * @note 如果数组中存在多个目标值，该函数返回第一个匹配的索引。
  * 
  */
-MYINT grt_findClosest_MYREAL(const MYREAL array[], MYINT size, MYREAL target);
+#define X(T) \
+MYINT grt_findClosest_##T(const T *array, MYINT size, T target);
+
+__FOR_EACH_TYPE
+#undef X
+
 
 /**
- * 搜索浮点数数组的最大或最小值，返回其索引。
+ * 搜索数组的最值，返回其索引。
  *
- * @param[in] array   要搜索的浮点数数组。
+ * @param[in] array   要搜索的数组。
  * @param[in] size    数组的大小（元素个数）。
- * @param[in] isMax   是否要找最大值，否则找最小值。
  * 
  * @return idx    目标值的索引。
  *
  * @note 如果数组中存在相同最值，该函数返回第一个匹配的索引。
  * 
  */
-MYINT grt_findMinMax_MYREAL(const MYREAL array[], MYINT size, bool isMax);
\ No newline at end of file
+#define X(T) \
+MYINT grt_findMin_##T(const T *array, MYINT size);\
+MYINT grt_findMax_##T(const T *array, MYINT size);\
+
+__FOR_EACH_TYPE
+#undef X
+
+
+/**
+ * 比较函数
+ * 
+ * @param[in]   a    元素 a 地址 
+ * @param[in]   b    元素 b 地址 
+ * 
+ * @return flag   比较结果，(1) a > b, (0) a == b, (-1) a < b
+ */
+#define X(T) \
+int grt_compare_##T(const void *a, const void *b);
+
+__FOR_EACH_TYPE
+#undef X
+#undef __FOR_EACH_TYPE
+
+
+
+/**
+ * 在有序数组中插入元素，元素类型和数组类型需匹配
+ * 
+ * @param[in,out]   arr          有序数组地址
+ * @param[in,out]   size         数组大小地址
+ * @param[in]       capacity     数组最大容量
+ * @param[in]       target       元素地址
+ * @param[in]       elementSize  元素和数组内元素的字节长度
+ * @param[in]       ascending    升序(true) 或 降序(false)
+ * @param[in]       compare      比较函数
+ * 
+ * @return pos   插入位置的索引
+ */
+MYINT grt_insertOrdered(
+    void *arr, MYINT *size, MYINT capacity, const void *target, size_t elementSize, bool ascending,
+    int (*compare)(const void *, const void *));
diff --git a/pygrt/C_extension/src/common/search.c b/pygrt/C_extension/src/common/search.c
index 21b6a7d8..dfa2047b 100644
--- a/pygrt/C_extension/src/common/search.c
+++ b/pygrt/C_extension/src/common/search.c
@@ -8,59 +8,150 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+#include <string.h>
 
 #include "grt/common/search.h"
 #include "grt/common/const.h"
 
-static bool _gt_(MYREAL a1, MYREAL a2) { return a1 > a2; }
-static bool _lt_(MYREAL a1, MYREAL a2) { return a1 < a2; }
+// 定义 X 宏，为多个类型定义查找函数
+#define __FOR_EACH_TYPE \
+    X(MYINT)  X(MYREAL)  X(float)  X(double)
 
 
-MYINT grt_findElement_MYINT(const MYINT array[], MYINT size, MYINT target) {
-    for (MYINT i = 0; i < size; ++i) {
-        if (array[i] == target) {
-            return i;  // 找到目标元素，返回索引
-        }
-    }
-    return -1;  // 未找到目标元素，返回-1
+#define X(T) \
+MYINT grt_findElement_##T(const T *array, MYINT size, T target) {\
+    for (MYINT i = 0; i < size; ++i) {\
+        if (array[i] == target) {\
+            /** 找到目标元素，返回索引 */\
+            return i;\
+        }\
+    }\
+    /** 未找到目标元素，返回-1 */\
+    return -1; \
 }
 
-MYINT grt_findLessEqualClosest_MYREAL(const MYREAL array[], MYINT size, MYREAL target) {
-    MYINT ires=-1;
-    MYREAL mindist=-1.0, dist=0.0;
-    for (MYINT i = 0; i < size; ++i) {
-        dist = target-array[i];
-        if(dist >= 0.0 && (mindist < 0.0 || dist < mindist)){
-            ires = i;
-            mindist = dist;
-        }
-    }
-    return ires;
+__FOR_EACH_TYPE
+#undef X
+
+
+
+#define X(T) \
+MYINT grt_findLessEqualClosest_##T(const T *array, MYINT size, T target) {\
+    MYINT ires=-1;\
+    T mindist=-1, dist=0;\
+    for (MYINT i = 0; i < size; ++i) {\
+        dist = target-array[i];\
+        if(dist >= 0 && (mindist < 0 || dist < mindist)){\
+            ires = i;\
+            mindist = dist;\
+        }\
+    }\
+    return ires;\
 }
 
-MYINT grt_findClosest_MYREAL(const MYREAL array[], MYINT size, MYREAL target) {
-    MYINT ires=0;
-    MYREAL mindist=-1.0, dist=0.0;
-    for (MYINT i = 0; i < size; ++i) {
-        dist = fabs(target-array[i]);
-        if(mindist < 0.0 || dist < mindist){
-            ires = i;
-            mindist = dist;
-        }
-    }
-    return ires;
+__FOR_EACH_TYPE
+#undef X
+
+
+
+#define X(T) \
+MYINT grt_findClosest_##T(const T *array, MYINT size, T target) {\
+    MYINT ires=0;\
+    T mindist=-1, dist=0;\
+    for (MYINT i = 0; i < size; ++i) {\
+        dist = fabs(target-array[i]);\
+        if(mindist < 0 || dist < mindist){\
+            ires = i;\
+            mindist = dist;\
+        }\
+    }\
+    return ires;\
+}
+
+__FOR_EACH_TYPE
+#undef X
+
+
+#define X(T) \
+MYINT grt_findMin_##T(const T *array, MYINT size) {\
+    T rval = array[0];\
+    MYINT idx=0;\
+    for(MYINT ir=0; ir<size; ++ir){\
+        if(array[ir] < rval){\
+            rval = array[ir];\
+            idx = ir;\
+        }\
+    }\
+    return idx;\
+}\
+MYINT grt_findMax_##T(const T *array, MYINT size) {\
+    T rval = array[0];\
+    MYINT idx=0;\
+    for(MYINT ir=0; ir<size; ++ir){\
+        if(array[ir] > rval){\
+            rval = array[ir];\
+            idx = ir;\
+        }\
+    }\
+    return idx;\
 }
 
-MYINT grt_findMinMax_MYREAL(const MYREAL array[], MYINT size, bool isMax) {
-    MYREAL rmax = array[0];
-    MYINT idx=0;
-    bool (*_func)(MYREAL, MYREAL) = (isMax)? _gt_ : _lt_;
-    for(MYINT ir=0; ir<size; ++ir){
-        if(_func(array[ir], rmax)){
-            rmax = array[ir];
-            idx = ir;
+__FOR_EACH_TYPE
+#undef X
+
+
+#define X(T) \
+int grt_compare_##T(const void *a, const void *b) {\
+    T vala = *(T *)a;\
+    T valb = *(T *)b;\
+    if(vala > valb){\
+        return 1;\
+    } else if (vala < valb){\
+        return -1;\
+    } else {\
+        return 0;\
+    }\
+}\
+
+__FOR_EACH_TYPE
+#undef X
+#undef __FOR_EACH_TYPE
+
+
+MYINT grt_insertOrdered(
+    void *arr, MYINT *size, MYINT capacity, const void *target, size_t elementSize, bool ascending,
+    int (*compare)(const void *, const void *))
+{    
+    MYINT sgn = (ascending)? 1 : -1;
+
+    // 数组满载情况下，只可能插入更小(升序)或更大(降序)的数值
+    if(*size == capacity && sgn*compare(target, arr+(*size-1)*elementSize) >= 0) return -1;
+
+    // 找到插入位置
+    MYINT pos=*size;
+    for(MYINT i=0; i<*size; ++i){
+        if(sgn*compare(target, arr+i*elementSize) < 0){
+            pos = i;
+            break;
         }
     }
-    return idx;
-}
 
+    // 截断式插入，防止越界
+    MYINT lastpos = *size;
+    if(lastpos >= capacity){
+        lastpos = capacity-1;
+    } else {
+        ++(*size);
+    }
+    pos = GRT_MIN(pos, lastpos);
+
+    // 移动插入位置后的元素
+    memmove(arr + (pos + 1) * elementSize,
+            arr + pos * elementSize,
+            (lastpos - pos) * elementSize);
+
+    // 插入新元素
+    memcpy(arr + pos * elementSize, target, elementSize);
+
+    return pos;
+}
\ No newline at end of file
diff --git a/pygrt/C_extension/src/dynamic/grn.c b/pygrt/C_extension/src/dynamic/grn.c
index 303fe509..6f4a4a3e 100755
--- a/pygrt/C_extension/src/dynamic/grn.c
+++ b/pygrt/C_extension/src/dynamic/grn.c
@@ -92,7 +92,7 @@ void grt_integ_grn_spec(
     gettimeofday(&begin_t, NULL);
 
     // 最大震中距
-    MYINT irmax = grt_findMinMax_MYREAL(rs, nr, true);
+    MYINT irmax = grt_findMax_MYREAL(rs, nr);
     MYREAL rmax=rs[irmax];   
 
     const MYREAL Rho = mod1d->Rho[mod1d->isrc]; // 震源区密度
diff --git a/pygrt/C_extension/src/dynamic/grt_greenfn.c b/pygrt/C_extension/src/dynamic/grt_greenfn.c
index 7fcef708..03a7890b 100644
--- a/pygrt/C_extension/src/dynamic/grt_greenfn.c
+++ b/pygrt/C_extension/src/dynamic/grt_greenfn.c
@@ -733,7 +733,7 @@ int greenfn_main(int argc, char **argv) {
     Ctrl->N.winT = Ctrl->N.nt*Ctrl->N.dt;
 
     // 最大震中距
-    MYREAL rmax = Ctrl->R.rs[grt_findMinMax_MYREAL(Ctrl->R.rs, Ctrl->R.nr, true)];   
+    MYREAL rmax = Ctrl->R.rs[grt_findMax_MYREAL(Ctrl->R.rs, Ctrl->R.nr)];   
 
     // 时窗最大截止时刻
     MYREAL tmax = Ctrl->E.delayT0 + Ctrl->N.winT;
diff --git a/pygrt/C_extension/src/static/static_grn.c b/pygrt/C_extension/src/static/static_grn.c
index ca7f2f1b..4be6c325 100644
--- a/pygrt/C_extension/src/static/static_grn.c
+++ b/pygrt/C_extension/src/static/static_grn.c
@@ -76,7 +76,7 @@ void grt_integ_static_grn(
 
     const char *statsstr // 积分结果输出
 ){
-    MYREAL rmax=rs[grt_findMinMax_MYREAL(rs, nr, true)];   // 最大震中距
+    MYREAL rmax=rs[grt_findMax_MYREAL(rs, nr)];   // 最大震中距
 
     const MYREAL hs = GRT_MAX(fabs(mod1d->depsrc - mod1d->deprcv), GRT_MIN_DEPTH_GAP_SRC_RCV); // hs=max(震源和台站深度差,1.0)