From dbe5ac328f31ff5cca654993cc19da8fcb619962 Mon Sep 17 00:00:00 2001
From: lh <2334563547@qq.com>
Date: Mon, 17 Aug 2026 11:40:13 +0800
Subject: [PATCH] =?UTF-8?q?feat(nmNum):=20=E6=8C=89=E6=B1=82=E8=A7=A3?=
 =?UTF-8?q?=E6=A8=A1=E5=9E=8B=E4=BC=98=E5=8C=96=E5=82=A8=E5=B1=82=E5=8F=82?=
 =?UTF-8?q?=E6=95=B0=E7=BC=96=E8=BE=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 根据求解器模型动态显示 PVT、压缩系数和饱和度参数
- 隐藏储层类型和 KxKy，清理无效的单值参数定义
- 补充油水饱和度之和校验及关联错误提示
- 优化对话框初始高度和参数分组名称
- 更新中英文参数 XML 及中文翻译资源
---
 Bin/Config/Common/ModelParaDefinesNM_cn.dat   |   2 +-
 Bin/Config/Common/ModelParaDefinesNM_en.dat   |   2 +-
 Bin/Config/Lang/cn/nmNum_cn.qm                | Bin 112710 -> 113137 bytes
 Bin/Config/Lang/cn/nmNum_cn.ts                |   8 +-
 Bin/XmlFiles/ModelParaDefinesNM_cn.xml        |   4 +-
 Bin/XmlFiles/ModelParaDefinesNM_en.xml        |   4 +-
 .../nmSubWxs/nmReservoirParameterField.h      |   4 +
 .../nmReservoirPropertiesDataSource.h         |   1 +
 .../nmSubWxs/nmReservoirParameterCatalog.cpp  | 194 ++++++++++++++++--
 .../nmSubWxs/nmReservoirParameterField.cpp    |  17 ++
 .../nmSubWxs/nmReservoirParameterPage.cpp     |  41 +++-
 .../nmReservoirPropertiesDataSource.cpp       |   5 +-
 .../nmWxReservoirPropertiesEditor.cpp         |   2 +-
 13 files changed, 257 insertions(+), 27 deletions(-)

diff --git a/Bin/Config/Common/ModelParaDefinesNM_cn.dat b/Bin/Config/Common/ModelParaDefinesNM_cn.dat
index f5f319c..c7e0160 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 09deb56..29f5b0a 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/Config/Lang/cn/nmNum_cn.qm b/Bin/Config/Lang/cn/nmNum_cn.qm
index 003de21ebdb765f01ee6b20642773fef7a370739..52d0c82c95643facf3bbf65aeda42be19d436d30 100644
GIT binary patch
delta 9815
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
MxpL?x_NvzZ073j>o&W#<

delta 9249
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

diff --git a/Bin/Config/Lang/cn/nmNum_cn.ts b/Bin/Config/Lang/cn/nmNum_cn.ts
index b604758..4497385 100644
--- a/Bin/Config/Lang/cn/nmNum_cn.ts
+++ b/Bin/Config/Lang/cn/nmNum_cn.ts
@@ -6793,6 +6793,7 @@ Average pressure in contour: %2 MPa</source>
     <message><source>Object display</source><translation>对象显示</translation></message>
     <message><source>Display:</source><translation>显示：</translation></message>
     <message><source>No editable objects in this category.</source><translation>此分类中没有可编辑对象。</translation></message>
+    <message><source>Initial oil and water saturations must sum to 1.</source><translation>初始含油饱和度与初始含水饱和度之和必须为 1。</translation></message>
 </context>
 <context>
     <name>nmWxReservoirPropertiesEditor</name>
@@ -6829,9 +6830,12 @@ Average pressure in contour: %2 MPa</source>
     <message><source>Position and wellbore</source><translation>位置与井筒</translation></message>
     <message><source>Wellbore storage</source><translation>井筒储集</translation></message>
     <message><source>Wellbore storage and fracture</source><translation>井筒储集与裂缝</translation></message>
-    <message><source>Basic properties</source><translation>基础特性</translation></message>
+    <message><source>Basic and medium properties</source><translation>基础与介质特性</translation></message>
     <message><source>Fluid parameters</source><translation>流体参数</translation></message>
-    <message><source>Compression and saturation</source><translation>压缩与饱和度</translation></message>
+    <message><source>Oil phase parameters</source><translation>油相参数</translation></message>
+    <message><source>Water phase parameters</source><translation>水相参数</translation></message>
+    <message><source>Compressibility</source><translation>压缩系数</translation></message>
+    <message><source>Compressibility and saturation</source><translation>压缩系数与饱和度</translation></message>
     <message><source>Reservoir medium parameters</source><translation>储层介质参数</translation></message>
     <message><source>Geometry</source><translation>几何位置</translation></message>
     <message><source>Flow properties</source><translation>流动属性</translation></message>
diff --git a/Bin/XmlFiles/ModelParaDefinesNM_cn.xml b/Bin/XmlFiles/ModelParaDefinesNM_cn.xml
index 540213f..54efcc8 100644
--- a/Bin/XmlFiles/ModelParaDefinesNM_cn.xml
+++ b/Bin/XmlFiles/ModelParaDefinesNM_cn.xml
@@ -21,10 +21,12 @@
     <ParaItem Name="phi" Alias="孔隙度"         Unit=""      Default="0.1"   Max="1"      Min="1e-05"  Digit="6"  Desc="porosity" />
     <ParaItem Name="Bo"  Alias="油体积系数"     Unit=""      Default="1.2"   Max="10"     Min="1e-06"  Digit="6"  Desc="oil formation volume factor" />
     <ParaItem Name="Miuo" Alias="油相黏度"      Unit="mPa.s" Default="0.5"   Max="10000"  Min="1e-06"  Digit="6"  Desc="oil viscosity" />
-    <ParaItem Name="KxKy" Alias="水平渗透率比"  Unit=""      Default="1"     Max="1000"   Min="1e-06"  Digit="6"  Desc="horizontal permeability ratio" />
+    <ParaItem Name="Bw"  Alias="水体积系数"     Unit=""      Default="1"     Max="10"     Min="1e-06"  Digit="6"  Desc="water formation volume factor" />
+    <ParaItem Name="Miuw" Alias="水相黏度"      Unit="mPa.s" Default="1"     Max="10000"  Min="1e-06"  Digit="6"  Desc="water viscosity" />
     <ParaItem Name="Cti" Alias="综合压缩系数"   Unit="1/MPa" Default="0.001" Max="10"     Min="1e-30"  Digit="10" Scientific="1" Desc="total compressibility" />
     <ParaItem Name="Cf"  Alias="岩石压缩系数"   Unit="1/MPa" Default="0.0001" Max="10"    Min="1e-30"  Digit="10" Scientific="1" Desc="rock compressibility" />
     <ParaItem Name="Soi" Alias="初始含油饱和度" Unit=""      Default="0.8"   Max="1"      Min="0"      Digit="6"  Desc="initial oil saturation" />
+    <ParaItem Name="Sgi" Alias="初始含气饱和度" Unit=""      Default="0"     Max="1"      Min="0"      Digit="6"  Desc="initial gas saturation" />
     <ParaItem Name="Swi" Alias="初始含水饱和度" Unit=""      Default="0.2"   Max="1"      Min="0"      Digit="6"  Desc="initial water saturation" />
   </ParaGroup>
 
diff --git a/Bin/XmlFiles/ModelParaDefinesNM_en.xml b/Bin/XmlFiles/ModelParaDefinesNM_en.xml
index 3b32735..23f0745 100644
--- a/Bin/XmlFiles/ModelParaDefinesNM_en.xml
+++ b/Bin/XmlFiles/ModelParaDefinesNM_en.xml
@@ -22,10 +22,12 @@
     <ParaItem Name="phi" Alias="Porosity"                    Unit=""      Default="0.1"   Max="1"      Min="1e-05"  Digit="4"  Desc="porosity" />
     <ParaItem Name="Bo"  Alias="Oil Formation Volume Factor" Unit=""      Default="1.2"   Max="10"     Min="1e-06"  Digit="6"  Desc="oil formation volume factor" />
     <ParaItem Name="Miuo" Alias="Oil Viscosity"              Unit="mPa.s" Default="0.5"   Max="10000"  Min="1e-06"  Digit="6"  Desc="oil viscosity" />
-    <ParaItem Name="KxKy" Alias="Horizontal Permeability Ratio" Unit=""   Default="1"     Max="1000"   Min="1e-06"  Digit="6"  Desc="horizontal permeability ratio" />
+    <ParaItem Name="Bw"  Alias="Water Formation Volume Factor" Unit=""    Default="1"     Max="10"     Min="1e-06"  Digit="6"  Desc="water formation volume factor" />
+    <ParaItem Name="Miuw" Alias="Water Viscosity"            Unit="mPa.s" Default="1"     Max="10000"  Min="1e-06"  Digit="6"  Desc="water viscosity" />
     <ParaItem Name="Cti" Alias="Total Compressibility"       Unit="1/MPa" Default="0.001" Max="10"     Min="1e-30"  Digit="10" Scientific="1" Desc="total compressibility" />
     <ParaItem Name="Cf"  Alias="Rock Compressibility"        Unit="1/MPa" Default="0.0001" Max="10"    Min="1e-30"  Digit="10" Scientific="1" Desc="rock compressibility" />
     <ParaItem Name="Soi" Alias="Initial Oil Saturation"      Unit=""      Default="0.8"   Max="1"      Min="0"      Digit="6"  Desc="initial oil saturation" />
+    <ParaItem Name="Sgi" Alias="Initial Gas Saturation"      Unit=""      Default="0"     Max="1"      Min="0"      Digit="6"  Desc="initial gas saturation" />
     <ParaItem Name="Swi" Alias="Initial Water Saturation"    Unit=""      Default="0.2"   Max="1"      Min="0"      Digit="6"  Desc="initial water saturation" />
   </ParaGroup>
 
diff --git a/Include/nmNum/nmSubWxs/nmReservoirParameterField.h b/Include/nmNum/nmSubWxs/nmReservoirParameterField.h
index 7669d9f..4409a0e 100644
--- a/Include/nmNum/nmSubWxs/nmReservoirParameterField.h
+++ b/Include/nmNum/nmSubWxs/nmReservoirParameterField.h
@@ -117,6 +117,9 @@ public:
     /** @brief 返回当前枚举稳定code。 */
     QString enumCode() const;
 
+    /** @brief 设置页面级关联校验错误；空文字表示清除关联错误。 */
+    void setExternalValidationError(const QString& sError);
+
     /** @brief 校验当前输入，并更新参数范围提示。 */
     bool validate();
 
@@ -159,6 +162,7 @@ private:
     QComboBox* m_pUnitComboBox;                  ///< 可换算单位下拉框。
     QLabel* m_pUnitLabel;                        ///< 无单位字段的空白对齐占位。
     QColor m_clrNormalText;                      ///< 输入框默认文字颜色。
+    QString m_sExternalValidationError;          ///< 页面级关联校验错误文字。
     bool m_bVisible;                             ///< 参数行是否参与编辑。
     bool m_bUpdating;                            ///< 程序写值时阻止业务信号。
 };
diff --git a/Include/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.h b/Include/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.h
index 02df385..6422d17 100644
--- a/Include/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.h
+++ b/Include/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.h
@@ -22,6 +22,7 @@ struct NM_SUB_WXS_EXPORT nmReservoirPropertiesSnapshot
     /** @brief 构造空快照。 */
     nmReservoirPropertiesSnapshot();
 
+    int m_nSolverModelType;                                           ///< 打开对话框时的求解器模型类型数值。
     nmDataReservoir m_oReservoir;                                      ///< 储层参数副本。
     QVector<nmDataVerticalWell> m_vecVerticalWells;                    ///< 直井参数副本。
     QVector<nmDataVerticalFracturedWell> m_vecVerticalFracturedWells;  ///< 垂直压裂井参数副本。
diff --git a/Src/nmNum/nmSubWxs/nmReservoirParameterCatalog.cpp b/Src/nmNum/nmSubWxs/nmReservoirParameterCatalog.cpp
index dc8265d..55a636a 100644
--- a/Src/nmNum/nmSubWxs/nmReservoirParameterCatalog.cpp
+++ b/Src/nmNum/nmSubWxs/nmReservoirParameterCatalog.cpp
@@ -2,6 +2,7 @@
 
 #include "nmReservoirPropertiesDataSource.h"
 #include "nmAttrRegistry.h"
+#include "nmDataAnalyzeManager.h"
 #include "nmDataAttribute.h"
 #include "nmDataPerforation.h"
 
@@ -31,9 +32,12 @@ static const char* const s_pCatalogTranslationMarkers[] =
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Position and wellbore"),
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Wellbore storage"),
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Wellbore storage and fracture"),
-    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Basic properties"),
+    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Basic and medium properties"),
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Fluid parameters"),
-    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Compression and saturation"),
+    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Oil phase parameters"),
+    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Water phase parameters"),
+    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Compressibility"),
+    QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Compressibility and saturation"),
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Reservoir parameters"),
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Vertical well"),
     QT_TRANSLATE_NOOP("nmWxReservoirPropertiesEditor", "Fractured vertical well"),
@@ -162,6 +166,141 @@ nmReservoirParameterGroupInfo parameterGroup(
     return oGroup;
 }
 
+/** @brief 返回当前求解器模型对应的流体参数分组标题。 */
+const char* solverPvtGroupTitle(
+        int nSolverModelType,
+        NM_PHASE_TYPE ePhaseType)
+{
+    switch (nSolverModelType)
+    {
+    case SMT_Oil_ConstPvt:
+        return "Oil phase parameters";
+    case SMT_Water_ConstPvt:
+        return "Water phase parameters";
+    default:
+        if (nSolverModelType == 0 && ePhaseType == PHASE_Oil)
+        {
+            return "Oil phase parameters";
+        }
+        if (nSolverModelType == 0 && ePhaseType == PHASE_Water)
+        {
+            return "Water phase parameters";
+        }
+        return "Fluid parameters";
+    }
+}
+
+/** @brief 按求解器模型向流体分组添加实际使用的PVT单值参数。 */
+void appendSolverPvtFields(
+        nmReservoirParameterGroupInfo& oGroup,
+        int nSolverModelType,
+        NM_PHASE_TYPE ePhaseType)
+{
+    switch (nSolverModelType)
+    {
+    case SMT_Oil_ConstPvt:
+        oGroup.m_listFields
+                << numericField("Miuo", "Miuo")
+                << unitlessNumericField("Bo", "Bo");
+        break;
+    case SMT_Water_ConstPvt:
+        oGroup.m_listFields
+                << numericField("Miuw", "Miuw")
+                << unitlessNumericField("Bw", "Bw");
+        break;
+    default:
+        // 自定义数据源未提供模型类型时，按单相相态保留兼容入口。
+        if (nSolverModelType == 0 &&
+                (ePhaseType == PHASE_Oil ||
+                 ePhaseType == PHASE_UNKNOWN))
+        {
+            oGroup.m_listFields
+                    << numericField("Miuo", "Miuo")
+                    << unitlessNumericField("Bo", "Bo");
+        }
+        else if (nSolverModelType == 0 &&
+                 ePhaseType == PHASE_Water)
+        {
+            oGroup.m_listFields
+                    << numericField("Miuw", "Miuw")
+                    << unitlessNumericField("Bw", "Bw");
+        }
+        break;
+    }
+}
+
+/** @brief 判断当前模型是否需要编辑初始含水饱和度。 */
+bool solverUsesInitialWaterSaturation(
+        int nSolverModelType,
+        NM_PHASE_TYPE ePhaseType)
+{
+    return nSolverModelType == SMT_Oil_Water_TwoPhase ||
+            (nSolverModelType == 0 &&
+             ePhaseType == PHASE_Oil_Water);
+}
+
+/** @brief 判断当前模型是否需要编辑初始含油饱和度。 */
+bool solverUsesInitialOilSaturation(
+        int nSolverModelType,
+        NM_PHASE_TYPE ePhaseType)
+{
+    return nSolverModelType == SMT_Oil_Water_TwoPhase ||
+            (nSolverModelType == 0 &&
+             ePhaseType == PHASE_Oil_Water);
+}
+
+/** @brief 判断当前模型是否需要编辑初始含气饱和度。 */
+bool solverUsesInitialGasSaturation(
+        int nSolverModelType,
+        NM_PHASE_TYPE ePhaseType)
+{
+    return nSolverModelType == SMT_Gas_VariablePvt ||
+            nSolverModelType == SMT_Gas_PseudoPressure ||
+            (nSolverModelType == 0 &&
+             ePhaseType == PHASE_Gas);
+}
+
+/** @brief 按求解器模型添加实际使用的压缩系数和饱和度参数。 */
+void appendSolverCompressionFields(
+        nmReservoirParameterGroupInfo& oGroup,
+        int nSolverModelType,
+        NM_PHASE_TYPE ePhaseType)
+{
+    switch (nSolverModelType)
+    {
+    case SMT_Oil_ConstPvt:
+    case SMT_Water_ConstPvt:
+        oGroup.m_listFields.append(numericField("Cti", "Cti"));
+        break;
+    default:
+        if (nSolverModelType == 0 &&
+                (ePhaseType == PHASE_Oil ||
+                 ePhaseType == PHASE_Water ||
+                 ePhaseType == PHASE_UNKNOWN))
+        {
+            oGroup.m_listFields.append(numericField("Cti", "Cti"));
+        }
+        else
+        {
+            oGroup.m_listFields.append(numericField("Cf", "Cf"));
+        }
+        break;
+    }
+
+    if (solverUsesInitialOilSaturation(nSolverModelType, ePhaseType))
+    {
+        oGroup.m_listFields.append(numericField("Soi", "Soi"));
+    }
+    if (solverUsesInitialWaterSaturation(nSolverModelType, ePhaseType))
+    {
+        oGroup.m_listFields.append(numericField("Swi", "Swi"));
+    }
+    if (solverUsesInitialGasSaturation(nSolverModelType, ePhaseType))
+    {
+        oGroup.m_listFields.append(numericField("Sgi", "Sgi"));
+    }
+}
+
 /** @brief 为参数ID添加对象编码前缀。 */
 QString prefixed(const QString& sObjectCode, const char* pParameterId)
 {
@@ -306,10 +445,12 @@ void nmReservoirParameterCatalog::registerSnapshot(
     pRegistry->regAttr("Cti", &oSnapshot.m_oReservoir.getCt());
     pRegistry->regAttr("Cf", &oSnapshot.m_oReservoir.getCf());
     pRegistry->regAttr("Soi", &oSnapshot.m_oReservoir.getSoi());
+    pRegistry->regAttr("Sgi", &oSnapshot.m_oReservoir.getSgi());
     pRegistry->regAttr("Swi", &oSnapshot.m_oReservoir.getSwi());
     pRegistry->regAttr("Bo", &oSnapshot.m_oReservoir.getBo());
     pRegistry->regAttr("Miuo", &oSnapshot.m_oReservoir.getMiuo());
-    pRegistry->regAttr("KxKy", &oSnapshot.m_oReservoir.getKxKy());
+    pRegistry->regAttr("Bw", &oSnapshot.m_oReservoir.getBw());
+    pRegistry->regAttr("Miuw", &oSnapshot.m_oReservoir.getMiuw());
 
     // 第二步：注册求解器支持的三类井及其压裂参数。
     for (int nIndex = 0;
@@ -437,8 +578,11 @@ nmReservoirParameterCatalog::createObjectInfos(
         oInfo.m_sObjectCode = "RESERVOIR";
         oInfo.m_sDisplayName = editorText("Reservoir parameters");
 
+        NM_PHASE_TYPE ePhaseType =
+                oSnapshot.m_oReservoir.getPhaseType();
+
         nmReservoirParameterGroupInfo oBasic =
-                parameterGroup("Basic properties", 0, 0, 1);
+                parameterGroup("Basic and medium properties", 0, 0, 1);
         oBasic.m_nRowSpan = 2;
         oBasic.m_bValueRightAligned = true;
         oBasic.m_listFields
@@ -448,21 +592,37 @@ nmReservoirParameterCatalog::createObjectInfos(
                 << numericField("phi", "phi");
 
         nmReservoirParameterGroupInfo oFluid =
-                parameterGroup("Fluid parameters", 0, 1, 1);
-        oFluid.m_listFields
-                << reservoirModelField("ReservoirType")
-                << numericField("Miuo", "Miuo")
-                << unitlessNumericField("Bo", "Bo")
-                << numericField("KxKy", "KxKy");
+                parameterGroup(solverPvtGroupTitle(
+                                   oSnapshot.m_nSolverModelType,
+                                   ePhaseType),
+                               0, 1, 1);
+        appendSolverPvtFields(oFluid,
+                              oSnapshot.m_nSolverModelType,
+                              ePhaseType);
 
+        bool bUsesSaturation = solverUsesInitialWaterSaturation(
+                    oSnapshot.m_nSolverModelType, ePhaseType) ||
+                solverUsesInitialGasSaturation(
+                    oSnapshot.m_nSolverModelType, ePhaseType);
         nmReservoirParameterGroupInfo oCompression =
-                parameterGroup("Compression and saturation", 1, 1, 1);
-        oCompression.m_listFields
-                << numericField("Cti", "Cti")
-                << numericField("Cf", "Cf")
-                << numericField("Soi", "Soi")
-                << numericField("Swi", "Swi");
-        oInfo.m_listGroups << oBasic << oFluid << oCompression;
+                parameterGroup(bUsesSaturation
+                               ? "Compressibility and saturation"
+                               : "Compressibility",
+                               oFluid.m_listFields.isEmpty() ? 0 : 1,
+                               1, 1);
+        if (oFluid.m_listFields.isEmpty())
+        {
+            oCompression.m_nRowSpan = 2;
+        }
+        appendSolverCompressionFields(oCompression,
+                                      oSnapshot.m_nSolverModelType,
+                                      ePhaseType);
+        oInfo.m_listGroups.append(oBasic);
+        if (!oFluid.m_listFields.isEmpty())
+        {
+            oInfo.m_listGroups.append(oFluid);
+        }
+        oInfo.m_listGroups.append(oCompression);
         listInfos.append(oInfo);
         return listInfos;
     }
diff --git a/Src/nmNum/nmSubWxs/nmReservoirParameterField.cpp b/Src/nmNum/nmSubWxs/nmReservoirParameterField.cpp
index e82e0ba..70e2cd6 100644
--- a/Src/nmNum/nmSubWxs/nmReservoirParameterField.cpp
+++ b/Src/nmNum/nmSubWxs/nmReservoirParameterField.cpp
@@ -66,6 +66,7 @@ nmReservoirParameterField::nmReservoirParameterField(
       m_pUnitComboBox(nullptr),
       m_pUnitLabel(nullptr),
       m_clrNormalText(),
+      m_sExternalValidationError(),
       m_bVisible(true),
       m_bUpdating(false)
 {
@@ -315,6 +316,13 @@ QString nmReservoirParameterField::enumCode() const
             m_pValueComboBox->currentIndex()).toString();
 }
 
+void nmReservoirParameterField::setExternalValidationError(
+        const QString& sError)
+{
+    m_sExternalValidationError = sError;
+    validate();
+}
+
 bool nmReservoirParameterField::validate()
 {
     if (!m_bVisible || isEnum())
@@ -345,6 +353,7 @@ bool nmReservoirParameterField::validate()
             bValid = dValue == static_cast<int>(dValue);
         }
     }
+    bValid = bValid && m_sExternalValidationError.isEmpty();
     updateValidationAppearance(bValid);
     return bValid;
 }
@@ -461,6 +470,14 @@ void nmReservoirParameterField::updateValidationAppearance(bool bValid)
         }
         sHelp += sRange;
     }
+    if (!m_sExternalValidationError.isEmpty())
+    {
+        if (!sHelp.isEmpty())
+        {
+            sHelp += "\n";
+        }
+        sHelp += m_sExternalValidationError;
+    }
     m_pLineEdit->setToolTip(validationToolTip(sHelp, bValid));
     m_pLineEdit->setWhatsThis(sHelp);
     if (m_pLabel != nullptr)
diff --git a/Src/nmNum/nmSubWxs/nmReservoirParameterPage.cpp b/Src/nmNum/nmSubWxs/nmReservoirParameterPage.cpp
index b1d2884..8f50929 100644
--- a/Src/nmNum/nmSubWxs/nmReservoirParameterPage.cpp
+++ b/Src/nmNum/nmSubWxs/nmReservoirParameterPage.cpp
@@ -10,6 +10,7 @@
 #include <QLabel>
 #include <QSizePolicy>
 #include <QVBoxLayout>
+#include <QtGlobal>
 
 nmReservoirParameterPage::nmReservoirParameterPage(
         nmReservoirPropertiesCategory eCategory,
@@ -375,6 +376,20 @@ bool nmReservoirParameterPage::commitPendingEdits()
 
 bool nmReservoirParameterPage::isInputValid()
 {
+    nmReservoirParameterField* pSoiField =
+            m_mapFields.value("Soi", nullptr);
+    nmReservoirParameterField* pSwiField =
+            m_mapFields.value("Swi", nullptr);
+    if (pSoiField != nullptr)
+    {
+        pSoiField->setExternalValidationError(QString());
+    }
+    if (pSwiField != nullptr)
+    {
+        pSwiField->setExternalValidationError(QString());
+    }
+
+    bool bAllValid = true;
     for (int nFieldIndex = 0;
          nFieldIndex < m_listFields.size();
          ++nFieldIndex)
@@ -384,10 +399,32 @@ bool nmReservoirParameterPage::isInputValid()
         if (pField != nullptr && pField->isFieldVisible() &&
                 !pField->validate())
         {
-            return false;
+            bAllValid = false;
         }
     }
-    return true;
+
+    // 油水两相同时显示两个初始饱和度时，两者之和必须为1。
+    if (pSoiField != nullptr && pSwiField != nullptr &&
+            pSoiField->isFieldVisible() &&
+            pSwiField->isFieldVisible())
+    {
+        bool bSoiValid = false;
+        bool bSwiValid = false;
+        QVariant oSoi = pSoiField->baseValue(bSoiValid);
+        QVariant oSwi = pSwiField->baseValue(bSwiValid);
+        const double dTolerance = 1.0e-6;
+        if (bSoiValid && bSwiValid &&
+                qAbs(oSoi.toDouble() + oSwi.toDouble() - 1.0) >
+                dTolerance)
+        {
+            QString sError = tr(
+                    "Initial oil and water saturations must sum to 1.");
+            pSoiField->setExternalValidationError(sError);
+            pSwiField->setExternalValidationError(sError);
+            bAllValid = false;
+        }
+    }
+    return bAllValid;
 }
 
 void nmReservoirParameterPage::slotFieldValueEdited()
diff --git a/Src/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.cpp b/Src/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.cpp
index c10ada0..0502ac6 100644
--- a/Src/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.cpp
+++ b/Src/nmNum/nmSubWxs/nmReservoirPropertiesDataSource.cpp
@@ -5,6 +5,7 @@
 #include "nmWxParameterProperty.h"
 
 nmReservoirPropertiesSnapshot::nmReservoirPropertiesSnapshot()
+    : m_nSolverModelType(0)
 {
 }
 
@@ -34,7 +35,9 @@ bool nmAnalyzeManagerReservoirDataSource::loadSnapshot(
         return false;
     }
 
-    // 第二步：复制储层和几何对象，确保界面编辑不会触碰实时数据。
+    // 第二步：复制求解器模型、储层和几何对象，确保界面编辑不会触碰实时数据。
+    oSnapshot.m_nSolverModelType =
+            static_cast<int>(m_pDataManager->getSolverModelType());
     oSnapshot.m_oReservoir = m_pDataManager->getReservoirDataCopy();
     oSnapshot.m_vecRegionMarks = m_pDataManager->getRegionMarkDataListCopy();
     oSnapshot.m_vecFaults = m_pDataManager->getFaultDataListCopy();
diff --git a/Src/nmNum/nmSubWxs/nmWxReservoirPropertiesEditor.cpp b/Src/nmNum/nmSubWxs/nmWxReservoirPropertiesEditor.cpp
index 2beb682..fe0bd13 100644
--- a/Src/nmNum/nmSubWxs/nmWxReservoirPropertiesEditor.cpp
+++ b/Src/nmNum/nmSubWxs/nmWxReservoirPropertiesEditor.cpp
@@ -48,7 +48,7 @@ nmWxReservoirPropertiesEditor::nmWxReservoirPropertiesEditor(
     setWindowTitle(tr("Reservoir properties settings"));
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
     // 首次打开使用建议尺寸，后续最小宽高均由页面内容和布局自动决定。
-    resize(880, 520);
+    resize(880, 480);
 }
 
 nmWxReservoirPropertiesEditor::~nmWxReservoirPropertiesEditor()