% sample.tex
%\documentclass[final,logg,nocolorBG,pdf]{prosper}
\documentclass[final, pdf,slideColor,nocolorBG]{prosper}
\hypersetup{colorlinks=true,anchorcolor=red,filecolor=red}

%\usepackage{graphicx}
%\usepackage{psfrag}
%\usepackage{epic}
%\usepackage{eepic}
%\usepackage{amssymb}
%\usepackage[latin1]{inputenc}
%\usepackage{latexsym}
%\usepackage{amsmath}

\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{latexsym}
\usepackage{epic}
\usepackage{eepic}
\usepackage{amsbsy}
\usepackage{relsize}
\usepackage{psfrag}

\newcommand{\fenics}{\scalebox{1.3}{\textbf{\textsf{FE}}}\scalebox{1.6}{\textbf{\textsf{ni}}}\scalebox{1.3}{\textbf{\textsf{CS}}}}
\newcommand{\fenicssmall}{\scalebox{1.0}{\textbf{\textsf{FE}}}\scalebox{1.2}{\textbf{\textsf{ni}}}\scalebox{1.0}{\textbf{\textsf{CS}}}}
\newcommand{\FENICS}{\textbf{\textsf{\Large{FE}\Huge{ni}\Large{CS}}}}
\newcommand{\dolfin}{\scalebox{1.3}{\textbf{\textsf{DOLFIN}}}}
\newcommand{\dolfinsmall}{\scalebox{1.0}{\textbf{\textsf{DOLFIN}}}}
\newcommand{\fiat}{\scalebox{1.3}{\textbf{\textsf{FIAT}}}}
\newcommand{\ko}{\scalebox{1.3}{\textbf{\textsf{Ko}}}}
\newcommand{\puffin}{\scalebox{1.3}{\textbf{\textsf{Puffin}}}}
\newcommand{\puffinsmall}{\scalebox{1.0}{\textbf{\textsf{Puffin}}}}
\newcommand{\ferari}{\scalebox{1.3}{\textbf{\textsf{FErari}}}}
\newcommand{\ffc}{\scalebox{1.3}{\textbf{\textsf{FFC}}}}
\newcommand{\ffcsmall}{\scalebox{1.0}{\textbf{\textsf{FFC}}}}
\newcommand{\cgq}{$\mathrm{cG}(q)$}
\newcommand{\dgq}{$\mathrm{dG}(q)$}
\newcommand{\mcgq}{$\mathrm{mcG}(q)$}
\newcommand{\mdgq}{$\mathrm{mdG}(q)$}
\newcommand{\back}{\scalebox{1.3}{$\hookleftarrow$}}
\newcommand{\comp}[1]{{\scriptstyle [#1]}}
\newcommand{\ind}[1]{{\scriptstyle (\cdot)}}
\newcommand{\real}{\mathbb{R}}

\ptsize{8}

\def\movieroot{file:///root/data/txt/tex/CAM2004/movies/}

\hyperbaseurl{}


\title{\black A compiler for variational forms - practical results}
\subtitle{USNCCM8}
\author{Johan Jansson}
\institution{Chalmers University of Technology

  \vspace{1.5cm}
  \scriptsize{Acknowledgements:
    Anders Logg and the FEniCS members}}
\email{johanjan@math.chalmers.se}



\begin{document}

\maketitle

\begin{slide}{Overview}

\bigskip

\begin{itemize}

\item
        Part I - \fenicssmall{} Form Compiler (FFC):

{\large
\begin{itemize}
\item
        Motivation for FFC (generality of FEM)

\item
        Introduction to FFC

\item
        Benchmarks (FFC vs. quadrature)
\end{itemize}
}

\item
        Part II - Application (Elasto-Plasticity):

{\large
\begin{itemize}
\item
        Motivation for elasto-plastic model

\item
        Implementation of elasto-plastic model in FFC

\item
        Benchmarks (FFC vs. mass-spring)

\item
        Future work
\end{itemize}
}


\end{itemize}

\end{slide}


\begin{slide}{Motivation for FFC}

\fenicssmall{} project: Automation of Computational Mathematical Modeling
(ACMM)

\bigskip

Finite Element Method: General method for automating discretization of
differential equations

\bigskip

{\color{red}This generality is seldom reflected in software}

\bigskip

Reasons: conceptual complexity, hand-written routines often outperform general routines

\bigskip

How can we overcome these difficulties?

\bigskip

Through a {\color{red}Form Compiler} which automatically generates an optimal
Finite Element routine (assembly)

\end{slide}

\begin{slide}{Motivation for FFC}

Advantages of compilation:

\begin{itemize}

\item
A form compiler can be written in a high-level language and/or with
high-level data structures which eases {\color{red}conceptual
abstraction}.

\item
A form compiler can {\color{red}pre-compute} quantities which are
known at compile time.

\end{itemize}

Disadvantages of compilation:

\begin{itemize}

\item
Forms cannot easily be modified during run time.

\end{itemize}

\end{slide}

\begin{slide}{FFC: the FEniCS Form Compiler}

\begin{itemize}
\item
  Automates a key step in the implementation of finite element methods
  for partial differential equations
\end{itemize}

\begin{itemize}
\item
  Input: a variational form and a finite element
\item
  Output: optimal C/C++
  % Put in a link so we can click yes to all quickly
%  \href{run:./demonstration.sh}{code}
\end{itemize}

\vspace{1cm}

\begin{center}
  \psfrag{FFC}{\ \ffc{}}
  \psfrag{form}{$a(v, u) = \int_{\Omega} \nabla u(x) \cdot \nabla v(x) \, dx$}
  \includegraphics[width=11cm]{eps/ffc.eps}
\end{center}

\vspace{0.5cm}

\begin{verbatim}
  >> ffc [-l language] poisson.form
\end{verbatim}

\end{slide}


\begin{slide}{Basic example: Poisson's equation}

\begin{itemize}
\item
  Strong form: Find $u \in \mathcal{C}^2(\overline{\Omega})$ with $u = 0$ on $\partial \Omega$ such that
  \begin{displaymath}
    -\Delta u = f \quad \mbox{in } \Omega 
  \end{displaymath}
\item
  Weak form: Find $u \in H^1_0(\Omega)$ such that
  \begin{displaymath}
    \int_{\Omega} \nabla u(x) \cdot \nabla v(x) \, dx =
    \int_{\Omega} f(x) v(x) \, dx \quad \mbox{for all } v \in H^1_0(\Omega)
  \end{displaymath}
\item
  Standard notation: Find $u \in V$ such that
  \begin{displaymath}
    a(v, u) = L(v) \quad \mbox{for all } v \in \hat{V}
  \end{displaymath}
  with $a : \hat{V} \times V \rightarrow \real$ a \emph{bilinear form}
  and $L : \hat{V} \rightarrow \real$ a \emph{linear form} (functional)
\end{itemize}


\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Obtaining the discrete system}

Let $V$ and $\hat{V}$ be discrete function spaces. Then
\begin{displaymath}
  a(v, U) = L(v) \quad \mbox{for all } v \in \hat{V}
\end{displaymath}
is a discrete linear system for the approximate solution $U \approx u$.

With $V = \mathrm{span} \{\phi_i\}_{i=1}^M$
and $\hat{V} = \mathrm{span} \{\hat{\phi}_i\}_{i=1}^M$,
we obtain the linear system
\begin{displaymath}
  A x = b
\end{displaymath}
for the degrees of freedom $x = (x_i)$ of $U = \sum_{i=1}^M x_i \phi_i$,
where
\begin{displaymath}
  \begin{split}
    A_{ij} &= a(\hat{\phi}_i, \phi_j) \\
    b_i &= L(\hat{\phi}_i)
  \end{split}
\end{displaymath}
  
\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Computing the linear system: assembly}


\begin{tabular}{ll}
  \begin{minipage}{4cm}
    \includegraphics[width=4cm]{eps/mesh.eps}
  \end{minipage}
  &
  \begin{minipage}{7cm}
    Noting that $a(v, u) = \sum_{K\in\mathcal{T}} a_K(v, u)$, the
    matrix $A$ can be assembled by \\
    \begin{verse}
      $A = 0$ \\
      \texttt{for all elements} $K \in \mathcal{T}$ \\
      \quad\quad $A$ \texttt{+=} $A^K$
    \end{verse}
  \end{minipage}
\end{tabular}

\vspace{0.5cm}

The \emph{element matrix} $A^K$ is defined by
\begin{displaymath}
  A^K_{ij} = a_K(\hat{\phi}_i, \phi_j)
\end{displaymath}
for all local basis functions $\hat{\phi}_i$ and $\phi_j$ on $K$

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Multi-linear forms}

Consider a multi-linear form
\begin{displaymath}
  a : V_1 \times V_2 \times \cdots \times V_r \rightarrow \real
\end{displaymath}
with $V_1, V_2, \ldots, V_r$ function spaces on the domain $\Omega$

\begin{itemize}
\item
  Typically, $r = 1$ (linear form) or $r = 2$ (bilinear form)
\item
  Assume $V_1 = V_2 = \cdots = V_r = V$ for ease of notation
\end{itemize}

Want to compute the rank $r$ \emph{element tensor} $A^K$ defined by
\begin{displaymath}
  A^K_i = a_K(\phi_{i_1}, \phi_{i_2}, \ldots, \phi_{i_r})
\end{displaymath}
with $\{\phi_i\}_{i=1}^n$ the local basis on $K$ and
multi-index $i = (i_1,i_2,\ldots,i_r)$

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Tensor representation}

In general, the element tensor $A^K$ can be represented as the product
of a \emph{reference tensor} $A^0$ and a \emph{geometry tensor} $G_K$:
\begin{displaymath}
  A^K_{i} = A^0_{i\alpha} G_K^{\alpha}
\end{displaymath}

\begin{itemize}
\item
  $A^0$: a tensor of rank $|i| + |\alpha| = r + |\alpha|$
\item
  $G_K$: a tensor of rank $|\alpha|$
\end{itemize}

Basic idea:
\begin{itemize}
\item
  Precompute $A^0$ at compile-time
\item
  Generate optimal code for run-time evaluation of $G_K$ and the
  product $A^0_{i\alpha} G_K^{\alpha}$

\end{itemize}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Example: Poisson}

\begin{itemize}
\item
  Form:
  \begin{displaymath}
    a(v, u) = \int_{\Omega} \nabla v(x) \cdot \nabla u(x) \, dx
  \end{displaymath}
\item
  Evaluation:
  \begin{displaymath}
    \begin{split}
      A^K_i &= \int_{K} \nabla \phi_{i_1}(x) \cdot \nabla \phi_{i_2}(x) \, dx \\
      &= \det F_K' 
      \frac{\partial X_{\alpha_1}}{\partial x_{\beta}} \frac{\partial X_{\alpha_2}}{\partial x_{\beta}}
      \int_{K_0}
      \frac{\partial \Phi_{i_1}}{\partial X_{\alpha_1}}
      \frac{\partial \Phi_{i_2}}{\partial X_{\alpha_2}} \, dX
      = A^0_{i\alpha} G_K^{\alpha}
    \end{split}
  \end{displaymath}
  with $A^0_{i\alpha} = \int_{K_0} \frac{\partial
    \Phi_{i_1}}{\partial X_{\alpha_1}} \frac{\partial
    \Phi_{i_2}}{\partial X_{\alpha_2}} \, dX$
  and $G_K^{\alpha} = \det F_K'
  \frac{\partial X_{\alpha_1}}{\partial x_{\beta}} \frac{\partial
    X_{\alpha_2}}{\partial x_{\beta}}$
\end{itemize}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Basic usage: compiling a form}

\begin{enumerate}
\item
  Implement the form using your favorite text editor (emacs):

  \null\quad
  \includegraphics[height=3cm]{eps/emacs-form.eps}

\item
  Compile the form using \ffc{}:
  
  \begin{verbatim}
    >> ffc poisson.form
  \end{verbatim}
  This will generate C++ code (\texttt{Poisson.h}) for \dolfin{}
\end{enumerate}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Example: Classical Elasticity}

FFC representation ({\tt Elasticity.form}):

\small\begin{verbatim}
# The bilinear form for classical linear elasticity
# Compile this form with FFC: ffc Elasticity.form.

element = FiniteElement("Lagrange", "tetrahedron", 1)

c1 = Constant()	# Lame coefficient
c2 = Constant()	# Lame coefficient
f = Function(element) # Source

v = BasisFunction(element)
u = BasisFunction(element)

a = (2.0 * c1 * u[i].dx(i) * v[j].dx(j) +
          c2 * (u[i].dx(j) + u[j].dx(i)) * (v[i].dx(j) + v[j].dx(i))) * dx
L = f[i] * v[i] * dx

\end{verbatim}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Example: Classical Elasticity}

FFC output ({\tt Elasticity.h}):

\small\begin{verbatim}
  BilinearForm(const real& c0, const real& c1) : ...

  bool interior(real* block) const
  {
    // Compute geometry tensors
    real G0_0_0_0_0 = det*c0*g00*g00;
    real G0_0_0_0_1 = det*c0*g00*g10;
    ...

    // Compute element tensor
    block[0] =
    3.333333333333329e-01*G0_0_0_0_0 + 3.333333333333329e-01*G0_0_0_0_1 +
    3.333333333333329e-01*G0_0_0_0_2 + 3.333333333333329e-01*G0_0_0_1_0 +
    3.333333333333329e-01*G0_0_0_1_1 + 3.333333333333329e-01*G0_0_0_1_2 +
    3.333333333333329e-01*G0_0_0_2_0 + 3.333333333333329e-01*G0_0_0_2_1 +
    3.333333333333329e-01*G0_0_0_2_2 + 1.666666666666664e-01*G1_0_0 +
    1.666666666666664e-01*G1_0_1 + 1.666666666666664e-01*G1_0_2 +
    1.666666666666664e-01*G1_1_0 + 1.666666666666664e-01*G1_1_1 +
    ...
\end{verbatim}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Impressive speedups}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/ffc-benchmark-2d.eps}
\end{center}  

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Results}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/ffc-benchmark-mass.eps}
\end{center}
  
\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Results}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/ffc-benchmark-poisson.eps}
\end{center}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Results}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/ffc-benchmark-navierstokes.eps}
\end{center}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Results}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/ffc-benchmark-elasticity.eps}
\end{center}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Motivation for elasto-plastic model}

State of the art computer games use rigid body motion with joints
(Half Life 2).

\bigskip

Motion pictures primarily use animation by hand, some cases of
mass-spring simulation (hair, cloth).

\bigskip

Why don't these applications use more advanced/general models?

\bigskip

Traditional elasticity models are difficult to understand $\Rightarrow$
difficult to apply, use effectively.

\bigskip

Attempt to find a simple model, attempt to automate discretization
of model.

\end{slide}

\begin{slide}{Previous work - mass-spring model}

\begin{center}
\href{run:movies/susp-physical.mpg}{\includegraphics[height=30mm]{movies/susp-physical.eps}}
\end{center}

\begin{center}
\href{run:movies/susp-geometric.mpg}{\includegraphics[height=30mm]{movies/susp-geometric.eps}}
\end{center}

\bigskip

Can we find an analogous PDE-model?

\end{slide}

\begin{slide}{Simple derivation of model}

Classical linear elasticity:

\begin{equation*}
\label{classicalelast}
\begin{split}
u &= x - X,\\
\dot{u}-v&=0\quad\mbox{in } \Omega^0,\\
\dot{v} - \nabla \cdot \sigma& =f \quad\mbox{in } \Omega^0,\\
\sigma &= E\epsilon (u) = E(\nabla u^\top +\nabla u)\\
E\epsilon &= \lambda\sum_k\epsilon_{kk} I + 2\mu \epsilon,\\
v(0,\cdot ) &=v^0,\quad u(0,\cdot )=u^0\quad\mbox{in } \Omega^0.
\end{split}
\end{equation*}

\large

Only works for small displacements. Computations carried out on fixed
geometry $\Omega^0$. Why not use the deformed geometry $\Omega(t)$?

\end{slide}

\begin{slide}{The elastic model}

Formulate the model in the deformed geometry $\Omega(t)$ (updated
Lagrange):

\begin{equation*}
\label{classicalelast}
\begin{split}
\dot{u} - v &= 0 \quad\mbox{in } \Omega(t),\\
\dot{v} - \nabla \cdot \sigma &= f \quad\mbox{in } \Omega(t),\\
\dot{\sigma} &= E\epsilon (v) = E(\nabla v^\top +\nabla v)\\
v(0,\cdot ) &=v^0,\quad u(0,\cdot )=u^0\quad\mbox{in } \Omega^0.
\end{split}
\end{equation*}

The model is a piecewise linear elastic model. Given some geometry
$\Omega_i$ we compute using the linear model (small displacements) for
a small time step/iteration and produce the geometry
$\Omega_{i+1}$. The process is then repeated.

\end{slide}

\begin{slide}{Examples}

\begin{center}
\href{run:movies/updelast-bar03-model1.mpg}{\includegraphics[height=20mm]{movies/updelast-bar03-model1.eps}}\\
\normalsize{Elastic bar (Updated Lagrange)}
\end{center}

\begin{center}
\href{run:movies/massspring-bar03.mpg}{\includegraphics[height=20mm]{movies/massspring-bar03.eps}}\\
\normalsize{Elastic bar (Mass-spring)}
\end{center}

\begin{center}
\href{run:movies/linearelasticity-bar03.mpg}{\includegraphics[height=20mm]{movies/linearelasticity-bar03.eps}}\\
\normalsize{Elastic bar (Classical elasticity)}
\end{center}

\end{slide}

\begin{slide}{Viscosity}

\begin{equation*}
\begin{split}
\label{viscosity}
\dot{v} - \nabla \cdot \sigma - \nu \nabla \cdot \epsilon(v) &= f \quad\mbox{in } \Omega(t)
\end{split}
\end{equation*}

We add a simple viscous term to model viscosity in materials.

\end{slide}

\begin{slide}{Plasticity}

\begin{equation*}
\label{elastplast}
\begin{split}
\dot{\sigma} &= E(\epsilon (v) - \frac{1}{\nu_p}(\sigma -\pi\sigma) )\quad\mbox{in } \Omega (t),\\
\pi\sigma &= \frac{\sigma}{\Vert \sigma \Vert}, \Vert \sigma \Vert > Y_s\\
\pi\sigma &= \sigma, \Vert \sigma \Vert \leq Y_s
\end{split}
\end{equation*}

Visco-plastic model. $\pi \sigma$ is the projection on to the set of
admissible stresses. $Y_s$ is the yield stress of the material.

\end{slide}

\begin{slide}{Examples (Plasticity)}

\begin{center}
\href{run:movies/beam-plast01.mpg}{\includegraphics[height=20mm]{movies/beam-plast01.eps}}\\
\normalsize{Plastic bar}
\end{center}

\end{slide}

\begin{slide}{Implementation in FFC}

FFC representation ({\tt ElasticityUpdated.form}):

\small\begin{verbatim}
# Form for updated elasticity (velocity)

element1 = FiniteElement("Discontinuous vector Lagrange", "tetrahedron", 0)
element2 = FiniteElement("Vector Lagrange", "tetrahedron", 1)

nu = Constant()	# viscosity coefficient

w = BasisFunction(element2)
f = Function(element2)
sigma0 = Function(element1)
epsilon0 = Function(element1)

L = (f[i] * v[i] -
	(sigma0[i] * w[0].dx(i) +
	sigma1[i] * w[1].dx(i) +
	sigma2[i] * w[2].dx(i)) -
	nu * (
	epsilon0[i] * w[0].dx(i) +
	epsilon1[i] * w[1].dx(i) +
	epsilon2[i] * w[2].dx(i))) * dx

\end{verbatim}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Implementation in FFC}

FFC representation ({\tt ElasticityUpdatedSigma0.form}):

\small\begin{verbatim}
# Form for updated elasticity (stress component 0)

element1 = FiniteElement("Vector Lagrange", "tetrahedron", 1)
element2 = FiniteElement("Discontinuous vector Lagrange", "tetrahedron", 0)

c1 = Constant()	# Lame coefficient
c2 = Constant()	# Lame coefficient
nuplast = Constant()	# Plastic viscosity

q = BasisFunction(element2)
v = Function(element1)
sigma0 = Function(element2)
sigmanorm = Function(element2)	# Norm of sigma (stress)

Lplast = ((c1 * (sigma0[0] + sigma1[1] + sigma2[2]) * q[0]) + 
          (c2 * sigma0[i] * q[i]))

Lelast = ((2 * c1 * v[i].dx(i) * q[0]) + 
          (c2 * (v[i].dx(0) + v[0].dx(i))) * q[i])

L = (Lelast - nuplast * (1 - sigmanorm[0]) * Lplast) * dx
\end{verbatim}

\end{slide}
%------------------------------------------------------------------------------



\begin{slide}{General examples}

%\begin{center}
%\href{run:movies/cow01.mpg}{\includegraphics[height=20mm]{movies/cow01.eps}}\\
%\normalsize{Elastic cow}
%\end{center}

\begin{center}
\href{run:movies/cow05.mpg}{\includegraphics[height=20mm]{movies/cow05.eps}}\\
\normalsize{Visco-elastic cow}
\end{center}

\begin{center}
\href{run:movies/cow06.mpg}{\includegraphics[height=20mm]{movies/cow06.eps}}\\
\normalsize{Plastic cow}
\end{center}

\begin{center}
\href{run:movies/cow_realtime04.mpg}{\includegraphics[height=20mm]{movies/cow_realtime04.eps}}\\
\normalsize{Real time simulation}
\end{center}

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Updated elasticity vs. mass-spring}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/bench.eps}
\end{center}  

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Time / dof}

\vspace{-0.5cm}
\begin{center}
  \includegraphics[width=10cm]{eps/bench-normalized.eps}
\end{center}  

\end{slide}
%------------------------------------------------------------------------------
\begin{slide}{Profiling}

\begin{itemize}
\item
Spends 90\% assembling, only 10\% actually evaluating form, could likely be optimized further
\end{itemize}

\small\begin{verbatim}
 %time    calls      name    

Flat:

 15.86    226382058  dolfin::Function::interpolate()
  8.04    41162058   dolfin::AffineMap::updateTetrahedron()
  3.23    10290000   dolfin::ElasticityUpdated::LinearForm::eval()
  3.23    740882058  dolfin::Cell::id() const
  2.57    617498784  dolfin::GenericCell::nodeID() const
  2.46    10290000   dolfin::ElasticityUpdatedSigma2::LinearForm::eval()
  2.30    10290000   dolfin::ElasticityUpdatedSigma0::LinearForm::eval()
  2.15    10290000   dolfin::ElasticityUpdatedSigma1::LinearForm::eval()

Graph:

 89.7     20000      dolfin::FEM::assemble()
 49.8     41162058   dolfin::Form::updateCoefficients()
\end{verbatim}

\end{slide}
%------------------------------------------------------------------------------

\begin{slide}{Future work}

FFC:

\begin{itemize}

\item
Independent comparisons for FFC - benchmark against other PDE packages
(also finite difference packages).

\end{itemize}

\begin{itemize}

\item
Extend the elastic model: contact, friction (mass-spring model already
does this).

\item
Space adaptivity

\item
Apply model in real applications (games for instance).

\item
Interface to fluid mechanics (Navier-Stokes).

\end{itemize}

\end{slide}



\end{document}


