As you may recall from my last post, for DirichletBC to work in parallel runs I had to implement a new class, meshfunction. However it was still quite unfinished, with no way for the user to create one, except extracting it from a mesh produced by the

At this link you can find a detailed explanation of the problem. It is a Poisson equation with variable diffusion coefficient on the unit square. Precisely, on [0.2, 1]x[0.5, 0.7] its value is 0.01, otherwise it is 1. The mentioned subset is the obstacle to diffusion, so we study its effect applying

In the beginning there is the now familiar ufl block. As you might have noticed, subscripted measures appear in the definition of the bilinear form

After defining the problem in UFL language, there are instructions to define the mesh, the function space, the essential boundary conditions and all the coefficients involved. All such lines come from fem-fenics before this summer or have been described in my previous posts, so I will not cover them in detail. The same applies for the assembly, solve and all the output in the end of the script. The only note is that the very last lines will error out in parallel runs: point-wise evaluations in

In between there are my latest efforts. At first, the brand new MeshFunction. With this, providing a mesh and a file name you can import a dolfin::MeshFunction. In this case it was saved in the XDMF format, here you can find the files needed to execute the script. DOLFIN uses this format for parallel input/output. It comprises a .h5 file storing data and a .xdmf with metadata useful to read the other one. The optional first argument is a string identifying the role of the returned meshfunction in the variational problem. In this case, with "dx" it will be searched for markers of the integrals on cells. All the previously mentioned measures are available, and "ds" is automatically attached to the meshfunction returned by Mesh. In the example this behaviour is exploited for the measure on edges.

Afterwards, the mesh functions are passed as arguments to BilinearForm and LinearForm, so that the markers are available to assemble the system. In addition to the usual parameters, such as the name of the imported UFL problem, the function spaces and the coefficients, it is now possible to provide mesh functions properly labeled and they will be used.

Currently fem-fenics allows for easily marking subdomains and exterior edges copying markers from the PDEtool representation returned by the functions of the

**msh**package, no description to display, no way to save it. These days I have been tackling this issue: while at it I wondered what one could do with meshfunction and found out that they can come in handy when you are dealing with obstacles.At this link you can find a detailed explanation of the problem. It is a Poisson equation with variable diffusion coefficient on the unit square. Precisely, on [0.2, 1]x[0.5, 0.7] its value is 0.01, otherwise it is 1. The mentioned subset is the obstacle to diffusion, so we study its effect applying

*u*= 0 on the*y*= 0 edge and*u*= 5 on*y*= 1. Here is the**fem-fenics**code:```
pkg load fem-fenics msh
```

ufl start Subdomains

ufl fe = FiniteElement "(""CG"", triangle, 2)"

ufl u = TrialFunction (fe)

ufl v = TestFunction (fe)

ufl

ufl a0 = Coefficient (fe)

ufl a1 = Coefficient (fe)

ufl g_L = Coefficient (fe)

ufl g_R = Coefficient (fe)

ufl f = Coefficient (fe)

ufl

ufl a = "inner(a0*grad (u), grad (v))*dx(0) + inner(a1*grad (u), grad (v))*dx(1)"

ufl L = g_L*v*ds(1) + g_R*v*ds(3) + f*v*dx(0) + f*v*dx(1)

ufl end

# Create mesh and define function space

x = y = linspace (0, 1, 65);

[msh, facets] = Mesh (msh2m_structured_mesh (x, y, 0, 4:-1:1));

V = FunctionSpace ("Subdomains", msh);

# Define boundary conditions

bc1 = DirichletBC (V, @(x, y) 5.0, facets, 2);

bc2 = DirichletBC (V, @(x, y) 0.0, facets, 4);

# Define problem coefficients

a0 = Constant ("a0", 1.0);

a1 = Constant ("a1", 0.01);

g_L = Expression ("g_L", @(x, y) - 10*exp(- (y - 0.5) ^ 2));

g_R = Constant ("g_R", 1.0);

f = Constant ("f", 1.0);

# Define subdomains

domains = MeshFunction ("dx", msh, "cells.xdmf");

# Define variational form

a = BilinearForm ("Subdomains", V, V, a0, a1, domains);

L = LinearForm ("Subdomains", V, g_L, g_R, f, facets, domains);

# Assemble system

[A, b] = assemble_system (a, L, bc1, bc2);

sol = A \ b;

u = Function ("u", V, sol);

# Save solution in VTK format

save (u, "subdomains");

# Plot solution

[X, Y] = meshgrid (x, y);

U = u (X, Y);

surf (X, Y, U);

In the beginning there is the now familiar ufl block. As you might have noticed, subscripted measures appear in the definition of the bilinear form

*a*and of the linear functional*L*. This is UFL notation for the integration on specific subsets of the computational domain. For instance, dx(1) is an integral over the subdomain marked with label 1, while ds(3) is an integral over the exterior edges marked with label 3. A third possibility, even if not used in this example, is to use dS for integrals on interior facets, which could be of use for interior penalty methods. Going back to the example, you can see that markers are used to enforce non-homogeneous Neumann conditions on the side edges and to assign the proper coefficient on the two subdomains.After defining the problem in UFL language, there are instructions to define the mesh, the function space, the essential boundary conditions and all the coefficients involved. All such lines come from fem-fenics before this summer or have been described in my previous posts, so I will not cover them in detail. The same applies for the assembly, solve and all the output in the end of the script. The only note is that the very last lines will error out in parallel runs: point-wise evaluations in

**DOLFIN**can be performed only on local cells, but with meshgrid we are providing to every process the whole domain.The computed solution |

Afterwards, the mesh functions are passed as arguments to BilinearForm and LinearForm, so that the markers are available to assemble the system. In addition to the usual parameters, such as the name of the imported UFL problem, the function spaces and the coefficients, it is now possible to provide mesh functions properly labeled and they will be used.

Currently fem-fenics allows for easily marking subdomains and exterior edges copying markers from the PDEtool representation returned by the functions of the

**msh**package, which makes it quite tricky to properly identify the obstacle in the example. The approach used in the python interface to DOLFIN entails subclassing dolfin::Subdomain with the proper implementation of the inside method, then use an object of the derived class to mark a dolfin::MeshFunction. This could be an interesting feature to implement in the future also in fem-fenics.
## No comments:

## Post a Comment