Gmsh教程

6、转换网格，删除实体

import gmsh  
import math  
import sys  
  
gmsh.initialize()  # 初始化Gmsh  
  
gmsh.model.add("t6")  # 添加一个名为"t6"的模型  
  

lc = 1e-2  # 设置特征长度  
gmsh.model.geo.addPoint(0, 0, 0, lc, 1)  # 添加点1  
gmsh.model.geo.addPoint(.1, 0, 0, lc, 2)  # 添加点2  
gmsh.model.geo.addPoint(.1, .3, 0, lc, 3)  # 添加点3  
gmsh.model.geo.addPoint(0, .3, 0, lc, 4)  # 添加点4  
# 添加线段  
gmsh.model.geo.addLine(1, 2, 1)  
gmsh.model.geo.addLine(3, 2, 2)  
gmsh.model.geo.addLine(3, 4, 3)  
gmsh.model.geo.addLine(4, 1, 4)  
# 添加曲线环  
gmsh.model.geo.addCurveLoop([4, 1, -2, 3], 1)  
# 添加平面表面  
gmsh.model.geo.addPlaneSurface([1], 1)  
  
# 删除表面和左线，并用3条新线替换左线：  
gmsh.model.geo.remove([(2, 1), (1, 4)])  
  
# 添加新点  
p1 = gmsh.model.geo.addPoint(-0.05, 0.05, 0, lc)  
p2 = gmsh.model.geo.addPoint(-0.05, 0.1, 0, lc)  
# 添加新线  
l1 = gmsh.model.geo.addLine(1, p1)  
l2 = gmsh.model.geo.addLine(p1, p2)  
l3 = gmsh.model.geo.addLine(p2, 4)  
  

gmsh.model.geo.addCurveLoop([2, -1, l1, l2, l3, -3], 2)  
gmsh.model.geo.addPlaneSurface([-2], 1)  
  
# `setTransfiniteCurve()'网格约束明确指定了曲线上节点的位置。  
# 例如，以下命令强制在曲线2上均匀放置20个节点（包括两个端点上的节点）：  
gmsh.model.geo.mesh.setTransfiniteCurve(2, 20)  
  
# 在组合曲线`l1', `l2'和`l3'上总共放置20个点  
# 注意点`p1'和`p2'是由曲线共享的，所以我们不创建6 + 6 + 10 = 22个节点，而是20！  
gmsh.model.geo.mesh.setTransfiniteCurve(l1, 6)  
gmsh.model.geo.mesh.setTransfiniteCurve(l2, 6)  
gmsh.model.geo.mesh.setTransfiniteCurve(l3, 10)  
  
# 最后，我们在曲线1上放置30个节点，按照几何级数排列（反转）  
# 在曲线3上也放置30个点，按照几何级数排列  
gmsh.model.geo.mesh.setTransfiniteCurve(1, 30, "Progression", -1.2)  
gmsh.model.geo.mesh.setTransfiniteCurve(3, 30, "Progression", 1.2)  
  
# `setTransfiniteSurface()'网格约束使用曲面的参数平面中的跨有限插值算法  
# 来连接边界上的节点，使用结构化网格。  
# 如果表面有超过4个角点，跨有限插值的角必须手动指定：  
gmsh.model.geo.mesh.setTransfiniteSurface(1, "Left", [1, 2, 3, 4])  
  
# 要创建四边形而不是三角形，可以使用`setRecombine'约束：  
gmsh.model.geo.mesh.setRecombine(2, 1)  
  
# 当表面边界上只有3或4个点时，在`setTransfiniteSurface()'调用中可以省略角列表：  
gmsh.model.geo.addPoint(0.2, 0.2, 0, 1.0, 7)  
gmsh.model.geo.addPoint(0.2, 0.1, 0, 1.0, 8)  
gmsh.model.geo.addPoint(0.25, 0.2, 0, 1.0, 9)  
gmsh.model.geo.addPoint(0.3, 0.1, 0, 1.0, 10)  
gmsh.model.geo.addLine(8, 10, 10)  
gmsh.model.geo.addLine(10, 9, 11)  
gmsh.model.geo.addLine(9, 7, 12)  
gmsh.model.geo.addLine(7, 8, 13)  
gmsh.model.geo.addCurveLoop([13, 10, 11, 12], 14)  
gmsh.model.geo.addPlaneSurface([14], 15)  
for i in range(10, 14):  
    gmsh.model.geo.mesh.setTransfiniteCurve(i, 10)  
gmsh.model.geo.mesh.setTransfiniteSurface(15)  
  
# 生成三角形的方式可以通过在`setTransfiniteSurface()'中指定"Left"、"Right"或"Alternate"来控制。  
# 例如：  
# gmsh.model.geo.mesh.setTransfiniteSurface(15, "Alternate")  
  
gmsh.model.geo.synchronize()  # 同步几何数据  
  
# 最后，我们对网格应用椭圆平滑器以获得更规则的网格：  
gmsh.option.setNumber("Mesh.Smoothing", 100)  
  
gmsh.model.mesh.generate(2)  # 生成网格  
gmsh.write("t6.msh")  # 写入网格文件  
  
# 启动GUI以查看结果：  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
gmsh.finalize()  # 清理并结束Gmsh

7、背景网格

import gmsh  
import os  
import sys  
  
# 通过提供一个背景网格，即包含目标网格大小的后期处理视图，可以非常准确地指定网格大小。  
  
gmsh.initialize()  
  
# 合并一个包含目标网格大小的基于列表的后期处理视图：  
path = os.path.dirname(os.path.abspath(__file__))  
gmsh.merge(os.path.join(path, os.pardir, 't7_bgmesh.pos'))  
  
# 如果后期处理视图是基于模型的而不是基于列表的（即如果它是基于实际的网格），  
# 那么我们需要创建一个新的模型来包含几何体，以便对其进行网格划分不会破坏背景网格。  
# 在这里不需要这样做，因为视图是基于列表的，但这样做也没有坏处：  
gmsh.model.add("t7")  
  
# 创建一个简单的矩形几何体：  
lc = 1e-2  
gmsh.model.geo.addPoint(0, 0, 0, lc, 1)  
gmsh.model.geo.addPoint(.1, 0, 0, lc, 2)  
gmsh.model.geo.addPoint(.1, .3, 0, lc, 3)  
gmsh.model.geo.addPoint(0, .3, 0, lc, 4)  

gmsh.model.geo.addLine(1, 2, 1)  
gmsh.model.geo.addLine(3, 2, 2)  
gmsh.model.geo.addLine(3, 4, 3)  
gmsh.model.geo.addLine(4, 1, 4)  

gmsh.model.geo.addCurveLoop([4, 1, -2, 3], 1)  
gmsh.model.geo.addPlaneSurface([1], 1)  
gmsh.model.geo.synchronize()  
  
# 将后期处理视图添加为一个新的尺寸字段：  
bg_field = gmsh.model.mesh.field.add("PostView")  
gmsh.model.mesh.field.setNumber(bg_field, "ViewIndex", 0)  
  
# 将视图应用为当前的背景网格尺寸字段：  
gmsh.model.mesh.field.setAsBackgroundMesh(bg_field)  
  
# 为了仅从背景网格计算网格大小，并忽略任何其他尺寸约束，可以设置：  
gmsh.option.setNumber("Mesh.MeshSizeExtendFromBoundary", 0)  
gmsh.option.setNumber("Mesh.MeshSizeFromPoints", 0)  
gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0)  
  
  
gmsh.model.mesh.generate(2)  
gmsh.write("t7.msh")  
  
# 启动GUI以查看结果：  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
gmsh.finalize()

8、后处理、图像导出和动画

# 导入必要的模块  
import gmsh  
import os  
import sys  
  
# 初始化Gmsh  
gmsh.initialize()  
  
# 设置特征长度  
lc = 1e-2  
  
# 添加几何体的点  
gmsh.model.geo.addPoint(0, 0, 0, lc, 1)  # 点1  
gmsh.model.geo.addPoint(.1, 0, 0, lc, 2)  # 点2  
gmsh.model.geo.addPoint(.1, .3, 0, lc, 3)  # 点3  
gmsh.model.geo.addPoint(0, .3, 0, lc, 4)  # 点4  
  
# 添加几何体的线  
gmsh.model.geo.addLine(1, 2, 1)  # 线1，连接点1和点2  
gmsh.model.geo.addLine(3, 2, 2)  # 线2，连接点3和点2  
gmsh.model.geo.addLine(3, 4, 3)  # 线3，连接点3和点4  
gmsh.model.geo.addLine(4, 1, 4)  # 线4，连接点4和点1  
  
# 添加曲线环，由线4, 1, -2, 3组成（注意线2的方向是相反的）  
gmsh.model.geo.addCurveLoop([4, 1, -2, 3], 1)  
  
# 根据曲线环添加平面表面  
gmsh.model.geo.addPlaneSurface([1], 1)  
  
# 同步几何体数据  
gmsh.model.geo.synchronize()  
  
# 获取当前脚本的路径，并合并后期处理视图文件  
path = os.path.dirname(os.path.abspath(__file__))  
gmsh.merge(os.path.join(path, os.pardir, 'view1.pos'))  # 注意：这里可能重复合并了同一个文件  
gmsh.merge(os.path.join(path, os.pardir, 'view1.pos'))  # 这行代码可能是多余的，应该合并不同的视图文件  
gmsh.merge(os.path.join(path, os.pardir, 'view4.pos'))  # 合并包含两个视图的文件  
  
# 设置一些通用选项  
# ...（省略了具体的设置选项代码，因为它们是自解释的）  
  
# 如果命令行参数中没有'-nopopup'，则初始化GUI  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.initialize()  
  
# 获取所有视图的标签  
v = gmsh.view.getTags()  
# 检查视图数量是否正确  
if len(v) != 4:  
    # 如果不正确，记录错误日志，结束Gmsh并退出程序  
    gmsh.logger.write("Wrong number of views!", "error")  
    gmsh.finalize()  
    exit()  
  
# 为每个视图设置选项  
gmsh.view.option.setNumber(v[0], "IntervalsType", 2)
gmsh.view.option.setNumber(v[0], "OffsetZ", 0.05)
gmsh.view.option.setNumber(v[0], "RaiseZ", 0)
gmsh.view.option.setNumber(v[0], "Light", 1)
gmsh.view.option.setNumber(v[0], "ShowScale", 0)
gmsh.view.option.setNumber(v[0], "SmoothNormals", 1)

gmsh.view.option.setNumber(v[1], "IntervalsType", 1)
gmsh.view.option.setNumber(v[1], "NbIso", 10)
gmsh.view.option.setNumber(v[1], "ShowScale", 0)

gmsh.view.option.setString(v[2], "Name", "Test...")
gmsh.view.option.setNumber(v[2], "Axes", 1)
gmsh.view.option.setNumber(v[2], "IntervalsType", 2)
gmsh.view.option.setNumber(v[2], "Type", 2)
gmsh.view.option.setNumber(v[2], "AutoPosition", 0)
gmsh.view.option.setNumber(v[2], "PositionX", 85)
gmsh.view.option.setNumber(v[2], "PositionY", 50)
gmsh.view.option.setNumber(v[2], "Width", 200)
gmsh.view.option.setNumber(v[2], "Height", 130)

gmsh.view.option.setNumber(v[3], "Visible", 0)
  
# 模拟动画循环  
t = 0 

for num in range(1, 4):

    for vv in v:
        gmsh.view.option.setNumber(vv, "TimeStep", t)
    current_step = gmsh.view.option.getNumber(v[0], "TimeStep")
    max_step = gmsh.view.option.getNumber(v[0], "NbTimeStep") - 1
    if current_step < max_step:
        t = t + 1
    else:
        t = 0

    gmsh.view.option.setNumber(v[0], "RaiseZ",
                               gmsh.view.option.getNumber(v[0], "RaiseZ") +
                               0.01 / gmsh.view.option.getNumber(v[0], "Max") * t)

    if num == 3:
        gmsh.option.setNumber("General.GraphicsWidth",
                              gmsh.option.getNumber("General.MenuWidth") + 640)
        gmsh.option.setNumber("General.GraphicsHeight", 480)

    frames = 50
    for num2 in range(frames):

        gmsh.option.setNumber("General.RotationX",
                              gmsh.option.getNumber("General.RotationX") + 10)
        gmsh.option.setNumber("General.RotationY",
                              gmsh.option.getNumber("General.RotationX") / 3)
        gmsh.option.setNumber("General.RotationZ",
                              gmsh.option.getNumber("General.RotationZ") + 0.1)

        gmsh.graphics.draw()

        if num == 3:

            pass

    if num == 3:
        pass
# ...（此部分代码模拟了一个动画循环，但其中一些部分（如num == 3时的空pass块）可能是为了演示或占位符）  
  
# 如果命令行参数中没有'-nopopup'，则运行GUI  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
# 清理并结束Gmsh  
gmsh.finalize()

9、插件

        gmsh.plugin.run("Annotate") 

import gmsh  # 导入Gmsh模块  
import os  # 导入os模块，用于处理文件路径  
import sys  # 导入sys模块，用于处理命令行参数  
  
gmsh.initialize()  # 初始化Gmsh  
  
# 获取当前脚本文件的目录，并向上回退一级目录来查找'view3.pos'文件  
path = os.path.dirname(os.path.abspath(__file__))  
gmsh.merge(os.path.join(path, os.pardir, 'view3.pos'))  # 合并一个后期处理视图文件  
  
# 获取所有视图的标签列表  
v = gmsh.view.getTags()  
if len(v) != 1:  # 检查是否只有一个视图  
    gmsh.logger.write("Wrong number of views!", "error")  # 如果不是，记录错误日志  
    gmsh.finalize()  # 清理并结束Gmsh  
    exit()  # 退出程序  
  
# 使用“Isosurface”插件来提取等表面  
gmsh.plugin.setNumber("Isosurface", "Value", 0.67)  # 设置等表面的值为0.67  
gmsh.plugin.setNumber("Isosurface", "View", 0)  # 指定操作的是第0个视图  
v1 = gmsh.plugin.run("Isosurface")  # 运行插件，并获取新视图的标签  
  
# 使用“CutPlane”插件来计算一个截面  
gmsh.plugin.setNumber("CutPlane", "A", 0)  # 设置切平面的A系数  
gmsh.plugin.setNumber("CutPlane", "B", 0.2)  # 设置切平面的B系数  
gmsh.plugin.setNumber("CutPlane", "C", 1)  # 设置切平面的C系数  
gmsh.plugin.setNumber("CutPlane", "D", 0)  # 设置切平面的D系数，形成方程A*x+B*y+C*z+D=0  
gmsh.plugin.setNumber("CutPlane", "View", 0)  # 指定操作的是第0个视图  
v2 = gmsh.plugin.run("CutPlane")  # 运行插件，并获取新视图的标签  
  
# 使用“Annotate”插件来添加注释  
gmsh.plugin.setString("Annotate", "Text", "A nice title")  # 设置注释文本  
gmsh.plugin.setNumber("Annotate", "X", 1.e5)  # 设置注释的X坐标（大于99999表示居中）  
gmsh.plugin.setNumber("Annotate", "Y", 50)  # 设置注释的Y坐标  
gmsh.plugin.setString("Annotate", "Font", "Times-BoldItalic")  # 设置字体  
gmsh.plugin.setNumber("Annotate", "FontSize", 28)  # 设置字体大小  
gmsh.plugin.setString("Annotate", "Align", "Center")  # 设置文本对齐方式  
gmsh.plugin.setNumber("Annotate", "View", 0)  # 指定操作的是第0个视图  
gmsh.plugin.run("Annotate")  # 运行插件添加标题  
  
# 添加一个副标题  
gmsh.plugin.setString("Annotate", "Text", "(and a small subtitle)")  # 设置副标题文本  
gmsh.plugin.setNumber("Annotate", "Y", 70)  # 调整Y坐标以放置副标题  
gmsh.plugin.setString("Annotate", "Font", "Times-Roman")  # 设置副标题的字体  
gmsh.plugin.setNumber("Annotate", "FontSize", 12)  # 设置副标题的字体大小  
gmsh.plugin.run("Annotate")  # 运行插件添加副标题  
  
# 设置视图选项  
gmsh.view.option.setNumber(v[0], "Light", 1)  # 启用光照  
gmsh.view.option.setNumber(v[0], "IntervalsType", 1)  # 设置间隔类型  
gmsh.view.option.setNumber(v[0], "NbIso", 6)  # 设置等值线数量  
gmsh.view.option.setNumber(v[0], "SmoothNormals", 1)  # 启用平滑法线  
gmsh.view.option.setNumber(v1, "IntervalsType", 2)  # 为等表面视图设置间隔类型  
gmsh.view.option.setNumber(v2, "IntervalsType", 2)  # 为切面视图设置间隔类型  
  
# 如果命令行参数中没有'-nopopup'，则启动GUI  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
gmsh.finalize()  # 清理并结束Gmsh

10、网格大小字段

# 导入Gmsh模块和sys模块，用于处理命令行参数  
import gmsh  
import sys  
  
# 初始化Gmsh，允许从命令行参数传递选项  
gmsh.initialize(sys.argv)  
  
# 添加一个名为"t10"的模型  
gmsh.model.add("t10")  
  
# 设定一个特征长度lc  
lc = .15  
  
# 添加几何体的点  
gmsh.model.geo.addPoint(0.0, 0.0, 0, lc, 1)  # 点1  
gmsh.model.geo.addPoint(1, 0.0, 0, lc, 2)    # 点2  
gmsh.model.geo.addPoint(1, 1, 0, lc, 3)    # 点3  
gmsh.model.geo.addPoint(0, 1, 0, lc, 4)    # 点4  
gmsh.model.geo.addPoint(0.2, .5, 0, lc, 5)  # 点5，用于后续的Distance字段  
  
# 添加几何体的线  
gmsh.model.geo.addLine(1, 2, 1)  # 线1，连接点1和点2  
gmsh.model.geo.addLine(2, 3, 2)  # 线2，连接点2和点3  
gmsh.model.geo.addLine(3, 4, 3)  # 线3，连接点3和点4  
gmsh.model.geo.addLine(4, 1, 4)  # 线4，连接点4和点1  
  
# 添加曲线环，由线1, 2, 3, 4组成  
gmsh.model.geo.addCurveLoop([1, 2, 3, 4], 5)  
  
# 添加平面表面，由曲线环5组成  
gmsh.model.geo.addPlaneSurface([5], 6)  
  
# 同步几何体数据，确保所有修改都已应用  
gmsh.model.geo.synchronize()  
  
# 定义网格尺寸字段  
# 添加Distance字段，计算点到点5和曲线2的距离  
gmsh.model.mesh.field.add("Distance", 1)  
gmsh.model.mesh.field.setNumbers(1, "PointsList", [5])  
gmsh.model.mesh.field.setNumbers(1, "CurvesList", [2])  
gmsh.model.mesh.field.setNumber(1, "Sampling", 100)  
  
# 添加Threshold字段，基于Distance字段1的返回值来定义元素尺寸  
gmsh.model.mesh.field.add("Threshold", 2)  
gmsh.model.mesh.field.setNumber(2, "InField", 1)  
gmsh.model.mesh.field.setNumber(2, "SizeMin", lc / 30)  
gmsh.model.mesh.field.setNumber(2, "SizeMax", lc)  
gmsh.model.mesh.field.setNumber(2, "DistMin", 0.15)  
gmsh.model.mesh.field.setNumber(2, "DistMax", 0.5)  
  
# 添加MathEval字段，使用数学表达式定义元素尺寸  
gmsh.model.mesh.field.add("MathEval", 3)  
gmsh.model.mesh.field.setString(3, "F", "cos(4*3.14*x) * sin(4*3.14*y) / 10 + 0.101")  
  
# 添加第二个Distance字段，计算点到点1的距离  
gmsh.model.mesh.field.add("Distance", 4)  
gmsh.model.mesh.field.setNumbers(4, "PointsList", [1])  
  
# 添加第二个MathEval字段，其表达式依赖于Distance字段4的返回值  
gmsh.model.mesh.field.add("MathEval", 5)  
gmsh.model.mesh.field.setString(5, "F", "F4^3 + " + str(lc / 100))  
  
# 添加Box字段，在指定区域内强制元素尺寸变化  
gmsh.model.mesh.field.add("Box", 6)  
gmsh.model.mesh.field.setNumber(6, "VIn", lc / 15)
gmsh.model.mesh.field.setNumber(6, "VOut", lc)
gmsh.model.mesh.field.setNumber(6, "XMin", 0.3)
gmsh.model.mesh.field.setNumber(6, "XMax", 0.6)
gmsh.model.mesh.field.setNumber(6, "YMin", 0.3)
gmsh.model.mesh.field.setNumber(6, "YMax", 0.6)
gmsh.model.mesh.field.setNumber(6, "Thickness", 0.3)
  
# 添加Min字段，取所有指定字段中的最小值作为元素尺寸  
gmsh.model.mesh.field.add("Min", 7)  
gmsh.model.mesh.field.setNumbers(7, "FieldsList", [2, 3, 5, 6])  
  
# 将Min字段设置为背景网格尺寸字段  
gmsh.model.mesh.field.setAsBackgroundMesh(7)  
  
# 定义全局网格尺寸回调函数（可选，此处已定义但可能未被充分使用）  
def meshSizeCallback(dim, tag, x, y, z, lc):
    return min(lc, 0.02 * x + 0.01)

gmsh.model.mesh.setSizeCallback(meshSizeCallback) 
  
# 设置网格生成选项  
gmsh.option.setNumber("Mesh.MeshSizeExtendFromBoundary", 0)  
gmsh.option.setNumber("Mesh.MeshSizeFromPoints", 0)  
gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0)  
gmsh.option.setNumber("Mesh.Algorithm", 5)  # 使用Delaunay算法  
  
# 生成网格  
gmsh.model.mesh.generate(2)  
  
# 将网格写入文件  
gmsh.write("t10.msh")  
  
# 如果命令行参数中没有'-nopopup'，则启动GUI以查看结果  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
# 清理并结束Gmsh  
gmsh.finalize()

11、非结构化四边形网格

        gmsh.model.mesh.setRecombine(2, p1)  

# 导入Gmsh模块和sys模块，用于处理命令行参数  
import gmsh  
import sys  
  
# 初始化Gmsh  
gmsh.initialize()  
  
# 添加一个名为"t11"的模型  
gmsh.model.add("t11")  
  
# 添加几何体的点  
p1 = gmsh.model.geo.addPoint(-1.25, -.5, 0)  # 左下角点  
p2 = gmsh.model.geo.addPoint(1.25, -.5, 0)   # 右下角点  
p3 = gmsh.model.geo.addPoint(1.25, 1.25, 0)  # 右上角点  
p4 = gmsh.model.geo.addPoint(-1.25, 1.25, 0) # 左上角点  
  
# 添加几何体的线，连接上述点形成矩形  
l1 = gmsh.model.geo.addLine(p1, p2)  # 下边  
l2 = gmsh.model.geo.addLine(p2, p3)  # 右边  
l3 = gmsh.model.geo.addLine(p3, p4)  # 上边  
l4 = gmsh.model.geo.addLine(p4, p1)  # 左边  
  
# 添加曲线环，由线l1, l2, l3, l4组成，表示矩形的边界  
cl = gmsh.model.geo.addCurveLoop([l1, l2, l3, l4])  
  
# 添加平面表面，由曲线环cl组成  
pl = gmsh.model.geo.addPlaneSurface([cl])  
  
# 同步几何体数据，确保所有修改都已应用  
gmsh.model.geo.synchronize()  
  
# 定义网格尺寸字段  
# 添加MathEval字段，使用数学表达式定义元素尺寸  
field = gmsh.model.mesh.field  
field.add("MathEval", 1)  # 添加MathEval字段，编号为1  
field.setString(1, "F", "0.01*(1.0+30.*(y-x*x)*(y-x*x) + (1-x)*(1-x))")  # 设置字段的表达式  
field.setAsBackgroundMesh(1)  # 将该字段设置为背景网格尺寸字段  
  
# 设置网格生成选项，尝试重组四边形网格  
gmsh.model.mesh.setRecombine(2, pl)  # 在平面表面pl上尝试重组网格为四边形  
  
# 生成网格  
gmsh.model.mesh.generate(2)  # 生成二维网格  
  
# 如果命令行参数中没有'-nopopup'，则启动GUI以查看结果  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
# 清理并结束Gmsh  
gmsh.finalize()

12、与化合物交叉啮合

        gmsh.model.mesh.setCompound(1, [2, 3, 4]) 

import gmsh  
import sys  
  
# 初始化Gmsh  
gmsh.initialize()  
  
# 设置一个特征长度lc，用于控制网格大小  
lc = 0.1  
  
# 添加几何体的点，每个点都有特定的坐标和特征长度  
gmsh.model.geo.addPoint(0, 0, 0, lc, 1)  # 点1  
gmsh.model.geo.addPoint(1, 0, 0, lc, 2)  # 点2  
gmsh.model.geo.addPoint(1, 1, 0.5, lc, 3)  # 点3  
gmsh.model.geo.addPoint(0, 1, 0.4, lc, 4)  # 点4  
gmsh.model.geo.addPoint(0.3, 0.2, 0, lc, 5)  # 点5，可能用于后续操作  
gmsh.model.geo.addPoint(0, 0.01, 0.01, lc, 6)  # 点6  
gmsh.model.geo.addPoint(0, 0.02, 0.02, lc, 7)  # 点7  
gmsh.model.geo.addPoint(1, 0.05, 0.02, lc, 8)  # 点8  
gmsh.model.geo.addPoint(1, 0.32, 0.02, lc, 9)  # 点9  
  
# 添加几何体的线，连接上述点形成几何形状  
# ...（省略了具体的addLine调用注释，因为它们仅连接点）  
  
# 添加曲线环，曲线环是由线组成的闭合路径，用于定义表面的边界  
gmsh.model.geo.addCurveLoop([5, 6, 9, 4], 11)  # 曲线环11  
gmsh.model.geo.addSurfaceFilling([11], 1)  # 根据曲线环11填充表面1  
  
# 添加第二个曲线环和对应的填充表面  
gmsh.model.geo.addCurveLoop([-9, 3, 10, 7], 13)  # 注意这里的负号表示线的方向相反  
gmsh.model.geo.addSurfaceFilling([13], 5)  # 填充表面5  
  
# 添加第三个曲线环和对应的填充表面  
gmsh.model.geo.addCurveLoop([-10, 2, 1, 8], 15)  # 同上，负号表示方向  
gmsh.model.geo.addSurfaceFilling([15], 10)  # 填充表面10  
  
# 同步几何体数据，确保所有修改都已应用  
gmsh.model.geo.synchronize()  
  
# 设置几何实体的复合体（Compound），但这里有几个问题：  
# 1. setCompound的第二个参数应该是一个列表，包含要组合的几何实体的标签。  
# 2. 第一个参数是复合体的标签，但这里重复使用了1，可能会导致错误或覆盖。  
# 假设这是为了演示，但实际应用中需要仔细规划标签。  
gmsh.model.mesh.setCompound(1, [2, 3, 4])  # 将线2, 3, 4组合为复合体1  
gmsh.model.mesh.setCompound(1, [6, 7, 8])  # 这将覆盖上面的设置，通常这不是想要的行为  
gmsh.model.mesh.setCompound(2, [1, 5, 10])  # 正确设置另一个复合体2  
  
# 生成网格  
gmsh.model.mesh.generate(2)  # 生成二维网格  
  
# 将网格写入文件  
gmsh.write('t12.msh')  
  
# 如果命令行参数中没有'-nopopup'，则启动GUI以查看结果  
if '-nopopup' not in sys.argv:  
    gmsh.fltk.run()  
  
# 清理并结束Gmsh  
gmsh.finalize()