Move authors from #Spatially varying load to the top

Some typos can be found in chapter2/ns_code1.html.

1. bewteen -> between
2. accross -> across
3. viscity -> viscosity
4. 
5. 
6. 
7. 
8. u=(0,0,0) on the walls y = 0.1. -> u=(0,0,0) on the walls y = 0, 1.
9. i n 2D or 3D -> in 2D or 3D
10. betwen -> between
11. differnent -> different
12. oposed -> opposed
13. createing -> creating
14. spacces -> spaces
15. spacecs -> spaces
16. methids -> methods
17. } Since we have two different function spaces,-> Since we have two different function spaces,
18. elasticty -> elasticity
19. myltigrid -> multigrid
20. u is the known -> u is unknown
21. convetion -> convention

How to project a ufl.Product into an appropriate function space

I wonder that where the ufl.Product is used.

Permute topology data from MSH-ordering to dolfinx-ordering

Here, G is missing.

Re-use convenience code from my webpage: http://jsdokken.com/converted_files/tutorial_pygmsh.html#second

Derive a priori solution of the problem from known strain potential

Relevant once FEniCS/dolfinx#1478 is merged

Ref: https://bitbucket.org/fenics-project/ufl/issues/40/make-quadrature-scheme-and-degree-a-native
Looks cleaner

In the text, it says

and h is the circumradius of the mesh element

In the code, it says

h = 2 * Circumradius(mesh)

I think that the text should say

h is the diameter of the circumscribed sphere of the mesh element

In the first demo, the function dolfinx.mesh.compute_boundary_facets is said to return an array of booleans where it seems to return 0 or 1. Should it be fixed? or is it something I got wrong?

... using dolfinx.mesh.compute_boundary_facets. This function returns an array of booleans of the same size as the number of facets on this processor, where True indicates that the local facet is on the boundary

Thanks for the tutorial!

For a second-order elliptic equation of the form, the third term is a mixed partial derivative

I have figured out how to use fenics to solve the Laplace equation where the grid region is a unit circle, but I now have a problem when there are mixed partial derivatives. I have tried converting the above equation to canonical form, but this will affect the solution area changing, no longer a canonical circular area. I would like to ask how to deal with this item in fenics? Is there a corresponding solution? thanks.

Relevant for the von Mises stresses on page /chapter2/linearelasticity_code.html

Revise usage of Constant

In the subsection Forming and solving the linear system, the link PETSc-documentation is missing, i.e., the page says 404 error! The page you're looking for could not be found!.

Hi @jorgensd,

Although a pretty minor detail, but isn't scatter_forward repeated in the Nonlinear poisson tutorial at the end? NewtonSolver.solve() automatically applies scatter_forward to the solution, as I can see here?

On another note, do you feel that adding an example on, say, implementing the Newton's method by hand would add value to tutorial? This could be illustrative in use cases where one needs to implement their own nonlinear solve? Something like this for the nonlinear poisson

from ufl import TrialFunction, derivative
Jac = derivative(F, uh, TrialFunction(V))

bilinear_form = fem.form(Jac)
linear_form = fem.form(-F)

du = fem.Function(V, name="incr_u")

bilinf = fem.assemble.create_matrix(bilinear_form)
linf = fem.assemble.create_vector(linear_form)

# zero the entries
bilinf.zeroEntries()

fem.assemble_matrix(bilinf, bilinear_form, bcs=bcs)
bilinf.assemble()

with linf.localForm() as loc:
    loc.set(0.)

fem.assemble_vector(linf, linear_form)

fem.apply_lifting(linf, [bilinear_form], [bcs])
linf.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.set_bc(linf, bcs)

res_0 = linf.norm()
res = res_0
print(f"Initial residual norm: {res_0}")
solver = PETSc.KSP().create(mesh.comm)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(bilinf)
solver.solve(linf, du.vector)
du.x.scatter_forward()
uh.vector.axpy(1.0, du.vector)
iters = 0
maxIter = 30

while res/res_0 > 1.e-8 and iters < maxIter:

    
    bilinf.zeroEntries()
    fem.assemble_matrix(bilinf, bilinear_form, bcs=bcs_hom)
    bilinf.assemble()

    with linf.localForm() as loc:
        loc.set(0.)

    fem.assemble_vector(linf, linear_form)
    fem.apply_lifting(linf, [bilinear_form], [bcs_hom])
    linf.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
    fem.set_bc(linf, bcs_hom)
    solver.setOperators(bilinf)
    solver.solve(linf, du.vector)
    du.x.scatter_forward()
    uh.vector.axpy(1.0, du.vector)
    res = linf.norm()
    print(f"norm: {res}")
    iters += 1

instead of the call to NewtonSolver.

There are some parts that seem to be typographical errors, so please check them.

1. 

2. 

3. 
   -->
   

4. 
   -->
   

5. We not that --> We note that

6. probles --> problems

Hi. When I was try to run the command

mpirun -n 2 python3 t1.py

I received the message

AttributeError: module 'dolfinx.mesh' has no attribute 'create_unit_square'

I didn't find the create_unit_square function in the module dolfinx.

While trying to run the diffusion problem on a jupyter notebook,
I found myself unable to generate the assembly matrix for the bilinear form.
The code is pasted from the fenics website.
The returned error is "ArityMissmatch: Failure to conjugate test function in complex Form".
But the equation given is correct.

Change addCircle to addDisk to simplify mesh generation code

Something along the lines of:

import dolfinx
from mpi4py import MPI
import os
import time
import ufl
from pathlib import Path
N = 3
mesh = dolfinx.UnitCubeMesh(MPI.COMM_WORLD, N, N, N)
V = dolfinx.FunctionSpace(mesh, ("CG", 3))
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx

cache_dir = f"{str(Path.cwd())}/.cache"


def compile_form(a, jit_parameters):
    os.system(f"rm -rf {jit_parameters['cache_dir']}")
    a_ = dolfinx.fem.Form(a, jit_parameters=jit_parameters)
    start = time.time()
    dolfinx.fem.assemble_matrix(a_)
    end = time.time()
    print(f"Assemble matrix {jit_parameters['cffi_extra_compile_args']}: {end-start}")
    os.system(f"rm -rf {jit_parameters['cache_dir']}")


compile_form(a, jit_parameters={"cffi_extra_compile_args": [
             "-Ofast", "-march=native"], "cache_dir": cache_dir + "native", "cffi_libraries": ["m"], "cffi_verbose": False})

compile_form(a, jit_parameters={"cffi_extra_compile_args": [
             "-Ofast"], "cache_dir": cache_dir, "cffi_libraries": ["m"], "cffi_verbose": False})
compile_form(a, jit_parameters={"cffi_extra_compile_args": [
             "-O2", "-march=native"], "cache_dir": cache_dir + "native", "cffi_libraries": ["m"], "cffi_verbose": False})

compile_form(a, jit_parameters={"cffi_extra_compile_args": [
             "-O2"], "cache_dir": cache_dir, "cffi_libraries": ["m"], "cffi_verbose": False})
compile_form(a, jit_parameters={"cffi_extra_compile_args": [
             "-O3", "-march=native"], "cache_dir": cache_dir + "native", "cffi_libraries": ["m"], "cffi_verbose": False})

compile_form(a, jit_parameters={"cffi_extra_compile_args": [
             "-O3"], "cache_dir": cache_dir, "cffi_libraries": ["m"], "cffi_verbose": False})

It seems that code block in fundamentals_code related to the L2 error computation is mislocated.

Additionally, if there's a First, we compute..., there should probably be Second, we compute....

Hi,
I think there may be a typo in equation 2, where trial and test space are defined, in the tutorial Solving the Poisson equation

V should contain the variable u, not v.
Bye,
Giovanni

Update how to set 0 values to u_D without using ghostUpdate.

Makes code more readable

Create the matrix and and vector for the linear problem

Double and here.

Verifying the numerical solution

Are the errors given here the L2 error and the maximum error at the last moment?

This book is distributed under the terms of the Creative Commons Attribution 4.0International License (http://creativecommons.org/licenses/by/4.0/), which permits use, duplication,adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license and indicate if changes were made.

The images or other third party material in this book are included in the work’s Creative Commons license, unless indicated otherwise in the credit line; if such material is not included in the work’s Creative Commons license and the respective action is not permitted by statutory regulation, users will need to obtain permission from the license holder to duplicate, adapt or reproduce the material.The use of general descriptive names, registered names, trademarks, service marks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use.

These problems illustrate howt o solve time-dependent problems

Small spelling errors in words.

I have the following error when running the test case:

Traceback (most recent call last):
File ".py", line 16, in
from dolfinx.mesh import CellType, create_box, locate_entities_boundary
ImportError: cannot import name 'CellType' from 'dolfinx.mesh' (/spack/var/spack/environments/fenicsx-env/.spack-env/view/lib/python3.9/site-packages/dolfinx/mesh.py)

I have also tried "from dolfinx import " instead, but it stuck again as follows:
Traceback (most recent call last):
File "**.py", line 18, in
mesh = create_box(MPI.COMM_WORLD, [np.array([0,0,0]), np.array([L, W, W])],
NameError: name 'create_box' is not defined

The version of code I am using is FEniCSX/dolfinX-0.3.0

Hello,

Just a nit: in the create_mesh() helper (taken from https://jorgensd.github.io/dolfinx-tutorial/chapter3/subdomains.html#convert-msh-files-to-xdmf-using-meshio), I believe points should be passed to the meshio.Mesh() constructor if one wants prune_z to work

import meshio
def create_mesh(mesh, cell_type, prune_z=False):
    cells = mesh.get_cells_type(cell_type)
    cell_data = mesh.get_cell_data("gmsh:physical", cell_type)
    points = mesh.points[:,:2] if prune_z else mesh.points
    out_mesh = meshio.Mesh(points=mesh.points, cells={cell_type: cells}, cell_data={"name_to_read":[cell_data]}) # <-- here, should be points=points
    return out_mesh

Thanks for these great tutorials !

I had bad time figuring out how to correctly write component-wise Dirichlet BCs.
I was not able to find an example in the tutorial (maybe this is my fault).
I think that adding something more explicit would be useful, like here

Hi @jorgensd, thanks for the huge work done for the FEniCSx. As one of the many users of FEniCS/FEniCSx, I really think at least two points of FEniCSx are attracting: (1) convenience for solving PDEs and (2) the high computational efficiency based on parallel computation. I think the first point is already well illustrated in this tutorial. However, it would be better to illustrate the computational efficiency of FEniCSx versus other software such as Matlab.

Should use:

    bndry_facets = np.where(np.array(cpp.mesh.compute_boundary_facets(mesh.topology)) == 1)[0]

In every place where we have the full boundary as BC. Expose locate_entities_boundary in a later demo

Add list of supported elements when this becomes available

I am trying to evaluate function in parallel like demonstrated in Chapter 1 of the tutorial and, then, Gatherv on rank 0

    bbox_tree = dolfinx.geometry.BoundingBoxTree(mesh, mesh.geometry.dim)

    pts = np.vstack(np.meshgrid(xx, yy, [z])).reshape(3, -1).T
    cells = []
    pts_on_proc = []
    for pt in pts:
        cell_candidates = dolfinx.geometry.compute_collisions_point(
            bbox_tree, pt)
        cell = dolfinx.geometry.select_colliding_cells(
            mesh, cell_candidates, pt, 1)
        if len(cell) == 1:
            pts_on_proc.append(pt)
            cells.append(cell[0])

    q_vals_on_proc = Q.eval(pts_on_proc, cells)

    val_counts = np.array(
        MPI.COMM_WORLD.gather(q_vals_on_proc.size, root=0))

    if MPI.COMM_WORLD.rank == 0:
        q_vals = np.empty(sum(val_counts), dtype=np.float64)
    else:
        q_vals = None

    MPI.COMM_WORLD.Gatherv(sendbuf=q_vals_on_proc, recvbuf=(
        q_vals, val_counts), root=0)

Eventually I end up with more values than grid points. This makes me think that GhostMode.shared_facet leads to a given point residing on multiple ranks. Is it a bug or intended behavior?

Maths rendered incorrectly

As dolfinx has bumped docker, the tutorial has to follow

Wait with revision until final interface is added

Isn't equation (23) missing the multiplication of v? That is:

First, awesome project and great tutorials! Very excited to get this running!

For now, I'm running from the docker image:

docker run -p 8888:8888 dolfinx/lab

I ran into a few issues though: first, pythreejs needed to be installed:

root@b8715fff55a6:~# pip install pythreejs

which I did inside a terminal in the JL interface, after which I could load the library, but then got errors "model cannot be found".

My guess is that the JL instance needs to be restarted after the package is installed, but I'm a bit of a docker noob and cannot figure out how to do this: if I stop the container and restart, there is no persistance of the changes I made...

I'll probably go whole-hog and install things properly in a conda env for now. But I guess probably there is a relatively simple fix in configuring the dolfinx/lab docker image?

Cheers,.
Gary

and the entity tag of the as the second argument

Here, the word membrane is missing.

I get a typeerror in chapter 1 fundamentals_code.ipynb at cell 14:

import dolfinx.plot; topology, cell_types = dolfinx.plot.create_vtk_topology(mesh, mesh.topology.dim)

The error seems to be with the mesh type.

TypeError Traceback (most recent call last)
/tmp/ipykernel_101/4156726744.py in
1 import dolfinx.plot
----> 2 topology, cell_types = dolfinx.plot.create_vtk_topology(mesh, mesh.topology.dim)

/usr/lib/python3.9/functools.py in wrapper(*args, **kw)
875 '1 positional argument')
876
--> 877 return dispatch(args[0].class)(*args, **kw)
878
879 funcname = getattr(func, 'name', 'singledispatch function')

/usr/local/dolfinx-real/lib/python3.8/dist-packages/dolfinx/plot.py in create_vtk_topology(mesh, dim, entities)
76
77 # Array holding the cell type (shape) for each cell
---> 78 e_type = cpp.mesh.cell_entity_type(mesh.topology.cell_type, dim)
79 degree = _element_degree(e_type, geometry_entities.shape[1])
80 if degree == 1:

TypeError: cell_entity_type(): incompatible function arguments. The following argument types are supported:
1. (arg0: dolfinx.cpp.mesh.CellType, arg1: int, arg2: int) -> dolfinx.cpp.mesh.CellType

Invoked with: <CellType.quadrilateral: -4>, 2

Remove usage of AdjacencyList_int32 and instead use dolfinx.graph.create_adjacencylist

Matplotlib is now deprecated, and usage of pyvista should be implemented everywhere

• Fundamentals
• Membrane
• Diffusion
• Linear elasticity
• Subdomain and bc demos

In the next line of equation (26), domain [-2,-2] x [2,2] should be domain [-2,2] x [-2,2] in mathematical terms, right?

There are also typos as follows:

• abd -> and
• # Plot every 20th time step -> # Plot every 15th time step

from ufl import (Circumradius, FacetNormal, SpatialCoordinate, TrialFunction, TestFunction,
                 div, dx, ds, grad, inner, grad)

Is it necessary to import grad twice?

Add reference to https://library.oapen.org/bitstream/handle/20.500.12657/27975/1002024.pdf?sequence=1 section 4.2 in scaling chapter

Mention that C is independent of mesh and therefore $h$

Instead of random off_screen variables everywhere.