From 1c9e33d46bd05e3051c2e5c96bfcca1125f12542 Mon Sep 17 00:00:00 2001
From: Katharina Heck <katharina.heck@iws.uni-stuttgart.de>
Date: Wed, 29 Nov 2017 13:46:37 +0100
Subject: [PATCH] [tests] port richardsanalytical
---
.../implicit/richardsanalyticalproblem.hh | 218 ++++++++----------
.../richardsanalyticalspatialparams.hh | 61 ++---
.../implicit/test_ccrichardsanalytical.cc | 202 +++++++++++++++-
.../implicit/test_ccrichardsanalytical.input | 5 +-
4 files changed, 321 insertions(+), 165 deletions(-)
diff --git a/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh b/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh
index f5cab8172f..1e4d4ff745 100644
--- a/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh
+++ b/test/porousmediumflow/richards/implicit/richardsanalyticalproblem.hh
@@ -29,8 +29,9 @@
#define DUMUX_RICHARDS_ANALYTICALPROBLEM_HH
#include <cmath>
-#include <dune/geometry/type.hh>
-#include <dune/geometry/quadraturerules.hh>
+#include <dumux/discretization/cellcentered/tpfa/properties.hh>
+#include <dumux/discretization/box/properties.hh>
+#include <dumux/porousmediumflow/problem.hh>
#include <dumux/porousmediumflow/richards/implicit/model.hh>
#include <dumux/material/components/simpleh2o.hh>
@@ -51,7 +52,7 @@ namespace Properties
{
NEW_TYPE_TAG(RichardsAnalyticalProblem, INHERITS_FROM(Richards, RichardsAnalyticalSpatialParams));
NEW_TYPE_TAG(RichardsAnalyticalBoxProblem, INHERITS_FROM(BoxModel, RichardsAnalyticalProblem));
-NEW_TYPE_TAG(RichardsAnalyticalCCProblem, INHERITS_FROM(CCModel, RichardsAnalyticalProblem));
+NEW_TYPE_TAG(RichardsAnalyticalCCProblem, INHERITS_FROM(CCTpfaModel, RichardsAnalyticalProblem));
// Use 2d YaspGrid
SET_TYPE_PROP(RichardsAnalyticalProblem, Grid, Dune::YaspGrid<2>);
@@ -69,26 +70,23 @@ public:
typedef FluidSystems::LiquidPhase<Scalar, SimpleH2O<Scalar> > type;
};
-// Enable gravity
-SET_BOOL_PROP(RichardsAnalyticalProblem, ProblemEnableGravity, true);
-
-// Enable partial reassembly of the Jacobian matrix
-SET_BOOL_PROP(RichardsAnalyticalProblem, ImplicitEnablePartialReassemble, true);
-
-// Enable re-use of the Jacobian matrix for the first iteration of a time step
-SET_BOOL_PROP(RichardsAnalyticalProblem, ImplicitEnableJacobianRecycling, true);
-
-// Use forward differences to approximate the Jacobian matrix
-SET_INT_PROP(RichardsAnalyticalProblem, ImplicitNumericDifferenceMethod, +1);
-
-// Set the maximum number of newton iterations of a time step
-SET_INT_PROP(RichardsAnalyticalProblem, NewtonMaxSteps, 28);
-
-// Set the "desireable" number of newton iterations of a time step
-SET_INT_PROP(RichardsAnalyticalProblem, NewtonTargetSteps, 18);
-
-// Do not write the intermediate results of the newton method
-SET_BOOL_PROP(RichardsAnalyticalProblem, NewtonWriteConvergence, false);
+// // Enable partial reassembly of the Jacobian matrix
+// SET_BOOL_PROP(RichardsAnalyticalProblem, ImplicitEnablePartialReassemble, true);
+//
+// // Enable re-use of the Jacobian matrix for the first iteration of a time step
+// SET_BOOL_PROP(RichardsAnalyticalProblem, ImplicitEnableJacobianRecycling, true);
+//
+// // Use forward differences to approximate the Jacobian matrix
+// SET_INT_PROP(RichardsAnalyticalProblem, ImplicitNumericDifferenceMethod, +1);
+//
+// // Set the maximum number of newton iterations of a time step
+// SET_INT_PROP(RichardsAnalyticalProblem, NewtonMaxSteps, 28);
+//
+// // Set the "desireable" number of newton iterations of a time step
+// SET_INT_PROP(RichardsAnalyticalProblem, NewtonTargetSteps, 18);
+//
+// // Do not write the intermediate results of the newton method
+// SET_BOOL_PROP(RichardsAnalyticalProblem, NewtonWriteConvergence, false);
}
/*!
@@ -107,32 +105,28 @@ SET_BOOL_PROP(RichardsAnalyticalProblem, NewtonWriteConvergence, false);
* The L2 error is decreasing with decreasing time and space discretization.
*/
template <class TypeTag>
-class RichardsAnalyticalProblem : public RichardsProblem<TypeTag>
+class RichardsAnalyticalProblem : public PorousMediumFlowProblem<TypeTag>
{
- typedef RichardsProblem<TypeTag> ParentType;
-
- typedef typename GET_PROP_TYPE(TypeTag, GridView) GridView;
- typedef typename GridView::template Codim<0>::Entity::Geometry Geometry;
- typedef typename GET_PROP_TYPE(TypeTag, PrimaryVariables) PrimaryVariables;
- typedef typename GET_PROP_TYPE(TypeTag, BoundaryTypes) BoundaryTypes;
- typedef typename GET_PROP_TYPE(TypeTag, TimeManager) TimeManager;
- typedef typename GET_PROP_TYPE(TypeTag, FVElementGeometry) FVElementGeometry;
- typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
-
- typedef typename GET_PROP_TYPE(TypeTag, Indices) Indices;
+ using ParentType = PorousMediumFlowProblem<TypeTag>;
+ using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
+ using PrimaryVariables = typename GET_PROP_TYPE(TypeTag, PrimaryVariables);
+ using MaterialLaw = typename GET_PROP_TYPE(TypeTag, MaterialLaw);
+ using BoundaryTypes = typename GET_PROP_TYPE(TypeTag, BoundaryTypes);
+ using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+ using Indices = typename GET_PROP_TYPE(TypeTag, Indices);
+ using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
enum {
// copy some indices for convenience
- pwIdx = Indices::pwIdx,
- contiEqIdx = Indices::contiEqIdx
- };
- enum {
+ pwIdx = Indices::pressureIdx,
+ conti0EqIdx = Indices::conti0EqIdx,
+ bothPhases = Indices::bothPhases,
+
// Grid and world dimension
- dim = GridView::dimension,
dimWorld = GridView::dimensionworld
};
- typedef typename GridView::template Codim<0>::Entity Element;
- typedef Dune::FieldVector<Scalar, dimWorld> GlobalPosition;
+ using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
+ using Geometry = typename GridView::template Codim<0>::Entity::Geometry;
public:
/*!
@@ -141,12 +135,12 @@ public:
* \param timeManager The Dumux TimeManager for simulation management.
* \param gridView The grid view on the spatial domain of the problem
*/
- RichardsAnalyticalProblem(TimeManager &timeManager,
- const GridView &gridView)
- : ParentType(timeManager, gridView)
+ RichardsAnalyticalProblem(std::shared_ptr<const FVGridGeometry> fvGridGeometry)
+ : ParentType(fvGridGeometry)
{
pnRef_ = 1e5; // air pressure
- name_ = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, std::string, Problem, Name);
+ name_ = getParam<std::string>("Problem.Name");
+ time_ = 0.0;
}
/*!
@@ -162,6 +156,9 @@ public:
const std::string name() const
{ return name_; }
+ void setTime(Scalar time)
+ { time_ = time; }
+
/*!
* \brief Returns the temperature [K] within a finite volume
*
@@ -182,9 +179,7 @@ public:
* \param scvIdx The sub control volume index inside the finite
* volume geometry
*/
- Scalar referencePressure(const Element &element,
- const FVElementGeometry &fvGeometry,
- const int scvIdx) const
+ Scalar nonWettingReferencePressure() const
{ return pnRef_; }
/*!
@@ -199,10 +194,10 @@ public:
* \param values Storage for all primary variables of the source term
* \param globalPos The position for which the source term is set
*/
- void sourceAtPos(PrimaryVariables &values,
- const GlobalPosition &globalPos) const
+ PrimaryVariables sourceAtPos(const GlobalPosition &globalPos) const
{
- const Scalar time = this->timeManager().time() + this->timeManager().timeStepSize();
+ PrimaryVariables values(0.0);
+ const Scalar time = time_;
const Scalar pwTop = 98942.8;
const Scalar pwBottom = 95641.1;
@@ -219,6 +214,7 @@ public:
*(pow(tanh(globalPos[1]*5.0+time*(1.0/1.0E1)-1.5E1),2.0)*5.0-5.0)*(pwBottom
*(1.0/2.0)-pwTop*(1.0/2.0))*(pwBottom*5.0E-16-(tanh(globalPos[1]*5.0+time*(1.0/1.0E1)
-1.5E1)+1.0)*(pwBottom*(1.0/2.0)-pwTop*(1.0/2.0))*5.0E-16+4.99995E-6)*1.0E1;
+ return values;
}
// \}
@@ -235,16 +231,17 @@ public:
* \param values The boundary types for the conservation equations
* \param globalPos The position for which the boundary type is set
*/
- void boundaryTypesAtPos(BoundaryTypes &values,
- const GlobalPosition &globalPos) const
+ BoundaryTypes boundaryTypesAtPos(const GlobalPosition &globalPos) const
{
+ BoundaryTypes bcTypes;
if (onLowerBoundary_(globalPos) ||
onUpperBoundary_(globalPos))
{
- values.setAllDirichlet();
+ bcTypes.setAllDirichlet();
}
else
- values.setAllNeumann();
+ bcTypes.setAllNeumann();
+ return bcTypes;
}
/*!
@@ -256,10 +253,11 @@ public:
*
* For this method, the \a values parameter stores primary variables.
*/
- void dirichletAtPos(PrimaryVariables &values,
- const GlobalPosition &globalPos) const
+ PrimaryVariables dirichletAtPos(const GlobalPosition &globalPos) const
{
- const Scalar time = this->timeManager().time() + this->timeManager().timeStepSize();
+ PrimaryVariables values(0.0);
+ values.setState(bothPhases);
+ const Scalar time = time_;
const Scalar pwTop = 98942.8;
const Scalar pwBottom = 95641.1;
using std::tanh;
@@ -267,6 +265,7 @@ public:
+ 0.5 * (tanh( (5.0 * globalPos[1]) - 15.0 + time/10.0) + 1.0) * (pwTop - pwBottom);
values[pwIdx] = pw;
+ return values;
}
/*!
@@ -279,10 +278,10 @@ public:
* \param values The neumann values for the conservation equations
* \param globalPos The position for which the Neumann value is set
*/
- void neumannAtPos(PrimaryVariables &values,
- const GlobalPosition &globalPos) const
+ PrimaryVariables neumannAtPos(const GlobalPosition &globalPos) const
{
- values = 0.0;
+ PrimaryVariables values(0.0);
+ return values;
}
/*!
@@ -299,11 +298,12 @@ public:
* \param values Storage for all primary variables of the initial condition
* \param globalPos The position for which the boundary type is set
*/
- void initialAtPos(PrimaryVariables &values,
- const GlobalPosition &globalPos) const
+ PrimaryVariables initialAtPos(const GlobalPosition &globalPos) const
{
- const Scalar time = this->timeManager().time();
- analyticalSolution(values, time, globalPos);
+ PrimaryVariables values(0.0);
+ values.setState(bothPhases);
+ analyticalSolution(values, time_, globalPos);
+ return values;
}
// \}
@@ -321,6 +321,7 @@ public:
const Scalar time,
const GlobalPosition &globalPos) const
{
+
const Scalar pwTop = 98942.8;
const Scalar pwBottom = 95641.1;
using std::tanh;
@@ -340,38 +341,38 @@ public:
*/
Scalar calculateL2Error()
{
- const unsigned int qOrder = 4;
- Scalar l2error = 0.0;
- Scalar l2analytic = 0.0;
- const Scalar time = this->timeManager().time() + this->timeManager().timeStepSize();
-
- for (const auto& element : elements(this->gridView()))
- {
- // value from numerical approximation
- Scalar numericalSolution =
- this->model().curSol()[this->model().dofMapper().subIndex(element, 0, 0)];
-
- // integrate over element using a quadrature rule
- Geometry geometry = element.geometry();
- Dune::GeometryType gt = geometry.type();
- Dune::QuadratureRule<Scalar, dim> rule =
- Dune::QuadratureRules<Scalar, dim>::rule(gt, qOrder);
-
- for (auto qIt = rule.begin(); qIt != rule.end(); ++qIt)
- {
- // evaluate analytical solution
- Dune::FieldVector<Scalar, dim> globalPos = geometry.global(qIt->position());
- Dune::FieldVector<Scalar, 1> values(0.0);
- analyticalSolution(values, time, globalPos);
- // add contributino of current quadrature point
- l2error += (numericalSolution - values[0]) * (numericalSolution - values[0]) *
- qIt->weight() * geometry.integrationElement(qIt->position());
- l2analytic += values[0] * values[0] *
- qIt->weight() * geometry.integrationElement(qIt->position());
- }
- }
- using std::sqrt;
- return sqrt(l2error/l2analytic);
+// const unsigned int qOrder = 4;
+// Scalar l2error = 0.0;
+// Scalar l2analytic = 0.0;
+// const Scalar time = time_;
+//
+// for (const auto& element : elements(this->gridView()))
+// {
+// // value from numerical approximation
+// Scalar numericalSolution =
+// this->model().curSol()[this->model().dofMapper().subIndex(element, 0, 0)];
+//
+// // integrate over element using a quadrature rule
+// Geometry geometry = element.geometry();
+// Dune::GeometryType gt = geometry.type();
+// Dune::QuadratureRule<Scalar, dim> rule =
+// Dune::QuadratureRules<Scalar, dim>::rule(gt, qOrder);
+//
+// for (auto qIt = rule.begin(); qIt != rule.end(); ++qIt)
+// {
+// // evaluate analytical solution
+// Dune::FieldVector<Scalar, dim> globalPos = geometry.global(qIt->position());
+// Dune::FieldVector<Scalar, 1> values(0.0);
+// analyticalSolution(values, time, globalPos);
+// // add contributino of current quadrature point
+// l2error += (numericalSolution - values[0]) * (numericalSolution - values[0]) *
+// qIt->weight() * geometry.integrationElement(qIt->position());
+// l2analytic += values[0] * values[0] *
+// qIt->weight() * geometry.integrationElement(qIt->position());
+// }
+// }
+// using std::sqrt;
+// return sqrt(l2error/l2analytic);
}
/*!
@@ -394,39 +395,24 @@ public:
<< std::endl;
}
- /*!
- * \brief If we should write output
- */
- bool shouldWriteOutput()
- {
- return this->timeManager().willBeFinished();
- }
-
- /*!
- * \brief If we should write output
- */
- bool shouldWriteRestartFile()
- {
- return false;
- }
-
private:
// evalutates if global position is at lower boundary
bool onLowerBoundary_(const GlobalPosition &globalPos) const
{
- return globalPos[1] < this->bBoxMin()[1] + eps_;
+ return globalPos[1] < this->fvGridGeometry().bBoxMin()[1] + eps_;
}
// evalutates if global position is at upper boundary
bool onUpperBoundary_(const GlobalPosition &globalPos) const
{
- return globalPos[1] > this->bBoxMax()[1] - eps_;
+ return globalPos[1] > this->fvGridGeometry().bBoxMax()[1] - eps_;
}
static constexpr Scalar eps_ = 3e-6;
Scalar pnRef_;
std::string name_;
+ Scalar time_;
};
} //end namespace
diff --git a/test/porousmediumflow/richards/implicit/richardsanalyticalspatialparams.hh b/test/porousmediumflow/richards/implicit/richardsanalyticalspatialparams.hh
index 78795be03d..57b34f9563 100644
--- a/test/porousmediumflow/richards/implicit/richardsanalyticalspatialparams.hh
+++ b/test/porousmediumflow/richards/implicit/richardsanalyticalspatialparams.hh
@@ -67,26 +67,25 @@ public:
template<class TypeTag>
class RichardsAnalyticalSpatialParams : public ImplicitSpatialParams<TypeTag>
{
- typedef ImplicitSpatialParams<TypeTag> ParentType;
- typedef typename GET_PROP_TYPE(TypeTag, Grid) Grid;
- typedef typename GET_PROP_TYPE(TypeTag, GridView) GridView;
- typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
- typedef typename Grid::ctype CoordScalar;
+ using ParentType = ImplicitSpatialParams<TypeTag>;
+ using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
+ using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
+ using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
enum {
dim=GridView::dimension,
dimWorld=GridView::dimensionworld
};
- typedef Dune::FieldVector<CoordScalar,dimWorld> GlobalPosition;
-
- typedef typename GridView::template Codim<0>::Entity Element;
- typedef typename GET_PROP_TYPE(TypeTag, FVElementGeometry) FVElementGeometry;
+ using GlobalPosition = Dune::FieldVector<Scalar, dimWorld>;
+ using MaterialLaw = typename GET_PROP_TYPE(TypeTag, MaterialLaw);
+ using MaterialLawParams = typename MaterialLaw::Params;
public:
- typedef typename GET_PROP_TYPE(TypeTag, MaterialLaw) MaterialLaw;
- //! The parameters of the material law to be used
- typedef typename MaterialLaw::Params MaterialLawParams;
+
+ // export permeability type
+ using PermeabilityType = Scalar;
+
/*!
* \brief Constructor
@@ -94,8 +93,8 @@ public:
* \param gridView The DUNE GridView representing the spatial
* domain of the problem.
*/
- RichardsAnalyticalSpatialParams(const GridView& gridView)
- : ParentType(gridView)
+ RichardsAnalyticalSpatialParams(const Problem& problem)
+ : ParentType(problem)
{
K_ = 5e-12;
materialParams_.setSwr(0.0);
@@ -107,13 +106,9 @@ public:
/*!
* \brief Returns the intrinsic permeability tensor [m^2] at a given location
*
- * \param element An arbitrary DUNE Codim<0> entity of the grid view
- * \param fvGeometry The current finite volume geometry of the element
- * \param scvIdx The index of the sub-control volume
+ * \param globalPos The global position where we evaluate
*/
- Scalar intrinsicPermeability(const Element &element,
- const FVElementGeometry &fvGeometry,
- int scvIdx) const
+ PermeabilityType permeabilityAtPos(const GlobalPosition& globalPos) const
{
return K_;
}
@@ -121,38 +116,20 @@ public:
/*!
* \brief Returns the porosity [] at a given location
*
- * \param element An arbitrary DUNE Codim<0> entity of the grid view
- * \param fvGeometry The current finite volume geometry of the element
- * \param scvIdx The index of the sub-control volume
+ * \param globalPos The global position where we evaluate
*/
- Scalar porosity(const Element &element,
- const FVElementGeometry &fvGeometry,
- int scvIdx) const
+ Scalar porosityAtPos(const GlobalPosition& globalPos) const
{ return 0.4; }
- /*!
- * \brief Returns the parameters for the material law at a given location
- *
- * \param element An arbitrary DUNE Codim<0> entity of the grid view
- * \param fvGeometry The current finite volume geometry of the element
- * \param scvIdx The index of the sub-control volume
- */
- const MaterialLawParams& materialLawParams(const Element &element,
- const FVElementGeometry &fvGeometry,
- int scvIdx) const
- {
- return materialLawParams(fvGeometry.subContVol[scvIdx].global);
- }
-
/*!
* \brief Returns the parameters for the material law at a given location
*
* This method is not actually required by the Richards model, but provided
- * for the convenience of the RichardsAnalyticalProblem
+ * for the convenience of the RichardsLensProblem
*
* \param globalPos A global coordinate vector
*/
- const MaterialLawParams& materialLawParams(const GlobalPosition &globalPos) const
+ const MaterialLawParams& materialLawParamsAtPos(const GlobalPosition &globalPos) const
{
return materialParams_;
}
diff --git a/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.cc b/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.cc
index 1da4e1740f..c03e51a00e 100644
--- a/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.cc
+++ b/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.cc
@@ -14,17 +14,40 @@
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
- * along with this program. If not, see <http://www.gnu.org/licenses/>. *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
* \file
*
- * \brief Test for the Richards CC analytical model.
+ * \brief Test for the Richards CC model.
*/
#include <config.h>
+
#include "richardsanalyticalproblem.hh"
-#include <dumux/common/start.hh>
+#include <ctime>
+#include <iostream>
+
+#include <dune/common/parallel/mpihelper.hh>
+#include <dune/common/timer.hh>
+#include <dune/grid/io/file/dgfparser/dgfexception.hh>
+#include <dune/grid/io/file/vtk.hh>
+#include <dune/istl/io.hh>
+
+#include <dumux/common/propertysystem.hh>
+#include <dumux/common/parameters.hh>
+#include <dumux/common/valgrind.hh>
+#include <dumux/common/dumuxmessage.hh>
+#include <dumux/common/defaultusagemessage.hh>
+
+#include <dumux/linear/amgbackend.hh>
+#include <dumux/nonlinear/newtonmethod.hh>
+#include <dumux/nonlinear/newtoncontroller.hh>
+#include <dumux/porousmediumflow/richards/implicit/newtoncontroller.hh>
+
+#include <dumux/assembly/fvassembler.hh>
+
+#include <dumux/io/vtkoutputmodule.hh>
/*!
* \brief Provides an interface for customizing error messages associated with
* reading in parameters.
@@ -51,8 +74,175 @@ void usage(const char *progName, const std::string &errorMsg)
}
}
-int main(int argc, char** argv)
+////////////////////////
+// the main function
+////////////////////////
+int main(int argc, char** argv) try
+{
+ using namespace Dumux;
+
+ // define the type tag for this problem
+ using TypeTag = TTAG(RichardsAnalyticalCCProblem);
+
+ // initialize MPI, finalize is done automatically on exit
+ const auto& mpiHelper = Dune::MPIHelper::instance(argc, argv);
+
+ // print dumux start message
+ if (mpiHelper.rank() == 0)
+ DumuxMessage::print(/*firstCall=*/true);
+
+ // parse command line arguments and input file
+ Parameters::init(argc, argv, usage);
+
+ // try to create a grid (from the given grid file or the input file)
+ using GridCreator = typename GET_PROP_TYPE(TypeTag, GridCreator);
+ GridCreator::makeGrid();
+ GridCreator::loadBalance();
+
+ ////////////////////////////////////////////////////////////
+ // run instationary non-linear problem on this grid
+ ////////////////////////////////////////////////////////////
+
+ // we compute on the leaf grid view
+ const auto& leafGridView = GridCreator::grid().leafGridView();
+
+ // create the finite volume grid geometry
+ using FVGridGeometry = typename GET_PROP_TYPE(TypeTag, FVGridGeometry);
+ auto fvGridGeometry = std::make_shared<FVGridGeometry>(leafGridView);
+ fvGridGeometry->update();
+
+ // the problem (initial and boundary conditions)
+ using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
+ auto problem = std::make_shared<Problem>(fvGridGeometry);
+
+ // the solution vector
+ using SolutionVector = typename GET_PROP_TYPE(TypeTag, SolutionVector);
+ SolutionVector x(fvGridGeometry->numDofs());
+ problem->applyInitialSolution(x);
+ auto xOld = x;
+
+ // the grid variables
+ using GridVariables = typename GET_PROP_TYPE(TypeTag, GridVariables);
+ auto gridVariables = std::make_shared<GridVariables>(problem, fvGridGeometry);
+ gridVariables->init(x, xOld);
+
+ // get some time loop parameters
+ using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
+ const auto tEnd = getParam<Scalar>("TimeLoop.TEnd");
+ const auto maxDivisions = getParam<int>("TimeLoop.MaxTimeStepDivisions");
+ const auto maxDt = getParam<Scalar>("TimeLoop.MaxTimeStepSize");
+ auto dt = getParam<Scalar>("TimeLoop.DtInitial");
+
+ // check if we are about to restart a previously interrupted simulation
+ Scalar restartTime = 0;
+ if (Parameters::getTree().hasKey("Restart") || Parameters::getTree().hasKey("TimeLoop.Restart"))
+ restartTime = getParam<Scalar>("TimeLoop.Restart");
+
+ // intialize the vtk output module
+ using VtkOutputFields = typename GET_PROP_TYPE(TypeTag, VtkOutputFields);
+ VtkOutputModule<TypeTag> vtkWriter(*problem, *fvGridGeometry, *gridVariables, x, problem->name());
+ VtkOutputFields::init(vtkWriter); //! Add model specific output fields
+ vtkWriter.write(0.0);
+
+ // instantiate time loop
+ auto timeLoop = std::make_shared<TimeLoop<Scalar>>(restartTime, dt, tEnd);
+ timeLoop->setMaxTimeStepSize(maxDt);
+
+ // the assembler with time loop for instationary problem
+ using Assembler = FVAssembler<TypeTag, DiffMethod::numeric>;
+ auto assembler = std::make_shared<Assembler>(problem, fvGridGeometry, gridVariables, timeLoop);
+
+ // the linear solver
+ using LinearSolver = Dumux::ILU0BiCGSTABBackend<TypeTag>;
+ auto linearSolver = std::make_shared<LinearSolver>();
+
+ // the non-linear solver
+ using NewtonController = Dumux::RichardsNewtonController<TypeTag>;
+ using NewtonMethod = Dumux::NewtonMethod<NewtonController, Assembler, LinearSolver>;
+ auto newtonController = std::make_shared<NewtonController>(leafGridView.comm(), timeLoop);
+ NewtonMethod nonLinearSolver(newtonController, assembler, linearSolver);
+
+ // time loop
+ timeLoop->start(); do
+ {
+ // set previous solution for storage evaluations
+ assembler->setPreviousSolution(xOld);
+ problem->setTime(timeLoop->time()+timeLoop->timeStepSize());
+
+ // try solving the non-linear system
+ for (int i = 0; i < maxDivisions; ++i)
+ {
+ // linearize & solve
+ auto converged = nonLinearSolver.solve(x);
+
+ if (converged)
+ break;
+
+ if (!converged && i == maxDivisions-1)
+ DUNE_THROW(Dune::MathError,
+ "Newton solver didn't converge after "
+ << maxDivisions
+ << " time-step divisions. dt="
+ << timeLoop->timeStepSize()
+ << ".\nThe solutions of the current and the previous time steps "
+ << "have been saved to restart files.");
+ }
+
+ // make the new solution the old solution
+ xOld = x;
+ gridVariables->advanceTimeStep();
+
+ // advance to the time loop to the next step
+ timeLoop->advanceTimeStep();
+
+ // write vtk output
+ vtkWriter.write(timeLoop->time());
+
+ // report statistics of this time step
+ timeLoop->reportTimeStep();
+
+ // set new dt as suggested by newton controller
+ timeLoop->setTimeStepSize(newtonController->suggestTimeStepSize(timeLoop->timeStepSize()));
+
+ } while (!timeLoop->finished());
+
+ timeLoop->finalize(leafGridView.comm());
+
+ ////////////////////////////////////////////////////////////
+ // finalize, print dumux message to say goodbye
+ ////////////////////////////////////////////////////////////
+
+ // print dumux end message
+ if (mpiHelper.rank() == 0)
+ {
+ Parameters::print();
+ DumuxMessage::print(/*firstCall=*/false);
+ }
+
+ return 0;
+}
+
+catch (Dumux::ParameterException &e)
+{
+ std::cerr << std::endl << e << " ---> Abort!" << std::endl;
+ return 1;
+}
+catch (Dune::DGFException & e)
+{
+ std::cerr << "DGF exception thrown (" << e <<
+ "). Most likely, the DGF file name is wrong "
+ "or the DGF file is corrupted, "
+ "e.g. missing hash at end of file or wrong number (dimensions) of entries."
+ << " ---> Abort!" << std::endl;
+ return 2;
+}
+catch (Dune::Exception &e)
+{
+ std::cerr << "Dune reported error: " << e << " ---> Abort!" << std::endl;
+ return 3;
+}
+catch (...)
{
- typedef TTAG(RichardsAnalyticalCCProblem) ProblemTypeTag;
- return Dumux::start<ProblemTypeTag>(argc, argv, usage);
+ std::cerr << "Unknown exception thrown! ---> Abort!" << std::endl;
+ return 4;
}
diff --git a/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.input b/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.input
index 4d6e06e783..fc347a6cb2 100644
--- a/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.input
+++ b/test/porousmediumflow/richards/implicit/test_ccrichardsanalytical.input
@@ -1,4 +1,4 @@
-[TimeManager]
+[TimeLoop]
DtInitial = 1e-1 # [s]
TEnd = 100 # [s]
MaxTimeStepSize = 1e-1 # [s]
@@ -10,3 +10,6 @@ Cells = 1 512
[Problem]
Name = richardsanalyticalcc
EnableGravity = false
+
+[Newton]
+EnableChop = false # chop for better convergence
--
GitLab