Merge branch 'UseTimeInsteadDouble' into 'master'

Use data struct Time instead a double for time

See merge request ogs/ogs!5030

Applications/ApplicationsLib/Simulation.cpp

@@ -115,13 +115,13 @@ void Simulation::initializeDataStructures(
 double Simulation::currentTime() const
 {
     auto const& time_loop = project_data->getTimeLoop();
-    return time_loop.currentTime();
+    return time_loop.currentTime()();
 }
 
 double Simulation::endTime() const
 {
     auto const& time_loop = project_data->getTimeLoop();
-    return time_loop.endTime();
+    return time_loop.endTime()();
 }
 
 bool Simulation::executeTimeStep()

NumLib/TimeStepping/Algorithms/EvolutionaryPIDcontroller.cpp

@@ -142,25 +142,26 @@ double EvolutionaryPIDcontroller::limitStepSize(
         return limited_h;
     }
 
-    // find first fixed timestep for output larger than the current time, i.e.,
+    // find first fixed output time larger than the current time, i.e.,
     // current time < fixed output time
     auto fixed_output_time_it = std::find_if(
         std::begin(_fixed_times_for_output), std::end(_fixed_times_for_output),
         [&timestep_current](auto const fixed_output_time)
-        { return timestep_current.current() < fixed_output_time; });
+        { return timestep_current.current() < Time{fixed_output_time}; });
 
     if (fixed_output_time_it != _fixed_times_for_output.end())
     {
         // check if the fixed output time is in the interval
         // (current time, current time + limited_h)
-        if (*fixed_output_time_it < timestep_current.current() + limited_h)
+        if (Time{*fixed_output_time_it} <
+            timestep_current.current() + limited_h)
         {
             // check if the potential adjusted time step is larger than zero
-            if (std::abs(*fixed_output_time_it - timestep_current.current()) >
+            if (std::abs(*fixed_output_time_it - timestep_current.current()()) >
                 std::numeric_limits<double>::epsilon() *
-                    timestep_current.current())
+                    timestep_current.current()())
             {
-                return *fixed_output_time_it - timestep_current.current();
+                return *fixed_output_time_it - timestep_current.current()();
             }
         }
     }

NumLib/TimeStepping/Algorithms/FixedTimeStepping.cpp

@@ -17,11 +17,14 @@
 #include <limits>
 #include <numeric>
 
+#include "NumLib/TimeStepping/Time.h"
+
 namespace
 {
 /// Returns sum of the newly added time increments.
-double addTimeIncrement(std::vector<double>& delta_ts, std::size_t const repeat,
-                        double const delta_t, double const t_curr)
+NumLib::Time addTimeIncrement(std::vector<double>& delta_ts,
+                              std::size_t const repeat, double const delta_t,
+                              NumLib::Time const t_curr)
 {
     auto const new_size = delta_ts.size() + repeat;
     try
@@ -48,9 +51,9 @@ double addTimeIncrement(std::vector<double>& delta_ts, std::size_t const repeat,
 
 namespace NumLib
 {
-std::size_t findDeltatInterval(double const t_initial,
+std::size_t findDeltatInterval(Time const& t_initial,
                                std::vector<double> const& delta_ts,
-                               double const fixed_output_time)
+                               Time const& fixed_output_time)
 {
     if (fixed_output_time < t_initial)
     {
@@ -72,35 +75,39 @@ std::size_t findDeltatInterval(double const t_initial,
 }
 
 void incorporateFixedTimesForOutput(
-    double const t_initial, double const t_end, std::vector<double>& delta_ts,
+    NumLib::Time const t_initial, NumLib::Time const t_end,
+    std::vector<double>& delta_ts,
     std::vector<double> const& fixed_times_for_output)
 {
     if (fixed_times_for_output.empty())
     {
         return;
     }
 
-    if (auto lower_bound =
-            std::lower_bound(begin(fixed_times_for_output),
-                             end(fixed_times_for_output), t_initial);
+    if (auto lower_bound = std::lower_bound(
+            begin(fixed_times_for_output), end(fixed_times_for_output),
+            t_initial,
+            [](auto const time, NumLib::Time const& initial_time)
+            { return NumLib::Time(time) < initial_time; });
         lower_bound != begin(fixed_times_for_output))
     {
         WARN(
             "Request for output at times {}, but the simulation's start time "
             "is {}. Output will be skipped.",
             fmt::join(begin(fixed_times_for_output), lower_bound, ", "),
-            t_initial);
+            t_initial());
     }
 
-    if (auto upper_bound = std::upper_bound(begin(fixed_times_for_output),
-                                            end(fixed_times_for_output), t_end);
+    if (auto upper_bound =
+            std::upper_bound(begin(fixed_times_for_output),
+                             end(fixed_times_for_output), t_end());
         upper_bound != end(fixed_times_for_output))
     {
         WARN(
             "Request for output at times {}, but simulation's end time is {}. "
             "Output will be skipped.",
             fmt::join(upper_bound, end(fixed_times_for_output), ", "),
-            t_end);
+            t_end());
     }
 
     if (delta_ts.empty())
@@ -112,31 +119,31 @@ void incorporateFixedTimesForOutput(
     // incorporate fixed output times into dts vector
     for (auto const fixed_time_for_output : fixed_times_for_output)
     {
-        auto const interval_number =
-            findDeltatInterval(t_initial, delta_ts, fixed_time_for_output);
+        auto const interval_number = findDeltatInterval(
+            t_initial, delta_ts, Time(fixed_time_for_output));
         if (interval_number == std::numeric_limits<std::size_t>::max())
         {
             WARN("Did not find interval for fixed output time {}",
                  fixed_time_for_output);
             continue;
         }
+
         auto const lower_bound = std::accumulate(
             begin(delta_ts), begin(delta_ts) + interval_number, t_initial);
         auto const upper_bound = lower_bound + delta_ts[interval_number];
-        if (fixed_time_for_output - lower_bound <=
-            TimeStep::minimalTimeStepSize)
+        // in order to use the comparison from struct Time
+        if (NumLib::Time(fixed_time_for_output) == lower_bound)
         {
             continue;
         }
-        if (upper_bound - fixed_time_for_output <=
-            TimeStep::minimalTimeStepSize)
+        if (upper_bound == NumLib::Time(fixed_time_for_output))
         {
             continue;
         }
-        delta_ts[interval_number] = fixed_time_for_output - lower_bound;
+        delta_ts[interval_number] = fixed_time_for_output - lower_bound();
 
         delta_ts.insert(delta_ts.begin() + interval_number + 1,
-                        upper_bound - fixed_time_for_output);
+                        upper_bound() - fixed_time_for_output);
     }
 }
 
@@ -145,7 +152,7 @@ FixedTimeStepping::FixedTimeStepping(
     std::vector<double> const& fixed_times_for_output)
     : TimeStepAlgorithm(t0, tn)
 {
-    double t_curr = _t_initial;
+    Time t_curr = _t_initial;
 
     if (!areRepeatDtPairsValid(repeat_dt_pairs))
     {
@@ -163,8 +170,8 @@ FixedTimeStepping::FixedTimeStepping(
     if (t_curr <= _t_end)
     {
         auto const delta_t = std::get<1>(repeat_dt_pairs.back());
-        auto const repeat =
-            static_cast<std::size_t>(std::ceil((_t_end - t_curr) / delta_t));
+        auto const repeat = static_cast<std::size_t>(
+            std::ceil((_t_end() - t_curr()) / delta_t));
         addTimeIncrement(_dt_vector, repeat, delta_t, t_curr);
     }
 
@@ -210,16 +217,15 @@ std::tuple<bool, double> FixedTimeStepping::next(
 {
     // check if last time step
     if (ts_current.timeStepNumber() == _dt_vector.size() ||
-        std::abs(ts_current.current() - end()) <
-            std::numeric_limits<double>::epsilon())
+        ts_current.current() >= end())
     {
-        return std::make_tuple(false, 0.0);
+        return std::make_tuple(true, 0.0);
     }
 
     double dt = _dt_vector[ts_current.timeStepNumber()];
     if (ts_current.current() + dt > end())
     {  // upper bound by t_end
-        dt = end() - ts_current.current();
+        dt = end()() - ts_current.current()();
     }
 
     return std::make_tuple(true, dt);

NumLib/TimeStepping/Algorithms/FixedTimeStepping.h

@@ -64,7 +64,7 @@ class FixedTimeStepping final : public TimeStepAlgorithm
     std::vector<double> _dt_vector;
 };
 
-std::size_t findDeltatInterval(double const t_initial,
+std::size_t findDeltatInterval(Time const& t_initial,
                                std::vector<double> const& delta_ts,
-                               double const fixed_output_time);
+                               Time const& fixed_output_time);
 }  // namespace NumLib

NumLib/TimeStepping/Algorithms/IterationNumberBasedTimeStepping.cpp

@@ -147,19 +147,19 @@ double IterationNumberBasedTimeStepping::getNextTimeStepSize(
     auto fixed_output_time_it = std::find_if(
         std::begin(_fixed_times_for_output), std::end(_fixed_times_for_output),
         [&ts_current](auto const fixed_output_time)
-        { return ts_current.current() < fixed_output_time; });
+        { return ts_current.current()() < fixed_output_time; });
 
     if (fixed_output_time_it != _fixed_times_for_output.end())
     {
         // check if the fixed output time is in the interval
         // (current time, current time + dt)
-        if (*fixed_output_time_it < ts_current.current() + dt)
+        if (*fixed_output_time_it < ts_current.current()() + dt)
         {
             // check if the potential adjusted time step is larger than zero
-            if (std::abs(*fixed_output_time_it - ts_current.current()) >
-                std::numeric_limits<double>::epsilon() * ts_current.current())
+            if (std::abs(*fixed_output_time_it - ts_current.current()()) >
+                std::numeric_limits<double>::epsilon() * ts_current.current()())
             {
-                return *fixed_output_time_it - ts_current.current();
+                return *fixed_output_time_it - ts_current.current()();
             }
         }
     }

NumLib/TimeStepping/Algorithms/TimeStepAlgorithm.cpp

@@ -12,24 +12,25 @@
 #include <algorithm>
 #include <limits>
 
+#include "NumLib/TimeStepping/Time.h"
+
 namespace NumLib
 {
 double possiblyClampDtToNextFixedTime(
-    double const t, double const dt,
+    Time const& t, double const dt,
     std::vector<double> const& fixed_output_times)
 {
     auto const specific_time = std::upper_bound(
-        std::cbegin(fixed_output_times), std::cend(fixed_output_times), t);
+        std::cbegin(fixed_output_times), std::cend(fixed_output_times), t());
 
     if (specific_time == std::cend(fixed_output_times))
     {
         return dt;
     }
 
-    double const t_to_specific_time = *specific_time - t;
-    if ((t_to_specific_time > std::numeric_limits<double>::epsilon()) &&
-        (t + dt - *specific_time > 0.0))
+    if ((t < Time(*specific_time)) && t + dt > Time(*specific_time))
     {
+        double const t_to_specific_time = *specific_time - t();
         return t_to_specific_time;
     }
 

NumLib/TimeStepping/Algorithms/TimeStepAlgorithm.h

@@ -21,6 +21,8 @@
 
 namespace NumLib
 {
+struct Time;
+
 /**
  * \brief Interface of time stepping algorithms
  */
@@ -35,9 +37,9 @@ class TimeStepAlgorithm
     virtual ~TimeStepAlgorithm() = default;
 
     /// return the beginning of time steps
-    double begin() const { return _t_initial; }
+    Time begin() const { return _t_initial; }
     /// return the end of time steps
-    double end() const { return _t_end; }
+    Time end() const { return _t_end; }
     /// reset the current step size from the previous time
     virtual void resetCurrentTimeStep(const double /*dt*/,
                                       TimeStep& /*ts_previous*/,
@@ -73,9 +75,9 @@ class TimeStepAlgorithm
 
 protected:
     /// initial time
-    const double _t_initial;
+    const Time _t_initial;
     /// end time
-    const double _t_end;
+    const Time _t_end;
 };
 
 /// If any of the fixed times will be reached with given time increment, it will
@@ -85,7 +87,7 @@ class TimeStepAlgorithm
 /// \param dt Suggested time increment.
 /// \param fixed_output_times Sorted list of times which are to be reached.
 double possiblyClampDtToNextFixedTime(
-    double const t, double const dt,
+    Time const& t, double const dt,
     std::vector<double> const& fixed_output_times);
 
 bool canReduceTimestepSize(TimeStep const& timestep_previous,