NumLib::FixedTimeStepping Class Reference

Detailed Description

Fixed time stepping algorithm.

This algorithm returns time step size defined by a user priori.

If the prescribed time step sizes are used up before the end time is reached—which happens if the steps actually taken are smaller than the prescribed ones, as in the staggered coupling scheme—the last prescribed time step size taken by the scheme is repeated until the end time.

Definition at line 25 of file FixedTimeStepping.h.

#include <FixedTimeStepping.h>

Inheritance diagram for NumLib::FixedTimeStepping:

Collaboration diagram for NumLib::FixedTimeStepping:

Public Member Functions
	FixedTimeStepping (double t0, double t_end, double dt)
	FixedTimeStepping (double t0, double tn, std::vector< RepeatDtPair > const &repeat_dt_pairs, std::vector< double > const &fixed_times_for_output)
double	next (double solution_error, int number_iterations, NumLib::TimeStep &ts_previous, NumLib::TimeStep &ts_current) override
Public Member Functions inherited from NumLib::TimeStepAlgorithm
	TimeStepAlgorithm (const double t0, const double t_end)
virtual	~TimeStepAlgorithm ()=default
Time	begin () const
	return the beginning of time steps
Time	end () const
	return the end of time steps
virtual bool	isSolutionErrorComputationNeeded () const
virtual bool	canReduceTimestepSize (NumLib::TimeStep const &, NumLib::TimeStep const &) const
	Query the timestepper if further time step size reduction is possible.

Static Public Member Functions
static bool	areRepeatDtPairsValid (std::vector< RepeatDtPair > const &repeat_dt_pairs)

Private Attributes
std::vector< double >	dt_vector_
	a vector of time step sizes
double	last_prescribed_dt_ = 0.0
bool	reuse_of_last_dt_reported_ = false

Additional Inherited Members
Protected Attributes inherited from NumLib::TimeStepAlgorithm
const Time	_t_initial
	initial time
const Time	_t_end
	end time

Constructor & Destructor Documentation

FixedTimeStepping() [1/2]

NumLib::FixedTimeStepping::FixedTimeStepping	(	double	t0,
		double	t_end,
		double	dt )

Constructor with homogeneous time step size

A user provides a single time step size \(\Delta t\). Total number of time steps is calculated by

\[ n=\frac{t_{\rm n} - t_0}{\Delta t} \]

.

Precondition

t_end is larger than t0 and dt is positive; both are required for a non-empty sequence of time steps and are checked with OGS_FATAL.

Parameters

t0	start time
t_end	end time
dt	uniform time step size

Definition at line 204 of file FixedTimeStepping.cpp.

    : TimeStepAlgorithm(t0, t_end), last_prescribed_dt_(dt)
{
    // Checked before the cast below, which is undefined for a negative value.
    if (Time(t_end) <= Time(t0) || dt <= 0.0)
    {
        OGS_FATAL(
            "FixedTimeStepping: No time steps can be generated for the time "
            "interval [{}, {}] with the time step size {:g}. The end time must "
            "be larger than the start time and the time step size must be "
            "positive.",
            t0, t_end, dt);
    }
 
    auto const new_size =
        static_cast<std::size_t>(std::ceil((t_end - t0) / dt));
    try
    {
        dt_vector_ = std::vector<double>(new_size, dt);
    }
    catch (std::length_error const& e)
    {
        OGS_FATAL(
            "Resize of the time steps vector failed for the requested new "
            "size {}. Probably there is not enough memory ({:g} GiB "
            "requested).\n"
            "Thrown exception: {}",
            new_size, new_size * sizeof(double) / 1024. / 1024. / 1024.,
            e.what());
    }
    catch (std::bad_alloc const& e)
    {
        OGS_FATAL(
            "Allocation of the time steps vector failed for the requested "
            "size {}. Probably there is not enough memory ({:g} GiB "
            "requested).\n"
            "Thrown exception: {}",
            new_size,
            new_size * sizeof(double) / 1024. / 1024. / 1024.,
            e.what());
    }
}

References NumLib::TimeStepAlgorithm::TimeStepAlgorithm(), dt_vector_, last_prescribed_dt_, and OGS_FATAL.

FixedTimeStepping() [2/2]

NumLib::FixedTimeStepping::FixedTimeStepping	(	double	t0,
		double	tn,
		std::vector< RepeatDtPair > const &	repeat_dt_pairs,
		std::vector< double > const &	fixed_times_for_output )

Constructor with user-specified time step sizes including additional time steps for output.

Precondition

tn is larger than t0 and repeat_dt_pairs is valid in the sense of areRepeatDtPairsValid(), i.e. non-empty with positive delta_t and non-zero repeat entries; both are required for a non-empty sequence of time steps and are checked with OGS_FATAL.

Parameters

t0	start time
tn	end time
repeat_dt_pairs	pairs of the number of repetitions and the time step size
fixed_times_for_output	times at which output is requested; the time step containing such a time is split at it

Definition at line 143 of file FixedTimeStepping.cpp.

    : TimeStepAlgorithm(t0, tn)
{
    Time t_curr = _t_initial;
 
    if (Time(tn) <= Time(t0))
    {
        OGS_FATAL(
            "FixedTimeStepping: No time steps can be generated for the time "
            "interval [{}, {}]. The end time must be larger than the start "
            "time.",
            t0, tn);
    }
 
    if (!areRepeatDtPairsValid(repeat_dt_pairs))
    {
        OGS_FATAL("FixedTimeStepping: Couldn't construct object from data");
    }
 
    for (auto const& [repeat, delta_t] : repeat_dt_pairs)
    {
        if (t_curr <= _t_end)
        {
            t_curr = addTimeIncrement(dt_vector_, repeat, delta_t, t_curr);
            last_prescribed_dt_ = delta_t;
        }
    }
 
    // append last delta_t until t_end is reached
    if (t_curr <= _t_end)
    {
        auto const repeat = static_cast<std::size_t>(
            std::ceil((_t_end() - t_curr()) / last_prescribed_dt_));
        addTimeIncrement(dt_vector_, repeat, last_prescribed_dt_, t_curr);
    }
 
    // The non-empty interval and areRepeatDtPairsValid(), which guarantees at
    // least one pair with <repeat> >= 1 and <delta_t> > 0, imply that the loop
    // above has appended at least one step size and has set
    // last_prescribed_dt_.
    if (dt_vector_.empty())
    {
        OGS_FATAL(
            "FixedTimeStepping: No time steps were generated for the time "
            "interval [{}, {}].",
            t0, tn);
    }
    if (last_prescribed_dt_ <= 0.0)
    {
        OGS_FATAL(
            "FixedTimeStepping: The last prescribed time step size is {:g}, "
            "but must be positive.",
            last_prescribed_dt_);
    }
 
    incorporateFixedTimesForOutput(_t_initial, _t_end, dt_vector_,
                                   fixed_times_for_output);
}

References NumLib::TimeStepAlgorithm::TimeStepAlgorithm(), NumLib::TimeStepAlgorithm::_t_end, NumLib::TimeStepAlgorithm::_t_initial, areRepeatDtPairsValid(), dt_vector_, NumLib::incorporateFixedTimesForOutput(), last_prescribed_dt_, and OGS_FATAL.

Member Function Documentation

areRepeatDtPairsValid()

bool NumLib::FixedTimeStepping::areRepeatDtPairsValid ( std::vector< RepeatDtPair > const & repeat_dt_pairs )

static

Definition at line 292 of file FixedTimeStepping.cpp.

{
    if (repeat_dt_pairs.empty())
    {
        return false;
    }
 
    for (auto const& [repeat, delta_t] : repeat_dt_pairs)
    {
        if (repeat == 0)
        {
            ERR("FixedTimeStepping: <repeat> is zero.");
            return false;
        }
        if (delta_t <= 0.0)
        {
            ERR("FixedTimeStepping: timestep <delta_t> is <= 0.0.");
            return false;
        }
    }
    return true;
}

References ERR().

Referenced by FixedTimeStepping(), and NumLib::createFixedTimeStepping().

next()

double NumLib::FixedTimeStepping::next ( double solution_error, int number_iterations, NumLib::TimeStep & ts_previous, NumLib::TimeStep & ts_current )

overridevirtual

Move to the next time step

Parameters

solution_error	Solution error \(e_n\) between two successive time steps.
number_iterations	Number of non-linear iterations used.
ts_previous	the previous time step used to compute the size of the next step
ts_current	the current time step used to compute the size of the next step

Returns

the computed step size.

Implements NumLib::TimeStepAlgorithm.

Definition at line 247 of file FixedTimeStepping.cpp.

{
    // check if last time step
    if (ts_current.current() >= end())
    {
        return 0.0;
    }
 
    // The prescribed step sizes can be used up before t_end is reached if the
    // steps actually taken are smaller than the prescribed ones. This is the
    // case in the staggered coupling scheme, where all processes advance with
    // the minimum of the step sizes of all processes, but each process consumes
    // one of its own prescribed step sizes per time step. The last prescribed
    // step size is repeated then, such that this process does not restrict the
    // step size of the other processes any more.
    if (ts_current.timeStepNumber() >= dt_vector_.size())
    {
        if (!reuse_of_last_dt_reported_)
        {
            reuse_of_last_dt_reported_ = true;
            WARN(
                "FixedTimeStepping: All {:d} time step sizes of the fixed time "
                "stepping scheme are used up at time {} before the end time "
                "{} is reached. The last prescribed time step size of {:g} "
                "will be repeated until the end time. Please check whether the "
                "prescribed number of time steps is large enough for the "
                "number of time steps that are actually taken.",
                dt_vector_.size(), ts_current.current()(), end()(),
                last_prescribed_dt_);
        }
        return std::min(last_prescribed_dt_, end()() - ts_current.current()());
    }
 
    double dt = dt_vector_[ts_current.timeStepNumber()];
    if (ts_current.current() + dt > end())
    {  // upper bound by t_end
        dt = end()() - ts_current.current()();
    }
 
    return dt;
}

References NumLib::TimeStep::current(), dt_vector_, NumLib::TimeStepAlgorithm::end(), last_prescribed_dt_, reuse_of_last_dt_reported_, NumLib::TimeStep::timeStepNumber(), and WARN().

Member Data Documentation

dt_vector_

std::vector<double> NumLib::FixedTimeStepping::dt_vector_

private

a vector of time step sizes

Definition at line 76 of file FixedTimeStepping.h.

Referenced by FixedTimeStepping(), FixedTimeStepping(), and next().

last_prescribed_dt_

double NumLib::FixedTimeStepping::last_prescribed_dt_ = 0.0

private

The size of the last time step the scheme takes as prescribed by the user. Kept separately from dt_vector_ because the latter's last entry is not necessarily a prescribed size: incorporateFixedTimesForOutput() splits the interval containing a fixed output time into two smaller ones. It is not the last (repeat, delta_t) pair's size either, because pairs whose steps start beyond the end time are not part of the scheme.

Definition at line 84 of file FixedTimeStepping.h.

Referenced by FixedTimeStepping(), FixedTimeStepping(), and next().

reuse_of_last_dt_reported_

bool NumLib::FixedTimeStepping::reuse_of_last_dt_reported_ = false

private

set if it has already been reported that the prescribed time step sizes are used up and the last one is repeated, in order to report it once only.

Definition at line 89 of file FixedTimeStepping.h.

Referenced by next().

---

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

• FixedTimeStepping.h
• FixedTimeStepping.cpp