clock.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2020,2022-2024
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_CLOCK_H_
#define SRC_INCLUDE_SMASH_CLOCK_H_
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <limits>
#include <stdexcept>
#include <vector>
 
#include "logging.h"
#include "numeric_cast.h"
 
namespace smash {
 
static constexpr int LClock = LogArea::Clock::id;
 
class Clock {
 public:
  using Representation = std::int64_t;
  virtual double timestep_duration() const = 0;
  virtual double current_time() const = 0;
  virtual double next_time() const = 0;
  virtual void reset(double start_time, bool is_output_clock) = 0;
  virtual void remove_times_in_past(double start_time) = 0;
  Clock& operator++() {
    // guard against overflow:
    if (counter_ >= std::numeric_limits<Representation>::max() - 1) {
      throw std::overflow_error("Too many timesteps, clock overflow imminent");
    }
    ++counter_;
    return *this;
  }
 
  Clock& operator+=(Representation advance_several_timesteps) {
    if (counter_ >= std::numeric_limits<Representation>::max() -
                        advance_several_timesteps) {
      throw std::overflow_error("Too many timesteps, clock overflow imminent");
    }
    counter_ += advance_several_timesteps;
    return *this;
  }
 
  bool operator<(const Clock& rhs) const {
    return present_internal_time() < rhs.present_internal_time();
  }
 
  bool operator<(double time) const { return present_internal_time() < time; }
 
  bool operator>(double time) const { return present_internal_time() > time; }
 
  virtual ~Clock() = default;
 
 protected:
  virtual double present_internal_time() const = 0;
  Representation counter_ = 0;
};
 
class UniformClock : public Clock {
  static constexpr double resolution = 0.000001;
 
 public:
  UniformClock() = default;
  UniformClock(double time, double dt, double time_end)
      : timestep_duration_(convert(dt)),
        reset_time_(convert(time)),
        time_end_(convert(time_end)) {
    if (dt <= 0.) {
      throw std::range_error("Time increment must be positive and non-zero");
    }
    if (reset_time_ >= time_end_) {
      throw std::range_error(
          "The initial time of UniformClock must be smaller than the end time. "
          "(Attempt to set initial time to " +
          std::to_string(time) + " and end time to " +
          std::to_string(time_end) + " not possible)");
    }
  }
  double current_time() const override {
    auto present_time = present_internal_time();
    // Do comparison in internal representation unit and return converted values
    if (convert(present_time) > time_end_) {
      return convert(time_end_);
    } else {
      return present_time;
    }
  }
  double next_time() const override {
    if (counter_ * timestep_duration_ >=
        std::numeric_limits<Representation>::max() - timestep_duration_) {
      throw std::overflow_error("Too many timesteps, clock overflow imminent");
    }
    auto next_point_in_time = reset_time_ + timestep_duration_ * (counter_ + 1);
    if (next_point_in_time > time_end_) {
      return convert(time_end_);
    } else {
      return convert(next_point_in_time);
    }
  }
 
  double timestep_duration() const override {
    auto present_time = convert(present_internal_time());
    if (present_time > time_end_) {
      logg[LClock].warn() << "UniformClock asked for timestep duration beyond "
                             "end of simulation, returning 0.";
      return 0.0;
    } else if (present_time + timestep_duration_ > time_end_) {
      return convert(time_end_ - present_time);
    } else {
      return convert(timestep_duration_);
    }
  }
  void set_timestep_duration(double dt) {
    if (dt <= 0.) {
      throw std::range_error("Time increment must be positive and non-zero!");
    }
    reset_time_ += timestep_duration_ * counter_;
    counter_ = 0;
    timestep_duration_ = convert(dt);
  }
 
  void reset(double start_time, bool is_output_clock) override {
    double reset_time;
    if (is_output_clock) {
      auto delta_t = convert(timestep_duration_);
      reset_time = std::floor(start_time / delta_t) * delta_t;
    } else {
      reset_time = start_time;
    }
    if (reset_time < current_time()) {
      logg[LClock].debug("Resetting clock from", current_time(), " fm to ",
                         reset_time, " fm");
    }
    reset_time_ = convert(reset_time);
    counter_ = 0;
  }
 
  void remove_times_in_past(double) override{};
 
  template <typename T>
  typename std::enable_if<std::is_floating_point<T>::value, Clock&>::type
  operator+=(T big_timestep) {
    if (big_timestep < 0.) {
      throw std::range_error("The clock cannot be turned back.");
    }
    reset_time_ += convert(big_timestep);
    return *this;
  }
  Clock& operator+=(Representation advance_several_timesteps) {
    if (counter_ >= std::numeric_limits<Representation>::max() -
                        advance_several_timesteps) {
      throw std::overflow_error("Too many timesteps, clock overflow imminent");
    }
    counter_ += advance_several_timesteps;
    return *this;
  }
 
 protected:
  double present_internal_time() const override {
    return convert(reset_time_ + timestep_duration_ * counter_);
  }
 
 private:
  static constexpr double to_double = resolution;
  static constexpr double from_double = 1. / resolution;
 
  static Representation convert(double x) {
    return numeric_cast<Representation>(std::round(x * from_double));
  }
  static double convert(Representation x) { return x * to_double; }
 
  Representation timestep_duration_ = 0;
  Representation reset_time_ = 0;
  Representation time_end_ = 0;
};
 
class CustomClock : public Clock {
 public:
  explicit CustomClock(std::vector<double> times) : custom_times_(times) {
    std::sort(custom_times_.begin(), custom_times_.end());
    counter_ = -1;
  }
 
  double current_time() const override {
    if (counter_ == -1) {
      // current time before the first output should be the starting time
      return start_time_;
    } else if (counter_ < -1) {
      throw std::runtime_error(
          "Trying to access time of clock in invalid state.");
    } else {
      return custom_times_.at(counter_);
    }
  }
 
  double next_time() const override { return custom_times_.at(counter_ + 1); }
 
  double timestep_duration() const override {
    return next_time() - current_time();
  }
 
  void reset(double start_time, bool) override {
    counter_ = -1;
    start_time_ = start_time;
  }
 
  void remove_times_in_past(double start_time) override {
    custom_times_.erase(
        std::remove_if(custom_times_.begin(), custom_times_.end(),
                       [start_time](double t) {
                         if (t <= start_time) {
                           logg[LClock].warn("Removing custom output time ", t,
                                             " fm since it is earlier than the "
                                             "starting time of the simulation");
                           return true;
                         } else {
                           return false;
                         }
                       }),
        custom_times_.end());
  }
 
 protected:
  double present_internal_time() const override { return current_time(); }
 
 private:
  std::vector<double> custom_times_;
  double start_time_ = 0.;
};
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_CLOCK_H_