[NL] Small refactorings, renames, braces, types.

Obligatory clang-format too.

Choosing int over size_t for number of iterations -- nobody
is going to wait that long anyway.

NumLib/TimeStepping/Algorithms/IterationNumberBasedAdaptiveTimeStepping.cpp

@@ -21,29 +21,30 @@ namespace NumLib
 {
 IterationNumberBasedAdaptiveTimeStepping::
     IterationNumberBasedAdaptiveTimeStepping(
-        double t0, double tn, double min_ts, double max_ts, double initial_ts,
-        std::vector<std::size_t>& iter_times_vector,
-        std::vector<double>& multiplier_vector)
-    : TimeStepAlgorithm(t0, tn),
+        double const t_initial, double const t_end, double const min_dt,
+        double const max_dt, double const initial_dt,
+        std::vector<int> const& iter_times_vector,
+        std::vector<double> const& multiplier_vector)
+    : TimeStepAlgorithm(t_initial, t_end),
       _iter_times_vector(iter_times_vector),
       _multiplier_vector(multiplier_vector),
-      _min_ts(min_ts),
-      _max_ts(max_ts),
-      _initial_ts(initial_ts),
-      _max_iter(_iter_times_vector.empty() ? 0 : _iter_times_vector.back()),
-      _iter_times(0),
-      _n_rejected_steps(0)
+      _min_dt(min_dt),
+      _max_dt(max_dt),
+      _initial_dt(initial_dt),
+      _max_iter(_iter_times_vector.empty() ? 0 : _iter_times_vector.back())
 {
     assert(iter_times_vector.size() == multiplier_vector.size());
 }
 
 bool IterationNumberBasedAdaptiveTimeStepping::next(
-    const double /*solution_error*/)
+    double const /*solution_error*/)
 {
     // check current time step
-    if (std::abs(_ts_current.current() - _t_end) <
+    if (std::abs(_ts_current.current() - end()) <
         std::numeric_limits<double>::epsilon())
+    {
         return false;
+    }
 
     // confirm current time and move to the next if accepted
     if (accepted())
@@ -71,38 +72,48 @@ double IterationNumberBasedAdaptiveTimeStepping::getNextTimeStepSize() const
     // then we use initial guess provided by a user
     if (_ts_prev.steps() == 0)
     {
-        dt = _initial_ts;
+        dt = _initial_dt;
     }
     else  // not the first time step
     {
-        double tmp_multiplier = 1.0;
+        double multiplier = 1.0;
         // get the first multiplier by default
         if (!_multiplier_vector.empty())
-            tmp_multiplier = _multiplier_vector[0];
+        {
+            multiplier = _multiplier_vector[0];
+        }
         // finding the right multiplier
         for (std::size_t i = 0; i < _iter_times_vector.size(); i++)
-            if (this->_iter_times > _iter_times_vector[i])
-                tmp_multiplier = _multiplier_vector[i];
-        // multiply the the multiplier
-        dt = _ts_prev.dt() * tmp_multiplier;
+        {
+            if (_iter_times > _iter_times_vector[i])
+            {
+                multiplier = _multiplier_vector[i];
+            }
+        }
+        dt = _ts_prev.dt() * multiplier;
     }
 
     // check whether out of the boundary
-    if (dt < _min_ts)
-        dt = _min_ts;
-    else if (dt > _max_ts)
-        dt = _max_ts;
+    if (dt < _min_dt)
+    {
+        dt = _min_dt;
+    }
+    else if (dt > _max_dt)
+    {
+        dt = _max_dt;
+    }
 
-    double t_next = dt + _ts_prev.current();
+    double const t_next = dt + _ts_prev.current();
     if (t_next > end())
+    {
         dt = end() - _ts_prev.current();
+    }
 
     return dt;
 }
 
 bool IterationNumberBasedAdaptiveTimeStepping::accepted() const
 {
-    return (_iter_times <= _max_iter);
+    return _iter_times <= _max_iter;
 }
-
-}  // NumLib
+}  // namespace NumLib

NumLib/TimeStepping/Algorithms/IterationNumberBasedAdaptiveTimeStepping.h

@@ -70,9 +70,9 @@ public:
      *
      * @param t_initial             start time
      * @param t_end                 end time
-     * @param min_ts                the minimum allowed time step size
-     * @param max_ts                the maximum allowed time step size
-     * @param initial_ts            initial time step size
+     * @param min_dt                the minimum allowed time step size
+     * @param max_dt                the maximum allowed time step size
+     * @param initial_dt            initial time step size
      * @param iter_times_vector     a vector of iteration numbers
      * (\f$i_1\f$, \f$i_2\f$, ..., \f$i_n\f$) which defines intervals as
      * \f$[i_1,i_2)\f$, \f$[i_2,i_3)\f$, ..., \f$[i_n,\infty)\f$.
@@ -84,29 +84,26 @@ public:
      * A time step size is calculated by \f$\Delta t_{n+1} = a * \Delta t_{n}\f$
      */
     IterationNumberBasedAdaptiveTimeStepping(
-        double t_initial,
-        double t_end,
-        double min_ts,
-        double max_ts,
-        double initial_ts,
-        std::vector<std::size_t>& iter_times_vector,
-        std::vector<double>& multiplier_vector);
+        double const t_initial,
+        double const t_end,
+        double const min_dt,
+        double const max_dt,
+        double const initial_dt,
+        std::vector<int> const& iter_times_vector,
+        std::vector<double> const& multiplier_vector);
 
     ~IterationNumberBasedAdaptiveTimeStepping() override = default;
 
     /// move to the next time step
-    bool next(const double solution_error) override;
+    bool next(double solution_error) override;
 
     /// return if the current step is accepted
     bool accepted() const override;
 
     /// set the number of iterations
-    void setIterationNumber(std::size_t n_itr) { this->_iter_times = n_itr; }
+    void setIterationNumber(int const n_itr) { _iter_times = n_itr; }
     /// return the number of repeated steps
-    std::size_t getNumberOfRepeatedSteps() const
-    {
-        return this->_n_rejected_steps;
-    }
+    int getNumberOfRepeatedSteps() const { return _n_rejected_steps; }
 
 private:
     /// calculate the next time step size
@@ -114,21 +111,21 @@ private:
 
     /// this vector stores the number of iterations to which the respective
     /// multiplier coefficient will be applied
-    const std::vector<std::size_t> _iter_times_vector;
+    const std::vector<int> _iter_times_vector;
     /// this vector stores the multiplier coefficients
     const std::vector<double> _multiplier_vector;
     /// the minimum allowed time step size
-    const double _min_ts;
+    const double _min_dt;
     /// the maximum allowed time step size
-    const double _max_ts;
+    const double _max_dt;
     /// initial time step size
-    const double _initial_ts;
+    const double _initial_dt;
     /// the maximum allowed iteration number to accept current time step
-    const std::size_t _max_iter;
+    const int _max_iter;
     /// the number of nonlinear iterations
-    std::size_t _iter_times;
+    int _iter_times = 0;
     /// the number of rejected steps
-    std::size_t _n_rejected_steps;
+    int _n_rejected_steps = 0;
 };
 
-}  // NumLib
+}  // namespace NumLib