nmWTAI-Platform/Src/nmNum/nmSubWnd/nmPebiExampleCalculator.cpp

#include "nmPebiExampleCalculator.h"

#include "pch.h"
#include "nmDataAnalyzeManager.h"
#include "nmDataPvtParaForPebi.h"

#include <QApplication>
#include <QCoreApplication>
#include <QDateTime>
#include <QDesktopServices>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QInputDialog>
#include <QMessageBox>
#include <QStringList>
#include <QTextStream>

#include <exception>

namespace
{
typedef void (*HX_NWTM_GRID_Func)(HX_NWTM_GRID_OUTPUT1&,
                                  HX_NWTM_GRID_OUTPUT2&,
                                  const HX_NWTM_GRID_INPUT&,
                                  std::string);
typedef void (*HX_NWTM_MODEL_Func)(HX_NWTM_MODEL_OUTPUT&,
                                   const HX_NWTM_MODEL_INPUT&,
                                   std::string);

QStringList exampleNames()
{
    QStringList names;
    names << QString::fromLocal8Bit("1. 油单相常数PVT（一口多段压裂水平井）")
          << QString::fromLocal8Bit("2. 油单相常数PVT（五口混合井）")
          << QString::fromLocal8Bit("3. 油单相常数PVT（五十口直井）")
          << QString::fromLocal8Bit("4. 油单相变化PVT（一口多段压裂水平井）")
          << QString::fromLocal8Bit("5. 水单相常数PVT（一口多段压裂水平井）")
          << QString::fromLocal8Bit("6. 水单相变化PVT（一口多段压裂水平井）")
          << QString::fromLocal8Bit("7. 气单相变化PVT（一口多段压裂水平井）")
          << QString::fromLocal8Bit("8. 气单相拟压力（一口多段压裂水平井）")
          << QString::fromLocal8Bit("9. 油水两相（一口多段压裂水平井）");
    return names;
}

dVec1 makePoint(double x, double y, double value)
{
    dVec1 point(3);
    point[0] = x;
    point[1] = y;
    point[2] = value;
    return point;
}

dVec1 makeLine(double x0, double y0, double x1, double y1)
{
    dVec1 line(4);
    line[0] = x0;
    line[1] = y0;
    line[2] = x1;
    line[3] = y1;
    return line;
}

dVec1 makeFracture(double x0, double y0, double x1, double y1,
                   double halfWidth, double conductivity)
{
    dVec1 fracture(6);
    fracture[0] = x0;
    fracture[1] = y0;
    fracture[2] = x1;
    fracture[3] = y1;
    fracture[4] = halfWidth;
    fracture[5] = conductivity;
    return fracture;
}

void initializeGridInput(HX_NWTM_GRID_INPUT& input, double halfSize)
{
    // 构造函数带有默认井数据，算例计算前必须全部清空后重新组装。
    input.Boundary.clear();
    input.VerticalWell.clear();
    input.HorizontalWell.clear();
    input.FractureVerticalWell.clear();
    input.MultistageFracturedHorizontalWell.clear();
    input.InclinedWell.clear();
    input.Fault.clear();

    input.Boundary.push_back(makeLine(-halfSize, -halfSize, -halfSize, halfSize));
    input.Boundary.push_back(makeLine(-halfSize, halfSize, halfSize, halfSize));
    input.Boundary.push_back(makeLine(halfSize, halfSize, halfSize, -halfSize));
    input.Boundary.push_back(makeLine(halfSize, -halfSize, -halfSize, -halfSize));
    input.GridControl = 150.0;
    input.D = 2;
}

void setupSingleWellGrid(HX_NWTM_GRID_INPUT& input)
{
    initializeGridInput(input, 1500.0);
    // 使用main.cpp中单口多段压裂水平井的五条裂缝参数。
    dVec2 fractures;
    fractures.push_back(makeFracture(-400.0, -200.0, -400.0, 200.0, 0.05, 100.0));
    fractures.push_back(makeFracture(-200.0, -200.0, -200.0, 200.0, 0.05, 100.0));
    fractures.push_back(makeFracture(0.0, -200.0, 0.0, 200.0, 0.05, 100.0));
    fractures.push_back(makeFracture(200.0, -200.0, 200.0, 200.0, 0.05, 100.0));
    fractures.push_back(makeFracture(400.0, -200.0, 400.0, 200.0, 0.05, 100.0));
    input.MultistageFracturedHorizontalWell.push_back(fractures);
}

void setupFiveWellGrid(HX_NWTM_GRID_INPUT& input)
{
    initializeGridInput(input, 1500.0);
    input.VerticalWell.push_back(makePoint(0.0, 0.0, 0.1));
    input.VerticalWell.push_back(makePoint(1000.0, 1000.0, 0.1));
    input.VerticalWell.push_back(makePoint(-1000.0, -1000.0, 0.1));
    input.FractureVerticalWell.push_back(
        makeFracture(-200.0, -200.0, 200.0, -200.0, 0.05, 0.0));

    dVec2 fractures;
    fractures.push_back(makeFracture(-600.0, 600.0, -400.0, 600.0, 0.1, 0.0));
    fractures.push_back(makeFracture(-600.0, 400.0, -400.0, 400.0, 0.1, 0.0));
    fractures.push_back(makeFracture(-600.0, 200.0, -400.0, 200.0, 0.1, 0.0));
    input.MultistageFracturedHorizontalWell.push_back(fractures);
    input.Fault.push_back(makeLine(-500.0, 1000.0, 500.0, 500.0));
}

void setupFiftyWellGrid(HX_NWTM_GRID_INPUT& input)
{
    initializeGridInput(input, 1000.0);

    static const double wells[50][2] = {
        {766.32207856101854, -408.4253100821785},
        {-359.11086885711029, -242.17185988435722},
        {-396.28113134064483, 618.18974488936828},
        {-844.38929572547772, 859.25724767620932},
        {-631.69279373636357, 620.26791301684102},
        {-858.84439780240791, 333.48071142559911},
        {-844.38929572547772, 609.87707237947734},
        {-639.95285206603785, 867.56992018610026},
        {764.25706397860017, -190.2176566975379},
        {-410.73623341757479, 867.56992018610026},
        {-121.63419187897284, 98.647713021176514},
        {-152.6094106152517, 364.65323333769061},
        {-152.6094106152517, 620.26791301684102},
        {-361.17588343952877, 102.80404927612199},
        {-844.38929572547772, -231.78101924699342},
        {-156.73943978008879, 875.88259269599121},
        {138.55764550576896, 890.42976958830059},
        {446.24481828613784, -439.59783199426988},
        {-846.45431030789632, 61.240686726666581},
        {-142.28433770315883, -223.46834673710214},
        {-375.63098551645885, -472.84852203383423},
        {-602.78258958250342, 354.2623927003267},
        {431.78971620920788, 624.42424927178672},
        {-834.06422281338484, -474.92669016130685},
        {-836.12923739580344, -747.16671486023938},
        {813.81741395664631, -693.13434354594744},
        {458.63490578064966, -718.07236107562062},
        {409.07455580260353, 873.80442456851847},
        {124.10254342883854, -454.14500888657915},
        {138.55764550576896, 96.569544893703778},
        {101.38738302223419, 611.95524050694985},
        {-373.56597093404037, 360.49689708274514},
        {-604.8476041649219, 79.944199873921661},
        {-611.0426479121777, -219.31201048215667},
        {448.30983286855667, -202.68666546237455},
        {735.34685982474002, 880.03892895093713},
        {107.58242676948976, -724.30686545803894},
        {150.94773300028032, -196.45216107995623},
        {762.19204939618135, 113.19488991348589},
        {-125.76422104381015, -470.77035390636138},
        {452.43986203339387, 366.73140146516357},
        {-350.85081052743578, -751.32305111518485},
        {122.03752884641995, 354.2623927003267},
        {-608.9776333297591, -447.91050450416094},
        {407.0095412201847, 113.19488991348589},
        {731.21683065990283, 636.89325803662314},
        {-121.63419187897284, -724.30686545803894},
        {289.3037100223255, -925.88917382289742},
        {737.41187440715862, 366.73140146516357},
        {-611.0426479121777, -730.54136984045726}
    };

    for(int i = 0; i < 50; ++i) {
        input.VerticalWell.push_back(makePoint(wells[i][0], wells[i][1], 0.108));
    }
}

void setupGridForExample(int exampleIndex, HX_NWTM_GRID_INPUT& input)
{
    if(exampleIndex == 2) {
        setupFiveWellGrid(input);
    } else if(exampleIndex == 3) {
        setupFiftyWellGrid(input);
    } else {
        setupSingleWellGrid(input);
    }
}

void resetWellData(HX_NWTM_MODEL_INPUT& input, int wellCount)
{
    // 所有相态统一按实际井数重建外层数组，避免沿用接口构造函数中的五井默认值。
    input.Rate.t.assign(wellCount, dVec1());
    input.Rate.qo.assign(wellCount, dVec1());
    input.Rate.qg.assign(wellCount, dVec1());
    input.Rate.qw.assign(wellCount, dVec1());
    input.Pressure.t.clear();
    input.Pressure.p.clear();
    input.CS.C.assign(wellCount, 0.0);
    input.CS.S.assign(wellCount, 0.0);
}

void resizeRateStep(HX_NWTM_MODEL_INPUT& input, int wellIndex, int stepCount)
{
    input.Rate.t[wellIndex].assign(stepCount, 0.0);
    input.Rate.qo[wellIndex].assign(stepCount, 0.0);
    input.Rate.qg[wellIndex].assign(stepCount, 0.0);
    input.Rate.qw[wellIndex].assign(stepCount, 0.0);
}

void setPressureAxis(HX_NWTM_MODEL_INPUT& input)
{
    input.PVT.p.assign(200, 0.0);
    for(int i = 0; i < 200; ++i) {
        input.PVT.p[i] = i + 1.0;
    }
}

void setBase(HX_NWTM_MODEL_INPUT& input, int cellCount,
             double permeability, double porosity, double thickness)
{
    input.Base.k.assign(cellCount, permeability);
    input.Base.phi.assign(cellCount, porosity);
    input.Base.h.assign(cellCount, thickness);
    input.Base.d = 1.05;
    input.Base.dt_Min = 0.0025;
    input.Base.dt_Max = 12.5;
}

void setupExample1(HX_NWTM_MODEL_INPUT& input, int cellCount)
{
    input.T = 1;
    resetWellData(input, 1);
    resizeRateStep(input, 0, 2);
    input.Rate.t[0][0] = 2000.0;
    input.Rate.t[0][1] = 500.0;
    input.Rate.qo[0][0] = 20.0;
    input.PVT.Bo.assign(200, 1.2);
    input.PVT.miuo.assign(200, 0.5);
    setPressureAxis(input);
    input.Base.Pi = 40.0;
    input.Base.Cti = 1e-3;
    setBase(input, cellCount, 0.001, 0.1, 10.0);
}

void setupExample2(HX_NWTM_MODEL_INPUT& input, int cellCount)
{
    input.T = 1;
    resetWellData(input, 5);

    resizeRateStep(input, 0, 2);
    input.Rate.t[0][0] = 2000.0;
    input.Rate.t[0][1] = 500.0;
    input.Rate.qo[0][0] = 10.0;

    resizeRateStep(input, 1, 0);

    resizeRateStep(input, 2, 3);
    input.Rate.t[2][0] = 1000.0;
    input.Rate.t[2][1] = 1000.0;
    input.Rate.t[2][2] = 500.0;
    input.Rate.qo[2][0] = 30.0;
    input.Rate.qo[2][1] = 40.0;
    input.Rate.qo[2][2] = 20.0;

    resizeRateStep(input, 3, 2);
    input.Rate.t[3][0] = 1500.0;
    input.Rate.t[3][1] = 1000.0;
    input.Rate.qo[3][0] = 30.0;
    input.Rate.qo[3][1] = 20.0;

    resizeRateStep(input, 4, 2);
    input.Rate.t[4][0] = 1000.0;
    input.Rate.t[4][1] = 1500.0;
    input.Rate.qo[4][0] = -50.0;
    input.Rate.qo[4][1] = -60.0;

    input.CS.C.assign(5, 0.1);
    input.CS.S.assign(5, 0.1);
    setPressureAxis(input);
    input.PVT.Bo.assign(200, 1.2);
    input.PVT.miuo.assign(200, 0.5);
    input.Base.Pi = 40.0;
    input.Base.Cti = 1e-3;
    setBase(input, cellCount, 0.001, 0.1, 10.0);
}

void setupExample3(HX_NWTM_MODEL_INPUT& input, int cellCount)
{
    input.T = 1;
    resetWellData(input, 50);
    for(int wellIndex = 0; wellIndex < 50; ++wellIndex) {
        resizeRateStep(input, wellIndex, 5);
        input.Rate.t[wellIndex][0] = 12.0;
        input.Rate.t[wellIndex][1] = 12.0;
        input.Rate.t[wellIndex][2] = 12.0;
        input.Rate.t[wellIndex][3] = 48.0;
        input.Rate.t[wellIndex][4] = 72.0;
        input.Rate.qo[wellIndex][0] = 158.98699999999999;
        input.Rate.qo[wellIndex][1] = 190.785;
        input.Rate.qo[wellIndex][2] = 222.58199999999999;
        input.Rate.qo[wellIndex][3] = 238.48099999999999;
    }
    input.CS.C.assign(50, 0.01);
    input.CS.S.assign(50, 0.0);
    setPressureAxis(input);
    input.PVT.Bo.assign(200, 1.07);
    input.PVT.miuo.assign(200, 0.79);
    input.Base.Pi = 40.0;
    input.Base.Cti = 0.43e-3;
    setBase(input, cellCount, 0.025, 0.1, 10.0);
}

void setupSinglePhaseExample(HX_NWTM_MODEL_INPUT& input, int exampleIndex,
                             int cellCount)
{
    resetWellData(input, 1);
    resizeRateStep(input, 0, 2);
    input.Rate.t[0][0] = 2000.0;
    input.Rate.t[0][1] = 500.0;
    input.CS.C[0] = 0.1;
    input.CS.S[0] = 0.1;

    if(exampleIndex == 4) {
        input.T = 2;
        input.Rate.qo[0][0] = 10.0;
    } else if(exampleIndex == 5 || exampleIndex == 6) {
        input.T = exampleIndex == 5 ? 3 : 4;
        input.Rate.qw[0][0] = -10.0;
        if(exampleIndex == 5) {
            setPressureAxis(input);
            input.PVT.Bw.assign(200, 1.05);
            input.PVT.miuw.assign(200, 0.8);
        }
    } else {
        input.T = exampleIndex == 7 ? 5 : 6;
        input.Rate.qg[0][0] = 50000.0;
    }

    input.Base.Pi = 40.0;
    input.Base.Cf = 1e-3;
    if(exampleIndex == 5) {
        input.Base.Cti = 1e-3;
    }
    setBase(input, cellCount, 0.001, 0.1, 10.0);
}

void setupExample9(HX_NWTM_MODEL_INPUT& input, int cellCount)
{
    input.T = 8;
    resetWellData(input, 1);
    resizeRateStep(input, 0, 2);
    input.Rate.t[0][0] = 2000.0;
    input.Rate.t[0][1] = 500.0;
    input.Rate.qo[0][0] = 20.0;
    input.CS.C[0] = 0.1;
    input.CS.S[0] = 0.1;

    input.Base.Pi = 40.0;
    input.Base.Cf = 1e-4;
    input.Base.Swi = 0.2;
    setBase(input, cellCount, 0.001, 0.1, 10.0);
}

void setupModelForExample(int exampleIndex, const HX_NWTM_GRID_OUTPUT2& grid,
                          HX_NWTM_MODEL_INPUT& input)
{
    const int cellCount = static_cast<int>(grid.Trinodexy.size());
    if(exampleIndex == 1) {
        setupExample1(input, cellCount);
    } else if(exampleIndex == 2) {
        setupExample2(input, cellCount);
    } else if(exampleIndex == 3) {
        setupExample3(input, cellCount);
    } else if(exampleIndex >= 4 && exampleIndex <= 8) {
        setupSinglePhaseExample(input, exampleIndex, cellCount);
    } else {
        setupExample9(input, cellCount);
    }
}

bool hasPhasePvt(const QVector<double>& pressure,
                 const QVector<double>& volumeFactor,
                 const QVector<double>& compressibility,
                 const QVector<double>& viscosity)
{
    return !pressure.isEmpty()
            && pressure.size() == volumeFactor.size()
            && pressure.size() == compressibility.size()
            && pressure.size() == viscosity.size();
}

bool loadFrameworkPvt(int exampleIndex,
                      HX_NWTM_MODEL_INPUT& input,
                      QString& error)
{
    // 常数PVT算例继续使用main.cpp中的固定数据。
    if(exampleIndex == 1 || exampleIndex == 2
            || exampleIndex == 3 || exampleIndex == 5) {
        return true;
    }

    nmDataAnalyzeManager* dataManager = nmDataAnalyzeManager::getCurrentInstance();
    nmDataPvtParaForPebi* pvt = dataManager == NULL
            ? NULL : dataManager->getPebiPvtPara();
    if(pvt == NULL) {
        error = QString::fromLocal8Bit("当前分析中没有可用的PVT数据。");
        return false;
    }

    const QVector<double>& pressure = pvt->getPressure();
    if(exampleIndex == 4) {
        if(!hasPhasePvt(pressure, pvt->getBo(), pvt->getCo(), pvt->getMiuo())) {
            error = QString::fromLocal8Bit("当前分析中的油相变化PVT数据不完整。");
            return false;
        }
        input.PVT.p = pressure.toStdVector();
        input.PVT.Bo = pvt->getBo().toStdVector();
        input.PVT.Co = pvt->getCo().toStdVector();
        input.PVT.miuo = pvt->getMiuo().toStdVector();
    } else if(exampleIndex == 6) {
        if(!hasPhasePvt(pressure, pvt->getBw(), pvt->getCw(), pvt->getMiuw())) {
            error = QString::fromLocal8Bit("当前分析中的水相变化PVT数据不完整。");
            return false;
        }
        input.PVT.p = pressure.toStdVector();
        input.PVT.Bw = pvt->getBw().toStdVector();
        input.PVT.Cw = pvt->getCw().toStdVector();
        input.PVT.miuw = pvt->getMiuw().toStdVector();
    } else if(exampleIndex == 7 || exampleIndex == 8) {
        if(!hasPhasePvt(pressure, pvt->getBg(), pvt->getCg(), pvt->getMiug())) {
            error = QString::fromLocal8Bit("当前分析中的气相变化PVT数据不完整。");
            return false;
        }
        input.PVT.p = pressure.toStdVector();
        input.PVT.Bg = pvt->getBg().toStdVector();
        input.PVT.Cg = pvt->getCg().toStdVector();
        input.PVT.miug = pvt->getMiug().toStdVector();
    } else if(exampleIndex == 9) {
        const bool oilWaterPvtValid = !pressure.isEmpty()
                && pressure.size() == pvt->getBo().size()
                && pressure.size() == pvt->getMiuo().size()
                && pressure.size() == pvt->getBw().size()
                && pressure.size() == pvt->getMiuw().size();
        const bool relativePermeabilityValid = !pvt->getSo().isEmpty()
                && pvt->getSo().size() == pvt->getKro().size()
                && pvt->getSo().size() == pvt->getKrw().size();
        if(!oilWaterPvtValid || !relativePermeabilityValid) {
            error = QString::fromLocal8Bit("当前分析中的油水两相PVT或相渗数据不完整。");
            return false;
        }
        input.PVT.p = pressure.toStdVector();
        input.PVT.Bo = pvt->getBo().toStdVector();
        input.PVT.miuo = pvt->getMiuo().toStdVector();
        input.PVT.Bw = pvt->getBw().toStdVector();
        input.PVT.miuw = pvt->getMiuw().toStdVector();
        input.PVT.So = pvt->getSo().toStdVector();
        input.PVT.Kro = pvt->getKro().toStdVector();
        input.PVT.Krw = pvt->getKrw().toStdVector();
    }
    return true;
}

QString numberText(double value)
{
    return QString::number(value, 'g', 16);
}

bool writePressureFile(const QString& filePath,
                       const HX_NWTM_MODEL_OUTPUT& output,
                       size_t wellIndex,
                       QString& error)
{
    QFile file(filePath);
    if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        error = QString::fromLocal8Bit("无法创建压力文件：%1").arg(filePath);
        return false;
    }

    QTextStream stream(&file);
    stream.setCodec("UTF-8");

    for(size_t timeIndex = 0; timeIndex < output.t.size(); ++timeIndex) {
        stream << numberText(output.t[timeIndex]) << " ";
        if(timeIndex < output.pw[wellIndex].size()) {
            stream << numberText(output.pw[wellIndex][timeIndex]);
        }
        stream << "\n";
    }
    return true;
}

bool writeFlowFile(const QString& filePath,
                   const HX_NWTM_MODEL_INPUT& input,
                   int exampleIndex,
                   size_t wellIndex,
                   QString& error)
{
    QFile file(filePath);
    if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        error = QString::fromLocal8Bit("无法创建流量文件：%1").arg(filePath);
        return false;
    }

    QTextStream stream(&file);
    stream.setCodec("UTF-8");
    stream << "0 0\n";

    // 按算例相态选择实际使用的油、气或水流量数组。
    const dVec1* rates = &input.Rate.qo[wellIndex];
    if(exampleIndex == 5 || exampleIndex == 6) {
        rates = &input.Rate.qw[wellIndex];
    } else if(exampleIndex == 7 || exampleIndex == 8) {
        rates = &input.Rate.qg[wellIndex];
    }
    for(size_t stepIndex = 0; stepIndex < input.Rate.t[wellIndex].size(); ++stepIndex) {
        stream << numberText(input.Rate.t[wellIndex][stepIndex]) << " ";
        if(stepIndex < rates->size()) {
            stream << numberText((*rates)[stepIndex]);
        }
        stream << "\n";
    }
    return true;
}

bool saveResults(int exampleIndex,
                 const HX_NWTM_MODEL_INPUT& input,
                 const HX_NWTM_MODEL_OUTPUT& output,
                 int& savedWellCount,
                 QString& error)
{
    QString desktopPath = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
    if(desktopPath.isEmpty()) {
        desktopPath = QDir::home().filePath("Desktop");
    }
    if(!QDir(desktopPath).exists()) {
        error = QString::fromLocal8Bit("桌面目录不存在：%1").arg(desktopPath);
        return false;
    }
    if(output.pw.size() != input.Rate.t.size()) {
        error = QString::fromLocal8Bit("求解器返回的压力井数与输入井数不一致。");
        return false;
    }

    const QString timestamp = QDateTime::currentDateTime().toString("yyyyMMdd_hhmmss");
    QStringList createdFiles;
    savedWellCount = static_cast<int>(input.Rate.t.size());
    for(int wellIndex = 0; wellIndex < savedWellCount; ++wellIndex) {
        const QString pressurePath = QDir(desktopPath).filePath(
            QString("PEBI_Model_%1_Well_%2_Pressure_%3.txt")
                .arg(exampleIndex).arg(wellIndex + 1).arg(timestamp));
        const QString flowPath = QDir(desktopPath).filePath(
            QString("PEBI_Model_%1_Well_%2_Flow_%3.txt")
                .arg(exampleIndex).arg(wellIndex + 1).arg(timestamp));

        if(!writePressureFile(pressurePath, output, wellIndex, error)) {
            break;
        }
        createdFiles.append(pressurePath);
        if(!writeFlowFile(flowPath, input, exampleIndex, wellIndex, error)) {
            break;
        }
        createdFiles.append(flowPath);
    }
    if(!error.isEmpty()) {
        for(int fileIndex = 0; fileIndex < createdFiles.size(); ++fileIndex) {
            QFile::remove(createdFiles[fileIndex]);
        }
        savedWellCount = 0;
        return false;
    }
    return true;
}

bool calculateExample(int exampleIndex,
                      int& savedWellCount,
                      QString& error)
{
    const QString dllPath = QDir(QCoreApplication::applicationDirPath()).filePath("HX_NWTM.dll");
    if(!QFileInfo(dllPath).exists()) {
        error = QString::fromLocal8Bit("未找到PEBI求解器：%1").arg(dllPath);
        return false;
    }

    HMODULE dll = LoadLibraryW(reinterpret_cast<const wchar_t*>(dllPath.utf16()));
    if(dll == NULL) {
        error = QString::fromLocal8Bit("加载PEBI求解器失败，错误码：%1").arg(GetLastError());
        return false;
    }

    HX_NWTM_GRID_Func gridFunction = reinterpret_cast<HX_NWTM_GRID_Func>(
        GetProcAddress(dll, "HX_NWTM_GRID"));
    HX_NWTM_MODEL_Func modelFunction = reinterpret_cast<HX_NWTM_MODEL_Func>(
        GetProcAddress(dll, "HX_NWTM_MODEL"));
    if(gridFunction == NULL || modelFunction == NULL) {
        error = QString::fromLocal8Bit("PEBI求解器缺少网格或模型计算接口。");
        FreeLibrary(dll);
        return false;
    }

    const QString licensePath = QDir::cleanPath(
        QDir(QCoreApplication::applicationDirPath()).filePath("../Res/license/HXNWTM_license.dat"));
    if(!QFileInfo(licensePath).exists()) {
        error = QString::fromLocal8Bit("未找到PEBI许可证：%1").arg(licensePath);
        FreeLibrary(dll);
        return false;
    }

    try {
        // 必须先由所选算例的井和边界生成网格，再用网格输出构造模型输入。
        HX_NWTM_GRID_INPUT gridInput;
        HX_NWTM_GRID_OUTPUT1 gridOutput1;
        HX_NWTM_GRID_OUTPUT2 gridOutput2;
        setupGridForExample(exampleIndex, gridInput);
        gridFunction(gridOutput1, gridOutput2, gridInput, licensePath.toStdString());
        if(gridOutput2.Trinodexy.empty()) {
            error = QString::fromLocal8Bit("PEBI网格生成失败，未返回有效网格单元。");
            FreeLibrary(dll);
            return false;
        }

        HX_NWTM_MODEL_INPUT modelInput(gridOutput2);
        HX_NWTM_MODEL_OUTPUT modelOutput;
        setupModelForExample(exampleIndex, gridOutput2, modelInput);
        if(!loadFrameworkPvt(exampleIndex, modelInput, error)) {
            FreeLibrary(dll);
            return false;
        }
        modelFunction(modelOutput, modelInput, licensePath.toStdString());
        if(modelOutput.t.empty() || modelOutput.pw.empty()) {
            error = QString::fromLocal8Bit("PEBI模型计算失败，未返回压力数据。");
            FreeLibrary(dll);
            return false;
        }

        const bool saved = saveResults(exampleIndex, modelInput, modelOutput,
                                       savedWellCount, error);
        FreeLibrary(dll);
        return saved;
    } catch(const std::exception& exception) {
        error = QString::fromLocal8Bit("PEBI算例计算异常：%1")
                .arg(QString::fromLocal8Bit(exception.what()));
    } catch(...) {
        error = QString::fromLocal8Bit("PEBI算例计算发生未知异常。");
    }

    FreeLibrary(dll);
    return false;
}
}

nmPebiExampleCalculator::nmPebiExampleCalculator(QWidget* pParent)
    : m_pParent(pParent)
{
}

void nmPebiExampleCalculator::run()
{
    bool accepted = false;
    const QString selected = QInputDialog::getItem(
        m_pParent,
        QString::fromLocal8Bit("PEBI算例计算"),
        QString::fromLocal8Bit("请选择计算模型："),
        exampleNames(), 0, false, &accepted);
    if(!accepted || selected.isEmpty()) {
        return;
    }

    const int exampleIndex = exampleNames().indexOf(selected) + 1;
    if(exampleIndex < 1 || exampleIndex > 9) {
        return;
    }

    QApplication::setOverrideCursor(Qt::WaitCursor);
    int savedWellCount = 0;
    QString error;
    const bool success = calculateExample(exampleIndex, savedWellCount, error);
    QApplication::restoreOverrideCursor();

    if(!success) {
        QMessageBox::warning(m_pParent, QString::fromLocal8Bit("PEBI算例计算"), error);
        return;
    }

    QMessageBox::information(
        m_pParent,
        QString::fromLocal8Bit("PEBI算例计算"),
        QString::fromLocal8Bit("计算完成，已按井保存到桌面，共%1口井、%2个文件。")
            .arg(savedWellCount).arg(savedWellCount * 2));
}