NumLib::FixedTimeStepping Class Reference

Detailed Description

Fixed time stepping algorithm.

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

Definition at line 27 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< std::pair< std::size_t, double > > 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
void	resetCurrentTimeStep (const double dt, TimeStep &, TimeStep &) override
	reset the current step size from the previous time
Public Member Functions inherited from NumLib::TimeStepAlgorithm
	TimeStepAlgorithm (const double t0, const double t_end)
virtual	~TimeStepAlgorithm ()=default
double	begin () const
	return the beginning of time steps
double	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.

Private Attributes
std::vector< double >	_dt_vector
	a vector of time step sizes

Additional Inherited Members
Protected Attributes inherited from NumLib::TimeStepAlgorithm
const double	_t_initial
	initial time
const double	_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 181 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< std::pair< std::size_t, double > > 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 143 of file FixedTimeStepping.cpp.

    : TimeStepAlgorithm(t0, tn)
{
    double t_curr = _t_initial;
 
    for (auto const& [repeat, delta_t] : repeat_dt_pairs)
    {
        if (repeat == 0)
        {
            OGS_FATAL("<repeat> is zero.");
        }
        if (delta_t <= 0.0)
        {
            OGS_FATAL("timestep <delta_t> is <= 0.0.");
        }
 
        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 = repeat_dt_pairs.back().second;
        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, NumLib::incorporateFixedTimesForOutput(), and OGS_FATAL.

Member Function Documentation

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 213 of file FixedTimeStepping.cpp.

{
    // check if last time step
    if (ts_current.timeStepNumber() == _dt_vector.size() ||
        std::abs(ts_current.current() - end()) <
            std::numeric_limits<double>::epsilon())
    {
        return std::make_tuple(false, 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().

resetCurrentTimeStep()

void NumLib::FixedTimeStepping::resetCurrentTimeStep ( const double dt, TimeStep & , TimeStep &  )

inlineoverridevirtual

reset the current step size from the previous time

Reimplemented from NumLib::TimeStepAlgorithm.

Definition at line 59 of file FixedTimeStepping.h.

    {
        _dt_vector.push_back(dt);
    }

References _dt_vector.

Member Data Documentation

_dt_vector

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

private

a vector of time step sizes

Definition at line 67 of file FixedTimeStepping.h.

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

---

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

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