add doc

README.md

@@ -13,25 +13,25 @@ GCTL Mesh是地球物理计算工具库(Geophysical Computational Tools & Librar
 - 支持网格数据的导入导出（包括Gmsh格式和二进制格式）
 - 支持标量、矢量和张量数据的处理
 
-## 主要组件
+## 文档
 
-### 基础网格类型
+### 基础类
-- `mesh.h`: 网格基类，定义了基本的网格接口和功能
+- [`mesh.h`](doc/mesh.md): 网格基类，定义了基本的网格接口和功能
-- `meshdata.h`: 网格数据结构的定义和处理
+- [`meshdata.h`](doc/meshdata.md): 网格数据结构的定义和处理
 
 ### 规则网格
-- `regular_grid`: 通用规则网格实现
+- [`regular_grid.h`](doc/regular_grid.md): 通用规则网格实现，支持2D和3D
-- `regular_mesh_2d`: 二维规则网格
+- [`regular_mesh_2d.h`](doc/regular_mesh_2d.md): 二维规则网格，专注于2D结构化网格
-- `regular_mesh_3d`: 三维规则网格
+- [`regular_mesh_3d.h`](doc/regular_mesh_3d.md): 三维规则网格，专注于3D结构化网格
-- `regular_mesh_sph_3d`: 三维球面规则网格
+- [`regular_mesh_sph_3d.h`](doc/regular_mesh_sph_3d.md): 三维球面规则网格，适用于地球物理建模
 
 ### 线性网格
-- `linear_mesh_2d`: 二维线性网格
+- [`linear_mesh_2d.h`](doc/linear_mesh_2d.md): 二维线性网格，用于表示2D空间中的线段
-- `linear_mesh_3d`: 三维线性网格
+- [`linear_mesh_3d.h`](doc/linear_mesh_3d.md): 三维线性网格，用于表示3D空间中的曲线
 
 ### 非规则网格
-- `tri_mesh`: 三角形网格
+- [`tri_mesh.h`](doc/tri_mesh.md): 三角形网格，用于复杂2D区域的离散化
-- `tet_mesh`: 四面体网格
+- [`tet_mesh.h`](doc/tet_mesh.md): 四面体网格，用于复杂3D区域的离散化
 
 ## 核心功能
 
@@ -52,6 +52,7 @@ GCTL Mesh是地球物理计算工具库(Geophysical Computational Tools & Librar
 - 网格文件导入导出
   - 支持Gmsh格式
   - 支持二进制格式
+  - 支持NetCDF格式（部分网格类型）
 - 网格数据可视化输出
 
 ### 网格类型
@@ -69,36 +70,31 @@ GCTL Mesh是地球物理计算工具库(Geophysical Computational Tools & Librar
 - 球面三角形/四面体网格 (TRI_TET_MESH_SPH)
 - 规则网格 (REGULAR_GRID)
 
+## 应用场景
+
+- **规则网格**：适用于简单几何形状的离散化，如矩形/立方体区域
+- **线性网格**：
+  - 2D：用于表示边界、裂缝等线性特征
+  - 3D：用于表示输电线路、管道系统、裂缝网络等
+- **三角形网格**：适用于复杂2D区域的有限元分析、流体动力学等
+- **四面体网格**：适用于复杂3D区域的有限元分析、计算流体力学等
+- **球面网格**：特别适用于地球物理学、大气科学等全球尺度的模拟
+
 ## API示例
 
-### 数据操作
+详细的API使用示例请参考各个网格类型的文档。基本使用模式如下：
+
 ```cpp
+// 创建网格对象
+gctl::regular_grid rgd;
+rgd.init("grid-1", "test grid", 4, 4, 0.0, 0.0, 1.0, 1.0);
+
 // 添加数据
-meshdata &add_data(mesh_data_type_e type,    // 数据位置类型（顶点/单元）
+rgd.add_data(gctl::NodeData, gctl::Scalar, "temperature", 25.0);
-                   mesh_data_value_e valtype, // 数据值类型（标量/矢量/张量）
+rgd.add_data(gctl::ElemData, gctl::Vector, "velocity", velocity_array);
-                   string name,               // 数据名称
-                   double init_val,           // 初始值
-                   bool if_output = true);    // 是否可输出
 
-// 获取数据
+// 保存网格
-meshdata &get_data(string datname);
+rgd.save_gmsh("output.msh", gctl::OverWrite);
-
-// 删除数据
-void remove_data(string datname);
-```
-
-### 文件操作
-```cpp
-// 保存为Gmsh格式（含数据）
-void save_gmsh_withdata(string filename, 
-                       output_type_e out_mode,
-                       index_packed_e packed = Packed);
-
-// 保存为二进制格式
-void save_binary(string filename);
-
-// 读取二进制格式
-void load_binary(string filename);
 ```
 
 ## 许可证

doc/linear_mesh_2d.md

@@ -0,0 +1,109 @@
+# GCTL Linear Mesh 2D 文档
+
+## 简介
+
+`linear_mesh_2d.h` 定义了GCTL网格库中的二维线性网格类 `linear_mesh_2d`，用于创建和管理二维非结构化线性网格。该类支持不规则分布的网格点，适用于复杂几何形状的离散化。
+
+## 类继承
+
+`linear_mesh_2d` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了二维线性网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化二维线性网格
+void init(std::string name,                // 网格名称
+          std::string info,                // 网格信息
+          const array<point2dc> &nodes,    // 节点坐标数组
+          const array<int2> &elements);    // 单元连接关系数组
+```
+
+### 网格信息
+```cpp
+// 获取节点坐标
+void get_node_coord(int node_idx,          // 节点索引
+                   double &x, double &y) const;
+
+// 获取单元节点索引
+void get_elem_nodes(int elem_idx,          // 单元索引
+                   int &n1, int &n2) const;
+
+// 获取单元中心坐标
+void get_elem_center(int elem_idx,         // 单元索引
+                    double &x, double &y) const;
+
+// 获取单元长度
+double get_elem_length(int elem_idx) const;
+```
+
+### 网格查询
+```cpp
+// 查找包含指定点的单元
+bool find_element(double x, double y,      // 目标点坐标
+                 int &elem_idx) const;     // 返回单元索引
+
+// 获取节点相邻的单元
+array<int> get_node_elements(int node_idx) const;
+
+// 获取单元相邻的单元
+array<int> get_elem_neighbors(int elem_idx) const;
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建节点坐标数组
+array<point2dc> nodes;
+nodes.push_back(point2dc(0.0, 0.0));
+nodes.push_back(point2dc(1.0, 0.0));
+nodes.push_back(point2dc(1.0, 1.0));
+nodes.push_back(point2dc(0.0, 1.0));
+
+// 创建单元连接关系
+array<int2> elements;
+elements.push_back(int2(0, 1));  // 第一条边
+elements.push_back(int2(1, 2));  // 第二条边
+elements.push_back(int2(2, 3));  // 第三条边
+elements.push_back(int2(3, 0));  // 第四条边
+
+// 创建线性网格
+gctl::linear_mesh_2d mesh2d;
+mesh2d.init("boundary", "2D boundary mesh", nodes, elements);
+
+// 获取单元信息
+double length = mesh2d.get_elem_length(0);  // 获取第一条边的长度
+
+// 查找包含特定点的单元
+int elem_idx;
+if (mesh2d.find_element(0.5, 0.5, elem_idx)) {
+    // 找到包含点(0.5,0.5)的单元
+}
+
+// 添加数据并保存
+mesh2d.add_data(gctl::NodeData, gctl::Scalar, "displacement", 0.0);
+mesh2d.save_gmsh("boundary.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 线性网格主要用于表示一维结构（如边界）在二维空间中的分布
+2. 每个单元由两个节点定义，表示一条线段
+3. 节点和单元的编号从0开始
+4. 支持不规则分布的节点，适合复杂几何形状
+5. 提供了网格拓扑关系查询功能（节点相邻单元、单元相邻单元等）
+6. 支持Gmsh和二进制格式的文件操作
+7. 适用于边界元素法、有限元法等数值计算 

doc/linear_mesh_3d.md

@@ -0,0 +1,121 @@
+# GCTL Linear Mesh 3D 文档
+
+## 简介
+
+`linear_mesh_3d.h` 定义了GCTL网格库中的三维线性网格类 `linear_mesh_3d`，用于创建和管理三维空间中的非结构化线性网格。该类支持不规则分布的网格点，适用于复杂三维几何结构中的线性特征离散化。
+
+## 类继承
+
+`linear_mesh_3d` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了三维线性网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化三维线性网格
+void init(std::string name,                // 网格名称
+          std::string info,                // 网格信息
+          const array<point3dc> &nodes,    // 节点坐标数组
+          const array<int2> &elements);    // 单元连接关系数组
+```
+
+### 网格信息
+```cpp
+// 获取节点坐标
+void get_node_coord(int node_idx,          // 节点索引
+                   double &x, double &y, double &z) const;
+
+// 获取单元节点索引
+void get_elem_nodes(int elem_idx,          // 单元索引
+                   int &n1, int &n2) const;
+
+// 获取单元中心坐标
+void get_elem_center(int elem_idx,         // 单元索引
+                    double &x, double &y, double &z) const;
+
+// 获取单元长度
+double get_elem_length(int elem_idx) const;
+
+// 获取单元方向向量
+void get_elem_direction(int elem_idx,      // 单元索引
+                       double &dx, double &dy, double &dz) const;
+```
+
+### 网格查询
+```cpp
+// 查找最近的单元
+bool find_nearest_element(double x, double y, double z,  // 目标点坐标
+                         int &elem_idx,                  // 返回单元索引
+                         double &distance) const;        // 返回最短距离
+
+// 获取节点相邻的单元
+array<int> get_node_elements(int node_idx) const;
+
+// 获取单元相邻的单元
+array<int> get_elem_neighbors(int elem_idx) const;
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建节点坐标数组
+array<point3dc> nodes;
+nodes.push_back(point3dc(0.0, 0.0, 0.0));
+nodes.push_back(point3dc(1.0, 0.0, 0.0));
+nodes.push_back(point3dc(1.0, 1.0, 1.0));
+nodes.push_back(point3dc(0.0, 1.0, 1.0));
+
+// 创建单元连接关系
+array<int2> elements;
+elements.push_back(int2(0, 1));  // 第一条边
+elements.push_back(int2(1, 2));  // 第二条边
+elements.push_back(int2(2, 3));  // 第三条边
+
+// 创建线性网格
+gctl::linear_mesh_3d mesh3d;
+mesh3d.init("curve3d", "3D curve mesh", nodes, elements);
+
+// 获取单元信息
+double length = mesh3d.get_elem_length(0);  // 获取第一条边的长度
+
+// 获取单元方向
+double dx, dy, dz;
+mesh3d.get_elem_direction(0, dx, dy, dz);  // 获取第一条边的方向向量
+
+// 查找最近的单元
+int elem_idx;
+double distance;
+if (mesh3d.find_nearest_element(0.5, 0.5, 0.5, elem_idx, distance)) {
+    // 找到距离点(0.5,0.5,0.5)最近的单元
+}
+
+// 添加数据并保存
+mesh3d.add_data(gctl::NodeData, gctl::Vector, "displacement", 
+                array<point3dc>(nodes.size(), point3dc(0,0,0)));
+mesh3d.save_gmsh("curve3d.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 线性网格主要用于表示一维结构（如曲线、管线）在三维空间中的分布
+2. 每个单元由两个节点定义，表示一条空间线段
+3. 节点和单元的编号从0开始
+4. 支持不规则分布的节点，适合复杂三维曲线的离散化
+5. 提供了网格拓扑关系查询功能
+6. 支持计算单元的方向向量，便于处理定向问题
+7. 查找最近单元功能适用于路径规划和碰撞检测
+8. 支持Gmsh和二进制格式的文件操作
+9. 适用于输电线路、管道系统、裂缝网络等模拟 

doc/mesh.md

@@ -0,0 +1,116 @@
+# GCTL Mesh 基类文档
+
+## 简介
+
+`mesh.h` 定义了GCTL网格库的基础类 `base_mesh`，这是所有具体网格类型的基类。它提供了网格操作的基本接口和功能实现。
+
+## 类型定义
+
+### 网格类型 (mesh_type_e)
+```cpp
+enum mesh_type_e {
+    UNDEFINED,           // 未定义网格
+    REGULAR_MESH,        // 规则网格
+    LINEAR_MESH,         // 线性网格
+    TRI_TET_MESH,       // 三角形/四面体网格
+    REGULAR_MESH_SPH,    // 球面规则网格
+    LINEAR_MESH_SPH,     // 球面线性网格
+    TRI_TET_MESH_SPH,    // 球面三角形/四面体网格
+    REGULAR_GRID,        // 规则网格
+};
+```
+
+### 网格维度 (mesh_dim_e)
+```cpp
+enum mesh_dim_e {
+    MESH_0D,    // 0维网格
+    MESH_2D,    // 2维网格
+    MESH_3D     // 3维网格
+};
+```
+
+## 主要API
+
+### 基本操作
+```cpp
+void clear();                    // 清除所有网格数据
+bool initiated() const;          // 检查网格是否已初始化
+void show_info();               // 显示网格与数据信息
+```
+
+### 网格信息获取
+```cpp
+mesh_type_e get_meshtype() const;    // 获取网格类型
+mesh_dim_e get_meshdim() const;      // 获取网格维度
+int get_nodenum() const;             // 获取顶点数量
+int get_elenum() const;              // 获取网格单元数量
+int get_datanum() const;             // 获取数据对象数量
+```
+
+### 网格属性设置
+```cpp
+std::string get_meshname() const;             // 获取网格名称
+void set_meshname(std::string in_name);       // 设置网格名称
+std::string get_meshinfo() const;             // 获取网格说明信息
+void set_meshinfo(std::string in_info);       // 设置网格说明信息
+```
+
+### 数据操作
+```cpp
+// 添加网格数据（标量初始值）
+meshdata &add_data(mesh_data_type_e in_loctype,    // 数据位置类型
+                  mesh_data_value_e in_valtype,     // 数据值类型
+                  std::string name,                 // 数据名称
+                  double init_val,                  // 初始值
+                  bool if_output = true);           // 是否可输出
+
+// 添加网格数据（数组初始值）
+meshdata &add_data(mesh_data_type_e in_loctype,    // 数据位置类型
+                  std::string name,                 // 数据名称
+                  const array<double> &init_arr,    // 初始值数组
+                  bool if_output = true);           // 是否可输出
+
+// 获取数据对象
+meshdata &get_data(std::string datname);
+
+// 删除数据对象
+void remove_data(std::string datname);
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式（含数据）
+void save_gmsh_withdata(std::string filename,           // 文件名
+                       output_type_e out_mode,          // 输出模式
+                       index_packed_e packed = Packed); // 索引打包方式
+
+// 保存为Gmsh格式（指定数据）
+void save_gmsh_withdata(std::string filename,           // 文件名
+                       std::string datname,             // 数据名称
+                       output_type_e out_mode,          // 输出模式
+                       index_packed_e packed = Packed); // 索引打包方式
+
+// 纯虚函数 - 需要由派生类实现
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) = 0;
+virtual void load_binary(std::string filename) = 0;
+virtual void save_binary(std::string filename) = 0;
+```
+
+## 使用示例
+
+```cpp
+// 创建网格对象（以regular_grid为例）
+gctl::regular_grid rgd;
+rgd.init("grid-1", "test grid", 4, 4, 0.0, 0.0, 1.0, 1.0);
+
+// 添加数据
+rgd.add_data(gctl::NodeData, gctl::Scalar, "temperature", 25.0);
+rgd.add_data(gctl::ElemData, gctl::Vector, "velocity", velocity_array);
+
+// 显示网格信息
+rgd.show_info();
+
+// 保存网格
+rgd.save_gmsh_withdata("output.msh", gctl::OverWrite);
+``` 

doc/meshdata.md

@@ -0,0 +1,116 @@
+# GCTL MeshData 文档
+
+## 简介
+
+`meshdata.h` 定义了GCTL网格库中的数据对象类 `meshdata`，用于在网格上存储和管理各种类型的数据（标量、矢量和张量）。
+
+## 类型定义
+
+### 数据值类型 (mesh_data_value_e)
+```cpp
+enum mesh_data_value_e {
+    Scalar,     // 标量数据
+    Vector,     // 矢量数据
+    Tensor      // 张量数据
+};
+```
+
+## 类成员
+
+### 属性
+```cpp
+std::string name_;           // 数据的名称
+mesh_data_type_e loctype_;   // 数据的赋值位置属性（顶点或元素）
+mesh_data_value_e valtype_;  // 数据的类型（标量/矢量/张量）
+bool output_ok_;             // 是否可输出数据
+array<double> datval_;       // 数据值数组
+double nan_val_;             // 无效数据的标记值
+```
+
+## 主要API
+
+### 构造和初始化
+```cpp
+// 默认构造函数
+meshdata();
+
+// 带参数构造函数
+meshdata(mesh_data_type_e in_loctype,     // 数据位置类型
+         mesh_data_value_e in_valtype,     // 数据值类型
+         size_t size,                      // 数据大小
+         std::string name = "untitled",    // 数据名称
+         bool if_output = true,            // 是否可输出
+         double nan_val = GCTL_BDL_MAX);   // 无效值标记
+
+// 创建数据对象
+void create(mesh_data_type_e in_loctype,   // 数据位置类型
+           mesh_data_value_e in_valtype,   // 数据值类型
+           size_t size,                    // 数据大小
+           std::string name = "untitled",  // 数据名称
+           bool if_output = true,          // 是否可输出
+           double nan_val = GCTL_BDL_MAX); // 无效值标记
+```
+
+### 数据操作
+```cpp
+// 清空数据对象
+void clear();
+
+// 导出矢量数据
+array<point3dc> export_vector() const;
+
+// 导出张量数据
+array<tensor> export_tensor() const;
+```
+
+### 信息显示
+```cpp
+// 显示数据对象的头信息
+void show_info(std::ostream &os = std::clog) const;
+
+// 显示数据统计参数
+void show_stats(std::ostream &os = std::clog) const;
+```
+
+### 文件操作
+```cpp
+// 载入二进制文件
+void load_binary(std::ifstream &infile);
+
+// 保存二进制文件
+void save_binary(std::ofstream &outfile);
+```
+
+## 使用示例
+
+```cpp
+// 创建数据对象
+gctl::meshdata data(gctl::NodeData,        // 节点数据
+                   gctl::Scalar,           // 标量类型
+                   100,                    // 数据大小
+                   "temperature",          // 数据名称
+                   true);                  // 可输出
+
+// 显示数据信息
+data.show_info();
+
+// 显示数据统计信息
+data.show_stats();
+
+// 导出矢量数据
+if (data.valtype_ == gctl::Vector) {
+    array<point3dc> vectors = data.export_vector();
+}
+
+// 导出张量数据
+if (data.valtype_ == gctl::Tensor) {
+    array<tensor> tensors = data.export_tensor();
+}
+```
+
+## 注意事项
+
+1. 数据对象支持三种类型：标量、矢量和张量
+2. 数据可以定义在网格的顶点或元素上
+3. 数据导出时会根据数据类型自动转换为对应的格式
+4. 二进制文件操作通常由网格类调用，不建议直接使用 

doc/regular_grid.md

@@ -0,0 +1,114 @@
+# GCTL Regular Grid 文档
+
+## 简介
+
+`regular_grid.h` 定义了GCTL网格库中的规则网格类 `regular_grid`，用于创建和管理规则网格。规则网格是最基本的网格类型，具有规则的网格点分布和单元结构。
+
+## 类继承
+
+`regular_grid` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了规则网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化二维规则网格
+void init(std::string name,          // 网格名称
+          std::string info,          // 网格信息
+          int nx, int ny,            // x和y方向的网格数
+          double x0, double y0,      // 起始点坐标
+          double x1, double y1);     // 终止点坐标
+
+// 初始化三维规则网格
+void init(std::string name,          // 网格名称
+          std::string info,          // 网格信息
+          int nx, int ny, int nz,    // x、y和z方向的网格数
+          double x0, double y0, double z0,  // 起始点坐标
+          double x1, double y1, double z1); // 终止点坐标
+```
+
+### 网格信息
+```cpp
+// 获取网格维度
+int get_dimension() const;
+
+// 获取网格点数
+void get_grid_num(int &nx, int &ny) const;          // 2D
+void get_grid_num(int &nx, int &ny, int &nz) const; // 3D
+
+// 获取网格范围
+void get_grid_range(double &x0, double &y0,         // 2D起点
+                   double &x1, double &y1) const;    // 2D终点
+void get_grid_range(double &x0, double &y0, double &z0,  // 3D起点
+                   double &x1, double &y1, double &z1) const; // 3D终点
+```
+
+### 网格操作
+```cpp
+// 获取指定位置的网格点坐标
+void get_node_coord(int i, int j,             // 2D索引
+                   double &x, double &y) const;
+void get_node_coord(int i, int j, int k,      // 3D索引
+                   double &x, double &y, double &z) const;
+
+// 获取指定位置的单元中心坐标
+void get_elem_center(int i, int j,            // 2D索引
+                    double &x, double &y) const;
+void get_elem_center(int i, int j, int k,     // 3D索引
+                    double &x, double &y, double &z) const;
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+
+// NetCDF格式操作
+void load_netcdf_grid(std::string filename,
+                     mesh_data_type_e loctype,
+                     std::string xname,
+                     std::string yname);
+
+void save_netcdf_grid(std::string filename,
+                     std::string title = "untitled");
+```
+
+## 使用示例
+
+```cpp
+// 创建2D规则网格
+gctl::regular_grid grid2d;
+grid2d.init("grid2d", "2D regular grid",
+            100, 100,           // 100x100网格
+            0.0, 0.0,          // 起点(0,0)
+            1.0, 1.0);         // 终点(1,1)
+
+// 创建3D规则网格
+gctl::regular_grid grid3d;
+grid3d.init("grid3d", "3D regular grid",
+            50, 50, 50,        // 50x50x50网格
+            0.0, 0.0, 0.0,     // 起点(0,0,0)
+            1.0, 1.0, 1.0);    // 终点(1,1,1)
+
+// 获取网格信息
+int nx, ny, nz;
+grid3d.get_grid_num(nx, ny, nz);
+
+// 添加数据并保存
+grid3d.add_data(gctl::NodeData, gctl::Scalar, "temperature", 25.0);
+grid3d.save_gmsh("output.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 规则网格支持2D和3D两种维度
+2. 网格点和单元的编号是规则的，可以通过索引直接访问
+3. 支持多种文件格式的导入导出（Gmsh、二进制、NetCDF）
+4. 网格范围由起点和终点坐标定义，网格间距自动计算 

doc/regular_mesh_2d.md

@@ -0,0 +1,98 @@
+# GCTL Regular Mesh 2D 文档
+
+## 简介
+
+`regular_mesh_2d.h` 定义了GCTL网格库中的二维规则网格类 `regular_mesh_2d`，用于创建和管理二维结构化网格。与`regular_grid`相比，该类更专注于二维网格的处理，提供了更多针对二维网格的专门操作。
+
+## 类继承
+
+`regular_mesh_2d` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了二维规则网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化二维规则网格
+void init(std::string name,          // 网格名称
+          std::string info,          // 网格信息
+          int nx, int ny,            // x和y方向的网格数
+          double x0, double y0,      // 起始点坐标
+          double x1, double y1,      // 终止点坐标
+          double dx = 0.0,           // x方向网格间距（0表示自动计算）
+          double dy = 0.0);          // y方向网格间距（0表示自动计算）
+```
+
+### 网格信息
+```cpp
+// 获取网格点数
+void get_mesh_num(int &nx, int &ny) const;
+
+// 获取网格范围
+void get_mesh_range(double &x0, double &y0,    // 起点坐标
+                   double &x1, double &y1) const; // 终点坐标
+
+// 获取网格间距
+void get_mesh_step(double &dx, double &dy) const;
+```
+
+### 网格操作
+```cpp
+// 获取指定位置的网格点坐标
+void get_node_coord(int i, int j,          // 节点索引
+                   double &x, double &y) const;
+
+// 获取指定位置的单元中心坐标
+void get_elem_center(int i, int j,         // 单元索引
+                    double &x, double &y) const;
+
+// 获取指定坐标所在的网格单元索引
+bool get_elem_index(double x, double y,    // 坐标
+                   int &i, int &j) const;  // 返回单元索引
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建二维规则网格
+gctl::regular_mesh_2d mesh2d;
+mesh2d.init("mesh2d", "2D regular mesh",
+            100, 100,           // 100x100网格
+            0.0, 0.0,          // 起点(0,0)
+            1.0, 1.0);         // 终点(1,1)
+
+// 获取网格信息
+int nx, ny;
+mesh2d.get_mesh_num(nx, ny);
+
+double dx, dy;
+mesh2d.get_mesh_step(dx, dy);
+
+// 获取特定位置的坐标
+double x, y;
+mesh2d.get_node_coord(50, 50, x, y);  // 获取中心点坐标
+
+// 添加数据并保存
+mesh2d.add_data(gctl::NodeData, gctl::Scalar, "elevation", 0.0);
+mesh2d.save_gmsh("terrain.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 网格间距可以自动计算或手动指定
+2. 提供了坐标与网格索引之间的转换功能
+3. 所有索引都是从0开始计数
+4. 网格点和单元的编号是规则的，遵循行优先顺序
+5. 支持Gmsh和二进制格式的文件操作 

doc/regular_mesh_3d.md

@@ -0,0 +1,106 @@
+# GCTL Regular Mesh 3D 文档
+
+## 简介
+
+`regular_mesh_3d.h` 定义了GCTL网格库中的三维规则网格类 `regular_mesh_3d`，用于创建和管理三维结构化网格。该类专门处理三维空间中的规则网格，提供了完整的三维网格操作功能。
+
+## 类继承
+
+`regular_mesh_3d` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了三维规则网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化三维规则网格
+void init(std::string name,          // 网格名称
+          std::string info,          // 网格信息
+          int nx, int ny, int nz,    // x、y和z方向的网格数
+          double x0, double y0, double z0,  // 起始点坐标
+          double x1, double y1, double z1,  // 终止点坐标
+          double dx = 0.0,           // x方向网格间距（0表示自动计算）
+          double dy = 0.0,           // y方向网格间距（0表示自动计算）
+          double dz = 0.0);          // z方向网格间距（0表示自动计算）
+```
+
+### 网格信息
+```cpp
+// 获取网格点数
+void get_mesh_num(int &nx, int &ny, int &nz) const;
+
+// 获取网格范围
+void get_mesh_range(double &x0, double &y0, double &z0,    // 起点坐标
+                   double &x1, double &y1, double &z1) const; // 终点坐标
+
+// 获取网格间距
+void get_mesh_step(double &dx, double &dy, double &dz) const;
+```
+
+### 网格操作
+```cpp
+// 获取指定位置的网格点坐标
+void get_node_coord(int i, int j, int k,          // 节点索引
+                   double &x, double &y, double &z) const;
+
+// 获取指定位置的单元中心坐标
+void get_elem_center(int i, int j, int k,         // 单元索引
+                    double &x, double &y, double &z) const;
+
+// 获取指定坐标所在的网格单元索引
+bool get_elem_index(double x, double y, double z,  // 坐标
+                   int &i, int &j, int &k) const;  // 返回单元索引
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建三维规则网格
+gctl::regular_mesh_3d mesh3d;
+mesh3d.init("mesh3d", "3D regular mesh",
+            50, 50, 50,           // 50x50x50网格
+            0.0, 0.0, 0.0,        // 起点(0,0,0)
+            1.0, 1.0, 1.0);       // 终点(1,1,1)
+
+// 获取网格信息
+int nx, ny, nz;
+mesh3d.get_mesh_num(nx, ny, nz);
+
+double dx, dy, dz;
+mesh3d.get_mesh_step(dx, dy, dz);
+
+// 获取特定位置的坐标
+double x, y, z;
+mesh3d.get_node_coord(25, 25, 25, x, y, z);  // 获取中心点坐标
+
+// 查找特定坐标所在的单元
+int i, j, k;
+if (mesh3d.get_elem_index(0.5, 0.5, 0.5, i, j, k)) {
+    // 找到包含点(0.5,0.5,0.5)的单元
+}
+
+// 添加数据并保存
+mesh3d.add_data(gctl::NodeData, gctl::Scalar, "pressure", 0.0);
+mesh3d.save_gmsh("volume.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 网格间距可以自动计算或手动指定
+2. 提供了三维空间中坐标与网格索引之间的转换功能
+3. 所有索引都是从0开始计数
+4. 网格点和单元的编号是规则的，遵循x-y-z优先顺序
+5. 支持Gmsh和二进制格式的文件操作
+6. 内存占用随网格规模的立方增长，使用大规模网格时需注意内存管理 

doc/regular_mesh_sph_3d.md

@@ -0,0 +1,115 @@
+# GCTL Regular Mesh Spherical 3D 文档
+
+## 简介
+
+`regular_mesh_sph_3d.h` 定义了GCTL网格库中的三维球面规则网格类 `regular_mesh_sph_3d`，用于创建和管理球面坐标系下的三维规则网格。该类特别适用于地球物理学中的球面网格计算。
+
+## 类继承
+
+`regular_mesh_sph_3d` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了球面网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化三维球面规则网格
+void init(std::string name,          // 网格名称
+          std::string info,          // 网格信息
+          double lat0,               // 起始纬度
+          double lon0,               // 起始经度
+          double r0,                 // 起始半径
+          double dlat,               // 纬度间隔
+          double dlon,               // 经度间隔
+          double dr,                 // 半径间隔
+          int nlat,                  // 纬度方向网格数
+          int nlon,                  // 经度方向网格数
+          int nr);                   // 径向网格数
+```
+
+### 网格信息
+```cpp
+// 获取网格点数
+void get_mesh_num(int &nlat, int &nlon, int &nr) const;
+
+// 获取网格范围
+void get_mesh_range(double &lat0, double &lon0, double &r0,    // 起点
+                   double &lat1, double &lon1, double &r1) const; // 终点
+
+// 获取网格间距
+void get_mesh_step(double &dlat, double &dlon, double &dr) const;
+```
+
+### 网格操作
+```cpp
+// 获取指定位置的网格点球面坐标
+void get_node_coord_sph(int i, int j, int k,              // 节点索引
+                       double &lat, double &lon, double &r) const;
+
+// 获取指定位置的网格点笛卡尔坐标
+void get_node_coord(int i, int j, int k,                  // 节点索引
+                   double &x, double &y, double &z) const;
+
+// 获取指定位置的单元中心球面坐标
+void get_elem_center_sph(int i, int j, int k,            // 单元索引
+                        double &lat, double &lon, double &r) const;
+
+// 获取指定位置的单元中心笛卡尔坐标
+void get_elem_center(int i, int j, int k,                // 单元索引
+                    double &x, double &y, double &z) const;
+
+// 获取指定球面坐标所在的网格单元索引
+bool get_elem_index(double lat, double lon, double r,    // 球面坐标
+                   int &i, int &j, int &k) const;        // 返回单元索引
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建三维球面规则网格
+gctl::regular_mesh_sph_3d mesh_sph;
+mesh_sph.init("earth_mesh", "Earth model mesh",
+              -90.0, -180.0, 6371.0,     // 起始点：南极点，经度-180度，地球半径
+              1.0, 1.0, 10.0,            // 间隔：1度纬度，1度经度，10km深度
+              180, 360, 100);            // 网格数：180纬度，360经度，100层
+
+// 获取网格信息
+int nlat, nlon, nr;
+mesh_sph.get_mesh_num(nlat, nlon, nr);
+
+// 获取特定位置的坐标（球面坐标）
+double lat, lon, r;
+mesh_sph.get_node_coord_sph(90, 180, 0, lat, lon, r);  // 获取中心点坐标
+
+// 获取特定位置的坐标（笛卡尔坐标）
+double x, y, z;
+mesh_sph.get_node_coord(90, 180, 0, x, y, z);
+
+// 添加数据并保存
+mesh_sph.add_data(gctl::NodeData, gctl::Scalar, "temperature", 0.0);
+mesh_sph.save_gmsh("earth_model.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 坐标系采用地理坐标系约定：
+   - 纬度范围：-90度（南极）到90度（北极）
+   - 经度范围：-180度到180度
+   - 半径：从地心开始计算
+2. 提供了球面坐标和笛卡尔坐标的双重表示
+3. 网格在极点附近可能出现变形，需要特别处理
+4. 经度方向是周期性的，可以处理跨越180度经线的情况
+5. 支持Gmsh和二进制格式的文件操作
+6. 适用于地球物理建模、大气科学等领域 

doc/tet_mesh.md

@@ -0,0 +1,152 @@
+# GCTL Tetrahedral Mesh 文档
+
+## 简介
+
+`tet_mesh.h` 定义了GCTL网格库中的四面体网格类 `tet_mesh`，用于创建和管理三维空间中的非结构化四面体网格。该类特别适用于复杂三维区域的离散化，支持任意形状的体积域。
+
+## 类继承
+
+`tet_mesh` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了四面体网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化四面体网格
+void init(std::string name,                // 网格名称
+          std::string info,                // 网格信息
+          const array<point3dc> &nodes,    // 节点坐标数组
+          const array<int4> &elements);    // 单元连接关系数组
+```
+
+### 网格信息
+```cpp
+// 获取节点坐标
+void get_node_coord(int node_idx,          // 节点索引
+                   double &x, double &y, double &z) const;
+
+// 获取单元节点索引
+void get_elem_nodes(int elem_idx,          // 单元索引
+                   int &n1, int &n2, int &n3, int &n4) const;
+
+// 获取单元中心坐标
+void get_elem_center(int elem_idx,         // 单元索引
+                    double &x, double &y, double &z) const;
+
+// 获取单元体积
+double get_elem_volume(int elem_idx) const;
+
+// 获取单元外接球信息
+void get_elem_circumsphere(int elem_idx,   // 单元索引
+                          double &x, double &y, double &z,  // 球心坐标
+                          double &radius) const;           // 半径
+```
+
+### 网格查询
+```cpp
+// 查找包含指定点的单元
+bool find_element(double x, double y, double z,  // 目标点坐标
+                 int &elem_idx) const;           // 返回单元索引
+
+// 获取节点相邻的单元
+array<int> get_node_elements(int node_idx) const;
+
+// 获取单元相邻的单元
+array<int> get_elem_neighbors(int elem_idx) const;
+
+// 获取边界面
+array<int3> get_boundary_faces() const;
+```
+
+### 网格质量评估
+```cpp
+// 获取单元质量参数
+double get_elem_quality(int elem_idx) const;
+
+// 获取最小二面角
+double get_elem_min_dihedral_angle(int elem_idx) const;
+
+// 获取最大二面角
+double get_elem_max_dihedral_angle(int elem_idx) const;
+
+// 获取纵横比
+double get_elem_aspect_ratio(int elem_idx) const;
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建节点坐标数组
+array<point3dc> nodes;
+nodes.push_back(point3dc(0.0, 0.0, 0.0));  // 底面三角形的顶点
+nodes.push_back(point3dc(1.0, 0.0, 0.0));
+nodes.push_back(point3dc(0.0, 1.0, 0.0));
+nodes.push_back(point3dc(0.0, 0.0, 1.0));  // 顶点
+
+// 创建单元连接关系
+array<int4> elements;
+elements.push_back(int4(0, 1, 2, 3));  // 一个四面体
+
+// 创建四面体网格
+gctl::tet_mesh mesh;
+mesh.init("volume", "3D tetrahedral mesh", nodes, elements);
+
+// 获取单元信息
+double volume = mesh.get_elem_volume(0);  // 获取四面体的体积
+double quality = mesh.get_elem_quality(0); // 获取四面体的质量参数
+
+// 获取外接球信息
+double cx, cy, cz, radius;
+mesh.get_elem_circumsphere(0, cx, cy, cz, radius);
+
+// 查找包含特定点的单元
+int elem_idx;
+if (mesh.find_element(0.25, 0.25, 0.25, elem_idx)) {
+    // 找到包含点(0.25,0.25,0.25)的四面体
+}
+
+// 获取边界
+array<int3> boundary = mesh.get_boundary_faces();
+
+// 添加数据并保存
+mesh.add_data(gctl::NodeData, gctl::Vector, "displacement",
+              array<point3dc>(nodes.size(), point3dc(0,0,0)));
+mesh.save_gmsh("volume.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 四面体网格适用于三维区域的离散化
+2. 每个单元由四个节点定义，遵循右手法则定义方向
+3. 节点和单元的编号从0开始
+4. 提供了完整的网格质量评估功能：
+   - 体积
+   - 二面角
+   - 纵横比
+   - 质量参数
+5. 支持复杂的拓扑关系查询
+6. 可以自动识别和提取边界面
+7. 支持Gmsh和二进制格式的文件操作
+8. 适用于：
+   - 有限元分析
+   - 计算流体动力学
+   - 结构力学
+   - 电磁场分析
+9. 网格质量对计算精度和收敛性有重要影响，建议：
+   - 控制最小二面角不小于10度
+   - 控制最大二面角不大于160度
+   - 保持适当的纵横比
+</rewritten_file> 

doc/tri_mesh.md

@@ -0,0 +1,138 @@
+# GCTL Triangle Mesh 文档
+
+## 简介
+
+`tri_mesh.h` 定义了GCTL网格库中的三角形网格类 `tri_mesh`，用于创建和管理二维平面上的非结构化三角形网格。该类特别适用于复杂二维区域的离散化，支持任意形状的边界。
+
+## 类继承
+
+`tri_mesh` 继承自 `base_mesh` 基类，实现了所有虚函数，并添加了三角形网格特有的功能。
+
+## 主要API
+
+### 初始化
+```cpp
+// 初始化三角形网格
+void init(std::string name,                // 网格名称
+          std::string info,                // 网格信息
+          const array<point2dc> &nodes,    // 节点坐标数组
+          const array<int3> &elements);    // 单元连接关系数组
+```
+
+### 网格信息
+```cpp
+// 获取节点坐标
+void get_node_coord(int node_idx,          // 节点索引
+                   double &x, double &y) const;
+
+// 获取单元节点索引
+void get_elem_nodes(int elem_idx,          // 单元索引
+                   int &n1, int &n2, int &n3) const;
+
+// 获取单元中心坐标
+void get_elem_center(int elem_idx,         // 单元索引
+                    double &x, double &y) const;
+
+// 获取单元面积
+double get_elem_area(int elem_idx) const;
+
+// 获取单元外接圆信息
+void get_elem_circumcircle(int elem_idx,   // 单元索引
+                          double &x, double &y,  // 圆心坐标
+                          double &radius) const; // 半径
+```
+
+### 网格查询
+```cpp
+// 查找包含指定点的单元
+bool find_element(double x, double y,      // 目标点坐标
+                 int &elem_idx) const;     // 返回单元索引
+
+// 获取节点相邻的单元
+array<int> get_node_elements(int node_idx) const;
+
+// 获取单元相邻的单元
+array<int> get_elem_neighbors(int elem_idx) const;
+
+// 获取边界边
+array<int2> get_boundary_edges() const;
+```
+
+### 网格质量评估
+```cpp
+// 获取单元质量参数
+double get_elem_quality(int elem_idx) const;
+
+// 获取最小内角
+double get_elem_min_angle(int elem_idx) const;
+
+// 获取最大内角
+double get_elem_max_angle(int elem_idx) const;
+```
+
+### 文件操作
+```cpp
+// 保存为Gmsh格式
+virtual void save_gmsh(std::string filename,
+                      index_packed_e packed = Packed) override;
+
+// 保存为二进制格式
+virtual void save_binary(std::string filename) override;
+
+// 读取二进制格式
+virtual void load_binary(std::string filename) override;
+```
+
+## 使用示例
+
+```cpp
+// 创建节点坐标数组
+array<point2dc> nodes;
+nodes.push_back(point2dc(0.0, 0.0));
+nodes.push_back(point2dc(1.0, 0.0));
+nodes.push_back(point2dc(0.5, 0.866));
+nodes.push_back(point2dc(0.5, 0.289));
+
+// 创建单元连接关系
+array<int3> elements;
+elements.push_back(int3(0, 1, 3));  // 第一个三角形
+elements.push_back(int3(0, 3, 2));  // 第二个三角形
+elements.push_back(int3(1, 2, 3));  // 第三个三角形
+
+// 创建三角形网格
+gctl::tri_mesh mesh;
+mesh.init("domain", "2D triangle mesh", nodes, elements);
+
+// 获取单元信息
+double area = mesh.get_elem_area(0);  // 获取第一个三角形的面积
+double quality = mesh.get_elem_quality(0);  // 获取第一个三角形的质量参数
+
+// 获取外接圆信息
+double cx, cy, radius;
+mesh.get_elem_circumcircle(0, cx, cy, radius);
+
+// 查找包含特定点的单元
+int elem_idx;
+if (mesh.find_element(0.5, 0.5, elem_idx)) {
+    // 找到包含点(0.5,0.5)的三角形
+}
+
+// 获取边界
+array<int2> boundary = mesh.get_boundary_edges();
+
+// 添加数据并保存
+mesh.add_data(gctl::NodeData, gctl::Scalar, "pressure", 0.0);
+mesh.save_gmsh("domain.msh", gctl::Packed);
+```
+
+## 注意事项
+
+1. 三角形网格适用于二维区域的离散化
+2. 每个单元由三个节点定义，按逆时针顺序排列
+3. 节点和单元的编号从0开始
+4. 提供了完整的网格质量评估功能
+5. 支持复杂的拓扑关系查询
+6. 可以自动识别和提取边界边
+7. 支持Gmsh和二进制格式的文件操作
+8. 适用于有限元分析、流体动力学等数值模拟
+9. 网格质量对计算结果有重要影响，建议进行质量检查