From 3d0f34321950e671cd5bc1ec7db5f07d9760a293 Mon Sep 17 00:00:00 2001 From: lvjunjie Date: Mon, 19 Oct 2026 11:38:40 +0800 Subject: [PATCH] =?UTF-8?q?feat(nmNum):=20=E5=AE=8C=E5=96=84=E5=88=86?= =?UTF-8?q?=E6=9E=90=E6=88=90=E6=9E=9C=E4=BF=9D=E5=AD=98=E4=B8=8E=E5=8F=82?= =?UTF-8?q?=E6=95=B0=E6=B1=87=E6=80=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 保存恢复计算方法、采样配置、拟合设置和分析结果。 - 保留筛选阈值及直方图设置，汇总拟合参数范围。 - 修正中文参数保存的 UTF-8 编码。 --- Bin/Config/Common/ModelParaDefinesNM_cn.dat | 2 +- Bin/Config/Common/ModelParaDefinesNM_en.dat | 2 +- Bin/XmlFiles/ModelParaDefinesNM_cn.xml | 13 ++ Bin/XmlFiles/ModelParaDefinesNM_en.xml | 13 ++ Include/nmNum/nmData/nmDataSensitive.h | 22 ++- Include/nmNum/nmSubWxs/nmWxSensitive.h | 2 - .../nmCalculationDllPebiSolverTask.cpp | 2 + Src/nmNum/nmData/nmDataAttribute.cpp | 14 +- Src/nmNum/nmData/nmDataSensitive.cpp | 162 ++++++++++++++++-- Src/nmNum/nmSubWnd/nmSubWndMain.cpp | 12 +- Src/nmNum/nmSubWxs/nmWxParaPropertyPebi.cpp | 8 + Src/nmNum/nmSubWxs/nmWxSensitive.cpp | 17 +- 12 files changed, 227 insertions(+), 42 deletions(-) diff --git a/Bin/Config/Common/ModelParaDefinesNM_cn.dat b/Bin/Config/Common/ModelParaDefinesNM_cn.dat index eae4155d..bd6932b0 100644 --- a/Bin/Config/Common/ModelParaDefinesNM_cn.dat +++ b/Bin/Config/Common/ModelParaDefinesNM_cn.dat @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/Bin/Config/Common/ModelParaDefinesNM_en.dat b/Bin/Config/Common/ModelParaDefinesNM_en.dat index 6de698d0..f6be0ef6 100644 --- a/Bin/Config/Common/ModelParaDefinesNM_en.dat +++ b/Bin/Config/Common/ModelParaDefinesNM_en.dat @@ -1 +1 @@ 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 \ No newline at end of file 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 \ No newline at end of file diff --git a/Bin/XmlFiles/ModelParaDefinesNM_cn.xml b/Bin/XmlFiles/ModelParaDefinesNM_cn.xml index 2d8216d0..8eefbe6b 100644 --- a/Bin/XmlFiles/ModelParaDefinesNM_cn.xml +++ b/Bin/XmlFiles/ModelParaDefinesNM_cn.xml @@ -145,6 +145,19 @@ + + + + + + + + + + + + + diff --git a/Bin/XmlFiles/ModelParaDefinesNM_en.xml b/Bin/XmlFiles/ModelParaDefinesNM_en.xml index f329b81f..d577243a 100644 --- a/Bin/XmlFiles/ModelParaDefinesNM_en.xml +++ b/Bin/XmlFiles/ModelParaDefinesNM_en.xml @@ -146,6 +146,19 @@ + + + + + + + + + + + + + diff --git a/Include/nmNum/nmData/nmDataSensitive.h b/Include/nmNum/nmData/nmDataSensitive.h index 49e76021..e8cc11ef 100644 --- a/Include/nmNum/nmData/nmDataSensitive.h +++ b/Include/nmNum/nmData/nmDataSensitive.h @@ -11,6 +11,7 @@ #include "nmData_global.h" #include "nmDataBase.h" #include "nmDataAttribute.h" +#include "nmDataAutomaticFitting.h" #include class NM_DATA_EXPORT nmDataSensitive : public nmDataBase @@ -51,7 +52,7 @@ public: nmDataAttribute m_maxValue; // Maximum // 表格中的数值列表 QVector m_values; - // Monte-Carlo 分布设置与确定性取值独立，仅保存在内存中。 + // Monte-Carlo 分布设置与确定性取值独立，随分析配置保存。 enum Distribution { NORMAL, LOGNORMAL, TRUNCATED_NORMAL, TRUNCATED_LOGNORMAL, UNIFORM, TRIANGULAR }; Distribution m_distribution; bool m_distributionInitialized; @@ -106,7 +107,7 @@ public: RunResult() : m_nRunIndex(0), m_dPressureRmse(-1.0), m_bSucceeded(false), m_bCancelled(false), m_bVisible(true) {} quint64 m_nRunIndex; QVector m_vecParameters; - QVector m_vecFittedParameters; // 本组 LM 最优值，与批次拟合参数顺序一致，仅存内存。 + QVector m_vecFittedParameters; // 本组 LM 最优值，与批次拟合参数顺序一致。 QVector > m_vecPressure; QVector > m_vecLogLog; QVector > m_vecSemiLog; @@ -119,10 +120,11 @@ public: struct NM_DATA_EXPORT BatchResult { - BatchResult() : m_calcType(CALC_DETERMINISTIC), m_dFilterThreshold(-1.0), m_nHistogramVariable(-1), m_bCompleted(false), m_bStopped(false) {} + BatchResult() : m_calcType(CALC_DETERMINISTIC), m_dFilterThreshold(-1.0), m_nHistogramVariable(-1), m_nHistogramBins(20), m_bCompleted(false), m_bStopped(false) {} CalculationType m_calcType; QList m_variables; // 求解时冻结的配置，独立于之后的参数编辑。 QList m_fitParameters; // 名称、基准单位和本批分析开始时的模型值。 + QStringList m_fitParameterCodes; // 对应 XML 的参数编码，与拟合参数同序。 QString m_sWellCode; QString m_sWellName; QString m_sAxisXName; @@ -132,11 +134,12 @@ public: QVector > m_vecHistoryLogLog; QVector > m_vecBaseLogLog; // 批次启动时原模型已有的数值解。 std::vector m_runs; - // 散点筛选阈值只随当前批次保存在内存中，负值表示尚未筛选。 + // 散点筛选阈值随当前批次保存，负值表示尚未筛选。 double m_dFilterThreshold; - int m_nHistogramVariable; // -1 为误差，其余为拟合参数下标，仅存内存。 + int m_nHistogramVariable; // -1 为误差，其余为拟合参数下标。 + int m_nHistogramBins; // 直方图分箱数，与统计变量一起恢复。 bool statisticValue(const RunResult& run, int variable, double& value) const; - bool filteredParameterBounds(int index, double& minimum, double& maximum) const; + bool filteredParameterBounds(int index, double& minimum, double& maximum, bool fitted = false) const; bool m_bCompleted; bool m_bStopped; QString m_sFailureReason; @@ -157,6 +160,11 @@ public: // === Calculation type === CalculationType getCalculationType() const; void setCalculationType(CalculationType type); + // 第四种仍复用 Monte-Carlo 采样，独立保存改善开关与确认的拟合设置。 + bool isImproveEnabled() const; + void setImproveEnabled(bool enabled); + QSharedPointer getImproveSettings() const; + void setImproveSettings(const QSharedPointer& settings); // === 总模型数 === quint64 getTotalModelCount() const; @@ -186,6 +194,8 @@ public: private: CalculationType m_calcType; + bool m_improveEnabled; + QSharedPointer m_improveSettings; quint64 m_totalModelCount; bool m_usesBaseUnits; QList m_variables; diff --git a/Include/nmNum/nmSubWxs/nmWxSensitive.h b/Include/nmNum/nmSubWxs/nmWxSensitive.h index 08deb608..e43c7831 100644 --- a/Include/nmNum/nmSubWxs/nmWxSensitive.h +++ b/Include/nmNum/nmSubWxs/nmWxSensitive.h @@ -27,7 +27,6 @@ class SensitivityResultsModel; class iGuiPlot; class QMenu; class QAction; -struct nmSensitivityFitSettings; class NM_SUB_WXS_EXPORT nmWxSensitivityHistogramOptions : public iDlgBase { @@ -153,7 +152,6 @@ private: // UI 控件 QComboBox *calculationTypeCombo; QPushButton *m_improveSettingsButton; - QSharedPointer m_improveSettings; QTreeWidget *variablesTree; QStackedWidget *detailStack; QLabel *modelCountLabel; diff --git a/Src/nmNum/nmCalculation/nmCalculationDllPebiSolverTask.cpp b/Src/nmNum/nmCalculation/nmCalculationDllPebiSolverTask.cpp index 05cb729d..e3fb4f32 100644 --- a/Src/nmNum/nmCalculation/nmCalculationDllPebiSolverTask.cpp +++ b/Src/nmNum/nmCalculation/nmCalculationDllPebiSolverTask.cpp @@ -996,6 +996,7 @@ nmCalculationDllPebiSolverTask* nmCalculationDllPebiSolverTask::createSensitivit const char* names[] = { "Permeability", "Skin", "Wellbore storage", "Porosity", "Fracture conductivity", "Fracture half length" }; const char* units[] = { "mD", "", "m^3/MPa", "", "mD.m", "m" }; + const char* codes[] = { "K", "Skin", "C", "phi", "Dfc", "FractureHalfLength" }; nmDataWellBase* well = m_pDataManager->findWellByName(improveSettings->targetWell); if(well) { // 启动前补齐拟合目标井的历史双对数，后台各组共用这份目标数据。 @@ -1021,6 +1022,7 @@ nmCalculationDllPebiSolverTask* nmCalculationDllPebiSolverTask::createSensitivit for(int j = 0; j < 6; ++j) if(selected[j]) { task->m_pSensitivityResult->m_fitParameters.append(nmDataAttribute( QCoreApplication::translate("nmWxAutomaticFitting", names[j]), values[j], units[j])); + task->m_pSensitivityResult->m_fitParameterCodes.append(codes[j]); } } } diff --git a/Src/nmNum/nmData/nmDataAttribute.cpp b/Src/nmNum/nmData/nmDataAttribute.cpp index 28dae7a4..0588216f 100644 --- a/Src/nmNum/nmData/nmDataAttribute.cpp +++ b/Src/nmNum/nmData/nmDataAttribute.cpp @@ -54,7 +54,7 @@ rapidjson::Value nmDataAttribute::ToJsonValue(rapidjson::Document::AllocatorType rapidjson::Value attributeValue(rapidjson::kObjectType); // 添加属性名称，QString转UTF8并移入JSON - attributeValue.AddMember("Name", rapidjson::Value(m_name.toStdString().c_str(), allocator).Move(), allocator); + attributeValue.AddMember("Name", rapidjson::Value(m_name.toUtf8().constData(), allocator).Move(), allocator); // 根据QVariant类型添加“值” if (m_value.type() == QVariant::Double) { @@ -62,11 +62,11 @@ rapidjson::Value nmDataAttribute::ToJsonValue(rapidjson::Document::AllocatorType } else if (m_value.type() == QVariant::Int) { attributeValue.AddMember("Value", m_value.toInt(), allocator); } else { // 字符串及其他类型转UTF8字符串 - attributeValue.AddMember("Value", rapidjson::Value(m_value.toString().toStdString().c_str(), allocator).Move(), allocator); + attributeValue.AddMember("Value", rapidjson::Value(m_value.toString().toUtf8().constData(), allocator).Move(), allocator); } // 添加单位，QString转UTF8并移入JSON - attributeValue.AddMember("Unit", rapidjson::Value(m_unit.toStdString().c_str(), allocator).Move(), allocator); + attributeValue.AddMember("Unit", rapidjson::Value(m_unit.toUtf8().constData(), allocator).Move(), allocator); // 如果最小值有效，添加“最小值” if (m_minValue.isValid()) { @@ -75,7 +75,7 @@ rapidjson::Value nmDataAttribute::ToJsonValue(rapidjson::Document::AllocatorType } else if (m_minValue.type() == QVariant::Int) { attributeValue.AddMember("MinValue", m_minValue.toInt(), allocator); } else { // 字符串及其他类型转UTF8字符串 - attributeValue.AddMember("MinValue", rapidjson::Value(m_minValue.toString().toStdString().c_str(), allocator).Move(), allocator); + attributeValue.AddMember("MinValue", rapidjson::Value(m_minValue.toString().toUtf8().constData(), allocator).Move(), allocator); } } @@ -86,7 +86,7 @@ rapidjson::Value nmDataAttribute::ToJsonValue(rapidjson::Document::AllocatorType } else if (m_maxValue.type() == QVariant::Int) { attributeValue.AddMember("MaxValue", m_maxValue.toInt(), allocator); } else { // 字符串及其他类型转UTF8字符串 - attributeValue.AddMember("MaxValue", rapidjson::Value(m_maxValue.toString().toStdString().c_str(), allocator).Move(), allocator); + attributeValue.AddMember("MaxValue", rapidjson::Value(m_maxValue.toString().toUtf8().constData(), allocator).Move(), allocator); } } @@ -94,7 +94,7 @@ rapidjson::Value nmDataAttribute::ToJsonValue(rapidjson::Document::AllocatorType if (!m_listValueSelections.isEmpty()) { rapidjson::Value selectionsArray(rapidjson::kArrayType); // 创建JSON数组 foreach (const QString& selection , m_listValueSelections) { // 遍历列表 - selectionsArray.PushBack(rapidjson::Value(selection.toStdString().c_str(), allocator).Move(), allocator); + selectionsArray.PushBack(rapidjson::Value(selection.toUtf8().constData(), allocator).Move(), allocator); } attributeValue.AddMember("ValueSelections", selectionsArray, allocator); // 将数组添加到JSON对象 } @@ -103,7 +103,7 @@ rapidjson::Value nmDataAttribute::ToJsonValue(rapidjson::Document::AllocatorType if (!m_listUnitSelections.isEmpty()) { rapidjson::Value unitSelectionsArray(rapidjson::kArrayType); // 创建JSON数组 foreach (const QString& unitSelection , m_listUnitSelections) { // 遍历列表 - unitSelectionsArray.PushBack(rapidjson::Value(unitSelection.toStdString().c_str(), allocator).Move(), allocator); + unitSelectionsArray.PushBack(rapidjson::Value(unitSelection.toUtf8().constData(), allocator).Move(), allocator); } attributeValue.AddMember("UnitSelections", unitSelectionsArray, allocator); // 将数组添加到JSON对象 } diff --git a/Src/nmNum/nmData/nmDataSensitive.cpp b/Src/nmNum/nmData/nmDataSensitive.cpp index 9775f648..dab62f08 100644 --- a/Src/nmNum/nmData/nmDataSensitive.cpp +++ b/Src/nmNum/nmData/nmDataSensitive.cpp @@ -18,16 +18,17 @@ bool nmDataSensitive::BatchResult::statisticValue(const RunResult& run, int vari return qIsFinite(value); } -bool nmDataSensitive::BatchResult::filteredParameterBounds(int index, double& minimum, double& maximum) const +bool nmDataSensitive::BatchResult::filteredParameterBounds(int index, double& minimum, double& maximum, bool fitted) const { - // 所有参数共用同一批误差严格小于阈值的样本，不受曲线可见性影响。 + // 采样和拟合参数共用误差严格小于阈值的运行，不受曲线可见性影响。 bool found = false; for(size_t i = 0; i < m_runs.size(); ++i) { const RunResult& run = m_runs[i]; + const QVector& parameters = fitted ? run.m_vecFittedParameters : run.m_vecParameters; if(!run.m_bSucceeded || run.m_bCancelled || !qIsFinite(run.m_dPressureRmse) || run.m_dPressureRmse < 0.0 || !(run.m_dPressureRmse < m_dFilterThreshold) || - index < 0 || index >= run.m_vecParameters.size()) continue; - const double value = run.m_vecParameters[index]; + index < 0 || index >= parameters.size()) continue; + const double value = parameters[index]; if(!qIsFinite(value)) continue; minimum = found ? qMin(minimum, value) : value; maximum = found ? qMax(maximum, value) : value; @@ -121,6 +122,13 @@ QString sensitiveTextFromJson(const rapidjson::Value& value, const char* key) return value.HasMember(key) && value[key].IsString() ? QString::fromUtf8(value[key].GetString()) : QString(); } + +double sensitiveNumberFromJson(const rapidjson::Value& value, const char* key, double fallback) +{ + // 新增数值字段缺失或无效时沿用默认值，兼容之前保存的成果。 + return value.HasMember(key) && value[key].IsNumber() && qIsFinite(value[key].GetDouble()) + ? value[key].GetDouble() : fallback; +} } rapidjson::Value nmDataSensitive::BatchResult::ToJsonValue( @@ -140,6 +148,18 @@ rapidjson::Value nmDataSensitive::BatchResult::ToJsonValue( value.AddMember("FailureReason", rapidjson::Value(m_sFailureReason.toUtf8().constData(), allocator).Move(), allocator); value.AddMember("HistoryLogLog", sensitiveCurvesToJson(m_vecHistoryLogLog, allocator), allocator); value.AddMember("BaseLogLog", sensitiveCurvesToJson(m_vecBaseLogLog, allocator), allocator); + // 统计图和结果参数页直接使用已保存的误差、拟合值及筛选设置。 + value.AddMember("FilterThreshold", qIsFinite(m_dFilterThreshold) ? m_dFilterThreshold : -1.0, allocator); + value.AddMember("HistogramVariable", m_nHistogramVariable, allocator); + value.AddMember("HistogramBins", m_nHistogramBins, allocator); + rapidjson::Value fitting(rapidjson::kArrayType); + for(int i = 0; i < m_fitParameters.size(); ++i) { + rapidjson::Value parameter(rapidjson::kObjectType); + parameter.AddMember("Attribute", m_fitParameters[i].ToJsonValue(allocator), allocator); + parameter.AddMember("Code", rapidjson::Value(m_fitParameterCodes.value(i).toUtf8().constData(), allocator).Move(), allocator); + fitting.PushBack(parameter, allocator); + } + value.AddMember("FitParameters", fitting, allocator); rapidjson::Value variables(rapidjson::kArrayType); for(int i = 0; i < m_variables.size(); ++i) variables.PushBack(m_variables[i].ToJsonValue(allocator), allocator); @@ -150,6 +170,8 @@ rapidjson::Value nmDataSensitive::BatchResult::ToJsonValue( rapidjson::Value item(rapidjson::kObjectType); item.AddMember("RunIndex", run.m_nRunIndex, allocator); item.AddMember("Parameters", sensitiveNumbersToJson(run.m_vecParameters, allocator), allocator); + item.AddMember("FittedParameters", sensitiveNumbersToJson(run.m_vecFittedParameters, allocator), allocator); + item.AddMember("PressureRmse", qIsFinite(run.m_dPressureRmse) ? run.m_dPressureRmse : -1.0, allocator); item.AddMember("Pressure", sensitiveCurvesToJson(run.m_vecPressure, allocator), allocator); item.AddMember("LogLog", sensitiveCurvesToJson(run.m_vecLogLog, allocator), allocator); item.AddMember("SemiLog", sensitiveCurvesToJson(run.m_vecSemiLog, allocator), allocator); @@ -169,8 +191,8 @@ void nmDataSensitive::BatchResult::FromJsonValue(const rapidjson::Value& value) *this = BatchResult(); if(!value.IsObject()) return; if(value.HasMember("CalculationType") && value["CalculationType"].IsInt() && - value["CalculationType"].GetInt() == CALC_DETERMINISTIC_MULTIVARIATE) - m_calcType = CALC_DETERMINISTIC_MULTIVARIATE; + value["CalculationType"].GetInt() >= CALC_DETERMINISTIC && value["CalculationType"].GetInt() <= CALC_MONTE_CARLO) + m_calcType = static_cast(value["CalculationType"].GetInt()); m_sWellCode = sensitiveTextFromJson(value, "WellCode"); m_sWellName = sensitiveTextFromJson(value, "WellName"); m_sAxisXName = sensitiveTextFromJson(value, "AxisXName"); @@ -182,6 +204,28 @@ void nmDataSensitive::BatchResult::FromJsonValue(const rapidjson::Value& value) m_bStopped = value.HasMember("Stopped") && value["Stopped"].IsBool() && value["Stopped"].GetBool(); m_vecHistoryLogLog = sensitiveCurvesFromJson(value, "HistoryLogLog"); m_vecBaseLogLog = sensitiveCurvesFromJson(value, "BaseLogLog"); + m_dFilterThreshold = sensitiveNumberFromJson(value, "FilterThreshold", -1.0); + if(value.HasMember("FitParameters") && value["FitParameters"].IsArray()) { + const rapidjson::Value& fitting = value["FitParameters"]; + for(rapidjson::SizeType i = 0; i < fitting.Size(); ++i) { + // 保留参数位置，确保每组拟合值与名称、单位和 XML 编码一一对应。 + nmDataAttribute parameter; + QString code; + if(fitting[i].IsObject()) { + if(fitting[i].HasMember("Attribute") && fitting[i]["Attribute"].IsObject()) + parameter.FromJsonValue(fitting[i]["Attribute"]); + code = sensitiveTextFromJson(fitting[i], "Code"); + } + m_fitParameters.append(parameter); + m_fitParameterCodes.append(code); + } + } + if(value.HasMember("HistogramVariable") && value["HistogramVariable"].IsInt()) { + const int index = value["HistogramVariable"].GetInt(); + if(index >= -1 && index < m_fitParameters.size()) m_nHistogramVariable = index; + } + if(value.HasMember("HistogramBins") && value["HistogramBins"].IsInt()) + m_nHistogramBins = qBound(1, value["HistogramBins"].GetInt(), 1000); if(value.HasMember("Variables") && value["Variables"].IsArray()) { const rapidjson::Value& variables = value["Variables"]; for(rapidjson::SizeType i = 0; i < variables.Size(); ++i) { @@ -199,6 +243,8 @@ void nmDataSensitive::BatchResult::FromJsonValue(const rapidjson::Value& value) RunResult run; run.m_nRunIndex = item["RunIndex"].GetUint64(); if(item.HasMember("Parameters")) sensitiveNumbersFromJson(item["Parameters"], run.m_vecParameters); + if(item.HasMember("FittedParameters")) sensitiveNumbersFromJson(item["FittedParameters"], run.m_vecFittedParameters); + run.m_dPressureRmse = sensitiveNumberFromJson(item, "PressureRmse", -1.0); run.m_vecPressure = sensitiveCurvesFromJson(item, "Pressure"); run.m_vecLogLog = sensitiveCurvesFromJson(item, "LogLog"); run.m_vecSemiLog = sensitiveCurvesFromJson(item, "SemiLog"); @@ -234,10 +280,10 @@ rapidjson::Value nmDataSensitive::VariableSampling::ToJsonValue( // 字符串字段 obj.AddMember("VarGroup", - rapidjson::Value(m_varGroup.toStdString().c_str(), allocator).Move(), + rapidjson::Value(m_varGroup.toUtf8().constData(), allocator).Move(), allocator); obj.AddMember("VarName", - rapidjson::Value(m_varName.toStdString().c_str(), allocator).Move(), + rapidjson::Value(m_varName.toUtf8().constData(), allocator).Move(), allocator); // 简单类型 @@ -245,6 +291,14 @@ rapidjson::Value nmDataSensitive::VariableSampling::ToJsonValue( obj.AddMember("Mode", static_cast(m_mode), allocator); obj.AddMember("Log", m_log, allocator); obj.AddMember("Number", m_number, allocator); + // 六种分布使用同一组字段，恢复时不重新生成用户设置的范围。 + obj.AddMember("Distribution", int(m_distribution), allocator); + obj.AddMember("DistributionInitialized", m_distributionInitialized, allocator); + obj.AddMember("Mean", m_mean, allocator); + obj.AddMember("StdDev", m_stdDev, allocator); + obj.AddMember("Peak", m_peak, allocator); + obj.AddMember("DistributionMinimum", m_distributionMin, allocator); + obj.AddMember("DistributionMaximum", m_distributionMax, allocator); // nmDataAttribute 成员 obj.AddMember("ModelValue", m_modelValue.ToJsonValue(allocator), allocator); @@ -264,6 +318,20 @@ rapidjson::Value nmDataSensitive::VariableSampling::ToJsonValue( // 从 RapidJSON Value 反序列化到 VariableSampling void nmDataSensitive::VariableSampling::FromJsonValue(const rapidjson::Value& jsonValue) { + // 旧文件未保存分布时保留默认状态，由分析窗口按模型值初始化。 + *this = VariableSampling(); + if(jsonValue.HasMember("Distribution") && jsonValue["Distribution"].IsInt()) { + const int distribution = jsonValue["Distribution"].GetInt(); + if(distribution >= NORMAL && distribution <= TRIANGULAR) + m_distribution = static_cast(distribution); + } + m_distributionInitialized = jsonValue.HasMember("DistributionInitialized") && + jsonValue["DistributionInitialized"].IsBool() && jsonValue["DistributionInitialized"].GetBool(); + m_mean = sensitiveNumberFromJson(jsonValue, "Mean", m_mean); + m_stdDev = sensitiveNumberFromJson(jsonValue, "StdDev", m_stdDev); + m_peak = sensitiveNumberFromJson(jsonValue, "Peak", m_peak); + m_distributionMin = sensitiveNumberFromJson(jsonValue, "DistributionMinimum", m_distributionMin); + m_distributionMax = sensitiveNumberFromJson(jsonValue, "DistributionMaximum", m_distributionMax); if (jsonValue.HasMember("VarGroup") && jsonValue["VarGroup"].IsString()) { m_varGroup = QString::fromUtf8(jsonValue["VarGroup"].GetString()); } @@ -492,6 +560,7 @@ bool nmDataSensitive::VariableSampling::distributionQuantile(double probability, nmDataSensitive::nmDataSensitive() : m_calcType(CALC_DETERMINISTIC) + , m_improveEnabled(false) , m_totalModelCount(0) , m_usesBaseUnits(false) , m_variables() @@ -510,6 +579,8 @@ nmDataSensitive& nmDataSensitive::operator=(const nmDataSensitive& other) { if (this != &other) { m_calcType = other.m_calcType; + m_improveEnabled = other.m_improveEnabled; + m_improveSettings = other.m_improveSettings; m_totalModelCount = other.m_totalModelCount; m_usesBaseUnits = other.m_usesBaseUnits; m_variables = other.m_variables; @@ -536,6 +607,19 @@ rapidjson::Value nmDataSensitive::ToJsonValue( root.AddMember("CalculationType", static_cast(m_calcType), allocator); + // 与曲线一起保存采样和拟合配置，重开项目后仍可查看同一批预览。 + root.AddMember("ImproveEnabled", m_improveEnabled, allocator); + root.AddMember("MonteCarloCount", m_monteCarloCount, allocator); + root.AddMember("MonteCarloValues", sensitiveCurvesToJson(m_monteCarloValues, allocator), allocator); + if(!m_improveSettings.isNull()) { + const nmSensitivityFitSettings& settings = *m_improveSettings; + rapidjson::Value fitting(rapidjson::kObjectType); + fitting.AddMember("Confirmed", settings.confirmed, allocator); + fitting.AddMember("Parameters", settings.parameters.ToJsonValue(allocator), allocator); + fitting.AddMember("TargetWell", rapidjson::Value(settings.targetWell.toUtf8().constData(), allocator).Move(), allocator); + fitting.AddMember("InitialValues", sensitiveNumbersToJson(settings.initialValues, allocator), allocator); + root.AddMember("ImproveSettings", fitting, allocator); + } // 总模型数 root.AddMember("TotalModelCount", @@ -557,6 +641,14 @@ rapidjson::Value nmDataSensitive::ToJsonValue( // 从 RapidJSON Value 反序列化数据到 nmDataSensitive void nmDataSensitive::FromJsonValue(const rapidjson::Value& jsonValue) { + // 先恢复默认值，旧成果缺失新增字段时不沿用上一项目的数据。 + *this = nmDataSensitive(); + if(!jsonValue.IsObject()) return; + m_improveEnabled = jsonValue.HasMember("ImproveEnabled") && + jsonValue["ImproveEnabled"].IsBool() && jsonValue["ImproveEnabled"].GetBool(); + if(jsonValue.HasMember("MonteCarloCount") && jsonValue["MonteCarloCount"].IsInt() && + jsonValue["MonteCarloCount"].GetInt() > 0) + m_monteCarloCount = jsonValue["MonteCarloCount"].GetInt(); // 旧项目没有 Results 时保持空结果。 m_results.clear(); if(jsonValue.HasMember("Results") && jsonValue["Results"].IsObject()) { @@ -567,10 +659,8 @@ void nmDataSensitive::FromJsonValue(const rapidjson::Value& jsonValue) jsonValue["UsesBaseUnits"].IsBool() && jsonValue["UsesBaseUnits"].GetBool(); if (jsonValue.HasMember("CalculationType") && jsonValue["CalculationType"].IsInt()) { int t = jsonValue["CalculationType"].GetInt(); - if (t == CALC_DETERMINISTIC_MULTIVARIATE) - m_calcType = CALC_DETERMINISTIC_MULTIVARIATE; - else - m_calcType = CALC_DETERMINISTIC; + if (t >= CALC_DETERMINISTIC && t <= CALC_MONTE_CARLO) + m_calcType = static_cast(t); } if (jsonValue.HasMember("TotalModelCount") && jsonValue["TotalModelCount"].IsUint64()) { @@ -589,6 +679,30 @@ void nmDataSensitive::FromJsonValue(const rapidjson::Value& jsonValue) m_variables.append(vs); } } + // 恢复完整样本，列数必须与参数表对应，避免预览或生成时错用参数。 + m_monteCarloValues = sensitiveCurvesFromJson(jsonValue, "MonteCarloValues"); + bool validSamples = m_monteCarloValues.size() == m_monteCarloCount; + for(int row = 0; validSamples && row < m_monteCarloValues.size(); ++row) { + const QVector& values = m_monteCarloValues[row]; + validSamples = values.size() == m_variables.size(); + for(int column = 0; validSamples && column < values.size(); ++column) + validSamples = qIsFinite(values[column]); + } + if(!validSamples) clearMonteCarloSamples(); + if(jsonValue.HasMember("ImproveSettings") && jsonValue["ImproveSettings"].IsObject()) { + const rapidjson::Value& fitting = jsonValue["ImproveSettings"]; + QSharedPointer settings(new nmSensitivityFitSettings()); + settings->targetWell = sensitiveTextFromJson(fitting, "TargetWell"); + const bool hasParameters = fitting.HasMember("Parameters") && fitting["Parameters"].IsObject(); + if(hasParameters) settings->parameters.FromJsonValue(fitting["Parameters"]); + if(fitting.HasMember("InitialValues")) sensitiveNumbersFromJson(fitting["InitialValues"], settings->initialValues); + bool valid = hasParameters && settings->initialValues.size() == 6 && !settings->targetWell.isEmpty(); + for(int i = 0; valid && i < settings->initialValues.size(); ++i) + valid = qIsFinite(settings->initialValues[i]); + settings->confirmed = valid && fitting.HasMember("Confirmed") && + fitting["Confirmed"].IsBool() && fitting["Confirmed"].GetBool(); + if(settings->confirmed) m_improveSettings = settings; + } } // === Calculation type === @@ -604,6 +718,30 @@ void nmDataSensitive::setCalculationType(CalculationType type) m_calcType = type; } +bool nmDataSensitive::isImproveEnabled() const +{ + // 开关独立于拟合设置，切回第三种后仍可保留上次确认的设置。 + return m_improveEnabled; +} + +void nmDataSensitive::setImproveEnabled(bool enabled) +{ + // 只记录是否启用改善，不改变 Monte-Carlo 的采样方式。 + m_improveEnabled = enabled; +} + +QSharedPointer nmDataSensitive::getImproveSettings() const +{ + // 设置按只读引用共享，窗口重新打开时恢复，编辑时另建副本。 + return m_improveSettings; +} + +void nmDataSensitive::setImproveSettings(const QSharedPointer& settings) +{ + // 只接收拟合窗口确认后的完整配置。 + m_improveSettings = settings; +} + // === 总模型数 === quint64 nmDataSensitive::getTotalModelCount() const { diff --git a/Src/nmNum/nmSubWnd/nmSubWndMain.cpp b/Src/nmNum/nmSubWnd/nmSubWndMain.cpp index 6c95f67f..c7a09e7c 100644 --- a/Src/nmNum/nmSubWnd/nmSubWndMain.cpp +++ b/Src/nmNum/nmSubWnd/nmSubWndMain.cpp @@ -2201,7 +2201,6 @@ void nmSubWndMain::updateSensitiveHistogramPlot() QVBoxLayout* layout = new QVBoxLayout(page); layout->setContentsMargins(0, 0, 0, 0); QHBoxLayout* options = new QHBoxLayout; - page->setProperty("nmHistogramBins", 20); QPushButton* scatter = new QPushButton(tr("Scatter plot"), page); scatter->setObjectName("nmScatterButton"); QPushButton* settings = new QPushButton(tr("Histogram options"), page); @@ -2230,7 +2229,7 @@ void nmSubWndMain::updateSensitiveHistogramPlot() connect(settings, SIGNAL(clicked()), this, SLOT(onSensitiveHistogramOptions())); } iGuiPlot* plot = window->widget()->findChild(); - const int binCount = window->widget()->property("nmHistogramBins").toInt(); + const int binCount = batch->m_nHistogramBins; // 拟合参数与误差共用分箱绘制，轴名称和单位随本批选择同步切换。 const int variable = batch->m_nHistogramVariable; plot->setAxisX(variable < 0 ? tr("Goodness of fit") : batch->m_fitParameters[variable].getName(), @@ -2338,7 +2337,7 @@ void nmSubWndMain::onSensitiveHistogramOptions() if(!window || batch.isNull()) return; nmWxSensitivityHistogramOptions* dialog = window->findChild(); if(!dialog) { - dialog = new nmWxSensitivityHistogramOptions(batch, window->widget()->property("nmHistogramBins").toInt(), window->widget()); + dialog = new nmWxSensitivityHistogramOptions(batch, batch->m_nHistogramBins, window->widget()); connect(dialog, SIGNAL(settingsChanged(int,int)), this, SLOT(onSensitiveHistogramSettingsChanged(int,int))); connect(manager, SIGNAL(sigSensitiveResultsChanged()), dialog, SLOT(reject())); } @@ -2349,17 +2348,18 @@ void nmSubWndMain::onSensitiveHistogramOptions() void nmSubWndMain::onSensitiveHistogramSettingsChanged(int bins, int variable) { - // 直方图变量仅存于本批内存结果，散点图独立选择自己的纵轴。 + // 分箱数与统计变量随批次保存，散点图独立选择自己的纵轴。 nmDataAnalyzeManager* manager = m_pResultRefreshDataManager.data(); if(!manager || !manager->getSensitiveData()) return; const QSharedPointer batch = manager->getSensitiveData()->getResults(); if(batch.isNull()) return; batch->m_nHistogramVariable = variable; + batch->m_nHistogramBins = bins; iSubWndFitting* fitting = m_pResultRefreshFitting.data(); if(!fitting || !fitting->m_pMdiArea) return; QMdiSubWindow* window = fitting->m_pMdiArea->findChild("nmSensitivityHistogram"); if(!window) return; - window->widget()->setProperty("nmHistogramBins", bins); + fitting->setModified(true); updateSensitiveHistogramPlot(); } @@ -2371,6 +2371,8 @@ void nmSubWndMain::onSensitiveFilterChanged() QWidget* page = fitting->getFitSubRstWxOf(FSRT_NmRst, false); nmWxParaPropertyPebi* parameters = page ? page->findChild() : nullptr; if(parameters) parameters->refreshSensitivityResults(); + // 只有用户调整阈值才标记修改，加载成果时的面板刷新不触发保存提示。 + if(qobject_cast(sender())) fitting->setModified(true); } void nmSubWndMain::onSensitiveScatter() diff --git a/Src/nmNum/nmSubWxs/nmWxParaPropertyPebi.cpp b/Src/nmNum/nmSubWxs/nmWxParaPropertyPebi.cpp index 95f38faa..c1c3744e 100644 --- a/Src/nmNum/nmSubWxs/nmWxParaPropertyPebi.cpp +++ b/Src/nmNum/nmSubWxs/nmWxParaPropertyPebi.cpp @@ -154,6 +154,14 @@ void appendSensitivityParas(nmDataAnalyzeManager* manager, QStringList& paras, appendResultPara(paras, values, groupCode, lower, minimum); appendResultPara(paras, values, groupCode, higher, maximum); } + // 第四种在采样范围后追加各组拟合最优值的范围，沿用同一阈值和 XML 分组。 + for(int i = 0; i < batch->m_fitParameterCodes.size(); ++i) { + double minimum = 0.0, maximum = 0.0; + if(!batch->filteredParameterBounds(i, minimum, maximum, true)) continue; + const QString name = "Sensitivity_Fit_" + batch->m_fitParameterCodes[i]; + appendResultPara(paras, values, groupCode, name + "_Minimum", minimum); + appendResultPara(paras, values, groupCode, name + "_Maximum", maximum); + } } QString resultModelTitlePrefix() diff --git a/Src/nmNum/nmSubWxs/nmWxSensitive.cpp b/Src/nmNum/nmSubWxs/nmWxSensitive.cpp index a35565c1..f5867f04 100644 --- a/Src/nmNum/nmSubWxs/nmWxSensitive.cpp +++ b/Src/nmNum/nmSubWxs/nmWxSensitive.cpp @@ -1523,7 +1523,7 @@ void nmWxSensitive::loadDataToUI(bool refreshRangesOnly) { // 加载过程中阻止联动刷新，先恢复设置，再一次生成各参数表格。 if (!refreshRangesOnly) - calculationTypeCombo->setCurrentIndex(int(m_sensitiveData.getCalculationType())); + calculationTypeCombo->setCurrentIndex(m_sensitiveData.isImproveEnabled() ? 3 : int(m_sensitiveData.getCalculationType())); m_monteCarloCount->setValue(m_sensitiveData.getMonteCarloCount()); for (int i = 0; i < m_sensitiveData.getVariableCount(); ++i) { nmDataSensitive::VariableSampling& variable = m_sensitiveData.getVariable(i); @@ -1611,6 +1611,7 @@ void nmWxSensitive::updateModelCount() if (m_loading) return; m_sensitiveData.setCalculationType( static_cast(calculationTypeCombo->itemData(calculationTypeCombo->currentIndex()).toInt())); + m_sensitiveData.setImproveEnabled(calculationTypeCombo->currentIndex() == 3); for (int group = 0; group < variablesTree->topLevelItemCount(); ++group) { QTreeWidgetItem* parent = variablesTree->topLevelItem(group); for (int child = 0; child < parent->childCount(); ++child) { @@ -1635,8 +1636,8 @@ void nmWxSensitive::updateModelCount() m_monteCarloCount->setVisible(monteCarlo); // 第四种确认设置且至少选择一个拟合参数后才开放生成，空选择直接禁用。 bool hasFittingParameters = false; - if(!m_improveSettings.isNull()) { - const nmDataAutomaticFitting& fitting = m_improveSettings->parameters; + if(!m_sensitiveData.getImproveSettings().isNull()) { + const nmDataAutomaticFitting& fitting = m_sensitiveData.getImproveSettings()->parameters; hasFittingParameters = fitting.getPermeabilitySelected() || fitting.getSkinSelected() || fitting.getWellboreStorageSelected() || fitting.getPorositySelected() || fitting.getFractureConductivitySelected() || fitting.getFractureHalfLengthSelected(); @@ -2489,8 +2490,8 @@ void nmWxSensitive::onGenerateClicked() } iAnalRun* analRun = fitting ? fitting->getAnalRun() : nullptr; // 第四种可选择其他井拟合，其历史曲线也要使用本次的拟压力配置。 - nmDataWellBase* fitWell = (calculationTypeCombo->currentIndex() == 3) && !m_improveSettings.isNull() - ? m_pDataManager->findWellByName(m_improveSettings->targetWell) : nullptr; + nmDataWellBase* fitWell = m_sensitiveData.isImproveEnabled() && !m_sensitiveData.getImproveSettings().isNull() + ? m_pDataManager->findWellByName(m_sensitiveData.getImproveSettings()->targetWell) : nullptr; if(!analRun || !analRun->configPsAbouts(true, fitting->getModelOption(), false, fitting->getAllWxPtr()) || !m_pDataManager->updateWellHistoryData(well) || @@ -2516,7 +2517,7 @@ void nmWxSensitive::onGenerateClicked() nmCalculationDllPebiSolverTask source(QString(), m_pDataManager, well->getWellName()); // 第四种直接交给后台任务逐组拟合，仍使用主窗口原有进度框。 task.reset(source.createSensitivityBatch(m_sensitiveData, &error, - (calculationTypeCombo->currentIndex() == 3) ? m_improveSettings.data() : nullptr)); + m_sensitiveData.isImproveEnabled() ? m_sensitiveData.getImproveSettings().data() : nullptr)); } catch(const std::bad_alloc&) { error = tr("Insufficient memory to prepare solver input."); } @@ -2628,7 +2629,7 @@ void nmWxSensitive::onImproveSettingsClicked() { // 在副本上编辑，只有确定才替换设置；取消保留上次确认的内容。 nmSensitivityFitSettings settings; - if(!m_improveSettings.isNull()) settings = *m_improveSettings; + if(!m_sensitiveData.getImproveSettings().isNull()) settings = *m_sensitiveData.getImproveSettings(); // 将分析窗口当前勾选的采样参数传给拟合窗口，用于禁用重叠选项。 updateModelCount(); QStringList sampledParameters; @@ -2636,7 +2637,7 @@ void nmWxSensitive::onImproveSettingsClicked() if(variable.m_enabled) sampledParameters.append(variable.m_varName); nmWxAutomaticFitting dialog(this, &settings, sampledParameters); if(dialog.exec() == QDialog::Accepted) { - m_improveSettings = QSharedPointer(new nmSensitivityFitSettings(settings)); + m_sensitiveData.setImproveSettings(QSharedPointer(new nmSensitivityFitSettings(settings))); updateModelCount(); } }