Detailed Description

Iteration number based adaptive time stepping.

This algorithm estimates a time step size depending on the number of iterations (e.g. of iterative linear solvers, nonlinear methods, partitioned coupling) needed in the last time step (see Hoffmann (2010) for Newton-Raphson case). The new time step $\Delta t_{n+1}$ size is calculated as

$\Delta t_{n+1} = \alpha \Delta t_n$

with the previous time step size $\Delta t_{n}$ and a multiplier coefficient $\alpha$ depending on the iteration number. Note that a time step size is always bounded by the minimum and maximum allowed value.

$\Delta t_{\min} \le \Delta t \le \Delta t_{\max}$

For example, users can setup the following time stepping strategy based on the iteration number of the Newton-Raphson method in the last time step.

Num. of Newton steps	0-2	3-6	7-8	9<
Time step size multiplier	1.6	1.	0.5	0.25 (repeat time step)
Upper and lower bound	$1. \le \Delta t \le 10.$

A time step size is increased for the small iteration number, and decreased for the large iteration number. If the iteration number exceeds a user-defined threshold (e.g. 9), a time step is repeated with a smaller time step size.

Reference

Hoffmann J (2010) Reactive Transport and Mineral Dissolution/Precipitation in Porous Media:Efficient Solution Algorithms, Benchmark Computations and Existence of Global Solutions. PhD thesis. pp82. Friedrich-Alexander-Universität Erlangen-Nürnberg.

Definition at line 67 of file IterationNumberBasedTimeStepping.h.

#include <IterationNumberBasedTimeStepping.h>

Inheritance diagram for NumLib::IterationNumberBasedTimeStepping:

[legend]

Collaboration diagram for NumLib::IterationNumberBasedTimeStepping:

[legend]

Public Member Functions
	IterationNumberBasedTimeStepping (double const t_initial, double const t_end, double const min_dt, double const max_dt, double const initial_dt, MultiplyerInterpolationType const multiplier_interpolation_type, std::vector< int > &&iter_times_vector, std::vector< double > &&multiplier_vector, std::vector< double > const &fixed_times_for_output)

	~IterationNumberBasedTimeStepping () override=default

std::tuple< bool, double >	next (double solution_error, int number_iterations, NumLib::TimeStep &ts_previous, NumLib::TimeStep &ts_current) override

bool	isSolutionErrorComputationNeeded () const override

bool	canReduceTimestepSize (NumLib::TimeStep const &timestep_previous, NumLib::TimeStep const &timestep_current) const override
	Query the timestepper if further time step size reduction is possible.

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

Private Member Functions
double	getNextTimeStepSize (NumLib::TimeStep const &ts_previous, NumLib::TimeStep const &ts_current) const
	Calculate the next time step size.

double	findMultiplier (int const number_iterations, NumLib::TimeStep const &ts_current) const
	Find a multiplier for the given number of iterations.

Private Attributes
const std::vector< int >	_iter_times_vector

const std::vector< double >	_multiplier_vector
	This vector stores the multiplier coefficients.

const double	_min_dt
	The minimum allowed time step size.

const double	_max_dt
	The maximum allowed time step size.

const double	_initial_dt
	Initial time step size.

const MultiplyerInterpolationType	_multiplier_interpolation_type
	Interpolation type for the multiplier.

const int	_max_iter
	The maximum allowed iteration number to accept current time step.

int	_iter_times = 0
	The number of nonlinear iterations.

bool	_previous_time_step_accepted = true

std::vector< double > const	_fixed_times_for_output

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

const Time	_t_end
	end time

Constructor & Destructor Documentation

◆ IterationNumberBasedTimeStepping()

NumLib::IterationNumberBasedTimeStepping::IterationNumberBasedTimeStepping	(	double const	t_initial,
		double const	t_end,
		double const	min_dt,
		double const	max_dt,
		double const	initial_dt,
		MultiplyerInterpolationType const	multiplier_interpolation_type,
		std::vector< int > &&	iter_times_vector,
		std::vector< double > &&	multiplier_vector,
		std::vector< double > const &	fixed_times_for_output )

Parameters

t_initial	start time
t_end	end time
min_dt	the minimum allowed time step size
max_dt	the maximum allowed time step size
initial_dt	initial time step size
iter_times_vector	a vector of iteration numbers ( $i_1$ , $i_2$ , ..., $i_n$ ) which defines intervals as $[i_1,i_2)$ , $[i_2,i_3)$ , ..., $[i_n,\infty)$ . If an iteration number is larger than $i_n$ , current time step is repeated with the new time step size.
multiplier_vector	a vector of multiplier coefficients ( $a_1$ , $a_2$ , ..., $a_n$ ) corresponding to the intervals given by iter_times_vector. A time step size is calculated by $\Delta t_{n+1} = a * \Delta t_{n}$
fixed_times_for_output	a vector of fixed time points for output

Definition at line 27 of file IterationNumberBasedTimeStepping.cpp.

    : TimeStepAlgorithm(t_initial, t_end),
      _iter_times_vector(std::move(iter_times_vector)),
      _multiplier_vector(std::move(multiplier_vector)),
      _min_dt(min_dt),
      _max_dt(max_dt),
      _initial_dt(initial_dt),
      _multiplier_interpolation_type(multiplier_interpolation_type),
      _max_iter(_iter_times_vector.empty() ? 0 : _iter_times_vector.back()),
      _fixed_times_for_output(fixed_times_for_output)
{
    if (_iter_times_vector.empty())
    {
        OGS_FATAL("Vector of iteration numbers must not be empty.");
    }
    if (_iter_times_vector.size() != _multiplier_vector.size())
    {
        OGS_FATAL(
            "Vector of iteration numbers must be of the same size as the "
            "vector of multipliers.");
    }
    if (!std::is_sorted(std::begin(_iter_times_vector),
                        std::end(_iter_times_vector)))
    {
        OGS_FATAL("Vector of iteration numbers must be sorted.");
    }
}

References _iter_times_vector, _multiplier_vector, and OGS_FATAL.

◆ ~IterationNumberBasedTimeStepping()

NumLib::IterationNumberBasedTimeStepping::~IterationNumberBasedTimeStepping ( )

overridedefault

Member Function Documentation

◆ canReduceTimestepSize()

bool NumLib::IterationNumberBasedTimeStepping::canReduceTimestepSize	(	NumLib::TimeStep const &	,
		NumLib::TimeStep const &	) const

overridevirtual

Query the timestepper if further time step size reduction is possible.

Reimplemented from NumLib::TimeStepAlgorithm.

Definition at line 187 of file IterationNumberBasedTimeStepping.cpp.

190{

191 return NumLib::canReduceTimestepSize(timestep_previous, timestep_current,

192 _min_dt);

193}

NumLib::canReduceTimestepSize

bool canReduceTimestepSize(TimeStep const &timestep_previous, TimeStep const &timestep_current, double const min_dt)

Definition TimeStepAlgorithm.cpp:40

References _min_dt, and NumLib::canReduceTimestepSize().

◆ findMultiplier()

double NumLib::IterationNumberBasedTimeStepping::findMultiplier	(	int const	number_iterations,
		NumLib::TimeStep const &	ts_current ) const

private

Find a multiplier for the given number of iterations.

Definition at line 104 of file IterationNumberBasedTimeStepping.cpp.

{
    double multiplier = _multiplier_vector.front();
    switch (_multiplier_interpolation_type)
    {
        case MultiplyerInterpolationType::PiecewiseLinear:
        {
            auto const& PWLI = MathLib::PiecewiseLinearInterpolation(
                _iter_times_vector, _multiplier_vector, false);
            multiplier = PWLI.getValue(number_iterations);
            DBUG("Using piecewise linear iteration-based time stepping.");
            break;
        }
        case MultiplyerInterpolationType::PiecewiseConstant:
            DBUG("Using piecewise constant iteration-based time stepping.");
            for (std::size_t i = 0; i < _iter_times_vector.size(); i++)
            {
                if (number_iterations >= _iter_times_vector[i])
                {
                    multiplier = _multiplier_vector[i];
                }
            }
            break;
    }
 
    if (!ts_current.isAccepted() && (multiplier >= 1.0))
    {
        return *std::min_element(_multiplier_vector.begin(),
                                 _multiplier_vector.end());
    }
 
    return multiplier;
}

References _iter_times_vector, _multiplier_interpolation_type, _multiplier_vector, DBUG(), NumLib::TimeStep::isAccepted(), NumLib::PiecewiseConstant, and NumLib::PiecewiseLinear.

Referenced by getNextTimeStepSize().

◆ getNextTimeStepSize()

double NumLib::IterationNumberBasedTimeStepping::getNextTimeStepSize	(	NumLib::TimeStep const &	ts_previous,
		NumLib::TimeStep const &	ts_current ) const

private

Calculate the next time step size.

Definition at line 139 of file IterationNumberBasedTimeStepping.cpp.

{
    double dt = 0.0;
 
    // In first time step and first non-linear iteration take the initial dt.
    if (ts_previous.timeStepNumber() == 0 && _iter_times == 0)
    {
        dt = _initial_dt;
    }
    else
    {
        // Attention: for the first time step and second iteration the
        // ts_prev.dt is 0 and 0*multiplier is the next dt, which will be
        // clamped to the minimum dt.
        dt = ts_previous.dt() * findMultiplier(_iter_times, ts_current);
    }
 
    if (_fixed_times_for_output.empty())
    {
        return std::clamp(dt, _min_dt, _max_dt);
    }
 
    // find first fixed timestep for output larger than the current time, i.e.,
    // current time < fixed output time
    auto fixed_output_time_it = std::find_if(
        std::begin(_fixed_times_for_output), std::end(_fixed_times_for_output),
        [&ts_current](auto const fixed_output_time)
        { return ts_current.current()() < fixed_output_time; });
 
    if (fixed_output_time_it != _fixed_times_for_output.end())
    {
        // check if the fixed output time is in the interval
        // (current time, current time + dt)
        if (*fixed_output_time_it < ts_current.current()() + dt)
        {
            // check if the potential adjusted time step is larger than zero
            if (std::abs(*fixed_output_time_it - ts_current.current()()) >
                std::numeric_limits<double>::epsilon() * ts_current.current()())
            {
                return *fixed_output_time_it - ts_current.current()();
            }
        }
    }
    return std::clamp(dt, _min_dt, _max_dt);
}

References _fixed_times_for_output, _initial_dt, _iter_times, _max_dt, _min_dt, NumLib::TimeStep::current(), NumLib::TimeStep::dt(), findMultiplier(), and NumLib::TimeStep::timeStepNumber().

Referenced by next().

◆ isSolutionErrorComputationNeeded()

bool NumLib::IterationNumberBasedTimeStepping::isSolutionErrorComputationNeeded ( ) const

inlineoverridevirtual

Get a flag to indicate whether this algorithm needs to compute solution error. The default return value is false.

Reimplemented from NumLib::TimeStepAlgorithm.

Definition at line 104 of file IterationNumberBasedTimeStepping.h.

104{ return true; }

◆ next()

std::tuple< bool, double > NumLib::IterationNumberBasedTimeStepping::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 61 of file IterationNumberBasedTimeStepping.cpp.

{
    _iter_times = number_iterations;
 
    if (_previous_time_step_accepted)
    {
        ts_previous = ts_current;
    }
 
    // confirm current time and move to the next if accepted
    if (ts_current.isAccepted())
    {
        _previous_time_step_accepted = true;
        return std::make_tuple(_previous_time_step_accepted,
                               getNextTimeStepSize(ts_previous, ts_current));
    }
    else
    {
        double dt = getNextTimeStepSize(ts_previous, ts_current);
        // In case it is the first time be rejected, re-computed dt again with
        // current dt
        if (std::abs(dt - ts_current.dt()) <
            std::numeric_limits<double>::epsilon())
        {
            // time step was rejected, keep dt for the next dt computation.
            ts_previous =  // essentially equal to _ts_prev.dt = _ts_current.dt.
                TimeStep{ts_previous.previous(), ts_previous.previous() + dt,
                         ts_previous.timeStepNumber()};
            dt = getNextTimeStepSize(ts_previous, ts_current);
        }
 
        // time step was rejected, keep dt for the next dt computation.
        ts_previous =  // essentially equal to ts_previous.dt = _ts_current.dt.
            TimeStep{ts_previous.previous(), ts_previous.previous() + dt,
                     ts_previous.timeStepNumber()};
 
        _previous_time_step_accepted = false;
        return std::make_tuple(_previous_time_step_accepted, dt);
    }
}