AppFlow/FITK_Interface/FITKInterfaceFlowOF/FITKFlowPhysicsHandlerFactory.cpp

#include "FITKFlowPhysicsHandlerFactory.h"
#include "FITK_Kernel/FITKEasyParam/FITKParameter.h"
#include "FITKOFPhysicsData.h"
#include "FITKAbstractOFSolver.h"
#include "FITKAbstractOFTurbulence.h"
#include "FITKOFSolution.h"
#include "FITKOFDiscretization.h"
#include "FITKOFBoundary.h"
#include "FITKOFRunControl.h"
#include "FITKOFBoundaryType.h"
#include "FITKOFSolutionSolver.h"
#include "FITKOFInitialConditions.h"
#include "FITKOFTransportProp.h"
#include "FITKOFTransportModel.h"
#include "FITKOFPhysicsManager.h"
#include "FITKOFSolverManager.h"
#include "FITKOFSolutionSolverManager.h"
#include "FITKOFTurbulenceManager.h"
#include "FITKOFBoundaryTypeManager.h"
#include "FITKOFTransportModelManager.h"
#include "FITK_Kernel/FITKAppFramework/FITKAppFramework.h"
#include "FITK_Kernel/FITKAppFramework/FITKGlobalData.h"
#include "FITK_Interface/FITKInterfaceMesh/FITKUnstructuredFluidMeshVTK.h"
#include "FITKOFOperatingConditions.h"

namespace Interface
{
    QString FITKFlowPhysicsHandlerFactory::getComponentName()
    {
        return "FITKFlowPhysicsHandlerFactory";
    }

    void FITKFlowPhysicsHandlerFactory::setSolver(QString solverName)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //查看是否是当前求解器
        if (physicsData->getSolver() && physicsData->getSolver()->getDataObjectName() == solverName)return;
        //获取求解器管理器
        FITKOFSolverManager* solverManager = physicsManager->getSolverManager();
        if (!solverManager)return;
        //通过求解器名称获取求解器信息
        FITKOFSolverInfo solverInfo = solverManager->getSolverInfoBySolverName(solverName);
        //创建求解器
        FITKAbstractOFSolver* solver = solverInfo._createFuns();
        this->actionSetSolver(solver);
    }

    void FITKFlowPhysicsHandlerFactory::setTurbence(QString turbulenceName)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //查看是否是湍流数据
        if (physicsData->getTurbulence() && physicsData->getTurbulence()->getDataObjectName() == turbulenceName)return;
        //获取湍流模型管理器
        FITKOFTurbulenceManager* turbulenceManager = physicsManager->getTurbulenceManager();
        if (!turbulenceManager)return;
        //通过湍流模型名称获取湍流模型信息
        FITKOFTurbulenceInfo turbulenceInfo = turbulenceManager->getTurbenceInfoByTurbulenceName(turbulenceName);
        if (turbulenceInfo._turbType == FITKOFSolverTypeEnum::FITKOFTurbulenceType::TurbNone)
        {
            physicsData->setTurbulence(nullptr);
            return;
        }
        //创建湍流模型
        FITKAbstractOFTurbulence* turbulence = turbulenceInfo._createFuns();
        this->actionSetTurbulence(turbulence);
    }

    void FITKFlowPhysicsHandlerFactory::setSolutionSolver(int vIndex, QString solutionSolverName)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //查看是否设置类型重复
        FITKOFSolution* solution = physicsData->getSolution();
        if (!solution)return;
        FITKOFAlgebraicEquationsPara* vPara = solution->getSolverVariablePara(vIndex);
        if (!vPara) return;
        if (vPara->getSolutionSolver() && vPara->getSolutionSolver()->getDataObjectName() == solutionSolverName)return;
        //获取湍流模型管理器
        FITKOFSolutionSolverManager* solutionSolverManager = physicsManager->getSolutionSolverManager();
        if (!solutionSolverManager)return;
        //通过名称获取solutionSolver信息
        FITKOFSolutionSolverInfo info = solutionSolverManager->getSolutionSolverInfo(solutionSolverName);
        if (info._solutionSolverName.isEmpty())return;
        FITKOFAbsSolutionSolver* solutionSolver = info._createFuns();
        vPara->setSolutionSolver(solutionSolver);
    }

    void FITKFlowPhysicsHandlerFactory::setTransportModel(int phaseIndex, QString modelName)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取物理场材料
        FITKOFTransportProp* transportProp = physicsData->getTransportProp();
        if (!transportProp)return;
        //获取Phase数据对象
        FITKOFTransportPhase* phase = transportProp->getPhase(phaseIndex);
        if (!phase)return;
        //获取Transport Model管理器
        FITKOFTransportModelManager* transportModelManager = physicsManager->getTransportModelManager();
        //通过名称获取Transport Model信息
        FITKOFTransportModelInfo info = transportModelManager->getTransportModelInfo(modelName);
        if (info._transModelName.isEmpty())return;
        FITKAbsOFTransportModel* modelNew = info._createFuns();
        phase->setTransportModel(modelNew);
    }

    void FITKFlowPhysicsHandlerFactory::setBoundary(int meshBoundaryId, FITKOFSolverTypeEnum::FITKOFBoundaryType bType)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取物理场边界管理器
        FITKOFBoundaryManager* boundaryManagerPhy = physicsData->getBoundaryManager();
        if (!boundaryManagerPhy)return;
        //获取边界类型管理器
        FITKOFBoundaryTypeManager* boundaryTypeManager = physicsManager->getBoundaryTypeManager();
        if (!boundaryTypeManager)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器里的边界信息
        FITKOFBoundary* boundarySol = solver->getBoundary(bType);
        if (!boundarySol)return;
        //创建新边界并添加到物理场边界管理器
        FITKOFBoundary* boundaryPhy = new FITKOFBoundary(bType);
        boundaryManagerPhy->appendDataObj(boundaryPhy);
        boundaryPhy->setMeshBoundaryID(meshBoundaryId);
        //将solver边界添加到物理场Flow
        int countSolFlow = boundarySol->getFlowCount();
        for (int i = 0; i < countSolFlow; ++i)
        {
            //获取求解器的变量名和边界
            QString variableName = boundarySol->getFlowVariableName(i);
            FITKOFAbsBoundaryType* boundaryType = boundarySol->getFlowVBType(i);
            if (!boundaryType)continue;
            //获取边界类型信息
            FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundarySol->getBoundaryType());
            if (info._boundaryTypeName.isEmpty())continue;
            //创建新的边界类型对象
            FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
            Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
            //拷贝数据对象
            para->copyPara(boundaryType->getBoundaryTypePara());
            //设置边界数据对象
            boundaryPhy->setFlowBoundary(variableName, boundaryTypeNew);
        }
        //将solver边界添加到物理场Phase
        int countSolPhases = boundarySol->getPhasesCount();
        for (int i = 0; i < countSolPhases; ++i)
        {
            //获取求解器的变量名和边界
            QString variableName = boundarySol->getPhasesVariableName(i);
            FITKOFAbsBoundaryType* boundaryType = boundarySol->getPhasesVBType(i);
            if (!boundaryType)continue;
            //获取边界类型信息
            FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundarySol->getBoundaryType());
            if (info._boundaryTypeName.isEmpty())continue;
            //创建新的边界类型对象
            FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
            Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
            //拷贝数据对象
            para->copyPara(boundaryType->getBoundaryTypePara());
            //设置边界数据对象
            boundaryPhy->setPhasesBoundary(variableName, boundaryTypeNew);
        }
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        if (!turbulence)return;
        //获取湍流里的边界信息
        FITKOFBoundary* boundaryTur = turbulence->getBoundary(bType);
        if (!boundaryTur)return;
        //将湍流边界添加到物理场Turbulence
        int countSolTurbulence = boundaryTur->getTurbulenceCount();
        for (int i = 0; i < countSolTurbulence; ++i)
        {
            //获取求解器的变量名和边界
            QString variableName = boundaryTur->getTurbulenceVariableName(i);
            FITKOFAbsBoundaryType* boundaryType = boundaryTur->getTurbulenceVBType(i);
            if (!boundaryType)continue;
            //获取边界类型信息
            FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundaryTur->getBoundaryType());
            if (info._boundaryTypeName.isEmpty())continue;
            //创建新的边界类型对象
            FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
            Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
            //拷贝数据对象
            para->copyPara(boundaryType->getBoundaryTypePara());
            //设置边界数据对象
            boundaryPhy->setTurbulenceBoundary(variableName, boundaryTypeNew);
        }
    }

    void FITKFlowPhysicsHandlerFactory::setBoundaryType(int boundaryIndex, FITKOFSolverTypeEnum::FITKOFBoundaryType bType)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取物理场边界管理器
        FITKOFBoundaryManager* boundaryManagerPhy = physicsData->getBoundaryManager();
        if (!boundaryManagerPhy)return;
        //获取边界类型管理器
        FITKOFBoundaryTypeManager* boundaryTypeManager = physicsManager->getBoundaryTypeManager();
        if (!boundaryTypeManager)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器里的边界信息
        FITKOFBoundary* boundarySol = solver->getBoundary(bType);
        if (!boundarySol)return;
        //获取物理场边界
        FITKOFBoundary* boundaryPhy = boundaryManagerPhy->getDataByIndex(boundaryIndex);
        if (!boundaryPhy)return;
        //将solver边界添加到物理场Flow
        int countSolFlow = boundarySol->getFlowCount();
        for (int i = 0; i < countSolFlow; ++i)
        {
            //获取求解器的变量名和边界
            QString variableName = boundarySol->getFlowVariableName(i);
            FITKOFAbsBoundaryType* boundaryType = boundarySol->getFlowVBType(i);
            if (!boundaryType)continue;
            //获取边界类型信息
            FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundarySol->getBoundaryType());
            if (info._boundaryTypeName.isEmpty())continue;
            //创建新的边界类型对象
            FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
            Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
            //拷贝数据对象
            para->copyPara(boundaryType->getBoundaryTypePara());
            //设置边界数据对象
            boundaryPhy->setFlowBoundary(variableName, boundaryTypeNew);
        }
        //将solver边界添加到物理场Phase
        int countSolPhases = boundarySol->getPhasesCount();
        for (int i = 0; i < countSolPhases; ++i)
        {
            //获取求解器的变量名和边界
            QString variableName = boundarySol->getPhasesVariableName(i);
            FITKOFAbsBoundaryType* boundaryType = boundarySol->getPhasesVBType(i);
            if (!boundaryType)continue;
            //获取边界类型信息
            FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundarySol->getBoundaryType());
            if (info._boundaryTypeName.isEmpty())continue;
            //创建新的边界类型对象
            FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
            Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
            //拷贝数据对象
            para->copyPara(boundaryType->getBoundaryTypePara());
            //设置边界数据对象
            boundaryPhy->setPhasesBoundary(variableName, boundaryTypeNew);
        }
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        if (!turbulence)return;
        //获取湍流里的边界信息
        FITKOFBoundary* boundaryTur = turbulence->getBoundary(bType);
        if (!boundaryTur)return;
        //将湍流边界添加到物理场Turbulence
        int countSolTurbulence = boundaryTur->getTurbulenceCount();
        for (int i = 0; i < countSolTurbulence; ++i)
        {
            //获取求解器的变量名和边界
            QString variableName = boundaryTur->getTurbulenceVariableName(i);
            FITKOFAbsBoundaryType* boundaryType = boundaryTur->getTurbulenceVBType(i);
            if (!boundaryType)continue;
            //获取边界类型信息
            FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundaryTur->getBoundaryType());
            if (info._boundaryTypeName.isEmpty())continue;
            //创建新的边界类型对象
            FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
            Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
            //拷贝数据对象
            para->copyPara(boundaryType->getBoundaryTypePara());
            //设置边界数据对象
            boundaryPhy->setTurbulenceBoundary(variableName, boundaryTypeNew);
        }
    }

    void FITKFlowPhysicsHandlerFactory::setVariableBoundaryType(int boundaryId, QString variableName, QString boundaryType)
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取物理场边界管理器
        FITKOFBoundaryManager* boundaryManagerPhy = physicsData->getBoundaryManager();
        if (!boundaryManagerPhy)return;
        //获取边界类型管理器
        FITKOFBoundaryTypeManager* boundaryTypeManager = physicsManager->getBoundaryTypeManager();
        if (!boundaryTypeManager)return;
        //获取物理场边界
        FITKOFBoundary* boundaryPhy = boundaryManagerPhy->getDataByID(boundaryId);
        if (!boundaryPhy)return;
        //获取边界类型信息
        FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType, solver->getSolverType(), variableName, boundaryPhy->getBoundaryType());
        if (info._boundaryTypeName.isEmpty())return;
        //创建新的边界类型对象
        FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
        boundaryPhy->setBoundary(variableName, boundaryTypeNew);
    }

    void FITKFlowPhysicsHandlerFactory::recordBoundaryMeshName()
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取物理场边界管理器
        FITKOFBoundaryManager* boundaryManagerPhy = physicsData->getBoundaryManager();
        if (!boundaryManagerPhy)return;
        //记录网格边界名称
        int count = boundaryManagerPhy->getDataCount();
        for (int i = 0; i < count; ++i)
        {
            FITKOFBoundary* boundary = boundaryManagerPhy->getDataByIndex(i);
            if (!boundary)continue;
            FITKBoundaryMeshVTK* boundaryMesh = boundary->getMeshBoundary();
            if (!boundaryMesh)continue;
            QString name = boundaryMesh->getDataObjectName();
            boundary->setUserData(Core::FITKUserData::FITKUserRole, name);
        }
    }

    void FITKFlowPhysicsHandlerFactory::resetBoundaryMesh()
    {
        //获取全局数据
        AppFrame::FITKGlobalData* globalData = FITKAPP->getGlobalData();
        if (!globalData)return;
        //获取网格数据
        Interface::FITKUnstructuredFluidMeshVTK* meshData = globalData->getMeshData<Interface::FITKUnstructuredFluidMeshVTK>();
        if (!meshData)return;
        //获取边界网格管理器
        Interface::FITKBoundaryMeshVTKManager* boundaryMeshMgr = meshData->getBoundaryMeshManager();
        if (!boundaryMeshMgr)return;
        //获取物理数据
        FITKOFPhysicsData* physicsData = globalData->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取物理场边界管理器
        FITKOFBoundaryManager* boundaryManagerPhy = physicsData->getBoundaryManager();
        if (!boundaryManagerPhy)return;
        int count = boundaryManagerPhy->getDataCount();
        for (int i = count - 1; i >= 0; --i)
        {
            FITKOFBoundary* boundary = boundaryManagerPhy->getDataByIndex(i);
            if (!boundary)continue;
            QString name = boundary->getUserDataT<QString>(Core::FITKUserData::FITKUserRole);
            Interface::FITKBoundaryMeshVTK* boundaryMesh = boundaryMeshMgr->getDataByName(name);
            if (boundaryMesh)
            {
                boundary->setMeshBoundaryID(boundaryMesh->getDataObjectID());
                continue;
            }
            boundaryManagerPhy->removeDataByIndex(i);
        }
    }

    void FITKFlowPhysicsHandlerFactory::setPatch(int geometryId, QStringList vNameList, FITKOFSolverInitialEnum::FITKPatchApplyObjectType type)
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器下的init数据
        FITKOFInitialConditions* physicsInitial = physicsData->getInitialConditions();
        if (!physicsInitial)return;
        //获取物理数据的init数据
        FITKOFInitialConditions* solverInitial = solver->getInitialConditions();
        if (!solverInitial)return;
        //创建patch
        FITKOFGeometryPatch* patch = new FITKOFGeometryPatch(geometryId, type);
        physicsInitial->appendPatch(patch);
        Core::FITKParameter* fieldData = patch->getFieldPara();
        //
        Core::FITKParameter* basicSol = solverInitial->getBasicData();
        int count = basicSol->getDataCount();
        for (int i = 0; i < count; ++i)
        {
            Core::FITKAbstractEasyParam* data = basicSol->getDataByIndex(i);
            if (!data)continue;
            QString name = data->getDataObjectName();
            if (!vNameList.contains(name))continue;
            fieldData->copyAppendPara(data);
        }
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        if (!turbulence)return;
        //获取湍流下的离散数据变化量
        FITKOFInitialConditions* turbulenceInitial = turbulence->getInitialConditions();
        if (!turbulenceInitial)return;
        Core::FITKParameter* basicTur = turbulenceInitial->getBasicData();
        count = basicTur->getDataCount();
        for (int i = 0; i < count; ++i)
        {
            Core::FITKAbstractEasyParam* data = basicTur->getDataByIndex(i);
            if (!data)continue;
            QString name = data->getDataObjectName();
            if (!vNameList.contains(name))continue;
            fieldData->copyAppendPara(data);
        }
    }

    QStringList FITKFlowPhysicsHandlerFactory::filterPatchFieldsType()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return QStringList();
        //获取求解器下的init数据
        FITKOFInitialConditions* physicsInitial = physicsData->getInitialConditions();
        if (!physicsInitial)return QStringList();
        //获取初始化参数
        Core::FITKParameter* basic = physicsInitial->getBasicData();
        if (!basic)return QStringList();
        QStringList strList;
        int count = basic->getDataCount();
        for (int i = 0; i < count; ++i)
        {
            Core::FITKAbstractEasyParam* data = basic->getDataByIndex(i);
            if (!data)continue;
            strList.append(data->getDataObjectName());
        }
        return strList;
    }

    bool FITKFlowPhysicsHandlerFactory::isExecuteSetFields()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return false;
        //获取求解器下的init数据
        FITKOFInitialConditions* physicsInitial = physicsData->getInitialConditions();
        if (!physicsInitial)return false;
        //获取patch数量
        return physicsInitial->getPatchCount() > 0;
    }

    void FITKFlowPhysicsHandlerFactory::clearPhysicsData()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //清理所有物理数据
        physicsData->setSolver(nullptr);
        physicsData->setEnableTurbulenceEqu(false);
        physicsData->setTurbulence(nullptr);
        physicsData->setTransportProp(nullptr);
        physicsData->setDiscretization(nullptr);
        physicsData->setSolution(nullptr);
        physicsData->setInitialConditions(nullptr);
        physicsData->setBoundaryManager(nullptr);
        physicsData->setRunControl(nullptr);
        physicsData->setOperatingConditions(nullptr);
    }

    void FITKFlowPhysicsHandlerFactory::actionSetSolver(FITKAbstractOFSolver* solver)
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //设置求解器
        physicsData->setSolver(solver);
        if (!solver)return;
        //设置是否启用湍流数据
        physicsData->setEnableTurbulenceEqu(solver->turbEnabled());
        //设置湍流为空
        physicsData->setTurbulence(nullptr);
        //设置离散
        this->setPhysicsDiscretization();
        //设置solution数据
        this->setPhysicsSolution();
        //设置init数据
        this->setPhysicsInitialConditions();
        //设置材料数据
        this->setPhysicsTransportProp();
        //设置边界管理器
        physicsData->setBoundaryManager(new FITKOFBoundaryManager);
        //设置运行配置
        this->setPhysicsRunControl();
        //设置工作条件
        this->setPhysicsOperatingConditions();
    }

    void FITKFlowPhysicsHandlerFactory::actionSetTurbulence(FITKAbstractOFTurbulence* turbulence)
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //设置湍流
        physicsData->setTurbulence(turbulence);
        //更新变量
        this->updatePhysicsDiscretization();
        this->updatePhysicsSolution();
        this->updatePhysicsInitialConditions();
        this->updatePhysicsBoundaryConditions();
    }

    void FITKFlowPhysicsHandlerFactory::setPhysicsDiscretization()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器下的离散数据
        FITKOFDiscretization* discretizationSol = solver->getDiscretization();
        if (!discretizationSol)return;
        //创建离散数据，初始化离散数据复制到实际数据中
        FITKOFDiscretization* discretizationPhy = new FITKOFDiscretization;
        //拷贝Time
        Core::FITKParameter* timePhy = discretizationPhy->getTimeOption();
        Core::FITKParameter* timeSol = discretizationSol->getTimeOption();
        if (timePhy && timeSol)
            timePhy->copyPara(timeSol);
        //拷贝Gradients
        Core::FITKParameter* gradientsPhy = discretizationPhy->getGradients();
        Core::FITKParameter* gradientsSol = discretizationSol->getGradients();
        if (gradientsPhy && gradientsSol)
            gradientsPhy->copyPara(gradientsSol);
        //拷贝Interpolation
        Core::FITKParameter* interpolationPhy = discretizationPhy->getInterpolation();
        Core::FITKParameter* interpolationSol = discretizationSol->getInterpolation();
        if (interpolationPhy && interpolationSol)
            interpolationPhy->copyPara(interpolationSol);
        //拷贝对流数据
        int count = discretizationSol->getConvectionCount();
        for (int i = 0; i < count; ++i)
        {
            Core::FITKParameter* para = discretizationSol->getConvectionVPara(i);
            if (!para)continue;
            Core::FITKParameter* newPara = new Core::FITKParameter;
            newPara->copyPara(para);
            discretizationPhy->insertConvection(discretizationSol->getConvectionVName(i), newPara);
        }
        //设置数据到物理数据
        physicsData->setDiscretization(discretizationPhy);
    }

    void FITKFlowPhysicsHandlerFactory::setPhysicsSolution()
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取湍流模型管理器
        FITKOFSolutionSolverManager* solutionSolverManager = physicsManager->getSolutionSolverManager();
        if (!solutionSolverManager)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器下的solution数据
        FITKOFSolution* solutionSol = solver->getSolution();
        if (!solutionSol)return;
        //创建solution,初始化solution数据复制到实际数据中
        FITKOFSolution* solutionPhy = new FITKOFSolution;
        //拷贝Solvers
        int count = solutionSol->getSolversCount();
        for (int i = 0; i < count; ++i)
        {
            //获取求解器代数变量数据对象
            FITKOFAlgebraicEquationsPara* solutionSolverSol = solutionSol->getSolverVariablePara(i);
            if (!solutionSolverSol)continue;
            FITKOFAbsSolutionSolver* data = solutionSolverSol->getSolutionSolver();
            if (!data)continue;
            //获取代数变量求解器信息
            FITKOFSolutionSolverInfo info = solutionSolverManager->getSolutionSolverInfo(data->getDataObjectName());
            if (info._solutionSolverName.isEmpty())continue;
            FITKOFAbsSolutionSolver* newData = info._createFuns();
            if (!newData)continue;
            Core::FITKParameter* para = newData->getSolverSolutionPara();
            para->copyPara(data->getSolverSolutionPara());
            //获取变量求解增加的参数对象并设置数据
            Core::FITKParameter* additionPSol = solutionSolverSol->getSolverAdditionalPara();
            Core::FITKParameter* additionPPhy = nullptr;
            if (additionPSol)
            {
                additionPPhy = new Core::FITKParameter;
                additionPPhy->copyPara(additionPSol);
            }
            //获取变量名称
            QString vname = solutionSolverSol->getVariableName();
            //创建新的数据对象
            FITKOFAlgebraicEquationsPara* solutionSolverPhy = new FITKOFAlgebraicEquationsPara;
            solutionSolverPhy->setVariableName(vname);
            solutionSolverPhy->setSolutionSolver(newData);
            solutionSolverPhy->setSolverAdditionalPara(additionPPhy);
            solutionPhy->appendSolutionSolver(solutionSolverPhy);
        }
        //拷贝求解器有关的特殊数据
        Core::FITKParameter* speciallySol = solutionSol->getSolverSpeciallyDataPara();
        if (speciallySol)
        {
            Core::FITKParameter* speciallyPhy = new Core::FITKParameter;
            speciallyPhy->copyPara(speciallySol);
            solutionPhy->setSpeciallyData(solutionSol->getSolverSpeciallyDataName(), speciallyPhy);
        }
        //拷贝residuals
        count = solutionSol->getResidualsCount();
        for (int i = 0; i < count; ++i)
        {
            Core::FITKParameter* para = solutionSol->getResidualVariablePara(i);
            if (!para)continue;
            Core::FITKParameter* newPara = new Core::FITKParameter;
            newPara->copyPara(para);
            solutionPhy->setResidualData(solutionSol->getResidualVariableName(i), newPara);
        }
        //拷贝relaxation
        Core::FITKParameter* relaxationSol = solutionSol->getRelaxation();
        Core::FITKParameter* relaxationPhy = solutionPhy->getRelaxation();
        if (relaxationPhy && relaxationSol)
            relaxationPhy->copyPara(relaxationSol);
        //拷贝limits
        Core::FITKParameter* limitsSol = solutionSol->getLimits();
        Core::FITKParameter* limitsPhy = solutionPhy->getLimits();
        if (limitsPhy && limitsSol)
            limitsPhy->copyPara(limitsSol);
        //设置数据到物理数据
        physicsData->setSolution(solutionPhy);
    }

    void FITKFlowPhysicsHandlerFactory::setPhysicsInitialConditions()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器下的离散数据
        FITKOFInitialConditions* solverInitial = solver->getInitialConditions();
        if (!solverInitial)return;
        //创建Initial数据，初始化Initial数据复制到实际数据中
        FITKOFInitialConditions* physicsInitial = new FITKOFInitialConditions;
        //拷贝Basic
        Core::FITKParameter* basicSol = solverInitial->getBasicData();
        Core::FITKParameter* basicPhy = physicsInitial->getBasicData();
        if (basicPhy && basicSol)
            basicPhy->copyPara(basicSol);
        //设置数据到物理数据
        physicsData->setInitialConditions(physicsInitial);
    }

    void FITKFlowPhysicsHandlerFactory::setPhysicsTransportProp()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取物理材料管理器
        FITKOFTransportModelManager* transportModelManager = physicsManager->getTransportModelManager();
        if (!transportModelManager)return;
        // 获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器下的物理材料
        FITKOFTransportProp* transSol = solver->getTransportProp();
        if (!transSol)return;
        //创建物理材料数据，初始化物理材料数据复制到实际数据中
        FITKOFTransportProp* transPhy = new FITKOFTransportProp;
        //拷贝材料所需参数
        Core::FITKParameter* addTransSol = transSol->getTransportAdditionalData();
        Core::FITKParameter* addTransPhy = transPhy->getTransportAdditionalData();
        if (addTransPhy && addTransSol)
            addTransPhy->copyPara(addTransSol);
        //拷贝Phase
        int count = transSol->getPhasesCount();
        for (int i = 0; i < count; ++i)
        {
            FITKOFTransportPhase* phaseSol = transSol->getPhase(i);
            if (!phaseSol) continue;

            Core::FITKParameter* addPhaseParaSol = phaseSol->getPhaseAdditionalData();
            FITKAbsOFTransportModel* modelSol = phaseSol->getTransportModel();
            FITKOFTransportModelInfo info = transportModelManager->getTransportModelInfo(modelSol->getDataObjectName());
            if (info._transModelName.isEmpty())continue;

            FITKAbsOFTransportModel* newModel = info._createFuns();
            Core::FITKParameter* modelPara = newModel->getTransportModelPara();
            modelPara->copyPara(modelSol->getTransportModelPara());
            Core::FITKParameter* addPhaseParaPhy = nullptr;
            if (addPhaseParaSol)
            {
                addPhaseParaPhy = new Core::FITKParameter;
                addPhaseParaPhy->copyPara(addPhaseParaSol);
            }
            //创建新对象
            FITKOFTransportPhase* phaseNew = new FITKOFTransportPhase;
            phaseNew->setPhaseName(phaseSol->getPhaseName());
            phaseNew->setPhaseAdditionalData(addPhaseParaPhy);
            phaseNew->setTransportModel(newModel);

            transPhy->appendPhase(phaseNew);
        }
        physicsData->setTransportProp(transPhy);
    }

    void FITKFlowPhysicsHandlerFactory::setPhysicsRunControl()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器下的运行配置数据
        FITKOFRunControl* solverRun = solver->getRunControl();
        if (!solverRun)return;
        //创建运行配置数据对象，初始化运行配置数据复制到实际数据中
        FITKOFRunControl* physicsRun = new FITKOFRunControl;
        //拷贝TimeControl
        Core::FITKParameter* timeConPhy = physicsRun->getTimeControl();
        Core::FITKParameter* timeConSol = solverRun->getTimeControl();
        if (timeConPhy && timeConSol)
            timeConPhy->copyPara(timeConSol);
        //拷贝OutputControl
        Core::FITKParameter* outputConPhy = physicsRun->getOutputControl();
        Core::FITKParameter* outputConSol = solverRun->getOutputControl();
        if (outputConPhy && outputConSol)
            outputConPhy->copyPara(outputConSol);
        //设置数据到物理数据
        physicsData->setRunControl(physicsRun);
    }

    void FITKFlowPhysicsHandlerFactory::setPhysicsOperatingConditions()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取求解器里的数据
        FITKOFOperatingConditions* operatingSol = solver->getOperatingConditions();
        if (!operatingSol)return;
        //创建新数据
        FITKOFOperatingConditions* operatingPhy = new FITKOFOperatingConditions;
        //拷贝引力与加速度条件参数
        Core::FITKParameter* gaPhy = operatingPhy->getGravitationalAcceleration();
        Core::FITKParameter* gaSol = operatingSol->getGravitationalAcceleration();
        if (gaPhy && gaSol)
            gaPhy->copyPara(gaSol);
        //拷贝OutputControl
        Core::FITKParameter* rpPhy = operatingPhy->getReferencePressure();
        Core::FITKParameter* rpSol = operatingSol->getReferencePressure();
        if (rpPhy && rpSol)
            rpPhy->copyPara(rpSol);
        physicsData->setOperatingConditions(operatingPhy);
    }

    void FITKFlowPhysicsHandlerFactory::updatePhysicsDiscretization()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器和物理数据离散数据
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        FITKOFDiscretization* physicsDis = physicsData->getDiscretization();
        if (!solver || !physicsDis)return;
        //获取求解器的离散数据
        FITKOFDiscretization* solverDis = solver->getDiscretization();
        if (!solverDis)return;
        //获取需要保留的离散数据名称
        QStringList nameList;
        int count = solverDis->getConvectionCount();
        for (int i = 0; i < count; ++i)
        {
            nameList.append(solverDis->getConvectionVName(i));
        }
        //设置需要保留物理数据离散数据
        physicsDis->onlyKeepConvection(nameList);
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        if (!turbulence)return;
        //获取湍流下的离散数据变化量
        FITKOFDiscretization* turbulenceDis = turbulence->getDiscretization();
        if (!turbulenceDis)return;
        //设置湍流下的离散数据变化量到物理数据离散数据
        count = turbulenceDis->getConvectionCount();
        for (int i = 0; i < count; ++i)
        {
            Core::FITKParameter* para = turbulenceDis->getConvectionVPara(i);
            if (!para)continue;
            Core::FITKParameter* newPara = new Core::FITKParameter;
            newPara->copyPara(para);
            physicsDis->insertConvection(turbulenceDis->getConvectionVName(i), newPara);
        }
    }

    void FITKFlowPhysicsHandlerFactory::updatePhysicsSolution()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取湍流模型管理器
        FITKOFSolutionSolverManager* solutionSolverManager = physicsManager->getSolutionSolverManager();
        if (!solutionSolverManager)return;
        //获取求解器和物理数据solution数据
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        FITKOFSolution* physicsSol = physicsData->getSolution();
        if (!solver || !physicsSol)return;
        //获取求解器的solution数据
        FITKOFSolution* solverSol = solver->getSolution();
        if (!solverSol)return;
        //获取relaxation参数
        Core::FITKParameter* relaxationPhy = physicsSol->getRelaxation();
        if (!relaxationPhy)return;
        //获取需要保留的solution数据名称
        QStringList nameSolversList, nameResidualsList;
        int count = solverSol->getSolversCount();
        for (int i = 0; i < count; ++i)
        {
            FITKOFAlgebraicEquationsPara* para = solverSol->getSolverVariablePara(i);
            if (!para)continue;
            nameSolversList.append(para->getVariableName());
        }
        count = solverSol->getResidualsCount();
        for (int i = 0; i < count; ++i)
        {
            nameResidualsList.append(solverSol->getResidualVariableName(i));
        }
        //设置需要保留物理数据离散数据
        solverSol->onlyKeepSolvers(nameSolversList);
        solverSol->onlyKeepResiduals(nameResidualsList);
        relaxationPhy->onlyKeepPara(solverSol->getRelaxation());
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        if (!turbulence)return;
        //获取湍流下的solution数据变化量
        FITKOFSolution* turbulenceSlo = turbulence->getSolution();
        if (!turbulenceSlo)return;
        //设置湍流下的solution数据变化量到物理数据solution数据
        count = turbulenceSlo->getSolversCount();
        for (int i = 0; i < count; ++i)
        {
            //获取求解器代数变量数据对象
            FITKOFAlgebraicEquationsPara* solutionSolverTur = turbulenceSlo->getSolverVariablePara(i);
            if (!solutionSolverTur)continue;
            FITKOFAbsSolutionSolver* data = solutionSolverTur->getSolutionSolver();
            if (!data)continue;
            FITKOFSolutionSolverInfo info = solutionSolverManager->getSolutionSolverInfo(data->getDataObjectName());
            if (info._solutionSolverName.isEmpty())continue;
            FITKOFAbsSolutionSolver* solutionSolver = info._createFuns();
            if (!solutionSolver)continue;
            //获取变量求解增加的参数对象并设置数据
            Core::FITKParameter* additionPTur = solutionSolverTur->getSolverAdditionalPara();
            Core::FITKParameter* additionPPhy = nullptr;
            if (additionPTur)
            {
                additionPPhy = new Core::FITKParameter;
                additionPPhy->copyPara(additionPTur);
            }
            //获取变量名称
            QString vname = solutionSolverTur->getVariableName();
            //创建新的数据对象
            FITKOFAlgebraicEquationsPara* solutionSolverPhy = new FITKOFAlgebraicEquationsPara;
            solutionSolverPhy->setVariableName(vname);
            solutionSolverPhy->setSolutionSolver(solutionSolver);
            solutionSolverPhy->setSolverAdditionalPara(additionPPhy);
            physicsSol->appendSolutionSolver(solutionSolverPhy);
        }
        //residuals
        count = turbulenceSlo->getResidualsCount();
        for (int i = 0; i < count; ++i)
        {
            QString vName = turbulenceSlo->getResidualVariableName(i);
            physicsSol->initAppendResidual(vName, physicsSol->getSolverSpeciallyDataName());
        }
        //relaxation
        relaxationPhy->appendPara(turbulenceSlo->getRelaxation());
    }

    void FITKFlowPhysicsHandlerFactory::updatePhysicsInitialConditions()
    {
        //获取物理数据
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        if (!physicsData)return;
        //获取求解器和物理数据Initial数据
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        FITKOFInitialConditions* physicsInitial = physicsData->getInitialConditions();
        if (!solver || !physicsInitial)return;
        //清理patch
        int count = physicsInitial->getPatchCount();
        for (int i = count - 1; i >= 0; ++i)
        {
            physicsInitial->removePatch(i);
        }
        //获取求解器的Initial数据
        FITKOFInitialConditions* solverInitial = solver->getInitialConditions();
        if (!solverInitial)return;
        //获取Basic参数
        Core::FITKParameter* basicPhy = physicsInitial->getBasicData();
        if (!basicPhy)return;
        //设置需要保留物理数据离散数据
        basicPhy->onlyKeepPara(solverInitial->getBasicData());
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        if (!turbulence)return;
        //获取湍流下的离散数据变化量
        FITKOFInitialConditions* turbulenceInitial = turbulence->getInitialConditions();
        if (!turbulenceInitial)return;
        //追加Basic参数
        basicPhy->appendPara(turbulenceInitial->getBasicData());
    }

    void FITKFlowPhysicsHandlerFactory::updatePhysicsBoundaryConditions()
    {
        //获取物理数据与物理场管理器
        FITKOFPhysicsData* physicsData = FITKAPP->getGlobalData()->getPhysicsData<FITKOFPhysicsData>();
        FITKOFPhysicsManager* physicsManager = FITKOFPhysicsManager::getInstance();
        if (!physicsManager || !physicsData)return;
        //获取求解器
        FITKAbstractOFSolver* solver = physicsData->getSolver();
        if (!solver)return;
        //获取物理场边界管理器
        FITKOFBoundaryManager* boundaryManagerPhy = physicsData->getBoundaryManager();
        if (!boundaryManagerPhy)return;
        //获取边界类型管理器
        FITKOFBoundaryTypeManager* boundaryTypeManager = physicsManager->getBoundaryTypeManager();
        if (!boundaryTypeManager)return;
        //获取湍流数据
        FITKAbstractOFTurbulence* turbulence = physicsData->getTurbulence();
        //获取物理场边界
        int boundCount = boundaryManagerPhy->getDataCount();
        for (int index = 0; index < boundCount; ++index)
        {
            FITKOFBoundary* boundaryPhy = boundaryManagerPhy->getDataByIndex(index);
            if (!boundaryPhy)continue;
            boundaryPhy->clearTurbulenceBoundary();
            if (!turbulence)continue;
            //获取边界类型
            FITKOFSolverTypeEnum::FITKOFBoundaryType bType = boundaryPhy->getBoundaryType();
            //获取湍流里的边界信息
            FITKOFBoundary* boundaryTur = turbulence->getBoundary(bType);
            if (!boundaryTur)return;
            //将湍流边界添加到物理场Turbulence
            int countSolTurbulence = boundaryTur->getTurbulenceCount();
            for (int i = 0; i < countSolTurbulence; ++i)
            {
                //获取求解器的变量名和边界
                QString variableName = boundaryTur->getTurbulenceVariableName(i);
                FITKOFAbsBoundaryType* boundaryType = boundaryTur->getTurbulenceVBType(i);
                if (!boundaryType)continue;
                //获取边界类型信息
                FITKOFBoundaryTypeInfo info = boundaryTypeManager->getBoundaryTypeInfo(boundaryType->getDataObjectName(), solver->getSolverType(), variableName, boundaryTur->getBoundaryType());
                if (info._boundaryTypeName.isEmpty())continue;
                //创建新的边界类型对象
                FITKOFAbsBoundaryType* boundaryTypeNew = info._createFuns();
                Core::FITKParameter* para = boundaryTypeNew->getBoundaryTypePara();
                //拷贝数据对象
                para->copyPara(boundaryType->getBoundaryTypePara());
                //设置边界数据对象
                boundaryPhy->setTurbulenceBoundary(variableName, boundaryTypeNew);
            }
        }
    }
}