Commit 7323fc43 authored by Dennis Gläser's avatar Dennis Gläser Committed by Simon Scholz
Browse files

[exercise-fractures] add solution

parent 8b513359
add_subdirectory(exercise-basic)
add_subdirectory(exercise-coupling-ff-pm)
add_subdirectory(exercise-fluidsystem)
add_subdirectory(exercise-fractures)
add_subdirectory(exercise-grids)
add_subdirectory(exercise-mainfile)
add_subdirectory(exercise-properties)
......
dune_symlink_to_source_files(FILES "grids" "exercise_fractures.input" "exercise_fractures_a.input" "exercise_fractures_b.input" "exercise_fractures_c.input")
# executable for the exercise
add_executable(exercise_fractures_solution EXCLUDE_FROM_ALL exercise_fractures.cc)
dune_add_test(NAME exercise_fractures_solution_a
CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )"
TARGET exercise_fractures_solution
COMMAND ./exercise_fractures_solution
CMD_ARGS exercise_fractures_a.input)
dune_add_test(NAME exercise_fractures_solution_b
CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )"
TARGET exercise_fractures_solution
COMMAND ./exercise_fractures_solution
CMD_ARGS exercise_fractures_b.input)
dune_add_test(NAME exercise_fractures_solution_c
CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )"
TARGET exercise_fractures_solution
COMMAND ./exercise_fractures_solution
CMD_ARGS exercise_fractures_c.input)
set(CMAKE_BUILD_TYPE Release)
#install sources
install(FILES
exercise_fractures.cc
matrixproblem.hh
fractureproblem.hh
matrixspatialparams.hh
fracturespatialparams.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/exercises/exercise-fractures)
# Exercise #5 (DuMuX course)
In this exercise we are going to use the multidomain framework and in particular the facet coupling module, which allows defining coupled problems in which a (d-1)-dimensional domain lives on the element facets of a d-dimensional domain. Here we are going to make use of this in the context of fractured porous media, where the fractures are represented as lower-dimensional entities embedded in a porous matrix. In this framework it is required that the grid resolves the fractures by aligning the matrix element facets with the fracture geometries, for which we are using the open-source mesh generator _Gmsh_ ([see _Gmsh_ documentation](http://gmsh.info/doc/texinfo/gmsh.html)). Note that the Gmsh file format (_.msh_) is currently the only supported file format within the facet coupling module.
## Problem set-up
We consider a domain of 100 x 100 m with a set of ten fractures. Apart from one fracture extending up to the top boundary, all other fractures are immersed, meaning that the fracture tips lie within the domain. Both the grid and the domain are shown in the image below.
![](../extradoc/exercise5_setup.png)
In the initial setup of this exercise, we want to consider buoancy-driven upwards migration of nitrogen (gas) in an initially fully water-saturated medium. We use hydrostatic pressure conditions and a zero nitrogen saturation as initial conditions, and prescribe no-flow boundary conditions on the left and right sides. We furthermore set the initial conditions as Dirichlet values for the upper and lower boundary except for the middle part of the lower boundary ($`y = 0 \wedge x > 25 \wedge x < 75`$), where we set a non-zero nitrogen saturation. Through this segment of the lower boundary, nitrogen can intrude the domain and flow upwards driven by buoancy.
## Preparing the exercise
Navigate to the directory `dumux/tutorial/exercise-fractures` and familiarize yourself with the files necessary for this exercise:
* The __main file__: `exercise_fractures.cc`
* The __input file__: `exercise_fractures.input`
* The __problem file__ for the matrix domain: `matrixproblem.hh`
* The __problem file__ for the fracture domain: `fractureproblem.hh`
* The __spatial parameters file__ for the matrix domain: `matrixspatialparams.hh`
* The __spatial parameters file__ for the matrix domain: `fracturespatialparams.hh`
You might want to take a closer look at the __main file__. The extensive comments above the key instructions will help you to understand the program flow of coupled problems and to identify the main differences with respect to an uncoupled _DuMuX_ model.
## Running the program
Head to the build directory, compile the exercise and execute the program by typing
```bash
cd build-cmake/exercises/exercise-fractures
make exercise_fractures
./exercise_fractures exercise_fractures.input
```
Take a look at the results by opening the files `matrix.pvd` and `fractures.pvd` with _Paraview_. In order to increase the visibility of the fracture solution, you might want to apply the tube filter to it (e.g. with a tube radius of 0.2). You will see how the fractures act as preferential flowpaths in the upwards movement of nitrogen due to their higher permeabilities. Additionally, you will observe high nitrogen saturations in the fracture tips as a result of the fractures acting as capillary traps due to the lower capillary pressures inside them. Consider turning them into capillary barriers, e.g. by setting __SpatialParams.VGAlpha = 1e-5__ in the fracture group in the input file (`exercise_fractures.input`). The nitrogen saturations in the fractures should now be lower than in the surrounding matrix. Do not forget to reset __SpatialParams.VGAlpha = 1e-1__ in the fracture group in the input file.
## Task A: Change the boundary conditions and disable gravity
In order for the influence of the fractures to be more visible in the resulting pressure fields, turn of gravity in the input file and change the boundary conditions in the two sub-problems (i.e. modify the function `boundaryTypesAtPos(...)` in `matrixproblem.hh` and `fractureproblem.hh`). We want to define the boundary conditions such that Neumann no-flow boundaries are used everywhere in the fracture domain and everywhere in the matrix domain except for the lower left and the upper right part of the lateral sides (i.e. $`x = 0 \wedge y < 25`$ and $`x = 100 \wedge y > 75`$).
Additionally, modify the function `dirichletAtPos(...)` in `matrixproblem.hh` such that an overpressure is added and a non-zero saturation is applied on the right Dirichlet segment ($`x = 100 \wedge y > 75`$). For this you can use the private variables `boundaryOverPressure_` and `boundarySaturation_` which are stored in the matrix problem and are read from the input file.
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* 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/>. *
*****************************************************************************/
/*!
* \file
* \brief Test for the exercise on two-phase flow in fractured porous media.
*/
#include <config.h>
#include <iostream>
#include <dune/common/parallel/mpihelper.hh>
// include the headers of the two sub-problems
// i.e. the problems for fractures and matrix
#include "matrixproblem.hh"
#include "fractureproblem.hh"
#include <dumux/common/properties.hh>
#include <dumux/common/parameters.hh>
#include <dumux/common/dumuxmessage.hh>
#include <dumux/common/timeloop.hh>
#include <dumux/assembly/diffmethod.hh>
#include <dumux/linear/seqsolverbackend.hh>
#include <dumux/multidomain/newtonsolver.hh>
#include <dumux/multidomain/fvassembler.hh>
#include <dumux/multidomain/traits.hh>
#include <dumux/multidomain/facet/gridmanager.hh>
#include <dumux/multidomain/facet/couplingmapper.hh>
#include <dumux/multidomain/facet/couplingmanager.hh>
#include <dumux/io/vtkoutputmodule.hh>
// Define some types for this test so that we can set them as properties below and
// reuse them again in the main function with only one single definition of them here
using MatrixTypeTag = TTAG(MatrixProblemTypeTag);
using FractureTypeTag = TTAG(FractureProblemTypeTag);
using MatrixFVGridGeometry = typename GET_PROP_TYPE(MatrixTypeTag, FVGridGeometry);
using FractureFVGridGeometry = typename GET_PROP_TYPE(FractureTypeTag, FVGridGeometry);
using TheMultiDomainTraits = Dumux::MultiDomainTraits<MatrixTypeTag, FractureTypeTag>;
using TheCouplingMapper = Dumux::FacetCouplingMapper<MatrixFVGridGeometry, FractureFVGridGeometry>;
using TheCouplingManager = Dumux::FacetCouplingManager<TheMultiDomainTraits, TheCouplingMapper>;
// set the coupling manager property in the sub-problems
namespace Dumux {
namespace Properties {
SET_TYPE_PROP(MatrixProblemTypeTag, CouplingManager, TheCouplingManager);
SET_TYPE_PROP(FractureProblemTypeTag, CouplingManager, TheCouplingManager);
} // end namespace Properties
} // end namespace Dumux
// main program
int main(int argc, char** argv) try
{
using namespace Dumux;
// 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);
// initialize parameter tree
Parameters::init(argc, argv);
// We use the grid manager from the facet coupling framework (see alias above main)
// This requires the grids used to be passed as template arguments, where
// they are assumed to be ordered in descending grid dimension. Thus,
// we pass the matrix grid as first and the fracture grid as second argument.
using MatrixGrid = typename GET_PROP_TYPE(MatrixTypeTag, Grid);
using FractureGrid = typename GET_PROP_TYPE(FractureTypeTag, Grid);
using GridManager = Dumux::FacetCouplingGridManager<MatrixGrid, FractureGrid>;
GridManager gridManager;
// try to create a grid (from the grid file in the input file)
// Init() creates the grid from the grid file specified in the input file.
// This works with a single grid file in which in addition to the matrix
// (d-dimensional) elements also the (d-1)-dimensional elements are specified
// which are interpreted as the fracture elements. See the .geo file in the
// grids folder on how to create such grids using gmsh. Note that currently
// only the Gmsh mesh format (.msh) is supported!
gridManager.init();
gridManager.loadBalance();
// we compute on the leaf grid views (get them from grid manager)
// the grid ids correspond to the order of the grids passed to the manager (see above)
static constexpr std::size_t matrixGridId = 0;
static constexpr std::size_t fractureGridId = 1;
const auto& matrixGridView = gridManager.template grid<matrixGridId>().leafGridView();
const auto& fractureGridView = gridManager.template grid<fractureGridId>().leafGridView();
// create the finite volume grid geometries
auto matrixFvGridGeometry = std::make_shared<MatrixFVGridGeometry>(matrixGridView);
auto fractureFvGridGeometry = std::make_shared<FractureFVGridGeometry>(fractureGridView);
matrixFvGridGeometry->update();
fractureFvGridGeometry->update();
// the problems (boundary/initial conditions etc)
using MatrixProblem = typename GET_PROP_TYPE(MatrixTypeTag, Problem);
using FractureProblem = typename GET_PROP_TYPE(FractureTypeTag, Problem);
// pass the model parameter group to the spatial params so that they obtain the right
// values from the input file since we use groups for matrix and fracture
// We also want to use domain markers in this exercise. For this reason, we also pass
// the grid data object from the grid manager to them, so that they have access to the
// domain markers that were specified in the grid file.
auto matrixGridData = gridManager.getGridData()->template getSubDomainGridData<matrixGridId>();
auto matrixSpatialParams = std::make_shared<typename MatrixProblem::SpatialParams>(matrixFvGridGeometry, matrixGridData, "Matrix");
auto matrixProblem = std::make_shared<MatrixProblem>(matrixFvGridGeometry, matrixSpatialParams, "Matrix");
// extract domain height from the matrix problem and pass to fracture problem (needed for right initial pressure distribution)
auto fractureGridData = gridManager.getGridData()->template getSubDomainGridData<fractureGridId>();
auto fractureSpatialParams = std::make_shared<typename FractureProblem::SpatialParams>(fractureFvGridGeometry, fractureGridData, "Fracture");
auto fractureProblem = std::make_shared<FractureProblem>(fractureFvGridGeometry, fractureSpatialParams, "Fracture");
// the solution vector
using SolutionVector = typename TheMultiDomainTraits::SolutionVector;
SolutionVector x, xOld;
// The domain ids within the multi-domain framework.
// They do not necessarily have to be the same as the grid ids
// in case you have more subdomains involved. We domain ids
// correspond to the order of the type tags passed to the multidomain
// traits (see definition of the traits class at the beginning of this file)
static const auto matrixDomainId = typename TheMultiDomainTraits::template DomainIdx<0>();
static const auto fractureDomainId = typename TheMultiDomainTraits::template DomainIdx<1>();
// resize the solution vector and write initial solution to it
x[matrixDomainId].resize(matrixFvGridGeometry->numDofs());
x[fractureDomainId].resize(fractureFvGridGeometry->numDofs());
matrixProblem->applyInitialSolution(x[matrixDomainId]);
fractureProblem->applyInitialSolution(x[fractureDomainId]);
// instantiate the class holding the coupling maps between the domains
// this needs the information on embeddings (connectivity between matrix
// and fracture domain). This information is extracted directly from the
// grid during file read and can therefore be obtained from the grid manager.
const auto embeddings = gridManager.getEmbeddings();
auto couplingMapper = std::make_shared<TheCouplingMapper>();
couplingMapper->update(*matrixFvGridGeometry, *fractureFvGridGeometry, embeddings);
// the coupling manager (needs the coupling mapper)
auto couplingManager = std::make_shared<TheCouplingManager>();
couplingManager->init(matrixProblem, fractureProblem, couplingMapper, x);
// we have to set coupling manager pointer in sub-problems
// they also have to be made accessible in them (see e.g. matrixproblem.hh)
matrixProblem->setCouplingManager(couplingManager);
fractureProblem->setCouplingManager(couplingManager);
// the grid variables
using MatrixGridVariables = typename GET_PROP_TYPE(MatrixTypeTag, GridVariables);
using FractureGridVariables = typename GET_PROP_TYPE(FractureTypeTag, GridVariables);
auto matrixGridVariables = std::make_shared<MatrixGridVariables>(matrixProblem, matrixFvGridGeometry);
auto fractureGridVariables = std::make_shared<FractureGridVariables>(fractureProblem, fractureFvGridGeometry);
matrixGridVariables->init(x[matrixDomainId]);
fractureGridVariables->init(x[fractureDomainId]);
xOld = x;
// intialize the vtk output modules
VtkOutputModule<MatrixTypeTag> matrixVtkWriter(*matrixProblem, *matrixFvGridGeometry, *matrixGridVariables, x[matrixDomainId], matrixProblem->name());
VtkOutputModule<FractureTypeTag> fractureVtkWriter(*fractureProblem, *fractureFvGridGeometry, *fractureGridVariables, x[fractureDomainId], fractureProblem->name());
// Add model specific output fields
using MatrixVtkOutputFields = typename GET_PROP_TYPE(MatrixTypeTag, VtkOutputFields);
using FractureVtkOutputFields = typename GET_PROP_TYPE(FractureTypeTag, VtkOutputFields);
MatrixVtkOutputFields::init(matrixVtkWriter);
FractureVtkOutputFields::init(fractureVtkWriter);
// add domain markers to output
std::vector<int> matrixDomainMarkers(matrixFvGridGeometry->gridView().size(0));
for (const auto& element : elements(matrixFvGridGeometry->gridView()))
matrixDomainMarkers[matrixFvGridGeometry->elementMapper().index(element)] = matrixProblem->spatialParams().getElementDomainMarker(element);
matrixVtkWriter.addField(matrixDomainMarkers, "domainMarker");
std::vector<int> fractureDomainMarkers(fractureFvGridGeometry->gridView().size(0));
for (const auto& element : elements(fractureFvGridGeometry->gridView()))
fractureDomainMarkers[fractureFvGridGeometry->elementMapper().index(element)] = fractureProblem->spatialParams().getElementDomainMarker(element);
fractureVtkWriter.addField(fractureDomainMarkers, "domainMarker");
// write out initial solution
matrixVtkWriter.write(0.0);
fractureVtkWriter.write(0.0);
// get some time loop parameters
const auto tEnd = getParam<double>("TimeLoop.TEnd");
const auto maxDt = getParam<double>("TimeLoop.MaxTimeStepSize");
auto dt = getParam<double>("TimeLoop.DtInitial");
// instantiate time loop
auto timeLoop = std::make_shared< TimeLoop<double> >(/*startTime*/0.0, dt, tEnd);
timeLoop->setMaxTimeStepSize(maxDt);
// the assembler for the coupled problem
using Assembler = MultiDomainFVAssembler<TheMultiDomainTraits, TheCouplingManager, DiffMethod::numeric, /*implicit?*/true>;
auto assembler = std::make_shared<Assembler>( std::make_tuple(matrixProblem, fractureProblem),
std::make_tuple(matrixFvGridGeometry, fractureFvGridGeometry),
std::make_tuple(matrixGridVariables, fractureGridVariables),
couplingManager,
timeLoop);
// the linear solver
using LinearSolver = ILU0BiCGSTABBackend;
auto linearSolver = std::make_shared<LinearSolver>();
// the non-linear solver
using NewtonSolver = Dumux::MultiDomainNewtonSolver<Assembler, LinearSolver, TheCouplingManager>;
auto newtonSolver = std::make_shared<NewtonSolver>(assembler, linearSolver, couplingManager);
// time loop
timeLoop->start(); do
{
// set previous solution for storage evaluations
assembler->setPreviousSolution(xOld);
// solve the non-linear system with time step control
newtonSolver->solve(x, *timeLoop);
// make the new solution the old solution
xOld = x;
matrixGridVariables->advanceTimeStep();
fractureGridVariables->advanceTimeStep();
// advance to the time loop to the next step
timeLoop->advanceTimeStep();
// write vtk output
matrixVtkWriter.write(timeLoop->time());
fractureVtkWriter.write(timeLoop->time());
// report statistics of this time step
timeLoop->reportTimeStep();
// set new dt as suggested by the Newton solver
timeLoop->setTimeStepSize(newtonSolver->suggestTimeStepSize(timeLoop->timeStepSize()));
} while (!timeLoop->finished());
// output some Newton statistics
newtonSolver->report();
// report time loop statistics
timeLoop->finalize();
// print dumux message to say goodbye
if (mpiHelper.rank() == 0)
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 (...)
{
std::cerr << "Unknown exception thrown! ---> Abort!" << std::endl;
return 4;
}
[TimeLoop]
TEnd = 30000 # [s]
DtInitial = 10 # [s]
MaxTimeStepSize = 2500 # [s]
[Problem]
EnableGravity = true
IsExercisePartA = false
IsExercisePartB = false
IsExercisePartC = false
[Grid]
File = ./grids/complex.msh
DomainMarkers = true # enable domain markers
[Matrix]
Problem.Name = matrix
Problem.BoundaryOverPressure = 5e5
Problem.BoundarySaturation = 0.5
SpatialParams.Permeability = 1e-12
SpatialParams.Porosity = 0.1
SpatialParams.VGAlpha = 1e-3
SpatialParams.VGN = 3
SpatialParams.Snr = 0.0
SpatialParams.Swr = 0.0
[Fracture]
Problem.Name = fractures
SpatialParams.Aperture = 1e-1
SpatialParams.Permeability = 1e-7
SpatialParams.PermeabilityBarrier = 1e-16
SpatialParams.Porosity = 0.85
SpatialParams.PorosityBarrier = 0.05
SpatialParams.VGAlpha = 1e-1
SpatialParams.VGAlphaBarrier = 1e-4
SpatialParams.VGN = 2
SpatialParams.VGNBarrier = 2.5
SpatialParams.Snr = 0.0
SpatialParams.SnrBarrier = 0.0
SpatialParams.Swr = 0.0
SpatialParams.SwrBarrier = 0.0
[TimeLoop]
TEnd = 30000 # [s]
DtInitial = 10 # [s]
MaxTimeStepSize = 2500 # [s]
[Problem]
EnableGravity = false
IsExercisePartA = true
IsExercisePartB = false
IsExercisePartC = false
[Grid]
File = ./grids/complex.msh
DomainMarkers = true # enable domain markers
[Matrix]
Problem.Name = matrix
Problem.BoundaryOverPressure = 5e5
Problem.BoundarySaturation = 0.5
SpatialParams.Permeability = 1e-12
SpatialParams.Porosity = 0.1
SpatialParams.VGAlpha = 1e-3
SpatialParams.VGN = 3
SpatialParams.Snr = 0.0
SpatialParams.Swr = 0.0
[Fracture]
Problem.Name = fractures
SpatialParams.Aperture = 1e-1
SpatialParams.Permeability = 1e-7
SpatialParams.PermeabilityBarrier = 1e-16
SpatialParams.Porosity = 0.85
SpatialParams.PorosityBarrier = 0.05
SpatialParams.VGAlpha = 1e-1
SpatialParams.VGAlphaBarrier = 1e-4
SpatialParams.VGN = 2
SpatialParams.VGNBarrier = 2.5
SpatialParams.Snr = 0.0
SpatialParams.SnrBarrier = 0.0
SpatialParams.Swr = 0.0
SpatialParams.SwrBarrier = 0.0
[TimeLoop]
TEnd = 30000 # [s]
DtInitial = 10 # [s]
MaxTimeStepSize = 2500 # [s]
[Problem]
EnableGravity = false
IsExercisePartA = false
IsExercisePartB = true
IsExercisePartC = false
[Grid]
File = ./grids/complex.msh
DomainMarkers = true # enable domain markers
[Matrix]
Problem.Name = matrix
Problem.BoundaryOverPressure = 5e5
Problem.BoundarySaturation = 0.5
SpatialParams.Permeability = 1e-12
SpatialParams.Porosity = 0.1
SpatialParams.VGAlpha = 1e-3
SpatialParams.VGN = 3
SpatialParams.Snr = 0.0
SpatialParams.Swr = 0.0
[Fracture]
Problem.Name = fractures
SpatialParams.Aperture = 1e-1
SpatialParams.Permeability = 1e-7
SpatialParams.PermeabilityBarrier = 1e-16
SpatialParams.Porosity = 0.85
SpatialParams.PorosityBarrier = 0.05
SpatialParams.VGAlpha = 1e-1
SpatialParams.VGAlphaBarrier = 1e-4
SpatialParams.VGN = 2
SpatialParams.VGNBarrier = 2.5
SpatialParams.Snr = 0.0
SpatialParams.SnrBarrier = 0.0
SpatialParams.Swr = 0.0
SpatialParams.SwrBarrier = 0.0
[TimeLoop]
TEnd = 30000 # [s]
DtInitial = 10 # [s]
MaxTimeStepSize = 2500 # [s]
[Problem]
EnableGravity = false
IsExercisePartA = false
IsExercisePartB = false
IsExercisePartC = true
[Grid]
File = ./grids/complex.msh
DomainMarkers = true # enable domain markers
[Matrix]
Problem.Name = matrix
Problem.BoundaryOverPressure = 5e5
Problem.BoundarySaturation = 0.5
SpatialParams.Permeability = 1e-12
SpatialParams.Porosity = 0.1
SpatialParams.VGAlpha = 1e-3
SpatialParams.VGN = 3
SpatialParams.Snr = 0.0
SpatialParams.Swr = 0.0
[Fracture]
Problem.Name = fractures
SpatialParams.Aperture = 1e-1
SpatialParams.Permeability = 1e-7
SpatialParams.PermeabilityBarrier = 1e-16
SpatialParams.Porosity = 0.85
SpatialParams.PorosityBarrier = 0.05
SpatialParams.VGAlpha = 1e-1
SpatialParams.VGAlphaBarrier = 1e-4
SpatialParams.VGN = 2
SpatialParams.VGNBarrier = 2.5
SpatialParams.Snr = 0.0
SpatialParams.SnrBarrier = 0.0
SpatialParams.Swr = 0.0
SpatialParams.SwrBarrier = 0.0
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* 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/>. *
*****************************************************************************/
/*!
* \file
* \ingroup MultiDomain
* \ingroup MultiDomainFacet
* \ingroup TwoPTests
* \brief The sub-problem for the fracture domain in the exercise on two-phase flow in fractured porous media.
*/
#ifndef DUMUX_COURSE_FRACTURESEXERCISE_FRACTURE_PROBLEM_HH
#define DUMUX_COURSE_FRACTURESEXERCISE_FRACTURE_PROBLEM_HH
// we use alu grid for the discretization of the fracture domain
// as this grid manager is able to represent network/surface grids
#include <dune/foamgrid/foamgrid.hh>
// we want to simulate nitrogen gas transport in a water-saturated medium
#include <dumux/material/fluidsystems/h2on2.hh>
// we use a cell-centered finite volume scheme with tpfa here
#include <dumux/discretization/cellcentered/tpfa/properties.hh>
// include the base problem and the model we inherit from
#include <dumux/porousmediumflow/problem.hh>
#include <dumux/porousmediumflow/2p/model.hh>
// the spatial parameters (permeabilities, material parameters etc.)
#include "fracturespatialparams.hh"