anonymous_namespace{TimeLoop.cpp} Namespace Reference

Functions
void	setEquationSystem (NumLib::NonlinearSolverBase &nonlinear_solver, NumLib::EquationSystem &eq_sys, NumLib::ConvergenceCriterion &conv_crit, NumLib::NonlinearSolverTag nl_tag)
bool	isMonolithicProcess (ProcessLib::ProcessData const &process_data)

Function Documentation

isMonolithicProcess()

bool anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess

(

ProcessLib::ProcessData const &

process_data

)

Definition at line 82 of file TimeLoop.cpp.

{
    return process_data.process.isMonolithicSchemeUsed();
}

References ProcessLib::Process::isMonolithicSchemeUsed(), and ProcessLib::ProcessData::process.

Referenced by ProcessLib::TimeLoop::initialize(), ProcessLib::TimeLoop::loop(), ProcessLib::TimeLoop::outputSolutions(), and ProcessLib::postTimestepForAllProcesses().

setEquationSystem()

void anonymous_namespace{TimeLoop.cpp}::setEquationSystem	(	NumLib::NonlinearSolverBase &	nonlinear_solver,
		NumLib::EquationSystem &	eq_sys,
		NumLib::ConvergenceCriterion &	conv_crit,
		NumLib::NonlinearSolverTag	nl_tag
	)

Definition at line 25 of file TimeLoop.cpp.

{
    using Tag = NumLib::NonlinearSolverTag;
    switch (nl_tag)
    {
        case Tag::Picard:
        {
            using EqSys = NumLib::NonlinearSystem<Tag::Picard>;
            auto& eq_sys_ = static_cast<EqSys&>(eq_sys);
            if (auto* nl_solver =
                    dynamic_cast<NumLib::NonlinearSolver<Tag::Picard>*>(
                        &nonlinear_solver);
                nl_solver != nullptr)
            {
                nl_solver->setEquationSystem(eq_sys_, conv_crit);
            }
            else
            {
                OGS_FATAL(
                    "Could not cast nonlinear solver to Picard type solver.");
            }
            break;
        }
        case Tag::Newton:
        {
            using EqSys = NumLib::NonlinearSystem<Tag::Newton>;
            auto& eq_sys_ = static_cast<EqSys&>(eq_sys);
 
            if (auto* nl_solver =
                    dynamic_cast<NumLib::NonlinearSolver<Tag::Newton>*>(
                        &nonlinear_solver);
                nl_solver != nullptr)
            {
                nl_solver->setEquationSystem(eq_sys_, conv_crit);
            }
#ifdef USE_PETSC
            else if (auto* nl_solver =
                         dynamic_cast<NumLib::PETScNonlinearSolver*>(
                             &nonlinear_solver);
                     nl_solver != nullptr)
            {
                nl_solver->setEquationSystem(eq_sys_, conv_crit);
            }
#endif  // USE_PETSC
            else
            {
                OGS_FATAL(
                    "Could not cast nonlinear solver to Newton type solver.");
            }
            break;
        }
    }
}

References OGS_FATAL.

Referenced by ProcessLib::calculateNonEquilibriumInitialResiduum(), and ProcessLib::solveOneTimeStepOneProcess().