From 79f5a1a9589a72aa7fee243ec9e0eb64fc071b81 Mon Sep 17 00:00:00 2001
From: Arne Morten Kvarving <arne.morten.kvarving@sintef.no>
Date: Tue, 14 Jan 2025 07:49:15 +0100
Subject: [PATCH] NonlinearSolver::Parameters: move to separate struct

and move some more code to the TU. small tidy up enabled
by typetag-less parameters system
---
 opm/simulators/flow/NonlinearSolver.cpp | 78 ++++++++++++++++++++-----
 opm/simulators/flow/NonlinearSolver.hpp | 71 ++++++----------------
 2 files changed, 81 insertions(+), 68 deletions(-)

diff --git a/opm/simulators/flow/NonlinearSolver.cpp b/opm/simulators/flow/NonlinearSolver.cpp
index f592eb584..03915ade2 100644
--- a/opm/simulators/flow/NonlinearSolver.cpp
+++ b/opm/simulators/flow/NonlinearSolver.cpp
@@ -105,21 +105,6 @@ void stabilizeNonlinearUpdate(BVector& dx, BVector& dxOld,
     return;
 }
 
-template<class Scalar>
-void registerNonlinearParameters()
-{
-    Parameters::Register<Parameters::NewtonMaxRelax<Scalar>>
-        ("The maximum relaxation factor of a Newton iteration");
-    Parameters::Register<Parameters::NewtonMaxIterations>
-        ("The maximum number of Newton iterations per time step");
-    Parameters::Register<Parameters::NewtonMinIterations>
-        ("The minimum number of Newton iterations per time step");
-    Parameters::Register<Parameters::NewtonRelaxationType>
-        ("The type of relaxation used by Newton method");
-
-    Parameters::SetDefault<Parameters::NewtonMaxIterations>(20);
-}
-
 template<class Scalar, int Size>
 using BV = Dune::BlockVector<Dune::FieldVector<Scalar,Size>>;
 
@@ -131,7 +116,6 @@ using BV = Dune::BlockVector<Dune::FieldVector<Scalar,Size>>;
     template void detectOscillations(const std::vector<std::vector<T>>&,    \
                                      const int, const int, const T,         \
                                      const int, bool&, bool&);              \
-    template void registerNonlinearParameters<T>();                         \
     INSTANTIATE(T,1)                                                        \
     INSTANTIATE(T,2)                                                        \
     INSTANTIATE(T,3)                                                        \
@@ -146,3 +130,65 @@ INSTANTIATE_TYPE(float)
 #endif
 
 } // namespace Opm::detail
+
+namespace Opm {
+
+template<class Scalar>
+NonlinearSolverParameters<Scalar>::
+NonlinearSolverParameters()
+{
+    // set default values
+    reset();
+
+    // overload with given parameters
+    relaxMax_ = Parameters::Get<Parameters::NewtonMaxRelax<Scalar>>();
+    maxIter_ = Parameters::Get<Parameters::NewtonMaxIterations>();
+    minIter_ = Parameters::Get<Parameters::NewtonMinIterations>();
+
+    const auto& relaxationTypeString = Parameters::Get<Parameters::NewtonRelaxationType>();
+    if (relaxationTypeString == "dampen") {
+        relaxType_ = NonlinearRelaxType::Dampen;
+    } else if (relaxationTypeString == "sor") {
+        relaxType_ = NonlinearRelaxType::SOR;
+    } else {
+        OPM_THROW(std::runtime_error,
+                  "Unknown Relaxtion Type " + relaxationTypeString);
+    }
+}
+
+template<class Scalar>
+void NonlinearSolverParameters<Scalar>::
+reset()
+{
+    // default values for the solver parameters
+    relaxType_ = NonlinearRelaxType::Dampen;
+    relaxMax_ = 0.5;
+    relaxIncrement_ = 0.1;
+    relaxRelTol_ = 0.2;
+    maxIter_ = 10;
+    minIter_ = 1;
+}
+
+template<class Scalar>
+void NonlinearSolverParameters<Scalar>::
+registerParameters()
+{
+    Parameters::Register<Parameters::NewtonMaxRelax<Scalar>>
+        ("The maximum relaxation factor of a Newton iteration");
+    Parameters::Register<Parameters::NewtonMaxIterations>
+        ("The maximum number of Newton iterations per time step");
+    Parameters::Register<Parameters::NewtonMinIterations>
+        ("The minimum number of Newton iterations per time step");
+    Parameters::Register<Parameters::NewtonRelaxationType>
+        ("The type of relaxation used by Newton method");
+
+    Parameters::SetDefault<Parameters::NewtonMaxIterations>(20);
+}
+
+template struct NonlinearSolverParameters<double>;
+
+#if FLOW_INSTANTIATE_FLOAT
+template struct NonlinearSolverParameters<float>;
+#endif
+
+}
diff --git a/opm/simulators/flow/NonlinearSolver.hpp b/opm/simulators/flow/NonlinearSolver.hpp
index b05ea0a98..dae4aa1a8 100644
--- a/opm/simulators/flow/NonlinearSolver.hpp
+++ b/opm/simulators/flow/NonlinearSolver.hpp
@@ -30,7 +30,6 @@
 #include <opm/models/nonlinear/newtonmethodparams.hpp>
 #include <opm/models/nonlinear/newtonmethodproperties.hh>
 
-#include <opm/models/utils/parametersystem.hpp>
 #include <opm/models/utils/propertysystem.hh>
 #include <opm/models/utils/basicproperties.hh>
 
@@ -72,11 +71,26 @@ template <class BVector, class Scalar>
 void stabilizeNonlinearUpdate(BVector& dx, BVector& dxOld,
                               const Scalar omega, NonlinearRelaxType relaxType);
 
-template<class Scalar>
-void registerNonlinearParameters();
-
 }
 
+// Solver parameters controlling nonlinear process.
+template<class Scalar>
+struct NonlinearSolverParameters
+{
+    NonlinearRelaxType relaxType_;
+    Scalar relaxMax_;
+    Scalar relaxIncrement_;
+    Scalar relaxRelTol_;
+    int maxIter_; // max nonlinear iterations
+    int minIter_; // min nonlinear iterations
+
+    NonlinearSolverParameters();
+
+    static void registerParameters();
+
+    void reset();
+};
+
     /// A nonlinear solver class suitable for general fully-implicit models,
     /// as well as pressure, transport and sequential models.
     template <class TypeTag, class PhysicalModel>
@@ -85,54 +99,7 @@ void registerNonlinearParameters();
         using Scalar = GetPropType<TypeTag, Properties::Scalar>;
 
     public:
-        // Solver parameters controlling nonlinear process.
-        struct SolverParameters
-        {
-            NonlinearRelaxType relaxType_;
-            Scalar relaxMax_;
-            Scalar relaxIncrement_;
-            Scalar relaxRelTol_;
-            int maxIter_; // max nonlinear iterations
-            int minIter_; // min nonlinear iterations
-
-            SolverParameters()
-            {
-                // set default values
-                reset();
-
-                // overload with given parameters
-                relaxMax_ = Parameters::Get<Parameters::NewtonMaxRelax<Scalar>>();
-                maxIter_ = Parameters::Get<Parameters::NewtonMaxIterations>();
-                minIter_ = Parameters::Get<Parameters::NewtonMinIterations>();
-
-                const auto& relaxationTypeString = Parameters::Get<Parameters::NewtonRelaxationType>();
-                if (relaxationTypeString == "dampen") {
-                    relaxType_ = NonlinearRelaxType::Dampen;
-                } else if (relaxationTypeString == "sor") {
-                    relaxType_ = NonlinearRelaxType::SOR;
-                } else {
-                    OPM_THROW(std::runtime_error,
-                              "Unknown Relaxtion Type " + relaxationTypeString);
-                }
-            }
-
-            static void registerParameters()
-            {
-                detail::registerNonlinearParameters<Scalar>();
-            }
-
-            void reset()
-            {
-                // default values for the solver parameters
-                relaxType_ = NonlinearRelaxType::Dampen;
-                relaxMax_ = 0.5;
-                relaxIncrement_ = 0.1;
-                relaxRelTol_ = 0.2;
-                maxIter_ = 10;
-                minIter_ = 1;
-            }
-
-        };
+        using SolverParameters = NonlinearSolverParameters<Scalar>;
 
         // ---------  Public methods  ---------