Commit abc1ba14 authored by Thomas Witkowski's avatar Thomas Witkowski
Browse files

Some work on the tutorial.

parent ac5fd6dc
......@@ -85,7 +85,7 @@ The first lines of class \verb+Heat+ are:
class Heat : public ProblemInstatScal
{
public:
Heat(ProblemScal *heatSpace)
Heat(ProblemScal &heatSpace)
: ProblemInstatScal("heat", heatSpace)
{
theta = -1.0;
......@@ -102,9 +102,7 @@ The next lines show the implementation of the time interface.
\begin{lstlisting}{}
void setTime(AdaptInfo *adaptInfo)
{
rhsTime =
adaptInfo->getTime()-
(1-theta)*adaptInfo->getTimestep();
rhsTime = adaptInfo->getTime() - (1 - theta) * adaptInfo->getTimestep();
boundaryTime = adaptInfo->getTime();
tau1 = 1.0 / adaptInfo->getTimestep();
}
......@@ -179,12 +177,12 @@ int main(int argc, char** argv)
Parameters::init(false, argv[1]);
// ===== create and init stationary problem =====
ProblemScal *heatSpace = new ProblemScal("heat->space");
heatSpace->initialize(INIT_ALL);
ProblemScal heatSpace("heat->space");
heatSpace.initialize(INIT_ALL);
// ===== create instationary problem =====
Heat *heat = new Heat(heatSpace);
heat->initialize(INIT_ALL);
Heat heat(heatSpace);
heat.initialize(INIT_ALL);
\end{lstlisting}
So far, the stationary space problem \verb+heatSpace+ and the instationary problem \verb+heat+ were created and initialized. \verb+heatSpace+ is an instance of \verb+ProblemScal+. \verb+heat+ is an instance of the class \verb+Heat+ we defined above. \verb+heatSpace+ is given to \verb+heat+ as its stationary problem.
......@@ -193,17 +191,17 @@ The next step is the creation of the needed \verb+AdaptInfo+ objects and of the
\begin{lstlisting}{}
// create adapt info for heat
AdaptInfo *adaptInfo = new AdaptInfo("heat->adapt");
AdaptInfo adaptInfo("heat->adapt");
// create initial adapt info
AdaptInfo *adaptInfoInitial = new AdaptInfo("heat->initial->adapt");
AdaptInfo adaptInfoInitial("heat->initial->adapt");
// create instationary adapt
AdaptInstationary *adaptInstat = new AdaptInstationary("heat->adapt",
heatSpace,
adaptInfo,
heat,
adaptInfoInitial);
AdaptInstationary adaptInstat("heat->adapt",
heatSpace,
adaptInfo,
heat,
adaptInfoInitial);
\end{lstlisting}
The object \verb+heatSpace+ is handed as \verb+ProblemIterationInterface+ (implemented by class\\ \verb+ProblemScal+) to the adaptation loop. \verb+heat+ is interpreted as \verb+ProblemTimeInterface+ (implemented by class \verb+ProblemInstatScal+).
......@@ -213,15 +211,15 @@ The definitions of functions $f$ and $g$ are:
\begin{lstlisting}{}
// ===== create boundary functions =====
G *boundaryFct = new G;
boundaryFct->setTimePtr(heat->getBoundaryTimePtr());
heat->setExactSolution(boundaryFct);
boundaryFct->setTimePtr(heat.getBoundaryTimePtr());
heat.setExactSolution(boundaryFct);
heatSpace->addDirichletBC(1, boundaryFct);
heatSpace.addDirichletBC(1, boundaryFct);
// ===== create rhs functions =====
int degree = heatSpace->getFESpace()->getBasisFcts()->getDegree();
int degree = heatSpace.getFESpace()->getBasisFcts()->getDegree();
F *rhsFct = new F(degree);
rhsFct->setTimePtr(heat->getRHSTimePtr());
rhsFct->setTimePtr(heat.getRHSTimePtr());
\end{lstlisting}
The functions interpreted as \verb+TimedObject+s are linked with the corresponding time pointers by \verb+setTimePtr+. The boundary function is handed to \verb+heat+ as exact solution and as Dirichlet boundary function with identifier $1$ to \verb+heatSpace+.
......@@ -234,61 +232,68 @@ Now, we define the operators:
double zero = 0.0;
// create laplace
Operator *A = new Operator(Operator::MATRIX_OPERATOR |
Operator::VECTOR_OPERATOR,
heatSpace->getFESpace());
A->addSecondOrderTerm(new Laplace_SOT);
A->setUhOld(heat->getOldSolution());
if((*(heat->getThetaPtr())) != 0.0)
heatSpace->addMatrixOperator(A, heat->getThetaPtr(), &one);
if((*(heat->getTheta1Ptr())) != 0.0)
heatSpace->addVectorOperator(A, heat->getTheta1Ptr(), &zero);
Operator A(Operator::MATRIX_OPERATOR | Operator::VECTOR_OPERATOR,
heatSpace.getFESpace());
A.addSecondOrderTerm(new Laplace_SOT);
A.setUhOld(heat.getOldSolution());
if (*(heat.getThetaPtr()) != 0.0)
heatSpace.addMatrixOperator(A, heat.getThetaPtr(), &one);
if (*(heat.getTheta1Ptr()) != 0.0)
heatSpace.addVectorOperator(A, heat.getTheta1Ptr(), &zero);
\end{lstlisting}
Operator \verb+A+ represents $-\Delta u$. It is used as matrix operator on the left hand side with factor $\theta$ and as vector operator on the right hand side with factor $-(1-\theta) = \theta - 1$. These assemble factors are the second arguments of \verb+addMatrixOperator+ and \verb+addVectorOperator+. The third argument is the factor used for estimation. In this example, the estimator will consider the operator only on the left hand side with factor $1$. On the right hand side the operator is applied to the solution of the last timestep. So the old solution is handed to the operator by \verb+setUhOld+.
Operator \verb+A+ represents $-\Delta u$. It is used as matrix
operator on the left hand side with factor $\theta$ and as vector
operator on the right hand side with factor $-(1-\theta) = \theta -
1$. These assemble factors are the second arguments of
\verb+addMatrixOperator+ and \verb+addVectorOperator+. The third
argument is the factor used for estimation. In this example, the
estimator will consider the operator only on the left hand side with
factor $1$. On the right hand side the operator is applied to the
solution of the last timestep. So the old solution is handed to the
operator by \verb+setUhOld+.
\begin{lstlisting}{}
// create zero order operator
Operator *C = new Operator(Operator::MATRIX_OPERATOR |
Operator::VECTOR_OPERATOR,
heatSpace->getFESpace());
C->addZeroOrderTerm(new Simple_ZOT);
C->setUhOld(heat->getOldSolution());
heatSpace->addMatrixOperator(C, heat->getTau1Ptr(), heat->getTau1Ptr());
heatSpace->addVectorOperator(C, heat->getTau1Ptr(), heat->getTau1Ptr());
Operator C(Operator::MATRIX_OPERATOR | Operator::VECTOR_OPERATOR,
heatSpace.getFESpace());
C.addZeroOrderTerm(new Simple_ZOT);
C.setUhOld(heat.getOldSolution());
heatSpace.addMatrixOperator(C, heat.getTau1Ptr(), heat.getTau1Ptr());
heatSpace.addVectorOperator(C, heat.getTau1Ptr(), heat.getTau1Ptr());
\end{lstlisting}
The \verb+Simple_ZOT+ of operator \verb+C+ represents the zero order terms for the time discretization. On both sides of the equation $u$ is added with $\frac{1}{\tau}$ as assemble factor and as estimate factor.
The \verb+Simple_ZOT+ of operator \verb+C+ represents the zero order
terms for the time discretization. On both sides of the equation $u$
is added with $\frac{1}{\tau}$ as assemble factor and as estimate
factor.
Finally, the operator for the right hand side function $f$ is added and the adaptation loop is started:
Finally, the operator for the right hand side function $f$ is added
and the adaptation loop is started:
\begin{lstlisting}{}
// create RHS operator
Operator *F = new Operator(Operator::VECTOR_OPERATOR,
heatSpace->getFESpace());
F->addZeroOrderTerm(new CoordsAtQP_ZOT(rhsFct));
heatSpace->addVectorOperator(F);
Operator F(Operator::VECTOR_OPERATOR, heatSpace.getFESpace());
F.addZeroOrderTerm(new CoordsAtQP_ZOT(rhsFct));
heatSpace.addVectorOperator(F);
// ===== start adaption loop =====
adaptInstat->adapt();
int errorCode = adaptInstat.adapt();
}
\end{lstlisting}
\verb+CoordsAtQP_ZOT+ is a zero order term that evaluates a given function $fct$ at all needed quadrature points. At the left hand side, it would represent the term $fct(x, t)\cdot u$, on the right hand side, just $fct(x, t)$. Note that the old solution isn't given to the operator here. Otherwise the term would represent $fct(x, t) \cdot u^{old}$ on the right hand side.
\verb+CoordsAtQP_ZOT+ is a zero order term that evaluates a given
function $fct$ at all needed quadrature points. At the left hand side,
it would represent the term $fct(x, t)\cdot u$, on the right hand
side, just $fct(x, t)$. Note that the old solution isn't given to the
operator here. Otherwise the term would represent $fct(x, t) \cdot
u^{old}$ on the right hand side.
\subsection{Parameter file}
\label{s:heat parameter}
In this section, we show only the relevant parts of the parameter file \verb+heat.dat.2d+.
In this section, we show only the relevant parts of the parameter file
\verb+heat.dat.2d+.
First the parameter $\theta$ for the time discretization is defined:
......@@ -314,7 +319,15 @@ heat->adapt->time theta 1: 1.0
heat->adapt->time theta 2: 0.3
\end{lstlisting}
The total tolerance is divided in a space tolerance and a time tolerance. The space tolerance is the maximal allowed space error, given by the product of \verb+tolerance+ and \verb+rel space error+. It is reached by adaptive mesh refinements. The time tolerance is the maximal allowed error, due to the timestep size. It is given by the product of \verb+tolerance+ and \verb+rel time error+ and \verb+time theta 1+. It is relevant, only if an implicit time strategy with adaptive timestep size is used. The parameter \verb+time theta 2+ is used to enlarge the timestep, if the estimated time error falls beneath a given threshold.
The total tolerance is divided in a space tolerance and a time
tolerance. The space tolerance is the maximal allowed space error,
given by the product of \verb+tolerance+ and \verb+rel space error+. It is reached by adaptive mesh refinements. The time tolerance
is the maximal allowed error, due to the timestep size. It is given by
the product of \verb+tolerance+ and \verb+rel time error+ and
\verb+time theta 1+. It is relevant, only if an implicit time strategy
with adaptive timestep size is used. The parameter \verb+time theta 2+
is used to enlarge the timestep, if the estimated time error falls
beneath a given threshold.
\begin{lstlisting}{}
heat->adapt->strategy: 1
......@@ -322,9 +335,17 @@ heat->adapt->time delta 1: 0.7071
heat->adapt->time delta 2: 1.4142
\end{lstlisting}
If \verb+strategy+ is $0$, an explicit time strategy with fixed timestep size is used. A value of $1$ stands for the implicit strategy. The time tolerance is reached by successively multiplying the timestep with \verb+time delta 1+. If the estimated timestep error is smaller than the product of \verb+tolerance+ and \verb+rel time error+ and \verb+time theta 2+ at the end of a timestep, the timestep size is multiplied by \verb+time delta 2+.
The following lines determine, whether coarsening is allowed in regions with sufficient small errors, and how many refinements or coarsenings are performed for marked elements.
If \verb+strategy+ is $0$, an explicit time strategy with fixed
timestep size is used. A value of $1$ stands for the implicit
strategy. The time tolerance is reached by successively multiplying
the timestep with \verb+time delta 1+. If the estimated timestep error
is smaller than the product of \verb+tolerance+ and
\verb+rel time error+ and \verb+time theta 2+ at the end of a
timestep, the timestep size is multiplied by \verb+time delta 2+.
The following lines determine, whether coarsening is allowed in
regions with sufficient small errors, and how many refinements or
coarsenings are performed for marked elements.
\begin{lstlisting}{}
heat->adapt->coarsen allowed: 1
heat->adapt->refine bisections: 2
......@@ -347,19 +368,33 @@ heat->space->output->index length: 6
heat->space->output->index decimals: 3
\end{lstlisting}
In this example, all output filenames start with prefix \verb+output/heat+ and end with the extensions \verb+.mesh+ and \verb+.dat+. Output is written after every $10$th timestep. The time of the single solution is added after the filename prefix with 6 letters, three of them are decimals. The solution for $t=0$ e.g. would be written in the files \verb+output/heat00.000.mesh+ and \verb+output/heat00.000.dat+.
In this example, all output filenames start with prefix
\verb+output/heat+ and end with the extensions \verb+.mesh+ and
\verb+.dat+. Output is written after every $10$th timestep. The time
of the single solution is added after the filename prefix with 6
letters, three of them are decimals. The solution for $t=0$ e.g. would
be written in the files \verb+output/heat00.000.mesh+ and
\verb+output/heat00.000.dat+.
Finally, we set parameter \verb+WAIT+ to $1$. So each call of the macro \verb+WAIT+ in the application will lead to an interruption of the program, until the \verb+return+ key is pressed.
Finally, we set parameter \verb+WAIT+ to $1$. So each call of the
macro \verb+WAIT+ in the application will lead to an interruption of
the program, until the \verb+return+ key is pressed.
\begin{lstlisting}{}
WAIT: 1
\end{lstlisting}
\subsection{Macro file}
We again use the macro file \verb+macro/macro.stand.2d+, which was described in Section \ref{s:ellipt macro}.
We again use the macro file \verb+macro/macro.stand.2d+, which was
described in Section \ref{s:ellipt macro}.
\subsection{Output}
As mentioned above, the output files look like \verb+output/heat00.000.mesh+ and \verb+output/heat00.000.dat+. Depending on the corresponding value in the parameter file only the solution after every $i$-th timestep is written. In Figure \ref{f:heat}, the solution at three timesteps is visualized.
As mentioned above, the output files look like
\verb+output/heat00.000.mesh+ and
\verb+output/heat00.000.dat+. Depending on the corresponding value in
the parameter file only the solution after every $i$-th timestep is
written. In Figure \ref{f:heat}, the solution at three timesteps is
visualized.
\begin{figure}
\center
......
......@@ -9,37 +9,45 @@ To install the AMDiS library, the following steps must be performed:
\item Create the AMDiS source directory. This can be done in different ways. Here, we show three possibilities:
\begin{itemize}
\item Unpacking the archive file {\tt AMDiS.tar.gz}:
\item Unpacking the archive file {\tt AMDiS.tgz}:
\begin{itemize}
\item {\tt > gunzip AMDiS.tar.gz}
\item {\tt > tar xvf AMDiS.tar}
\item {\tt > tar xvfz AMDiS.tgz}
\end{itemize}
\item Checking out a CVS project:
\item Checking out an SVN project:
\begin{itemize}
\item {\tt > export CVSROOT=<cvsroot>}
\item {\tt > cvs checkout AMDiS}
\end{itemize}
\item Checking out a CVS project:
\begin{itemize}
\item {\tt > svn checkout file://<SVN-REPOSITORY-PATH>/AMDiS}
\item {\tt > svn checkout --username developername \\}
{\tt https://gforge.zih.tu-dresden.de/svn/amdis/trunk amdis}
\end{itemize}
\end{itemize}
\item Change into the AMDiS directory:
\begin{verbatim}
> cd AMDiS
> cd amdis/AMDiS
\end{verbatim}
\item Create the makefiles for your system using the \verb+configure+ script:
\begin{verbatim}
> ./configure <CONFIGURE-OPTIONS>
\end{verbatim}
The \verb+configure+ script creates the needed makefiles. It can be called with the following options:
The \verb+configure+ script creates the needed makefiles. It can be
called with the following options:
\begin{description}
\item \verb+--prefix=<AMDIS-DIR>+: Installation path of the AMDiS library. The library file will be stored in \verb+<AMDIS-DIR>/lib+. With \verb+--prefix=`pwd`+ AMDiS will be installed in the current working directory, which mostly is a good choice.
\item \verb+--enable-debug+: If this option is used, AMDiS will be compiled with debug support. By default, AMDiS is compiled in an optimized mode without debug support.
\item \verb+--with-mpi=<MPI-DIR>+: MPI installation path. Used for parallelization support.
\item \verb+--with-parmetis=<PARMETIS-DIR>+: ParMETIS installation path. ParMETIS is a parallel graph partitioning library, see \\\verb+http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview+. Used for parallelization support.
\item \verb+--prefix=<AMDIS-DIR>+: Installation path of the AMDiS
library. The library file will be stored in
\verb+<AMDIS-DIR>/lib+. With \verb+--prefix=`pwd`+ AMDiS will be
installed in the current working directory, which mostly is a good
choice.
\item \verb+--enable-debug+: If this option is used, AMDiS will be
compiled with debug support. By default, AMDiS is compiled in an
optimized mode without debug support.
\item \verb+--enable-umfpack+: If this option is used, AMDiS is
compiled with support for the UMFPACK solver library.
\item \verb+--with-mpi=<MPI-DIR>+: MPI installation path. Used for
parallelization support.
\item \verb+--with-parmetis=<PARMETIS-DIR>+: ParMETIS installation
path. ParMETIS is a parallel graph partitioning library, see
\\\verb+http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview+. Used
for parallelization support.
\end{description}
If AMDiS should be compiled for parallel usage, the MPI and ParMETIS paths must be set.
......
\section{Systems of PDEs}
\label{s:vecellipt}
In this example, we show how to implement a system of coupled PDEs. We define
In this example, we show how to implement a system of coupled PDEs. We
define
\begin{eqnarray}
-\Delta u &=& f\\
u - v &=& 0.
\end{eqnarray}
For the first equation, we use the boundary condition and definition of function $f$ from Section \ref{s:ellipt}. The second equation defines a second solution component $v$, which is coupled to $u$, such that $v=u$. For the second equation, no boundary conditions have to be defined. The system can be written in matrix-vector form as
For the first equation, we use the boundary condition and definition
of function $f$ from Section \ref{s:ellipt}. The second equation
defines a second solution component $v$, which is coupled to $u$, such
that $v=u$. For the second equation, no boundary conditions have to be
defined. The system can be written in matrix-vector form as
\begin{equation}
\left( \begin{array}{rr}-\Delta & 0 \\I & -I\end{array}\right)
\left(\begin{array}{r}u\\v\end{array}\right)
=
\left( \begin{array}{r}f\\0\end{array}\right),
\end{equation}
where $I$ stands for the identity and $0$ for a {\it zero operator} (or for the absence of any operator). This is a very simple example without practical relevance. But it is appropriate to demonstrate the main principles of implementing vector valued problems.
where $I$ stands for the identity and $0$ for a {\it zero operator}
(or for the absence of any operator). This is a very simple example
without practical relevance. But it is appropriate to demonstrate the
main principles of implementing vector valued problems.
\begin{table}
\center
......@@ -33,31 +41,30 @@ where $I$ stands for the identity and $0$ for a {\it zero operator} (or for the
\end{table}
\subsection{Source code}
Instead of a scalar problem, we now create and initialize the vector valued problem \verb+vecellipt+:
Instead of a scalar problem, we now create and initialize the vector
valued problem \verb+vecellipt+:
\begin{lstlisting}{}
ProblemVec vecellipt("vecellipt");
vecellipt.initialize(INIT_ALL);
\end{lstlisting}
The \verb+AdaptInfo+ constructor is called with the number of problem components, which is defined in the parameter file.
The \verb+AdaptInfo+ constructor is called with the number of problem
components, which is defined in the parameter file.
\begin{lstlisting}{}
// === create adapt info ===
AdaptInfo *adaptInfo = new AdaptInfo("vecellipt->adapt",
vecellipt.getNumComponents());
AdaptInfo adaptInfo("vecellipt->adapt", vecellipt.getNumComponents());
// === create adapt ===
AdaptStationary *adapt = new AdaptStationary("vecellipt->adapt",
&vecellipt,
adaptInfo);
// === create adapt ===
AdaptStationary adapt("vecellipt->adapt", vecellipt, adaptInfo);
\end{lstlisting}
The adaptation loop doesn't care about the component number. It treats \verb+vecellipt+ only as implementation of the iteration interface.
The adaptation loop doesn't care about the component number. It treats
\verb+vecellipt+ only as implementation of the iteration interface.
The Dirichlet boundary condition for the first equation is defined by
The Dirichlet boundary condition for the first equation is defined by
\begin{lstlisting}{}
// ===== add boundary conditions =====
......@@ -78,43 +85,49 @@ The operator definitions for the first equation are:
matrixOperator00.addSecondOrderTerm(new Laplace_SOT);
vecellipt.addMatrixOperator(&matrixOperator00, 0, 0);
int degree = vecellipt.getFESpace(0)->getBasisFcts()->getDegree();
Operator rhsOperator0(Operator::VECTOR_OPERATOR,
vecellipt.getFESpace(0));
int degree = vecellipt.getFESpace(0)->getBasisFcts()->getDegree();
rhsOperator0.addZeroOrderTerm(new CoordsAtQP_ZOT(new F(degree)));
vecellipt.addVectorOperator(&rhsOperator0, 0);
\end{lstlisting}
Operator \verb+matrixOperator00+ represents the $-\Delta$ operator. Each operator belongs to two finite element spaces, the {\it row space} and the {\it column space}. If an operator has the position $(i,j)$ in the operator matrix, the row space is the finite element space of component $i$ and the column space is the finite element space of component $j$. The finite element spaces can differ in the used basis function degree. The underlying meshes must be the same. After \verb+matrixOperator00+ is created, it is handed to the problems operator matrix at position $(0,0)$.
The right hand side operator \verb+rhsOperator0+ only needs a row space, which is the finite element space of component $0$ ($u$). It is handed to the operator vector at position $0$.
Operator \verb+matrixOperator00+ represents the $-\Delta$
operator. Each operator belongs to two finite element spaces, the {\it
row space} and the {\it column space}. If an operator has the
position $(i,j)$ in the operator matrix, the row space is the finite
element space of component $i$ and the column space is the finite
element space of component $j$. The finite element spaces can differ
in the used basis function degree. The underlying meshes must be the
same. After \verb+matrixOperator00+ is created, it is handed to the
problems operator matrix at position $(0,0)$. The right hand side
operator \verb+rhsOperator0+ only needs a row space, which is the
finite element space of component $0$ ($u$). It is handed to the
operator vector at position $0$.
Now, the operators for the second equation are defined:
\begin{lstlisting}{}
Operator matrixOperator10(Operator::MATRIX_OPERATOR,
vecellipt.getFESpace(1),
vecellipt.getFESpace(0));
Operator matrixOperator11(Operator::MATRIX_OPERATOR,
vecellipt.getFESpace(1),
vecellipt.getFESpace(1));
vecellipt.getFESpace(1), vecellipt.getFESpace(0));
matrixOperator10.addZeroOrderTerm(new Simple_ZOT);
vecellipt.addMatrixOperator(matrixOperator10, 1, 0);
vecellipt.addMatrixOperator(&matrixOperator10, 1, 0);
Operator matrixOperator11(Operator::MATRIX_OPERATOR,
vecellipt.getFESpace(1), vecellipt.getFESpace(1));
matrixOperator11.addZeroOrderTerm(new Simple_ZOT(-1.0));
vecellipt.addMatrixOperator(&matrixOperator11, 1, 1);
vecellipt.addMatrixOperator(matrixOperator11, 1, 1);
\end{lstlisting}
Note that the operator \verb+matrixOperator10+ can have different finite element spaces, if the spaces of the two components differ. The operators $I$ and $-I$ are implemented by \verb+Simple_ZOT+, once with a fixed factor of $1$ and once with a factor of $-1$.
Note that the operator \verb+matrixOperator10+ can have different
finite element spaces, if the spaces of the two components differ. The
operators $I$ and $-I$ are implemented by \verb+Simple_ZOT+, once with
a fixed factor of $1$ and once with a factor of $-1$.
\subsection{Parameter file}
First, the number of components and the basis function degrees are given. We use Lagrange polynomials of degree 1 for the first component and of degree 2 for the second component.
First, the number of components and the basis function degrees are
given. We use Lagrange polynomials of degree 1 for the first component
and of degree 2 for the second component.
\begin{lstlisting}{}
vecellipt->components: 2
......@@ -123,29 +136,41 @@ vecellipt->polynomial degree[0]: 1
vecellipt->polynomial degree[1]: 2
\end{lstlisting}
In general, the linear system of equations for systems of PDEs is not symmetric. So with the GMRes solver, we use a solver that doesn't assume symmetric matrices.
In general, the linear system of equations for systems of PDEs is not
symmetric. So with the GMRes solver, we use a solver that doesn't
assume symmetric matrices.
\begin{lstlisting}{}
vecellipt->solver: gmres
\end{lstlisting}
Note that we have only one solver, because the equations of our system are assembled in one linear system of equations.
Note that we have only one solver, because the equations of our system
are assembled in one linear system of equations.
Each equation can have its own estimator. In this case, adaptivity should be managed only by the first component. So the second equation has no estimator.
Each equation can have its own estimator. In this case, adaptivity
should be managed only by the first component. So the second equation
has no estimator.
\begin{lstlisting}{}
vecellipt->estimator[0]: residual
vecellipt->estimator[1]: no
\end{lstlisting}
Also the marking strategy can differ between the components. Refinement is done, if at least one component has marked an element for refinement. Coarsening only is done, if all components have marked the element for coarsening. In our example, only component $0$ will mark elements.
Also the marking strategy can differ between the
components. Refinement is done, if at least one component has marked
an element for refinement. Coarsening only is done, if all components
have marked the element for coarsening. In our example, only component
$0$ will mark elements.
\begin{lstlisting}{}
vecellipt->marker[0]->strategy: 2
vecellipt->marker[1]->strategy: 0
\end{lstlisting}
We have only one adaptation loop, which does maximal $6$ iterations. The tolerance can be determined for each component. The total tolerance criterion is fulfilled, if all criteria of all components are fulfilled.
We have only one adaptation loop, which does maximal $6$
iterations. The tolerance can be determined for each component. The
total tolerance criterion is fulfilled, if all criteria of all
components are fulfilled.
\begin{lstlisting}{}
vecellipt->adapt->max iteration: 6
......@@ -171,12 +196,15 @@ vecellipt->output[1]->AMDiS data ext: .dat
\end{lstlisting}
\subsection{Macro file}
We again use the macro file \verb+macro/macro.stand.2d+, which was described in Section \ref{s:ellipt macro}.
We again use the macro file \verb+macro/macro.stand.2d+, which was
described in Section \ref{s:ellipt macro}.
\subsection{Output}
\label{s:vecellipt output}
Component $0$ of the solution (approximation of $u$) is written to the files \verb+output/vecellipt0.mesh+ and \verb+output/vecellipt0.dat+.
Component $1$ of the solution (approximation of $v$) is written to the files \verb+output/vecellipt1.mesh+ and \verb+output/vecellipt1.dat+.
Component $0$ of the solution (approximation of $u$) is written to the
files \verb+output/vecellipt0.mesh+ and \verb+output/vecellipt0.dat+.
Component $1$ of the solution (approximation of $v$) is written to the
files \verb+output/vecellipt1.mesh+ and \verb+output/vecellipt1.dat+.
The two components are visualized in Figure \ref{f:vecellipt}.
\begin{figure}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment