clock.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2018
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */

#ifndef SRC_INCLUDE_CLOCK_H_
#define SRC_INCLUDE_CLOCK_H_

#include <cmath>
#include <cstdint>
#include <cstdio>
#include <limits>
#include <stdexcept>

#include "logging.h"

namespace smash {

class Clock {
  static constexpr double resolution = 0.000001;

 public:
  using Representation = std::int64_t;

 public:
  Clock() = default;
  Clock(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 {
    return convert(reset_time_ + timestep_duration_ * counter_);
  }
  double next_time() const {
    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 { 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);
  }
  bool multiple_is_in_next_tick(const double interval) const {
    if (interval < 0.) {
      throw std::range_error("Negative interval makes no sense for clock");
    }
    const Representation int_interval = convert(interval);
    // if the interval is less than or equal to the time step size, one
    // multiple will surely be within the next tick!
    if (int_interval <= timestep_duration_) {
      return true;
    }
    const auto next = reset_time_ + timestep_duration_ * counter_;
    if (unlikely(next < 0)) {
      return -next % int_interval < timestep_duration_;
    }
    return (timestep_duration_ - 1 + next) % int_interval < timestep_duration_;
  }
  double next_multiple(const double interval) const {
    const Representation int_interval = convert(interval);
    const auto current = reset_time_ + timestep_duration_ * counter_;
    if (unlikely(current < 0)) {
      return convert(current / int_interval * int_interval);
    }
    return convert((current / int_interval + 1) * int_interval);
  }
  void end_tick_on_multiple(const double interval) {
    const Representation int_interval = convert(interval);
    const auto current = reset_time_ + timestep_duration_ * counter_;
    reset_time_ = current;
    counter_ = 0;
    if (unlikely(current < 0)) {
      timestep_duration_ = current / int_interval * int_interval - current;
    } else {
      timestep_duration_ =
          (current / int_interval + 1) * int_interval - current;
    }
  }
  void reset(const double reset_time) {
    if (reset_time < current_time()) {
      logger<LogArea::Clock>().debug("Resetting clock from", current_time(),
                                     " fm/c to ", reset_time, " fm/c");
    }
    reset_time_ = convert(reset_time);
    counter_ = 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;
  }
  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;
  }
  bool operator<(const Clock& rhs) const {
    return (reset_time_ + timestep_duration_ * counter_) <
           (rhs.reset_time_ + rhs.timestep_duration_ * rhs.counter_);
  }
  bool operator<(double time) const { return current_time() < time; }
  bool operator>(double time) const { return current_time() > time; }

 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 counter_ = 0;
  Representation timestep_duration_ = 0u;
  Representation reset_time_ = 0;
};

}  // namespace smash

#endif  // SRC_INCLUDE_CLOCK_H_