Skip to content
  • 最新
  • 版块
  • 东岳流体
  • 随机看[请狂点我]
皮肤
  • Light
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • 默认(不使用皮肤)
  • 不使用皮肤
折叠
CFD中文网

CFD中文网

G

Gengxiaotian

@Gengxiaotian
关于
帖子
22
主题
4
群组
0
粉丝
1
关注
1

帖子

最新

  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    感谢大佬,我解决了问题,但似乎又出现了新的问题。起因是我希望用snap来加密多孔介质,但是我不知道为什么突然多了stl中不存在的部分。如下图,第一张图是cellZone,第二个是用来生成cellZone的stl文件。我在最下面贴出了我的snap设置。这让我十分困惑,我不理解为什么会出现这种情况。

    image.png

    image.png
    /--------------------------------- C++ -----------------------------------
    | ========= | |
    | \ / F ield | OpenFOAM: The Open Source CFD Toolbox |
    | \ / O peration | Version: 2.2.0 |
    | \ / A nd | Web: www.OpenFOAM.org |
    | \/ M anipulation | |
    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    object snappyHexMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    // Which of the steps to run
    castellatedMesh true; // make basic mesh ?
    snap true; // decide to snap back to surface ?
    addLayers false; // decide to add viscous layers ?

    geometry // 录入STL文件
    {

    side_mesh_0_45.stl {type triSurfaceMesh; name side_0;}
    side_mesh_45_90.stl {type triSurfaceMesh; name side_1;}
    side_mesh_90_135.stl {type triSurfaceMesh; name side_2;}
    side_mesh_135_180.stl {type triSurfaceMesh; name side_3;}
    side_mesh_180_225.stl {type triSurfaceMesh; name side_4;}
    side_mesh_225_270.stl {type triSurfaceMesh; name side_5;}
    side_mesh_270_315.stl {type triSurfaceMesh; name side_6;}
    side_mesh_315_360.stl {type triSurfaceMesh; name side_7;}
    
    top_mesh.stl {type triSurfaceMesh; name top;}
    building.stl {type triSurfaceMesh; name building;}
    grassland.stl {type triSurfaceMesh; name grassland;}
    ground.stl {type triSurfaceMesh; name ground;}
    water.stl {type triSurfaceMesh; name water;}
    
    tree.stl {type triSurfaceMesh; name tree;}
    
    refinementBox_building
    {
        type searchableBox;
    
        min ( 720 -600 15);
        max ( 2250  860 280);
    }
    

    };

    castellatedMeshControls
    {
    maxLocalCells 2000000; // 每个 CPU 核心允许使用的最大网格单元数,避免某个核心负载过重
    maxGlobalCells 20000000; // 全局允许的最大网格单元数,在细化阶段如果超过这个数量,系统将触发删除操作,防止内存溢出
    maxRefinementIterations 5; // 有效地限制整体迭代次数
    minRefinementCells 10; // 提高触发终止的阈值 maxLoadUnbalance 0.10; // 允许的最大负载不平衡度,表示各个 CPU 核心之间的工作负载差异最多为 10%,确保负载均衡
    nCellsBetweenLevels 3; // 不同细化等级之间的网格扩展因子,设置为 1 表示高细化区域与低细化区域之间的过渡最平滑
    maxShellRefinementIter 10;
    // 边缘特征细化程度
    features
    (
    {file "building.eMesh"; level 2;}
    {file "tree.eMesh"; level 1;}
    );

    refinementSurfaces
    {
        building {
            level (2 3);
            patchInfo
            {
                type wall; 
                inGroups (building);
            }
        }
    
        tree
        {
            // level (minLevel maxLevel)
            level          (2 3);        // 例:最少细 3 级、必要时再细 1 级
            faceZone       treeFZ;       // 可省;若想留出面区可保留
            cellZone       treeZone;     // 关键:让 snappy 直接生成 treeZone
            cellZoneInside inside;       // inside = STL 内部全进 cellZone
            patchInfo{
                type patch;
                inGroups (treeSurf);
            }
        }
        
        side_0 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_1 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_2 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_3 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_4 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_5 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_6 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
        side_7 {
            level (0 0);
            patchInfo{
                type patch;
                inGroups (side);
            }
        }
    
    
        top {
            level (0 0);
            patchInfo
            {
                type patch;
                inGroups (top);
            }
        }
    
        grassland {
            level (0 1);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        ground {
            level (0 1);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        water {
            level (0 1);            
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
    
    }
    
    resolveFeatureAngle 60; // 特征边缘角度,小于这个角度的边缘将被忽略
    refinementRegions 
    {
    
        refinementBox_building
        {
            mode inside;
            levels ((1 2));            
        }
        tree
        {
            mode   inside;               // STL 内部
            levels ((2 3));              // 在 level 3–4 的基础上再加 1 级
        }
    }
    // {wholeDomain {mode inside; levels ((0 0));}} // 细化区域,mode 为细化模式,levels 为细化等级
    // {building {mode distance; levels ((1 2) (3 1));}} // 细化区域,mode 为细化模式,levels 为细化等级mode 为细化模式(包括inside对内部网格进行细化 outside distance根据距表面网格距离进行细化),levels 为细化等级
    locationInMesh (100 100 100); //规定哪边网格是流域
    allowFreeStandingZoneFaces true; // 允许自由区域面
    

    }

    snapControls
    {
    nSmoothPatch 3; // 平滑次数
    tolerance 0.5; // 两个网格点之间的最大距离
    nSolveIter 50; // 迭代次数
    nRelaxIter 8; // 松弛次数
    nFeatureSnapIter 10; // 特征边缘迭代次数
    implicitFeatureSnap true; // 隐式特征边缘
    explicitFeatureSnap true; // 显式特征边缘
    multiRegionFeatureSnap false; // 多区域特征边缘
    }

    addLayersControls
    {
    relativeSizes false; // 相对大小/绝对大小
    layers
    {
    building {nSurfaceLayers 1;}
    }

    expansionRatio 1; // 扩展比例
    finalLayerThickness 0.3; // 最外层厚度
    minThickness 0.001; // 最小厚度
    nGrow 0; // 增长层数
    
    // 高级设置:
    
    featureAngle 80;  // 表面层生成的特征角度。0 表示平面,90 表示直角。如果几何表面的角度超过 80 度,则停止挤出层。
    nRelaxIter 5;  // 层生成过程中,最大允许的松弛迭代次数。用于平滑网格,防止扭曲或变形。
    nSmoothSurfaceNormals 1;  // 对表面法线的平滑处理次数,用于减少表面网格的尖锐突变。
    nSmoothNormals 5;  // 对网格内部运动方向的平滑处理迭代次数,确保网格平滑地向外扩展。
    nSmoothThickness 10;  // 平滑表面层厚度的迭代次数,数值越大,厚度分布越均匀。
    maxFaceThicknessRatio 0.5;  // 如果网格面太过扭曲(厚度超过此比值),则停止层生长。防止生成变形严重的网格。
    maxThicknessToMedialRatio 0.3;  // 层厚度与中线距离的比值,防止厚度过大时停止层的生长。
    minMedianAxisAngle 130;  // 中线轴的最小角度。如果角度过小,可能会跳过层生成。通常用于复杂几何体的细化。
    nBufferCellsNoExtrude 0;  // 用于新层终止时创建的缓冲区单元数,防止层过度扩展。
    nLayerIter 50;  // 添加层的最大迭代次数,限制网格生成过程中层生长的迭代次数
    

    }
    // 控制网格质量的设置。任何无法处理的阶段将根据这些设置回退操作。
    meshQualityControls
    {
    maxNonOrtho 65; // 允许的最大非正交角(度数),控制网格的正交性。
    maxBoundarySkewness 4; // 网格边界倾斜度的最大允许值。
    maxInternalSkewness 4; // 内部网格单元的最大倾斜度。
    maxConcave 80; // 允许的最大凹角(度数),控制网格单元的形状。
    maxFaceDiff 2;
    minFlatness 0.5; // 允许的最小平面度,确保网格面不过于扭曲。
    minVol 1e-13; // 允许的最小单元体积,避免生成过小的网格单元。
    minTetQuality 1e-8; // 四面体网格单元的最小质量。
    minArea -1; // 最小网格面面积,-1 表示忽略此限制。
    minTwist 0.02; // 网格单元的最小扭曲度,确保网格质量。
    minDeterminant 0.001; // 网格最小行列式值,衡量网格形状的质量。
    minFaceWeight 0.02; // 网格面权重的最小值,用于衡量网格面质量。
    minVolRatio 0.01; // 最小网格体积比,衡量相邻单元的体积差异。
    minTriangleTwist -1; // 最小三角形扭曲度,-1 表示忽略此限制。

    // 高级设置:
    nSmoothScale 5;  // 控制网格平滑的比例,数值越大,网格越平整。
    errorReduction 0.75;  // 错误减少系数,控制每次迭代中如何减少网格问题。
    

    }

    // 高级设置:是否启用调试信息
    debug 0; // 设置为 0 表示关闭调试信息。

    // 网格合并容差。相邻网格单元如果在此容差范围内,将被合并。
    // 容差值是初始网格边界框尺寸的一个分数。
    mergeTolerance 1E-5; // 合并容差,值越大,网格越容易被合并。

    // ************************************************************************* //


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    我想进一步加上距离建筑逐步加密
    building
    {
    mode distance;
    levels ((5.0 3) (15.0 2) (30.0 1));
    }
    我添加了
    refinementRegions
    {
    building
    {
    mode distance;
    levels ((5.0 3) (15.0 2) (30.0 1));
    }
    refinementBox_building
    {
    mode inside;
    levels ((1 2));
    }
    }
    目前还在运行,我有一个困惑,我想要同时对建筑与植被加密,我是否应该设置refinementBox_building同时包含建筑和植被,还是说建筑一个Box,植被一个box。而且我的植被网格是通过toposet设置的,我有点不清楚是否应该在snappyHexMesh中设置。
    还有一个我不清楚的点,我想要做的是用圆形作为边界,目前还是以blockMesh的矩形构成的比阿姐。这里面我是要将side_0-7,top, ground等都放到refinementSurfaces对吗,还是说refinementRegions 也要加上,我现在对这两个部分有点混淆。


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    我进行了修改,只加密了建筑,以及设置了Box,图片是目前的结果,看上去实现了部分局部加密,但是我不太理解为什么会有条曲线。
    image.png
    /--------------------------------- C++ -----------------------------------
    | ========= | |
    | \ / F ield | OpenFOAM: The Open Source CFD Toolbox |
    | \ / O peration | Version: 2.2.0 |
    | \ / A nd | Web: www.OpenFOAM.org |
    | \/ M anipulation | |
    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    object snappyHexMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    // Which of the steps to run
    castellatedMesh true; // make basic mesh ?
    snap true; // decide to snap back to surface ?
    addLayers false; // decide to add viscous layers ?

    geometry // 录入STL文件
    {

    side_mesh_0_45.stl {type triSurfaceMesh; name side_0;}
    side_mesh_45_90.stl {type triSurfaceMesh; name side_1;}
    side_mesh_90_135.stl {type triSurfaceMesh; name side_2;}
    side_mesh_135_180.stl {type triSurfaceMesh; name side_3;}
    side_mesh_180_225.stl {type triSurfaceMesh; name side_4;}
    side_mesh_225_270.stl {type triSurfaceMesh; name side_5;}
    side_mesh_270_315.stl {type triSurfaceMesh; name side_6;}
    side_mesh_315_360.stl {type triSurfaceMesh; name side_7;}
    
    
    
    top_mesh.stl {type triSurfaceMesh; name top;}
    
    building.stl {type triSurfaceMesh; name building;}
    grassland.stl {type triSurfaceMesh; name grassland;}
    ground.stl {type triSurfaceMesh; name ground;}
    water.stl {type triSurfaceMesh; name water;}
    
    tree.stl {type triSurfaceMesh; name tree;}
    
    refinementBox_building
    {
        type searchableBox;
    
        min ( 740 -610 15);
        max ( 2250  860 280);
    }
    

    };

    castellatedMeshControls
    {
    maxLocalCells 1500000; // 每个 CPU 核心允许使用的最大网格单元数,避免某个核心负载过重
    maxGlobalCells 15000000; // 全局允许的最大网格单元数,在细化阶段如果超过这个数量,系统将触发删除操作,防止内存溢出
    maxRefinementIterations 3; // 有效地限制整体迭代次数
    minRefinementCells 10; // 提高触发终止的阈值 maxLoadUnbalance 0.10; // 允许的最大负载不平衡度,表示各个 CPU 核心之间的工作负载差异最多为 10%,确保负载均衡
    nCellsBetweenLevels 2; // 不同细化等级之间的网格扩展因子,设置为 1 表示高细化区域与低细化区域之间的过渡最平滑
    maxShellRefinementIter 10;
    // 边缘特征细化程度
    features
    (
    {file "building.eMesh"; level 1;}
    );

    refinementSurfaces
    {
        building {
            level (3 3);
            patchInfo
            {
                type wall; 
                inGroups (building);
            }
        }
    
    }
    
    resolveFeatureAngle 60; // 特征边缘角度,小于这个角度的边缘将被忽略
    refinementRegions 
    {
        refinementBox_building
        {
            mode inside;
            levels ((1 2));
        }
    }
    // {wholeDomain {mode inside; levels ((1 1));}} // 细化区域,mode 为细化模式,levels 为细化等级
    // {building {mode distance; levels ((1 2) (3 1));}} // 细化区域,mode 为细化模式,levels 为细化等级mode 为细化模式(包括inside对内部网格进行细化 outside distance根据距表面网格距离进行细化),levels 为细化等级
    locationInMesh (100 100 100); //规定哪边网格是流域
    allowFreeStandingZoneFaces true; // 允许自由区域面
    

    }

    snapControls
    {
    nSmoothPatch 3; // 平滑次数
    tolerance 0.5; // 两个网格点之间的最大距离
    nSolveIter 50; // 迭代次数
    nRelaxIter 8; // 松弛次数
    nFeatureSnapIter 10; // 特征边缘迭代次数
    implicitFeatureSnap true; // 隐式特征边缘
    explicitFeatureSnap false; // 显式特征边缘
    multiRegionFeatureSnap false; // 多区域特征边缘
    }

    addLayersControls
    {
    relativeSizes false; // 相对大小/绝对大小
    layers
    {
    building {nSurfaceLayers 1;}
    }

    expansionRatio 1; // 扩展比例
    finalLayerThickness 0.3; // 最外层厚度
    minThickness 0.001; // 最小厚度
    nGrow 0; // 增长层数
    
    // 高级设置:
    
    featureAngle 80;  // 表面层生成的特征角度。0 表示平面,90 表示直角。如果几何表面的角度超过 80 度,则停止挤出层。
    nRelaxIter 5;  // 层生成过程中,最大允许的松弛迭代次数。用于平滑网格,防止扭曲或变形。
    nSmoothSurfaceNormals 1;  // 对表面法线的平滑处理次数,用于减少表面网格的尖锐突变。
    nSmoothNormals 5;  // 对网格内部运动方向的平滑处理迭代次数,确保网格平滑地向外扩展。
    nSmoothThickness 10;  // 平滑表面层厚度的迭代次数,数值越大,厚度分布越均匀。
    maxFaceThicknessRatio 0.5;  // 如果网格面太过扭曲(厚度超过此比值),则停止层生长。防止生成变形严重的网格。
    maxThicknessToMedialRatio 0.3;  // 层厚度与中线距离的比值,防止厚度过大时停止层的生长。
    minMedianAxisAngle 130;  // 中线轴的最小角度。如果角度过小,可能会跳过层生成。通常用于复杂几何体的细化。
    nBufferCellsNoExtrude 0;  // 用于新层终止时创建的缓冲区单元数,防止层过度扩展。
    nLayerIter 50;  // 添加层的最大迭代次数,限制网格生成过程中层生长的迭代次数
    

    }
    // 控制网格质量的设置。任何无法处理的阶段将根据这些设置回退操作。
    meshQualityControls
    {
    maxNonOrtho 65; // 允许的最大非正交角(度数),控制网格的正交性。
    maxBoundarySkewness 4; // 网格边界倾斜度的最大允许值。
    maxInternalSkewness 4; // 内部网格单元的最大倾斜度。
    maxConcave 80; // 允许的最大凹角(度数),控制网格单元的形状。
    maxFaceDiff 2;
    minFlatness 0.5; // 允许的最小平面度,确保网格面不过于扭曲。
    minVol 1e-13; // 允许的最小单元体积,避免生成过小的网格单元。
    minTetQuality 1e-8; // 四面体网格单元的最小质量。
    minArea -1; // 最小网格面面积,-1 表示忽略此限制。
    minTwist 0.02; // 网格单元的最小扭曲度,确保网格质量。
    minDeterminant 0.001; // 网格最小行列式值,衡量网格形状的质量。
    minFaceWeight 0.02; // 网格面权重的最小值,用于衡量网格面质量。
    minVolRatio 0.01; // 最小网格体积比,衡量相邻单元的体积差异。
    minTriangleTwist -1; // 最小三角形扭曲度,-1 表示忽略此限制。

    // 高级设置:
    nSmoothScale 5;  // 控制网格平滑的比例,数值越大,网格越平整。
    errorReduction 0.75;  // 错误减少系数,控制每次迭代中如何减少网格问题。
    

    }

    // 高级设置:是否启用调试信息
    debug 0; // 设置为 0 表示关闭调试信息。

    // 网格合并容差。相邻网格单元如果在此容差范围内,将被合并。
    // 容差值是初始网格边界框尺寸的一个分数。
    mergeTolerance 1E-5; // 合并容差,值越大,网格越容易被合并。

    // ************************************************************************* //


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    会和toposet有关吗,我为了将树冠设置为多孔介质,设置了这个代码。另外我使用foamToVTK -latestTime生成的vtk查看了文件,这是对的吗。求大佬解答
    /--------------------------------- C++ -----------------------------------\

    \ / F ield OpenFOAM: The Open Source CFD Toolbox
    \ / O peration Website: https://openfoam.org
    \ / A nd Version: 6
    \/ M anipulation

    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    location "system";
    object topoSetDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    actions
    (
    {
    name treeCellSet;
    type cellSet;
    action new;
    source surfaceToCell;
    sourceInfo
    {
    file "constant/triSurface/tree.stl";
    outsidePoints ((2000 2000 200)); // 确保该点在 STL 外部
    nearDistance 5; // 选取距离表面 5m 内的单元
    includeCut true;
    includeInside true;
    includeOutside false;
    curvature 0; // 加入 curvature 参数,避免报错
    }
    }

    {
        name    treeZone;
        type    cellZoneSet;
        action  new;
        source  setToCellZone;
        sourceInfo
        {
            set treeCellSet;
        }
    }
    

    );

    // ************************************************************************* //


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    求大佬解答,或者发一个已经有逐层加密的示例代码也成。


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    @ice_flow
    f91f783c-2f93-4110-b8e1-55ff896f7367-image.png
    38a2172a-b4f1-4ea3-a733-ed8dc34ed181-image.png
    目前我生成了结果如图片所示,但似乎没有逐层加密,能看到紧贴着轮廓有小的网格,但我不知道这样的做法是否正确。
    下面是我的配置代码,我放上了snappyHexMeshDict和blockMeshDict
    /--------------------------------- C++ -----------------------------------
    | ========= | |
    | \ / F ield | OpenFOAM: The Open Source CFD Toolbox |
    | \ / O peration | Version: 2.2.0 |
    | \ / A nd | Web: www.OpenFOAM.org |
    | \/ M anipulation | |
    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    object snappyHexMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    // Which of the steps to run
    castellatedMesh true; // make basic mesh ?
    snap true; // decide to snap back to surface ?
    addLayers false; // decide to add viscous layers ?

    geometry // 录入STL文件
    {

    side_mesh_0_45.stl {type triSurfaceMesh; name side_0;}
    side_mesh_45_90.stl {type triSurfaceMesh; name side_1;}
    side_mesh_90_135.stl {type triSurfaceMesh; name side_2;}
    side_mesh_135_180.stl {type triSurfaceMesh; name side_3;}
    side_mesh_180_225.stl {type triSurfaceMesh; name side_4;}
    side_mesh_225_270.stl {type triSurfaceMesh; name side_5;}
    side_mesh_270_315.stl {type triSurfaceMesh; name side_6;}
    side_mesh_315_360.stl {type triSurfaceMesh; name side_7;}
    
    
    
    top_mesh.stl {type triSurfaceMesh; name top;}
    
    building.stl {type triSurfaceMesh; name building;}
    grassland.stl {type triSurfaceMesh; name grassland;}
    ground.stl {type triSurfaceMesh; name ground;}
    water.stl {type triSurfaceMesh; name water;}
    
    tree.stl {type triSurfaceMesh; name tree;}
    
    //refinementBox {type searchableBox; min (-1500 -1500 -5); max (2200 2200 600);}
    // 建筑加密搜索盒
    

    // refinementBox_building
    //{
    // type searchableBox;
    //
    // min ( 740 -610 15);
    // max ( 2250 860 280);
    //}

    // 树木加密搜索盒
    

    // refinementBox_tree
    //{
    // type searchableBox;
    // // 同理,这里改成包围你的植被群
    // min (720 -600 15);
    // max (2250 860 80);
    //}
    };

    castellatedMeshControls
    {
    maxLocalCells 1500000; // 每个 CPU 核心允许使用的最大网格单元数,避免某个核心负载过重
    maxGlobalCells 15000000; // 全局允许的最大网格单元数,在细化阶段如果超过这个数量,系统将触发删除操作,防止内存溢出
    maxRefinementIterations 3; // 有效地限制整体迭代次数
    minRefinementCells 10; // 提高触发终止的阈值 maxLoadUnbalance 0.10; // 允许的最大负载不平衡度,表示各个 CPU 核心之间的工作负载差异最多为 10%,确保负载均衡
    nCellsBetweenLevels 2; // 不同细化等级之间的网格扩展因子,设置为 1 表示高细化区域与低细化区域之间的过渡最平滑
    maxShellRefinementIter 10;
    // 边缘特征细化程度
    features
    (
    {file "building.eMesh"; level 2;}
    {file "tree.eMesh"; level 0;}

        {file "side_mesh_0_45.eMesh"; level 0;}
        {file "side_mesh_45_90.eMesh"; level 0;}
        {file "side_mesh_90_135.eMesh"; level 0;}
        {file "side_mesh_135_180.eMesh"; level 0;}
        {file "side_mesh_180_225.eMesh"; level 0;}
        {file "side_mesh_225_270.eMesh"; level 0;}
        {file "side_mesh_270_315.eMesh"; level 0;}
        {file "side_mesh_315_360.eMesh"; level 0;}
    
        {file "top_mesh.eMesh"; level 0;}
        {file "grassland.eMesh"; level 0;}
        {file "ground.eMesh"; level 0;}
        {file "water.eMesh"; level 0;}
    );
    
    refinementSurfaces
    {
        building {
            level (1 1);
            patchInfo
            {
                type wall; 
                inGroups (building);
            }
        }
        
        side_0 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_1 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_2 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_3 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_4 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_5 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_6 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_7 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
    
        top {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (top);
            }
        }
    
        grassland {
            level (1 2);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        ground {
            level (1 2);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        water {
            level (1 2);            
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
    
    }
    
    resolveFeatureAngle 60; // 特征边缘角度,小于这个角度的边缘将被忽略
    refinementRegions {
        building
        {
            mode distance;
            levels ((5.0 3) (15.0 2) (30.0 1));
        }
         tree
     {
        mode inside;
         levels ((0 1));
         cellZone treeZone;
     }
    }
    // {wholeDomain {mode inside; levels ((1 1));}} // 细化区域,mode 为细化模式,levels 为细化等级
    // {building {mode distance; levels ((1 2) (3 1));}} // 细化区域,mode 为细化模式,levels 为细化等级mode 为细化模式(包括inside对内部网格进行细化 outside distance根据距表面网格距离进行细化),levels 为细化等级
    locationInMesh (100 100 100); //规定哪边网格是流域
    allowFreeStandingZoneFaces true; // 允许自由区域面
    

    }

    snapControls
    {
    nSmoothPatch 3; // 平滑次数
    tolerance 0.5; // 两个网格点之间的最大距离
    nSolveIter 50; // 迭代次数
    nRelaxIter 8; // 松弛次数
    nFeatureSnapIter 10; // 特征边缘迭代次数
    implicitFeatureSnap true; // 隐式特征边缘
    explicitFeatureSnap true; // 显式特征边缘
    multiRegionFeatureSnap false; // 多区域特征边缘
    }

    addLayersControls
    {
    relativeSizes false; // 相对大小/绝对大小
    layers
    {
    building {nSurfaceLayers 1;}
    }

    expansionRatio 1; // 扩展比例
    finalLayerThickness 0.3; // 最外层厚度
    minThickness 0.001; // 最小厚度
    nGrow 0; // 增长层数
    
    // 高级设置:
    
    featureAngle 80;  // 表面层生成的特征角度。0 表示平面,90 表示直角。如果几何表面的角度超过 80 度,则停止挤出层。
    nRelaxIter 5;  // 层生成过程中,最大允许的松弛迭代次数。用于平滑网格,防止扭曲或变形。
    nSmoothSurfaceNormals 1;  // 对表面法线的平滑处理次数,用于减少表面网格的尖锐突变。
    nSmoothNormals 5;  // 对网格内部运动方向的平滑处理迭代次数,确保网格平滑地向外扩展。
    nSmoothThickness 10;  // 平滑表面层厚度的迭代次数,数值越大,厚度分布越均匀。
    maxFaceThicknessRatio 0.5;  // 如果网格面太过扭曲(厚度超过此比值),则停止层生长。防止生成变形严重的网格。
    maxThicknessToMedialRatio 0.3;  // 层厚度与中线距离的比值,防止厚度过大时停止层的生长。
    minMedianAxisAngle 130;  // 中线轴的最小角度。如果角度过小,可能会跳过层生成。通常用于复杂几何体的细化。
    nBufferCellsNoExtrude 0;  // 用于新层终止时创建的缓冲区单元数,防止层过度扩展。
    nLayerIter 50;  // 添加层的最大迭代次数,限制网格生成过程中层生长的迭代次数
    

    }
    // 控制网格质量的设置。任何无法处理的阶段将根据这些设置回退操作。
    meshQualityControls
    {
    maxNonOrtho 180;
    maxBoundarySkewness 20;
    maxInternalSkewness 4;
    maxConcave 180;
    minVol 1e-30;
    minTetQuality 1e-30;
    minArea -1;
    minTwist -2;
    minDeterminant 1e-30;
    minFaceWeight 1e-30;
    minVolRatio 1e-30;
    minTriangleTwist -1;
    nSmoothScale 4;
    errorReduction 0.75;
    }

    // 高级设置:是否启用调试信息
    debug 0; // 设置为 0 表示关闭调试信息。

    // 网格合并容差。相邻网格单元如果在此容差范围内,将被合并。
    // 容差值是初始网格边界框尺寸的一个分数。
    mergeTolerance 1E-5; // 合并容差,值越大,网格越容易被合并。

    // ************************************************************************* //

    /--------------------------------- C++ -----------------------------------
    | ========= | |
    | \ / F ield | OpenFOAM: The Open Source CFD Toolbox |
    | \ / O peration | Version: 2.0.1 |
    | \ / A nd | Web: www.OpenFOAM.com |
    | \/ M anipulation | |
    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    object blockMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    scale 1; // 单位为米

    vertices // (x, y, z) 坐标,需要比实际模型略大。需要注意的是边角点的编辑需要按照立方体的编写顺序,与下面保持一致

    (
    // 略大于截图中的 range
    (-720 -2080 0) // 0
    (3680 -2080 0) // 1
    (3680 2320 0) // 2
    (-720 2320 0) // 3
    (-720 -2080 760) // 4
    (3680 -2080 760) // 5
    (3680 2320 760) // 6
    (-720 2320 760) // 7
    );
    edges // 没有曲线可以空着
    (
    );

    blocks
    (
    // 一个六面体:0-1-2-3 + 4-5-6-7
    // 你可以调节 (200 200 200) 改变每个方向网格数
    hex (0 1 2 3 4 5 6 7)
    (880 880 152)
    simpleGrading (1 1 3)
    );

    boundary
    (
    front
    {
    type patch;
    faces
    (
    (0 4 7 3)
    );
    }

    back
    {
        type patch;
        faces
        (
            (1 2 6 5)
        );
    }
    
    leftAndRight
    {
        type patch;
        faces
        (
            (2 3 7 6)  // 右侧面
            (0 1 5 4)  // 左侧面
        );
    }
    
    top
    {
        type patch;
        faces
        (
            (4 5 6 7)
        );
    }
    
    bottom
    {
        type patch;
        faces
        (
            (0 3 2 1)
        );
    }
    

    );

    mergePatchPairs
    (
    );


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    @chenboyao 这个是我上一个代码删除了Box的结果,我现在尝试下面的参数代码,正在跑。我现在有点不清楚具体是什么样的配置会产生不同距离不同网格大小的网格。我希望越靠近建筑网格越小

    /--------------------------------- C++ -----------------------------------
    | ========= | |
    | \ / F ield | OpenFOAM: The Open Source CFD Toolbox |
    | \ / O peration | Version: 2.2.0 |
    | \ / A nd | Web: www.OpenFOAM.org |
    | \/ M anipulation | |
    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    object snappyHexMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    // Which of the steps to run
    castellatedMesh true; // make basic mesh ?
    snap true; // decide to snap back to surface ?
    addLayers false; // decide to add viscous layers ?

    geometry // 录入STL文件
    {

    side_mesh_0_45.stl {type triSurfaceMesh; name side_0;}
    side_mesh_45_90.stl {type triSurfaceMesh; name side_1;}
    side_mesh_90_135.stl {type triSurfaceMesh; name side_2;}
    side_mesh_135_180.stl {type triSurfaceMesh; name side_3;}
    side_mesh_180_225.stl {type triSurfaceMesh; name side_4;}
    side_mesh_225_270.stl {type triSurfaceMesh; name side_5;}
    side_mesh_270_315.stl {type triSurfaceMesh; name side_6;}
    side_mesh_315_360.stl {type triSurfaceMesh; name side_7;}
    
    
    
    top_mesh.stl {type triSurfaceMesh; name top;}
    
    building.stl {type triSurfaceMesh; name building;}
    grassland.stl {type triSurfaceMesh; name grassland;}
    ground.stl {type triSurfaceMesh; name ground;}
    water.stl {type triSurfaceMesh; name water;}
    
    tree.stl {type triSurfaceMesh; name tree;}
    
    //refinementBox {type searchableBox; min (-1500 -1500 -5); max (2200 2200 600);}
    // 建筑加密搜索盒
    

    // refinementBox_building
    //{
    // type searchableBox;
    //
    // min ( 740 -610 15);
    // max ( 2250 860 280);
    //}

    // 树木加密搜索盒
    

    // refinementBox_tree
    //{
    // type searchableBox;
    // // 同理,这里改成包围你的植被群
    // min (720 -600 15);
    // max (2250 860 80);
    //}
    };

    castellatedMeshControls
    {
    maxLocalCells 1500000; // 每个 CPU 核心允许使用的最大网格单元数,避免某个核心负载过重
    maxGlobalCells 15000000; // 全局允许的最大网格单元数,在细化阶段如果超过这个数量,系统将触发删除操作,防止内存溢出
    maxRefinementIterations 3; // 有效地限制整体迭代次数
    minRefinementCells 10; // 提高触发终止的阈值 maxLoadUnbalance 0.10; // 允许的最大负载不平衡度,表示各个 CPU 核心之间的工作负载差异最多为 10%,确保负载均衡
    nCellsBetweenLevels 2; // 不同细化等级之间的网格扩展因子,设置为 1 表示高细化区域与低细化区域之间的过渡最平滑
    maxShellRefinementIter 10;
    // 边缘特征细化程度
    features
    (
    {file "building.eMesh"; level 2;}
    {file "tree.eMesh"; level 0;}

        {file "side_mesh_0_45.eMesh"; level 0;}
        {file "side_mesh_45_90.eMesh"; level 0;}
        {file "side_mesh_90_135.eMesh"; level 0;}
        {file "side_mesh_135_180.eMesh"; level 0;}
        {file "side_mesh_180_225.eMesh"; level 0;}
        {file "side_mesh_225_270.eMesh"; level 0;}
        {file "side_mesh_270_315.eMesh"; level 0;}
        {file "side_mesh_315_360.eMesh"; level 0;}
    
        {file "top_mesh.eMesh"; level 0;}
        {file "grassland.eMesh"; level 0;}
        {file "ground.eMesh"; level 0;}
        {file "water.eMesh"; level 0;}
    );
    
    refinementSurfaces
    {
        building {
            level (1 1);
            patchInfo
            {
                type wall; 
                inGroups (building);
            }
        }
        
        side_0 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_1 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_2 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_3 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_4 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_5 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_6 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_7 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
    
        top {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (top);
            }
        }
    
        grassland {
            level (1 2);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        ground {
            level (1 2);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        water {
            level (1 2);            
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
    
    }
    
    resolveFeatureAngle 60; // 特征边缘角度,小于这个角度的边缘将被忽略
    refinementRegions {
        building
        {
            mode distance;
            levels ((5.0 3) (15.0 2) (30.0 1));
        }
         tree
     {
        mode inside;
         levels ((0 1));
         cellZone treeZone;
     }
    }
    // {wholeDomain {mode inside; levels ((1 1));}} // 细化区域,mode 为细化模式,levels 为细化等级
    // {building {mode distance; levels ((1 2) (3 1));}} // 细化区域,mode 为细化模式,levels 为细化等级mode 为细化模式(包括inside对内部网格进行细化 outside distance根据距表面网格距离进行细化),levels 为细化等级
    locationInMesh (100 100 100); //规定哪边网格是流域
    allowFreeStandingZoneFaces true; // 允许自由区域面
    

    }

    snapControls
    {
    nSmoothPatch 3; // 平滑次数
    tolerance 0.5; // 两个网格点之间的最大距离
    nSolveIter 50; // 迭代次数
    nRelaxIter 8; // 松弛次数
    nFeatureSnapIter 10; // 特征边缘迭代次数
    implicitFeatureSnap true; // 隐式特征边缘
    explicitFeatureSnap true; // 显式特征边缘
    multiRegionFeatureSnap false; // 多区域特征边缘
    }

    addLayersControls
    {
    relativeSizes false; // 相对大小/绝对大小
    layers
    {
    building {nSurfaceLayers 1;}
    }

    expansionRatio 1; // 扩展比例
    finalLayerThickness 0.3; // 最外层厚度
    minThickness 0.001; // 最小厚度
    nGrow 0; // 增长层数
    
    // 高级设置:
    
    featureAngle 80;  // 表面层生成的特征角度。0 表示平面,90 表示直角。如果几何表面的角度超过 80 度,则停止挤出层。
    nRelaxIter 5;  // 层生成过程中,最大允许的松弛迭代次数。用于平滑网格,防止扭曲或变形。
    nSmoothSurfaceNormals 1;  // 对表面法线的平滑处理次数,用于减少表面网格的尖锐突变。
    nSmoothNormals 5;  // 对网格内部运动方向的平滑处理迭代次数,确保网格平滑地向外扩展。
    nSmoothThickness 10;  // 平滑表面层厚度的迭代次数,数值越大,厚度分布越均匀。
    maxFaceThicknessRatio 0.5;  // 如果网格面太过扭曲(厚度超过此比值),则停止层生长。防止生成变形严重的网格。
    maxThicknessToMedialRatio 0.3;  // 层厚度与中线距离的比值,防止厚度过大时停止层的生长。
    minMedianAxisAngle 130;  // 中线轴的最小角度。如果角度过小,可能会跳过层生成。通常用于复杂几何体的细化。
    nBufferCellsNoExtrude 0;  // 用于新层终止时创建的缓冲区单元数,防止层过度扩展。
    nLayerIter 50;  // 添加层的最大迭代次数,限制网格生成过程中层生长的迭代次数
    

    }
    // 控制网格质量的设置。任何无法处理的阶段将根据这些设置回退操作。
    meshQualityControls
    {
    maxNonOrtho 180;
    maxBoundarySkewness 20;
    maxInternalSkewness 4;
    maxConcave 180;
    minVol 1e-30;
    minTetQuality 1e-30;
    minArea -1;
    minTwist -2;
    minDeterminant 1e-30;
    minFaceWeight 1e-30;
    minVolRatio 1e-30;
    minTriangleTwist -1;
    nSmoothScale 4;
    errorReduction 0.75;
    }

    // 高级设置:是否启用调试信息
    debug 0; // 设置为 0 表示关闭调试信息。

    // 网格合并容差。相邻网格单元如果在此容差范围内,将被合并。
    // 容差值是初始网格边界框尺寸的一个分数。
    mergeTolerance 1E-5; // 合并容差,值越大,网格越容易被合并。

    // ************************************************************************* //


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    @ice_flow
    我多截了几个图,像下面这样。
    bb228655-b473-4a9d-9137-c172e1ae8fe4-image.png 3a386e7d-f38b-48c9-bffe-2ab8b6ef61dd-image.png
    928f2689-ecb4-4cda-a909-5df0d01a1134-image.png
    “为什么在refinementRegions只设置了building和tree,而且这两者似乎也没有统一。”
    我是根据GPT的回答和一些示例设置的,我不知道这样设置是否正确。我这两天删除了refinementBox也是一样的效果。也许是您说的refinementSurfaces和refinementRegions设置不一致导致的吗。我只是希望靠近building和tree附近的网格按照距离逐层加密,所以才只设置了这两个。


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    @ice_flow 538da608-28d7-47ee-9628-a8f0b97e7cbd-image.png
    我用foamToVTK导出了网格,这个图片是internal.vtu但是仍然好像每个网格都是等大的。我设置了refinementRegions的mode distance,但是好像没有预想的那样。请问大佬我有地方出错了吗,下面是我的snappyHexMeshDict。
    /--------------------------------- C++ -----------------------------------
    | ========= | |
    | \ / F ield | OpenFOAM: The Open Source CFD Toolbox |
    | \ / O peration | Version: 2.2.0 |
    | \ / A nd | Web: www.OpenFOAM.org |
    | \/ M anipulation | |
    *---------------------------------------------------------------------------*/
    FoamFile
    {
    version 2.0;
    format ascii;
    class dictionary;
    object snappyHexMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

    // Which of the steps to run
    castellatedMesh true; // make basic mesh ?
    snap true; // decide to snap back to surface ?
    addLayers false; // decide to add viscous layers ?

    geometry // 录入STL文件
    {

    side_mesh_0_45.stl {type triSurfaceMesh; name side_0;}
    side_mesh_45_90.stl {type triSurfaceMesh; name side_1;}
    side_mesh_90_135.stl {type triSurfaceMesh; name side_2;}
    side_mesh_135_180.stl {type triSurfaceMesh; name side_3;}
    side_mesh_180_225.stl {type triSurfaceMesh; name side_4;}
    side_mesh_225_270.stl {type triSurfaceMesh; name side_5;}
    side_mesh_270_315.stl {type triSurfaceMesh; name side_6;}
    side_mesh_315_360.stl {type triSurfaceMesh; name side_7;}
    
    
    
    top_mesh.stl {type triSurfaceMesh; name top;}
    
    building.stl {type triSurfaceMesh; name building;}
    grassland.stl {type triSurfaceMesh; name grassland;}
    ground.stl {type triSurfaceMesh; name ground;}
    water.stl {type triSurfaceMesh; name water;}
    
    tree.stl {type triSurfaceMesh; name tree;}
    
    refinementBox {type searchableBox; min (-1500 -1500 -5); max (2200 2200 600);}
    // 建筑加密搜索盒
    refinementBox_building
    {
        type searchableBox;
    
        min ( 740 -610 15);
        max ( 2250  860 280);
    }
    
    // 树木加密搜索盒
    refinementBox_tree
    {
        type searchableBox;
        // 同理,这里改成包围你的植被群
        min (720 -600 15);
        max (2250 860 80);
    }
    

    };

    castellatedMeshControls
    {
    maxLocalCells 1500000; // 每个 CPU 核心允许使用的最大网格单元数,避免某个核心负载过重
    maxGlobalCells 15000000; // 全局允许的最大网格单元数,在细化阶段如果超过这个数量,系统将触发删除操作,防止内存溢出
    maxRefinementIterations 3; // 有效地限制整体迭代次数
    minRefinementCells 10; // 提高触发终止的阈值 maxLoadUnbalance 0.10; // 允许的最大负载不平衡度,表示各个 CPU 核心之间的工作负载差异最多为 10%,确保负载均衡
    nCellsBetweenLevels 2; // 不同细化等级之间的网格扩展因子,设置为 1 表示高细化区域与低细化区域之间的过渡最平滑
    maxShellRefinementIter 10;
    // 边缘特征细化程度
    features
    (
    {file "building.eMesh"; level 2;}
    {file "tree.eMesh"; level 0;}

        {file "side_mesh_0_45.eMesh"; level 0;}
        {file "side_mesh_45_90.eMesh"; level 0;}
        {file "side_mesh_90_135.eMesh"; level 0;}
        {file "side_mesh_135_180.eMesh"; level 0;}
        {file "side_mesh_180_225.eMesh"; level 0;}
        {file "side_mesh_225_270.eMesh"; level 0;}
        {file "side_mesh_270_315.eMesh"; level 0;}
        {file "side_mesh_315_360.eMesh"; level 0;}
    
        {file "top_mesh.eMesh"; level 0;}
        {file "grassland.eMesh"; level 0;}
        {file "ground.eMesh"; level 0;}
        {file "water.eMesh"; level 0;}
    );
    
    refinementSurfaces
    {
        building {
            level (2 3);
            patchInfo
            {
                type wall; 
                inGroups (building);
            }
        }
        
        side_0 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_1 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_2 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_3 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_4 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_5 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_6 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
        side_7 {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (side);
            }
        }
    
        top {
            level (1 1);
            patchInfo
            {
                type patch;
                inGroups (top);
            }
        }
    
        grassland {
            level (1 2);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        ground {
            level (1 2);
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
        water {
            level (1 2);            
            patchInfo
            {
                type wall;
                inGroups (ground);
            }
        }
    
    }
    
    resolveFeatureAngle 60; // 特征边缘角度,小于这个角度的边缘将被忽略
    refinementRegions {
        building
        {
            mode distance;
            levels ((5.0 3) (10.0 2) (30.0 1));
        }
         tree
     {
        mode inside;
         levels ((0 1));
         cellZone treeZone;
     }
    }
    // {wholeDomain {mode inside; levels ((1 1));}} // 细化区域,mode 为细化模式,levels 为细化等级
    // {building {mode distance; levels ((1 2) (3 1));}} // 细化区域,mode 为细化模式,levels 为细化等级mode 为细化模式(包括inside对内部网格进行细化 outside distance根据距表面网格距离进行细化),levels 为细化等级
    locationInMesh (100 100 100); //规定哪边网格是流域
    allowFreeStandingZoneFaces true; // 允许自由区域面
    

    }

    snapControls
    {
    nSmoothPatch 3; // 平滑次数
    tolerance 0.5; // 两个网格点之间的最大距离
    nSolveIter 50; // 迭代次数
    nRelaxIter 8; // 松弛次数
    nFeatureSnapIter 10; // 特征边缘迭代次数
    implicitFeatureSnap true; // 隐式特征边缘
    explicitFeatureSnap true; // 显式特征边缘
    multiRegionFeatureSnap false; // 多区域特征边缘
    }

    addLayersControls
    {
    relativeSizes false; // 相对大小/绝对大小
    layers
    {
    building {nSurfaceLayers 1;}
    }

    expansionRatio 1; // 扩展比例
    finalLayerThickness 0.3; // 最外层厚度
    minThickness 0.001; // 最小厚度
    nGrow 0; // 增长层数
    
    // 高级设置:
    
    featureAngle 80;  // 表面层生成的特征角度。0 表示平面,90 表示直角。如果几何表面的角度超过 80 度,则停止挤出层。
    nRelaxIter 5;  // 层生成过程中,最大允许的松弛迭代次数。用于平滑网格,防止扭曲或变形。
    nSmoothSurfaceNormals 1;  // 对表面法线的平滑处理次数,用于减少表面网格的尖锐突变。
    nSmoothNormals 5;  // 对网格内部运动方向的平滑处理迭代次数,确保网格平滑地向外扩展。
    nSmoothThickness 10;  // 平滑表面层厚度的迭代次数,数值越大,厚度分布越均匀。
    maxFaceThicknessRatio 0.5;  // 如果网格面太过扭曲(厚度超过此比值),则停止层生长。防止生成变形严重的网格。
    maxThicknessToMedialRatio 0.3;  // 层厚度与中线距离的比值,防止厚度过大时停止层的生长。
    minMedianAxisAngle 130;  // 中线轴的最小角度。如果角度过小,可能会跳过层生成。通常用于复杂几何体的细化。
    nBufferCellsNoExtrude 0;  // 用于新层终止时创建的缓冲区单元数,防止层过度扩展。
    nLayerIter 50;  // 添加层的最大迭代次数,限制网格生成过程中层生长的迭代次数
    

    }
    // 控制网格质量的设置。任何无法处理的阶段将根据这些设置回退操作。
    meshQualityControls
    {
    maxNonOrtho 65; // 允许的最大非正交角(度数),控制网格的正交性。
    maxBoundarySkewness 4; // 网格边界倾斜度的最大允许值。
    maxInternalSkewness 4; // 内部网格单元的最大倾斜度。
    maxConcave 80; // 允许的最大凹角(度数),控制网格单元的形状。
    maxFaceDiff 2;
    minFlatness 0.5; // 允许的最小平面度,确保网格面不过于扭曲。
    minVol 1e-13; // 允许的最小单元体积,避免生成过小的网格单元。
    minTetQuality 1e-8; // 四面体网格单元的最小质量。
    minArea -1; // 最小网格面面积,-1 表示忽略此限制。
    minTwist 0.02; // 网格单元的最小扭曲度,确保网格质量。
    minDeterminant 0.001; // 网格最小行列式值,衡量网格形状的质量。
    minFaceWeight 0.02; // 网格面权重的最小值,用于衡量网格面质量。
    minVolRatio 0.01; // 最小网格体积比,衡量相邻单元的体积差异。
    minTriangleTwist -1; // 最小三角形扭曲度,-1 表示忽略此限制。

    // 高级设置:
    nSmoothScale 5;  // 控制网格平滑的比例,数值越大,网格越平整。
    errorReduction 0.75;  // 错误减少系数,控制每次迭代中如何减少网格问题。
    

    }

    // 高级设置:是否启用调试信息
    debug 0; // 设置为 0 表示关闭调试信息。

    // 网格合并容差。相邻网格单元如果在此容差范围内,将被合并。
    // 容差值是初始网格边界框尺寸的一个分数。
    mergeTolerance 1E-5; // 合并容差,值越大,网格越容易被合并。

    // ************************************************************************* //


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    @ice_flow 谢谢大佬


  • snappyHexMesh的网格加密问题。
    G Gengxiaotian

    我尝试使用snappyHexMesh对网格进行进一步的细化,但是我不理解为什么我的网格在运算完之后没有大小的变化。下面是我的snappyHexMeshdict,我是一个新手,我是按照案例修改的。我不知道目前是否正确,请问懂行的大佬问题出在了哪里。图片展示了我其中一次的生成效果,下面是在图片效果之后修改的。但实际上没有什么本质区别,我只是加多了blockMeshDict里面的网格大小。我不理解的点事为什么网格靠近建筑之后没有像其他案例中一层一层的加密就如同图2一样。@李东岳
    5a716988-7368-4906-b093-e6fd40a6ef55-aff66b0c98b57abe340265e2c8be7ed.jpg
    826aaa0d-82c1-41cc-ab20-06cd73c3a976-image.png

    
    /*--------------------------------*- C++ -*----------------------------------*\
    | =========                 |                                                 |
    | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
    |  \\    /   O peration     | Version:  2.2.0                                 |
    |   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
    |    \\/     M anipulation  |                                                 |
    \*---------------------------------------------------------------------------*/
    FoamFile
    {
        version     2.0;
        format      ascii;
        class       dictionary;
        object      snappyHexMeshDict;
    }
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    // Which of the steps to run
    castellatedMesh true;    // make basic mesh ?
    snap            true;    // decide to snap back to surface ?
    addLayers       false;   // decide to add viscous layers ?
    
    geometry // 录入STL文件
    {
        
        side_mesh_0_45.stl {type triSurfaceMesh; name side_0;}
        side_mesh_45_90.stl {type triSurfaceMesh; name side_1;}
        side_mesh_90_135.stl {type triSurfaceMesh; name side_2;}
        side_mesh_135_180.stl {type triSurfaceMesh; name side_3;}
        side_mesh_180_225.stl {type triSurfaceMesh; name side_4;}
        side_mesh_225_270.stl {type triSurfaceMesh; name side_5;}
        side_mesh_270_315.stl {type triSurfaceMesh; name side_6;}
        side_mesh_315_360.stl {type triSurfaceMesh; name side_7;}
    
    
    
        top_mesh.stl {type triSurfaceMesh; name top;}
    
        building.stl {type triSurfaceMesh; name building;}
        grassland.stl {type triSurfaceMesh; name grassland;}
        ground.stl {type triSurfaceMesh; name ground;}
        water.stl {type triSurfaceMesh; name water;}
    
        tree.stl {type triSurfaceMesh; name tree;}
    
        refinementBox {type searchableBox; min (-1500 -1500 -5); max (2200 2200 600);}
        // 建筑加密搜索盒
        refinementBox_building
        {
            type searchableBox;
    
            min ( 740 -610 15);
            max ( 2250  860 280);
        }
    
        // 树木加密搜索盒
        refinementBox_tree
        {
            type searchableBox;
            // 同理,这里改成包围你的植被群
            min (720 -600 15);
            max (2250 860 80);
        }
    };
    
    castellatedMeshControls
    {
        maxLocalCells 2000000;  // 每个 CPU 核心允许使用的最大网格单元数,避免某个核心负载过重
        maxGlobalCells 20000000; // 全局允许的最大网格单元数,在细化阶段如果超过这个数量,系统将触发删除操作,防止内存溢出
        maxRefinementIterations 5; // 有效地限制整体迭代次数
        minRefinementCells 10; // 提高触发终止的阈值  maxLoadUnbalance 0.10;  // 允许的最大负载不平衡度,表示各个 CPU 核心之间的工作负载差异最多为 10%,确保负载均衡
        nCellsBetweenLevels 3;  // 不同细化等级之间的网格扩展因子,设置为 1 表示高细化区域与低细化区域之间的过渡最平滑
        maxShellRefinementIter 10;
        // 边缘特征细化程度
        features
        (
            {file "building.eMesh"; level 2;}
            {file "tree.eMesh"; level 0;}
    
            {file "side_mesh_0_45.eMesh"; level 0;}
            {file "side_mesh_45_90.eMesh"; level 0;}
            {file "side_mesh_90_135.eMesh"; level 0;}
            {file "side_mesh_135_180.eMesh"; level 0;}
            {file "side_mesh_180_225.eMesh"; level 0;}
            {file "side_mesh_225_270.eMesh"; level 0;}
            {file "side_mesh_270_315.eMesh"; level 0;}
            {file "side_mesh_315_360.eMesh"; level 0;}
    
            {file "top_mesh.eMesh"; level 0;}
            {file "grassland.eMesh"; level 0;}
            {file "ground.eMesh"; level 0;}
            {file "water.eMesh"; level 0;}
        );
    
        refinementSurfaces
        {
            building {
                level (2 3);
                patchInfo
                {
                    type wall; 
                    inGroups (building);
                }
            }
            
            side_0 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_1 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_2 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_3 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_4 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_5 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_6 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
            side_7 {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (side);
                }
            }
    
            top {
                level (1 1);
                patchInfo
                {
                    type patch;
                    inGroups (top);
                }
            }
    
            grassland {
                level (1 2);
                patchInfo
                {
                    type wall;
                    inGroups (ground);
                }
            }
            ground {
                level (1 2);
                patchInfo
                {
                    type wall;
                    inGroups (ground);
                }
            }
            water {
                level (1 2);            
                patchInfo
                {
                    type wall;
                    inGroups (ground);
                }
            }
    
        }
    
        resolveFeatureAngle 60; // 特征边缘角度,小于这个角度的边缘将被忽略
        refinementRegions {
             tree
         {
            mode inside;
             levels ((0 1));
             cellZone treeZone;
         }
        }
        // {wholeDomain {mode inside; levels ((1 1));}} // 细化区域,mode 为细化模式,levels 为细化等级
        // {building {mode distance; levels ((1 2) (3 1));}} // 细化区域,mode 为细化模式,levels 为细化等级mode 为细化模式(包括inside对内部网格进行细化 outside distance根据距表面网格距离进行细化),levels 为细化等级
        locationInMesh (100 100 100); //规定哪边网格是流域
        allowFreeStandingZoneFaces true; // 允许自由区域面
    }
    
    snapControls
    {
        nSmoothPatch 3; // 平滑次数
        tolerance 0.5; // 两个网格点之间的最大距离
        nSolveIter 50; // 迭代次数
        nRelaxIter 8; // 松弛次数
        nFeatureSnapIter 10; // 特征边缘迭代次数
        implicitFeatureSnap true; // 隐式特征边缘
        explicitFeatureSnap true; // 显式特征边缘
        multiRegionFeatureSnap false; // 多区域特征边缘
    }
    
    addLayersControls
    {
        relativeSizes false; // 相对大小/绝对大小
        layers
        {
            building {nSurfaceLayers 1;}
        }
    
        expansionRatio 1; // 扩展比例
        finalLayerThickness 0.3; // 最外层厚度
        minThickness 1; // 最小厚度
        nGrow 0; // 增长层数
    
        // 高级设置:
        
        featureAngle 80;  // 表面层生成的特征角度。0 表示平面,90 表示直角。如果几何表面的角度超过 80 度,则停止挤出层。
        nRelaxIter 5;  // 层生成过程中,最大允许的松弛迭代次数。用于平滑网格,防止扭曲或变形。
        nSmoothSurfaceNormals 1;  // 对表面法线的平滑处理次数,用于减少表面网格的尖锐突变。
        nSmoothNormals 5;  // 对网格内部运动方向的平滑处理迭代次数,确保网格平滑地向外扩展。
        nSmoothThickness 10;  // 平滑表面层厚度的迭代次数,数值越大,厚度分布越均匀。
        maxFaceThicknessRatio 0.5;  // 如果网格面太过扭曲(厚度超过此比值),则停止层生长。防止生成变形严重的网格。
        maxThicknessToMedialRatio 0.3;  // 层厚度与中线距离的比值,防止厚度过大时停止层的生长。
        minMedianAxisAngle 130;  // 中线轴的最小角度。如果角度过小,可能会跳过层生成。通常用于复杂几何体的细化。
        nBufferCellsNoExtrude 0;  // 用于新层终止时创建的缓冲区单元数,防止层过度扩展。
        nLayerIter 50;  // 添加层的最大迭代次数,限制网格生成过程中层生长的迭代次数
    }
    // 控制网格质量的设置。任何无法处理的阶段将根据这些设置回退操作。
    meshQualityControls
    {
        maxNonOrtho 65;  // 允许的最大非正交角(度数),控制网格的正交性。
        maxBoundarySkewness 4;  // 网格边界倾斜度的最大允许值。
        maxInternalSkewness 4;  // 内部网格单元的最大倾斜度。
        maxConcave 80;  // 允许的最大凹角(度数),控制网格单元的形状。
        maxFaceDiff 2;
        minFlatness 0.5;  // 允许的最小平面度,确保网格面不过于扭曲。
        minVol 5e-11;  // 允许的最小单元体积,避免生成过小的网格单元。
        minTetQuality 1e-8;  // 四面体网格单元的最小质量。
        minArea -1;  // 最小网格面面积,-1 表示忽略此限制。
        minTwist 0.02;  // 网格单元的最小扭曲度,确保网格质量。
        minDeterminant 0.001;  // 网格最小行列式值,衡量网格形状的质量。
        minFaceWeight 0.02;  // 网格面权重的最小值,用于衡量网格面质量。
        minVolRatio 0.01;  // 最小网格体积比,衡量相邻单元的体积差异。
        minTriangleTwist -1;  // 最小三角形扭曲度,-1 表示忽略此限制。
    
        // 高级设置:
        nSmoothScale 5;  // 控制网格平滑的比例,数值越大,网格越平整。
        errorReduction 0.75;  // 错误减少系数,控制每次迭代中如何减少网格问题。
    }
    
    // 高级设置:是否启用调试信息
    debug 0;  // 设置为 0 表示关闭调试信息。
    
    // 网格合并容差。相邻网格单元如果在此容差范围内,将被合并。
    // 容差值是初始网格边界框尺寸的一个分数。
    mergeTolerance 1E-6;  // 合并容差,值越大,网格越容易被合并。
    
    // ************************************************************************* //
    
    
    

  • 关于网格建立的方向与模型方向是否需要一致
    G Gengxiaotian

    有没有其他大佬,半个多月了,求问一下。还有没有大佬吱一声


  • 关于hexRef8 : Dumping cell as obj to ".../cell_813430.obj"的问题
    G Gengxiaotian

    求大佬看看!
    702a48d4-6fc4-4ebb-9b44-3ab220ebebbb-image.png

    Added patches in = 0.02 s
    
    Edge intersection testing:
        Number of edges             : 5008207
        Number of edges to retest   : 490832
        Number of intersected edges : 475794
    Decomposition method none [1]
    
    Refinement phase
    ----------------
    
    Found point (10 20 5) in cell 587820 on processor 0
    
    Feature refinement iteration 0
    ------------------------------
    
    Marked for refinement due to explicit features             : 6 cells.
    Determined cells to refine in = 9.79 s
    Selected for feature refinement : 13 cells (out of 1506875)
    Edge intersection testing:
        Number of edges             : 5008546
        Number of edges to retest   : 781
        Number of intersected edges : 475794
    Refined mesh in = 2.28 s
    After refinement feature refinement iteration 0 : cells:1506966  faces:5008546  points:2028784
    Cells per refinement level:
        0   438931
        1   42098
        2   131721
        3   456157
        4   438059
    
    Feature refinement iteration 1
    ------------------------------
    
    Marked for refinement due to explicit features             : 0 cells.
    Determined cells to refine in = 9.22 s
    Selected for feature refinement : 0 cells (out of 1506966)
    Stopping refining since too few cells selected.
    
    
    Surface refinement iteration 0
    ------------------------------
    
    Marked for refinement due to surface intersection          : 27528 cells.
    Determined cells to refine in = 0.62 s
    Selected for refinement : 29733 cells (out of 1506966)
    hexRef8 : Dumping cell as obj to "/mnt/g/City4CFD/City4CFD/examples/TUDCampus/c4c_tst_20240924/cell_813430.obj"
    
    
    --> FOAM FATAL ERROR: (openfoam-2312)
    cell 813430 of level 2 uses more than 8 points of equal or lower level
    Points so far:8(467622 506063 542474 660192 812094 865708 953356 1395965)
    
        From Foam::labelListList Foam::hexRef8::setRefinement(const labelList&, Foam::polyTopoChange&)
        in file polyTopoChange/polyTopoChange/hexRef8/hexRef8.C at line 3604.
    
    FOAM aborting
    
    [stack trace]
    =============
    #1  Foam::error::simpleExit(int, bool) in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so
    #2  Foam::hexRef8::setRefinement(Foam::List<int> const&, Foam::polyTopoChange&) in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/lib/libdynamicMesh.so
    #3  Foam::meshRefinement::refine(Foam::List<int> const&) in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so
    #4  Foam::meshRefinement::balanceAndRefine(Foam::string const&, Foam::decompositionMethod&, Foam::fvMeshDistribute&, Foam::List<int> const&, double, int) in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so
    #5  Foam::snappyRefineDriver::surfaceOnlyRefine(Foam::refinementParameters const&, int, int) in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so
    #6  Foam::snappyRefineDriver::doRefine(Foam::dictionary const&, Foam::refinementParameters const&, Foam::snapParameters const&, bool, Foam::meshRefinement::FaceMergeType, Foam::dictionary const&) in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/lib/libsnappyHexMesh.so
    #7  ? in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/bin/snappyHexMesh
    #8  ? in /lib/x86_64-linux-gnu/libc.so.6
    #9  __libc_start_main in /lib/x86_64-linux-gnu/libc.so.6
    #10  ? in ~/OpenFOAM-v2312/platforms/linux64GccDPInt32Opt/bin/snappyHexMesh
    =============
    Aborted
    

    通过报错信息生成了个obj文件,求问这个是个啥,为什么会生成


  • snappyHexMesh生成网格后,结果显示“non-orthogonality > 45 degrees”过多
    G Gengxiaotian

    每日一捞一捞


  • 关于网格建立的方向与模型方向是否需要一致
    G Gengxiaotian

    image.png
    我重新写了配置,可以snap出来了,但是不知道为什么矩形立方体被切成了三角形
    请问这是什么原因


  • snappyHexMesh生成网格后,结果显示“non-orthogonality > 45 degrees”过多
    G Gengxiaotian

    8a7ce4cd-95c3-431d-8038-4bed83920464-image.png
    d02bd7f2-d547-45e5-bfb0-b4ecc05b7b7e-image.png
    第一个图是小视角,第二个是大视角,可以看出基本上还都是小网格,没有什么变化。snappyHexMeshDict blockMeshDict
    我分别运行了blockmesh和snappyhexmesh但得到了如下的记过,不管是从最终的结果可视化还是报告,好像都是错的。尤其是“non-orthogonality > 45 degrees”很多,这是为什么。到底是什么参数控制了这个结果。
    No layers to generate ...
    Layer mesh : cells:1584584 faces:5627764 points:2554142
    Cells per refinement level:
    0 105641
    1 55348
    2 238190
    3 627103
    4 558302
    Writing mesh to time 0
    Wrote mesh in = 3.02 s.
    Layers added in = 364.18 s.
    Checking final mesh ...
    Checking faces in error :
    non-orthogonality > 45 degrees : 210392
    faces with face pyramid volume < 1e-13 : 0
    faces with face-decomposition tet quality < 1e-09 : 0
    faces with concavity > 80 degrees : 0
    faces with skewness > 4 (internal) or 20 (boundary) : 0
    faces with interpolation weights (0..1) < 0.02 : 0
    faces with volume ratio of neighbour cells < 0.01 : 0
    faces with face twist < 0.02 : 3
    faces with triangle twist < 0.05 : 32
    faces on cells with determinant < 0.001 : 0
    Finished meshing with 210427 illegal faces (concave, zero area or negative cell pyramid volume)
    Finished meshing in = 1509.18 s.
    End[链接文本]
    snappyHexMeshDict blockMeshDict


  • 关于网格建立的方向与模型方向是否需要一致
    G Gengxiaotian

    @李东岳 44444222.png 找到了老师,调整了时间步也是这样的,但是我调整dict中的参数似乎没怎么变化


  • snappyHexMesh中网格始终snap不到物体表面上
    G Gengxiaotian

    @Be1tazzz 44444222.png
    可以的,但是好像我的网格还是没怎么变,可能是我网格设置的问题?


  • 关于网格建立的方向与模型方向是否需要一致
    G Gengxiaotian

    @李东岳 东岳老师,我有搜到您之前回答的一个贴子《snappyHexMesh中网格始终snap不到物体表面上》,我看他上传的图跟我这个情况有点像。帖子中,您说处理对象被当成二维处理了,需要修改blockMesh中的type(将empty进行更改,随后用blockMesh, surfaceFeatureExtract, snappyHexMesh -overwrite),这个方法我试了样子没变。帖主说在您的基础上,在paramview中显示第二个时间步,切换显示就好了,我不知道这是否对我有效,现在我还在找这个切换的按钮(因为我是最近才上手这个,所以搜了半天也没找到这个)1024198f-d922-4e2a-95a5-aa0bcc09bfdc-image.png
    除了这个问题,还有一个问题,就是在生成网格结束的报告中显示我生成的网格错误很多“non-orthogonality > 45 degrees : 210392”,我的理解是基本上全错了?我有按照论坛里面的snappyHexMeshDict文件和chatgpt回答调整我的文件,但是似乎我写的存在很多问题。目前我尝试调整配置中的参数(某些参数调大或调小),但对结果的改进不大。
    我的stl文件是使用“city4cfd”根据点云和建筑足迹生成的(这里生成的是mesh网格,包含了openfoam需要的边界,在triSurface中),先生成了stl,然后转为vtk,最后生成emesh(因为在使用Blockmesh的时候提示需要emesh),最后snappyHexMesh生成网格。网盘链接是我生成的模型和其他的文件。
    ——————————————————————————————————————————
    通过百度网盘分享的文件:c4c_tst.rar
    链接:https://pan.baidu.com/s/1ALcAWpd8mh38VKY9YMI1IA
    提取码:8dp1
    --来自百度网盘超级会员V7的分享
    ————————————————————————————————————————————
    No layers to generate ...
    Layer mesh : cells:1584584 faces:5627764 points:2554142
    Cells per refinement level:
    0 105641
    1 55348
    2 238190
    3 627103
    4 558302
    Writing mesh to time 0
    Wrote mesh in = 3.02 s.
    Layers added in = 364.18 s.
    Checking final mesh ...
    Checking faces in error :
    non-orthogonality > 45 degrees : 210392
    faces with face pyramid volume < 1e-13 : 0
    faces with face-decomposition tet quality < 1e-09 : 0
    faces with concavity > 80 degrees : 0
    faces with skewness > 4 (internal) or 20 (boundary) : 0
    faces with interpolation weights (0..1) < 0.02 : 0
    faces with volume ratio of neighbour cells < 0.01 : 0
    faces with face twist < 0.02 : 3
    faces with triangle twist < 0.05 : 32
    faces on cells with determinant < 0.001 : 0
    Finished meshing with 210427 illegal faces (concave, zero area or negative cell pyramid volume)
    Finished meshing in = 1509.18 s.
    End


  • snappyHexMesh中网格始终snap不到物体表面上
    G Gengxiaotian

    @Enthusiasm 你好可以问下你在哪里调的时间步吗,我也是这种情况7ccc2081-9626-4b47-9177-e7ea6f94228e-image.png

  • 登录

  • 登录或注册以进行搜索。
  • 第一个帖子
    最后一个帖子
0
  • 最新
  • 版块
  • 东岳流体
  • 随机看[请狂点我]