13#ifndef DUMUX_NEWTON_SOLVER_HH 
   14#define DUMUX_NEWTON_SOLVER_HH 
   23#include <dune/common/timer.hh> 
   24#include <dune/common/exceptions.hh> 
   25#include <dune/common/parallel/mpicommunication.hh> 
   26#include <dune/common/parallel/mpihelper.hh> 
   27#include <dune/common/std/type_traits.hh> 
   28#include <dune/common/indices.hh> 
   29#include <dune/common/hybridutilities.hh> 
   31#include <dune/istl/bvector.hh> 
   32#include <dune/istl/multitypeblockvector.hh> 
   54template<
class Assembler>
 
   56    = Dune::Std::is_detected_v<AssemblerGridVariablesType, Assembler>;
 
   59template<
class Assembler, 
bool exportsGr
idVars = assemblerExportsGr
idVariables<Assembler>>
 
   64template<
class Assembler>
 
   66{ 
using Type = 
struct EmptyGridVariables {}; };
 
 
   69template<
class Assembler>
 
   76    template<
class Assembler>
 
   78    -> 
decltype(a.assembleJacobianAndResidual(std::declval<const typename Assembler::SolutionVector&>(),
 
 
 
   87template<
class C> 
static constexpr auto hasStaticIndexAccess = Dune::Std::is_detected<staticIndexAccess, C>{};
 
   89template<
class V, 
class Scalar, 
class Reduce, 
class Transform>
 
   90auto hybridInnerProduct(
const V& v1, 
const V& v2, Scalar init, Reduce&& r, Transform&& t)
 
   91-> std::enable_if_t<hasDynamicIndexAccess<V>(), Scalar>
 
   93    return std::inner_product(v1.begin(), v1.end(), v2.begin(), init, std::forward<Reduce>(r), std::forward<Transform>(t));
 
 
   96template<
class V, 
class Scalar, 
class Reduce, 
class Transform>
 
   97auto hybridInnerProduct(
const V& v1, 
const V& v2, Scalar init, Reduce&& r, Transform&& t)
 
  100    using namespace Dune::Hybrid;
 
  101    forEach(std::make_index_sequence<V::N()>{}, [&](
auto i){
 
  102        init = r(init, 
hybridInnerProduct(v1[Dune::index_constant<i>{}], v2[Dune::index_constant<i>{}], init, std::forward<Reduce>(r), std::forward<Transform>(t)));
 
  110template<
class Scalar, 
class V>
 
  112-> std::enable_if_t<Dune::IsNumber<V>::value, Scalar>
 
  114    using std::abs; 
using std::max;
 
  115    return abs(v1 - v2)/max<Scalar>(1.0, abs(v1 + v2)*0.5);
 
 
  120template<
class Scalar, 
class V>
 
  122-> std::enable_if_t<!Dune::IsNumber<V>::value, Scalar>
 
  125        [](
const auto& a, 
const auto& b){ 
using std::max; 
return max(a, b); },
 
  130template<
class To, 
class From>
 
  131void assign(To& to, 
const From& from)
 
  135        using namespace Dune::Hybrid;
 
  136        forEach(std::make_index_sequence<To::N()>{}, [&](
auto i){
 
  137            assign(to[Dune::index_constant<i>{}], from[Dune::index_constant<i>{}]);
 
  141    else if constexpr (std::is_assignable<To&, From>::value)
 
  145        for (
decltype(to.size()) i = 0; i < to.size(); ++i)
 
  150        assert(to.size() == 1);
 
  156        assert(from.size() == 1);
 
  161        DUNE_THROW(Dune::Exception, 
"Values are not assignable to each other!");
 
 
 
  181          class Comm = Dune::Communication<Dune::MPIHelper::MPICommunicator> >
 
  192    using Scalar = 
typename Assembler::Scalar;
 
  193    using JacobianMatrix = 
typename Assembler::JacobianMatrix;
 
  200    using PriVarSwitchVariables
 
  201        = std::conditional_t<assemblerExportsVariables,
 
  214                 const std::string& paramGroupName = 
"Newton",
 
  220    , solverName_(paramGroupName)
 
  221    , priVarSwitchAdapter_(std::make_unique<PrimaryVariableSwitchAdapter>(
paramGroup))
 
  235        if (enablePartialReassembly_)
 
  236            partialReassembler_ = std::make_unique<Reassembler>(this->
assembler());
 
 
  251    { shiftTolerance_ = tolerance; }
 
  260    { residualTolerance_ = tolerance; }
 
  269    { reductionTolerance_ = tolerance; }
 
  311        if constexpr (!assemblerExportsVariables)
 
  313            if (this->
assembler().isStationaryProblem())
 
  314                DUNE_THROW(Dune::InvalidStateException, 
"Using time step control with stationary problem makes no sense!");
 
  318        for (std::size_t i = 0; i <= maxTimeStepDivisions_; ++i)
 
  321            const bool converged = solve_(vars);
 
  326            else if (!converged && i < maxTimeStepDivisions_)
 
  328                if constexpr (assemblerExportsVariables)
 
  329                    DUNE_THROW(Dune::NotImplemented, 
"Time step reset for new assembly methods");
 
  333                    Backend::update(vars, this->
assembler().prevSol());
 
  334                    this->
assembler().resetTimeStep(Backend::dofs(vars));
 
  339                        std::cout << Fmt::format(
"{} solver did not converge with dt = {} seconds. ", solverName_, dt)
 
  340                                  << Fmt::format(
"Retrying with time step of dt = {} seconds.\n", dt*retryTimeStepReductionFactor_);
 
  351                    Fmt::format(
"{} solver didn't converge after {} time-step divisions; dt = {}.\n",
 
  352                                solverName_, maxTimeStepDivisions_, timeLoop.
timeStepSize()));
 
 
  365        const bool converged = solve_(vars);
 
  368                Fmt::format(
"{} solver didn't converge after {} iterations.\n", solverName_, 
numSteps_));
 
 
  396            if constexpr (assemblerExportsVariables)
 
  397                priVarSwitchAdapter_->initialize(Backend::dofs(initVars), initVars);
 
  399                priVarSwitchAdapter_->initialize(initVars, this->
assembler().gridVariables());
 
  403        const auto& initSol = Backend::dofs(initVars);
 
  406        if (convergenceWriter_)
 
  408            this->
assembler().assembleResidual(initVars);
 
  411            ResidualVector delta = LinearAlgebraNativeBackend::zeros(Backend::size(initSol));
 
  412            convergenceWriter_->write(initSol, delta, this->
assembler().residual());
 
  415        if (enablePartialReassembly_)
 
  417            partialReassembler_->resetColors();
 
  418            resizeDistanceFromLastLinearization_(initSol, distanceFromLastLinearization_);
 
 
  439            if (enableShiftCriterion_)
 
 
  471        assembleLinearSystem_(this->
assembler(), vars);
 
  473        if (enablePartialReassembly_)
 
 
  490        bool converged = 
false;
 
  501        catch (
const Dune::Exception &e)
 
  504                std::cout << solverName_ << 
": Caught exception from the linear solver: \"" << e.what() << 
"\"\n";
 
  510        int convergedRemote = converged;
 
  511        if (comm_.size() > 1)
 
  512            convergedRemote = comm_.min(converged);
 
  517            ++numLinearSolverBreakdowns_;
 
  519        else if (!convergedRemote)
 
  521            DUNE_THROW(
NumericalProblem, 
"Linear solver did not converge on a remote process");
 
  522            ++numLinearSolverBreakdowns_; 
 
 
  555            auto uCurrentIter = uLastIter;
 
  556            Backend::axpy(-1.0, deltaU, uCurrentIter);
 
  559            if (enableResidualCriterion_)
 
  563        if (enableShiftCriterion_ || enablePartialReassembly_)
 
  566        if (enablePartialReassembly_) {
 
  586            auto reassemblyThreshold = max(reassemblyMinThreshold_,
 
  587                                           min(reassemblyMaxThreshold_,
 
  588                                               shift_*reassemblyShiftWeight_));
 
  590            auto actualDeltaU = uLastIter;
 
  591            actualDeltaU -= Backend::dofs(vars);
 
  592            updateDistanceFromLastLinearization_(uLastIter, actualDeltaU);
 
  593            partialReassembler_->computeColors(this->
assembler(),
 
  594                                               distanceFromLastLinearization_,
 
  595                                               reassemblyThreshold);
 
  598            for (
unsigned int i = 0; i < distanceFromLastLinearization_.size(); i++)
 
  600                    distanceFromLastLinearization_[i] = 0;
 
 
  615            if constexpr (assemblerExportsVariables)
 
  616                priVarSwitchAdapter_->invoke(Backend::dofs(vars), vars);
 
  618                priVarSwitchAdapter_->invoke(vars, this->
assembler().gridVariables());
 
  625            if (enableDynamicOutput_)
 
  628            const auto width = Fmt::formatted_size(
"{}", 
maxSteps_);
 
  629            std::cout << Fmt::format(
"{} iteration {:{}} done", solverName_, 
numSteps_, width);
 
  631            if (enableShiftCriterion_)
 
  632                std::cout << Fmt::format(
", maximum relative shift = {:.4e}", 
shift_);
 
  633            if (enableResidualCriterion_ || enableAbsoluteResidualCriterion_)
 
 
  659        if (priVarSwitchAdapter_->switched())
 
  662        if (enableShiftCriterion_ && !enableResidualCriterion_)
 
  664            return shift_ <= shiftTolerance_;
 
  666        else if (!enableShiftCriterion_ && enableResidualCriterion_)
 
  668            if(enableAbsoluteResidualCriterion_)
 
  673        else if (satisfyResidualAndShiftCriterion_)
 
  675            if(enableAbsoluteResidualCriterion_)
 
  676                return shift_ <= shiftTolerance_
 
  679                return shift_ <= shiftTolerance_
 
  682        else if(enableShiftCriterion_ && enableResidualCriterion_)
 
  684            if(enableAbsoluteResidualCriterion_)
 
  685                return shift_ <= shiftTolerance_
 
  688                return shift_ <= shiftTolerance_
 
  693            return shift_ <= shiftTolerance_
 
 
  716    void report(std::ostream& sout = std::cout)
 const 
  719             << solverName_ << 
" statistics\n" 
  720             << 
"----------------------------------------------\n" 
  721             << 
"-- Total iterations:                   " << totalWastedIter_ + totalSucceededIter_ << 
'\n' 
  722             << 
"-- Total wasted iterations:            " << totalWastedIter_ << 
'\n' 
  723             << 
"-- Total succeeded iterations:         " << totalSucceededIter_ << 
'\n' 
  724             << 
"-- Average iterations per solve:       " << std::setprecision(3) << double(totalSucceededIter_) / double(numConverged_) << 
'\n' 
  725             << 
"-- Number of linear solver breakdowns: " << numLinearSolverBreakdowns_ << 
'\n' 
 
  734        totalWastedIter_ = 0;
 
  735        totalSucceededIter_ = 0;
 
  737        numLinearSolverBreakdowns_ = 0;
 
 
  745        sout << 
"\n" << solverName_ << 
" solver configured with the following options and parameters:\n";
 
  747        if (useLineSearch_) sout << 
" -- " << solverName_ << 
".UseLineSearch = true\n";
 
  748        if (useChop_) sout << 
" -- " << solverName_ << 
".EnableChop = true\n";
 
  749        if (enablePartialReassembly_) sout << 
" -- " << solverName_ << 
".EnablePartialReassembly = true\n";
 
  750        if (enableAbsoluteResidualCriterion_) sout << 
" -- " << solverName_ << 
".EnableAbsoluteResidualCriterion = true\n";
 
  751        if (enableShiftCriterion_) sout << 
" -- " << solverName_ << 
".EnableShiftCriterion = true (relative shift convergence criterion)\n";
 
  752        if (enableResidualCriterion_) sout << 
" -- " << solverName_ << 
".EnableResidualCriterion = true\n";
 
  753        if (satisfyResidualAndShiftCriterion_) sout << 
" -- " << solverName_ << 
".SatisfyResidualAndShiftCriterion = true\n";
 
  755        if (enableShiftCriterion_) sout << 
" -- " << solverName_ << 
".MaxRelativeShift = " << shiftTolerance_ << 
'\n';
 
  756        if (enableAbsoluteResidualCriterion_) sout << 
" -- " << solverName_ << 
".MaxAbsoluteResidual = " << residualTolerance_ << 
'\n';
 
  757        if (enableResidualCriterion_) sout << 
" -- " << solverName_ << 
".ResidualReduction = " << reductionTolerance_ << 
'\n';
 
  758        sout << 
" -- " << solverName_ << 
".MinSteps = " << 
minSteps_ << 
'\n';
 
  759        sout << 
" -- " << solverName_ << 
".MaxSteps = " << 
maxSteps_ << 
'\n';
 
  760        sout << 
" -- " << solverName_ << 
".TargetSteps = " << 
targetSteps_ << 
'\n';
 
  761        if (enablePartialReassembly_)
 
  763            sout << 
" -- " << solverName_ << 
".ReassemblyMinThreshold = " << reassemblyMinThreshold_ << 
'\n';
 
  764            sout << 
" -- " << solverName_ << 
".ReassemblyMaxThreshold = " << reassemblyMaxThreshold_ << 
'\n';
 
  765            sout << 
" -- " << solverName_ << 
".ReassemblyShiftWeight = " << reassemblyShiftWeight_ << 
'\n';
 
  767        sout << 
" -- " << solverName_ << 
".RetryTimeStepReductionFactor = " << retryTimeStepReductionFactor_ << 
'\n';
 
  768        sout << 
" -- " << solverName_ << 
".MaxTimeStepDivisions = " << maxTimeStepDivisions_ << 
'\n';
 
 
  789            return oldTimeStep/(1.0 + percent);
 
  793        return oldTimeStep*(1.0 + percent/1.2);
 
 
  800    { verbosity_ = val; }
 
  806    { 
return verbosity_ ; }
 
  812    { useLineSearch_ = val; }
 
  818    { 
return useLineSearch_; }
 
  824    { 
return paramGroup_; }
 
  830    { convergenceWriter_ = convWriter; }
 
  836    { convergenceWriter_ = 
nullptr; }
 
  842    { 
return retryTimeStepReductionFactor_; }
 
  848    { retryTimeStepReductionFactor_ = factor; }
 
  859        Backend::update(vars, uCurrentIter);
 
  861        if constexpr (!assemblerExportsVariables)
 
  862            this->
assembler().updateGridVariables(Backend::dofs(vars));
 
 
  869        if constexpr (!assemblerExportsVariables)
 
  870            this->
assembler().assembleResidual(Backend::dofs(vars));
 
  872            this->
assembler().assembleResidual(vars);
 
 
  880    { 
return enableResidualCriterion_; }
 
  919            auto uLastIter = Backend::dofs(vars);
 
  920            ResidualVector deltaU = LinearAlgebraNativeBackend::zeros(Backend::size(Backend::dofs(vars)));
 
  924            Dune::Timer assembleTimer(
false);
 
  925            Dune::Timer solveTimer(
false);
 
  926            Dune::Timer updateTimer(
false);
 
  930            bool converged = 
false;
 
  939                    uLastIter = Backend::dofs(vars);
 
  941                if (verbosity_ >= 1 && enableDynamicOutput_)
 
  942                    std::cout << 
"Assemble: r(x^k) = dS/dt + div F - q;   M = grad r" 
  950                assembleTimer.start();
 
  952                assembleTimer.stop();
 
  961                const char clearRemainingLine[] = { 0x1b, 
'[', 
'K', 0 };
 
  963                if (verbosity_ >= 1 && enableDynamicOutput_)
 
  964                    std::cout << 
"\rSolve: M deltax^k = r" 
  965                              << clearRemainingLine << std::flush;
 
  979                if (verbosity_ >= 1 && enableDynamicOutput_)
 
  980                    std::cout << 
"\rUpdate: x^(k+1) = x^k - deltax^k" 
  981                              << clearRemainingLine << std::flush;
 
  993                if (convergenceWriter_)
 
  995                    this->
assembler().assembleResidual(vars);
 
  996                    convergenceWriter_->write(Backend::dofs(vars), deltaU, this->
assembler().residual());
 
 1020            if (verbosity_ >= 1) {
 
 1021                const auto elapsedTot = assembleTimer.elapsed() + solveTimer.elapsed() + updateTimer.elapsed();
 
 1022                std::cout << Fmt::format(
"Assemble/solve/update time: {:.2g}({:.2f}%)/{:.2g}({:.2f}%)/{:.2g}({:.2f}%)\n",
 
 1023                                         assembleTimer.elapsed(), 100*assembleTimer.elapsed()/elapsedTot,
 
 1024                                         solveTimer.elapsed(), 100*solveTimer.elapsed()/elapsedTot,
 
 1025                                         updateTimer.elapsed(), 100*updateTimer.elapsed()/elapsedTot);
 
 1032            if (verbosity_ >= 1)
 
 1033                std::cout << solverName_ << 
": Caught exception: \"" << e.what() << 
"\"\n";
 
 1047        this->
assembler().assembleJacobianAndResidual(vars, partialReassembler_.get());
 
 1052    auto assembleLinearSystem_(
const A& assembler, 
const Variables& vars)
 
 1053    -> 
typename std::enable_if_t<!
decltype(
isValid(Detail::Newton::supportsPartialReassembly())(assembler))::value, 
void>
 
 1055        this->assembler().assembleJacobianAndResidual(vars);
 
 1065    [[deprecated(
"Use computeShift_(u1, u2) instead")]]
 
 1069        auto uNew = uLastIter;
 
 1070        Backend::axpy(-1.0, deltaU, uNew);
 
 
 1082        if (comm_.size() > 1)
 
 
 1098        Scalar lambda = 1.0;
 
 1099        auto uCurrentIter = uLastIter;
 
 1103            Backend::axpy(-lambda, deltaU, uCurrentIter);
 
 1116            uCurrentIter = uLastIter;
 
 
 1132        DUNE_THROW(Dune::NotImplemented,
 
 1133                   "Chopped " << solverName_ << 
" solver update strategy not implemented.");
 
 
 1145        return this->linearSolver().solve(
 
 1146            this->assembler().jacobian(),
 
 1148            this->assembler().residual()
 
 
 1153    void initParams_(
const std::string& group = 
"")
 
 1156        lineSearchMinRelaxationFactor_ = 
getParamFromGroup<Scalar>(group, solverName_ + 
".LineSearchMinRelaxationFactor", 0.125);
 
 1158        if(useLineSearch_ && useChop_)
 
 1159            DUNE_THROW(Dune::InvalidStateException, 
"Use either linesearch OR chop!");
 
 1161        enableAbsoluteResidualCriterion_ = 
getParamFromGroup<bool>(group, solverName_ + 
".EnableAbsoluteResidualCriterion", 
false);
 
 1163        enableResidualCriterion_ = 
getParamFromGroup<bool>(group, solverName_ + 
".EnableResidualCriterion", 
false) || enableAbsoluteResidualCriterion_;
 
 1164        satisfyResidualAndShiftCriterion_ = 
getParamFromGroup<bool>(group, solverName_ + 
".SatisfyResidualAndShiftCriterion", 
false);
 
 1167        if (!enableShiftCriterion_ && !enableResidualCriterion_)
 
 1169            DUNE_THROW(Dune::NotImplemented,
 
 1170                       "at least one of " << solverName_ << 
".EnableShiftCriterion or " 
 1171                       << solverName_ << 
".EnableResidualCriterion has to be set to true");
 
 1182        reassemblyMinThreshold_ = 
getParamFromGroup<Scalar>(group, solverName_ + 
".ReassemblyMinThreshold", 1e-1*shiftTolerance_);
 
 1183        reassemblyMaxThreshold_ = 
getParamFromGroup<Scalar>(group, solverName_ + 
".ReassemblyMaxThreshold", 1e2*shiftTolerance_);
 
 1192        if (verbosity_ >= 2)
 
 1196    template<
class SolA, 
class SolB>
 
 1197    void updateDistanceFromLastLinearization_(
const SolA& 
u, 
const SolB& uDelta)
 
 1199        if constexpr (Dune::IsNumber<SolA>::value)
 
 1201            auto nextPriVars = 
u;
 
 1202            nextPriVars -= uDelta;
 
 1206            distanceFromLastLinearization_[0] += shift;
 
 1210            for (std::size_t i = 0; i < 
u.size(); ++i)
 
 1212                const auto& currentPriVars(
u[i]);
 
 1213                auto nextPriVars(currentPriVars);
 
 1214                nextPriVars -= uDelta[i];
 
 1218                distanceFromLastLinearization_[i] += shift;
 
 1223    template<
class ...ArgsA, 
class...ArgsB>
 
 1224    void updateDistanceFromLastLinearization_(
const Dune::MultiTypeBlockVector<ArgsA...>& uLastIter,
 
 1225                                              const Dune::MultiTypeBlockVector<ArgsB...>& deltaU)
 
 1227        DUNE_THROW(Dune::NotImplemented, 
"Reassembly for MultiTypeBlockVector");
 
 1231    void resizeDistanceFromLastLinearization_(
const Sol& 
u, std::vector<Scalar>& dist)
 
 1233        dist.assign(Backend::size(
u), 0.0);
 
 1236    template<
class ...Args>
 
 1237    void resizeDistanceFromLastLinearization_(
const Dune::MultiTypeBlockVector<Args...>& 
u,
 
 1238                                              std::vector<Scalar>& dist)
 
 1240        DUNE_THROW(Dune::NotImplemented, 
"Reassembly for MultiTypeBlockVector");
 
 1244    Communication comm_;
 
 1249    Scalar shiftTolerance_;
 
 1250    Scalar reductionTolerance_;
 
 1251    Scalar residualTolerance_;
 
 1254    std::size_t maxTimeStepDivisions_;
 
 1255    Scalar retryTimeStepReductionFactor_;
 
 1258    bool useLineSearch_;
 
 1259    Scalar lineSearchMinRelaxationFactor_;
 
 1261    bool enableAbsoluteResidualCriterion_;
 
 1262    bool enableShiftCriterion_;
 
 1263    bool enableResidualCriterion_;
 
 1264    bool satisfyResidualAndShiftCriterion_;
 
 1265    bool enableDynamicOutput_;
 
 1268    std::string paramGroup_;
 
 1270    std::string solverName_;
 
 1273    bool enablePartialReassembly_;
 
 1274    std::unique_ptr<Reassembler> partialReassembler_;
 
 1275    std::vector<Scalar> distanceFromLastLinearization_;
 
 1276    Scalar reassemblyMinThreshold_;
 
 1277    Scalar reassemblyMaxThreshold_;
 
 1278    Scalar reassemblyShiftWeight_;
 
 1281    std::size_t totalWastedIter_ = 0; 
 
 1282    std::size_t totalSucceededIter_ = 0; 
 
 1283    std::size_t numConverged_ = 0; 
 
 1284    std::size_t numLinearSolverBreakdowns_ = 0; 
 
 1287    std::unique_ptr<PrimaryVariableSwitchAdapter> priVarSwitchAdapter_;
 
 1290    std::shared_ptr<ConvergenceWriter> convergenceWriter_ = 
nullptr;
 
 
Base class for linear solvers.
Definition solver.hh:27
Comm Communication
Definition nonlinear/newtonsolver.hh:207
virtual void newtonFail(Variables &u)
Called if the Newton method broke down. This method is called after newtonEnd()
Definition nonlinear/newtonsolver.hh:704
int maxSteps_
Definition nonlinear/newtonsolver.hh:886
void setMaxSteps(int maxSteps)
Set the number of iterations after which the Newton method gives up.
Definition nonlinear/newtonsolver.hh:298
typename Assembler::ResidualType ResidualVector
Definition nonlinear/newtonsolver.hh:189
void solveLinearSystem(ResidualVector &deltaU)
Solve the linear system of equations .
Definition nonlinear/newtonsolver.hh:487
void setResidualReduction(Scalar tolerance)
Set the maximum acceptable residual norm reduction.
Definition nonlinear/newtonsolver.hh:267
void reportParams(std::ostream &sout=std::cout) const
Report the options and parameters this Newton is configured with.
Definition nonlinear/newtonsolver.hh:742
int targetSteps_
Definition nonlinear/newtonsolver.hh:882
const std::string & paramGroup() const
Definition nonlinear/newtonsolver.hh:822
void setRetryTimeStepReductionFactor(const Scalar factor)
Set the factor for reducing the time step after a Newton iteration has failed.
Definition nonlinear/newtonsolver.hh:846
Scalar reduction_
Definition nonlinear/newtonsolver.hh:891
Scalar retryTimeStepReductionFactor() const
Return the factor for reducing the time step after a Newton iteration has failed.
Definition nonlinear/newtonsolver.hh:840
bool useLineSearch() const
Return whether line search is enabled or not.
Definition nonlinear/newtonsolver.hh:816
int numSteps_
Definition nonlinear/newtonsolver.hh:888
virtual void newtonComputeShift_(const SolutionVector &u1, const SolutionVector &u2)
Update the maximum relative shift of one solution compared to another.
Definition nonlinear/newtonsolver.hh:1077
int verbosity() const
Definition nonlinear/newtonsolver.hh:804
void setMinSteps(int minSteps)
Set the number of minimum iterations for the Newton method.
Definition nonlinear/newtonsolver.hh:289
void newtonUpdate(Variables &vars, const SolutionVector &uLastIter, const ResidualVector &deltaU)
Update the current solution with a delta vector.
Definition nonlinear/newtonsolver.hh:542
virtual void choppedUpdate_(Variables &vars, const SolutionVector &uLastIter, const ResidualVector &deltaU)
Use a custom chopped update strategy (do not use the full update)
Definition nonlinear/newtonsolver.hh:1127
int minSteps_
Definition nonlinear/newtonsolver.hh:884
virtual void newtonBegin(Variables &initVars)
Called before the Newton method is applied to an non-linear system of equations.
Definition nonlinear/newtonsolver.hh:389
virtual void assembleLinearSystem(const Variables &vars)
Assemble the linear system of equations .
Definition nonlinear/newtonsolver.hh:468
bool enableResidualCriterion() const
Definition nonlinear/newtonsolver.hh:878
virtual bool newtonProceed(const Variables &varsCurrentIter, bool converged)
Returns true if another iteration should be done.
Definition nonlinear/newtonsolver.hh:427
void solve(Variables &vars, TimeLoop &timeLoop) override
Run the Newton method to solve a non-linear system. Does time step control when the Newton fails to c...
Definition nonlinear/newtonsolver.hh:308
virtual void newtonEndStep(Variables &vars, const SolutionVector &uLastIter)
Indicates that one Newton iteration was finished.
Definition nonlinear/newtonsolver.hh:609
virtual bool solveLinearSystem_(ResidualVector &deltaU)
Solve the linear system of equations .
Definition nonlinear/newtonsolver.hh:1140
NewtonSolver(std::shared_ptr< Assembler > assembler, std::shared_ptr< LinearSolver > linearSolver, const Communication &comm=Dune::MPIHelper::getCommunication(), const std::string ¶mGroup="", const std::string ¶mGroupName="Newton", int verbosity=2)
Definition nonlinear/newtonsolver.hh:209
virtual void solutionChanged_(Variables &vars, const SolutionVector &uCurrentIter)
Update solution-dependent quantities like grid variables after the solution has changed.
Definition nonlinear/newtonsolver.hh:856
void report(std::ostream &sout=std::cout) const
output statistics / report
Definition nonlinear/newtonsolver.hh:715
bool apply(Variables &vars) override
Run the Newton method to solve a non-linear system. The solver is responsible for all the strategic d...
Definition nonlinear/newtonsolver.hh:378
virtual void newtonSucceed()
Called if the Newton method ended successfully This method is called after newtonEnd()
Definition nonlinear/newtonsolver.hh:710
void attachConvergenceWriter(std::shared_ptr< ConvergenceWriter > convWriter)
Attach a convergence writer to write out intermediate results after each iteration.
Definition nonlinear/newtonsolver.hh:828
Scalar initialResidual_
Definition nonlinear/newtonsolver.hh:894
Scalar lastReduction_
Definition nonlinear/newtonsolver.hh:893
void setUseLineSearch(bool val=true)
Specify whether line search is enabled or not.
Definition nonlinear/newtonsolver.hh:810
virtual void newtonBeginStep(const Variables &vars)
Indicates the beginning of a Newton iteration.
Definition nonlinear/newtonsolver.hh:450
std::ostringstream endIterMsgStream_
Definition nonlinear/newtonsolver.hh:901
void setVerbosity(int val)
Specify the verbosity level.
Definition nonlinear/newtonsolver.hh:798
typename Backend::DofVector SolutionVector
Definition nonlinear/newtonsolver.hh:188
const Communication & comm() const
Definition nonlinear/newtonsolver.hh:239
void resetReport()
reset the statistics
Definition nonlinear/newtonsolver.hh:731
VariablesBackend< typename ParentType::Variables > Backend
Definition nonlinear/newtonsolver.hh:187
void setMaxAbsoluteResidual(Scalar tolerance)
Set the maximum acceptable absolute residual for declaring convergence.
Definition nonlinear/newtonsolver.hh:258
virtual void newtonEnd()
Called if the Newton method ended (not known yet if we failed or succeeded)
Definition nonlinear/newtonsolver.hh:648
void setTargetSteps(int targetSteps)
Set the number of iterations at which the Newton method should aim at.
Definition nonlinear/newtonsolver.hh:280
virtual bool newtonConverged() const
Returns true if the error of the solution is below the tolerance.
Definition nonlinear/newtonsolver.hh:654
Scalar suggestTimeStepSize(Scalar oldTimeStep) const
Suggest a new time-step size based on the old time-step size.
Definition nonlinear/newtonsolver.hh:779
void detachConvergenceWriter()
Detach the convergence writer to stop the output.
Definition nonlinear/newtonsolver.hh:834
VariablesBackend< ResidualVector > LinearAlgebraNativeBackend
Definition nonlinear/newtonsolver.hh:190
void setMaxRelativeShift(Scalar tolerance)
Set the maximum acceptable difference of any primary variable between two iterations for declaring co...
Definition nonlinear/newtonsolver.hh:249
Scalar shift_
Definition nonlinear/newtonsolver.hh:897
void computeResidualReduction_(const Variables &vars)
Definition nonlinear/newtonsolver.hh:864
Scalar residualNorm_
Definition nonlinear/newtonsolver.hh:892
virtual void lineSearchUpdate_(Variables &vars, const SolutionVector &uLastIter, const ResidualVector &deltaU)
Use a line search update based on simple backtracking.
Definition nonlinear/newtonsolver.hh:1093
virtual void newtonUpdateShift_(const SolutionVector &uLastIter, const ResidualVector &deltaU)
Definition nonlinear/newtonsolver.hh:1065
Scalar lastShift_
Definition nonlinear/newtonsolver.hh:898
Exception thrown if a fixable numerical problem occurs.
Definition exceptions.hh:27
bool checkSizesOfSubMatrices(const Dune::MultiTypeBlockMatrix< FirstRow, Args... > &matrix) const
Definition common/pdesolver.hh:148
const LinearSolver & linearSolver() const
Definition common/pdesolver.hh:133
const Assembler & assembler() const
Definition common/pdesolver.hh:121
PDESolver(std::shared_ptr< Assembler > assembler, std::shared_ptr< LinearSolver > linearSolver)
Definition common/pdesolver.hh:78
Detail::PDESolver::AssemblerVariables< Assembler > Variables
Definition common/pdesolver.hh:71
detects which entries in the Jacobian have to be recomputed
Definition partialreassembler.hh:420
An adapter for the Newton to manage models with primary variable switch.
Definition primaryvariableswitchadapter.hh:44
Manages the handling of time dependent problems.
Definition common/timeloop.hh:84
virtual void setTimeStepSize(Scalar dt)=0
Set the current time step size to a given value.
virtual Scalar timeStepSize() const =0
Returns the suggested time step length .
Defines a high-level interface for a PDESolver.
Manages the handling of time dependent problems.
Some exceptions thrown in DuMux
@ red
distance from last linearization is above the tolerance
Definition entitycolor.hh:25
Detail::VariablesBackend< Vars, Dune::Std::is_detected_v< Detail::SolutionVectorType, Vars > > VariablesBackend
Class providing operations for generic variable classes that represent the state of a numerical solut...
Definition variablesbackend.hh:253
constexpr bool hasPriVarsSwitch
Helper boolean to check if the given variables involve primary variable switching.
Definition primaryvariableswitchadapter.hh:36
T getParamFromGroup(Args &&... args)
A free function to get a parameter from the parameter tree singleton with a model group.
Definition parameters.hh:149
constexpr auto isValid(const Expression &t)
A function that creates a test functor to do class member introspection at compile time.
Definition isvalid.hh:81
A helper function for class member function introspection.
A helper class that converts a Dune::MultiTypeBlockMatrix into a plain Dune::BCRSMatrix.
Definition nonlinear/newtonsolver.hh:50
typename Assembler::GridVariables AssemblerGridVariablesType
Definition nonlinear/newtonsolver.hh:53
static constexpr auto hasStaticIndexAccess
Definition nonlinear/newtonsolver.hh:86
auto maxRelativeShift(const V &v1, const V &v2) -> std::enable_if_t< Dune::IsNumber< V >::value, Scalar >
Definition nonlinear/newtonsolver.hh:110
void assign(To &to, const From &from)
Definition nonlinear/newtonsolver.hh:130
auto hybridInnerProduct(const V &v1, const V &v2, Scalar init, Reduce &&r, Transform &&t) -> std::enable_if_t< hasDynamicIndexAccess< V >(), Scalar >
Definition nonlinear/newtonsolver.hh:89
decltype(std::declval< C >()[Dune::Indices::_0]) staticIndexAccess
Definition nonlinear/newtonsolver.hh:84
decltype(std::declval< C >()[0]) dynamicIndexAccess
Definition nonlinear/newtonsolver.hh:83
typename PriVarSwitchVariablesType< Assembler, assemblerExportsGridVariables< Assembler > >::Type PriVarSwitchVariables
Definition nonlinear/newtonsolver.hh:70
static constexpr auto hasDynamicIndexAccess
Definition nonlinear/newtonsolver.hh:85
constexpr bool assemblerExportsGridVariables
Definition nonlinear/newtonsolver.hh:56
constexpr bool assemblerExportsVariables
Definition common/pdesolver.hh:35
const Scalar PengRobinsonMixture< Scalar, StaticParameters >::u
Definition pengrobinsonmixture.hh:138
This class provides the infrastructure to write the convergence behaviour of the newton method into a...
The infrastructure to retrieve run-time parameters from Dune::ParameterTrees.
Detects which entries in the Jacobian have to be recomputed.
An adapter for the Newton to manage models with primary variable switch.
A convergence writer interface Provide an interface that show the minimal requirements a convergence ...
Definition nonlinear/newtonconvergencewriter.hh:32
struct EmptyGridVariables {} Type
Definition nonlinear/newtonsolver.hh:66
Definition nonlinear/newtonsolver.hh:60
typename Assembler::GridVariables Type
Definition nonlinear/newtonsolver.hh:60
helper struct detecting if an assembler supports partial reassembly
Definition nonlinear/newtonsolver.hh:74
auto operator()(Assembler &&a) -> decltype(a.assembleJacobianAndResidual(std::declval< const typename Assembler::SolutionVector & >(), std::declval< const PartialReassembler< Assembler > * >()))
Definition nonlinear/newtonsolver.hh:76
Backends for operations on different solution vector types or more generic variable classes to be use...
Type traits to be used with vector types.