ProcessLib::TimeLoop Class Reference

Detailed Description

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

Definition at line 36 of file TimeLoop.h.

#include <TimeLoop.h>

Public Member Functions
	TimeLoop (std::unique_ptr< Output > &&output, std::vector< std::unique_ptr< ProcessData >> &&per_process_data, const int global_coupling_max_iterations, std::vector< std::unique_ptr< NumLib::ConvergenceCriterion >> &&global_coupling_conv_crit, const double start_time, const double end_time)
void	initialize ()
	initialize output, convergence criterion, etc. More...
bool	loop ()
	~TimeLoop ()

Private Member Functions
void	setCoupledSolutions ()
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. More...
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. More...
double	computeTimeStepping (const double prev_dt, double &t, std::size_t &accepted_steps, std::size_t &rejected_steps)
template<typename OutputClass , typename OutputClassMember >
void	outputSolutions (bool const output_initial_condition, unsigned timestep, const double t, OutputClass &output_object, OutputClassMember output_class_member) const

Private Attributes
std::vector< GlobalVector * >	_process_solutions
std::vector< GlobalVector * >	_process_solutions_prev
std::unique_ptr< Output >	_output
std::vector< std::unique_ptr< ProcessData > >	_per_process_data
bool	_last_step_rejected = false
int	_repeating_times_of_rejected_step = 0
const double	_start_time
const double	_end_time
const int	_global_coupling_max_iterations
	Maximum iterations of the global coupling. More...
std::vector< std::unique_ptr< NumLib::ConvergenceCriterion > >	_global_coupling_conv_crit
	Convergence criteria of processes for the global coupling iterations. More...
std::vector< GlobalVector * >	_solutions_of_last_cpl_iteration
std::vector< std::size_t >	_xdot_vector_ids

Constructor & Destructor Documentation

TimeLoop()

ProcessLib::TimeLoop::TimeLoop	(	std::unique_ptr< Output > &&	output,
		std::vector< std::unique_ptr< ProcessData >> &&	per_process_data,
		const int	global_coupling_max_iterations,
		std::vector< std::unique_ptr< NumLib::ConvergenceCriterion >> &&	global_coupling_conv_crit,
		const double	start_time,
		const double	end_time
	)

Definition at line 328 of file TimeLoop.cpp.

    : _output(std::move(output)),
      _per_process_data(std::move(per_process_data)),
      _start_time(start_time),
      _end_time(end_time),
      _global_coupling_max_iterations(global_coupling_max_iterations),
      _global_coupling_conv_crit(std::move(global_coupling_conv_crit))
{
}

~TimeLoop()

ProcessLib::TimeLoop::~TimeLoop

(

)

Definition at line 945 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);
    }
 
    for (auto* x : _solutions_of_last_cpl_iteration)
    {
        NumLib::GlobalVectorProvider::provider.releaseVector(*x);
    }
}

References _process_solutions, _process_solutions_prev, _solutions_of_last_cpl_iteration, NumLib::GlobalVectorProvider::provider, and NumLib::VectorProvider::releaseVector().

Member Function Documentation

computeTimeStepping()

double ProcessLib::TimeLoop::computeTimeStepping ( const double  prev_dt, double &  t, std::size_t &  accepted_steps, std::size_t &  rejected_steps  )

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.

Definition at line 358 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();
 
    bool is_initial_step = false;
    for (std::size_t i = 0; i < _per_process_data.size(); i++)
    {
        auto& ppd = *_per_process_data[i];
        const auto& timestepper = ppd.timestepper;
        if (timestepper->getTimeStep().steps() == 0)
        {
            is_initial_step = true;
        }
 
        auto& time_disc = ppd.time_disc;
        auto const& x = *_process_solutions[i];
        auto const& x_prev = *_process_solutions_prev[i];
 
        auto const& conv_crit = ppd.conv_crit;
        const MathLib::VecNormType norm_type =
            (conv_crit) ? conv_crit->getVectorNormType()
                        : MathLib::VecNormType::NORM2;
 
        const double solution_error =
            (timestepper->isSolutionErrorComputationNeeded())
                ? ((t == timestepper->begin())
                       ? 0.  // Always accepts the zeroth step
                       : time_disc->computeRelativeChangeFromPreviousTimestep(
                             x, x_prev, norm_type))
                : 0.;
 
        if (!ppd.nonlinear_solver_status.error_norms_met)
        {
            timestepper->setAcceptedOrNot(false);
        }
        else
        {
            timestepper->setAcceptedOrNot(true);
        }
 
        auto [step_accepted, timestepper_dt] = timestepper->next(
            solution_error, ppd.nonlinear_solver_status.number_iterations);
 
        if (!step_accepted &&
            // In case of FixedTimeStepping, which makes timestepper->next(...)
            // return false when the ending time is reached.
            t + std::numeric_limits<double>::epsilon() < timestepper->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 > std::numeric_limits<double>::epsilon() ||
            std::abs(t - timestepper->end()) <
                std::numeric_limits<double>::epsilon())
        {
            dt = std::min(timestepper_dt, dt);
        }
    }
 
    if (all_process_steps_accepted)
    {
        _repeating_times_of_rejected_step = 0;
    }
    else
    {
        _repeating_times_of_rejected_step++;
    }
 
    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) <
                                     std::numeric_limits<double>::epsilon())
            {
                t -= prev_dt;
                rejected_steps++;
                _last_step_rejected = true;
            }
        }
    }
 
    // Adjust step size if t < _end_time, while t+dt exceeds the end time
    if (t < _end_time && t + dt > _end_time)
    {
        dt = _end_time - t;
    }
 
    dt = NumLib::possiblyClampDtToNextFixedTime(t, dt,
                                                _output->getFixedOutputTimes());
    // Check whether the time stepping is stabilized
    if (std::abs(dt - prev_dt) < std::numeric_limits<double>::epsilon())
    {
        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++)
    {
        const auto& ppd = *_per_process_data[i];
        auto& timestepper = ppd.timestepper;
        if (all_process_steps_accepted)
        {
            timestepper->resetCurrentTimeStep(dt);
        }
 
        if (t == timestepper->begin())
        {
            continue;
        }
 
        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) <
                                     std::numeric_limits<double>::epsilon())
            {
                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;
}

References _end_time, _last_step_rejected, _output, _per_process_data, _process_solutions, _process_solutions_prev, _repeating_times_of_rejected_step, MathLib::LinAlg::copy(), DBUG(), MathLib::NORM2, OGS_FATAL, NumLib::possiblyClampDtToNextFixedTime(), and WARN().

Referenced by loop().

initialize()

void ProcessLib::TimeLoop::initialize

(

)

initialize output, convergence criterion, etc.

Definition at line 525 of file TimeLoop.cpp.

{
    for (auto& process_data : _per_process_data)
    {
        auto& pcs = process_data->process;
        int const process_id = process_data->process_id;
        _output->addProcess(pcs);
 
        setTimeDiscretizedODESystem(*process_data);
 
        if (auto* conv_crit =
                dynamic_cast<NumLib::ConvergenceCriterionPerComponent*>(
                    process_data->conv_crit.get()))
        {
            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);
 
    // All _per_process_data share the first process.
    bool const is_staggered_coupling =
        !isMonolithicProcess(*_per_process_data[0]);
 
    if (is_staggered_coupling)
    {
        setCoupledSolutions();
    }
 
    // Output initial conditions
    {
        const bool output_initial_condition = true;
        outputSolutions(output_initial_condition, 0, _start_time, *_output,
                        &Output::doOutput);
    }
}

References _output, _per_process_data, _process_solutions, _process_solutions_prev, _start_time, ProcessLib::Output::doOutput(), anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess(), outputSolutions(), setCoupledSolutions(), ProcessLib::setInitialConditions(), and ProcessLib::setTimeDiscretizedODESystem().

Referenced by main().

loop()

bool ProcessLib::TimeLoop::loop

(

)

Definition at line 572 of file TimeLoop.cpp.

{
    // All _per_process_data share the first process.
    bool const is_staggered_coupling =
        !isMonolithicProcess(*_per_process_data[0]);
 
    bool non_equilibrium_initial_residuum_computed = false;
    double t = _start_time;
    std::size_t accepted_steps = 0;
    std::size_t rejected_steps = 0;
    NumLib::NonlinearSolverStatus nonlinear_solver_status;
 
    double dt = computeTimeStepping(0.0, t, accepted_steps, rejected_steps);
 
    while (t < _end_time)
    {
        BaseLib::RunTime time_timestep;
        time_timestep.start();
 
        t += dt;
        const double prev_dt = dt;
 
        const std::size_t timesteps = accepted_steps + 1;
        // TODO(wenqing): , input option for time unit.
        INFO(
            "=== Time stepping at step #{:d} and time {:g} with step size {:g}",
            timesteps, t, dt);
 
        // Check element deactivation:
        for (auto& process_data : _per_process_data)
        {
            process_data->process.updateDeactivatedSubdomains(
                t, process_data->process_id);
        }
 
        if (!non_equilibrium_initial_residuum_computed)
        {
            calculateNonEquilibriumInitialResiduum(
                _per_process_data, _process_solutions, _process_solutions_prev);
            non_equilibrium_initial_residuum_computed = true;
        }
 
        preTimestepForAllProcesses(t, dt, _per_process_data,
                                   _process_solutions);
 
        if (is_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)
        {
            postTimestepForAllProcesses(
                t, dt, _per_process_data, _process_solutions,
                _process_solutions_prev, _xdot_vector_ids);
        }
 
        INFO("[time] Time step #{:d} took {:g} s.", timesteps,
             time_timestep.elapsed());
 
        double const current_time = t;
        // _last_step_rejected is also checked in computeTimeStepping.
        dt = computeTimeStepping(prev_dt, t, accepted_steps, rejected_steps);
 
        if (!_last_step_rejected)
        {
            const bool output_initial_condition = false;
            outputSolutions(output_initial_condition, timesteps, current_time,
                            *_output, &Output::doOutput);
        }
 
        if (std::abs(t - _end_time) < std::numeric_limits<double>::epsilon() ||
            t + dt > _end_time)
        {
            break;
        }
 
        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, t);
            break;
        }
    }
 
    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 (nonlinear_solver_status.error_norms_met)
    {
        const bool output_initial_condition = false;
        outputSolutions(output_initial_condition,
                        accepted_steps + rejected_steps, t, *_output,
                        &Output::doOutputLastTimestep);
    }
 
    return nonlinear_solver_status.error_norms_met;
}

References _end_time, _last_step_rejected, _output, _per_process_data, _process_solutions, _process_solutions_prev, _start_time, _xdot_vector_ids, ProcessLib::calculateNonEquilibriumInitialResiduum(), computeTimeStepping(), ProcessLib::Output::doOutput(), ProcessLib::Output::doOutputLastTimestep(), BaseLib::RunTime::elapsed(), NumLib::NonlinearSolverStatus::error_norms_met, INFO(), anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess(), outputSolutions(), ProcessLib::postTimestepForAllProcesses(), ProcessLib::preTimestepForAllProcesses(), solveCoupledEquationSystemsByStaggeredScheme(), solveUncoupledEquationSystems(), BaseLib::RunTime::start(), and WARN().

outputSolutions()

template<typename OutputClass , typename OutputClassMember >

void ProcessLib::TimeLoop::outputSolutions ( bool const  output_initial_condition, unsigned  timestep, const double  t, OutputClass &  output_object, OutputClassMember  output_class_member  ) const

private

Definition at line 868 of file TimeLoop.cpp.

{
    // All _per_process_data share the first process.
    bool const is_staggered_coupling =
        !isMonolithicProcess(*_per_process_data[0]);
 
    for (auto& 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;
 
        if (!is_staggered_coupling && output_initial_condition)
        {
            auto const& ode_sys = *process_data->tdisc_ode_sys;
            // 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);
 
            auto& x_dot = NumLib::GlobalVectorProvider::provider.getVector(
                ode_sys.getMatrixSpecifications(process_id));
            x_dot.setZero();
 
            pcs.preTimestep(_process_solutions, _start_time, dt, process_id);
            // Update secondary variables, which might be uninitialized, before
            // output.
            pcs.computeSecondaryVariable(_start_time, dt, _process_solutions,
                                         x_dot, process_id);
 
            NumLib::GlobalVectorProvider::provider.releaseVector(x_dot);
        }
        if (is_staggered_coupling && output_initial_condition)
        {
            CoupledSolutionsForStaggeredScheme coupled_solutions(
                _process_solutions);
 
            process_data->process.setCoupledSolutionsForStaggeredScheme(
                &coupled_solutions);
            process_data->process
                .setCoupledTermForTheStaggeredSchemeToLocalAssemblers(
                    process_id);
 
            auto const& ode_sys = *process_data->tdisc_ode_sys;
            // 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);
 
            auto& x_dot = NumLib::GlobalVectorProvider::provider.getVector(
                ode_sys.getMatrixSpecifications(process_id));
            x_dot.setZero();
 
            pcs.preTimestep(_process_solutions, _start_time, dt, process_id);
            // Update secondary variables, which might be uninitialized, before
            // output.
            pcs.computeSecondaryVariable(_start_time, dt, _process_solutions,
                                         x_dot, process_id);
 
            NumLib::GlobalVectorProvider::provider.releaseVector(x_dot);
        }
        (output_object.*output_class_member)(
            pcs, process_id, timestep, t,
            process_data->nonlinear_solver_status.number_iterations,
            _process_solutions);
    }
}

References _per_process_data, _process_solutions, _start_time, NumLib::VectorProvider::getVector(), anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess(), NumLib::GlobalVectorProvider::provider, NumLib::VectorProvider::releaseVector(), and MathLib::EigenVector::setZero().

Referenced by initialize(), and loop().

setCoupledSolutions()

void ProcessLib::TimeLoop::setCoupledSolutions ( )

private

This function fills the vector of solutions of coupled processes of processes, _solutions_of_coupled_processes, and initializes the vector of solutions of the previous coupling iteration, _solutions_of_last_cpl_iteration.

Definition at line 343 of file TimeLoop.cpp.

{
    for (auto& process_data : _per_process_data)
    {
        auto const& x = *_process_solutions[process_data->process_id];
 
        // Create a vector to store the solution of the last coupling iteration
        auto& x0 = NumLib::GlobalVectorProvider::provider.getVector(x);
        MathLib::LinAlg::copy(x, x0);
 
        // append a solution vector of suitable size
        _solutions_of_last_cpl_iteration.emplace_back(&x0);
    }
}

References _per_process_data, _process_solutions, _solutions_of_last_cpl_iteration, MathLib::LinAlg::copy(), NumLib::VectorProvider::getVector(), and NumLib::GlobalVectorProvider::provider.

Referenced by initialize().

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 747 of file TimeLoop.cpp.

{
    // Coupling iteration
    if (_global_coupling_max_iterations != 0)
    {
        // Set the flag of the first iteration be true.
        for (auto& conv_crit : _global_coupling_conv_crit)
        {
            conv_crit->preFirstIteration();
        }
    }
    auto resetCouplingConvergenceCriteria = [&]()
    {
        for (auto& conv_crit : _global_coupling_conv_crit)
        {
            conv_crit->reset();
        }
    };
 
    NumLib::NonlinearSolverStatus nonlinear_solver_status{false, -1};
    bool coupling_iteration_converged = true;
    for (int global_coupling_iteration = 0;
         global_coupling_iteration < _global_coupling_max_iterations;
         global_coupling_iteration++, resetCouplingConvergenceCriteria())
    {
        // TODO(wenqing): use process name
        coupling_iteration_converged = true;
        _xdot_vector_ids.resize(_per_process_data.size());
        std::size_t cnt = 0;
        for (auto& process_data : _per_process_data)
        {
            auto const process_id = process_data->process_id;
            BaseLib::RunTime time_timestep_process;
            time_timestep_process.start();
 
            // The following setting of coupled_solutions can be removed only if
            // the CoupledSolutionsForStaggeredScheme and related functions are
            // removed totally from the computation of the secondary variable
            // and from post-time functions.
            CoupledSolutionsForStaggeredScheme coupled_solutions(
                _process_solutions);
 
            process_data->process.setCoupledSolutionsForStaggeredScheme(
                &coupled_solutions);
 
            nonlinear_solver_status = solveOneTimeStepOneProcess(
                _process_solutions, _process_solutions_prev, timestep_id, t, dt,
                *process_data, *_output, _xdot_vector_ids[cnt]);
            cnt++;
            process_data->nonlinear_solver_status = nonlinear_solver_status;
 
            INFO(
                "[time] Solving process #{:d} took {:g} s in time step #{:d}  "
                "coupling iteration #{:d}",
                process_id, time_timestep_process.elapsed(), timestep_id,
                global_coupling_iteration);
 
            if (!nonlinear_solver_status.error_norms_met)
            {
                WARN(
                    "The nonlinear solver failed in time step #{:d} at t = "
                    "{:g} s for process #{:d}.",
                    timestep_id, t, process_id);
                _last_step_rejected = true;
                return nonlinear_solver_status;
            }
 
            // Check the convergence of the coupling iteration
            auto& x = *_process_solutions[process_id];
            auto& x_old = *_solutions_of_last_cpl_iteration[process_id];
            if (global_coupling_iteration > 0)
            {
                MathLib::LinAlg::axpy(x_old, -1.0, x);  // save dx to x_old
                INFO(
                    "------- Checking convergence criterion for coupled "
                    "solution of process #{:d} -------",
                    process_id);
                _global_coupling_conv_crit[process_id]->checkDeltaX(x_old, x);
                coupling_iteration_converged =
                    coupling_iteration_converged &&
                    _global_coupling_conv_crit[process_id]->isSatisfied();
            }
            MathLib::LinAlg::copy(x, x_old);
        }  // end of for (auto& process_data : _per_process_data)
 
        if (coupling_iteration_converged && global_coupling_iteration > 0)
        {
            break;
        }
 
        if (!nonlinear_solver_status.error_norms_met)
        {
            return nonlinear_solver_status;
        }
    }
 
    if (!coupling_iteration_converged)
    {
        WARN(
            "The coupling iterations reaches its maximum number in time step "
            "#{:d} at t = {:g} s",
            timestep_id, t);
    }
 
    {
        for (auto& 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_conv_crit, _global_coupling_max_iterations, _last_step_rejected, _output, _per_process_data, _process_solutions, _process_solutions_prev, _solutions_of_last_cpl_iteration, _xdot_vector_ids, MathLib::LinAlg::axpy(), MathLib::LinAlg::copy(), BaseLib::RunTime::elapsed(), INFO(), ProcessLib::solveOneTimeStepOneProcess(), BaseLib::RunTime::start(), and WARN().

Referenced by loop().

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 706 of file TimeLoop.cpp.

{
    NumLib::NonlinearSolverStatus nonlinear_solver_status;
 
    _xdot_vector_ids.resize(_per_process_data.size());
    std::size_t cnt = 0;
 
    for (auto& 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, *_output, _xdot_vector_ids[cnt]);
        cnt++;
 
        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->timestepper->canReduceTimestepSize())
            {
                // save unsuccessful solution
                _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 _output, _per_process_data, _process_solutions, _process_solutions_prev, _xdot_vector_ids, ERR(), NumLib::NonlinearSolverStatus::error_norms_met, OGS_FATAL, ProcessLib::solveMonolithicProcess(), and ProcessLib::timestepper_cannot_reduce_dt.

Referenced by loop().

Member Data Documentation

_end_time

const double ProcessLib::TimeLoop::_end_time

private

Definition at line 116 of file TimeLoop.h.

Referenced by computeTimeStepping(), and loop().

_global_coupling_conv_crit

std::vector<std::unique_ptr<NumLib::ConvergenceCriterion> > ProcessLib::TimeLoop::_global_coupling_conv_crit

private

Convergence criteria of processes for the global coupling iterations.

Definition at line 122 of file TimeLoop.h.

Referenced by solveCoupledEquationSystemsByStaggeredScheme().

_global_coupling_max_iterations

const int ProcessLib::TimeLoop::_global_coupling_max_iterations

private

Maximum iterations of the global coupling.

Definition at line 119 of file TimeLoop.h.

Referenced by solveCoupledEquationSystemsByStaggeredScheme().

_last_step_rejected

bool ProcessLib::TimeLoop::_last_step_rejected = false

private

Definition at line 113 of file TimeLoop.h.

Referenced by computeTimeStepping(), loop(), and solveCoupledEquationSystemsByStaggeredScheme().

_output

std::unique_ptr<Output> ProcessLib::TimeLoop::_output

private

Definition at line 110 of file TimeLoop.h.

Referenced by computeTimeStepping(), initialize(), loop(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_per_process_data

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

private

Definition at line 111 of file TimeLoop.h.

Referenced by computeTimeStepping(), initialize(), loop(), outputSolutions(), setCoupledSolutions(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_process_solutions

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

private

Definition at line 108 of file TimeLoop.h.

Referenced by ~TimeLoop(), computeTimeStepping(), initialize(), loop(), outputSolutions(), setCoupledSolutions(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

_process_solutions_prev

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

private

Definition at line 109 of file TimeLoop.h.

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

_repeating_times_of_rejected_step

int ProcessLib::TimeLoop::_repeating_times_of_rejected_step = 0

private

Definition at line 114 of file TimeLoop.h.

Referenced by computeTimeStepping().

_solutions_of_last_cpl_iteration

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

private

Solutions of the previous coupling iteration for the convergence criteria of the coupling iteration.

Definition at line 126 of file TimeLoop.h.

Referenced by ~TimeLoop(), setCoupledSolutions(), and solveCoupledEquationSystemsByStaggeredScheme().

_start_time

const double ProcessLib::TimeLoop::_start_time

private

Definition at line 115 of file TimeLoop.h.

Referenced by initialize(), loop(), and outputSolutions().

_xdot_vector_ids

std::vector<std::size_t> ProcessLib::TimeLoop::_xdot_vector_ids

private

store the ids of the global xdot vectors in the global vector provider for reuse, needed in postTimestepForAllProcesses the length of the vector is the size of _per_process_data

Definition at line 131 of file TimeLoop.h.

Referenced by loop(), solveCoupledEquationSystemsByStaggeredScheme(), and solveUncoupledEquationSystems().

---

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

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