FEniCSx is a popular open-source (LGPLv3) computing platform for solving partial differential equations (PDEs). FEniCSx enables users to quickly translate scientific models into efficient finite element code. With the high-level Python and C++ interfaces to FEniCSx, it is easy to get started, but FEniCSx offers also powerful capabilities for more experienced programmers. FEniCSx runs on a multitude of platforms ranging from laptops to high-performance clusters.
In all cases we recommend that prospective students join our Slack channel #gsoc2022 and work with us to write their project proposals. The below are just ideas; if you have your own idea, we are more than happy to discuss it with you!
We would ask that potential applicants install FEniCSx and try out the demos. The DOLFINx tutorial has an up-to-date description of using FEniCSx to solve partial differential equations.
GSoC 2022 is now open to a wider range of applicants, not just those registered in a course at a higher-education institution as in previous years. Please read the GSoC FAQ here for all of the new eligibility requirements.
The FEniCS Project has recently undergone an almost complete ground up
redevelopment. Consequently, all projects will be additions to the new FEniCSx
components (DOLFINx, FFCx, Basix) not the old components (DOLFIN, FFC and FIAT)
All developent takes place on our our GitHub page.
When looking for relevant examples you should see import dolfinx not import dolfin or from dolfin import * at the top.
All projects will require knowledge of Modern C++ and Python. You will mainly be working with DOLFINx, the finite element solver of the FEniCS Project. Some knowledge of finite element methods and more generally in numerical computing would be a big advantage.
The DOLFINx Python and C++ demos are the main ways that our users get to know and learn the FEniCS Project. After an intensive period of recent work to smooth the design of the API of DOLFINx we are now ready to both polish and expand on our existing (limited!) set of demos. This project would be ideal for a participant with knowledge of finite element and numerical methods and a enthusiasm for writing very clear and precise examples for end users.
| Difficulty | Priority | Involves | Mentors |
|---|---|---|---|
| Medium (175h) | High | Python and/or C++ | Michal Habera, Jack S. Hale |
You can see the current state of the demos on the main branch here.
A possible plan could be:
- Look at the existing DOLFIN and DOLFINx demos and familarise yourself with the pipeline used to transform Python files into e.g. notebooks or Sphinx documentation.
- Identify gaps in terms of concepts exposed by those demos. Try to minimise overlap in concepts shown between demos. For example, we do not need to explain the basics of mesh generation in a demo focused on showing users how to solve non-linear problems.
- Define a set of new demos and/or ports of existing DOLFINx demos.
- Propose API changes or new high-level functions where existing lower-level
functions are producing a lot of boiler-plate code or potential errors. See
e.g.
fem.LinearProblem.
Because this task will involve writing some English language text to document the demos candidates should be reasonably proficient in written English.
We envisage the possibility of two students working collaboratively on this topic, see Expanding the DOLFINx demos (1).
| Difficulty | Priority | Involves | Mentors |
|---|---|---|---|
| Medium (175h) | High | Python, C++ | Jack S. Hale, Garth N. Wells |
Finite element methods require a discretisation of a domain into small cells (or elements), called a mesh. At the moment, FEniCSx only supports meshes consisting of cells of a single type (e.g. triangles, tetrahedrons, quadrilaterials, or hexahedrons). However, in many applications, it is important to use meshes consisting of cells of multiple types. For example, to effectively mesh boundary layers around complex geometries in fluid mechanics problems, it is optimal to use mostly hexahedral cells with a few cells of alternative type (e.g. pyramids) for tractability of the meshing problem. In this project, you will extend FEniCSx to fully support meshes with cells of multiple types.
| Difficulty | Priority | Involves | Mentors |
|---|---|---|---|
| Hard (350h) | Medium | Python, C++ | Chris Richardson, Igor Baratta |
This project will likely have an important conceptual design component and will need to be undertaken in close collaboration with a core developer. Candidates with good knowledge of computational geometry or topology would also be ideally suited for this project.
A possible plan could be:
- Identify with precision all parts of DOLFINx where uniform cell topology is
currently assumed, e.g.
fem::ElementDofLayout,fem::DofMapandassemble_*functions. Note that some cell types have multiple facet topologies, e.g. pyramids (one square facet and three triangular facets). - Validate existing finite element kernels on untested cell types.
- Identify appropriate non-intrusive design for assembling on mixed topology meshes. This could perhaps be handled by dispatching one generated kernel per cell type into the assembler acting on a set of cells of uniform topology.
- Specify work plan for making multiple small incremental pull requests rather than one large request.
- Implement new design and specify and write appropriate unit tests.
- Generate meshes with mixed cell topologies.
- Perform standard convergence tests for e.g. the Poisson problem on mixed topology meshes.
A widespread method for solving time-dependent partial differential equations (PDEs) is to employ a finite difference scheme in time and a finite element scheme in space. This method will produce a sequence of problems that have to be solved sequentially. For many PDEs, adaptive time stepping is crucial to get a stable solution. However, for complex problems, the stability criterion might not be known a priori, and has to be estimated by trial and error. For large problems, such an exploration can become very time consuming as the simulation has to start from the initial time step for every simulation. Having a checkpointing algorithm to store the solution to the finite element problem to disk at any time step would make it possible to restart the simulation from the last stable solution. Currently, FEniCSx does not support checkpointing of functions. In this project, you would extend FEniCSx to support checkpointing using ADIOS2.
| Difficulty | Priority | Involves | Mentors |
|---|---|---|---|
| Hard (350h) | Medium | Python, C++ | Jørgen Dokken, Chris Richardson |
FEniCSx currently supports writing output with ADIOS2, and the implementation can be found here. The candidate would be expected to extend this interface, and a candidate should ideally be familiar with C++ and the fundamentals of finite element methods.
A possible plan could be:
- Extend the ADIOS2-functionality in FEniCSx to be able to read in meshes in serial (from files produced with a single MPI process).
- Familiarize with how ADIOS2 store data written in parallel using MPI, and how to read such data in a serial program.
- Explore data written with a single MPI process is read with ADIOS2 when executed with multiple processes.
- With the two previous concepts explored, extend the reading of meshes to parallel.
- Extend the ADIOS2-IO in FEniCSx to checkpoint functions.