FEniCS DOLFIN

https://olddocs.fenicsproject.org/dolfin/2019.1.0/
Admin
FEniCS DOLFIN is the C++ and Python interface of the FEniCS Project, serving as a broad, efficient,...
Tokens:54,738
Snippets:597
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### dolfin.cpp.log.begin

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_autogenerated/dolfin.cpp.log.html

Starts a progress bar or logging block.

```APIDOC
## begin(arg0: int, arg1: str) -> None
## begin(arg0: str) -> None

### Description
Starts a progress bar or logging block with an optional level and message.
```

--------------------------------

### Initialize Time Stepping

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Setup time arrays and XDMF output parameters for simulation results.

```python
 # Time-stepping
 time = np.linspace(0, T, Nsteps+1)
 u_tip = np.zeros((Nsteps+1,))
 energies = np.zeros((Nsteps+1, 4))
 E_damp = 0
 E_ext = 0
 sig = Function(Vsig, name="sigma")
 xdmf_file = XDMFFile("elastodynamics-results.xdmf")
 xdmf_file.parameters["flush_output"] = True
 xdmf_file.parameters["functions_share_mesh"] = True
 xdmf_file.parameters["rewrite_function_mesh"] = False
```

--------------------------------

### Import DOLFIN and Matplotlib

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/built-in-meshes/demo_built-in-meshes.py.rst.txt

Initial setup required to use DOLFIN mesh classes and plotting utilities.

```python
from dolfin import *
import matplotlib.pyplot as plt
```

--------------------------------

### Retrieve pybind11 include paths

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_modules/dolfin/jit.html

Locates the pybind11 include directory by checking environment variables or the installed pybind11 module.

```python
import os



[docs]def get_pybind_include():
    """Find the pybind11 include path"""

    # Look in PYBIND11_DIR
    pybind_dir = os.getenv('PYBIND11_DIR', None)
    if pybind_dir:
        p = os.path.join(pybind_dir, "include")
        if (_check_pybind_path(p)):
            return [p]

    # Extract from pybind11 module
    import pybind11
    return [pybind11.get_include(True), pybind11.get_include()]



def _check_pybind_path(root):
    p = os.path.join(root, "pybind11", "pybind11.h")
    if os.path.isfile(p):
        return True
    else:
        return False
```

--------------------------------

### Import and Configure DOLFIN

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/maxwell-eigenvalues/demo_maxwell-eigenvalues.py.rst.txt

Initializes the environment by importing necessary libraries and verifying that PETSc and SLEPc backends are available.

```python
from dolfin import *
import numpy as np
if not has_linear_algebra_backend("PETSc"):
    print("DOLFIN has not been configured with PETSc. Exiting.")
    exit()
if not has_slepc():
    print("DOLFIN has not been configured with SLEPc. Exiting.")
    exit()
```

--------------------------------

### Initialize Test, Trial, and State Functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/elastodynamics/demo_elastodynamics.py.html

Sets up the variational forms and state variables for the current and previous time steps.

```python
# Test and trial functions
du = TrialFunction(V)
u_ = TestFunction(V)
# Current (unknown) displacement
u = Function(V, name="Displacement")
# Fields from previous time step (displacement, velocity, acceleration)
u_old = Function(V)
v_old = Function(V)
a_old = Function(V)
```

--------------------------------

### Get Linear Algebra Index Data Type

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_modules/dolfin/la.html

Returns the numpy dtype corresponding to the internal la_index type based on the system architecture.

```python
def la_index_dtype():
    """Return the numpy dtype equivalent to the type of la_index"""
    return intc if cpp.common.sizeof_la_index() == 4 else int64
```

--------------------------------

### Configure Krylov solver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Initialize the Krylov solver and associate the system matrix and preconditioner.

```python
# Create Krylov solver and AMG preconditioner
solver = KrylovSolver(krylov_method, "amg")

# Associate operator (A) and preconditioner matrix (P)
solver.set_operators(A, P)
```

--------------------------------

### Configure and Solve Krylov Solver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/stokes-iterative/demo_stokes-iterative.py.html

Initializes the Krylov solver with the chosen method and AMG preconditioner, then solves the system.

```python
# Create Krylov solver and AMG preconditioner
solver = KrylovSolver(krylov_method, "amg")

# Associate operator (A) and preconditioner matrix (P)
solver.set_operators(A, P)

# Solve
U = Function(W)
solver.solve(U.vector(), bb)
```

--------------------------------

### Layout header files

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/styleguide_cpp.rst.txt

Follow the standard header template including license and namespace.

```c++
// Copyright (C) 2008 Foo Bar
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>. 
//
// Modified by Bar Foo 2008

#ifndef __FOO_H
#define __FOO_H

namespace dolfin
{

  class Bar; // Forward declarations here

  /// Documentation of class

  class Foo
  {
  public:

    ...

  private:

    ...

  };

}

#endif
```

--------------------------------

### Define Mesh and Boundary Conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Initializes the simulation environment by importing modules, setting compiler optimizations, and defining the geometry and boundary subdomains.

```python
from dolfin import *
 import numpy as np
 import matplotlib.pyplot as plt

 # Form compiler options
 parameters["form_compiler"]["cpp_optimize"] = True
 parameters["form_compiler"]["optimize"] = True

 # Define mesh
 mesh = BoxMesh(Point(0., 0., 0.), Point(1., 0.1, 0.04), 60, 10, 5)

 # Sub domain for clamp at left end
 def left(x, on_boundary):
     return near(x[0], 0.) and on_boundary

 # Sub domain for rotation at right end
 def right(x, on_boundary):
     return near(x[0], 1.) and on_boundary
```

--------------------------------

### Assemble system and preconditioner

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Assemble the system matrix and preconditioner matrix while applying boundary conditions symmetrically.

```python
# Assemble system
A, bb = assemble_system(a, L, bcs)

# Assemble preconditioner system
P, btmp = assemble_system(b, L, bcs)
```

--------------------------------

### Configure PETSc Backend

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/singular-poisson/demo_singular-poisson.py.rst.txt

Verifies that PETSc is available and sets it as the linear algebra backend.

```python
# Test for PETSc
if not has_linear_algebra_backend("PETSc"):
    info("DOLFIN has not been configured with PETSc. Exiting.")
    exit()

parameters["linear_algebra_backend"] = "PETSc"
```

--------------------------------

### Create the mesh

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/mixed-poisson/demo_mixed-poisson.py.rst.txt

Initialize a UnitSquareMesh with 32x32 subdivisions.

```python
# Create mesh
mesh = UnitSquareMesh(32, 32)
```

--------------------------------

### Initialize the eigensolver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/eigenvalue/demo_eigenvalue.py.rst.txt

Create a SLEPcEigenSolver instance initialized with the assembled matrix.

```python
# Create eigensolver
eigensolver = SLEPcEigenSolver(A)
```

--------------------------------

### Define Test, Trial, and State Functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Sets up the trial and test functions along with the current and previous state functions for the time-stepping loop.

```python
# Test and trial functions
 du = TrialFunction(V)
 u_ = TestFunction(V)
 # Current (unknown) displacement
 u = Function(V, name="Displacement")
 # Fields from previous time step (displacement, velocity, acceleration)
 u_old = Function(V)
 v_old = Function(V)
 a_old = Function(V)
```

--------------------------------

### Create Mesh

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/mixed-poisson/demo_mixed-poisson.py.html

Initialize a 32x32 unit square mesh.

```python
# Create mesh
mesh = UnitSquareMesh(32, 32)

```

--------------------------------

### Configure Krylov Solver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/singular-poisson/demo_singular-poisson.py.rst.txt

Initialize a PETSc Krylov solver using the conjugate gradient method and set the operator.

```python
# Create Krylov solver
solver = PETScKrylovSolver("cg")
solver.set_operator(A)
```

--------------------------------

### Name files

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/styleguide_cpp.rst.txt

Use camel caps for class-related files and lower-case for utility files.

```c++
FooBar.h
FooBar.cpp
```

--------------------------------

### Defining the solution function

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/auto-adaptive-poisson/demo_auto-adaptive-poisson.py.html

Initialize the function that will store the solution.

```python
# Define function for the solution
u = Function(V)
```

--------------------------------

### Configure Nonlinear Problem and Newton Solver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Instantiates the nonlinear problem and configures the Newton solver parameters.

```python
# Create nonlinear problem and Newton solver
problem = CahnHilliardEquation(a, L)
solver = NewtonSolver()
solver.parameters["linear_solver"] = "lu"
solver.parameters["convergence_criterion"] = "incremental"
solver.parameters["relative_tolerance"] = 1e-6
```

--------------------------------

### Configure linear algebra backend and solver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Checks for required linear algebra backends (PETSc or Tpetra) and selects an appropriate Krylov solver method.

```python
from dolfin import *

# Test for PETSc or Tpetra
if not has_linear_algebra_backend("PETSc") and not has_linear_algebra_backend("Tpetra"):
    info("DOLFIN has not been configured with Trilinos or PETSc. Exiting.")
    exit()

if not has_krylov_solver_preconditioner("amg"):
    info("Sorry, this demo is only available when DOLFIN is compiled with AMG "
         "preconditioner, Hypre or ML.")
    exit()

if has_krylov_solver_method("minres"):
    krylov_method = "minres"
elif has_krylov_solver_method("tfqmr"):
    krylov_method = "tfqmr"
else:
    info("Default linear algebra backend was not compiled with MINRES or TFQMR "
         "Krylov subspace method. Terminating.")
    exit()
```

--------------------------------

### Process and save results

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Split the solution into sub-functions and export them to VTK format.

```python
# Get sub-functions
u, p = U.split()

# Save solution in VTK format
ufile_pvd = File("velocity.pvd")
ufile_pvd << u
pfile_pvd = File("pressure.pvd")
pfile_pvd << p
```

--------------------------------

### Define and assemble the stiffness matrix

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/eigenvalue/demo_eigenvalue.py.rst.txt

Construct the mesh, function space, and variational form, then assemble the stiffness matrix using a PETScMatrix.

```python
# Define mesh, function space
mesh = Mesh("box_with_dent.xml.gz")
V = FunctionSpace(mesh, "Lagrange", 1)

# Define basis and bilinear form
u = TrialFunction(V)
v = TestFunction(V)
a = dot(grad(u), grad(v))*dx

# Assemble stiffness form
A = PETScMatrix()
assemble(a, tensor=A)
```

--------------------------------

### Define Mesh and Boundary Subdomains

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/elastodynamics/demo_elastodynamics.py.html

Initializes the simulation mesh and defines geometric subdomains for boundary conditions.

```python
from dolfin import *
import numpy as np
import matplotlib.pyplot as plt

# Form compiler options
parameters["form_compiler"]["cpp_optimize"] = True
parameters["form_compiler"]["optimize"] = True

# Define mesh
mesh = BoxMesh(Point(0., 0., 0.), Point(1., 0.1, 0.04), 60, 10, 5)

# Sub domain for clamp at left end
def left(x, on_boundary):
    return near(x[0], 0.) and on_boundary

# Sub domain for rotation at right end
def right(x, on_boundary):
    return near(x[0], 1.) and on_boundary
```

--------------------------------

### Define Trial and Test Functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/singular-poisson/demo_singular-poisson.py.rst.txt

Sets up the trial and test functions for the variational form.

```python
u = TrialFunction(V)
v = TestFunction(V)
```

--------------------------------

### Define and split mixed functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Initialize solution functions and split them into individual components for access.

```python
# Define functions
u   = Function(ME)  # current solution
u0  = Function(ME)  # solution from previous converged step

# Split mixed functions
dc, dmu = split(du)
c,  mu  = split(u)
c0, mu0 = split(u0)
```

--------------------------------

### Creating mesh and function space

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/biharmonic/demo_biharmonic.py.rst.txt

Setting up the mesh with ghosting for DG terms and defining the quadratic finite element space.

```python
# Make mesh ghosted for evaluation of DG terms
parameters["ghost_mode"] = "shared_facet"

# Create mesh and define function space
mesh = UnitSquareMesh(32, 32)
V = FunctionSpace(mesh, "CG", 2)
```

--------------------------------

### Compute and plot solution

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/mixed-poisson/demo_mixed-poisson.py.rst.txt

Solve the system, split the solution into components, and visualize the results.

```python
# Compute solution
w = Function(W)
solve(a == L, w, bc)
(sigma, u) = w.split()

# Plot sigma and u
plt.figure()
plot(sigma)

plt.figure()
plot(u)

plt.show()
```

--------------------------------

### Define Trial and Test Functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/singular-poisson/demo_singular-poisson.py.html

Initializes the trial and test functions on the defined function space.

```python
u = TrialFunction(V)
v = TestFunction(V)

```

--------------------------------

### Creating the Mesh

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/neumann-poisson/demo_neumann-poisson.py.rst.txt

Generates a 64x64 quadrilateral mesh for the unit square domain.

```python
# Create mesh
mesh = UnitSquareMesh.create(64, 64, CellType.Type.quadrilateral)
```

--------------------------------

### MultiStageScheme Initialization

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_modules/dolfin/multistage/multistagescheme.html

The base constructor for defining a multi-stage scheme with specific stage forms and solver parameters.

```python
MultiStageScheme.__init__(self, rhs_form, ufl_stage_forms,
                                  dolfin_stage_forms, last_stage,
                                  stage_solutions, solution, time, dt,
                                  c, jacobian_indices, order,
                                  self.__class__.__name__, human_form,
                                  bcs, contraction)
```

--------------------------------

### Importing DOLFIN

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/neumann-poisson/demo_neumann-poisson.py.rst.txt

Initializes the dolfin module for use in the script.

```python
from dolfin import *
```

--------------------------------

### Configure SLEPc EigenSolver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/maxwell-eigenvalues/demo_maxwell-eigenvalues.py.rst.txt

Sets up the SLEPc solver parameters for a generalized Hermitian eigenvalue problem.

```python
#
    solver = SLEPcEigenSolver(A, B)
    solver.parameters["solver"] = "krylov-schur"
    solver.parameters["problem_type"] = "gen_hermitian"
```

--------------------------------

### Configure Linear Solver

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Define a LUSolver to reuse factorizations for constant time steps.

```python
 # Define solver for reusing factorization
 K, res = assemble_system(a_form, L_form, bc)
 solver = LUSolver(K, "mumps")
 solver.parameters["symmetric"] = True
```

--------------------------------

### Defining Initial Conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

A custom UserExpression class used to initialize the concentration and chemical potential fields with random perturbations.

```python
# Class representing the intial conditions
class InitialConditions(UserExpression):
    def __init__(self, **kwargs):
        random.seed(2 + MPI.rank(MPI.comm_world))
        super().__init__(**kwargs)
    def eval(self, values, x):
        values[0] = 0.63 + 0.02*(0.5 - random.random())
        values[1] = 0.0
    def value_shape(self):
        return (2,)
```

--------------------------------

### Compute Stresses and Energies

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Projects stresses onto a DG-0 space using LocalSolver and calculates system energies at each time step.

```python
# Save solution to XDMF format
xdmf_file.write(u, t)

# Compute stresses and save to file
local_project(sigma(u), Vsig, sig)
xdmf_file.write(sig, t)

p.t = t
# Record tip displacement and compute energies
# Note: Only works in serial
if MPI.comm_world.size == 1:
    u_tip[i+1] = u(1., 0.05, 0.)[1]
E_elas = assemble(0.5*k(u_old, u_old))
E_kin = assemble(0.5*m(v_old, v_old))
E_damp += dt*assemble(c(v_old, v_old))
# E_ext += assemble(Wext(u-u_old))
E_tot = E_elas+E_kin+E_damp #-E_ext
energies[i+1, :] = np.array([E_elas, E_kin, E_damp, E_tot])
```

--------------------------------

### dolfin.cpp.fem.assemble_system

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_autogenerated/dolfin.cpp.fem.html

Assembles a linear system from variational forms and boundary conditions.

```APIDOC
## dolfin.cpp.fem.assemble_system

### Description
Assembles a system of equations (matrix and vector) from bilinear and linear forms, including Dirichlet boundary conditions.

### Signature
1. assemble_system(arg0: dolfin::GenericMatrix, arg1: dolfin::GenericVector, arg2: dolfin.cpp.fem.Form, arg3: dolfin.cpp.fem.Form, arg4: List[dolfin.cpp.fem.DirichletBC]) -> None
2. assemble_system(arg0: dolfin::GenericMatrix, arg1: dolfin::GenericVector, arg2: dolfin.cpp.fem.Form, arg3: dolfin.cpp.fem.Form, arg4: List[dolfin.cpp.fem.DirichletBC], arg5: dolfin::GenericVector) -> None
```

--------------------------------

### Collect boundary conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Define the list of boundary conditions for the system.

```python
# Collect boundary conditions
bcs = [bc0, bc1]
```

--------------------------------

### Importing Required Modules

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Initial imports for the Cahn-Hilliard demo, including random number generation and the FEniCS library.

```python
import random
from dolfin import *
```

--------------------------------

### Create mesh and function space

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Initialize a quadrilateral unit square mesh and define a mixed function space using linear Lagrange elements.

```python
# Create mesh and build function space
mesh = UnitSquareMesh.create(96, 96, CellType.Type.quadrilateral)
P1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1)
ME = FunctionSpace(mesh, P1*P1)
```

--------------------------------

### Define Material and Damping Parameters

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Sets up the elastic constitutive relation, mass density, and Rayleigh damping coefficients for the simulation.

```python
# Elastic parameters
 E  = 1000.0
 nu = 0.3
 mu    = Constant(E / (2.0*(1.0 + nu)))
 lmbda = Constant(E*nu / ((1.0 + nu)*(1.0 - 2.0*nu)))

 # Mass density
 rho = Constant(1.0)

 # Rayleigh damping coefficients
 eta_m = Constant(0.)
 eta_k = Constant(0.)
```

--------------------------------

### Importing modules

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/biharmonic/demo_biharmonic.py.rst.txt

Initial imports required for the simulation and plotting.

```python
import matplotlib.pyplot as plt
from dolfin import *
```

--------------------------------

### dolfin.jit.get_pybind_include()

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_autogenerated/dolfin.jit.html

Retrieves the include path for the pybind11 library, which is required for JIT compilation of C++ extensions in Python.

```APIDOC
## dolfin.jit.get_pybind_include()

### Description
Finds and returns the include path for the pybind11 library.

### Signature
`dolfin.jit.get_pybind_include()`

### Returns
- **path** (string) - The filesystem path to the pybind11 include directory.
```

--------------------------------

### Solving the adaptive variational problem

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/auto-adaptive-poisson/demo_auto-adaptive-poisson.py.html

Configure and execute the adaptive solver, then visualize the initial and final mesh solutions.

```python
# Solve equation a = L with respect to u and the given boundary
# conditions, such that the estimated error (measured in M) is less
# than tol
problem = LinearVariationalProblem(a, L, u, bc)
solver = AdaptiveLinearVariationalSolver(problem, M)
solver.parameters["error_control"]["dual_variational_solver"]["linear_solver"] = "cg"
solver.parameters["error_control"]["dual_variational_solver"]["symmetric"] = True
solver.solve(tol)

solver.summary()

# Plot solution(s)
plt.figure()
plot(u.root_node(), title="Solution on initial mesh")
plt.figure()
plot(u.leaf_node(), title="Solution on final mesh")
plt.show()
```

--------------------------------

### UnitCubeMesh.create

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_autogenerated/dolfin.cpp.generation.html

Creates a UnitCubeMesh instance.

```APIDOC
## UnitCubeMesh.create

### Description
Creates a unit cube mesh with specified resolution.

### Signature
- create(n: List[int[3]], cell_type: dolfin.cpp.mesh.CellType.Type) -> dolfin.cpp.mesh.Mesh
- create(comm: MPICommWrapper, n: List[int[3]], cell_type: dolfin.cpp.mesh.CellType.Type) -> dolfin.cpp.mesh.Mesh
- create(nx: int, ny: int, nz: int, cell_type: dolfin.cpp.mesh.CellType.Type) -> dolfin.cpp.mesh.Mesh
- create(comm: MPICommWrapper, nx: int, ny: int, nz: int, cell_type: dolfin.cpp.mesh.CellType.Type) -> dolfin.cpp.mesh.Mesh
```

--------------------------------

### Standard DOLFIN File Header and Structure

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/styleguide_cpp.rst.txt

Template for source files including copyright notice, includes, and class structure with 79-character width separators.

```c++
// Copyright (C) 2008 Foo Bar
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Bar Foo 2008

#include <dolfin/Foo.h>

using namespace dolfin;

//-----------------------------------------------------------------------------
Foo::Foo() : // variable initialization here
{
  ...
}
//-----------------------------------------------------------------------------
Foo::~Foo()
{
  // Do nothing
}
//-----------------------------------------------------------------------------
```

--------------------------------

### Configure Boundary Conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/elastodynamics/demo_elastodynamics.py.html

Marks boundary subdomains and applies Dirichlet boundary conditions.

```python
# Create mesh function over the cell facets
boundary_subdomains = MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
boundary_subdomains.set_all(0)
force_boundary = AutoSubDomain(right)
force_boundary.mark(boundary_subdomains, 3)

# Define measure for boundary condition integral
dss = ds(subdomain_data=boundary_subdomains)

# Set up boundary condition at left end
zero = Constant((0.0, 0.0, 0.0))
bc = DirichletBC(V, zero, left)
```

--------------------------------

### Define trial and test functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/mixed-poisson/demo_mixed-poisson.py.rst.txt

Initialize trial and test functions for the mixed function space W.

```python
# Define trial and test functions
(sigma, u) = TrialFunctions(W)
(tau, v) = TestFunctions(W)
```

--------------------------------

### Define boundary conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Sets up Dirichlet boundary conditions for velocity on specific parts of the domain boundary.

```python
# Boundaries
def right(x, on_boundary): return x[0] > (1.0 - DOLFIN_EPS)
def left(x, on_boundary): return x[0] < DOLFIN_EPS
def top_bottom(x, on_boundary):
    return x[1] > 1.0 - DOLFIN_EPS or x[1] < DOLFIN_EPS

# No-slip boundary condition for velocity
noslip = Constant((0.0, 0.0, 0.0))
bc0 = DirichletBC(W.sub(0), noslip, top_bottom)

# Inflow boundary condition for velocity
inflow = Expression(("-sin(x[1]*pi)", "0.0", "0.0"), degree=2)
bc1 = DirichletBC(W.sub(0), inflow, right)
```

--------------------------------

### Compute and Save Solution

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/neumann-poisson/demo_neumann-poisson.py.rst.txt

Computes the solution using the defined forms and exports the result to a VTK file.

```python
# Compute solution
w = Function(W)
solve(a == L, w)
(u, c) = w.split()

# Save solution in VTK format
file = File("neumann_poisson.pvd")
file << u
```

--------------------------------

### Check PETSc and SLEPc availability

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/eigenvalue/demo_eigenvalue.py.rst.txt

Verify that the required linear algebra backends are configured before proceeding with eigenvalue computations.

```python
import matplotlib.pyplot as plt
from dolfin import *
# Test for PETSc and SLEPc

if not has_linear_algebra_backend("PETSc"):
    print("DOLFIN has not been configured with PETSc. Exiting.")
    exit()

if not has_slepc():
    print("DOLFIN has not been configured with SLEPc. Exiting.")
    exit()
```

--------------------------------

### Initialize FFC default parameters

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_modules/dolfin/parameter.html

Retrieves default FFC parameters and adds them to the global parameter set if not already present.

```python
[docs]def ffc_default_parameters():
    """Get default parameters of FFC"""
    # Get dict with defaults

    # FIXME: intialising MPI because setting parameters makes MPI
    # calls, possibly via the log systems. Needs to be fixed.
    cpp.MPI.init()

    d = default_jit_parameters()
    p = Parameters("form_compiler")

    typemap = {"quadrature_rule": "", "quadrature_degree": 0,
               "precision": 0}

    # Add the rest
    for key, value in d.items():
        if value is None:
            p.add(key, typemap[key])
            p[key] = None
        else:
            p.add(key, value)

    return p



# Add form compiler parameters to global parameter set
if not parameters.has_parameter_set("form_compiler"):
    parameters.add(ffc_default_parameters())
```

--------------------------------

### Execute Time-Stepping Loop

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Advances the solver in time and saves the solution to a PVD file.

```python
# Output file
file = File("output.pvd", "compressed")

# Step in time
t = 0.0
T = 50*dt
while (t < T):
    t += dt
    u0.vector()[:] = u.vector()
    solver.solve(problem, u.vector())
    file << (u.split()[0], t)
```

--------------------------------

### Define Nedelec Function Space and Eigenvalues

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/maxwell-eigenvalues/demo_maxwell-eigenvalues.py.rst.txt

Sets up the Nedelec function space and computes eigenvalues with Dirichlet boundary conditions.

```python
    nedelec_V   = FunctionSpace(mesh, "N1curl", 1)
    nedelec_bcs = [DirichletBC(nedelec_V, Constant((0.0, 0.0)), DomainBoundary())]
    nedelec_eig = eigenvalues(nedelec_V, nedelec_bcs)
```

--------------------------------

### Perform Local Projection

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Project fields element-wise using LocalSolver.

```python
 def local_project(v, V, u=None):
     """Element-wise projection using LocalSolver"""
     dv = TrialFunction(V)
     v_ = TestFunction(V)
     a_proj = inner(dv, v_)*dx
     b_proj = inner(v, v_)*dx
     solver = LocalSolver(a_proj, b_proj)
     solver.factorize()
     if u is None:
         u = Function(V)
         solver.solve_local_rhs(u)
         return u
     else:
         solver.solve_local_rhs(u)
         return
```

--------------------------------

### Visualize Simulation Results

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Plots tip displacement and energy evolution over time using matplotlib.

```python
if MPI.comm_world.size == 1:
    # Plot tip displacement evolution
    plt.figure()
    plt.plot(time, u_tip)
    plt.xlabel("Time")
    plt.ylabel("Tip displacement")
    plt.ylim(-0.5, 0.5)
    plt.show()

if (MPI.comm_world.rank == 0):
    # Plot energies evolution
    plt.figure()
    plt.plot(time, energies)
    plt.legend(("elastic", "kinetic", "damping", "total"))
    plt.xlabel("Time")
    plt.ylabel("Energies")
    plt.ylim(0, 0.0011)
    plt.show()
```

--------------------------------

### Define Mesh and Source Terms

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/biharmonic/demo_biharmonic.py.rst.txt

Initializes cell diameter, facet normals, and source terms for the biharmonic problem.

```python
# Define normal component, mesh size and right-hand side
h = CellDiameter(mesh)
h_avg = (h('+') + h('-'))/2.0
n = FacetNormal(mesh)
f = Source(degree=2)

# Penalty parameter
alpha = Constant(8.0)
```

--------------------------------

### Define Boundary Conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/stokes-iterative/demo_stokes-iterative.py.html

Sets up no-slip and inflow Dirichlet boundary conditions for the velocity component of the mixed function space.

```python
# Boundaries
def right(x, on_boundary): return x[0] > (1.0 - DOLFIN_EPS)
def left(x, on_boundary): return x[0] < DOLFIN_EPS
def top_bottom(x, on_boundary):
    return x[1] > 1.0 - DOLFIN_EPS or x[1] < DOLFIN_EPS

# No-slip boundary condition for velocity
noslip = Constant((0.0, 0.0, 0.0))
bc0 = DirichletBC(W.sub(0), noslip, top_bottom)

# Inflow boundary condition for velocity
inflow = Expression(("-sin(x[1]*pi)", "0.0", "0.0"), degree=2)
bc1 = DirichletBC(W.sub(0), inflow, right)

# Collect boundary conditions
bcs = [bc0, bc1]
```

--------------------------------

### Set Material and Damping Parameters

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/elastodynamics/demo_elastodynamics.py.html

Configures elastic constitutive relations, density, and Rayleigh damping coefficients.

```python
# Elastic parameters
E  = 1000.0
nu = 0.3
mu    = Constant(E / (2.0*(1.0 + nu)))
lmbda = Constant(E*nu / ((1.0 + nu)*(1.0 - 2.0*nu)))

# Mass density
rho = Constant(1.0)

# Rayleigh damping coefficients
eta_m = Constant(0.)
eta_k = Constant(0.)
```

--------------------------------

### Creating boundary condition

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/biharmonic/demo_biharmonic.py.rst.txt

Instantiating the Dirichlet boundary condition using the defined domain.

```python
# Define boundary condition
u0 = Constant(0.0)
bc = DirichletBC(V, u0, DirichletBoundary())
```

--------------------------------

### Configuring form compiler

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/biharmonic/demo_biharmonic.py.rst.txt

Setting optimization parameters for the FEniCS form compiler.

```python
# Optimization options for the form compiler
parameters["form_compiler"]["cpp_optimize"] = True
parameters["form_compiler"]["optimize"] = True
```

--------------------------------

### Defining trial and test functions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/biharmonic/demo_biharmonic.py.rst.txt

Creating trial and test functions on the finite element space V.

```python
# Define trial and test functions
u = TrialFunction(V)
v = TestFunction(V)
```

--------------------------------

### Defining function spaces

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/nonmatching-interpolation/demo_nonmatching-interpolation.py.rst.txt

Sets up linear Lagrange elements on the coarse mesh and cubic Lagrange elements on the fine mesh.

```python
P1 = FunctionSpace(mesh0, "Lagrange", 1)
P3 = FunctionSpace(mesh1, "Lagrange", 3)
```

--------------------------------

### Define Vector Lagrange Space and Boundary Conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/demos/maxwell-eigenvalues/demo_maxwell-eigenvalues.py.html

Sets up a vector Lagrange function space and applies Dirichlet boundary conditions to specific components on mesh edges.

```python
#
    lagrange_V   = VectorFunctionSpace(mesh, "Lagrange", 1)
    lagrange_bcs = [DirichletBC(lagrange_V.sub(1), 0, "near(x[0], 0) || near(x[0], pi)"),
                    DirichletBC(lagrange_V.sub(0), 0, "near(x[1], 0) || near(x[1], pi)")]
    lagrange_eig = eigenvalues(lagrange_V, lagrange_bcs)
```

--------------------------------

### Configure Boundary Conditions and Measures

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Marks boundaries using a MeshFunction and defines the exterior surface measure and Dirichlet boundary conditions.

```python
# Create mesh function over the cell facets
 boundary_subdomains = MeshFunction("size_t", mesh, mesh.topology().dim() - 1)
 boundary_subdomains.set_all(0)
 force_boundary = AutoSubDomain(right)
 force_boundary.mark(boundary_subdomains, 3)

 # Define measure for boundary condition integral
 dss = ds(subdomain_data=boundary_subdomains)

 # Set up boundary condition at left end
 zero = Constant((0.0, 0.0, 0.0))
 bc = DirichletBC(V, zero, left)
```

--------------------------------

### Format code blocks

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/styleguide_cpp.rst.txt

Use BSD/Allman style for curly brackets.

```c++
for (std::size_t i = 0; i < 10; i++)
{
  ...
}
```

--------------------------------

### Define Lagrange Function Space and Eigenvalues

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/maxwell-eigenvalues/demo_maxwell-eigenvalues.py.rst.txt

Sets up the vector Lagrange function space with specific component-wise boundary conditions.

```python
    lagrange_V   = VectorFunctionSpace(mesh, "Lagrange", 1)
    lagrange_bcs = [DirichletBC(lagrange_V.sub(1), 0, "near(x[0], 0) || near(x[0], pi)"),
                    DirichletBC(lagrange_V.sub(0), 0, "near(x[1], 0) || near(x[1], pi)")]
    lagrange_eig = eigenvalues(lagrange_V, lagrange_bcs)
```

--------------------------------

### BoxMesh.create

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_autogenerated/dolfin.cpp.generation.html

Creates a BoxMesh instance.

```APIDOC
## BoxMesh.create

### Description
Creates a 3D box mesh defined by points and cell counts.

### Signature
- create(p: List[dolfin::Point[2]], n: List[int[3]], cell_type: dolfin.cpp.mesh.CellType.Type) -> dolfin.cpp.mesh.Mesh
- create(comm: MPICommWrapper, p: List[dolfin::Point[2]], n: List[int[3]], cell_type: dolfin.cpp.mesh.CellType.Type) -> dolfin.cpp.mesh.Mesh
```

--------------------------------

### Create Mesh and Function Space

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/hyperelasticity/demo_hyperelasticity.py.rst.txt

Initializes a unit cube mesh and a vector function space for displacement fields.

```python
# Create mesh and define function space
mesh = UnitCubeMesh(24, 16, 16)
V = VectorFunctionSpace(mesh, "Lagrange", 1)
```

--------------------------------

### Setting Error Tolerance and Solving

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/auto-adaptive-poisson/demo_auto-adaptive-poisson.py.rst.txt

Configures the adaptive solver with a specified error tolerance and executes the solution process.

```python
# Define error tolerance
tol = 1.e-5

# Solve equation a = L with respect to u and the given boundary
# conditions, such that the estimated error (measured in M) is less
# than tol
problem = LinearVariationalProblem(a, L, u, bc)
solver = AdaptiveLinearVariationalSolver(problem, M)
solver.parameters["error_control"]["dual_variational_solver"]["linear_solver"] = "cg"
solver.parameters["error_control"]["dual_variational_solver"]["symmetric"] = True
solver.solve(tol)

solver.summary()
```

--------------------------------

### Define Cahn-Hilliard model parameters

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Set physical and numerical parameters including surface tension, time step, and the time-stepping scheme.

```python
# Model parameters
lmbda  = 1.0e-02  # surface parameter
dt     = 5.0e-06  # time step
theta  = 0.5      # time stepping family, e.g. theta=1 -> backward Euler, theta=0.5 -> Crank-Nicolson
```

--------------------------------

### Convert to Backend Type

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_modules/dolfin/la.html

Returns the underlying backend instance for Matrix, Vector, or LinearOperator types.

```python
def as_backend_type(x):
    """Return Matrix and Vector backend instance. Not required for other
    types as pybind11 automatically downcasts objects to the derived
    type.

    """
    if isinstance(x, cpp.la.Vector) or isinstance(x, cpp.la.Matrix) or isinstance(x, cpp.la.LinearOperator):
        return x.instance()
    else:
        return x
```

--------------------------------

### Execute Time Loop

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/elastodynamics/demo_elastodynamics.py.rst.txt

Iterate through time steps to solve the system and update fields.

```python
 for (i, dt) in enumerate(np.diff(time)):
 
     t = time[i+1]
     print("Time: ", t)

     # Forces are evaluated at t_{n+1-alpha_f}=t_{n+1}-alpha_f*dt
     p.t = t-float(alpha_f*dt)

     # Solve for new displacement
     res = assemble(L_form)
     bc.apply(res)
     solver.solve(K, u.vector(), res)


     # Update old fields with new quantities
     update_fields(u, u_old, v_old, a_old)
```

--------------------------------

### Interpolate initial conditions

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Initialize the solution functions by interpolating from a defined initial condition class.

```python
# Create intial conditions and interpolate
u_init = InitialConditions(degree=1)
u.interpolate(u_init)
u0.interpolate(u_init)
```

--------------------------------

### Set Solver Spectrum Parameters

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/maxwell-eigenvalues/demo_maxwell-eigenvalues.py.rst.txt

Configures the solver to target specific eigenvalues using shift-and-invert transformation.

```python
#
    solver.parameters["spectrum"] = "target magnitude"
    solver.parameters["spectral_transform"] = "shift-and-invert"
    solver.parameters["spectral_shift"] = 5.5
    neigs = 12
    solver.solve(neigs)
```

--------------------------------

### Configuring form compiler optimization

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/hyperelasticity/demo_hyperelasticity.py.rst.txt

Sets FFC parameters to enable C++ optimization and use the UFLACS representation backend.

```python
# Optimization options for the form compiler
parameters["form_compiler"]["cpp_optimize"] = True
parameters["form_compiler"]["representation"] = "uflacs"
```

--------------------------------

### Assemble Linear System

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/singular-poisson/demo_singular-poisson.py.rst.txt

Assemble the coefficient matrix A and the right-hand side vector b.

```python
# Assemble system
A = assemble(a)
b = assemble(L)
```

--------------------------------

### Define variational problem

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/stokes-iterative/demo_stokes-iterative.py.rst.txt

Set up the trial and test functions and the bilinear and linear forms for the Stokes equations.

```python
# Define variational problem
(u, p) = TrialFunctions(W)
(v, q) = TestFunctions(W)
f = Constant((0.0, 0.0, 0.0))
a = inner(grad(u), grad(v))*dx + div(v)*p*dx + q*div(u)*dx
L = inner(f, v)*dx
```

--------------------------------

### Configure form compiler options

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/cahn-hilliard/demo_cahn-hilliard.py.rst.txt

Enable optimization flags for the form compiler to improve performance during code generation and execution.

```python
# Form compiler options
parameters["form_compiler"]["optimize"]     = True
parameters["form_compiler"]["cpp_optimize"] = True
```

--------------------------------

### Solve and Plot

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/singular-poisson/demo_singular-poisson.py.rst.txt

Solve the linear system and visualize the resulting solution.

```python
solver.solve(u.vector(), b)

plot(u)
plt.show()
```

--------------------------------

### Handle Null Space

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/demos/singular-poisson/demo_singular-poisson.py.rst.txt

Create a basis for the null space and attach it to the matrix A to handle singular systems.

```python
# Create vector that spans the null space and normalize
null_vec = Vector(u.vector())
V.dofmap().set(null_vec, 1.0)
null_vec *= 1.0/null_vec.norm("l2")

# Create null space basis object and attach to PETSc matrix
null_space = VectorSpaceBasis([null_vec])
as_backend_type(A).set_nullspace(null_space)
```

--------------------------------

### Comment code

Source: https://olddocs.fenicsproject.org/dolfin/2019.1.0/python/_sources/styleguide_cpp.rst.txt

Use // for comments and /// for documentation.

```c++
// Check if connectivity has already been computed
if (connectivity.size() > 0)
  return;

// Invalidate ordering
mesh._ordered = false;

// Compute entities if they don't exist
if (topology.size(d0) == 0)
  compute_entities(mesh, d0);
if (topology.size(d1) == 0)
  compute_entities(mesh, d1);

// Check if connectivity still needs to be computed
if (connectivity.size() > 0)
  return;

...
```
Tokens:
Raw