Trial time

src/porepy/models/protocol.py

@@ -666,6 +666,9 @@ def _is_reference_component_eliminated(self) -> bool:
             """Returns True if ``params['eliminate_reference_component'] == True`.
             Defaults to True."""
 
+        def before_time_step(self) -> None:
+            """Called at the start of each time step by model runners."""
+
         def before_nonlinear_loop(self) -> None:
             """Method to be called before the non-linear loop.
 
@@ -689,6 +692,12 @@ def after_nonlinear_convergence(self) -> None:
 
             """
 
+        def after_time_step_convergence(self) -> None:
+            """Called after a new time step solution has been achieved."""
+
+        def after_time_step_failure(self) -> None:
+            """Called after a time step has failed to converge."""
+
         def set_nonlinear_discretizations(self) -> None:
             """Set the list of nonlinear discretizations.
 

src/porepy/numerics/linear_solvers.py

@@ -8,24 +8,30 @@
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING
-from warnings import warn
 
 from porepy.models.solution_strategy import SolutionStrategy
 from porepy.numerics.nonlinear.convergence_check import (
     ConvergenceCriteria,
     ConvergenceInfoCollection,
+    ConvergenceStatus,
     ConvergenceStatusCollection,
     DivergenceCriteria,
     IncrementBasedNanCriterion,
     ResidualBasedNanCriterion,
-    SolverStatus,
 )
-from porepy.viz.solver_statistics import TimeStatistics
+from porepy.numerics.nonlinear.nonlinear_solver_status import (
+    NonlinearSolverStatus,
+    NonlinearSolverStatusConverged,
+    NonlinearSolverStatusFailed,
+)
 
 if TYPE_CHECKING:
     import numpy as np
 
+logger = logging.getLogger(__name__)
+
 
 class LinearSolver:
     """Base solver class for PorePy models, assuming the model is linear and performing
@@ -60,7 +66,7 @@ def __init__(self, params: dict | None = None) -> None:
         )
         """Divergence criterion used in the convergence check."""
 
-    def solve(self, model: SolutionStrategy) -> SolverStatus:
+    def solve(self, model: SolutionStrategy) -> NonlinearSolverStatus:
         """Solve a linear problem defined by the current state of the model.
 
         The linear solver performs only one iteration and checks whether it converged.
@@ -87,11 +93,58 @@ def solve(self, model: SolutionStrategy) -> SolverStatus:
 
         # Conclude on the solver status.
         solver_status = self.summarize_solver_status(
-            model, convergence_status, divergence_status
+            convergence_status, divergence_status
         )
 
+        # Logging statistics.
+        self.update_solver_statistics(model=model, solver_status=solver_status)
+
+        if solver_status.is_converged():
+            model.after_nonlinear_convergence()
+        else:
+            model.after_nonlinear_failure()
+
         return solver_status
 
+    def summarize_solver_status(
+        self,
+        convergence_status: ConvergenceStatusCollection,
+        divergence_status: ConvergenceStatusCollection,
+    ) -> NonlinearSolverStatus:
+        """Consider a collection of convergence and divergence statuses from multiple
+        criteria and make an overall verdict on whether we accept the sollution or not.
+
+        Parameters:
+            convergence_status: Multiple convergence statuses from different criteria.
+            divergence_status: Multiple divergence statuses from variaous criteria.
+
+        Returns:
+            NonlinearSolverStatus: Either Converged or Failed.
+
+        """
+        # YZ: This is a duplicated method of NewtonSolver, but I find it acceptible for
+        # now since we are planning to unify these two classes in the nearest future.
+        if convergence_status.is_converged():
+            return NonlinearSolverStatusConverged(
+                convergence_statuses=convergence_status,
+                divergence_statuses=divergence_status,
+            )
+        elif divergence_status.is_diverged():
+            logger.warning("Failed to solve the nonlinear problem.")
+            return NonlinearSolverStatusFailed(
+                convergence_statuses=convergence_status,
+                divergence_statuses=divergence_status,
+            )
+        else:
+            logger.error(
+                "Nonlinear solver did not fail, but the convergence criterion did not "
+                "accept the solution. Treating it as a failure."
+            )
+            return NonlinearSolverStatusFailed(
+                convergence_statuses=convergence_status,
+                divergence_statuses=divergence_status,
+            )
+
     def before_linear_solve(self, model: SolutionStrategy) -> None:
         """Prepare the linear solve.
 
@@ -135,42 +188,6 @@ def linear_solve(
 
         return convergence_status, divergence_status
 
-    def summarize_solver_status(
-        self,
-        model: SolutionStrategy,
-        convergence_status: ConvergenceStatusCollection,
-        divergence_status: ConvergenceStatusCollection,
-    ) -> SolverStatus:
-        """Conclude on the overall solver status.
-
-        NOTE: Convergence status takes precedence over divergence status.
-
-        Parameters:
-            model: The model instance specifying the problem to be solved.
-            convergence_status: Convergence statuses.
-            divergence_status: Divergence statuses.
-
-        Returns:
-            SolverStatus: The overall status of the nonlinear solver.
-
-        """
-        if convergence_status.is_converged():
-            solver_status = SolverStatus.SUCCESSFUL
-            self.update_solver_statistics(model, solver_status)
-            model.after_nonlinear_convergence()
-        elif divergence_status.is_diverged():
-            solver_status = SolverStatus.FAILED
-            self.update_solver_statistics(model, solver_status)
-            model.after_nonlinear_failure()
-            warn("Failed to solve the (non)linear problem.", UserWarning)
-        else:
-            raise ValueError(
-                "Invalid convergence status: "
-                f"{convergence_status.union(divergence_status)}"
-            )
-
-        return solver_status
-
     def after_linear_iteration(
         self, model: SolutionStrategy, nonlinear_increment: np.ndarray
     ) -> tuple[ConvergenceStatusCollection, ConvergenceStatusCollection]:
@@ -223,25 +240,35 @@ def check_convergence(
         """
         # Fetch the residual.
         residual = model.equation_system.assemble(evaluate_jacobian=False)
+        iterate = model.equation_system.get_variable_values(iterate_index=0)
 
         # Check convergence status based on current iteration.
         convergence_status, convergence_info = self.convergence_criteria.check(
             increment=nonlinear_increment,
             residual=residual,
+            # Reference values don't make sense for a linear solver, but passed to
+            # conform the interface defined by the NewtonSolver.
+            reference_increment=iterate,
+            reference_residual=residual,
         )
 
         # Check divergence status based on current iteration.
         divergence_status = self.divergence_criteria.check(
             increment=nonlinear_increment,
             residual=residual,
+            # Reference values and num_iterations don't make sense for a linear solver,
+            # but passed to conform the interface defined by the NewtonSolver.
+            reference_increment=iterate,
+            reference_residual=residual,
+            num_iterations=1,
         )
 
         return convergence_status, divergence_status, convergence_info
 
     def update_solver_statistics(
         self,
         model: SolutionStrategy,
-        solver_status: SolverStatus,
+        solver_status: NonlinearSolverStatus,
     ) -> None:
         """Update the solver statistics in the model.
 
@@ -254,11 +281,3 @@ def update_solver_statistics(
         # Basic discretization-related information and overall simulation status.
         model.nonlinear_solver_statistics.log_solver_status(solver_status)
         model.nonlinear_solver_statistics.log_mesh_information(model.mdg.subdomains())
-        if model._is_time_dependent():
-            assert isinstance(model.nonlinear_solver_statistics, TimeStatistics)
-            model.nonlinear_solver_statistics.log_time_information(
-                model.time_manager.time_index,
-                model.time_manager.time,
-                model.time_manager.dt,
-                model.time_manager.final_time_reached(),
-            )