ProcessLib::TimeLoop Class Reference

Detailed Description

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

Definition at line 37 of file TimeLoop.h.

#include <TimeLoop.h>

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 double start_time, const double end_time)
void	initialize ()
	initialize output, convergence criterion, etc.
void	outputLastTimeStep () const
	~TimeLoop ()
bool	executeTimeStep ()
bool	calculateNextTimeStep ()
double	endTime () const
double	currentTime () const

Public Attributes
bool	successful_time_step = false

Private Member Functions
bool	preTsNonlinearSolvePostTs (double const t, double const dt, std::size_t const timesteps)
NumLib::NonlinearSolverStatus	solveUncoupledEquationSystems (const double 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 double t, const double dt, const std::size_t timestep_id)
	Member to solver coupled systems of equations by the staggered scheme.
std::pair< double, bool >	computeTimeStepping (const double prev_dt, double &t, std::size_t &accepted_steps, std::size_t &rejected_steps, std::vector< std::function< double(double, double)> > const &time_step_constraints)
template<typename OutputClassMember >
void	outputSolutions (unsigned timestep, const double t, OutputClassMember output_class_member) const
std::vector< std::function< double(double, double)> >	generateOutputTimeStepConstraints (std::vector< double > &&fixed_times) const
void	preOutputInitialConditions (const double t) 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 double	_start_time
const double	_end_time
double	_current_time = _start_time
std::size_t	_accepted_steps = 0
std::size_t	_rejected_steps = 0
double	_dt = 0
int	_repeating_times_of_rejected_step = 0
bool	_last_step_rejected = false
std::unique_ptr< NumLib::StaggeredCoupling >	_staggered_coupling

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 double	start_time,
		const double	end_time )

Definition at line 266 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 743 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 538 of file TimeLoop.cpp.

{
    const double prev_dt = _dt;
    double 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);
    }
 
    if (std::abs(_current_time - _end_time) <
            std::numeric_limits<double>::epsilon() ||
        _current_time + _dt > _end_time)
    {
        return false;
    }
 
    if (_dt < std::numeric_limits<double>::epsilon())
    {
        WARN(
            "Time step size of {:g} is too small.\n"
            "Time stepping stops at step {:d} and at time of {:g}.",
            _dt, timesteps, _current_time);
        return false;
    }
 
    return true;
}

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

computeTimeStepping()

std::pair< double, bool > ProcessLib::TimeLoop::computeTimeStepping ( const double prev_dt, double & t, std::size_t & accepted_steps, std::size_t & rejected_steps, std::vector< std::function< double(double, double)> > 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 291 of file TimeLoop.cpp.

{
    bool all_process_steps_accepted = true;
    // Get minimum time step size among step sizes of all processes.
    double 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 [previous_step_accepted, timestepper_dt] = timestep_algorithm.next(
            solution_error, ppd.nonlinear_solver_status.number_iterations,
            ppd.timestep_previous, ppd.timestep_current);
 
        if (!previous_step_accepted &&
            // In case of FixedTimeStepping, which makes
            // timestep_algorithm.next(...) return false when the ending time
            // is reached.
            t + eps < timestep_algorithm.end())
        {
            // 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 ||
            std::abs(t - timestep_algorithm.end()) < eps)
        {
            dt = 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 || std::abs(t - _end_time) < eps)
            {
                t -= prev_dt;
                rejected_steps++;
                last_step_rejected = true;
            }
        }
    }
 
    // adjust step size considering external communciation_point_calculators
    for (auto const& time_step_constain : time_step_constraints)
    {
        dt = std::min(dt, time_step_constain(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 {:g} 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 {:g}.",
                 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& timestep_algorithm = ppd.timestep_algorithm;
            timestep_algorithm->resetCurrentTimeStep(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 || std::abs(t - _end_time) < eps)
            {
                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()

double ProcessLib::TimeLoop::currentTime ( ) const

inline

Definition at line 62 of file TimeLoop.h.

{ return _current_time; }

References _current_time.

endTime()

double ProcessLib::TimeLoop::endTime ( ) const

inline

Definition at line 61 of file TimeLoop.h.

{ return _end_time; }

References _end_time.

executeTimeStep()

bool ProcessLib::TimeLoop::executeTimeStep

(

)

Definition at line 515 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 stepping at step #{:d} and time {:.15g} with step size "
        "{:.15g}",
        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< std::function< double(double, double)> > ProcessLib::TimeLoop::generateOutputTimeStepConstraints ( std::vector< double > && fixed_times ) const

private

Definition at line 445 of file TimeLoop.cpp.

{
    std::vector<std::function<double(double, double)>> const
        time_step_constraints{
            [fixed_times = std::move(fixed_times)](double t, double dt) {
                return NumLib::possiblyClampDtToNextFixedTime(t, dt,
                                                              fixed_times);
            },
            [this](double t, double dt)
            {
                if (t < _end_time && t + dt > _end_time)
                {
                    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 466 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);
 
    // Output initial conditions
    {
        preOutputInitialConditions(_start_time);
        outputSolutions(0, _start_time, &Output::doOutput);
    }
 
    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);
 
    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 577 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 + _rejected_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 718 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, t,
                process_data->nonlinear_solver_status.number_iterations,
                _process_solutions);
        }
    }
}

References _outputs, _per_process_data, and _process_solutions.

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

preOutputInitialConditions()

void ProcessLib::TimeLoop::preOutputInitialConditions ( const double t ) const

private

Definition at line 755 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;
 
        // dummy value to handle the time derivative terms more or less
        // correctly, i.e. to ignore them.
        double const dt = 1;
        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 ( double const t, double const dt, std::size_t const timesteps )

private

Definition at line 592 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 double 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 double 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 650 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 = {:g} 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_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 134 of file TimeLoop.h.

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

_current_time

double ProcessLib::TimeLoop::_current_time = _start_time

private

Definition at line 133 of file TimeLoop.h.

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

_dt

double ProcessLib::TimeLoop::_dt = 0

private

Definition at line 136 of file TimeLoop.h.

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

_end_time

const double ProcessLib::TimeLoop::_end_time

private

Definition at line 132 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 138 of file TimeLoop.h.

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

_outputs

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

private

Definition at line 128 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 129 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 126 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 127 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 135 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 137 of file TimeLoop.h.

Referenced by computeTimeStepping().

_staggered_coupling

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

private

Definition at line 140 of file TimeLoop.h.

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

_start_time

const double ProcessLib::TimeLoop::_start_time

private

Definition at line 131 of file TimeLoop.h.

Referenced by initialize(), and preOutputInitialConditions().

successful_time_step

bool ProcessLib::TimeLoop::successful_time_step = false

Definition at line 63 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