软件架构详解 - 工业软件的"骨骼" / Software Architecture as the Skeleton of Industrial Applications
日期：2026-04-29 标签：#架构 #几何内核 #网格引擎 #求解器 #插件 前置知识：技术栈与开发语言
本章目标
- 理解工业软件的整体架构
- 掌握几何内核的架构设计
- 了解网格引擎的实现原理
- 理解求解器的模块化设计
- 认识并行计算架构
- 了解插件系统和 API 设计
第1部分：工业软件架构总览
1.1 分层架构
┌─────────────────────────────────────────────────────────────────────────────┐
│ 工业软件分层架构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 用户界面层 (UI Layer) │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 主窗口 │ │ 属性面板 │ │ 图形视图 │ │ 对话框 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 业务逻辑层 (Business Layer) │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 建模 │ │ 仿真 │ │ 后处理 │ │ 数据管理 │ │ 工具集 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 核心引擎层 (Engine Layer) │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │几何内核 │ │ 网格引擎│ │ 求解器 │ │ 可视化 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 基础设施层 (Infrastructure Layer) │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 数学库 │ │ IO系统 │ │ 内存管理 │ │ 并行框架│ │ 工具库 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘1.2 模块化设计
┌─────────────────────────────────────────────────────────────────────────────┐
│ 模块化架构示意 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ │
│ │ 主程序框架 │ │
│ └──────────┬──────────┘ │
│ │ │
│ ┌────────────────────┼────────────────────┐ │
│ ↓ ↓ ↓ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ 建模模块 │ │ 仿真模块 │ │ 工具模块 │ │
│ │ │ │ │ │ │ │
│ │ ┌───────────┐│ │ ┌───────────┐│ │ ┌───────────┐│ │
│ │ │ 零件设计 ││ │ │ 前处理 ││ │ │ 数据转换 ││ │
│ │ ├───────────┤│ │ ├───────────┤│ │ ├───────────┤│ │
│ │ │ 装配设计 ││ │ │ 求解器 ││ │ ├───────────┤│ │
│ │ ├───────────┤│ │ ├───────────┤│ │ │ 批处理 ││ │
│ │ │ 工程图 ││ │ │ 后处理 ││ │ └───────────┘│ │
│ │ └───────────┘│ │ └───────────┘│ │
│ └───────────────┘ └───────────────┘ │
│ │
│ 所有模块都依赖： │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ 几何内核 │ │ 数学库 │ │ 核心框架 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘第2部分：几何内核架构
2.1 几何内核的地位
几何内核 = 几何引擎 = Geometric Kernel
是 CAD 软件的核心，负责所有几何运算。
┌─────────────────────────────────────────────────────────────────────────────┐
│ 几何内核在架构中的位置 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 用户界面 │
│ ↓ │
│ CAD 逻辑 │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 几何内核 │ │
│ │ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ │
│ │ │ B-Rep │ │ CSG │ │ 曲面/曲线 │ │ 布尔运算 │ │ │
│ │ │ 拓扑管理 │ │ 历史管理 │ │ 数学表示 │ │ 几何查询 │ │ │
│ │ └───────────┘ └───────────┘ └───────────┘ └───────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 数学库 + 数值计算 │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘2.2 B-Rep 数据结构
cpp
// 简化的 B-Rep 数据结构
// 顶点
struct Vertex {
Point3d position; // 坐标
Vector3d normal; // 法向量
};
// 有向边
struct Edge {
Curve3d* geometry; // 曲线几何
Vertex* start; // 起点
Vertex* end; // 终点
Loop* coEdge; // 所属环
};
// 有向边环（面的边界）
struct Loop {
std::list<Edge*> edges;
Face* face; // 所属面
};
// 面
struct Face {
Surface* geometry; // 曲面几何
Loop* outer; // 外环
std::list<Loop*> inner; // 内环（孔）
Solid* solid; // 所属实体
};
// 实体
struct Solid {
std::list<Face*> faces;
BoundingBox bbox; // 包围盒
};2.3 布尔运算架构
┌─────────────────────────────────────────────────────────────────────────────┐
│ 布尔运算流程 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 输入：实体 A，实体 B，运算类型（并/交/差） │
│ │
│ 实体A 实体B │
│ ↓ ↓ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ B-Rep 解析 │ │ B-Rep 解析 │ │
│ └──────┬───────┘ └──────┬───────┘ │
│ ↓ ↓ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ 分类边计算 │ │ 分类边计算 │ ← 计算交线 │
│ └──────┬───────┘ └──────┬───────┘ │
│ └──────────┬─────────┘ │
│ ↓ │
│ ┌──────────────────────┐ │
│ │ 交线分类与缝合 │ ← 关键步骤 │
│ │ - 求交线 │ │
│ │ - 分类内外 │ │
│ │ - 构建新拓扑 │ │
│ └──────────┬───────────┘ │
│ ↓ │
│ ┌──────────────────────┐ │
│ │ 新 B-Rep 生成 │ │
│ └──────────┬───────────┘ │
│ ↓ │
│ 结果实体 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘2.4 主流几何内核对比
| 内核 | 公司 | 架构特点 | 优势 |
|---|---|---|---|
| Parasolid | Siemens | 成熟稳定 | 布尔运算强 |
| ACIS | Dassault | 开放灵活 | 定制方便 |
| CGM | Dassault | 现代设计 | 性能优化 |
| OCCT | 开源 | 社区驱动 | 免费可改 |
第3部分：网格引擎架构
3.1 网格引擎概述
网格引擎 = 网格生成器 = Mesher
负责将几何模型离散化为有限元网格。
┌─────────────────────────────────────────────────────────────────────────────┐
│ 网格引擎功能 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 输入： │
│ - 几何模型（B-Rep） │
│ - 网格控制参数 │
│ - 网格尺寸函数 │
│ │
│ 处理： │
│ - 表面网格生成 │
│ - 体积网格生成 │
│ - 网格优化 │
│ - 质量评估 │
│ │
│ 输出： │
│ - 网格数据（节点、单元） │
│ - 质量报告 │
│ - 边界条件映射 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘3.2 曲面网格生成
** Delaunay 三角剖分**：
┌─────────────────────────────────────────────────────────────────────────────┐
│ Delaunay 三角剖分 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 定义： │
│ - 空圆准则：任何三角形的外接圆内不包含其他点 │
│ │
│ 优点： │
│ - 自动化程度高 │
│ - 适合复杂几何 │
│ - 理论成熟 │
│ │
│ 算法（Bowyer-Watson）： │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ 1. 创建超级三角形包围所有点 │ │
│ │ 2. 逐点插入： │ │
│ │ - 找到被破坏的三角形 │ │
│ │ - 删除这些三角形 │ │
│ │ - 从空腔边界重建三角网 │ │
│ │ 3. 删除与超级三角形相关的边 │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘3.3 体积网格生成
┌─────────────────────────────────────────────────────────────────────────────┐
│ 体积网格生成方法 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 四面体网格（前向推进法 - Advancing Front）： │
│ │
│ 1. 表面网格 │
│ ↓ │
│ 2. 在面上初始化前向 │
│ ↓ │
│ 3. 选择合适的边作为新四面体的基面 │
│ ↓ │
│ 4. 生成新四面体，推进前向 │
│ ↓ │
│ 5. 重复直到填满体积 │
│ │
│ 六面体网格（主要是映射法和多块法）： │
│ - 映射法：规则区域参数映射 │
│ - 多块法：复杂区域分解为规则块 │
│ - PolyCube：自动多块分解 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘3.4 网格质量优化
cpp
// 网格优化算法示例： Laplacian 平滑
void LaplacianSmooth(Mesh& mesh) {
const int iterations = 10;
const double tolerance = 0.01;
for (int iter = 0; iter < iterations; iter++) {
for (auto& node : mesh.nodes) {
if (node.isBoundary) continue; // 边界节点不移动
// 计算邻居节点平均位置
Vector3d avg(0, 0, 0);
int count = 0;
for (auto neighbor : node.neighbors) {
avg += neighbor->position;
count++;
}
avg /= count;
// 移动节点到平均位置
Vector3d newPos = avg * 0.8 + node.position * 0.2;
node.position = newPos;
}
// 检查收敛
if (mesh.maxDisplacement() < tolerance) break;
}
}第4部分：求解器架构
4.1 求解器模块划分
┌─────────────────────────────────────────────────────────────────────────────┐
│ 求解器模块架构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 求解器主控器 │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ 流程控制 │ │ 收敛判定 │ │ 输出管理 │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 物理模块 │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ 结构力学 │ │ 热传导 │ │ 流体力学 │ │ │
│ │ │ - 弹性 │ │ - 导热 │ │ - 湍流 │ │ │
│ │ │ - 塑性 │ │ - 对流 │ │ - 层流 │ │ │
│ │ │ - 粘弹 │ │ - 辐射 │ │ - 多相流 │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 数值模块 │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ 单元库 │ │ 代数求解器 │ │ 线性代数 │ │ │
│ │ │ - 梁 │ │ - 直接法 │ │ - 矩阵运算 │ │ │
│ │ │ - 壳 │ │ - 迭代法 │ │ - 稀疏格式 │ │ │
│ │ │ - 实体 │ │ - 预条件子 │ │ - 特征值 │ │ │
│ │ │ - 接触 │ │ - 加速收敛 │ │ - 稀疏矩阵 │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘4.2 求解器核心流程
cpp
// 伪代码：有限元求解流程
class Solver {
public:
void solve(Problem& problem) {
// 1. 初始化
initialize(problem);
// 2. 单元循环 - 组装刚度矩阵
for (Element& elem : elements) {
Matrix Ke = elem.stiffness();
assemble(Ke, elem.dofs());
}
// 3. 边界条件处理
applyBoundaryConditions();
// 4. 求解
switch (problem.type()) {
case LINEAR_STATIC:
solveLinearStatic();
break;
case NONLINEAR:
solveNonlinear();
break;
case MODAL:
solveModal();
break;
}
// 5. 结果后处理
computeResults();
outputResults();
}
private:
void solveNonlinear() {
double loadFactor = 0.0;
int maxSteps = 100;
for (int step = 0; step < maxSteps; step++) {
loadFactor += 1.0 / maxSteps;
// 牛顿迭代
for (int iter = 0; iter < maxIterations; iter++) {
Matrix Kt = computeTangentStiffness();
Vector R = computeResidual(loadFactor);
if (R.norm() < tolerance) break;
Vector du = Kt.solve(R);
u += du;
}
if (converged) break;
}
}
};4.3 耦合器设计
多物理场耦合：
┌─────────────────────────────────────────────────────────────────────────────┐
│ 耦合器架构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 耦合器主控 │
│ ↓ │
│ ┌───────────────────┼───────────────────┐ │
│ ↓ ↓ ↓ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 结构求解器│ ←──→ │ 热求解器 │ ←──→ │ 流求解器 │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ ↓ ↓ ↓ │
│ 位移/应力 温度分布 速度/压力 │
│ ↓ ↓ ↓ │
│ └───────────────────┼───────────────────┘ │
│ ↓ │
│ 耦合变量交换 │
│ │
│ 耦合方式： │
│ - 弱耦合 (Staggered)：交替求解，各自收敛 │
│ - 强耦合 (Monolithic)：联立方程组，一次求解 │
│ - 显式耦合：时间步交替 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘第5部分：并行计算架构
5.1 域分解并行
┌─────────────────────────────────────────────────────────────────────────────┐
│ 域分解并行架构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 原始问题域： │
│ ┌─────────────────────────────────────────────┐ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ └─────────────────────────────────────────────┘ │
│ │
│ 分解后（4个进程）： │
│ ┌───────────────────┬───────────────────┐ │
│ │ 域 1 │ 域 2 │ │
│ │ (进程 0) │ (进程 1) │ │
│ ├───────────────────┼───────────────────┤ │
│ │ 域 3 │ 域 4 │ │
│ │ (进程 2) │ (进程 3) │ │
│ └───────────────────┴───────────────────┘ │
│ ↓ │
│ 边界信息通过 MPI 通信交换 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘5.2 并行求解流程
cpp
// 伪代码：并行求解
class ParallelSolver {
public:
void solveParallel(Mesh& mesh, int numProcs) {
// 1. 域分解
DomainDecomposer decomposer;
std::vector<SubDomain> subDomains = decomposer.decompose(mesh, numProcs);
// 2. 分配到进程
MPI_Scatter(subDomains.data(), ..., MPI_COMM_WORLD);
// 3. 每个进程组装局部矩阵
for (SubDomain& sub : mySubdomain) {
for (Element& elem : sub.elements) {
Matrix Ke = elem.stiffness();
assembleLocal(Ke, elem.dofs());
}
}
// 4. 装配全局矩阵
// 交换边界自由度信息
MPI_Sendrecv(boundaryData, ...);
// 5. 并行求解
ParallelLinearSolver solver;
Vector u = solver.solve(K, F);
// 6. 收集结果
MPI_Gather(u.local(), u.size(), u.global(), ...);
}
};5.3 共享内存并行
cpp
// OpenMP 并行：单元循环并行化
#pragma omp parallel for schedule(dynamic, 100)
for (int i = 0; i < numElements; i++) {
Element& elem = elements[i];
// 计算单元刚度矩阵
Matrix Ke = elem.computeStiffness();
// 互斥锁保护全局装配
#pragma omp critical(assemble)
{
assemble(Ke, elem.dofs());
}
}
// 或者使用 reductions
double totalEnergy = 0.0;
#pragma omp parallel for reduction(+:totalEnergy)
for (int i = 0; i < numElements; i++) {
Element& elem = elements[i];
totalEnergy += elem.computeEnergy();
}第6部分：插件系统与 API
6.1 插件架构
┌─────────────────────────────────────────────────────────────────────────────┐
│ 插件系统架构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ │
│ │ 主应用程序 │ │
│ │ │ │
│ │ ┌───────────────┐ │ │
│ │ │ 插件管理器 │ │ │
│ │ │ - 加载/卸载 │ │ │
│ │ │ - 版本管理 │ │ │
│ │ │ - 依赖解析 │ │ │
│ │ └───────────────┘ │ │
│ └──────────┬──────────┘ │
│ ↓ │
│ ┌────────────────────┼────────────────────┐ │
│ ↓ ↓ ↓ │
│ ┌───────────┐ ┌───────────┐ ┌───────────┐ │
│ │ 插件1 │ │ 插件2 │ │ 插件3 │ │
│ │ 新求解器 │ │ CAD模块 │ │ 导入导出 │ │
│ └───────────┘ └───────────┘ └───────────┘ │
│ │
│ 接口定义： │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 插件接口 (Plugin Interface) │ │
│ │ │ │
│ │ class IPlugin { │ │
│ │ public: │ │
│ │ virtual void initialize() = 0; │ │
│ │ virtual void cleanup() = 0; │ │
│ │ virtual std::string name() const = 0; │ │
│ │ }; │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘6.2 API 设计
面向客户的 API 层次：
┌─────────────────────────────────────────────────────────────────────────────┐
│ API 层次设计 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 高级 API (Python/Lua) │ │
│ │ 用户脚本、自动化、工作流 │ │
│ │ │ │
│ │ 示例： │ │
│ │ import ansys │ │
│ │ model = ansys.open("bracket.rst") │ │
│ │ stress = model.result("Mises Stress").max() │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 中级 API (C++/COM) │ │
│ │ 插件开发、定制扩展 │ │
│ │ │ │
│ │ 示例： │ │
│ │ IModelPtr model = OpenModel("file.rst"); │ │
│ │ IResultPtr stress = model->GetResult("Mises Stress"); │ │
│ │ double maxStress = stress->GetMaxValue(); │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 底层 API (内部) │ │
│ │ 内核调用、直接访问 │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘第7部分：云化与现代化
7.1 云化趋势
┌─────────────────────────────────────────────────────────────────────────────┐
│ 工业软件云化 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 传统模式： │
│ ┌─────────────┐ │
│ │ 本地安装 │ ← 单机运行，数据本地存储 │
│ │ 厚重客户端 │ │
│ └─────────────┘ │
│ │
│ 云化模式： │
│ ┌─────────────────────────────────────────────┐ │
│ │ 云端服务器群 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Web UI │ │ 求解器 │ │ 数据库 │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────┘ │
│ ↑ │
│ 浏览器访问 │
│ │
│ 优势： │
│ - 无需本地安装 │
│ - 随时随地访问 │
│ - 按需计算资源 │
│ - 协作便利 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘7.2 架构演进
传统架构：
┌─────────────────────────────────────┐
│ 单体应用 │
│ UI | 业务 | 数据 全部在一起 │
└─────────────────────────────────────┘
服务化架构（微服务）：
┌──────────┐ ┌──────────┐ ┌──────────┐
│ 建模 │ │ 求解器 │ │ 后处理 │
│ 服务 │ │ 服务 │ │ 服务 │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
└──────────────┼──────────────┘
↓
┌──────────────┐
│ 消息总线 │
└──────────────┘核心总结
总结1：架构核心
几何内核：B-Rep 数据结构、布尔运算、几何查询
网格引擎：曲面网格、体积网格、质量优化
求解器：单元库、代数求解器、物理模块
可视化：OpenGL/Vulkan、视口管理、交互总结2：并行架构
域分解：MPI 进程间通信
共享内存：OpenMP 线程并行
GPU 加速：CUDA/OpenCL
混合并行：MPI + OpenMP + CUDA总结3：扩展机制
插件系统：动态加载、接口定义
API 层次：Python（高级）、C++（中级）、内核（低级）
云化：微服务架构、Web UI章节测试
测试1：几何内核
几何内核在工业软件架构中处于什么位置？主要功能是什么？
测试2：B-Rep 数据结构
B-Rep 数据结构包含哪些基本元素？它们之间的关系是什么？
测试3：求解器模块
求解器主要由哪些模块组成？各自负责什么功能？
测试4：并行策略
工业软件中，常用的并行策略有哪些？各自的特点是什么？
测试5：API 层次
工业软件 API 通常分为几个层次？各自面向什么用户？
参考答案
测试1答案
几何内核处于核心引擎层，是 CAD 软件的几何运算核心，主要功能包括：B-Rep 数据结构管理、CSG 历史操作、曲线曲面数学表示、布尔运算（合并/相减/相交）、几何查询（距离、相交、投影）等。
测试2答案
B-Rep 数据结构包含：顶点（Vertex，存储点坐标）、边（Edge，存储曲线几何和端点）、环（Loop，边的有序循环）、面（Face，存储曲面几何和内外环）、实体（Solid，包含所有面）。关系是：实体 → 面 → 环 → 边 → 顶点。
测试3答案
求解器主要由物理模块（结构力学、热传导、流体力学等）、数值模块（单元库、代数求解器、线性代数运算）、主控器（流程控制、收敛判定、输出管理）组成。
测试4答案
常用并行策略：MPI（消息传递，多进程分布式内存）、OpenMP（共享内存，多线程）、CUDA（GPU 并行）、域分解（将网格分区并行处理）。
测试5答案
API 通常分为三层：高级 API（Python 脚本，面向用户自动化）、中级 API（C++/COM，面向插件开发者）、底层 API（内核直接调用，面向内部开发）。
相关笔记
- [[08 - 技术栈与开发语言]] - 开发技术基础
- [[06 - 主流工业软件介绍]] - 商业软件架构参考
下一步
恭喜完成工业软件学习路线的全部内容！
返回：00 - 学习路线总览
学习状态：完成