Example codes and Tutorials

This document provides a complete list of the example codes that are distributed with the `oomph-lib` library. For each code we give a brief description of the problem solved and provide a link to the detailed documentation. The codes are listed in order of increasing complexity. The bullet-point list in the right column lists the new `oomph-lib` features that are introduced in the example. You may either work through the examples one-by-one, treating the example codes and their documentation as chapters in a self-study course, or use the list of topics in the right column as a quick reference to example codes that provide an introduction to a specific feature.

You may also wish to consult the following documents:

 Work in progress We're still working on the detailed documentation for many of the demo problems listed below. The fully-documented demo problems are accessible via the links. If you are particularly interested in a specific problem for which the detailed documentation is incomplete, let us know – we might be able to give it a slightly higher priority. We are happy to let you have driver codes before the documentation is complete. Such codes usually need a bit of tidying to make them acceptable for "general release", but they are fully functional. In fact, they are run on a regular basis as part of ` oomph-lib's ` self-test routines (activated by typing ` make check ` in the top-level directory).

# Overview:

• Eigenproblems:

How to use example code list

 Problem solved by example code Short description of problem. `oomph-lib` features/conventions illustrated by the example code.

## Poisson problems

The 1D Poisson equation

We (re-)solve the problem considered in the Quick Guide, this time using existing `oomph-lib` objects: The `OneDMesh` and finite elements from the `QPoisson` family.

• General post-processing routines.
• General conventions:
• Use of public typedefs to specify function pointers.
• Element constructors should not have any arguments.

The 2D Poisson equation.

We solve a 2D Poisson problem with Dirichlet boundary conditions and compare the results against an exact solution.

• How to apply Dirichlet boundary conditions in complex meshes.
• How to use the `DocInfo` object to label output files.
• How does one change the linear solver in the Newton method?
• General conventions:
• `oomph-lib` mesh objects are templated by the element type. How does one pre-compile mesh objects?

The 2D Poisson equation with flux boundary conditions (I)

Another 2D Poisson problem – this time with Dirichlet and Neumann boundary conditions.

• How to apply non-Dirichlet (flux) boundary conditions with `FaceElements`.
• General conventions:
• What are broken virtual functions and why/when/where are they used?

The 2D Poisson equation with flux boundary conditions (II)

An alternative solution for the previous problem, using multiple meshes.

• How to use multiple meshes.
• General conventions:
• In problems with multiple sub-meshes, `Nodes` retain the boundary numbers of the mesh in which they were created.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

Adaptive solution of Poisson's equation in a fish-shaped domain

We solve a 2D Poisson equation in a nontrivial, fish-shaped domain and demonstrate `oomph-lib's` fully-automatic mesh adaptation routines.

• How to perform automatic mesh adaptation.
• `oomph-lib's` "black-box" adaptive Newton solver.
• `The` functions `Problem::actions_before_adapt()` and `Problem::actions_after_adapt()`.

The 2D Poisson equation revisited – how to create a refineable mesh

We revisit an earlier example and demonstrate how easy it is to "upgrade" an existing mesh to a mesh that can be used with `oomph-lib's` automatic mesh adaptation routines.

• "Upgrading" meshes to make them refineable.
• General conventions:
• Hanging nodes – the functions `Node::position(...)` and `Node::value(...)`.

Poisson's equation in a fish-shaped domain revisited – mesh adaptation in deformable domains with curvilinear and/or moving boundaries.

We revisit an earlier example and demonstrate how to create refineable meshes for problems with curvilinear and/or moving domain boundaries.

• How to create refineable meshes for problems with curvilinear and/or moving domain boundaries.
• General conventions:
• The `GeomObject`, `Domain` and `MacroElement` objects.
• The `Mesh::node_update()` function.
• It is good practice to store boundary coordinates for (`Boundary`) `Nodes` that are located on curvilinear domain boundaries.

Adaptive solution of Poisson's equation with flux boundary conditions.

We revisit an earlier example and demonstrate how to apply flux boundary conditions in problems with spatial adaptivity.

• How to apply flux boundary conditions in problems with spatial adaptivity.
• General conventions:
• The `Mesh::flush_element_and_node_storage()` function: "Emptying" a mesh without deleting its constituent nodes and elements (they might be shared with other meshes!).
• Note: There is a separate tutorial that discusses the parallelisation of this code.

Adaptive solution of a 3D Poisson equations in a spherical domain

We demonstrate `oomph-lib's` octree-based 3D mesh adaptation routines.

• Setting up and solving 3D problems isn't any harder than doing it in 2D.
• General conventions:
• The namespace `CommandLineArgs` provides storage for the command line arguments to make them accessible throughout the code.
• Plotting mesh boundaries.

We solve a 2D advection-diffusion equation and illustrate the characteristic features of solutions at large Peclet number.

• How to specify the "wind" and the Peclet number for the advection diffusion equation.
• How to document the progress of `oomph-lib's` "black box" adaptive Newton solver.

2D advection diffusion equation with Neumann (flux) boundary conditions.

We solve a 2D advection-diffusion equation with flux boundary conditions.

• How to specify Neumann (flux) boundary conditions for the advection diffusion equation.

The 2D advection diffusion equation revisited: Petrov-Galerkin methods and SUPG stabilisation.

We demonstrate how to implement a stabilised Petrov-Galerkin discretisation of the advection diffusion equation.

• Petrov-Galerkin discretisation of the advection-diffusion equation.
• General conventions:
• The role of shape, basis and test functions.
• The element building blocks: Geometric elements, equation classes and specific elements.
• Note: the driver code is unannotated.

## The unsteady heat equation and an introduction to time-stepping

We solve the 2D unsteady heat equation and demonstrate `oomph-lib's` time-stepping procedures for parabolic problems.

• Solving time-dependent problems with `Problem::unsteady_newton_solve(...)`
• The functions `Problem::actions_before_implicit_timestep()` and `Problem::actions_before_implicit_timestep()`.
• The BDF timesteppers and how to set up initial conditions for parabolic problems.
• Initialising the "previous" nodal positions for elements that are based on an ALE formulation.
• General conventions:
• Providing a default `Steady` timestepper for all `Mesh` constructors.
• Steady and unsteady versions of functions – position and interpretation of the (discrete) time index.

The 2D unsteady heat equation with restarts

We demonstrate `oomph-lib's` dump/restart capabilities which allow time-dependent simulations to be restarted.

• The functions `Problem::dump(...)` and `Problem::read(...)`.
• How to customise the generic dump/restart functions.

We demonstrate `oomph-lib's` adaptive timestepping capabilities.

• How to enable temporal adaptivity.
• The function `Problem::adaptive_unsteady_newton_solve()`.
• The function `Problem::global_temporal_error_norm()`.
• How to choose the target for the global temporal error norm.

Spatially adaptive solution of the 2D unsteady heat equation with Neumann (flux) boundary conditions.

We solve a 2D unsteady heat equation in a non-trivial domain with flux boundary conditions and compare the computed results against the exact solution.

• Spatial adaptivity in time-dependent problems.
• Choosing the maximum number of spatial adaptations per timestep.
• Using `Problem::set_initial_condition()` to assign initial conditions ensures that the initial conditions are re-assigned when mesh adaptations are performed while the first timestep is computed.
• The functions `Problem::dump(...)` and `Problem::read(...)` can handle adaptive meshes.

Spatially adaptive solution of the 2D unsteady heat equation in a moving domain with Neumann (flux) boundary conditions.

We demonstrate the spatially adaptive solution of a 2D unsteady heat equation in a nontrivial moving domain.

• The ALE form of the unsteady heat equation and its implementation in `oomph-lib's` unsteady heat elements.
• The role of the positional `TimeStepper` and the importance of assigning history values for the nodal positions.
• General conventions:
• The function `Mesh::node_update()` automatically updates the nodal positions in response to the deformation/motion of time-dependent `GeomObjects` that define the `Domain` and `Mesh` boundaries.

Spatially and temporally adaptive solution of the 2D unsteady heat equation in a moving domain with flux boundary conditions.

We demonstrate the use of combined spatial and temporal adaptivity for the solution of a 2D unsteady heat equation in a nontrivial moving domain.

## The linear wave equation

The 2D linear wave equation.

We solve a 2D wave equation and demonstrate `oomph-lib's` time-stepping procedures for hyperbolic problems.

• Timestepping for hyperbolic problems: The Newmark scheme.
• How to set up initial conditions for hyperbolic problems.
• Default settings for the linear wave equation elements.
• How to apply Neumann (flux) boundary conditions for the linear wave equation.

## The Helmholtz equation

The Helmholtz equation.

We solve a 2D Helmholtz problem, simulating scattering of a planar wave from a circular cylinder.

• The Helmholtz equation and its discretisation.
• The Sommerfeld radiation condition and its approximation by approximate/absorbing boundary conditions and Dirichlet-to-Neumann mappings.

Solving the Helmholtz equation on an unstructured mesh.

We solve a 2D Helmholtz problem, simulating scattering of a planar wave from a circular cylinder – this time using an unstructured mesh.

• How to solve the Helmholtz equation on an unstructured mesh.

## The azimuthally Fourier-decomposed 3D Helmholtz equation

The azimuthally Fourier-decomposed 3D Helmholtz equation.

We solve the 3D Helmholtz equation in cylindrical polar coordinates, using a Fourier-decomposition in the azimuthal direction.

• The Helmholtz equation and its azimuthal Fourier decomposition.
• Dirichlet to Neumann mapping.
• Validation with an exact solution formed by a superposition of outgoing waves from a sphere.

The spatially adaptive solution of the azimuthally Fourier-decomposed 3D Helmholtz equation on unstructured meshes.

We re-visit the 3D Helmholtz equation in cylindrical polar coordinates, using a Fourier-decomposition in the azimuthal direction – this time using spatial adaptivity and an unstructured mesh

• Spatial adaptivity on unstructured meshes for the azimuthally Fourier-decomposed 3D Helmholtz equation.

## The Helmholtz equation and perfectly matched layers

The Helmholtz equation and perfectly matched layers (PMLs). We demonstrate the imposition of the Sommerfeld radiation condition by perfectly matched layers (PMLs) using the example of a radiating cylinder.
• The Helmholtz equation.
• The Sommerfeld radiation condition and its approximation by perfectly matched layers (PMLs).

## The azimuthally Fourier-decomposed 3D Helmholtz equation and perfectly matched layers (PMLs)

The azimuthally Fourier-decomposed 3D Helmholtz equation and perfectly matched layers (PMLs).

We consider the azimuthally Fourier-decomposed 3D Helmholtz equation and demonstrate the imposition of the Sommerfeld radiation condition by perfectly matched layers (PMLs).

• The azimuthally Fourier-decomposed 3D Helmholtz equation.
• The Sommerfeld radiation condition and its approximation by perfectly matched layers (PMLs).

## The Young Laplace equation

The solution of the Young-Laplace equation.

We solve the Young Laplace equation that governs the shape of static air-liquid interfaces.

• Theory and implementation.
• The use of spines for the representation of complicated air-liquid interfaces.
• Natural boundary conditions along free contact lines.
• How to use displacement control to compute (past) limit points in the load-displacement characteristics.

Contact-angle boundary conditions for the Young-Laplace equation

We demonstrate how to apply contact angle-boundary conditions for the Young-Laplace equation.

• Theory and implementation of contact angle-boundary conditions.
• How to generate initial guesses for the solution
• Limitations of the current approach and suggestions for improvement
• An inherent difficulty in problems with zero contact angles.

## The Navier-Stokes equations

The 2D Navier-Stokes equations: Driven cavity flow

Probably the most-solved problem in computational fluid dynamics: Steady driven cavity flow. We illustrate the problem's discretisation with Taylor-Hood and Crouzeix-Raviart elements.

• Discretising the steady Navier-Stokes equations: The governing equations and their implementation in the stress-divergence and simplified forms.
• Non-dimensional parameters and their default values.
• The pressure representation in Taylor-Hood and Crouzeix-Raviart elements.
• Pinning a pressure value in problems with Dirichlet boundary conditions for the velocity on all boundaries.

The 2D Navier-Stokes equations: Adaptive solution of the 2D driven cavity problem

We employ `oomph-lib's` mesh adaptation routines to refine the mesh in the neighbourhood of the pressure singularities.

• Treatment of pressure degrees of freedom in Navier-Stokes simulations with adaptive mesh refinement – pinning "redundant" pressure degrees of freedom.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

The 2D Navier-Stokes equations: Driven cavity flow in a quarter-circle domain with mesh adaptation

We re-solve the driven-cavity problem in a different domain, demonstrate how to apply body forces and show how to switch between the stress-divergence and simplified forms of the Navier-Stokes equations.

• Adapting the driven cavity problem to different domains.
• How to apply body forces in the Navier-Stokes equations.
• How to switch between the stress-divergence and the simplified form of the incompressible Navier-Stokes equations.

Adaptive simulation of 3D finite Reynolds number entry flow into a circular pipe

We solve the classical problem of entry flow into a 3D tube.

• Adaptivity for 3D Navier-Stokes problems
• How to determine the numbering scheme for mesh boundaries.
• How to adjust parameters that control the behaviour of `oomph-lib's` Newton solver.
• The natural (traction-free) boundary conditions for the Navier-Stokes equations.

A variant of Rayleigh's oscillating plate problem: The unsteady 2D Navier-Stokes equations with periodic boundary conditions

We solve a variant of the classical Rayleigh plate problem to demonstrate the use of periodic boundary conditions and time-stepping for the Navier-Stokes equations.

• Timestepping for the Navier-Stokes equations.
• How to apply periodic boundary conditions.
• General conventions:
• Periodic boundary conditions should be applied in the `Mesh` constructor.

Another variant of Rayleigh's oscillating plate problem: The unsteady 2D Navier-Stokes equations with periodic boundary conditions, driven by an applied traction.

We demonstrate how to apply traction boundary conditions for the Navier-Stokes equations.

• How to apply traction boundary conditions for the Navier-Stokes equations.

2D finite-Reynolds-number-flow driven by an oscillating ellipse

We study the 2D finite-Reynolds number flow contained inside an oscillating elliptical ring and compare the computed results against an exact solution (an unsteady stagnation point flow).

• Solving the Navier-Stokes equations in a moving domain.
• How to apply no-slip boundary conditions on moving walls, using the function `FSI_functions::apply_no_slip_on_moving_wall(...)`

 2D finite-Reynolds-number-flow in a 2D channel with a moving wall This is a "warm-up" problem for the classical fluid-structure interaction problem of flow in a 2D collapsible channel. Here we compute the flow through a 2D channel in which part of one wall is replaced by a moving "membrane" whose motion is prescribed. The adaptive solution of the Navier-Stokes equations in a moving domain with traction boundary conditions. 2D finite-Reynolds-number-flow in a 2D channel with a moving wall revisited: Algebraic Node updates. We re-visit the problem studied in the previous example and demonstrate an alternative node-update procedure, based on `oomph-lib's` `AlgebraicNode`, `AlgebraicElement` and `AlgebraicMesh` classes. Algebraic node updates will turn out to be essential for the efficient implementation of fluid-structure interaction problems. How to customise the node-update, using `oomph-lib's` `AlgebraicNode`, `AlgebraicElement` and `AlgebraicMesh` classes. Existing `AlgebraicMeshes` are easy to use: Simply "upgrade" the required element (of type `ELEMENT`, say) in the templated wrapper class `AlgebraicElement`. Steady 2D finite-Reynolds-number-flow in a 2D channel of non-uniform width: An Introduction to Spine meshes We consider a variation of the problem studied in the previous example and demonstrate an alternative node-update procedure, based on `oomph-lib's` `SpineNode`, `SpineElement` and `SpineMesh` classes. Spine node updates are an alternative to algebraic nodes updates for the efficient implementation of fluid problems in deforming domains. Introduction to the method of spines. How to create a custom `SpineMesh`. 2D finite-Reynolds-number-flow in a 2D channel that is partially obstructed by an oscillating leaflet This is a "warm-up" problem for the corresponding fluid-structure interaction problem where the leaflet deforms in response to the fluid traction. Here we consider the case where the motion of the leaflet is prescribed. Another example illustrating the use of algebraic and `MacroElement/Domain-based` node update techniques. Flow past a cylinder with a waving flag This is a "warm-up" problem for Turek & Hron's FSI benchmark problem where the flag deforms in response to the fluid traction. Here we consider the case where the motion of the flag is prescribed. Another example illustrating the use of algebraic and `MacroElement/Domain-based` node update techniques.

Unstructured meshes for fluids problems

This is a "warm-up" problem for another tutorial in which we demonstrate the use of unstructured meshes for FSI problems.

• How to use xfig/triangle-generated, unstructured meshes for flow problems.

Unstructured meshes for 3D fluids problems

This is a "warm-up" problem for another tutorial in which we demonstrate the use of unstructured 3D meshes for FSI problems.

• How to use tetgen-generated, unstructured meshes for 3D flow problems.
• Avoiding "locking" with the `split_corner_elements` flag.

Steady finite-Reynolds-number flow through an iliac bifurcation

We show how to simulate physiological flow problems, using the Vascular Modeling Toolkit (VMTK). This is a "warm-up" problem for another tutorial in which we consider the corresponding FSI problems in which the vessel wall is elastic.

• How to use `ImposeParallelOutflowElements` to enforce parallel in- and outflow from cross-sections that are not aligned with any coordinate planes.

Motion of elliptical particles in shear flow: unstructured adaptivity

We solve the classical problem of shear flow past a immersed ellipse

• An example of using inline mesh generation for adaptivity in unstructured meshes
• `ImmersedRigidBodyElements` to describe the interaction of fluids with rigid bodies

Adaptive simulation of flow at finite Reynolds number in a curved circular pipe

We solve the classical problem of flow into a 3D curved tube.

• Another example of adaptivity for 3D Navier-Stokes problems
• Note: the documentation for this problem is incomplete.

## The axisymmetric Navier-Stokes equations

Spin-up of a viscous fluid – the spatially adaptive solution of the unsteady axisymmetric Navier-Stokes equations.

A classical fluid mechanics problem: Spin-up of a viscous fluid. A key feature of the flow is the development of thin Ekman (boundary) layers during the early stages of the spin-up. We demonstrate how the use of spatial adaptivity helps to resolve these layers. At large times, the flow field approaches a rigid-body rotation – this poses a subtle problem for the spatial adaptivity as its default behaviour would cause strong spatially uniform refinement.

• The axisymmetric Navier-Stokes equations
• How to prescribe a constant reference value for the normalisation of the error in spatially-adaptive computations in which the solution approaches a "trivial" solution.

## The free-surface Navier-Stokes equations

Interfaces, Free Surfaces and Surface Transport: Theory and Implementation. In this document, we introduce the basic theory of moving surfaces, surface calculus and surface transport equations. In addition, we describe how `oomph-lib's` free-surface and surface-transport capabilities are implemented.
• Theory
• Geometry of Surfaces
• Differential Operators On A Surface
• Free Surface and Interface Boundary Conditions
• Surface Transport Equations
• Implementation
• The FluidInterfaceElement class
• Spine and Elastic formulations of free surface elements

Free-surface relaxation oscillations of a viscous fluid layer.

We study the oscillations of a perturbed fluid layer and compare the results to the analytic dispersion relation based on linearised disturbances.

• Boundary conditions at a free surface
• How to solve free-boundary problems using a pseudo-solid node update approach.

Relaxation oscillations of an interface between two viscous fluids.

We study the oscillations of a two-layer fluid system and compare the results to the analytic dispersion relation based on linearised disturbances.

• Boundary conditions at an interface between two immiscible fluids.
• Adaptivity in free-surface/interfacial problems with a pseudo-solid node update approach.

A static free surface bounding a layer of viscous fluid.

A hydrostatics problem: Compute the static free surface that bounds a layer of viscous fluid – harder than you might think!

• Imposing a volume constraint in steady free-surface problems.
• Imposing static contact angle constraints when a free-surface meets a solid boundary.
• Hijacking (overwriting) data from within elements.

A static interface between two viscous fluids.

A hydrostatics problem: Compute the static interface between two viscous fluids – harder than you might think!

• Adapting an existing mesh to include an interface.
• Imposing a static contact angle when an interface meets a solid boundary.

Flow of a fluid film down an inclined plane

A classical fluid mechanics problem: We study the flow of a film of fluid down an inclined plane and compare the results to the exact solution of Nusselt. The stability is assessed by simulating the time-evolution of a perturbation to the free surface.

• Comparison between spine-based and pseudo-solid node update strategies for free surface problems.
• Applying time-dependent perturbations to steady solutions.
• Open flow boundary conditions.

The Bretherton problem: An air finger propagates into a 2D fluid-filled channel.

A classical fluid mechanics problem: We study the propagation of an inviscid (air) finger into a 2D fluid-filled channel and compare our results against those from Bretherton's theoretical analysis.

• Another example for the solution of a free-surface problem using the Method of Spines.
• Use of external `Data` to implement non-local interactions between elements.

A finite bubble propagates in a 2D fluid-filled channel.

Uses a pseudo-elastic remesh strategy and unstructured spatial adaptivity in a non-trivial free surface problem.

• Mesh adaptation for closed free boundaries – what happens "under the hood" and how to customise the default behaviour, specifically:
• Selecting the refinement and unrefinement tolerances on the free boundaries.
• Redistributing segments between polylines in cases when the nodes on the free surface all get convected into one region.
• Why you shouldn't use `TriangleMeshCurviLines` to describe the initial shape of (initially curvilinear) free boundaries.
• How to impose a volume constraint onto an enclosed "bubble" in a viscous fluid.

A finite droplet propagates in a 2D fluid-filled channel.

Uses a pseudo-elastic remesh strategy and unstructured spatial adaptivity in a non-trivial interfacial (two-fluid) problem.

• How to use regions in an unstructured two-fluid problem.
• How to impose and then remove a volume constraint onto an enclosed "droplet" in a viscous fluid.

## The axisymmetric free-surface Navier-Stokes equations

Relaxation oscillations of an interface between two viscous fluids in an axisymmetric domain.

We study the oscillations of a two-layer fluid system in an axisymmetric domain and compare the results to the analytic dispersion relation based on linearised disturbances.

• Free-surface/interfacial problems in an axisymmetric domain with a pseudo-solid node update approach and spatial adaptivity.

An axisymmetric static free surface bounding a layer of viscous fluid.

A hydrostatics problem: Compute the static free surface that bounds a layer of viscous fluid in an axisymmetric geometry.

• Trivial differences between two-dimensional and axisymmetric static problems.

## Nonlinear solid mechanics problems

Nonlinear solid mechanics: Theory and implementation

In this document we discuss the theoretical background and the practical implementation of `oomph-lib's` nonlinear solid mechanics capabilities.

• Theory:
• Nonlinear solid mechanics problems – Lagrangian coordinates
• The geometry
• Equilibrium and the Principle of Virtual Displacements
• Constitutive Equations for Purely Elastic Behaviour
• Non-dimensionalisation
• 2D problems: Plane strain.
• Isotropic growth.
• Specialisation to a cartesian basis and finite element discretisation
• Implementation:
• The `SolidNode` class
• The `SolidFiniteElement` class
• The `SolidMesh` class
• The `SolidTractionElement` class
• Timestepping and the generation of initial conditions for solid mechanics problems

Bending of a cantilever beam

We study a classical solid mechanics problem: the bending of a cantilever beam subject to a uniform pressure loading on its upper face and/or gravity. We compare the results for zero-gravity against the (approximate) analytical St. Venant solution for the stress field.

• How to formulate solid mechanics problems.
• How to choose a constitutive equation.
• How to apply traction boundary conditions, using `SolidTractionElements`.

Axisymmetric compression of a circular disk

We study the axisymmetric compression of a circular, elastic disk, loaded by an external traction. The results are compared against the predictions from small-displacement elasticity.

• How to upgrade an existing mesh to `SolidMesh`.
• Why it is necessary to use "undeformed MacroElements" to ensure that the numerical results converge to the correct solution under mesh refinement if the domain has curvilinear boundaries.
• How to switch between different constitutive equations
• how to incorporate isotropic growth into the model.

Compressible and incompressible behaviour

We discuss various issues related to (in)compressible material behaviour and illustrate various solution techniques in a simple test-problem: The compression of a square block of (compressible or incompressible) material by a gravitational body force. The results are compared against the predictions from small-displacement elasticity.

• Different formulations of the constitutive laws for compressible, near-incompressible and incompressible behaviour.
• How to combine the various constitutive laws with the displacement and pressure/displacement formulations of the principle of virtual displacements.
• The default setting: Incompressibility is not enforced automatically. It must be requested explicitly.

Axisymmetric oscillations of a circular disk

We study the free axisymmetric oscillations of a circular, elastic disk and compare the eigenfrequencies and modes against the predictions from small-displacement elasticity.

Deformation of a solid by a prescribed boundary motion

We study the large deformations of a 2D elastic domain, driven by the prescribed deformation of its boundary. The boundary motion is imposed by Lagrange multipliers. This technique is important for the solution of fluid-structure interaction problems in which the deformation of the fluid mesh is controlled by (pseudo-)elasticity.

• How to impose displacement boundary conditions in solid mechanics problems by Lagrange multipliers.

 Large-amplitude bending of an asymmetric 3D cantilever beam made of incompressible material. We study the deformation of an asymmetric 3D cantilever beam made of incompressible material. How to enforce incompressible behaviour. How to solve 3D solid mechanics problems with spatial adaptivity. Unstructured meshes for 2D and 3D solid mechanics problems. We demonstrate how to use unstructured meshes to solve 2D and 3D solid mechanics problems. This tutorial acts as a "warm-up" problem for the solution of unstructured FSI problems. How to solve 2D and 3D solid mechanics problems on unstructured meshes. How to identify domain boundaries in xfig-generated unstructured meshes. Unstructured meshes for 3D solid mechanics problems. We demonstrate how to use unstructured meshes to solve 3D solid mechanics problems. This is a "warm-up" problem for another tutorial in which we demonstrate the use of unstructured 3D meshes for FSI problems. How to solve 3D solid mechanics problems on unstructured meshes. Inflation of a blood vessel We show how to simulate physiological solid mechanics problems, using the Vascular Modeling Toolkit (VMTK). This is a "warm-up" problem for another tutorial in which we consider the corresponding FSI problems in which the vessel conveys (and is loaded by) a viscous fluid. How to solve physiological solid mechanics problems. Large-amplitude shock waves in a circular disk We study the propagation of shock waves in an elastic 2D circular disk. How to employ spatial adaptivity in time-dependent solid mechanics problems. Note: this driver code is currently undocumented. Solid Mechanics using unstructured meshes with adaptivity We study the deflection of a 2D rectangular solid under a lateral pressure load. How to employ spatial adaptivity in solid mechanics problems using unstructured meshes. Large shearing deformations of a hyper-elastic, incompressible block of material We solve a classical problem in large-displacement elasticity and compare against Green and Zerna's exact solution. A validation problem. Note: this driver code is currently undocumented.

## Linear elasticity

Linear Elasticity: Theory and implementation

In this document we discuss the theoretical background and the practical implementation of `oomph-lib's` linear elasticity elements and demonstrate their use in a 2D model problem.

• The equations of linear elasticity and their non-dimensionalisation.
• Implementation of the equations, based on a displacement formulation.
• The solution of a 2D model problem: The deformation of a linearly elastic strip, loaded by a spatially periodic surface traction.

Spatially-adaptive simulation of the deformation of a linearly elastic strip, loaded by a spatially periodic surface traction.

We demonstrate how to compute the deformation of a linearly elastic strip, loaded by a spatially periodic surface traction, using spatial adaptivity.

• How to apply periodic boundary conditions in spatially adaptive computations.

## Axisymmetric linear elasticity

Axisymmetric linear elasticity: Theory, implementation and a time-dependent demo problem.

In this document we discuss the theoretical background and the practical implementation of `oomph-lib's` axisymmetric linear elasticity elements and demonstrate their use in time-dependent test problem.

• The equations of axisymmetric linear elasticity and their non-dimensionalisation.
• Implementation of the equations, based on a displacement formulation.
• The solution of a 2D model problem: The time-dependent deformation of an annular region and the validation against a manufactured exact solution.

## Time-harmonic linear elasticity

The equations of time-harmonic linear elasticity: Theory and implementation

In this document we discuss the theoretical background and the practical implementation of equations describing forced, time-harmonic oscillations of elastic bodies.

• The time-harmonic equations of linear elasticity and their non-dimensionalisation.
• Implementation of the equations, based on a displacement formulation.
• The solution of test problem: The forced oscillations of an annular elastic region, computed with and without spatial adaptation.

Solving the equations of time-harmonic linear elasticity on unstructured meshes

We re-visit the solution of the equations of time-harmonic linear elasticity – this time using an unstructured mesh.

• Solving the equations of time-harmonic linear elasticity on unstructured meshes, with and without adaptation.
• How to assign different material properties to different parts of the domain.

## Generalised time-harmonic linear elasticity and perfectly matched layers (PMLs)

The generalised equations of time-harmonic linear elasticity and perfectly matched layers (PMLs).

In this document we discuss a generalisation of the equations of time-harmonic linear elasticity that allows the implementation of far field boundary condition by perfectly matched layers

• The generalised time-harmonic equations of linear elasticity and their non-dimensionalisation.
• Perfectly matched layers
• The solution of test problem: Oscillations of an infinite 2D medium forced by the prescribed oscillations of an embedded circular disk.

## Azimuthally Fourier-decomposed 3D time-harmonic linear elasticity

The azimuthally Fourier-decomposed equations of 3D time-harmonic linear elasticity: Theory and implementation

In this document we discuss the theoretical background and the practical implementation of equations describing forced, time-harmonic, non-axisymmetric oscillations of axisymmetric elastic bodies.

• The time-harmonic equations of linear elasticity and their non-dimensionalisation.
• Fourier decomposition of general three-dimensional disturbances.
• Implementation of the equations, based on a displacement formulation.
• The solution of a "manufactured" test problem.

The spatially-adaptive solution of the azimuthally Fourier-decomposed equations of 3D time-harmonic linear elasticity on unstructured meshes.

We simulate the forced, time-harmonic oscillations of a hollow cylinder loaded by a spatially-constant pressure load on its inner surface.

• The use of spatial adaptivity in the solution of the azimuthally Fourier-decomposed equations of 3D time-harmonic linear elasticity on unstructured meshes.

## Beam structures

The deformation of a pre-stressed elastic beam, loaded by a pressure load

We study the lateral deformation of a pre-stressed elastic beam, using `oomph-lib's` geometrically non-linear Kirchhoff-Love-type `HermiteBeamElement` and compare the results against an (approximate) analytical solution.

• How to specify the undeformed reference shape for the Kirchhoff-Love-type beam elements.
• How to apply boundary conditions and loads for the `HermiteBeamElement`.
• General conventions:
• How to change control parameters for the Newton solver.

Large-displacement post-buckling of a pressure-loaded, thin-walled elastic ring

We compute the post-buckling deformation of a thin-walled elastic ring, subjected to a pressure load and compare the results against results from the literature.

• How to use `oomph-lib's` `DisplacementControlElement` to apply displacement control in solid mechanics problems.
• General conventions:
• What should be stored in a `GeneralisedElement's` "external" `Data`?
• What should be stored in a `Problem's` "global" `Data`?

Large-amplitude oscillations of a thin-walled elastic ring.

We compute the free, large-amplitude oscillations of a thin-walled elastic ring and demonstrate that Newmark's method is energy conserving.

• How to use the dump/restart function for `HermiteBeamElements`.
• Demonstrate that `Newmark` timesteppers can be used with variable timesteps.
• How to retrieve solutions at previous timesteps in computations with `Newmark` timesteppers.
• Changing the default non-dimensionalisation for time.
• The non-dimensionalisation of the kinetic and potential (strain) energies of `HermiteBeamElements`.

Small-amplitude oscillations of a thin-walled elastic ring.

We compute the free, small-amplitude oscillations of a thin-walled elastic ring, demonstrate that Newmark's method is energy conserving, and compare the oscillation frequencies and mode shapes against analytical predictions.

• General conventions:
• ***
• Note: this driver code is currently undocumented.

## Shell structures

Large-displacement post-buckling of a clamped, circular cylindrical shell.

We simulate the post-buckling deformation of a pressure-loaded, clamped, thin-walled elastic shell.

• How to specify the undeformed reference configuration with `HermiteShellElement` structures.
• Using displacement control for `HermiteShellElements`.
• General conventions:
• ***
• Note: this driver code is currently undocumented.

## Large-displacement fluid-structure interaction problems

We demonstrate how to "upgrade" a `GeomObject` to a `GeneralisedElement` so that it can be used to parametrise an unknown domain boundary.

• How to use multiple inheritance to combine `GeomObjects` and `GeneralisedElements`.
• How to "upgrade" a `GeomObject` to a `GeneralisedElement` so that it can be used to parametrise an unknown domain boundary.
• What is a `GeomObject's` geometric `Data`?
• What is a `GeneralisedElement's` external and internal `Data`?

A toy interaction problem: The solution of a 2D Poisson equation coupled to the deformation of the domain boundary

We show how to use `MacroElementNodeUpdateElements` and `MacroElementNodeUpdateMeshes` to implement sparse node update operations in free-boundary problems. We demonstrate their use in a simple free-boundary problem: The solution of Poisson's equation, coupled to an equation that determines the position of the domain boundary.

• How to use `MacroElementNodeUpdateElements` and `MacroElementNodeUpdateMeshes` to implement sparse node update operations in free-boundary problems.
• Basic free-boundary problems: Making the domain boundary dependent on the solution in the domain.
• General conventions:
• `MacroElementNodeUpdateElements` and `MacroElementNodeUpdateMeshes`.

A classical fluid-structure interaction problem: Finite Reynolds number flow in a 2D channel with an elastic wall.

We demonstrate the solution of this classical fluid-structure interaction problem and demonstrate how easy it is to combine the two single-physics problems (the deformation of an elastic beam under pressure loading and the flow in a 2D channel with a moving wall) to a fully-coupled fluid-structure interaction problem.

• The `FSIFluidElements` and `FSIWallElement` base classes.
• Representing a discretised beam/shell structure as a "compound" `GeomObject:` The `MeshAsGeomObject` class.
• Using the function `FSI_functions::setup_fluid_load_info_for_solid_elements(...)` to set up the fluid-structure interaction.
• The pros (convenient!) and cons (slow!) of the `MacroElement/Domain` - based node-update procedures in fluid-structure interaction problems.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

Finite Reynolds number flow in a 2D channel with an elastic wall revisited: Sparse algebraic node updates

We revisit the problem of flow in a collapsible channel to demonstrate that the sparse algebraic node update procedures first discussed in an earlier non-FSI example lead to a much more efficient code.

• How to "sparsify" the node update with algebraic node update procedures.
• The `GeomObject::locate_zeta(...)` function and its default implementation.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

Finite Reynolds number flow in a 2D channel with an elastic wall revisited again: Spatial adaptivity in fluid-structure interaction problems.

We revisit the problem of flow in a collapsible channel yet again to demonstrate the use of spatial adaptivity in fluid-structure interaction problems.

• How to use spatial adaptivity in fluid-structure interaction problems.
• The `Steady<NSTEPS>` timestepper: How to assign positional history values for newly created nodes.
• Updating the node-update data in refineable `AlgebraicMeshes`.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

 Segregated solvers for fluid-structure-interaction problems: Revisiting the flow in a 2D collapsible channel We revisit the problem of flow in a collapsible channel once more to demonstrate the use of segregated solvers in fluid-structure interaction problems. The base SegregatableFSIProblem class How to construct and solve a segregated problem from a (standard) "monolithic" problem Preconditioning monolithic solvers for fluid-structure-interaction problems: Revisiting the flow in a 2D collapsible channel yet again We revisit the problem of flow in a collapsible channel yet again to demonstrate the use of `oomph-lib's` FSI preconditioner for the monolithic solution of fluid-structure interaction problems in which the node update in the fluid mesh is performed by algebraic node updates. How to use `oomph-lib's` `FSIPreconditioner` Flow past a flexible leaflet We study the flow in a 2D channel that is partially obstructed by an elastic leaflet. FSI problems with fully immersed beam structures (i.e. beams that are subjected to the fluid traction on both faces). Another application of `oomph-lib's` `FSIPreconditioner`. Note: There is a separate tutorial that discusses the parallelisation of this code. Turek & Hron's FSI benchmark: Flow past an elastic flag attached to a cylinder We demonstrate how to discretise and solve this benchmark problem with `oomph-lib`. FSI problems with "proper" 2D solids (rather than beam or shell structures) FSI problems with wall inertia. Another application of `oomph-lib's` `FSIPreconditioner`. Note: There is a separate tutorial that discusses the parallelisation of this code and shows to modify it to allow spatial adaptivity in the fluid and solid meshes. Using unstructured meshes for FSI problems. We demonstrate how to use xfig/triangle-generated unstructured meshes (together with a pseudo-solid node update strategy for the fluid mesh) in fluid-structure interaction problems. How to use pseudo-elasticity to update fluid meshes in FSI problems. How to use xfig/triangle-generated unstructured meshes for fluid-structure interaction problems. The automatic generation of boundary coordinates for xfig/triangle-generated, unstructured meshes. How it works and what can go wrong... Using unstructured meshes for 3D FSI problems. We demonstrate how to use tetgen-generated unstructured meshes for 3D fluid-structure interaction problems. How to use tetgen-generated unstructured meshes for 3D fluid-structure interaction problems. The automatic generation of boundary coordinates for tetgen-generated, unstructured meshes. How it works and what can go wrong...
 2D FSI on unstructured meshes with adaptivity We demonstrate how to use spatial adaptivity on unstructured meshes for 2D fluid-structure interaction problems. How to use inline mesh generation to provide spatial adaptivity for fluid-structure interaction problems Finite-Reynolds-number flow through an elastic iliac bifurcation We show how to simulate physiological fluid-structure interaction problems, using the Vascular Modeling Toolkit (VMTK). How to attach multiple `FaceElements` to the same node – distinguishing different Lagrange multipliers. How to solve physiological fluid-structure interaction problems. `oomph-lib`'s preconditioner for the solution of fluid-structure interaction problems with pseudo-solid node updates for the fluid mesh We discuss `oomph-lib`'s preconditioner for the solution of FSI problems in which the fluid node update is performed by pseudo-elasticity. How to use `oomph-lib`'s for the solution of FSI problems in which the fluid node update is performed by pseudo-elasticity. A simple fluid-structure interaction problem: Finite Reynolds number flow, driven by an oscillating ring. This is a very simple fluid-structure interaction problem: We study the finite-Reynolds number internal flow generated by an oscillating ring. The wall motion only has a single degree of freedom: The ring's average radius, which needs to be adjusted to conserve mass. The nodal positions in the fluid domain is updated by `MacroElements`. [This is a warm-up problem for the full fluid structure interaction problem discussed in the next example]. We compare the predictions for the flow field against asymptotic results. Fluid-structure interaction. General conventions: *** Note: this driver code is currently undocumented. A simple fluid-structure interaction problem re-visited: Finite Reynolds number flow, driven by an oscillating ring – this time with algebraic updates for the nodal positions. We re-visit the simple fluid-structure interaction problem considered in the earlier example.This time we perform the update of the nodal positions with `AlgebraicElements`. Fluid-structure interaction. General conventions: *** Note: this driver code is currently undocumented. A real fluid-structure interaction problem: Finite Reynolds number flow in an oscillating elastic ring. Our first "real" fluid-structure interaction problem: We study the finite-Reynolds number internal flow generated by the motion of an oscillating elastic ring and compare the results against asymptotic predictions. Fluid-structure interaction. General conventions: *** Note: this driver code is currently undocumented.

## Acoustic fluid-structure interaction problems

A time-harmonic acoustic fluid-structure interaction problem: Sound radiation from an immersed oscillating cylinder that is coated with an elastic layer.

We provide an overview of `oomph-lib's` methodology for the solution of time-harmonic acoustic fluid-structure interaction problems which are based on a coupled solution of the time-harmonic equations of linear elasticity and the Helmholtz equation.

• Theory: The formulation and non-dimensionalisation of time-harmonic acoustic fluid-structure interaction problems.
• Coupling time-harmonic equations of linear elasticity and the Helmholtz equation, using the `Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh(...)` helper function
• Validation of the methodology via a comparison against an analytical solution.

A time-harmonic acoustic fluid-structure interaction problem: Sound radiation from an immersed oscillating cylinder that is coated with an elastic layer – this time solved on an unstructured mesh.

A brief extension of the previous tutorial illustrating how to solve the problem with unstructured meshes.

• The solution of time-harmonic acoustic fluid-structure interaction problems on unstructured meshes.
• How to assign different material properties to different regions of the elastic body.

## Azimuthally Fourier-decomposed 3D acoustic fluid-structure interaction problems

An azimuthally Fourier-decomposed time-harmonic acoustic fluid-structure interaction problem: Sound radiation from an immersed oscillating sphere that is coated with an elastic layer.

We provide an overview of `oomph-lib's` methodology for the solution of azimuthally Fourier-decomposed time-harmonic acoustic fluid-structure interaction problems which are based on a coupled solution of the time-harmonic equations of linear elasticity and the Helmholtz equation.

• Theory: The formulation and non-dimensionalisation of time-harmonic acoustic fluid-structure interaction problems in cylindrical polar coordinates, using a Fourier-decomposition of all fields in the azimuthal direction.
• Coupling time-harmonic equations of linear elasticity and the Helmholtz equation, using the `Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh(...)` helper function
• Validation of the methodology via a comparison against an analytical solution.

A time-harmonic acoustic fluid-structure interaction problem: Sound radiation from an immersed oscillating sphere that is coated with an elastic layer – this time solved on an unstructured mesh with spatial adaptivity.

A brief extension of the previous tutorial illustrating how to solve the problem on adaptive, unstructured meshes.

• The spatially-adaptive solution of Fourier-decomposed time-harmonic acoustic fluid-structure interaction problems on unstructured meshes.
• How to assign different material properties to different regions of the elastic body.

## Multi-physics problems

We demonstrate how to "combine" a `CrouzeixRaviartElements` and `QAdvectionDiffusionElements` into a single `BuoyantCrouzeixRaviartElement` that solves the Navier–Stokes equations under the Boussinesq approximation coupled to an energy equation.

• How to use multiple inheritance to combine two single-physics elements.
• How to write single-physics elements that can be combined into multi-physics elements.
• How to use the `Problem::steady_newton_solve(...)` function to find steady solutions of unsteady problems.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

Refineable multi-physics problem: How to combine existing refineable single-physics elements into new refineable multi-physics elements.

We demonstrate how to "combine" a `RefineableCrouzeixRaviartElements` and `RefineableQAdvectionDiffusionElements` into a single `RefineableBuoyantCrouzeixRaviartElement` that solves the Navier–Stokes equations under the Boussinesq approximation coupled to an energy equation.

• How to use multiple inheritance to combine two refineable single-physics elements.
• How to choose the "Z2 flux" for multi-physics elements that are both derived from the `ElementWithZ2ErrorEstimator` class.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

Solving multi-field problems with multi-domain discretisations.

We demonstrate an alternative approach to the solution of multi-field problems, in which the governing PDEs are discretised in separate meshes and interact via "external elements".

• How to discretise multi-field problems with multi-domain approaches.
• The `Multi_domain_functions` namespace.
• Note: There is a separate tutorial that discusses the parallelisation of this code.

We demonstrate how to "combine" a `QUnsteadyHeatElement` and `QPVDElement` into a single `QThermalPVDElement` that solves the equations governing elastic deformations coupled to uniform thermal expansion. The geometric coupling back to the heat equation is completely hidden.

• How to use multiple inheritance to combine a single-physics element and a solid element
• Note: this driver code is currently undocumented.

We demonstrate how to add general surface transport equations to the `FluidInterfaceElements` and apply them to determine the effects of insoluble surfactant on the Rayleigh–Plateau instability.

• How to use the member function `add_additional_residual_contributions_interface()` to include additional terms in free surface problems.

## Eigenproblems

We demonstrate how to write `QHarmonicElements` that solve the eigenvalues and eigenfunctions of the one-dimensional Laplace operator.

• A brief introduction to linear stability theory.
• How to use `oomph-lib's` interfaces to eigensolvers.
• How to write elements that can be used in eigenproblems.
• How to use the `Problem::solve_eigenproblem(...)` function to find solutions of the eigenproblems.
• Post-processing of eigenvalue problems.

We demonstrate how to write `QComplexHarmonicElements` that determine the eigenvalues and eigenfunctions of the shifted one-dimensional Laplace operator as a quadratic eigenvalue problem.

• How to write eigenproblems that involve more than one field.
• How to write a quadratic eigenproblem as two linear eigenproblems.
• How to output complex eigenvalues and eigenvectors.

# Mesh generation

## Structured meshes

Structured meshes

We list `oomph-lib's` existing structured meshes and provide a quick overview of their common features.

• Reminder of `oomph-lib's` design features that facilitate the re-use of meshes.
• What structured meshes are available? .

## Unstructured meshes using input from third-party mesh generators

Unstructured meshes generated via input from third-party mesh generators

We describe `oomph-lib's` wrappers to third-party (unstructured) mesh generators.

Inline unstructured mesh generation

We describe how to generate unstructured 2D meshes from within an `oomph-lib` driver code.

• How to generated inline unstructured 2D meshes using Triangle.
• How to create unstructured meshes with curvilinear boundaries
• How to perform spatial adaptivity on unstructured meshes via complete remeshing

Inline unstructured mesh generation including internal boundaries

We describe how to generate unstructured 2D meshes that contain internal boundaries, delineating different regions of space, from within an `oomph-lib` driver code.

• How to generated more complicated inline unstructured 2D meshes using Triangle.
• How to create additional regions in space

Mesh generation with `xfig`

`oomph-lib's` one-and-only GUI: Generating unstructured triangular meshes using xfig and Triangle

• How to generated unstructured triangular meshes using xfig and Triangle.

# Linear solvers and preconditioners

## Direct and iterative linear solvers and general-purpose preconditioners

Overview

We provide an overview of `oomph-lib's` direct and iterative linear solvers and preconditioners.

• How to change the linear solver for `oomph-lib's` Newton solver.
• How to use `oomph-lib's` `IterativeLinearSolvers` and `Preconditioners`.
• How to use `oomph-lib's` wrappers to the third-party iterative linear solvers/preconditioners from the `Hypre` and `Trilinos` libraries.

## (Distributed) linear algebra and oomph-lib's block preconditioning framework

(Distributed) Linear Algebra Infrastructure We provide an overview of `oomph-lib's` (distributed) linear algebra infrastructure.
• The `OomphCommunicator`.
• The `LinearAlgebraDistribution` and the `DistributedLinearAlgebraObject` base class.
• The `CRDoubleMatrix` and the `DoubleVector`.

(Distributed) Block preconditioners We provide an overview of `oomph-lib's` (distributed) block preconditioning framework and demonstrate how to write a new block preconditioner.
• Theory
• Block preconditionable elements: Classifying the block and dof types.
• Master and subsidiary preconditioners.
• An example: A simple implementation of an FSI preconditioner.

(Distributed) General-purpose block preconditioners We provide an overview of `oomph-lib's` (distributed) general purpose block preconditioners
• Theory
• Block diagonal and block triangular preconditioners.
• Two-level parallelisation for block diagonal preconditioning.
• How to specify subsidiary preconditioners for the (approximate) solution of the linear systems involving the diagonal blocks.
• How to specify the dof types.

## Problem-specific preconditioners

`oomph-lib`'s Least-Squares-Commutator (LSC) Navier-Stokes preconditioner

We discuss `oomph-lib`'s implementation of Elman, Silvester & Wathen's Least-Squares-Commutator (LSC) Navier-Stokes preconditioner.

• How to use `oomph-lib`'s Least-Squares-Commutator (LSC) Navier-Stokes preconditioner.

`oomph-lib`'s fluid-structure interaction preconditioner

We discuss `oomph-lib`'s preconditioner for the solution of monolithically-discretised fluid-structure interaction problems with algebraic node updates.

• How to use `oomph-lib`'s FSI preconditioner for problems with algebraic node updates.

`oomph-lib`'s preconditioner for the solution of solid mechanics problems with prescribed boundary displacements

We discuss `oomph-lib`'s preconditioner for the solution of solid mechanics problems in which the displacement of a boundary is prescribed and imposed by Lagrange multipliers. This preconditioner is an important building block for the solution of FSI problems in which the fluid node update is performed by pseudo-elasticity.

• How to use `oomph-lib`'s for the solution of solid mechanics problems with prescribed boundary displacements.
• How to specify subsidiary preconditioners (inexact solvers) with any of `oomph-lib`'s existing block preconditioners.

`oomph-lib`'s preconditioner for the solution of fluid-structure interaction problems with pseudo-solid node updates for the fluid mesh

We discuss `oomph-lib`'s preconditioner for the solution of FSI problems in which the fluid node update is performed by pseudo-elasticity.

• How to use `oomph-lib`'s for the solution of FSI problems in which the fluid node update is performed by pseudo-elasticity.

# Visualisation of the results

## Paraview

Displaying results with paraview

We demonstrate how to use Angelo Simone's conversion scripts that allow the `oomph-lib` results to be displayed by paraview.

• How to display `oomph-lib's` results with paraview.

# Parallel driver codes

## Distributed problems

Example code

`oomph-lib` features/conventions illustrated by the example code

We demonstrate how to distribute a straightforward single-physics problem.

• Initialising and finalising MPI
• Distributing the problem
• Specifying a pre-determined partition of the problem
• Modifying the output filename
• Pinning values in specific elements

We demonstrate the modifications required to perform a load balancing step within the distributed adaptive driven cavity problem

• The build_mesh function
• The use of a default partition when performing a test run
• The actions before and after load balance functions

Parallel solution of the 2D Poisson problem with flux boundary conditions

We demonstrate the modifications required to distribute a problem involving `FaceElements`.

• The actions before and after distribute functions and their use to strip off and re-attach `FaceElements` that are used to enforce Neumann/flux boundary conditions.

Parallel solution of the Boussinesq convection problem

We demonstrate how to distribute a straightforward multi-physics problem where two domains interact.

• More details on the `Multi_domain_functions` helper functions and their parallel implementation.

Parallel solution of an FSI problem: Channel with an elastic leaflet

We demonstrate how to distribute FSI problems that use algebraic update methods.

• How to distribute fluid-structure interaction problems in which algebraic node update methods are used to deform the fluid mesh in response to changes in the shape of the domain boundary
• How to retain all elements in a mesh on all processors when the problem is distributed.

Parallel solution of Turek and Hron's FSI benchmark problem

We demonstrate how to distribute a problem involving refineable 2D solid and fluid meshes that interact along interface boundaries.

• How to "upgrade" Turek & Hron's FSI benchmark problem to allow spatial adaptivity in the fluid and solid meshes.
• How to retain selected elements on all processors when the problem is distributed.
• How to implement load-balancing of a distributed multi-domain problem, with particular reference to the actions before and after load balance functions.