#include <clock.h>

Clock with uniformly spaced time steps.

Internals

Clock stores a time step size \(\Delta t\) and a base time \(t_0\) as well as a counter \(n\). The current time is calculated from \(t = t_0 + n \cdot \Delta t\). When \(\Delta t\) is changed, \(t_0\) is reset.

Definition at line 175 of file clock.h.

Inheritance diagram for smash::UniformClock:

Public Member Functions
	UniformClock ()=default
	default initializer: Timestep size is set to 0! More...

	UniformClock (const double time, const double dt, const double time_end)
	Initialize with base time and time step size. More...

double	current_time () const override

double	next_time () const override

double	timestep_duration () const override

void	set_timestep_duration (const double dt)
	Sets the time step size (and resets the counter). More...

void	reset (const double start_time, const bool is_output_clock) override
	Resets the time to the starting time of an event. More...

void	remove_times_in_past (double) override
	Remove output times before the starting time of the simulation if this is a custom clock. More...

template<typename T >
std::enable_if< std::is_floating_point< T >::value, Clock & >::type	operator+= (T big_timestep)
	Advances the clock by an arbitrary timestep (multiple of 0.000001 fm). More...

Clock &	operator+= (Representation advance_several_timesteps)
	advances the clock by an arbitrary number of ticks. More...

Public Member Functions inherited from smash::Clock
Clock &	operator++ ()
	Advances the clock by one tick. More...

Clock &	operator+= (Representation advance_several_timesteps)
	Advances the clock by an arbitrary number of ticks. More...

bool	operator< (const Clock &rhs) const
	Compares the times between two clocks. More...

bool	operator< (double time) const
	Compares the time of the clock against a fixed time. More...

bool	operator> (double time) const
	Compares the time of the clock against a fixed time. More...

virtual	~Clock ()=default

Static Private Member Functions
static Representation	convert (double x)
	Convert a double `x` into the internal int representation. More...

static double	convert (Representation x)
	Convert an internal int value `x` into the double representation. More...

Private Attributes
Representation	timestep_duration_ = 0u
	The time step size \(\Delta t\) in \(10^{-6}\,\mathrm{fm}\). More...

Representation	reset_time_ = 0
	The time of last reset (when counter_ was set to 0). More...

Representation	time_end_ = 0
	The end time of the particle propagation. More...

Static Private Attributes
static constexpr double	resolution = 0.000001
	Defines the resolution of the clock (i.e. More...

static constexpr double	to_double = resolution
	A multiplier transfering the internal integer to the real time. More...

static constexpr double	from_double = 1. / resolution
	A multiplier transfering the real time to the internal integer. More...

Additional Inherited Members
Public Types inherited from smash::Clock
using	Representation = std::int64_t
	The type used for counting ticks/time. More...

Protected Attributes inherited from smash::Clock
Representation	counter_ = 0
	Internally used to count the number of time steps. More...

Constructor & Destructor Documentation

◆ UniformClock() [1/2]

smash::UniformClock::UniformClock ( )

default

default initializer: Timestep size is set to 0!

◆ UniformClock() [2/2]

smash::UniformClock::UniformClock	(	const double	time,
		const double	dt,
		const double	time_end
	)

inline

Initialize with base time and time step size.

Parameters

[in]	time	base time
[in]	dt	step size
[in]	time_end	end time of particle propagation

Definition at line 200 of file clock.h.

       : timestep_duration_(convert(dt)),
         reset_time_(convert(time)),
         time_end_(convert(time_end)) {
     if (dt < 0.) {
       throw std::range_error("No negative time increment allowed");
     }
   }

Member Function Documentation

◆ current_time()

double smash::UniformClock::current_time ( ) const

inlineoverridevirtual

Returns: the current time.

Implements smash::Clock.

Definition at line 209 of file clock.h.

                                        {
     if ((reset_time_ + timestep_duration_ * counter_) > time_end_) {
       return convert(time_end_);
     } else {
       return convert(reset_time_ + timestep_duration_ * counter_);
     }
   }

◆ next_time()

double smash::UniformClock::next_time ( ) const

inlineoverridevirtual

Returns: the time in the next tick.

This function is needed, because current_time() + timestep_duration() is not the same as the next tick (numerically; this is due to floating point arithmetic).

Implements smash::Clock.

Definition at line 223 of file clock.h.

                                     {
     if (counter_ * timestep_duration_ >=
         std::numeric_limits<Representation>::max() - timestep_duration_) {
       throw std::overflow_error("Too many timesteps, clock overflow imminent");
     }
     if ((reset_time_ + timestep_duration_ * (counter_ + 1)) > time_end_) {
       return convert(time_end_);
     } else {
       return convert(reset_time_ + timestep_duration_ * (counter_ + 1));
     }
   }

◆ timestep_duration()

double smash::UniformClock::timestep_duration ( ) const

inlineoverridevirtual

Returns: the time step size.

Implements smash::Clock.

Definition at line 235 of file clock.h.

                                             {
     if ((reset_time_ + timestep_duration_ * (counter_ + 1)) > time_end_) {
       Representation last_timestep =
           time_end_ - (reset_time_ + timestep_duration_ * counter_);
       return convert(last_timestep);
     } else {
       return convert(timestep_duration_);
     }
   }

◆ set_timestep_duration()

void smash::UniformClock::set_timestep_duration ( const double dt )

inline

Sets the time step size (and resets the counter).

Parameters

[in] dt new time step size

Definition at line 249 of file clock.h.

                                               {
     if (dt < 0.) {
       throw std::range_error("No negative time increment allowed");
     }
     reset_time_ += timestep_duration_ * counter_;
     counter_ = 0;
     timestep_duration_ = convert(dt);
   }

◆ reset()

void smash::UniformClock::reset	(	const double	start_time,
		const bool	is_output_clock
	)

inlineoverridevirtual

Resets the time to the starting time of an event.

Parameters

[in]	start_time	Starting time of the simulation
[in]	is_output_clock	whether this is an output clock or a lab clock

Implements smash::Clock.

Definition at line 264 of file clock.h.

                                                                            {
     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 to ",
                          reset_time, " fm");
     }
     reset_time_ = convert(reset_time);
     counter_ = 0;
   }

◆ remove_times_in_past()

void smash::UniformClock::remove_times_in_past ( double start_time )

inlineoverridevirtual

Remove output times before the starting time of the simulation if this is a custom clock.

Parameters

[in] start_time starting time of the simulation

Implements smash::Clock.

Definition at line 280 of file clock.h.

280 {};

◆ operator+=() [1/2]

template<typename T >

std::enable_if<std::is_floating_point<T>::value, Clock&>::type smash::UniformClock::operator+= ( T big_timestep )

inline

Advances the clock by an arbitrary timestep (multiple of 0.000001 fm).

Template Parameters

T	type of the timestep

Parameters

[in] big_timestep Timestep by which the clock is advanced.

Note: It uses a template parameter only for disambiguation with the overload below.

Definition at line 292 of file clock.h.

                              {
     if (big_timestep < 0.) {
       throw std::range_error("The clock cannot be turned back.");
     }
     reset_time_ += convert(big_timestep);
     return *this;
   }

◆ operator+=() [2/2]

Clock& smash::UniformClock::operator+= ( Representation advance_several_timesteps )

inline

advances the clock by an arbitrary number of ticks.

Parameters

[in] advance_several_timesteps Number of the timesteps added to the clock

Exceptions

OverflowError if the number of the added timesteps exceeds the maximum value.

Definition at line 307 of file clock.h.

                                                               {
     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;
   }

◆ convert() [1/2]

static Representation smash::UniformClock::convert ( double x )

inlinestaticprivate

Convert a double x into the internal int representation.

Definition at line 323 of file clock.h.

                                           {
     return std::round(x * from_double);
   }

◆ convert() [2/2]

static double smash::UniformClock::convert ( Representation x )

inlinestaticprivate

Convert an internal int value x into the double representation.

Definition at line 327 of file clock.h.

327 { return x * to_double; }

smash::UniformClock::to_double

static constexpr double to_double

A multiplier transfering the internal integer to the real time.

Definition: clock.h:318

Member Data Documentation

◆ resolution

constexpr double smash::UniformClock::resolution = 0.000001

staticconstexprprivate

Defines the resolution of the clock (i.e.

the smallest representable time difference).

The value 0.000001 is very well suited because

It should be \(10^{-n},\;n\in\mathbb{N}\). That's because we want to use it to convert user input/output and that's in decimal representation.
The floating-point representation of the constant should have a small error. 0.000001 has the smallest error (i.e. 0.022 ulp) in the range \(1\leq n \leq 10\). The small error helps to convert the internal integer representation as precise as possible to floating-point.

Definition at line 188 of file clock.h.

◆ to_double

constexpr double smash::UniformClock::to_double = resolution

staticconstexprprivate

A multiplier transfering the internal integer to the real time.

Definition at line 318 of file clock.h.

◆ from_double

constexpr double smash::UniformClock::from_double = 1. / resolution

staticconstexprprivate

A multiplier transfering the real time to the internal integer.

Definition at line 320 of file clock.h.

◆ timestep_duration_

Representation smash::UniformClock::timestep_duration_ = 0u

private

The time step size \(\Delta t\) in \(10^{-6}\,\mathrm{fm}\).

Definition at line 330 of file clock.h.

◆ reset_time_

Representation smash::UniformClock::reset_time_ = 0

private

The time of last reset (when counter_ was set to 0).

Definition at line 332 of file clock.h.

◆ time_end_

Representation smash::UniformClock::time_end_ = 0

private

The end time of the particle propagation.

Definition at line 334 of file clock.h.

The documentation for this class was generated from the following file:

src/include/smash/clock.h

Internals

Public Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ UniformClock() [1/2]

◆ UniformClock() [2/2]

Member Function Documentation

◆ current_time()

◆ next_time()

◆ timestep_duration()

◆ set_timestep_duration()

◆ reset()

◆ remove_times_in_past()

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ convert() [1/2]

◆ convert() [2/2]

Member Data Documentation

◆ resolution

◆ to_double

◆ from_double

◆ timestep_duration_

◆ reset_time_

◆ time_end_