You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
555 lines
26 KiB
C++
555 lines
26 KiB
C++
#include "FITKOFSnappyHexMeshDictWriter.h"
|
|
#include "FITKDictObject.h"
|
|
#include "FITKDictArray.h"
|
|
#include "FITKDictGroup.h"
|
|
#include "FITKDictVector.h"
|
|
#include "FITKDictValue.h"
|
|
#include "FITK_Kernel/FITKCore/FITKEnumTransformer.hpp"
|
|
#include "FITK_Kernel/FITKAppFramework/FITKAppFramework.h"
|
|
#include "FITK_Kernel/FITKAppFramework/FITKGlobalData.h"
|
|
#include "FITK_Interface/FITKInterfaceFlowOF/FITKOFGeometryData.h"
|
|
#include "FITK_Interface/FITKInterfaceMeshGen/FITKMeshGenInterface.h"
|
|
#include "FITK_Interface/FITKInterfaceMeshGen/FITKGeometryMeshSize.h"
|
|
#include "FITK_Interface/FITKInterfaceMeshGen/FITKRegionGeometryRefine.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKGeoCommandList.h"
|
|
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKVirtualTopoManager.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsVirtualTopo.h"
|
|
|
|
#include "FITK_Interface/FITKInterfaceMeshGen/FITKZonePoints.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsGeoShapeAgent.h"
|
|
#include "FITK_Interface/FITKInterfaceModel/FITKAbstractGeoModel.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsGeoModelBox.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsGeoModelCylinder.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsGeoModelSphere.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsGeoOperBool.h"
|
|
#include "FITK_Interface/FITKInterfaceGeometry/FITKAbsGeoModelImport.h"
|
|
#include "FITK_Interface/FITKInterfaceMeshGen/FITKRegionMeshSize.h"
|
|
#include "FITK_Interface/FITKInterfaceMeshGen/FITKRegionMeshSizeGeom.h"
|
|
#include "FITK_Kernel/FITKCore/FITKDataRepo.h"
|
|
#include <QFileInfo>
|
|
#include <QtMath>
|
|
//命名空间
|
|
namespace IO
|
|
{
|
|
FITKOFSnappyHexMeshDictWriter::FITKOFSnappyHexMeshDictWriter()
|
|
{
|
|
}
|
|
FITKOFSnappyHexMeshDictWriter::~FITKOFSnappyHexMeshDictWriter()
|
|
{
|
|
}
|
|
|
|
void FITKOFSnappyHexMeshDictWriter::setFilePath(const QString& filePath)
|
|
{
|
|
FITKOFAbstractDictWriter::setFilePath(filePath);
|
|
QFileInfo fileInfo(filePath);
|
|
//判断是否是路径
|
|
if (!fileInfo.isDir())return;
|
|
m_fileName = QString("%1/system/snappyHexMeshDict").arg(filePath);
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::run()
|
|
{
|
|
//判断文件是否存在
|
|
if (m_fileName.isEmpty())return false;
|
|
//获取网格生成单例
|
|
Interface::FITKMeshGenInterface* meshGen = Interface::FITKMeshGenInterface::getInstance();
|
|
if (!meshGen)return false;
|
|
//获取几何网格区域大小管理器
|
|
m_geometryMeshSizeManager = meshGen->getGeometryMeshSizeManager();
|
|
if (!m_geometryMeshSizeManager)return false;
|
|
//获取字典工程
|
|
this->openDictObject();
|
|
if (!m_objectDict)return false;
|
|
//写出FoamFile
|
|
this->dictObjectFoamFile();
|
|
//设置写出的网格区域数据
|
|
bool Ok = this->snappyHexMeshGeometryMeshW();
|
|
//写出字典文件
|
|
if (Ok)
|
|
Ok = this->writeDictFile();
|
|
//关闭字典工程
|
|
this->closeDictObject();
|
|
return Ok;
|
|
}
|
|
|
|
QString FITKOFSnappyHexMeshDictWriter::getFileName()
|
|
{
|
|
return m_fileName;
|
|
}
|
|
|
|
void FITKOFSnappyHexMeshDictWriter::dictObjectFoamFile()
|
|
{
|
|
if (!m_objectDict)return;
|
|
//FoamFile
|
|
DICT::FITKDictGroup* group = new DICT::FITKDictGroup;
|
|
group->append("version", 2.0);
|
|
group->append("format", "ascii");
|
|
group->append("class", "dictionary");
|
|
group->append("location", "\"system\"");
|
|
group->append("object", "snappyHexMeshDict");
|
|
m_objectDict->append("FoamFile", group);
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::snappyHexMeshGeometryMeshW()
|
|
{
|
|
if (!m_objectDict)return false;
|
|
bool ok = true;
|
|
m_objectDict->append("castellatedMesh", true);
|
|
m_objectDict->append("snap", true);
|
|
//是否有层数
|
|
bool addLayers = m_geometryMeshSizeManager->getDataCount() != 0 ? true : false;
|
|
m_objectDict->append("addLayers", addLayers);
|
|
ok &= this->geometrySnappyHexMesh();
|
|
ok &= this->castellatedMeshControls();
|
|
ok &= this->snapControls();
|
|
ok &= this->addLayersControls(addLayers);
|
|
ok &= this->meshQualityControls();
|
|
m_objectDict->append("mergeTolerance", "1.0E-6");
|
|
m_objectDict->append("debug", 0);
|
|
return ok;
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::geometrySnappyHexMesh()
|
|
{
|
|
if (!m_objectDict)return false;
|
|
//获取全局数据管理器
|
|
AppFrame::FITKGlobalData* globalData = FITKAPP->getGlobalData();
|
|
if (!globalData)return false;
|
|
//获取几何数据
|
|
Interface::FITKGeoCommandList* geometryData = globalData->getGeometryData<Interface::FITKGeoCommandList>();
|
|
int count = geometryData->getDataCount();
|
|
//创建字典组件
|
|
DICT::FITKDictGroup* group = new DICT::FITKDictGroup;
|
|
m_objectDict->append("geometry", group);
|
|
//获取几何数据
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
//获取几何模型数据
|
|
Interface::FITKAbsGeoCommand* geoCommand = dynamic_cast<Interface::FITKAbsGeoCommand*>(geometryData->getDataByIndex(i));
|
|
if (!geoCommand)continue;
|
|
//获取名称
|
|
QString name = geoCommand->getDataObjectName();
|
|
//创建stl字典组件
|
|
DICT::FITKDictGroup* stlGroup = new DICT::FITKDictGroup;
|
|
group->append(QString("%1.stl").arg(name), stlGroup);
|
|
stlGroup->append("type", "triSurfaceMesh");
|
|
//获取类型
|
|
Interface::FITKGeoEnum::FITKGeometryComType type = geoCommand->getGeometryCommandType();
|
|
if (type == Interface::FITKGeoEnum::FITKGeometryComType::FGTBox)
|
|
{
|
|
Interface::FITKAbsGeoModelBox* box = dynamic_cast<Interface::FITKAbsGeoModelBox*>(geoCommand);
|
|
if (!box)return false;
|
|
stlGroup->append("simflowType", "primitive");
|
|
stlGroup->append("primitiveType", "box");
|
|
stlGroup->append("name", name);
|
|
//第一个点
|
|
double minP[3]{ 0.0, 0.0, 0.0 };
|
|
box->getPoint1(minP);
|
|
//长度
|
|
double length[3]{ 0.0, 0.0, 0.0 };
|
|
box->getLength(length);
|
|
//最高点
|
|
double maxP[3]{ minP[0], minP[1], minP[2] };
|
|
length[0] < 0 ? minP[0] = minP[0] + length[0] : maxP[0] = minP[0] + length[0];
|
|
length[1] < 0 ? minP[1] = minP[1] + length[1] : maxP[1] = minP[1] + length[1];
|
|
length[2] < 0 ? minP[2] = minP[2] + length[2] : maxP[2] = minP[2] + length[2];
|
|
stlGroup->append("max", QString("(%1 %2 %3)").arg(maxP[0]).arg(maxP[1]).arg(maxP[2]));
|
|
stlGroup->append("min", QString("(%1 %2 %3)").arg(minP[0]).arg(minP[1]).arg(minP[2]));
|
|
}
|
|
else if (type == Interface::FITKGeoEnum::FITKGeometryComType::FGTCylinder)
|
|
{
|
|
Interface::FITKAbsGeoModelCylinder* cylinder = dynamic_cast<Interface::FITKAbsGeoModelCylinder*>(geoCommand);
|
|
if (!cylinder)return false;
|
|
stlGroup->append("simflowType", "primitive");
|
|
stlGroup->append("primitiveType", "cylinder");
|
|
stlGroup->append("name", name);
|
|
//底面圆心
|
|
double p[3]{ 0.0, 0.0, 0.0 };
|
|
cylinder->getLocation(p);
|
|
stlGroup->append("point1", QString("(%1 %2 %3)").arg(p[0]).arg(p[1]).arg(p[2]));
|
|
//轴向与长度
|
|
double axis[3]{ 0.0, 0.0, 0.0 };
|
|
double length = cylinder->getLength();
|
|
cylinder->getDirection(axis);
|
|
double axisLenth = qSqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
|
|
//获取上圆心
|
|
double p2[3]{ p[0] + length * axis[0] / axisLenth, p[1] + length * axis[1] / axisLenth, p[2] + length * axis[2] / axisLenth };
|
|
stlGroup->append("point2", QString("(%1 %2 %3)").arg(p2[0]).arg(p2[1]).arg(p2[2]));
|
|
//半径
|
|
double r = cylinder->getRadius();
|
|
stlGroup->append("radius", r);
|
|
}
|
|
else if (type == Interface::FITKGeoEnum::FITKGeometryComType::FGTSphere)
|
|
{
|
|
Interface::FITKAbsGeoModelSphere* sphere = dynamic_cast<Interface::FITKAbsGeoModelSphere*>(geoCommand);
|
|
if (!sphere)return false;
|
|
stlGroup->append("simflowType", "primitive");
|
|
stlGroup->append("primitiveType", "sphere");
|
|
stlGroup->append("name", name);
|
|
//球心
|
|
double center[3]{ 0.0 };
|
|
sphere->getLocation(center);
|
|
stlGroup->append("centre", QString("(%1 %2 %3)").arg(center[0]).arg(center[1]).arg(center[2]));
|
|
//半径
|
|
double radius = sphere->getRadius();
|
|
stlGroup->append("radius", radius);
|
|
}
|
|
else if (type == Interface::FITKGeoEnum::FITKGeometryComType::FGTBool)
|
|
{
|
|
Interface::FITKAbsGeoOperBool* boolOper = dynamic_cast<Interface::FITKAbsGeoOperBool*>(geoCommand);
|
|
if (!boolOper)return false;
|
|
stlGroup->append("simflowType", "brep");
|
|
stlGroup->append("topoType", "compound");
|
|
stlGroup->append("name", name);
|
|
}
|
|
else if (type == Interface::FITKGeoEnum::FITKGeometryComType::FGTImport)
|
|
{
|
|
Interface::FITKAbsGeoModelImport* importModel = dynamic_cast<Interface::FITKAbsGeoModelImport*>(geoCommand);
|
|
if (!importModel)return false;
|
|
//stlGroup->append("simflowType", "stl");
|
|
stlGroup->append("simflowType", "stl");
|
|
stlGroup->append("topoType", "shell");
|
|
stlGroup->append("name", name);
|
|
}
|
|
if (!this->geoFaceGroupStl(geoCommand->getShapeAgent(), stlGroup, name))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::castellatedMeshControls()
|
|
{
|
|
if (!m_objectDict)return false;
|
|
//创建字典组件
|
|
DICT::FITKDictGroup* group = new DICT::FITKDictGroup;
|
|
m_objectDict->append("castellatedMeshControls", group);
|
|
//获取网格生成单例
|
|
Interface::FITKMeshGenInterface* meshGen = Interface::FITKMeshGenInterface::getInstance();
|
|
if (!meshGen)return false;
|
|
//获取材料点管理器
|
|
Interface::FITKZonePointManager* pointManager = meshGen->getZonePointManager();
|
|
if (!pointManager)return false;
|
|
//获取区域网格尺寸管理器
|
|
Interface::FITKRegionMeshSizeManager* meshRegionManager = meshGen->getRegionMeshSizeMgr();
|
|
if (!meshRegionManager)return false;
|
|
//获取材料点的个数
|
|
int count = pointManager->getDataCount();
|
|
double point[3]{ 0,0,0 };
|
|
if (count == 0)return false;
|
|
//材料点
|
|
if (count == 1)
|
|
{
|
|
Interface::FITKZonePoint* pointData = pointManager->getDataByIndex(0);
|
|
if (!pointData)return false;
|
|
pointData->getCoor(point);
|
|
group->append("locationInMesh", QString("(%1 %2 %3)").arg(point[0]).arg(point[1]).arg(point[2]));
|
|
}
|
|
else
|
|
{
|
|
//多个材料点
|
|
DICT::FITKDictArray* materialPoint = new DICT::FITKDictArray;
|
|
group->append("locationsInMesh", materialPoint);
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
Interface::FITKZonePoint* pointData = pointManager->getDataByIndex(i);
|
|
if (!pointData)continue;
|
|
pointData->getCoor(point);
|
|
DICT::FITKDictVector* pointDict = new DICT::FITKDictVector;
|
|
pointDict->append(QString("(%1 %2 %3)").arg(point[0]).arg(point[1]).arg(point[2]));
|
|
pointDict->append(QString("zone%1").arg(i + 1));
|
|
materialPoint->append(pointDict);
|
|
}
|
|
}
|
|
//面加密 创建字典组件
|
|
DICT::FITKDictGroup* refinement = new DICT::FITKDictGroup;
|
|
group->append("refinementSurfaces", refinement);
|
|
//获取集合大小
|
|
QList<Interface::FITKAbstractRegionMeshSize*> geomList = meshRegionManager->getRigonByType(Interface::FITKAbstractRegionMeshSize::RegionType::RigonGeom);
|
|
for (Interface::FITKAbstractRegionMeshSize* geom : geomList)
|
|
{
|
|
Interface::FITKRegionMeshSizeGeom* geomData = dynamic_cast<Interface::FITKRegionMeshSizeGeom*>(geom);
|
|
if (!geomData)continue;
|
|
Interface::FITKAbsGeoCommand* geoCommand = FITKDATAREPO->getTDataByID<Interface::FITKAbsGeoCommand>(geomData->getGeomID());
|
|
if (!geoCommand)continue;
|
|
//获取最值
|
|
int min = int(geomData->getMinSize());
|
|
int max = int(geomData->getMaxSize());
|
|
//获取名称
|
|
QString name = geoCommand->getDataObjectName();
|
|
//创建stl字典组件
|
|
DICT::FITKDictGroup* modelGroup = new DICT::FITKDictGroup;
|
|
refinement->append(name, modelGroup);
|
|
modelGroup->append("level", QString("( %1 %2 )").arg(min).arg(max));
|
|
DICT::FITKDictGroup* patchInfo = new DICT::FITKDictGroup;
|
|
modelGroup->append("patchInfo", patchInfo);
|
|
patchInfo->append("type", "wall");
|
|
}
|
|
//获取几何优化管理器
|
|
Interface::FITKRegionGeometryRefineManager* geoRefineMgr = meshGen->getRegionGeometryRefineManager();
|
|
if (!geoRefineMgr) return false;
|
|
//体加密-细化区域
|
|
DICT::FITKDictGroup* refinementRegions = new DICT::FITKDictGroup;
|
|
group->append("refinementRegions", refinementRegions);
|
|
count = geoRefineMgr->getDataCount();
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
//获取区域优化数据
|
|
Interface::FITKRegionGeometryRefine* regRefine = geoRefineMgr->getDataByIndex(i);
|
|
if (!regRefine)continue;
|
|
//获取几何数据
|
|
Interface::FITKAbsGeoCommand* geoCommand = regRefine->getGeometryModel();
|
|
if (!geoCommand) continue;
|
|
DICT::FITKDictGroup* refRegion = new DICT::FITKDictGroup;
|
|
refinementRegions->append(geoCommand->getDataObjectName(), refRegion);
|
|
//获取距离和限制
|
|
double distance = regRefine->getDistance();
|
|
int level = regRefine->getLevel();
|
|
//获取优化模式
|
|
Interface::FITKRegionGeometryRefine::RefineModelType refinetype = regRefine->getRefineModel();
|
|
if (refinetype == Interface::FITKRegionGeometryRefine::RefineModelType::RefineDistance)
|
|
{
|
|
refRegion->append("mode", "distance");
|
|
refRegion->append("levels", QString("((%1 %2))").arg(distance).arg(level));
|
|
}
|
|
else if (refinetype == Interface::FITKRegionGeometryRefine::RefineModelType::RefineInside)
|
|
{
|
|
refRegion->append("mode", "inside");
|
|
refRegion->append("levels", QString("((1.0E30 %1))").arg(level));
|
|
}
|
|
else if (refinetype == Interface::FITKRegionGeometryRefine::RefineModelType::RefineOutside)
|
|
{
|
|
refRegion->append("mode", "outside");
|
|
refRegion->append("levels", QString("((1.0E30 %1))").arg(level));
|
|
}
|
|
//获取间隙参数
|
|
int cells = regRefine->getCellsInGapNum();
|
|
int maxGap = regRefine->getMaxGapLevel();
|
|
//获取间隙模式
|
|
Interface::FITKRegionGeometryRefine::GapModelType gaptype = regRefine->getGapRefineModel();
|
|
if (gaptype == Interface::FITKRegionGeometryRefine::GapModelType::GapMixed)
|
|
{
|
|
refRegion->append("gapMode", "mixed");
|
|
refRegion->append("gapLevel", QString("((%1 0 %2))").arg(cells).arg(maxGap));
|
|
}
|
|
else if (gaptype == Interface::FITKRegionGeometryRefine::GapModelType::GapInside)
|
|
{
|
|
refRegion->append("gapMode", "inside");
|
|
refRegion->append("gapLevel", QString("((%1 0 %2))").arg(cells).arg(maxGap));
|
|
}
|
|
else if (gaptype == Interface::FITKRegionGeometryRefine::GapModelType::GapOutside)
|
|
{
|
|
refRegion->append("gapMode", "outside");
|
|
refRegion->append("gapLevel", QString("((%1 0 %2))").arg(cells).arg(maxGap));
|
|
}
|
|
}
|
|
//限制区域
|
|
DICT::FITKDictGroup* limitRegions = new DICT::FITKDictGroup;
|
|
group->append("limitRegions", limitRegions);
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
//获取区域优化数据
|
|
Interface::FITKRegionGeometryRefine* regRefine = geoRefineMgr->getDataByIndex(i);
|
|
if (!regRefine)continue;
|
|
//获取几何数据
|
|
Interface::FITKAbsGeoCommand* geoCommand = regRefine->getGeometryModel();
|
|
if (!geoCommand) continue;
|
|
if (!regRefine->getLimitRefineMent())continue;
|
|
DICT::FITKDictGroup* refRegion = new DICT::FITKDictGroup;
|
|
limitRegions->append(geoCommand->getDataObjectName(), refRegion);
|
|
//获取距离和限制
|
|
double distance = regRefine->getDistance();
|
|
int level = regRefine->getLevel();
|
|
//获取优化模式
|
|
Interface::FITKRegionGeometryRefine::RefineModelType refinetype = regRefine->getRefineModel();
|
|
if (refinetype == Interface::FITKRegionGeometryRefine::RefineModelType::RefineDistance)
|
|
{
|
|
refRegion->append("mode", "distance");
|
|
refRegion->append("levels", QString("(%1 %2)").arg(distance).arg(level));
|
|
}
|
|
else if (refinetype == Interface::FITKRegionGeometryRefine::RefineModelType::RefineInside)
|
|
{
|
|
refRegion->append("mode", "outside");
|
|
refRegion->append("levels", QString("(1.0E30 %1)").arg(level));
|
|
}
|
|
else if (refinetype == Interface::FITKRegionGeometryRefine::RefineModelType::RefineOutside)
|
|
{
|
|
refRegion->append("mode", "inside");
|
|
refRegion->append("levels", QString("(1.0E30 %1)").arg(level));
|
|
}
|
|
}
|
|
//默认数据
|
|
group->append("maxLocalCells", 1000000);
|
|
group->append("maxGlobalCells", 10000000);
|
|
group->append("nCellsBetweenLevels", 4);
|
|
group->append("maxLoadUnbalance", 0.1);
|
|
group->append("minRefinementCells", 10);
|
|
group->append("resolveFeatureAngle", 30.0);
|
|
group->append("allowFreeStandingZoneFaces", true);
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::geoFaceGroupStl(Interface::FITKAbsGeoShapeAgent* geoModel, DICT::FITKDictGroup* stlGroup, QString name)
|
|
{
|
|
if (!geoModel || !stlGroup)return false;
|
|
//获取几何组件管理器
|
|
Interface::FITKGeoComponentManager* geoComponentManager = geoModel->getGeoComponentManager();
|
|
if (!geoComponentManager)return false;
|
|
//创建面数据字典组件
|
|
DICT::FITKDictGroup* faceGroups = new DICT::FITKDictGroup;
|
|
stlGroup->append("faceGroups", faceGroups);
|
|
|
|
if (!geoModel->getVirtualTopoManager())return false;
|
|
Interface::FITKShapeVirtualTopoManager* faceMgr = geoModel->getVirtualTopoManager()->getShapeVirtualTopoManager(Interface::FITKGeoEnum::VTopoShapeType::VSFace);
|
|
if (!faceMgr)return false;
|
|
|
|
//获取模型全部表面数量
|
|
int allFaceNum = geoModel->getShapeCount(Interface::FITKModelEnum::FITKModelSetType::FMSSurface);
|
|
for (int i = 0; i < allFaceNum; ++i)
|
|
{
|
|
DICT::FITKDictGroup* face = new DICT::FITKDictGroup;
|
|
face->append("name", QString("%1").arg(name));
|
|
faceGroups->append(QString("face_%1").arg(i), face);
|
|
}
|
|
//获取面组链表
|
|
QList<Interface::FITKGeoComponent*> componentList = geoComponentManager->getGeoComponent(Interface::FITKModelEnum::FITKModelSetType::FMSSurface);
|
|
for (Interface::FITKGeoComponent* componentData : componentList)
|
|
{
|
|
if (!componentData)continue;
|
|
QString groupName = componentData->getDataObjectName();
|
|
//面id
|
|
QList<int> id_list = componentData->getMember();
|
|
for (int i = 0; i < id_list.size(); ++i)
|
|
{
|
|
Interface::FITKAbsVirtualTopo* topo = faceMgr->getDataByID(id_list.at(i));
|
|
if (!topo)continue;
|
|
int index = topo->getIndexLabel();
|
|
faceGroups->removeKey(QString("face_%1").arg(index));
|
|
DICT::FITKDictGroup* face = new DICT::FITKDictGroup;
|
|
face->append("name", QString("%1_%2").arg(name).arg(groupName));
|
|
faceGroups->append(QString("face_%1").arg(index), face);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::snapControls()
|
|
{
|
|
if (!m_objectDict)return false;
|
|
//创建添加字典组件
|
|
DICT::FITKDictGroup* group = new DICT::FITKDictGroup;
|
|
m_objectDict->append("snapControls", group);
|
|
group->append("tolerance", 1.0);
|
|
group->append("nSmoothPatch", 3);
|
|
group->append("nSolveIter", 500);
|
|
group->append("nRelaxIter", 5);
|
|
group->append("nFeatureSnapIter", 10);
|
|
group->append("implicitFeatureSnap", false);
|
|
group->append("explicitFeatureSnap", true);
|
|
group->append("multiRegionFeatureSnap", true);
|
|
group->append("nFaceSplitInterval", 5);
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::addLayersControls(bool isAddLayers)
|
|
{
|
|
if (!m_objectDict || !m_geometryMeshSizeManager)return false;
|
|
//创建添加图层字典组件
|
|
DICT::FITKDictGroup* addLayer = new DICT::FITKDictGroup;
|
|
m_objectDict->append("addLayersControls", addLayer);
|
|
//创建添加层级字典组件
|
|
DICT::FITKDictGroup* layers = new DICT::FITKDictGroup;
|
|
addLayer->append("layers", layers);
|
|
//添加层数
|
|
int count = m_geometryMeshSizeManager->getDataCount();
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
Interface::FITKGeometryMeshSize* geoMeshSize = m_geometryMeshSizeManager->getDataByIndex(i);
|
|
if (!geoMeshSize)continue;
|
|
//获取数据
|
|
int layerNum = geoMeshSize->getLayerNumber();
|
|
double ratio = geoMeshSize->getExpansionRatio();
|
|
double thickness = geoMeshSize->getLayerThickness();
|
|
//获取组件
|
|
Interface::FITKGeoComponent* componentData = geoMeshSize->getGeoComponent();
|
|
//获取模型
|
|
Interface::FITKAbsGeoCommand* geoCommand = geoMeshSize->getGeoModel();
|
|
if (!componentData || !geoCommand)continue;
|
|
Interface::FITKAbsGeoShapeAgent* geoModel = geoCommand->getShapeAgent();
|
|
if (!geoModel || !geoModel->getVirtualTopoManager())return false;
|
|
Interface::FITKShapeVirtualTopoManager* faceMgr = geoModel->getVirtualTopoManager()->getShapeVirtualTopoManager(Interface::FITKGeoEnum::VTopoShapeType::VSFace);
|
|
if (!faceMgr)return false;
|
|
QString name = geoCommand->getDataObjectName();
|
|
//编号
|
|
QList<int> id_list = componentData->getMember();
|
|
for (int i = 0; i < id_list.size(); ++i)
|
|
{
|
|
Interface::FITKAbsVirtualTopo* topo = faceMgr->getDataByID(id_list.at(i));
|
|
if (!topo)continue;
|
|
DICT::FITKDictGroup* face = new DICT::FITKDictGroup;
|
|
face->append("nSurfaceLayers", layerNum);
|
|
face->append("expansionRatio", ratio);
|
|
face->append("firstLayerThickness", thickness);
|
|
int index = topo->getIndexLabel();
|
|
layers->append(QString("%1_face_%2").arg(name).arg(index), face);
|
|
}
|
|
}
|
|
//添加默认数据
|
|
addLayer->append("relativeSizes", true);
|
|
addLayer->append("minThickness", 0.1);
|
|
addLayer->append("firstLayerThickness", 0.2);
|
|
addLayer->append("expansionRatio", 1.25);
|
|
addLayer->append("nGrow", 0);
|
|
addLayer->append("featureAngle", 180.0);
|
|
addLayer->append("maxFaceThicknessRatio", 0.5);
|
|
addLayer->append("nSmoothSurfaceNormals", 5);
|
|
addLayer->append("nSmoothThickness", 10);
|
|
addLayer->append("minMedialAxisAngle", 90.0);
|
|
addLayer->append("maxThicknessToMedialRatio", 0.5);
|
|
addLayer->append("nMedialAxisIter", 100);
|
|
addLayer->append("nSmoothNormals", 3);
|
|
addLayer->append("slipFeatureAngle", 30.0);
|
|
addLayer->append("nRelaxIter", 5);
|
|
addLayer->append("nBufferCellsNoExtrude", 0);
|
|
addLayer->append("nLayerIter", 50);
|
|
addLayer->append("nRelaxedIter", 20);
|
|
addLayer->append("detectExtrusionIsland", true);
|
|
|
|
//是否添加几何层级
|
|
if (!isAddLayers)return true;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFSnappyHexMeshDictWriter::meshQualityControls()
|
|
{
|
|
if (!m_objectDict)return false;
|
|
//创建添加字典组件
|
|
DICT::FITKDictGroup* group = new DICT::FITKDictGroup;
|
|
m_objectDict->append("meshQualityControls", group);
|
|
group->append("maxNonOrtho", 65.0);
|
|
group->append("maxBoundarySkewness", 20.0);
|
|
group->append("maxInternalSkewness", 4.0);
|
|
group->append("maxConcave", 80.0);
|
|
group->append("minVol", "1.0E-14");
|
|
group->append("minTetQuality", "1.0E-20");
|
|
group->append("minArea", -1.0);
|
|
group->append("minTwist", 0.02);
|
|
group->append("minTriangleTwist", -1.0);
|
|
group->append("minDeterminant", 0.01);
|
|
group->append("minFaceWeight", 0.05);
|
|
group->append("minVolRatio", 0.01);
|
|
group->append("minVolCollapseRatio", 0.1);
|
|
group->append("nSmoothScale", 4);
|
|
group->append("errorReduction", 0.75);
|
|
DICT::FITKDictGroup* relaxed = new DICT::FITKDictGroup;
|
|
group->append("relaxed", relaxed);
|
|
relaxed->append("maxNonOrtho", 75.0);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
|