clock.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2020
 *      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"
 
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, const 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 current_time() < rhs.current_time();
  }
 
  bool operator<(double time) const { return current_time() < time; }
 
  bool operator>(double time) const { return current_time() > time; }
 
  virtual ~Clock() = default;
 
 protected:
  Representation counter_ = 0;
};
 
class UniformClock : public Clock {
  static constexpr double resolution = 0.000001;
 
 public:
  UniformClock() = default;
  UniformClock(const double time, const double dt)
      : timestep_duration_(convert(dt)), reset_time_(convert(time)) {
    if (dt < 0.) {
      throw std::range_error("No negative time increment allowed");
    }
  }
  double current_time() const override {
    return convert(reset_time_ + timestep_duration_ * counter_);
  }
  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");
    }
    return convert(reset_time_ + timestep_duration_ * (counter_ + 1));
  }
  double timestep_duration() const override {
    return convert(timestep_duration_);
  }
  void set_timestep_duration(const double dt) {
    if (dt < 0.) {
      throw std::range_error("No negative time increment allowed");
    }
    reset_time_ += timestep_duration_ * counter_;
    counter_ = 0;
    timestep_duration_ = convert(dt);
  }
 
  void reset(const double start_time, const bool is_output_clock) override {
    double reset_time;
    if (is_output_clock) {
      reset_time =
          std::floor(start_time / timestep_duration()) * timestep_duration();
    } else {
      reset_time = start_time;
    }
    if (reset_time < current_time()) {
      logg[LClock].debug("Resetting clock from", current_time(), " fm/c to ",
                         reset_time, " fm/c");
    }
    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;
  }
 
 private:
  static constexpr double to_double = resolution;
  static constexpr double from_double = 1. / resolution;
 
  static Representation convert(double x) {
    return std::round(x * from_double);
  }
  static double convert(Representation x) { return x * to_double; }
 
  Representation timestep_duration_ = 0u;
  Representation reset_time_ = 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 undefined zeroth output time");
    } else {
      return custom_times_[counter_];
    }
  }
  double next_time() const override { return custom_times_[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 {
    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;
                     }
                   });
  }
 
 private:
  std::vector<double> custom_times_;
  double start_time_ = 0.;
};
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_CLOCK_H_