NumLib::FixedTimeStepping Class Reference

Detailed Description

Fixed time stepping algorithm.

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

Definition at line 29 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)
std::tuple< bool, 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 void	resetCurrentTimeStep (const double, TimeStep &, TimeStep &)
	reset the current step size from the previous time
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

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}$$

.

Parameters

t0	start time
t_end	end time
dt	uniform time step size

Definition at line 184 of file FixedTimeStepping.cpp.

    : TimeStepAlgorithm(t0, t_end)
{
    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 _dt_vector, 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.

Definition at line 152 of file FixedTimeStepping.cpp.

    : TimeStepAlgorithm(t0, tn)
{
    Time t_curr = _t_initial;
 
    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);
        }
    }
 
    // append last delta_t until t_end is reached
    if (t_curr <= _t_end)
    {
        auto const delta_t = std::get<1>(repeat_dt_pairs.back());
        auto const repeat = static_cast<std::size_t>(
            std::ceil((_t_end() - t_curr()) / delta_t));
        addTimeIncrement(_dt_vector, repeat, delta_t, t_curr);
    }
 
    incorporateFixedTimesForOutput(_t_initial, _t_end, _dt_vector,
                                   fixed_times_for_output);
}

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

Member Function Documentation

areRepeatDtPairsValid()

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

static

Definition at line 236 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()

std::tuple< bool, 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

A step acceptance flag and the computed step size.

Implements NumLib::TimeStepAlgorithm.

Definition at line 216 of file FixedTimeStepping.cpp.

{
    // check if last time step
    if (ts_current.timeStepNumber() == _dt_vector.size() ||
        ts_current.current() >= end())
    {
        return std::make_tuple(true, 0.0);
    }
 
    double dt = _dt_vector[ts_current.timeStepNumber()];
    if (ts_current.current() + dt > end())
    {  // upper bound by t_end
        dt = end()() - ts_current.current()();
    }
 
    return std::make_tuple(true, dt);
}

References _dt_vector, NumLib::TimeStep::current(), NumLib::TimeStepAlgorithm::end(), and NumLib::TimeStep::timeStepNumber().

Member Data Documentation

_dt_vector

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

private

a vector of time step sizes

Definition at line 64 of file FixedTimeStepping.h.

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

---

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

• NumLib/TimeStepping/Algorithms/FixedTimeStepping.h
• NumLib/TimeStepping/Algorithms/FixedTimeStepping.cpp