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.
410 lines
17 KiB
C++
410 lines
17 KiB
C++
#include "FITKOFFVSchemesWriter.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/FITKOFPhysicsData.h"
|
|
#include "FITK_Interface/FITKInterfaceFlowOF/FITKOFDiscretization.h"
|
|
#include "FITK_Kernel/FITKEasyParam/FITKParameter.h"
|
|
#include "FITK_Kernel/FITKEasyParam/FITKParamRadioGroup.h"
|
|
#include "FITK_Kernel/FITKEasyParam/FITKParamBool.h"
|
|
#include "FITK_Kernel/FITKEasyParam/FITKParamCombox.h"
|
|
#include "FITK_Kernel/FITKEasyParam/FITKParamDouble.h"
|
|
#include "FITK_Interface/FITKInterfaceFlowOF/FITKAbstractOFSolver.h"
|
|
#include <QFileInfo>
|
|
#include <QtMath>
|
|
//命名空间
|
|
namespace IO
|
|
{
|
|
FITKOFFVSchemesWriter::FITKOFFVSchemesWriter()
|
|
{
|
|
}
|
|
FITKOFFVSchemesWriter::~FITKOFFVSchemesWriter()
|
|
{
|
|
}
|
|
|
|
void FITKOFFVSchemesWriter::setFilePath(const QString& filePath)
|
|
{
|
|
FITKOFAbstractDictWriter::setFilePath(filePath);
|
|
QFileInfo fileInfo(filePath);
|
|
//判断是否是路径
|
|
if (!fileInfo.isDir())return;
|
|
m_fileName = QString("%1/system/fvSchemes").arg(filePath);
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::run()
|
|
{
|
|
//判断文件是否存在
|
|
if (m_fileName.isEmpty())return false;
|
|
//获取字典工程
|
|
this->openDictObject();
|
|
if (!m_objectDict)return false;
|
|
//写出FoamFile
|
|
this->dictObjectFoamFile();
|
|
//设置写出的网格区域数据
|
|
bool Ok = this->fvSchemesW();
|
|
//写出字典文件
|
|
if (Ok)
|
|
Ok = this->writeDictFile();
|
|
|
|
//关闭字典工程
|
|
this->closeDictObject();
|
|
return Ok;
|
|
}
|
|
|
|
QString FITKOFFVSchemesWriter::getFileName()
|
|
{
|
|
return m_fileName;
|
|
}
|
|
|
|
void FITKOFFVSchemesWriter::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", "fvSchemes");
|
|
m_objectDict->append("FoamFile", group);
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeEmptySchemes()
|
|
{
|
|
if (!m_objectDict) return false;
|
|
DICT::FITKDictGroup* timeOp = new DICT::FITKDictGroup;
|
|
m_objectDict->append("ddtSchemes", timeOp);
|
|
timeOp->append("default", "none");
|
|
|
|
DICT::FITKDictGroup* gradSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("gradSchemes", gradSchemes);
|
|
gradSchemes->append("default", "none");
|
|
|
|
DICT::FITKDictGroup* divSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("divSchemes", divSchemes);
|
|
divSchemes->append("default", "none");
|
|
|
|
DICT::FITKDictGroup* laplacianSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("laplacianSchemes", laplacianSchemes);
|
|
laplacianSchemes->append("default", "none");
|
|
|
|
DICT::FITKDictGroup* interpolationSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("interpolationSchemes", interpolationSchemes);
|
|
interpolationSchemes->append("default", "none");
|
|
|
|
DICT::FITKDictGroup* snGradSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("snGradSchemes", snGradSchemes);
|
|
snGradSchemes->append("default", "none");
|
|
|
|
DICT::FITKDictGroup* fluxRequired = new DICT::FITKDictGroup;
|
|
m_objectDict->append("fluxRequired", fluxRequired);
|
|
fluxRequired->append("default", "no");
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::fvSchemesW()
|
|
{
|
|
if (!m_objectDict) return false;
|
|
//获取全局数据管理器
|
|
AppFrame::FITKGlobalData* globalData = FITKAPP->getGlobalData();
|
|
if (!globalData)return false;
|
|
//获取物理数据
|
|
Interface::FITKOFPhysicsData* physicsData = globalData->getPhysicsData<Interface::FITKOFPhysicsData>();
|
|
if (!physicsData)return false;
|
|
Interface::FITKAbstractOFSolver* solver = physicsData->getSolver();
|
|
if (!solver)return false;
|
|
|
|
//根据不同求解器设置求解通量
|
|
Interface::FITKOFSolverTypeEnum::FITKOFSolverType solverType = solver->getSolverType();
|
|
//获取离散数据
|
|
Interface::FITKOFDiscretization* discretization = physicsData->getDiscretization();
|
|
if (!discretization)return this->writeEmptySchemes();
|
|
bool ok = this->writeDDTSchemes(discretization->getTimeOption());
|
|
ok &= this->writeGradSchemes(discretization->getGradients());
|
|
if (solverType == Interface::FITKOFSolverTypeEnum::FITKOFSolverType::SIMPLE)
|
|
ok &= this->writeDivSchemesSimple(discretization);
|
|
else if (solverType == Interface::FITKOFSolverTypeEnum::FITKOFSolverType::INTER)
|
|
ok &= this->writeDivSchemesInter(discretization);
|
|
ok &= this->writeLaplacianSchemes(discretization);
|
|
ok &= this->writeInterpolationSchemes(discretization->getInterpolation());
|
|
ok &= this->writesnGradSchemes(discretization->getGradients());
|
|
ok &= this->writeFluxWall();
|
|
return ok;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeDDTSchemes(Core::FITKParameter* timeOption)
|
|
{
|
|
if (!timeOption)return false;
|
|
DICT::FITKDictGroup* timeOp = new DICT::FITKDictGroup;
|
|
m_objectDict->append("ddtSchemes", timeOp);
|
|
Core::FITKParamRadioGroup* timePara = dynamic_cast<Core::FITKParamRadioGroup*>(timeOption->getDataByName("Time Type"));
|
|
Core::FITKRadioGroupValue value = timePara->getCurrentRadioGroupValue();
|
|
QString paraValue;
|
|
if (value._name == "Steady State")
|
|
paraValue = "steadyState";
|
|
else if (value._name == "Implicit Euler")
|
|
paraValue = "Euler";
|
|
else if (value._name == "Backward")
|
|
paraValue = "backward";
|
|
else if (value._name == "Crank-Nicolson")
|
|
{
|
|
if (!value._value)return false;
|
|
bool ok = false;
|
|
double v = value._value->getDoubleParaByName("Crank-Nicolson", ok);
|
|
paraValue = QString("CrankNicolson %1").arg(QString::number(v));
|
|
}
|
|
else if (value._name == "Local Euler")
|
|
paraValue = "localEuler";
|
|
//获取boundary
|
|
QList<Core::FITKAbstractEasyParam*> baselist = timePara->getSubValues();
|
|
bool isBounded = false;
|
|
for (Core::FITKAbstractEasyParam* data : baselist)
|
|
{
|
|
if (data->getDataObjectName() == "Bounded")
|
|
{
|
|
Core::FITKParamBool* d = dynamic_cast<Core::FITKParamBool*>(data);
|
|
if (!d)return false;
|
|
isBounded = d->getValue();
|
|
}
|
|
}
|
|
if (isBounded)
|
|
timeOp->append("default", QString("bounded %1").arg(paraValue));
|
|
else
|
|
timeOp->append("default", paraValue);
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeGradSchemes(Core::FITKParameter* gradient)
|
|
{
|
|
if (!gradient)return false;
|
|
DICT::FITKDictGroup* gradSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("gradSchemes", gradSchemes);
|
|
Core::FITKParamRadioGroup* gradientData = dynamic_cast<Core::FITKParamRadioGroup*>(gradient->getDataByName("Gradient"));
|
|
if (!gradientData)return false;
|
|
Core::FITKRadioGroupValue value = gradientData->getCurrentRadioGroupValue();
|
|
if (value._name.isEmpty()) return false;
|
|
QString gradType;
|
|
if (value._name == "Gauss")
|
|
{
|
|
if (!value._value)return false;
|
|
Core::FITKParamCombox* gauss = dynamic_cast<Core::FITKParamCombox*>(value._value->getDataByName("Gauss"));
|
|
if (!gauss)return false;
|
|
QString gaussType = gauss->getCurrentValue().toLower().remove(' ');
|
|
gradType = QString("Gauss %1").arg(gaussType);
|
|
}
|
|
else if (value._name == "Least Squares")
|
|
gradType = "leastSquares";
|
|
else if (value._name == "Fourth")
|
|
gradType = "fourth";
|
|
//获取boundary
|
|
Core::FITKParameter* subValue = gradientData->getSubValuePara();
|
|
if (!subValue) return false;
|
|
Core::FITKParamRadioGroup* limitScheme = dynamic_cast<Core::FITKParamRadioGroup*>(subValue->getDataByName("Limiting Scheme"));
|
|
if (!limitScheme)return false;
|
|
Core::FITKRadioGroupValue valueLimit = limitScheme->getCurrentRadioGroupValue();
|
|
if (valueLimit._name == "Cell Limited")
|
|
{
|
|
if (!valueLimit._value)return false;
|
|
Core::FITKParamDouble* cell = dynamic_cast<Core::FITKParamDouble*>(valueLimit._value->getDataByName("Cell Limited"));
|
|
if (!cell)return false;
|
|
gradType = QString("cellLimited %1 %2").arg(gradType).arg(QString::number(cell->getValue()));
|
|
}
|
|
else if (valueLimit._name == "Face Limited")
|
|
{
|
|
if (!valueLimit._value)return false;
|
|
Core::FITKParamDouble* face = dynamic_cast<Core::FITKParamDouble*>(valueLimit._value->getDataByName("Face Limited"));
|
|
if (!face)return false;
|
|
gradType = QString("faceLimited %1 %2").arg(gradType).arg(QString::number(face->getValue()));
|
|
}
|
|
gradSchemes->append("default", gradType);
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeDivSchemesSimple(Interface::FITKOFDiscretization* discretization)
|
|
{
|
|
if (!discretization)return false;
|
|
DICT::FITKDictGroup* divSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("divSchemes", divSchemes);
|
|
divSchemes->append("div((nuEff*dev2(T(grad(U)))))", "Gauss linear");
|
|
divSchemes->append("div(R)", "Gauss linear");
|
|
divSchemes->append("default", "bounded Gauss upwind");
|
|
int count = discretization->getConvectionCount();
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
QString vName = discretization->getConvectionVName(i);
|
|
Core::FITKParameter* vPara = discretization->getConvectionVPara(i);
|
|
if (!vPara)continue;
|
|
QString boundaryType = getConvectionValue(vPara);
|
|
divSchemes->append(QString("div(phi,%1)").arg(vName), boundaryType);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeDivSchemesInter(Interface::FITKOFDiscretization* discretization)
|
|
{
|
|
if (!discretization)return false;
|
|
DICT::FITKDictGroup* divSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("divSchemes", divSchemes);
|
|
divSchemes->append("div(((rho*nuEff)*dev2(T(grad(U)))))", "Gauss linear");
|
|
divSchemes->append("div(R)", "Gauss linear");
|
|
divSchemes->append("default", "Gauss upwind");
|
|
int count = discretization->getConvectionCount();
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
QString vName = discretization->getConvectionVName(i);
|
|
Core::FITKParameter* vPara = discretization->getConvectionVPara(i);
|
|
if (!vPara)continue;
|
|
QString boundaryType = getConvectionValue(vPara);
|
|
|
|
if (vName == "U")
|
|
divSchemes->append(QString("div(rhoPhi,%1)").arg(vName), boundaryType);
|
|
else
|
|
divSchemes->append(QString("div(phi,%1)").arg(vName), boundaryType);
|
|
}
|
|
|
|
divSchemes->append("div(phi,alpha)", "Gauss vanLeer");
|
|
divSchemes->append("div(phirb,alpha)", "Gauss linear");
|
|
return true;
|
|
}
|
|
|
|
QString FITKOFFVSchemesWriter::getConvectionValue(Core::FITKParameter* vPara)
|
|
{
|
|
if (!vPara)return QString();
|
|
Core::FITKParamRadioGroup* convectionType = dynamic_cast<Core::FITKParamRadioGroup*>(vPara->getDataByName("Convection Type"));
|
|
if (!convectionType)QString();
|
|
Core::FITKRadioGroupValue conT = convectionType->getCurrentRadioGroupValue();
|
|
QString boundaryType = conT._name.toLower().remove(' ');
|
|
if (boundaryType == "upwind")
|
|
boundaryType = "Gauss upwind";
|
|
else if (boundaryType == "linearupwind")
|
|
boundaryType = "Gauss linearUpwind";
|
|
|
|
Core::FITKParameter* sub = convectionType->getSubValuePara();
|
|
if (!sub)return QString();
|
|
int count = sub->getDataCount();
|
|
if (conT._labelValue.size() != count)return QString();
|
|
bool selectRes[3]{ false };
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
if (!conT._labelValue.at(i)) continue;
|
|
Core::FITKParamBool* selectData = dynamic_cast<Core::FITKParamBool*>(sub->getDataByIndex(i));
|
|
if (!selectData)continue;
|
|
QString name = selectData->getDataObjectName();
|
|
if (name == "VectorSpecific")
|
|
selectRes[0] = selectData->getValue();
|
|
else if (name == "Bounded")
|
|
selectRes[1] = selectData->getValue();
|
|
else if (name == "SkewCorrected")
|
|
selectRes[2] = selectData->getValue();
|
|
}
|
|
if (selectRes[0]) boundaryType += "V";
|
|
if (selectRes[2]) boundaryType = "skewCorrected " + boundaryType;
|
|
if (selectRes[1]) boundaryType = "bounded " + boundaryType;
|
|
return boundaryType;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeLaplacianSchemes(Interface::FITKOFDiscretization* discretization)
|
|
{
|
|
if (!discretization)return false;
|
|
DICT::FITKDictGroup* laplacianSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("laplacianSchemes", laplacianSchemes);
|
|
|
|
Core::FITKParameter* interpolation = discretization->getInterpolation();
|
|
if (!interpolation)return false;
|
|
Core::FITKParamCombox* scheme = dynamic_cast<Core::FITKParamCombox*>(interpolation->getDataByName("Scheme"));
|
|
if (!scheme)return false;
|
|
QString schemeType = scheme->getCurrentValue().toLower().remove(' ');
|
|
|
|
Core::FITKParameter* gradient = discretization->getGradients();
|
|
if (!gradient) return false;
|
|
Core::FITKParamRadioGroup* surGrad = dynamic_cast<Core::FITKParamRadioGroup*>(gradient->getDataByName("Surface Normal Gradient"));
|
|
if (!surGrad) return false;
|
|
Core::FITKRadioGroupValue surGradType = surGrad->getCurrentRadioGroupValue();
|
|
|
|
QString defaultValue;
|
|
if (surGradType._name == "Corrected")
|
|
defaultValue = QString("Gauss %1 corrected").arg(schemeType);
|
|
else if (surGradType._name == "Uncorrected")
|
|
defaultValue = QString("Gauss %1 uncorrected").arg(schemeType);
|
|
|
|
laplacianSchemes->append("default", defaultValue);
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeInterpolationSchemes(Core::FITKParameter* interpolation)
|
|
{
|
|
if (!interpolation)return false;
|
|
DICT::FITKDictGroup* interpolationSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("interpolationSchemes", interpolationSchemes);
|
|
|
|
Core::FITKParamCombox* scheme = dynamic_cast<Core::FITKParamCombox*>(interpolation->getDataByName("Scheme"));
|
|
if (!scheme)return false;
|
|
QString schemeType = scheme->getCurrentValue().toLower().remove(' ');
|
|
interpolationSchemes->append("default", schemeType);
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writesnGradSchemes(Core::FITKParameter* gradient)
|
|
{
|
|
if (!gradient)return false;
|
|
DICT::FITKDictGroup* snGradSchemes = new DICT::FITKDictGroup;
|
|
m_objectDict->append("snGradSchemes", snGradSchemes);
|
|
|
|
Core::FITKParamRadioGroup* surGrad = dynamic_cast<Core::FITKParamRadioGroup*>(gradient->getDataByName("Surface Normal Gradient"));
|
|
if (!surGrad) return false;
|
|
Core::FITKRadioGroupValue surGradType = surGrad->getCurrentRadioGroupValue();
|
|
|
|
QString defaultValue;
|
|
if (surGradType._name == "Corrected")
|
|
snGradSchemes->append("default", "corrected");
|
|
else if (surGradType._name == "Uncorrected")
|
|
snGradSchemes->append("default", "uncorrected");
|
|
return true;
|
|
}
|
|
|
|
bool FITKOFFVSchemesWriter::writeFluxWall()
|
|
{
|
|
//不同求解器计算的通量是不一样的
|
|
if (!m_objectDict) return false;
|
|
DICT::FITKDictGroup* fluxRequired = new DICT::FITKDictGroup;
|
|
m_objectDict->append("fluxRequired", fluxRequired);
|
|
fluxRequired->append("default", "no");
|
|
//获取全局数据管理器
|
|
AppFrame::FITKGlobalData* globalData = FITKAPP->getGlobalData();
|
|
if (!globalData)return false;
|
|
//获取物理数据
|
|
Interface::FITKOFPhysicsData* physicsData = globalData->getPhysicsData<Interface::FITKOFPhysicsData>();
|
|
if (!physicsData)return false;
|
|
Interface::FITKAbstractOFSolver* solver = physicsData->getSolver();
|
|
if (!solver)return false;
|
|
|
|
//根据不同求解器设置求解通量
|
|
Interface::FITKOFSolverTypeEnum::FITKOFSolverType solverType = solver->getSolverType();
|
|
if (solverType == Interface::FITKOFSolverTypeEnum::FITKOFSolverType::SIMPLE)
|
|
{
|
|
fluxRequired->append("p", "");
|
|
}
|
|
else if (solverType == Interface::FITKOFSolverTypeEnum::FITKOFSolverType::INTER)
|
|
{
|
|
fluxRequired->append("p_rgh", "");
|
|
fluxRequired->append("pcorr", "");
|
|
fluxRequired->append("alpha", "");
|
|
}
|
|
|
|
//wallDist
|
|
DICT::FITKDictGroup* wallDist = new DICT::FITKDictGroup;
|
|
m_objectDict->append("wallDist", wallDist);
|
|
wallDist->append("method", "meshWave");
|
|
wallDist->append("nRequired", false);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
|