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.