A general system preconditioner: the CPRW pressure stage as a two-level method

CMakeLists_files.cmake

@@ -516,6 +516,8 @@ list (APPEND TEST_SOURCE_FILES
   tests/test_tpsa_localresidual.cpp
   tests/test_tpsa_primaryvariables.cpp
   tests/test_vfpproperties.cpp
+  tests/test_GeneralSystemPreconditioner.cpp
+  tests/test_SystemCprwPressureStage.cpp
   tests/test_WellMatrixMerger.cpp
   tests/test_WaterSatfuncConsistencyChecks.cpp
   tests/test_wellmodel.cpp
@@ -691,6 +693,10 @@ list (APPEND TEST_DATA_FILES
   tests/options_system_cpr_missing_smoother.json
   tests/options_system_cpr_missing_well.json
   tests/options_system_cpr_res_precond_not_cpr.json
+  tests/options_system_cprw_approx_wells.json
+  tests/options_system_cprw_approx_wells_bad_outer.json
+  tests/options_system_cprw_complete.json
+  tests/options_system_cprw_missing_coarsesolver.json
   tests/GCONSUMP.DATA
   tests/GCONSUMP_COMPLEX.DATA
   tests/GROUP_HIGHER_CONSTRAINTS.DATA
@@ -1123,6 +1129,11 @@ list (APPEND PUBLIC_HEADER_FILES
   opm/simulators/linalg/ISTLSolverRuntimeOptionProxy.hpp
   opm/simulators/linalg/Preconditioner2InverseOperator.hpp
   opm/simulators/linalg/system/MultiComm.hpp
+  opm/simulators/linalg/system/SystemCprwPressureStage.hpp
+  opm/simulators/linalg/system/GeneralSystemPreconditioner.hpp
+  opm/simulators/linalg/system/SystemPreconditionerParts.hpp
+  opm/simulators/linalg/system/SystemPressureBhpTransferPolicy.hpp
+  opm/simulators/linalg/system/SystemPreconditionerParts.hpp
   opm/simulators/linalg/system/SystemPreconditioner.hpp
   opm/simulators/linalg/system/SystemPreconditionerFactory.hpp
   opm/simulators/linalg/system/SystemTypes.hpp

opm/simulators/linalg/FlowLinearSolverParameters.cpp

@@ -135,6 +135,8 @@ void FlowLinearSolverParameters::registerParameters()
         ("Scale linear system according to equation scale and primary variable types");
     Parameters::Register<Parameters::LinearSolver>
         ("Configuration of solver. Valid options are: cprw (default), system_cpr (CPU-only), "
+         "system_cprw (CPU-only, system_cpr with the wells in the pressure stage), "
+         "general_system_cpr / general_system_cprw (the same composed from named parts), "
          "ilu0, dilu, cpr (an alias for cprw), cpr_quasiimpes, "
          "cpr_trueimpes, cpr_trueimpesanalytic, amg or hybrid (experimental). "
          "Alternatively, you can request a configuration to be read from a "

opm/simulators/linalg/ISTLSolverRuntimeOptionProxy.hpp

@@ -155,13 +155,15 @@ class ISTLSolverRuntimeOptionProxy : public AbstractISTLSolver<GetPropType<TypeT
     void createSolver(const Simulator& simulator, Args&&... args)
     {
         auto linSolverConf = Parameters::Get<Parameters::LinearSolver>();
-        bool useSystemCpr = (linSolverConf == "system_cpr");
+        bool useSystemCpr = (linSolverConf == "system_cpr") || (linSolverConf == "system_cprw")
+            || (linSolverConf == "general_system_cpr") || (linSolverConf == "general_system_cprw");
         if (!useSystemCpr && linSolverConf.size() > 5
             && linSolverConf.ends_with(".json")
             && std::filesystem::exists(linSolverConf)) {
             try {
                 PropertyTree prm(linSolverConf);
-                useSystemCpr = (prm.get<std::string>("preconditioner.type", "") == "system_cpr");
+                const auto type = prm.get<std::string>("preconditioner.type", "");
+                useSystemCpr = (type == "system_cpr") || (type == "general_system_cpr");
             } catch (...) {}
         }
         if (useSystemCpr) {

opm/simulators/linalg/PropertyTree.cpp

@@ -114,6 +114,36 @@ std::vector<std::string> PropertyTree::get_child_keys() const
     return keys;
 }
 
+void PropertyTree::put_child_list(const std::string& key,
+                                  const std::vector<PropertyTree>& items)
+{
+    // An array is a node whose children all have an empty key.
+    boost::property_tree::ptree array;
+    for (const auto& item : items) {
+        array.push_back(std::make_pair(std::string{}, *item.tree_));
+    }
+    tree_->put_child(key, array);
+}
+
+std::optional<std::vector<PropertyTree>>
+PropertyTree::get_child_list(const std::string& child) const
+{
+    auto subTree = this->tree_->get_child_optional(child);
+    if (! subTree) {
+        return std::nullopt;
+    }
+
+    // A JSON array parses to a node whose children all have an empty key, so
+    // they cannot be reached by name; walk them in order instead.
+    std::vector<PropertyTree> items;
+    items.reserve(subTree->size());
+    for (const auto& item : *subTree) {
+        items.emplace_back(PropertyTree(item.second));
+    }
+
+    return items;
+}
+
 template <typename T>
 std::optional<std::vector<T>>
 PropertyTree::get_child_items_as_vector(const std::string& child) const

opm/simulators/linalg/PropertyTree.hpp

@@ -137,6 +137,31 @@ class PropertyTree
     /// \return Vector of strings containing the names of all immediate children
     std::vector<std::string> get_child_keys() const;
 
+    /// Retrieve a node's children as sub trees, in order.
+    ///
+    /// For a JSON array of objects.  Such an array parses to a node whose
+    /// children all have an empty key, so they cannot be reached by name and
+    /// get_child_items_as_vector() cannot read them either -- that one reads
+    /// scalars.
+    ///
+    /// \param[in] child Property key.  Expected to be in hierarchical
+    /// notation for subtrees--i.e., using periods ('.') to separate
+    /// hierarchy levels.
+    ///
+    /// \return The child sub trees in the order they appear.  Nullopt if no
+    /// node named by \p child exists.
+    std::optional<std::vector<PropertyTree>>
+    get_child_list(const std::string& child) const;
+
+    /// Store a sequence of sub trees as a JSON array.
+    ///
+    /// \param[in] key Property key.  Expected to be in hierarchical
+    /// notation for subtrees--i.e., using periods ('.') to separate
+    /// hierarchy levels.
+    ///
+    /// \param[in] items Sub trees, stored in the order given.
+    void put_child_list(const std::string& key, const std::vector<PropertyTree>& items);
+
     /// Retrieve node items as linearised vector.
     ///
     /// Assumes that the node's child is an array type of homongeneous