diff --git a/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh b/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh
index f086757e677c3cca105485f519fa63d4f1c3498d..e53d359dfc7e53d7fa1d70054345bb58d3a3386f 100644
--- a/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh
+++ b/dumux/decoupled/1p/diffusion/fv/fvpressure1p.hh
@@ -278,11 +278,12 @@ void FVPressure1P<TypeTag>::assemble(bool first)
// get absolute permeability
FieldMatrix permeabilityI(problem_.spatialParameters().intrinsicPermeability(globalPos, *eIt));
+ int isIndex = 0;
IntersectionIterator isItEnd = problem_.gridView().iend(*eIt);
- for (IntersectionIterator isIt = problem_.gridView().ibegin(*eIt); isIt != isItEnd; ++isIt)
+ for (IntersectionIterator isIt = problem_.gridView().ibegin(*eIt);
+ isIt != isItEnd;
+ ++isIt, ++isIndex)
{
- int isIndex = isIt->indexInInside();
-
// get normal vector
Dune::FieldVector < Scalar, dimWorld > unitOuterNormal = isIt->centerUnitOuterNormal();
@@ -430,7 +431,6 @@ void FVPressure1P<TypeTag>::assemble(bool first)
}
}
} // end all intersections
-
} // end grid traversal
return;
}
diff --git a/dumux/linear/boxlinearsolver.hh b/dumux/linear/boxlinearsolver.hh
index ebb91fe13efab5ecfed9b7abebf60cc01875bc08..a02259d05b6af2e7b710f6d26ef7723e26310ea8 100644
--- a/dumux/linear/boxlinearsolver.hh
+++ b/dumux/linear/boxlinearsolver.hh
@@ -39,6 +39,75 @@
namespace Dumux {
+namespace Properties
+{
+/*!
+ * \brief Specifies the verbosity of the linear solver
+ *
+ * By default it is 0, i.e. it doesn't print anything. Setting this
+ * property to 1 prints aggregated convergence rates, 2 prints the
+ * convergence rate of every iteration of the scheme.
+ */
+NEW_PROP_TAG(LSVerbosity);
+// the outdated name
+NEW_PROP_TAG(NewtonLinearSolverVerbosity);
+
+//! target reduction of the initial residual
+// if the deflection of the newton method is large, we do not
+// need to solve the linear approximation accurately. Assuming
+// that the initial value for the delta vector u is quite
+// close to the final value, a reduction of 6 orders of
+// magnitude in the defect should be sufficient...
+NEW_PROP_TAG(LSResidualReduction);
+
+//! maximum number of iterations of solver
+NEW_PROP_TAG(LSMaxIterations);
+
+//! relaxation parameter for the preconditioner
+NEW_PROP_TAG(PreconditionerRelaxation);
+
+//! number of preconditioner iterations per solver iteration
+NEW_PROP_TAG(PreconditionerIterations);
+
+//! restart parameter for GMRes
+NEW_PROP_TAG(GMResRestart);
+
+SET_PROP_DEFAULT(NewtonLinearSolverVerbosity)
+{public:
+ static constexpr int value = 0;
+};
+
+SET_PROP_DEFAULT(LSVerbosity)
+{public:
+ static constexpr int value = GET_PROP_VALUE(TypeTag, PTAG(NewtonLinearSolverVerbosity));
+};
+
+SET_PROP_DEFAULT(LSResidualReduction)
+{public:
+ static constexpr double value = 1e-6;
+};
+
+SET_PROP_DEFAULT(LSMaxIterations)
+{public:
+ static constexpr int value = 250;
+};
+
+SET_PROP_DEFAULT(PreconditionerRelaxation)
+{public:
+ static constexpr double value = 1.0;
+};
+
+SET_PROP_DEFAULT(PreconditionerIterations)
+{public:
+ static constexpr int value = 1;
+};
+
+SET_PROP_DEFAULT(GMResRestart)
+{public:
+ static constexpr int value = 10;
+};
+}
+
/*!
* \brief Provides a linear solver for the stabilized BiCG method with
* an ILU-0 preconditioner.
@@ -93,13 +162,17 @@ public:
*
* \return true if the residual reduction could be achieved, else false.
*/
- template <class SeqPreconditioner, class Solver>
+ template <class PrecBackend, class SolverBackend>
bool solve(const Matrix &M,
Vector &x,
- const Vector &b,
- double residReduction,
- int verbosityLevel = 0)
+ const Vector &b)
{
+ int verbosity = 0;
+ if (problem_.gridView().comm().rank() == 0)
+ verbosity = GET_PROP_VALUE(TypeTag, PTAG(LSVerbosity));
+ static const int maxIter = GET_PROP_VALUE(TypeTag, PTAG(LSMaxIterations));
+ static const double residReduction = GET_PROP_VALUE(TypeTag, PTAG(LSResidualReduction));
+
if (!overlapMatrix_) {
// make sure that the overlapping matrix and block vectors
// have been created
@@ -114,26 +187,26 @@ public:
(*overlapx_) = 0.0;
// create sequential and overlapping preconditioners
- //SeqPreconditioner seqPreCond(*overlapMatrix_, 1, 1.0);
- SeqPreconditioner seqPreCond(*overlapMatrix_, 1.0);
+ PrecBackend seqPreCond(*overlapMatrix_);
+ typedef typename PrecBackend::Implementation SeqPreconditioner;
typedef Dumux::OverlappingPreconditioner<SeqPreconditioner, Overlap> OverlappingPreconditioner;
- OverlappingPreconditioner preCond(seqPreCond, overlapMatrix_->overlap());
+ OverlappingPreconditioner preCond(seqPreCond.imp(), overlapMatrix_->overlap());
// create the scalar products and linear operators for ISTL
OverlappingScalarProduct scalarProd(overlapMatrix_->overlap());
OverlappingOperator opA(*overlapMatrix_);
// create the actual solver
- Solver solver(opA,
+ SolverBackend solver(opA,
scalarProd,
preCond,
residReduction,
- /*maxIterations=*/250,
- verbosityLevel);
+ maxIter,
+ verbosity);
// run the solver
Dune::InverseOperatorResult result;
- solver.apply(*overlapx_, *overlapb_, result);
+ solver.imp().apply(*overlapx_, *overlapb_, result);
// copy the result back to the non-overlapping vector
overlapx_->assignTo(x);
@@ -180,6 +253,70 @@ private:
OverlappingVector *overlapx_;
};
+template <class TypeTag, class Imp>
+class PrecNoIterBackend
+{
+public:
+ typedef Imp Implementation;
+
+ template <class Matrix>
+ PrecNoIterBackend(Matrix& A)
+ : imp_(A, GET_PROP_VALUE(TypeTag, PTAG(PreconditionerRelaxation)))
+ {}
+
+ Imp& imp()
+ {
+ return imp_;
+ }
+
+private:
+ Imp imp_;
+};
+
+template <class TypeTag, class Imp>
+class PrecIterBackend
+{
+public:
+ typedef Imp Implementation;
+
+ template <class Matrix>
+ PrecIterBackend(Matrix& A)
+ : imp_(A,
+ GET_PROP_VALUE(TypeTag, PTAG(PreconditionerIterations)),
+ GET_PROP_VALUE(TypeTag, PTAG(PreconditionerRelaxation)))
+ {}
+
+ Imp& imp()
+ {
+ return imp_;
+ }
+
+private:
+ Imp imp_;
+};
+
+template <class TypeTag, class Imp>
+class StandardSolverBackend
+{
+public:
+ typedef Imp Implementation;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(Scalar)) Scalar;
+
+ template <class Operator, class ScalarProduct, class Prec>
+ StandardSolverBackend(Operator& A, ScalarProduct& sp, Prec& prec,
+ Scalar residReduction, int maxIter, int verbosity)
+ : imp_(A, sp, prec, residReduction, maxIter, verbosity)
+ {}
+
+ Imp& imp()
+ {
+ return imp_;
+ }
+
+private:
+ Imp imp_;
+};
+
template <class TypeTag>
class BoxBiCGStabILU0Solver : public BoxLinearSolver<TypeTag>
{
@@ -190,7 +327,9 @@ class BoxBiCGStabILU0Solver : public BoxLinearSolver<TypeTag>
typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
typedef Dune::SeqILU0<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecNoIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
typedef Dune::BiCGSTABSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
public:
template <class Problem>
@@ -200,11 +339,121 @@ public:
bool solve(const Matrix &M,
Vector &x,
- const Vector &b,
- double residReduction,
- int verbosityLevel = 0)
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxBiCGStabSORSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqSOR<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::BiCGSTABSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxBiCGStabSORSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxBiCGStabSSORSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqSSOR<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::BiCGSTABSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxBiCGStabSSORSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxBiCGStabJacSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqJac<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::BiCGSTABSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxBiCGStabJacSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxBiCGStabGSSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqGS<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::BiCGSTABSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxBiCGStabGSSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
{
- return ParentType::template solve<SeqPreconditioner, Solver>(M, x, b, residReduction, verbosityLevel);
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
}
};
@@ -218,7 +467,9 @@ class BoxCGILU0Solver : public BoxLinearSolver<TypeTag>
typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
typedef Dune::SeqILU0<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecNoIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
typedef Dune::CGSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
public:
template <class Problem>
@@ -228,11 +479,121 @@ public:
bool solve(const Matrix &M,
Vector &x,
- const Vector &b,
- double residReduction,
- int verbosityLevel = 0)
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxCGSORSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqSOR<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::CGSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxCGSORSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxCGSSORSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqSSOR<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::CGSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxCGSSORSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxCGJacSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqJac<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::CGSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxCGJacSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
+ {
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
+ }
+};
+
+template <class TypeTag>
+class BoxCGGSSolver : public BoxLinearSolver<TypeTag>
+{
+ typedef BoxLinearSolver<TypeTag> ParentType;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(JacobianMatrix)) Matrix;
+ typedef Dumux::OverlappingBCRSMatrix<Matrix> OverlappingMatrix;
+ typedef typename OverlappingMatrix::Overlap Overlap;
+ typedef typename GET_PROP_TYPE(TypeTag, PTAG(SolutionVector)) Vector;
+ typedef Dumux::OverlappingBlockVector<typename Vector::block_type, Overlap> OverlappingVector;
+ typedef Dune::SeqGS<OverlappingMatrix, OverlappingVector, OverlappingVector> SeqPreconditioner;
+ typedef PrecIterBackend<TypeTag, SeqPreconditioner> PrecBackend;
+ typedef Dune::CGSolver<OverlappingVector> Solver;
+ typedef StandardSolverBackend<TypeTag, Solver> SolverBackend;
+
+public:
+ template <class Problem>
+ BoxCGGSSolver(const Problem &problem, int overlapSize = 3)
+ : ParentType(problem, overlapSize)
+ {}
+
+ bool solve(const Matrix &M,
+ Vector &x,
+ const Vector &b)
{
- return ParentType::template solve<SeqPreconditioner, Solver>(M, x, b, residReduction, verbosityLevel);
+ return ParentType::template solve<PrecBackend, SolverBackend>(M, x, b);
}
};
diff --git a/dumux/nonlinear/newtoncontroller.hh b/dumux/nonlinear/newtoncontroller.hh
index ba91fe91998f68436e7d5ed026baea1211b8140a..ec35e2ef609049d855dc4000dd8b2b3c5d261f0f 100644
--- a/dumux/nonlinear/newtoncontroller.hh
+++ b/dumux/nonlinear/newtoncontroller.hh
@@ -63,15 +63,6 @@ NEW_PROP_TAG(VertexMapper);
//! specifies the type of the time manager
NEW_PROP_TAG(TimeManager);
-/*!
- * \brief Specifies the verbosity of the linear solver
- *
- * By default it is 0, i.e. it doesn't print anything. Setting this
- * property to 1 prints aggregated convergence rates, 2 prints the
- * convergence rate of every iteration of the scheme.
- */
-NEW_PROP_TAG(NewtonLinearSolverVerbosity);
-
//! specifies whether the convergence rate and the global residual
//! gets written out to disk for every newton iteration (default is false)
NEW_PROP_TAG(NewtonWriteConvergence);
@@ -94,11 +85,6 @@ NEW_PROP_TAG(EnablePartialReassemble);
*/
NEW_PROP_TAG(NewtonUseLineSearch);
-SET_PROP_DEFAULT(NewtonLinearSolverVerbosity)
-{public:
- static const int value = 0;
-};
-
SET_PROP_DEFAULT(NewtonWriteConvergence)
{public:
static const bool value = false;
@@ -442,20 +428,8 @@ public:
SolutionVector &x,
const SolutionVector &b)
{
- // if the deflection of the newton method is large, we do not
- // need to solve the linear approximation accurately. Assuming
- // that the initial value for the delta vector u is quite
- // close to the final value, a reduction of 9 orders of
- // magnitude in the defect should be sufficient...
- Scalar residReduction = 1e-6;
-
try {
- int verbosityLevel = 0;
- if (verbose()) {
- verbosityLevel = GET_PROP_VALUE(TypeTag, PTAG(NewtonLinearSolverVerbosity));
- }
-
- int converged = linearSolver_.solve(A, x, b, residReduction, verbosityLevel);
+ int converged = linearSolver_.solve(A, x, b);
// make sure all processes converged
converged = gridView_().comm().min(converged);
diff --git a/test/boxmodels/1p/1ptestproblem.hh b/test/boxmodels/1p/1ptestproblem.hh
index 207b4b6654bfd15f6e78460752e57e7ac1affe92..bcf591a73fb3cac4ec6344387a10a840482e4ae4 100644
--- a/test/boxmodels/1p/1ptestproblem.hh
+++ b/test/boxmodels/1p/1ptestproblem.hh
@@ -67,8 +67,6 @@ SET_PROP(OnePTestProblem, Grid)
typedef Dune::YaspGrid<2> type;
};
-SET_INT_PROP(OnePTestProblem, NewtonLinearSolverVerbosity, 0);
-
// Set the problem property
SET_PROP(OnePTestProblem, Problem)
{ typedef Dumux::OnePTestProblem<TTAG(OnePTestProblem)> type; };
@@ -77,6 +75,12 @@ SET_PROP(OnePTestProblem, Problem)
SET_PROP(OnePTestProblem, SpatialParameters)
{ typedef Dumux::OnePTestSpatialParameters<TypeTag> type; };
+// Linear solver settings
+SET_TYPE_PROP(OnePTestProblem, LinearSolver, Dumux::BoxCGILU0Solver<TypeTag> );
+SET_INT_PROP(OnePTestProblem, LSVerbosity, 1);
+SET_INT_PROP(OnePTestProblem, PreconditionerIterations, 1);
+SET_SCALAR_PROP(OnePTestProblem, PreconditionerRelaxation, 1.0);
+
// Enable gravity
SET_BOOL_PROP(OnePTestProblem, EnableGravity, true);
}
diff --git a/test/boxmodels/2p/lensproblem.hh b/test/boxmodels/2p/lensproblem.hh
index e7bf27bf114f49e63900dcb3a6390d84f5823192..4b5924cb1731beb805a8f442ae3e4294ac543f5c 100644
--- a/test/boxmodels/2p/lensproblem.hh
+++ b/test/boxmodels/2p/lensproblem.hh
@@ -110,12 +110,15 @@ SET_BOOL_PROP(LensProblem, EnableJacobianRecycling, true);
// Write the solutions of individual newton iterations?
SET_BOOL_PROP(LensProblem, NewtonWriteConvergence, false);
-// The verbosity of the linear solver
-SET_BOOL_PROP(LensProblem, NewtonLinearSolverVerbosity, 0);
-
// Use forward differences instead of central differences
SET_INT_PROP(LensProblem, NumericDifferenceMethod, +1);
+// Linear solver settings
+SET_TYPE_PROP(LensProblem, LinearSolver, Dumux::BoxBiCGStabILU0Solver<TypeTag> );
+SET_INT_PROP(LensProblem, LSVerbosity, 0);
+SET_INT_PROP(LensProblem, PreconditionerIterations, 1);
+SET_SCALAR_PROP(LensProblem, PreconditionerRelaxation, 1.0);
+
// Enable gravity
SET_BOOL_PROP(LensProblem, EnableGravity, true);
}