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 <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <limits>
#include <stdexcept>

#include "logging.h"

namespace smash {

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()) {
      logger<LogArea::Clock>().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:
  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_ < 0) {
      throw std::runtime_error("Trying to access undefined zeroth output time");
    }
    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, bool) override { counter_ = -1; }

  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) {
            logger<LogArea::Clock>().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_;
};
}  // namespace smash

#endif  // SRC_INCLUDE_CLOCK_H_