ProcessLib::TimeLoop Class Reference

Detailed Description

Time loop capable of time-integrating several processes at once.

Definition at line 32 of file TimeLoop.h.

#include <TimeLoop.h>

Collaboration diagram for ProcessLib::TimeLoop:

Public Member Functions
	TimeLoop (std::vector< Output > &&outputs, std::vector< std::unique_ptr< ProcessData > > &&per_process_data, std::unique_ptr< NumLib::StaggeredCoupling > &&staggered_coupling, const NumLib::Time &start_time, const NumLib::Time &end_time)
void	initialize ()
	initialize output, convergence criterion, etc.
void	outputLastTimeStep () const
	~TimeLoop ()
bool	executeTimeStep ()
bool	calculateNextTimeStep ()
NumLib::Time	endTime () const
NumLib::Time	currentTime () const

Public Attributes
bool	successful_time_step = true

Private Types
using	TimeStepConstraintCallback

Private Member Functions
bool	preTsNonlinearSolvePostTs (NumLib::Time const &t, double const dt, std::size_t const timesteps)
NumLib::NonlinearSolverStatus	solveUncoupledEquationSystems (const NumLib::Time &t, const double dt, const std::size_t timestep_id)
	Member to solver non coupled systems of equations, which can be a single system of equations, or several systems of equations without any dependency among the different systems.
NumLib::NonlinearSolverStatus	solveCoupledEquationSystemsByStaggeredScheme (const NumLib::Time &t, const double dt, const std::size_t timestep_id)
	Member to solver coupled systems of equations by the staggered scheme.
std::pair< NumLib::TimeIncrement, bool >	computeTimeStepping (const double prev_dt, NumLib::Time &t, std::size_t &accepted_steps, std::size_t &rejected_steps, std::vector< TimeStepConstraintCallback > const &time_step_constraints)
template<typename OutputClassMember>
void	outputSolutions (unsigned timestep, const double t, OutputClassMember output_class_member) const
std::vector< TimeStepConstraintCallback >	generateOutputTimeStepConstraints (std::vector< double > &&fixed_times) const
void	preOutputInitialConditions (NumLib::Time const &t, const double dt) const

Private Attributes
std::vector< GlobalVector * >	_process_solutions
std::vector< GlobalVector * >	_process_solutions_prev
std::vector< Output >	_outputs
std::vector< std::unique_ptr< ProcessData > >	_per_process_data
const NumLib::Time	_start_time
const NumLib::Time	_end_time
NumLib::Time	_current_time = _start_time
std::size_t	_accepted_steps = 0
std::size_t	_rejected_steps = 0
NumLib::TimeIncrement	_dt {0.}
int	_repeating_times_of_rejected_step = 0
bool	_previous_step_rejected = false
int	_global_coupling_number_iterations = 0
std::unique_ptr< NumLib::StaggeredCoupling >	_staggered_coupling

Member Typedef Documentation

TimeStepConstraintCallback

using ProcessLib::TimeLoop::TimeStepConstraintCallback

private

Initial value:

 
        std::function<double(NumLib::Time const&, double)>

Definition at line 91 of file TimeLoop.h.

Constructor & Destructor Documentation

TimeLoop()

ProcessLib::TimeLoop::TimeLoop	(	std::vector< Output > &&	outputs,
		std::vector< std::unique_ptr< ProcessData > > &&	per_process_data,
		std::unique_ptr< NumLib::StaggeredCoupling > &&	staggered_coupling,
		const NumLib::Time &	start_time,
		const NumLib::Time &	end_time )

Definition at line 263 of file TimeLoop.cpp.

    : _outputs{std::move(outputs)},
      _per_process_data(std::move(per_process_data)),
      _start_time(start_time),
      _end_time(end_time),
      _staggered_coupling(std::move(staggered_coupling))
{
}

References _end_time, _outputs, _per_process_data, _staggered_coupling, and _start_time.

~TimeLoop()

ProcessLib::TimeLoop::~TimeLoop

(

)

Definition at line 754 of file TimeLoop.cpp.

{
    for (auto* x : _process_solutions)
    {
        NumLib::GlobalVectorProvider::provider.releaseVector(*x);
    }
    for (auto* x : _process_solutions_prev)
    {
        NumLib::GlobalVectorProvider::provider.releaseVector(*x);
    }
}

References _process_solutions, _process_solutions_prev, and NumLib::GlobalVectorProvider::provider.

Member Function Documentation

calculateNextTimeStep()

bool ProcessLib::TimeLoop::calculateNextTimeStep

(

)

Computes and sets the next timestep.

Attention

The timestepper might reject the current timestep and repeat it (with a reduced timestep size).

Returns

true if the simulation (time) has not finished, yet, false otherwise.

Definition at line 541 of file TimeLoop.cpp.

{
    const double prev_dt = _dt();
    // keep a copy of _current_time to check if a new point in time is computed
    auto const current_time = _current_time;
 
    const std::size_t timesteps = _accepted_steps + 1;
 
    auto const time_step_constraints = generateOutputTimeStepConstraints(
        calculateUniqueFixedTimesForAllOutputs(_outputs));
 
    // _previous_step_rejected is also checked in computeTimeStepping.
    std::tie(_dt, _previous_step_rejected) =
        computeTimeStepping(prev_dt, _current_time, _accepted_steps,
                            _rejected_steps, time_step_constraints);
 
    if (!_previous_step_rejected)
    {
        outputSolutions(timesteps, current_time(), &Output::doOutput);
    }
 
    // check if the newly computed time point (=_current_time + _dt()) differs
    // from the previously computed time point (current_time) saved at the
    // beginning of the method
    if (current_time == (_current_time + _dt()))
    {
        DBUG("current time == previous time + dt : {:a} == {:a} + {:a} = {:a}",
             current_time(), _current_time(), _dt(), _current_time() + _dt());
        ERR("The time increment {} results in exactly the same time {} as the "
            "previous rejected time step.\n"
            "Time stepping stops at time step {:d} and time {}.",
            _dt, current_time, timesteps, _current_time);
        return false;
    }
 
    if (_current_time >= _end_time || _current_time + _dt() > _end_time)
    {
        return false;
    }
 
    return true;
}

References _accepted_steps, _current_time, _dt, _end_time, _outputs, _previous_step_rejected, _rejected_steps, ProcessLib::calculateUniqueFixedTimesForAllOutputs(), computeTimeStepping(), DBUG(), ProcessLib::Output::doOutput(), ERR(), generateOutputTimeStepConstraints(), and outputSolutions().

computeTimeStepping()

std::pair< NumLib::TimeIncrement, bool > ProcessLib::TimeLoop::computeTimeStepping ( const double prev_dt, NumLib::Time & t, std::size_t & accepted_steps, std::size_t & rejected_steps, std::vector< TimeStepConstraintCallback > const & time_step_constraints )

private

Find the minimum time step size among the predicted step sizes of processes and step it as common time step size.

Parameters

prev_dt	Previous time step size.
t	Current time.
accepted_steps	Accepted time steps that are counted in this function.
rejected_steps	Rejected time steps that are counted in this function.
time_step_constraints	Functions that are evaluate to influence the time step size (for instance a fixed output time)

Returns

the time step size and the information if the previous time step was rejected

Definition at line 289 of file TimeLoop.cpp.

{
    bool all_process_steps_accepted = true;
    // Get minimum time step size among step sizes of all processes.
    NumLib::TimeIncrement dt{std::numeric_limits<double>::max()};
    constexpr double eps = std::numeric_limits<double>::epsilon();
 
    bool const is_initial_step =
        std::any_of(_per_process_data.begin(), _per_process_data.end(),
                    [](auto const& ppd) -> bool
                    { return ppd->timestep_current.timeStepNumber() == 0; });
 
    // In the staggered scheme the time step size is controlled by the maximum
    // over the number of global coupling iterations and the per-process
    // nonlinear solver iterations of all processes.
    int staggered_number_iterations = 0;
    if (_staggered_coupling)
    {
        auto const ppd_max_iterations = std::ranges::max_element(
            _per_process_data, {}, [](auto const& ppd)
            { return ppd->nonlinear_solver_status.number_iterations; });
        staggered_number_iterations = std::max(
            _global_coupling_number_iterations,
            (*ppd_max_iterations)->nonlinear_solver_status.number_iterations);
    }
 
    for (std::size_t i = 0; i < _per_process_data.size(); i++)
    {
        auto& ppd = *_per_process_data[i];
        auto& timestep_algorithm = *ppd.timestep_algorithm.get();
 
        auto const& x = *_process_solutions[i];
        auto const& x_prev = *_process_solutions_prev[i];
 
        const double solution_error =
            computationOfChangeNeeded(timestep_algorithm, t)
                ? MathLib::LinAlg::computeRelativeNorm(
                      x, x_prev,
                      ppd.conv_crit.get() ? ppd.conv_crit->getVectorNormType()
                                          : MathLib::VecNormType::NORM2)
                : 0.0;
 
        ppd.timestep_current.setAccepted(
            ppd.nonlinear_solver_status.error_norms_met);
 
        int const number_iterations =
            _staggered_coupling ? staggered_number_iterations
                                : ppd.nonlinear_solver_status.number_iterations;
 
        auto const timestepper_dt = timestep_algorithm.next(
            solution_error, number_iterations, ppd.timestep_previous,
            ppd.timestep_current);
 
        if (!ppd.timestep_current.isAccepted())
        {
            // Not all processes have accepted steps.
            all_process_steps_accepted = false;
        }
 
        if (!ppd.nonlinear_solver_status.error_norms_met)
        {
            WARN(
                "Time step will be rejected due to nonlinear solver "
                "divergence.");
            all_process_steps_accepted = false;
        }
 
        if (timestepper_dt > eps || t < timestep_algorithm.end())
        {
            dt = NumLib::TimeIncrement{std::min(timestepper_dt, dt())};
        }
    }
 
    if (all_process_steps_accepted)
    {
        _repeating_times_of_rejected_step = 0;
    }
    else
    {
        _repeating_times_of_rejected_step++;
    }
 
    bool previous_step_rejected = false;
    if (!is_initial_step)
    {
        if (all_process_steps_accepted)
        {
            accepted_steps++;
            previous_step_rejected = false;
        }
        else
        {
            if (t <= _end_time)
            {
                t -= prev_dt;
                rejected_steps++;
                previous_step_rejected = true;
            }
        }
    }
 
    // adjust step size considering external communciation_point_calculators
    for (auto const& time_step_constraint : time_step_constraints)
    {
        dt = NumLib::TimeIncrement{
            std::min(dt(), time_step_constraint(t, dt()))};
    }
 
    // Check whether the time stepping is stabilized
    if (std::abs(dt() - prev_dt) < eps)
    {
        if (previous_step_rejected)
        {
            OGS_FATAL(
                "The new step size of {} is the same as that of the previous "
                "rejected time step. \nPlease re-run ogs with a proper "
                "adjustment in the numerical settings, \ne.g. those for time "
                "stepper, local or global non-linear solver.",
                dt);
        }
        else
        {
            DBUG("The time stepping is stabilized with the step size of {}.",
                 dt);
        }
    }
 
    // Reset the time step with the minimum step size, dt
    // Update the solution of the previous time step.
    for (std::size_t i = 0; i < _per_process_data.size(); i++)
    {
        if (all_process_steps_accepted)
        {
            auto& ppd = *_per_process_data[i];
            NumLib::updateTimeSteps(dt(), ppd.timestep_previous,
                                    ppd.timestep_current);
        }
 
        auto& x = *_process_solutions[i];
        auto& x_prev = *_process_solutions_prev[i];
        if (all_process_steps_accepted)
        {
            MathLib::LinAlg::copy(x, x_prev);  // pushState
        }
        else
        {
            if (t <= _end_time)
            {
                WARN(
                    "Time step {:d} was rejected {:d} times and it will be "
                    "repeated with a reduced step size.",
                    accepted_steps + 1, _repeating_times_of_rejected_step);
                MathLib::LinAlg::copy(x_prev, x);  // popState
            }
        }
    }
 
    return {dt, previous_step_rejected};
}

References _end_time, _global_coupling_number_iterations, _per_process_data, _process_solutions, _process_solutions_prev, _repeating_times_of_rejected_step, _staggered_coupling, ProcessLib::computationOfChangeNeeded(), MathLib::LinAlg::computeRelativeNorm(), MathLib::LinAlg::copy(), DBUG(), MathLib::NORM2, OGS_FATAL, NumLib::updateTimeSteps(), and WARN().

Referenced by calculateNextTimeStep(), and initialize().

currentTime()

NumLib::Time ProcessLib::TimeLoop::currentTime ( ) const

inline

Definition at line 57 of file TimeLoop.h.

{ return _current_time; }

References _current_time.

endTime()

NumLib::Time ProcessLib::TimeLoop::endTime ( ) const

inline

Definition at line 56 of file TimeLoop.h.

{ return _end_time; }

References _end_time.

executeTimeStep()

bool ProcessLib::TimeLoop::executeTimeStep

(

)

Definition at line 520 of file TimeLoop.cpp.

{
    BaseLib::RunTime time_timestep;
    time_timestep.start();
 
    _current_time += _dt();
 
    const std::size_t timesteps = _accepted_steps + 1;
    // TODO(wenqing): , input option for time unit.
    INFO("Time step #{:d} started. Time: {}. Step size: {}.", timesteps,
         _current_time, _dt);
 
    updateDeactivatedSubdomains(_per_process_data, _current_time());
 
    successful_time_step =
        preTsNonlinearSolvePostTs(_current_time, _dt(), timesteps);
    INFO("[time] Time step #{:d} took {:g} s.", timesteps,
         time_timestep.elapsed());
    return successful_time_step;
}

References _accepted_steps, _current_time, _dt, _per_process_data, BaseLib::RunTime::elapsed(), INFO(), preTsNonlinearSolvePostTs(), BaseLib::RunTime::start(), and successful_time_step.

generateOutputTimeStepConstraints()

std::vector< TimeLoop::TimeStepConstraintCallback > ProcessLib::TimeLoop::generateOutputTimeStepConstraints ( std::vector< double > && fixed_times ) const

private

Definition at line 453 of file TimeLoop.cpp.

{
    std::vector<TimeStepConstraintCallback> const time_step_constraints{
        [fixed_times = std::move(fixed_times)](NumLib::Time const& t, double dt)
        { return NumLib::possiblyClampDtToNextFixedTime(t, dt, fixed_times); },
        [this](NumLib::Time const& t, double dt) -> double
        {
            if (t < _end_time && _end_time < t + dt)
            {
                return _end_time() - t();
            }
            return dt;
        }};
    return time_step_constraints;
}

References _end_time, and NumLib::possiblyClampDtToNextFixedTime().

Referenced by calculateNextTimeStep(), and initialize().

initialize()

void ProcessLib::TimeLoop::initialize

(

)

initialize output, convergence criterion, etc.

Definition at line 471 of file TimeLoop.cpp.

{
    for (auto const& process_data : _per_process_data)
    {
        auto& pcs = process_data->process;
        for (auto& output : _outputs)
        {
            output.addProcess(pcs);
        }
 
        setTimeDiscretizedODESystem(*process_data);
 
        if (auto* conv_crit =
                dynamic_cast<NumLib::ConvergenceCriterionPerComponent*>(
                    process_data->conv_crit.get()))
        {
            int const process_id = process_data->process_id;
            conv_crit->setDOFTable(pcs.getDOFTable(process_id), pcs.getMesh());
        }
    }
 
    // initial solution storage
    std::tie(_process_solutions, _process_solutions_prev) =
        setInitialConditions(_start_time, _per_process_data);
 
    if (_staggered_coupling)
    {
        _staggered_coupling->initializeCoupledSolutions(_process_solutions);
    }
 
    updateDeactivatedSubdomains(_per_process_data, _start_time());
 
    auto const time_step_constraints = generateOutputTimeStepConstraints(
        calculateUniqueFixedTimesForAllOutputs(_outputs));
 
    std::tie(_dt, _previous_step_rejected) =
        computeTimeStepping(0.0, _current_time, _accepted_steps,
                            _rejected_steps, time_step_constraints);
 
    // Output initial conditions
    {
        preOutputInitialConditions(_start_time, _dt());
        outputSolutions(0, _start_time(), &Output::doOutput);
    }
 
    calculateNonEquilibriumInitialResiduum(
        _per_process_data, _process_solutions, _process_solutions_prev);
}

References _accepted_steps, _current_time, _dt, _outputs, _per_process_data, _previous_step_rejected, _process_solutions, _process_solutions_prev, _rejected_steps, _staggered_coupling, _start_time, ProcessLib::calculateNonEquilibriumInitialResiduum(), ProcessLib::calculateUniqueFixedTimesForAllOutputs(), computeTimeStepping(), ProcessLib::Output::doOutput(), generateOutputTimeStepConstraints(), outputSolutions(), preOutputInitialConditions(), ProcessLib::setInitialConditions(), and ProcessLib::setTimeDiscretizedODESystem().

outputLastTimeStep()

void ProcessLib::TimeLoop::outputLastTimeStep

(

)

const

Definition at line 584 of file TimeLoop.cpp.

{
    INFO(
        "The whole computation of the time stepping took {:d} steps, in which\n"
        "\t the accepted steps are {:d}, and the rejected steps are {:d}.\n",
        _accepted_steps + _rejected_steps, _accepted_steps, _rejected_steps);
 
    // output last time step
    if (successful_time_step)
    {
        outputSolutions(_accepted_steps, _current_time(),
                        &Output::doOutputLastTimestep);
    }
}

References _accepted_steps, _current_time, _rejected_steps, ProcessLib::Output::doOutputLastTimestep(), INFO(), outputSolutions(), and successful_time_step.

outputSolutions()

template<typename OutputClassMember>

void ProcessLib::TimeLoop::outputSolutions ( unsigned timestep, const double t, OutputClassMember output_class_member ) const

private

Definition at line 728 of file TimeLoop.cpp.

{
    for (auto const& process_data : _per_process_data)
    {
        // If nonlinear solver diverged, the solution has already been
        // saved.
        if (!process_data->nonlinear_solver_status.error_norms_met)
        {
            continue;
        }
 
        auto const process_id = process_data->process_id;
        auto const& pcs = process_data->process;
 
        for (auto const& output_object : _outputs)
        {
            (output_object.*output_class_member)(
                pcs, process_id, timestep, NumLib::Time(t),
                process_data->nonlinear_solver_status.number_iterations,
                process_data->nonlinear_solver_status.error_norms_met,
                _process_solutions);
        }
    }
}

References _outputs, _per_process_data, and _process_solutions.

Referenced by calculateNextTimeStep(), initialize(), and outputLastTimeStep().

preOutputInitialConditions()

void ProcessLib::TimeLoop::preOutputInitialConditions ( NumLib::Time const & t, const double dt ) const

private

Definition at line 766 of file TimeLoop.cpp.

{
    for (auto const& process_data : _per_process_data)
    {
        // If nonlinear solver diverged, the solution has already been
        // saved.
        if (!process_data->nonlinear_solver_status.error_norms_met)
        {
            continue;
        }
 
        auto const process_id = process_data->process_id;
        auto& pcs = process_data->process;
 
        process_data->time_disc->nextTimestep(t(), dt);
 
        pcs.preTimestep(_process_solutions, _start_time(), dt, process_id);
 
        pcs.preOutput(_start_time(), dt, _process_solutions,
                      _process_solutions_prev, process_id);
 
        // Update secondary variables, which might be uninitialized, before
        // output.
        pcs.computeSecondaryVariable(_start_time(), dt, _process_solutions,
                                     *_process_solutions_prev[process_id],
                                     process_id);
    }
}

References _per_process_data, _process_solutions, _process_solutions_prev, and _start_time.

Referenced by initialize().

preTsNonlinearSolvePostTs()

bool ProcessLib::TimeLoop::preTsNonlinearSolvePostTs ( NumLib::Time const & t, double const dt, std::size_t const timesteps )

private

Definition at line 599 of file TimeLoop.cpp.

{
    preTimestepForAllProcesses(t, dt, _per_process_data, _process_solutions);
 
    NumLib::NonlinearSolverStatus nonlinear_solver_status;
 
    if (_staggered_coupling)
    {
        nonlinear_solver_status =
            solveCoupledEquationSystemsByStaggeredScheme(t, dt, timesteps);
    }
    else
    {
        nonlinear_solver_status =
            solveUncoupledEquationSystems(t, dt, timesteps);
    }
 
    // Run post time step only if the last iteration was successful.
    // Otherwise it runs the risks to get the same errors as in the last
    // iteration, an exception thrown in assembly, for example.
    if (nonlinear_solver_status.error_norms_met)
    {
        // Later on, the timestep_algorithm might reject the timestep. We assume
        // that this is a rare case, so still, we call preOutput() here. We
        // don't expect a large overhead from it.
        preOutputForAllProcesses(timesteps, t, dt, _end_time, _per_process_data,
                                 _process_solutions, _process_solutions_prev,
                                 _outputs);
 
        postTimestepForAllProcesses(t, dt, _per_process_data,
                                    _process_solutions,
                                    _process_solutions_prev);
    }
    return nonlinear_solver_status.error_norms_met;
}

References _end_time, _outputs, _per_process_data, _process_solutions, _process_solutions_prev, _staggered_coupling, NumLib::NonlinearSolverStatus::error_norms_met, ProcessLib::postTimestepForAllProcesses(), ProcessLib::preTimestepForAllProcesses(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

Referenced by executeTimeStep().

solveCoupledEquationSystemsByStaggeredScheme()

NumLib::NonlinearSolverStatus ProcessLib::TimeLoop::solveCoupledEquationSystemsByStaggeredScheme ( const NumLib::Time & t, const double dt, const std::size_t timestep_id )

private

Member to solver coupled systems of equations by the staggered scheme.

Parameters

t	Current time
dt	Time step size
timestep_id	Index of the time step

Returns

true: if all nonlinear solvers convergence. false: if any of nonlinear solvers divergences.

Definition at line 702 of file TimeLoop.cpp.

{
    auto const nonlinear_solver_status =
        _staggered_coupling->execute<ProcessData, Output>(
            t(), dt, timestep_id, _process_solutions, _process_solutions_prev,
            _per_process_data, _outputs, &solveOneTimeStepOneProcess);
 
    _global_coupling_number_iterations =
        _staggered_coupling->lastNumberOfCouplingIterations();
 
    _previous_step_rejected = nonlinear_solver_status.error_norms_met;
 
    for (auto const& process_data : _per_process_data)
    {
        auto& pcs = process_data->process;
        int const process_id = process_data->process_id;
        auto& ode_sys = *process_data->tdisc_ode_sys;
        pcs.solveReactionEquation(_process_solutions, _process_solutions_prev,
                                  t(), dt, ode_sys, process_id);
    }
 
    return nonlinear_solver_status;
}

References _global_coupling_number_iterations, _outputs, _per_process_data, _previous_step_rejected, _process_solutions, _process_solutions_prev, _staggered_coupling, and ProcessLib::solveOneTimeStepOneProcess().

Referenced by preTsNonlinearSolvePostTs().

solveUncoupledEquationSystems()

NumLib::NonlinearSolverStatus ProcessLib::TimeLoop::solveUncoupledEquationSystems ( const NumLib::Time & t, const double dt, const std::size_t timestep_id )

private

Member to solver non coupled systems of equations, which can be a single system of equations, or several systems of equations without any dependency among the different systems.

Parameters

t	Current time
dt	Time step size
timestep_id	Index of the time step

Returns

true: if all nonlinear solvers convergence. false: if any of nonlinear solvers divergences.

Definition at line 659 of file TimeLoop.cpp.

{
    NumLib::NonlinearSolverStatus nonlinear_solver_status;
 
    for (auto const& process_data : _per_process_data)
    {
        auto const process_id = process_data->process_id;
        nonlinear_solver_status = solveMonolithicProcess(
            t, dt, timestep_id, *process_data, _process_solutions,
            _process_solutions_prev, _outputs);
 
        process_data->nonlinear_solver_status = nonlinear_solver_status;
        if (!nonlinear_solver_status.error_norms_met)
        {
            ERR("The nonlinear solver failed in time step #{:d} at t = {} s "
                "for process #{:d}.",
                timestep_id, t, process_id);
 
            if (!process_data->timestep_algorithm->canReduceTimestepSize(
                    process_data->timestep_current,
                    process_data->timestep_previous))
            {
                // save unsuccessful solution
                for (auto const& output : _outputs)
                {
                    output.doOutputAlways(
                        process_data->process, process_id, timestep_id, t,
                        process_data->nonlinear_solver_status.number_iterations,
                        process_data->nonlinear_solver_status.error_norms_met,
                        _process_solutions);
                }
                OGS_FATAL(timestepper_cannot_reduce_dt.data());
            }
 
            return nonlinear_solver_status;
        }
    }
 
    return nonlinear_solver_status;
}

References _outputs, _per_process_data, _process_solutions, _process_solutions_prev, ERR(), NumLib::NonlinearSolverStatus::error_norms_met, OGS_FATAL, ProcessLib::solveMonolithicProcess(), and ProcessLib::timestepper_cannot_reduce_dt.

Referenced by preTsNonlinearSolvePostTs().

Member Data Documentation

_accepted_steps

std::size_t ProcessLib::TimeLoop::_accepted_steps = 0

private

Definition at line 131 of file TimeLoop.h.

Referenced by calculateNextTimeStep(), executeTimeStep(), initialize(), and outputLastTimeStep().

_current_time

NumLib::Time ProcessLib::TimeLoop::_current_time = _start_time

private

Definition at line 130 of file TimeLoop.h.

Referenced by calculateNextTimeStep(), currentTime(), executeTimeStep(), initialize(), and outputLastTimeStep().

_dt

NumLib::TimeIncrement ProcessLib::TimeLoop::_dt {0.}

private

Definition at line 133 of file TimeLoop.h.

{0.};

Referenced by calculateNextTimeStep(), executeTimeStep(), and initialize().

_end_time

const NumLib::Time ProcessLib::TimeLoop::_end_time

private

Definition at line 129 of file TimeLoop.h.

Referenced by TimeLoop(), calculateNextTimeStep(), computeTimeStepping(), endTime(), generateOutputTimeStepConstraints(), and preTsNonlinearSolvePostTs().

_global_coupling_number_iterations

int ProcessLib::TimeLoop::_global_coupling_number_iterations = 0

private

Number of global coupling iterations of the previous time step in the staggered scheme. It drives the time step size control of all processes.

Definition at line 139 of file TimeLoop.h.

Referenced by computeTimeStepping(), and solveCoupledEquationSystemsByStaggeredScheme().

_outputs

std::vector<Output> ProcessLib::TimeLoop::_outputs

private

Definition at line 125 of file TimeLoop.h.

Referenced by TimeLoop(), calculateNextTimeStep(), initialize(), outputSolutions(), preTsNonlinearSolvePostTs(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_per_process_data

std::vector<std::unique_ptr<ProcessData> > ProcessLib::TimeLoop::_per_process_data

private

Definition at line 126 of file TimeLoop.h.

Referenced by TimeLoop(), computeTimeStepping(), executeTimeStep(), initialize(), outputSolutions(), preOutputInitialConditions(), preTsNonlinearSolvePostTs(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_previous_step_rejected

bool ProcessLib::TimeLoop::_previous_step_rejected = false

private

Definition at line 135 of file TimeLoop.h.

Referenced by calculateNextTimeStep(), initialize(), and solveCoupledEquationSystemsByStaggeredScheme().

_process_solutions

std::vector<GlobalVector*> ProcessLib::TimeLoop::_process_solutions

private

Definition at line 123 of file TimeLoop.h.

Referenced by ~TimeLoop(), computeTimeStepping(), initialize(), outputSolutions(), preOutputInitialConditions(), preTsNonlinearSolvePostTs(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_process_solutions_prev

std::vector<GlobalVector*> ProcessLib::TimeLoop::_process_solutions_prev

private

Definition at line 124 of file TimeLoop.h.

Referenced by ~TimeLoop(), computeTimeStepping(), initialize(), preOutputInitialConditions(), preTsNonlinearSolvePostTs(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_rejected_steps

std::size_t ProcessLib::TimeLoop::_rejected_steps = 0

private

Definition at line 132 of file TimeLoop.h.

Referenced by calculateNextTimeStep(), initialize(), and outputLastTimeStep().

_repeating_times_of_rejected_step

int ProcessLib::TimeLoop::_repeating_times_of_rejected_step = 0

private

Definition at line 134 of file TimeLoop.h.

Referenced by computeTimeStepping().

_staggered_coupling

std::unique_ptr<NumLib::StaggeredCoupling> ProcessLib::TimeLoop::_staggered_coupling

private

Definition at line 141 of file TimeLoop.h.

Referenced by TimeLoop(), computeTimeStepping(), initialize(), preTsNonlinearSolvePostTs(), and solveCoupledEquationSystemsByStaggeredScheme().

_start_time

const NumLib::Time ProcessLib::TimeLoop::_start_time

private

Definition at line 128 of file TimeLoop.h.

Referenced by TimeLoop(), initialize(), and preOutputInitialConditions().

successful_time_step

bool ProcessLib::TimeLoop::successful_time_step = true

Definition at line 58 of file TimeLoop.h.

Referenced by executeTimeStep(), and outputLastTimeStep().

---

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

• TimeLoop.h
• TimeLoop.cpp