3_tutorialsequential.tex

\section[Sequential model]{Solving a problem using a Sequential Model}\label{tutorial-sequential}
The process of solving a problem using \Dumux can be roughly divided into four parts:
\begin{enumerate}
 \item The geometry of the problem and correspondingly a grid have to be defined.
 \item Material properties and constitutive relationships have to be defined.
 \item Boundary conditions as well as initial conditions have to be defined.
 \item A suitable model has to be chosen.
\end{enumerate}

In contrast to the last section, we now apply a sequential solution procedure, a
so-called \textit{IMPET} (\textit{IM}plicit \textit{P}ressure \textit{E}xplicit
\textit{T}ransport) algorithm. This means that the pressure equation is first
solved using an implicit method. The resulting velocities are then used to solve
a transport equation explicitly.\\
In this tutorial, pure fluid phases are solved with a finite volume discretization
of both pressure- and transport step. Primary variables, according to default
settings of the model, are the pressure and the saturation of the wetting phase.

The problem which is solved in this tutorial is illustrated in figure
\ref{tutorial-sequential:problemfigure}. A rectangular domain with no flow
boundaries on the top and at the bottom, which is initially saturated with oil,
is considered. Water infiltrates from the left side into the domain. Gravity
effects are neglected.

\begin{figure}[ht]
\centering
\begin{tikzpicture}[>=latex]
  % basic sketch
  \fill [fill=dumuxBlue](0,0) rectangle ++(2,1.5);
  \fill [fill=dumuxYellow](2,0) rectangle ++(5,1.5);
  \draw (0,0) rectangle ++(7,1.5);
  \foreach \x in {0,0.25,...,6.75}
    \draw (\x,1.5) -- ++(0.25,0.25);
  \foreach \x in {0,0.25,...,6.75}
    \draw (\x,-0.25) -- ++(0.25,0.25);
  % labels
  \draw [->](-0.5,-0.5) -- ++(0,0.7) node [anchor=east]{$y$};
  \draw [->](-0.5,-0.5) -- ++(0.7,0) node [anchor=north]{$x$};
  \node at(3.5,1.75)[anchor=south]{no flow};
  \node at(3.5,-0.25)[anchor=north]{no flow};
  \draw[->,thick](-0.4,0.75) -- ++(0.9,0) node[anchor=north]{water};
  \draw[->,thick](6.5,0.75)node[anchor=north]{oil} -- ++(0.9,0);
  % equations
  \node [anchor=west] at (2,1.1){$p_{w_\text{initial}} = \unit[2 \cdot 10^5]{Pa}$};
  \node [anchor=west] at (2,0.4){$S_{w_\text{initial}} = 0$};
  \node [anchor=west] at (-3,1.1){$p_w = \unit[2 \cdot 10^5]{Pa}$};
  \node [anchor=west] at (-3,0.4){$S_w = 1$};
  \node [anchor=west] at (7.5,1.1){$q_w = \unitfrac[0]{kg}{m^2s}$};
  \node [anchor=west] at (7.5,0.4){$q_n = \unitfrac[3 \cdot 10^{-2}] {kg}{m^2s}$};
\end{tikzpicture}
\caption{Geometry of the tutorial problem with initial and boundary conditions.}
\label{tutorial-sequential:problemfigure}
\end{figure}

Listing \ref{tutorial-sequential:mainfile} shows how the main file, which has to be
executed, has to be set up, if the problem described above is to be solved using
a sequential model. This main file can be found in the directory \texttt{/tutorial}
of the stable part of \Dumux.

\begin{lst}[File tutorial/tutorial\_sequential.cc]\label{tutorial-sequential:mainfile} \mbox{}
\lstinputlisting[style=DumuxCode, numbersep=5pt, firstline=24, firstnumber=24]{../../tutorial/tutorial_sequential.cc}
\end{lst}

First, from line \ref{tutorial-sequential:include-begin} to line
\ref{tutorial-sequential:include-end} the \Dune and \Dumux files containing
essential functions and classes are included.

At line \ref{tutorial-sequential:set-type-tag} the type tag of the
problem which is going to be simulated is set. All other data types
can be retrieved by the \Dumux property system and only depend on this
single type tag. For an introduction to the
property system, see section \ref{sec:propertysystem}.

After this \Dumux' default startup routine \texttt{Dumux::start()} is
called in line \ref{tutorial-sequential:call-start}. This function deals
with parsing the command line arguments, reading the parameter file,
setting up the infrastructure necessary for \Dune, loading the grid, and
starting the simulation. All parameters can
be either specified by command line arguments of the form
(\texttt{-ParameterName ParameterValue}), in the file specified by the
\texttt{-parameterFile} argument, or if the latter is not specified,
in the file \texttt{tutorial\_sequential.input}. If a parameter is
specified on the command line as well as in the parameter file, the
values provided in the command line have
precedence. Listing~\ref{tutorial-sequential:parameter-file} shows the
default parameter file for the tutorial problem.

\begin{lst}[File tutorial/tutorial\_sequential.input]\label{tutorial-sequential:parameter-file} \mbox{}
\lstinputlisting[style=DumuxParameterFile]{../../tutorial/tutorial_sequential.input}
\end{lst}

To provide an error message, the usage message which is displayed to
the user if the simulation is called incorrectly, is printed via the
custom function which is defined on
line~\ref{tutorial-sequential:usage-function}. In this function the usage
message is customized to the problem at hand. This means that at least
the necessary parameters are listed here.

\subsection{The Problem Class}
\label{sequential_problem}

When solving a problem using \Dumux, the most important file is the
so-called \textit{problem file} as shown in listing
\ref{tutorial-sequential:problemfile} of
\texttt{tutorialproblem\_sequential.hh}.

\begin{lst}[File tutorial/tutorialproblem\_sequential.hh]\label{tutorial-sequential:problemfile} \mbox{}
\lstinputlisting[style=DumuxCode, numbersep=5pt, firstline=24, firstnumber=24]{../../tutorial/tutorialproblem_sequential.hh}
\end{lst}

First, both \Dune  grid handlers and the sequential model of \Dumux
have to be included. Then, a new type tag is created for the problem
in line \ref{tutorial-sequential:create-type-tag}.  In this case, the
new type tag inherits all properties defined for the \texttt{SequentialTwoP}
type tag, which means that for this problem the two-phase sequential approach
is chosen as discretization scheme (defined via the include in line
\ref{tutorial-sequential:parent-problem}). On line \ref{tutorial-sequential:set-problem},
a problem class is attached to the new type tag, while the grid which
is going to be used is defined in line \ref{tutorial-sequential:set-grid-type} --
in this case an \texttt{YaspGrid} is created. Since there's no uniform mechanism to
allocate grids in \Dune, \Dumux features the concept of grid creators.
In this case the generic \texttt{CubeGridCreator} which creates a
structured hexahedron grid of a specified size and resolution. For
this grid creator the  physical domain of the grid is specified via the
run-time parameters \texttt{Grid.UpperRight} and
\texttt{Grid.Cells}. These parameters can be specified via
the command-line or in a parameter file.
For more information about the \Dune grid interface, the different grid types
that are supported and the generation of different grids, consult chapter \ref{sec:gridhandling} of this document and
the \textit{Dune Grid Interface HOWTO} \cite{DUNE-HP}.

Next, we select the material of the simulation: In the case of a pure two-phase
model, each phase is a bulk fluid, and the complex (compositional) fluidsystems
do not need to be used. However, they can be used (see exercise 1 \ref{dec-ex1-fluidsystem}).
Instead, we use a simplified fluidsystem container that provides classes
for liquid and gas phases, line \ref{tutorial-sequential:2p-system-start} to
\ref{tutorial-sequential:2p-system-end}. These are linked to the appropriate
chemical species in line \ref{tutorial-sequential:wettingPhase} and
\ref{tutorial-sequential:nonwettingPhase}. For all parameters that depend
on space, such as the properties of the soil, the specific spatial parameters
for the problem of interest are specified in line
\ref{tutorial-sequential:set-spatialparameters}.

Now we arrive at some model parameters of the applied two-phase sequential
model. First, in line  \ref{tutorial-sequential:cflflux} a flux function for the
evaluation of the cfl-criterion is defined. This is optional as there exists also
a default flux function. The choice depends on the problem which has to be solved.
For cases which are not advection dominated the one chosen here is more reasonable.
Line \ref{tutorial-sequential:cflfactor} assigns the CFL-factor to be used in the
simulation run, which scales the time-step size (kind of security factor). The last
property in line \ref{tutorial-sequential:gravity}
is optional and tells the model not to use gravity.

After all necessary information is written into the property system and
its namespace is closed in line \ref{tutorial-sequential:propertysystem-end},
the problem class is defined in line \ref{tutorial-sequential:def-problem}.
As its property, the problem class itself is also derived from a parent,
\texttt{IMPESProblem2P}. The class constructor (line
\ref{tutorial-sequential:constructor-problem}) is able to hold two vectors,
which is not needed in this tutorial.

Beside the definition of the boundary and initial conditions (discussed in
subsection \ref{tutorial-implicit:problem} from 4$^{th}$ paragraph on page
\pageref{tutorial-implicit:boundaryStart}), the problem class also contains
general information about the current simulation. First, the name used by
the \texttt{VTK-writer} to generate output is defined in the method of line
\ref{tutorial-sequential:name}, and line \ref{tutorial-sequential:restart} indicates
whether restart files are written. As sequential schemes usually feature small
time-steps, it can be usefull to set an output interval larger than 1. The respective
function is called in line \ref{tutorial-sequential:outputinterval}, which gets the output interval as argument.

The following methods all have in common that they may be dependent on space.
Hence, they all have either an \texttt{element} or an \texttt{intersection} as their
function argument: Both are \Dune entities, depending on whether the parameter of
the method is defined in an element, such as
    initial values, or on an intersection, such as a boundary condition. As it may
    be sufficient to return values only based on a position, \Dumux models can also
    access functions in the problem with the form \mbox{\texttt{...AtPos(GlobalPosition\& globalPos)}},
    without an \Dune entity, as one can see in line \ref{tutorial-sequential:bctype}.

There are the methods for general parameters, source- or
sinkterms, boundary conditions (lines \ref{tutorial-sequential:bctype} to
\ref{tutorial-sequential:neumann}) and initial values for the transported
quantity in line \ref{tutorial-sequential:initial}. For more information
on the functions, consult the documentation in the code.

\subsection{The Definition of the Parameters that are Dependent on Space}\label{tutorial-sequential:description-spatialParameters}

Listing \ref{tutorial-sequential:spatialparamsfile} shows the file
\verb+tutorialspatialparams_sequential.hh+:

\begin{lst}[File tutorial/tutorialspatialparams\_sequential.hh]\label{tutorial-sequential:spatialparamsfile} \mbox{}
\lstinputlisting[style=DumuxCode, numbersep=5pt, firstline=24, firstnumber=24]{../../tutorial/tutorialspatialparams_sequential.hh}
\end{lst}
As this file only slightly differs from the implicit version, consult
chapter \ref{tutorial-implicit:description-spatialParameters} for explanations.
However, as a standard Finite Volume scheme is used, in contrast to the box-method
in the implicit case, the argument list here is the same as for the problem
functions: Either an \texttt{element}, or only the global position if the function is called \texttt{...AtPos(...)}.

\subsection{Exercises}
\label{tutorial-deoucpled:exercises}
The following exercises will give you the opportunity to learn how you can change
soil parameters, boundary conditions and fluid properties in \Dumux and to play along
with the sequential modelling framework.

\subsubsection{Exercise 1}
\renewcommand{\labelenumi}{\alph{enumi})}
For Exercise 1 you only have to make some small changes in the tutorial files.
\begin{enumerate}
\item \textbf{Altering output}

To get an impression what the results should look like you can first run the
original version of the sequential tutorial model by typing  \texttt{./tutorial\_sequential}.
The runtime parameters which are set can be found in the input file (listing~\ref{tutorial-sequential:parameter-file}).
If the input file has the same name than the main file (e.g. \texttt{tutorial\_sequential.cc}
and \texttt{tutorial\_sequential.input}), it is automatically chosen. If the name differs
the program has to be started typing \texttt{./tutorial\_sequential -parameterFile <filename>.input}.
For more options you can also type \texttt{./tutorial\_sequential -h}. For the
visualisation with paraview please refer to \ref{quick-start-guide}.\\
As you can see, the simulation creates many output files. To reduce these in order
to perform longer simulations, change the method responsible for output (line
\ref{tutorial-sequential:outputinterval} in the file \texttt{tutorialproblem\_\allowbreak sequential})
as to write an output only every 20 time-steps. Compile the main file by typing
\texttt{make tutorial\_sequential} and run the model. Now, run the simulation for 5e5 seconds.

\item \textbf{Changing the Model Domain and the Boundary Conditions} \\
Change the size of the model domain so that you get a rectangle
with edge lengths of x = 300 m \\  and y = 300 m and with discretisation lengths
of  $\Delta \text{x} = 20$ m and $\Delta \text{y} = 10$ m. \\
Change the boundary conditions in the file \texttt{tutorialproblem\_sequential.hh}
so that water enters from the bottom and oil flows out at the top boundary. The
right and the left boundary should be closed for water and oil fluxes. The Neumannn
Boundary conditions are multiplied by the normal (pointing outwards), so an influx
is negative, an outflux always positive. Such information can easily be found in the
documentation of the functions (also look into base classes).

\item \textbf{Changing Fluids} \\
Now you can change the fluids. Use DNAPL instead of Oil and Brine instead of Water.
To do that you have to select different components via the property system in the problem file:
\begin{enumerate}
 \item Brine: The class \texttt{Dumux::Brine} acts as an adapter to the fluid system
 that alters a pure water class by adding some salt. Hence, the class \texttt{Dumux::Brine}
 uses a pure water class, such as \texttt{Dumux::H2O}, as a second template
 argument after the data type \texttt{<Scalar>} as a template argument (be sure
 to use the complete water class with its own template parameter).
 \item DNAPL: A standard set of chemical substances, such as Water and Brine,
 is already included (via a list of \texttt{\#include ..} commandos) and hence
 easily accessible by default. This is not the case for the class \texttt{Dumux::DNAPL},
 however, which is located in the folder \texttt{dumux/material/components/}. Try to
 include the file as well as select the component via the property system.
\end{enumerate}
If you want to take a closer look at how the fluid classes are defined and which
substances are already available please browse through the files in the directory
\texttt{/dumux/material/components}.

\item \textbf{Use the \Dumux fluid system}\label{dec-ex1-fluidsystem} \\
\Dumux usually organizes fluid mixtures via a \texttt{fluidsystem}, see also chapter
\ref{sec:fluidframework}. In order to include a fluidsystem you first have to comment
the lines \ref{tutorial-sequential:2p-system-start} to \ref{tutorial-sequential:2p-system-end}
in the problem file. If you use eclipse, this can easily be done by pressing
\textit{str + shift + 7} -- the same as to cancel the comment later on.\\
Now include the file \texttt{fluidsystems/h2oair.hh} in the material folder,
and set a property \texttt{FluidSystem} with the appropriate type,
\texttt{Dumux::H2OAirFluidSystem<TypeTag>}. However, this rather complicated fluidsystem
uses tabularized fluid data, which need to be initialized (i.e. the tables need to be
filled with values) in the constructor body of the current problem by adding
\texttt{GET\_PROP\_TYPE(TypeTag, FluidSystem)::init();}. Remember that the constructor
function always has the same name as the respective class, i.e. \texttt{TutorialProblemSequential(..)}.\\
To avoid the initialization, use the simpler version of water \texttt{Dumux::SimpleH2O}
or a non-tabulated version \texttt{Dumux::H2O}. This can be done by setting the property
\texttt{Components} type \texttt{H2O},
as is done in all the test problems of the sequential 2p2c model.\\
The density of the gas is magnitudes smaller than that of oil, so please decrease
the outflow rate to $q_n = 3 \times 10^{-4}$ $\left[\frac{\textnormal{kg}}{\textnormal{m}^2 \textnormal{s}}\right]$.
Also reduce the simulation duration to 2e4 seconds.\\
Please reverse the changes of this example, as we still use bulk phases and
hence do not need such an extensive fluid system.

\item \textbf{Heterogeneities}  \\
Set up a model domain with the soil properties given in figure \ref{tutorial-deoucpled:exercise1_d}.
Adjust the boundary conditions so that water is again flowing from left to right.
\begin{figure}[bt]
\centering
\begin{tikzpicture}[>=latex]
  % basic sketch
  \fill [dumuxBlue](3,0) rectangle ++(3,3);
  \draw (3,0) -- ++(0,3);
  \draw (0,0) rectangle ++(6,3);
  % arrows
  \draw [|<->|](0,-0.3) -- ++(6,0);
  \node at (3,-0.3)[anchor=north]{$\unit[600]{m}$};
  \draw [|<->|](-0.3,0) -- ++(0,3);
  \node at(-0.3,1.5)[anchor=east]{$\unit[300]{m}$};
  % labels
  \node [anchor=west] at (0.2,1.5){$\mathbf{K}=\unit[10^{-8}]{m^2}$};
  \node [anchor=west] at (0.2,1){$\phi=0.15$};
  \node [anchor=west] at (3.2,1.5){$\mathbf{K}=\unit[10^{-9}]{m^2}$};
  \node [anchor=west] at (3.2,1){$\phi=0.3$};
\end{tikzpicture}
\caption{Exercise 1d: Set-up of a model domain a heterogeneity. $\Delta x = \Delta y = \unit[20]{m}$.}
\label{tutorial-deoucpled:exercise1_d}
\end{figure}
When does the front cross the material border? In paraview, the option
\textit{View} $\rightarrow$ \textit{Animation View} is nice to get a rough
feeling of the time-step sizes.
\end{enumerate}

\subsubsection{Exercise 2}
For this exercise you should create a new problem file analogous to
the file \texttt{tutorialproblem\_sequential.hh} (e.g. with the name
\texttt{ex2\_tutorialproblem\_sequential.hh} and new spatial parameters
just like \texttt{tutorial\-spatialparams\_sequential.hh}. These files need to
be included in the file \texttt{tutorial\_sequential.cc}.

Each new files should contain the definition of a new class with a
name that relates to the file name, such as \texttt{Ex2TutorialProblemSequential}.
Make sure that you also adjust the guardian
macros in lines \ref{tutorial-sequential:guardian1} and \ref{tutorial-sequential:guardian2}
 in the header files (e.g. change \\
\texttt{DUMUX\_TUTORIALPROBLEM\_SEQUENTIAL\_HH} to
\texttt{DUMUX\_EX2\_TUTORIALPROBLEM\_SEQUENTIAL\_HH}).  Beside also adjusting the guardian macros,
the new problem file should define and use a new type tag for the problem as well as a new problem class
e.g. \texttt{Ex2TutorialProblemSequential}. Make sure to assign your newly defined spatial
parameter class to the \texttt{SpatialParams} property for the new
type tag.

After this, change the domain size (parameter input file) to match the domain described
by figure \ref{tutorial-sequential:ex2_Domain}. Adapt the problem class
so that the boundary conditions are consistent with figure
\ref{tutorial-sequential:ex2_BC}. Initially, the domain is fully saturated
with water and the pressure is $p_w = 2 \times 10^5 \, \text{Pa}$ . Oil
infiltrates from the left side. Create a grid with $20$ cells in
$x$-direction and $10$ cells in $y$-direction. The simulation time
should be set to $\unit[1e6]{s}$.

Now include your new problem file in the main file and replace the
\texttt{TutorialProblemSequential} type tag by the one you've created and
compile the program.


\begin{figure}[ht]
\centering
\begin{tikzpicture}[scale=0.7,>=latex]
  % basic sketch
  \draw (0,0) rectangle ++(10,5);
  \draw [fill=dumuxYellow] (2.5,1.5) rectangle ++(5,2);
  % arrows
  \draw[|<->|] (-0.2,0) -- ++(0,5);
  \node [anchor=east] at (-0.2,2.5){$\unit[50]{m}$};
  \draw[|<->|] (0,5.2) -- ++(10,0);
  \node [anchor=south] at (5,5.2){$\unit[100]{m}$};
  \draw[|<->|] (2.3,1.5) -- ++(0,2);
  \node [anchor=east] at (2.3,2.5){$\unit[20]{m}$};
  \draw[|<->|] (2.3,0) -- ++(0,1.5);
  \node [anchor=east] at (2.3,0.75){$\unit[15]{m}$};
  \draw[|<->|] (2.5,3.7) -- ++(5,0);
  \node [anchor=south] at (5,3.7){$\unit[50]{m}$};
  \draw[|<->|] (7.5,3.7) -- ++(2.5,0);
  \node [anchor=south] at (8.25,3.7){$\unit[25]{m}$};
  % labels
  \draw [dashed] (11,3) rectangle ++(7,3.5);
  \node [anchor=south west] at (11,5.4){$\mathbf{K} = \unit[10^{-7}]{m^2}$};
  \node [anchor=south west] at (11,4.6){$\phi = 0.2$};
  \node [anchor=south west] at (11,3.8){\textsc{Brooks-Corey Law}};
  \node [anchor=south west] at (11,3.0){$\lambda = 1.8, p_e = \unit[1000]{Pa}$};
  \draw [->] (11,4) -- (9.5,2.5);
  \draw [dashed] (11,-1) rectangle ++(7,3.5);
  \node [anchor=south west] at (11,1.4){$\mathbf{K} = \unit[10^{-9}]{m^2}$};
  \node [anchor=south west] at (11,0.6){$\phi = 0.15$};
  \node [anchor=south west] at (11,-0.2){\textsc{Brooks-Corey Law}};
  \node [anchor=south west] at (11,-1.0){$\lambda = 2, p_e = \unit[1500]{Pa}$};
  \draw [->] (11,1.5) -- (7,2.5);
\end{tikzpicture}
\caption{Set-up of the model domain and the soil parameters}\label{tutorial-sequential:ex2_Domain}
\end{figure}

\begin{figure}[ht]
\centering
\begin{tikzpicture}[scale=0.7,>=latex]
  % basic sketch
  \fill [pattern=north west lines] (0,0) rectangle ++(10,-0.25);
  \fill [pattern=north west lines] (0,5) rectangle ++(10,0.25);
  \draw (0,0) rectangle ++(10,5);
  \draw [fill=dumuxYellow] (2.5,1.5) rectangle ++(5,2);
  \foreach \y in {0.5,1.5,...,4.5}
    \draw [->](10.2,\y) -- ++(0.8,0);
  % labels
  \node [anchor=south] at (5,5.25){no flow};
  \node [anchor=north] at (5,-0.25){no flow};
  \node [anchor=west] at(11,2){$q_n = 0$};
  \node [anchor=west] at(11,3){$q_w = \unitfrac[2 \cdot 10^{-4}]{kg}{m^2 s}$};
  \node [anchor=west] at(-4,2){$S_w = 0$};
  \node [anchor=west] at(-4,3){$p_w = \unit[2 \cdot 10^5]{Pa}$};
\end{tikzpicture}
\caption{Boundary Conditions}\label{tutorial-sequential:ex2_BC}
\end{figure}

\begin{itemize}
 \item What happens if you increase the resolution of the grid? Hint: Paraview
 can visualize the time-steps via the ``Animation View'' (to be enabled unter the button \textit{View}).
 \item Set the CFL-factor to 1 and investigate the saturation: Is the value range reasonable?
 \item Further increase the CFL-factor to 2 and investigate the saturation.
\end{itemize}

\subsubsection{Exercise 3: Parameter file input}
As you have experienced, compilation takes quite some time. Therefore, \Dumux
provides a simple method to read in parameters (such as simulation end time or
modelling parameters) via \texttt{Paramter Input Files}. The tests in the Test-folder
\texttt{/test/} already use this system.\\
If you look at the Application in \texttt{/test/porousmediumflow/2p/sequential/}, you see that
the main file looks rather empty: The parameter file \texttt{test\_box2p.input}
is read by a standard start procedure, which is called in the main function.
This should be adapted for your problem at hand. The program run has to be
called with the parameter file as argument. As this is a basic \Dumux feature,
the procedure is the equivalent in the sequential as in the box models.
In the code, parameters can be read via the macro
\texttt{GET\_RUNTIME\_PARAM(TypeTag, Scalar, MyWonderfulGroup.MyWonderfulParameter);}.
In \texttt{test\_2p}, \texttt{MyWonderfulGroup} is the group \texttt{SpatialParams}
- any type of groups is applicable, if the group definition in the parameter file
is enclosed in square brackets. The parameters are then listed thereafter.
Try and use as much parameters as possible via the input file, such as lens
dimension, grid resolution, soil properties etc. In addition, certain parameters
that are specific to the model, such as the \texttt{CFL}-factor, can be assigned
in the parameter file without any further action.

\subsubsection{Exercise 4}
Create a new file for benzene called \texttt{benzene.hh} and implement
a new fluid system. (You may get a hint by looking at existing fluid
systems in the directory \verb+/dumux/material/fluidsystems+.)

Use benzene as a new fluid and run the model of Exercise 2 with water
and benzene. Benzene has a density of $889.51 \, \text{kg} / \text{m}^3$
and a viscosity of $0.00112 \, \text{Pa} \, \text{s}$.

\subsubsection{Exercise 5: Time Dependent Boundary Conditions}
In this exercise we want to investigate the influence of time dependent boundary
conditions. For this, redo the steps of exercise 2 and create a new problem and
spatial parameters file.

After this, change the run-time parameters so that they match the
domain described by figure \ref{tutorial-sequential:ex5_Domain}. Adapt
the problem class so that the boundary conditions are consistent with
figure \ref{tutorial-sequential:ex5_BC}. Here you can see the time dependence of
the wetting saturation, where water infiltrates only during $10^5\,\text{s}$ and
$4 \cdot 10^5\,\text{s}$. To implement these time dependencies you need the actual
time $t_{n+1}=t_n + \Delta t$ and the endtime of the simulation. For this you can
use the methods \texttt{this->timeManager().time()}, \texttt{this->timeManager().timeStepSize()}
and \texttt{this->timeManager().endTime()}.

Initially, the domain is fully saturated with oil and the pressure is $p_w = 2 \times
10^5\,\text{Pa}$.  Water infiltrates from the left side. Create a grid
with $100$ cells in $x$-direction and $10$ cells in $y$-direction. The
simulation time should be set to $5 \cdot 10^5\,\text{s}$ with an
initial time-step size of $10\,\text{s}$. To avoid too big time-step sizes you
should set the parameter \texttt{MaxTimeStepSize} for the group \texttt{TimeManager}
(in your input file) to $\unit[100]{s}$. You should only create output files
every $100^{th}$ time-step (see exercise 1a). Then, you can compile the program.

\begin{figure}[ht]
\centering
\begin{tikzpicture}[scale=0.7,>=latex]
  % basic sketch
  \fill [pattern=north west lines] (0,0) rectangle ++(10,-0.25);
  \fill [pattern=north west lines] (0,5) rectangle ++(10,0.25);
  \draw (0,0) rectangle ++(10,5);
  \foreach \y in {0.5,1.5,...,4.5}
    \draw [->](10.2,\y) -- ++(0.8,0);
  % arrows
  \draw[|<->|] (-0.2,0) -- ++(0,5);
  \node [anchor=east] at (-0.2,1.5){$\unit[50]{m}$};
  \draw[|<->|] (0,5.35) -- ++(10,0);
  \node [anchor=south] at (2.5,5.2){$\unit[100]{m}$};
  % labels
  \node [anchor=south] at (5,5.25){no flow};
  \node [anchor=north] at (5,-0.25){no flow};
  \node [anchor=west] at(11,2){$q_n = \unitfrac[1 \cdot 10^{-3}]{kg}{m^2 s}$};
  \node [anchor=west] at(11,3){$q_w = 0$};
  \node [anchor=west] at(-4,2){$S_w(t)$};
  \node [anchor=west] at(-4,3){$p_w = \unit[2 \cdot 10^5]{Pa}$};
  \node [anchor=south west] at (2.5,3.4){$\mathbf{K} = \unit[10^{-7}]{m^2}$};
  \node [anchor=south west] at (2.5,2.6){$\phi = 0.2$};
  \node [anchor=south west] at (2.5,1.8){\textsc{Brooks-Corey Law}};
  \node [anchor=south west] at (2.5,1.0){$\lambda = 2, \; p_e = \unit[500]{Pa}$};
\end{tikzpicture}
\caption{Set-up of the model domain and the soil parameters}\label{tutorial-sequential:ex5_Domain}
\end{figure}

%  \draw (0,0) sin (5,5) cos (10,0);
\begin{figure}[ht]
\centering
\begin{tikzpicture}[scale=0.9,>=latex]
    % Draw axes
    \draw [<->,thick] (0,6) node (yaxis) [above] {$S_w$}
        |- (11,0) node (xaxis) [right] {time\,[s]};
    \draw plot[smooth,samples=100,domain=0:1] (6*\x + 2 ,{5*sin((\x)*pi r)});
	\draw [dashed] (0,5) -- (5,5);

    % axes labeling
    \draw [-] (-0.1,5) -- (0.1,5);
    \node [anchor=west] at(-0.5,5){$1$};
    \draw [-] (-0.1,0) -- (0.1,0);
    \node [anchor=west] at(-0.5,0){$0$};
    \draw [-] (2,0.1) -- (2,-0.1);
    \node [anchor=west] at(1.5,-0.4){$1\cdot10^{5}$};
    \draw [-] (8,0.1) -- (8,-0.1);
    \node [anchor=west] at(7.5,-0.4){$4\cdot10^{5}$};
    \draw [-] (10,0.1) -- (10,-0.1);
    \node [anchor=west] at(9.5,-0.4){$5\cdot10^{5}$};

    \node [anchor=base] at (5,2){$\sin(\pi\frac{\text{time}-10^5}{3\cdot 10^5 })$};
\end{tikzpicture}
\caption{Time Dependent Boundary Conditions}\label{tutorial-sequential:ex5_BC}
\end{figure}

\begin{itemize}
 \item Open paraview and plot the values of $S_w$ at time $\unit[5 \cdot 10^5]{s}$
 over the $x-$axis.\\ (\texttt{Filter->Data Analysis->Plot Over Line})
 \item What happens without any time-step restriction?
\end{itemize}

\subsubsection{Exercise 6}
If both the implicit and the sequential tutorial are completed, one should have
noticed that the function arguments in the problem function differ slighty, as
the numerical models differ. However, both are functions that depend on space,
so both models can also work with functions based ond \mbox{\texttt{...AtPos(GlobalPosition \& globalPos)}},
no matter if we model implicit or sequential. Try to formulate a spatial parameters
file that works with both problems, the implicit and the sequential. Therein, only
use functions at the position.