## Fenics examples

The following examples illustrate basic usage of the form language for the definition of a collection of standard multilinear forms.

This example is implemented in the file Mass. This example is implemented in the file Poisson. This example is implemented in the file PoissonSystem. This example is implemented in the file Elasticity.

The bilinear form for fixed-point iteration on the nonlinear term of the incompressible Navier—Stokes equations.

This example is implemented in the file NavierStokes. In the example below, we implement this variational problem with piecewise linear test and trial functions, but other choices are possible just choose another finite element.

This example is implemented in the file Heat. This example is implemented in the file Stokes. This example is implemented in the file MixedPoisson. The corresponding finite element variational problem for discontinuous first order elements may be implemented as follows:. This example is implemented in the file PoissonDG. The strong equation looks as follows:. The above form will be denoted REF1 and serves as our reference implementation for linear elements. A similar form REF2 using quadratic elements will serve as a reference for quadratic elements. Substituting into the bilinear and linear forms, we obtain.

This situation shows up in plasticity and other problems where certain quantities need to be computed elsewhere in user-defined functions. The three forms using the standard FiniteElement linear elements can then be implemented as.

The three forms can be implemented using the QuadratureElement in a similar fashion in which only the element declaration is different:. Note that we use two points when declaring the QuadratureElement.

This is because the RHS of Tangent. Due to consistency issues, when passing functions around between the forms, we also need to use two points when declaring the QuadratureElement in the other forms. Typical values of the relative residual for each Newton iteration for all three approaches are shown in the table below.

## FEniCS Project

It is to be noted that the convergence rate is quadratic as it should be for all three methods. This influences the convergence rate as seen in the table below. Clearly, using the standard FiniteElement leads to a poor convergence whereas the QuadratureElement still leads to quadratic convergence.Logg, K. Mardal, G. Wells et al. Springer, Download from Launchpad. We see JIT compilation of finite element code, i.

This is done once and will not be done again with different mesh. The function boundary defines boundary of the domain and bc represents Dirichlet boundary condition on space V. Finally we create finite-element function u on space V. TrialFunction and TestFunction were only thought arguments of multi-linear forms - not a real function with its values in memory. Note that the solution process can be controlled in a much detailed way. Task 2.

Try also running it in parallel using mpirun command. Task 3. Task 4. Use Constant class for k to avoid form recompilation when changing k. Very short introduction to Python. Heat equation. Enter search terms or a module, class or function name.

Navigation index next previous FEniCS tutorial 1. UFL Unified Form Language is a specific language for declaration of finite element discretizations of variational forms. Provides data structeres for holding vectors and matrices and lots of linear and non-linear solvers and preconditioners. And now Start interactive Python session and type in following code. Solving linear variational problem. But attendees will probably encounter this when modifying the code. Last updated on May 12, Created using Sphinx 1.Andy Terrel also notes that the FEniCS software package was originally compiled at the University of Chicagowhose mascot is a phoenix, which likely inspired the name.

A discussion of the topic can be found here on the FEniCS launchpad. This article acts as an introduction to the Python programming language and specifically its use with FEniCS. The Python code below, taken from an example problem found here: Egm The structure of the example code can be applied to many problems but will require varying degrees of modification. A Python code file can quickly be created from the Linux terminal. Entering the command "gedit" will open a blank document.

Simply write the code in this document and save it into the desired directory with a. The file can be reopened for editing by entering "gedit filename. The code can be run by entering "Python filename. Code can also be written using iPython, an interactive Python with many benefits and additional capabilities.

Begin iPython by entering "ipython" in the terminal. You can quit iPython at any time by entering "quit". The code can be saved to your current directory by entering "save filename. For example, "save example.

### FEniCS Project

The code here imports classes like Interval, Functionspace, Function, etc. FEniCS relies heavily on these classes so this will normally be the first line in your Python code. Including "from" causes the statement to repeatedly define names from the module. The example interval runs from 0 to 1 with 20 divisions. We then define a discrete function space V over the mesh. The functionspace class follows the syntax "FunctionSpace" your mesh, type of element, degree of basis functions.

Above, the standard Lagrange family of elements is used which can also be denoted by 'CG' for Continuous Galerkin. A degree of 1 is also shown. This denotes the standard linear Lagrange element, later yielding a computed u that is continuous and linearly varying over each mesh division.

The following lines can be used to create a unit square or rectangular mesh. Each cell created by the x and y divisions is divided in half to create two triangular elements. Here the code defines new classes, BoundaryLeft and BoundaryRight, for the left and right boundaries. Note that variables x and y would be denoted by x and x, respectively. The function "near" value1,value2 checks that value1 is within machine precision of value2.

The code here creates two variables of the previously created class types BoundaryLeft and BoundaryRight. These variables are used in the next step when applying the boundary conditions. Here we apply the Dirichlet boundary conditions using the dolfin class DirichletBC following the syntax "DirichletBC" function space, boundary value, boundary variables.

Note that the left and right boundaries are both included. Here we define several variables including the dolfin classes TrialFunction and TestFunction using the function space V. Constants f, g, nu, and ac are also defined to values given in the problem statement.

Here we define our a u,v and L vobtained by the derivation of the weak variational form. Note the syntax for inner product inner and gradient grad.The examples in the section Fundamentals illustrate that solving linear, stationary PDE problems with the aid of FEniCS is easy and requires little programming. That is, FEniCS automates the spatial discretization by the finite element method. The solution of nonlinear problems, as we showed in the section Nonlinear Problemscan also be automated cf.

The section Solving the Nonlinear Variational Problem Directlybut many scientists will prefer to code the solution strategy of the nonlinear problem themselves and experiment with various combinations of strategies in difficult problems. Time-dependent problems are somewhat similar in this respect: we have to add a time discretization scheme, which is often quite simple, making it natural to explicitly code the details of the scheme so that the programmer has full control.

We shall explain how easily this is accomplished through examples.

### Introduction to Python for FEniCS

Our time-dependent model problem for teaching purposes is naturally the simplest extension of the Poisson problem into the time domain, i. Here, varies with space and time, e. The source function and the boundary values may also vary with space and time. The initial condition is a function of space only. A straightforward approach to solving time-dependent PDEs by the finite element method is to first discretize the time derivative by a finite difference approximation, which yields a recursive set of stationary problems, and then turn each stationary problem into a variational formulation.

Let superscript denote a quantity at timewhere is an integer counting time levels. For example, means at time level. A finite difference discretization in time first consists in sampling the PDE at some time level, say :. The time-derivative can be approximated by a finite difference.

For simplicity and stability reasons we choose a simple backward difference:. Inserting this approximation in the PDE yields. This is our time-discrete version of the diffusion PDE problem. Reordering the last equation so that appears on the left-hand side only, yields a recursive set of spatial stationary problems for assuming is known from computations at the previous time level :. Givenwe can solve for,and so on. We use a finite element method to solve the time-discrete equations which still have spatial differential operators.

This requires turning the equations into weak forms. As usual, we multiply by a test function and integrate second-derivatives by parts. Introducing the symbol for which is natural in the program toothe resulting weak form can be conveniently written in the standard notation: for the initial step and for a general step, where. The continuous variational problem is to find such that holds for alland then find such that for all .FEniCS enables users to quickly translate scientific models into efficient finite element code.

FEniCS runs on a multitude of platforms ranging from laptops to high-performance clusters. The above code snippet also shows how to define a suitable finite element function space, using continuous piecewise quadratic vector-valued functions for the velocity and continuous piecewise linear functions for the pressure Taylor-Hood. The computational domain and mesh are also easily created with FEniCS, here defined by three spheres immersed in a 3D channel.

The figure shows the von Mises stresses computed from a nonlinear thermomechanical FEniCS simulation of a turbocharger. The finite element system of linear equations comprises more than 3.

Choose between Docker containers, binary packages and source code. Visit our installation page to get the latest version of FEniCS. FEniCS comes with extensive documentation and numerous examples. The FEniCS Project is developed and maintained as a freely available, open-source project by a global community of scientists and software developers.

If you like FEniCS and want to support our mission to produce the best possible platform for open-source computing, consider making a donation to our project. FEniCS Project Define function space. Define variational problem. Compute solution. Define domain. Generate mesh. FEniCS Project. Copyright Vega Wordpress Theme by LyraThemes.GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together.

If nothing happens, download GitHub Desktop and try again. If nothing happens, download Xcode and try again. If nothing happens, download the GitHub extension for Visual Studio and try again. This repository contains all source files, published documents, and example programs for the FEniCS Tutorial. Skip to content. Dismiss Join GitHub today GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together. Latest commit. Anders Logg Small fix comment from Andreas Felderer. Latest commit bfc Oct 30, You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window.

Oct 28, Add new scan of comments from referee 4. Nov 4, Small fix comment from Andreas Felderer. Oct 30, Translate Chapter 1 and some work on Chapter 2.

Jun 8, First commit. Mar 4, GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together. 