Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/eduardgomezescandell/finite_elements_1d_julia
https://github.com/eduardgomezescandell/finite_elements_1d_julia
Last synced: 13 days ago
JSON representation
- Host: GitHub
- URL: https://github.com/eduardgomezescandell/finite_elements_1d_julia
- Owner: EduardGomezEscandell
- Created: 2022-04-19T23:51:47.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2022-04-25T22:39:07.000Z (over 2 years ago)
- Last Synced: 2024-11-07T10:53:30.529Z (2 months ago)
- Language: Julia
- Size: 101 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Finite element implementation in Julia
This is a toy project as a first contact with the Julia programming language.
It solves partial derivative equations in a 1D domain using the Finite Element Method.
Currently, the following equations are implemented:
- Poisson (pure diffusion)
- Convection-diffusion
- Burger's equation
The program is easily extendable to other partial derivative equations.
You can choose between diferent polynomial interpolations and diferent quadrature orders.
You can also choose between Neumann and Dirichlet boundary conditions.
### Dependencies
You need to install the `Gaston` package and `GNUplot`:
```bash
julia -e 'using Pkg; Pkg.add("Gaston")'
sudo apt install gnuplot
```
## How to run
Open the `demos/demo_steady.jl` file and edit the settings to your liking. Then use:
```bash
julia -i demos/demo_steady.jl
```
The following figure should pop up:
If no figure pops up, you may be missing `gnuplot` (a warning will show in the console) or you might have run the
program without the `-i` flag. A Julia interactive session will stay open, and you can subsequently call
```julia
julia> include("demos/demo_steady.jl")
```
after changing any of the settings to avoid recompiling Gaston, the plotting library.
The same process works for the other demos. For instance, here is the result for `demos/demo_unsteady_implicit.jl`:
Convection-diffusion equation:
Here is the Burger's equation:
## General Structure
### Time integrator
The time integrator is in charge of time-stepping. If you don't want to step in time, `TimeIntegratorSteady` is a dummy integrator that
merely solves the steady-state equation. In order to solve each step (or the steady state), the time integrator assembles a system such as:
```
∂u/∂t + L(u)u = s
```
by discretizing the previous equation in space, with help of shape functions `w`, we obtain:
```
(w, ∂u/∂t) - (w, L(u)u) = (w, s)
```
This generates two matrices and a vector, one for each term: `M`, `L`, and `F`. Depending on the time integrator, these matrices are evaluated
at one ore more points in time. For instance, with a Forward-Euler time scheme we get:
```
M(t_old)*U(t) = Δt*F(t_old) + (M(t_old) - Δt*K(t_old))*U(t_old)
```
Hence:
```
LHS = M
RHS = Δt*F(t_old) + (M - Δt*K(t_old)) U(t_old)
U = LHS \ RHS
```
The time scheme is in charge of evaluating this expression. To obtain matrices `M`, `L` and vector `F`, the space integrator is called.
### Space integrator
This class is in charge of assembling the contributions from each element and boundary condition by calling `calculate_M`, `calculate_L` and `calculate_F`.
The global matrices are partitioned:
```
[ LHS_ff | LHS_fl ] [ Uf ] [ RHS_f ]
[----------+----------] [----] = [-------]
[ LHS_ff | LHS_fl ] [ Ul ] [ RHS_l ]
```
where `f` indicates the free degrees of freedom, and `l` indicates the locked ones (Dirichlet boundary condition). The space integrator is also in charge
of sending each local contribution to the right partition.
It is also in charge of generating a solution vector `U` by interlacing `Uf` and `Ul`.
### SystemOfEquations
To solve the partitioned system of equations, the following expression is followed:
```
LHS_ff * Uf = RHS_f - LHS_fl*Ul
```
Class SystemOfEquations is in charge of solving for Uf.
### Elements
They are in charge of computing local matrices `M`, `L` and vector `F`. They use Gauss quadrature to integrate them.
# Known issues
Explicit time integrators do not work with non-linear elements.