ProcessLib::TimeLoop Class Reference

Detailed Description

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

Definition at line 39 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	_last_step_rejected = false
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 98 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 271 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))
{
}

~TimeLoop()

ProcessLib::TimeLoop::~TimeLoop

(

)

Definition at line 741 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, NumLib::GlobalVectorProvider::provider, and NumLib::VectorProvider::releaseVector().

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 531 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));
 
    // _last_step_rejected is also checked in computeTimeStepping.
    std::tie(_dt, _last_step_rejected) =
        computeTimeStepping(prev_dt, _current_time, _accepted_steps,
                            _rejected_steps, time_step_constraints);
 
    if (!_last_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 "
            "last 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, _last_step_rejected, _outputs, _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 last time step was rejected

Definition at line 297 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; });
 
    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);
 
        auto const timestepper_dt = timestep_algorithm.next(
            solution_error, ppd.nonlinear_solver_status.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 last_step_rejected = false;
    if (!is_initial_step)
    {
        if (all_process_steps_accepted)
        {
            accepted_steps++;
            last_step_rejected = false;
        }
        else
        {
            if (t <= _end_time)
            {
                t -= prev_dt;
                rejected_steps++;
                last_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 (last_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, last_step_rejected};
}

References _end_time, _per_process_data, _process_solutions, _process_solutions_prev, _repeating_times_of_rejected_step, 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 64 of file TimeLoop.h.

{ return _current_time; }

References _current_time.

endTime()

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

inline

Definition at line 63 of file TimeLoop.h.

{ return _end_time; }

References _end_time.

executeTimeStep()

bool ProcessLib::TimeLoop::executeTimeStep

(

)

Definition at line 510 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 443 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 461 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, _last_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, _last_step_rejected, _outputs, _per_process_data, _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 574 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 715 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 753 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 589 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 692 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);
 
    _last_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 _last_step_rejected, _outputs, _per_process_data, _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 649 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 138 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 137 of file TimeLoop.h.

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

_dt

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

private

Definition at line 140 of file TimeLoop.h.

{0.};

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

_end_time

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

private

Definition at line 136 of file TimeLoop.h.

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

_last_step_rejected

bool ProcessLib::TimeLoop::_last_step_rejected = false

private

Definition at line 142 of file TimeLoop.h.

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

_outputs

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

private

Definition at line 132 of file TimeLoop.h.

Referenced by 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 133 of file TimeLoop.h.

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

_process_solutions

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

private

Definition at line 130 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 131 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 139 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 141 of file TimeLoop.h.

Referenced by computeTimeStepping().

_staggered_coupling

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

private

Definition at line 144 of file TimeLoop.h.

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

_start_time

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

private

Definition at line 135 of file TimeLoop.h.

Referenced by initialize(), and preOutputInitialConditions().

successful_time_step

bool ProcessLib::TimeLoop::successful_time_step = true

Definition at line 65 of file TimeLoop.h.

Referenced by executeTimeStep(), and outputLastTimeStep().

---

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

• ProcessLib/TimeLoop.h
• ProcessLib/TimeLoop.cpp