[timeloop] Define locally coupled processes in the staggered solution scheme.

ProcessLib/CreateProcessData.cpp

@@ -8,6 +8,8 @@
  *
  */
 
+#include <range/v3/algorithm/contains.hpp>
+
 #include "BaseLib/Algorithm.h"
 #include "BaseLib/ConfigTree.h"
 #include "NumLib/ODESolver/TimeDiscretizationBuilder.h"
@@ -66,12 +68,14 @@ static std::unique_ptr<ProcessData> makeProcessData(
 std::vector<std::unique_ptr<ProcessData>> createPerProcessData(
     BaseLib::ConfigTree const& config,
     std::vector<std::unique_ptr<Process>> const& processes,
+    std::map<std::string, int>& local_coupling_processes,
     std::map<std::string, std::unique_ptr<NumLib::NonlinearSolverBase>> const&
         nonlinear_solvers,
     bool const compensate_non_equilibrium_initial_residuum,
     std::vector<double> const& fixed_times_for_output)
 {
     std::vector<std::unique_ptr<ProcessData>> per_process_data;
+    std::vector<std::string> process_names;
     int process_id = 0;
 
     //! \ogs_file_param{prj__time_loop__processes__process}
@@ -85,6 +89,35 @@ std::vector<std::unique_ptr<ProcessData>> createPerProcessData(
             { return p->name == pcs_name; },
             "A process with the given name has not been defined.");
 
+        auto const process_name =
+            //! \ogs_file_param{prj__time_loop__processes__process__process_name}
+            pcs_config.getConfigParameterOptional<std::string>("process_name");
+        if (process_name)
+        {
+            if (!local_coupling_processes.contains(*process_name))
+            {
+                OGS_FATAL(
+                    "The given process name '{}' for the element "
+                    "'time_loop/processes/process/process_name' is not found "
+                    "in the element "
+                    "'time_loop/global_process_coupling/"
+                    "local_coupling_processes/process_name' in the project "
+                    "file.",
+                    *process_name);
+            }
+
+            if (ranges::contains(process_names, *process_name))
+            {
+                OGS_FATAL(
+                    "The given process name '{}' for the element "
+                    "'time_loop/processes/process/process_name' is not unique! "
+                    "Please check this in the project file.",
+                    *process_name);
+            }
+            process_names.emplace_back(*process_name);
+            local_coupling_processes[*process_name] = process_id;
+        }
+
         auto const nl_slv_name =
             //! \ogs_file_param{prj__time_loop__processes__process__nonlinear_solver}
             pcs_config.getConfigParameter<std::string>("nonlinear_solver");
@@ -142,6 +175,16 @@ std::vector<std::unique_ptr<ProcessData>> createPerProcessData(
         }
     }
 
+    if (process_names.size() != local_coupling_processes.size())
+    {
+        OGS_FATAL(
+            "The number of the given process names for the element "
+            "'time_loop/processes/process/process_name' is not equal to that "
+            "in the element "
+            "'time_loop/global_process_coupling/local_coupling_processes/"
+            "process_name' in the project file.");
+    }
+
     return per_process_data;
 }
 }  // namespace ProcessLib

ProcessLib/CreateProcessData.h

@@ -17,6 +17,7 @@ namespace ProcessLib
 std::vector<std::unique_ptr<ProcessData>> createPerProcessData(
     BaseLib::ConfigTree const& config,
     std::vector<std::unique_ptr<Process>> const& processes,
+    std::map<std::string, int>& local_coupling_processes,
     std::map<std::string, std::unique_ptr<NumLib::NonlinearSolverBase>> const&
         nonlinear_solvers,
     bool const compensate_non_equilibrium_initial_residuum,

ProcessLib/CreateTimeLoop.cpp

@@ -35,6 +35,7 @@ std::unique_ptr<TimeLoop> createTimeLoop(
 
     std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>
         global_coupling_conv_criteria;
+    std::map<std::string, int> local_coupling_processes;
     int max_coupling_iterations = 1;
     if (coupling_config)
     {
@@ -55,6 +56,49 @@ std::unique_ptr<TimeLoop> createTimeLoop(
                        std::back_inserter(global_coupling_conv_criteria),
                        [](BaseLib::ConfigTree const& c)
                        { return NumLib::createConvergenceCriterion(c); });
+
+        auto const& local_coupling_processes_config =
+            coupling_config
+                //! \ogs_file_param{prj__time_loop__global_process_coupling__local_coupling_processes}
+                ->getConfigSubtreeOptional("local_coupling_processes");
+        if (local_coupling_processes_config)
+        {
+            for (
+                auto name :
+                local_coupling_processes_config
+                    //! \ogs_file_param{prj__time_loop__global_process_coupling__local_coupling_processes__process_name}
+                    ->getConfigParameterList<std::string>("process_name"))
+            {
+                BaseLib::insertIfKeyUniqueElseError(
+                    local_coupling_processes, name, -1,
+                    "The name of locally coupled process is not unique.");
+            }
+
+            static std::string const error_info =
+                "Please check the number of elements in the tag "
+                "'time_loop/global_process_coupling/"
+                "local_coupling_processes' in the project file.";
+            if (local_coupling_processes.size() >
+                global_coupling_conv_criteria.size() - 1)
+            {
+                OGS_FATAL(
+                    "The number of the locally coupled processes is greater "
+                    "than or equal to the number of total coupled processes. "
+                    "{}",
+                    error_info);
+            }
+
+            INFO("There are {:d} locally coupled processes.",
+                 local_coupling_processes.size());
+
+            if (local_coupling_processes.size() < 2)
+            {
+                OGS_FATAL(
+                    "At least two locally coupled processes are required for "
+                    "the local iteration solution! {} ",
+                    error_info);
+            }
+        }
     }
 
     //! \ogs_file_param{prj__time_loop__output}
@@ -105,7 +149,8 @@ std::unique_ptr<TimeLoop> createTimeLoop(
 
     auto per_process_data = createPerProcessData(
         //! \ogs_file_param{prj__time_loop__processes}
-        config.getConfigSubtree("processes"), processes, nonlinear_solvers,
+        config.getConfigSubtree("processes"), processes,
+        local_coupling_processes, nonlinear_solvers,
         compensate_non_equilibrium_initial_residuum, fixed_times_for_output);
 
     const bool use_staggered_scheme =
@@ -153,6 +198,6 @@ std::unique_ptr<TimeLoop> createTimeLoop(
     return std::make_unique<TimeLoop>(
         std::move(outputs), std::move(per_process_data),
         max_coupling_iterations, std::move(global_coupling_conv_criteria),
-        start_time, end_time);
+        std::move(local_coupling_processes), start_time, end_time);
 }
 }  // namespace ProcessLib

ProcessLib/TimeLoop.cpp

@@ -11,6 +11,7 @@
 #include "TimeLoop.h"
 
 #include <range/v3/algorithm/any_of.hpp>
+#include <range/v3/algorithm/contains.hpp>
 
 #include "BaseLib/Error.h"
 #include "BaseLib/RunTime.h"
@@ -265,13 +266,15 @@ TimeLoop::TimeLoop(std::vector<Output>&& outputs,
                    const int global_coupling_max_iterations,
                    std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>&&
                        global_coupling_conv_crit,
+                   std::map<std::string, int>&& local_coupling_processes,
                    const double start_time, const double end_time)
     : _outputs{std::move(outputs)},
       _per_process_data(std::move(per_process_data)),
       _start_time(start_time),
       _end_time(end_time),
       _global_coupling_max_iterations(global_coupling_max_iterations),
-      _global_coupling_conv_crit(std::move(global_coupling_conv_crit))
+      _global_coupling_conv_crit(std::move(global_coupling_conv_crit)),
+      _local_coupling_processes(std::move(local_coupling_processes))
 {
 }
 
@@ -713,15 +716,28 @@ TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
 
     NumLib::NonlinearSolverStatus nonlinear_solver_status{false, -1};
     bool coupling_iteration_converged = true;
+    bool local_coupling_iteration_converged = true;
     for (int global_coupling_iteration = 0;
          global_coupling_iteration < _global_coupling_max_iterations;
          global_coupling_iteration++, resetCouplingConvergenceCriteria())
     {
         // TODO(wenqing): use process name
         coupling_iteration_converged = true;
+        bool local_iteration_converged = true;
         for (auto const& process_data : _per_process_data)
         {
             auto const process_id = process_data->process_id;
+
+            auto const isLocalCouplingProcess =
+                ranges::contains(_local_coupling_processes, process_id,
+                                 [](const auto& m) { return m.second; });
+
+            if (!local_coupling_iteration_converged && !isLocalCouplingProcess)
+            {
+                coupling_iteration_converged = false;
+                continue;
+            }
+
             BaseLib::RunTime time_timestep_process;
             time_timestep_process.start();
 
@@ -760,11 +776,19 @@ TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
                 coupling_iteration_converged =
                     coupling_iteration_converged &&
                     _global_coupling_conv_crit[process_id]->isSatisfied();
+                if (isLocalCouplingProcess)
+                {
+                    local_iteration_converged =
+                        local_iteration_converged &&
+                        _global_coupling_conv_crit[process_id]->isSatisfied();
+                }
             }
             MathLib::LinAlg::copy(x, x_old);
         }  // end of for (auto& process_data : _per_process_data)
 
-        if (coupling_iteration_converged && global_coupling_iteration > 0)
+        local_coupling_iteration_converged = local_iteration_converged;
+        if (local_coupling_iteration_converged &&
+            coupling_iteration_converged && global_coupling_iteration > 0)
         {
             break;
         }
@@ -775,7 +799,7 @@ TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
         }
     }
 
-    if (!coupling_iteration_converged)
+    if (!coupling_iteration_converged || !local_coupling_iteration_converged)
     {
         WARN(
             "The coupling iterations reaches its maximum number in time step "

ProcessLib/TimeLoop.h

@@ -41,6 +41,7 @@ public:
              const int global_coupling_max_iterations,
              std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>&&
                  global_coupling_conv_crit,
+             std::map<std::string, int>&& local_coupling_processes,
              const double start_time, const double end_time);
 
     void initialize();
@@ -153,6 +154,9 @@ private:
     std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>
         _global_coupling_conv_crit;
 
+    /// Processes that will be solved in a local iteration.
+    std::map<std::string, int> _local_coupling_processes;
+
     /// Solutions of the previous coupling iteration for the convergence
     /// criteria of the coupling iteration.
     std::vector<GlobalVector*> _solutions_of_last_cpl_iteration;