Interpolation from 1D to 2D in dolfinx

dolfinx
1

Hi, if I have two functions f2D and f1D that are defined in 2D and 1D meshes respectively, and I want to interpolate f1D to f2D such that:

f2D(x,y) = f1D(x)

In the old fenics, we can simply use the Lagrange interpolator, but in the dolfinx, it seems like the Lagrange interpolator is removed
If I do:
f2D->interplolate(f1D),
I only get f2D(x,y) = f1D(x) when y=0, which means I only get a line, and the rest of the domain is emply.
Is there any functions that I can try?
BTW, in my case, the 2D mesh is [0,L] * [-v,v] and the 1D mesh is [0,L]

Thanks very much!

2

More details: my 1D mesh and 2D mesh will always be match, like this:
Screenshot from 2024-01-12 17-09-10
so it is more like I want to “paste” a 1D function into the 2D grid, maybe it is not that efficient to use interpolate?

3

Will you only work with Lagrange elements (and of what degree)? Will they be vector elements, tensor elements, or something else?

4

Yes I only work with CG, scalar value element, but the degree can be differ (1D and 2D function spaces will always have the same degree)

5

Here is a code that runs in serial.
Would have to think a bit more carefully about this to get it to work in parallel:

import dolfinx
from mpi4py import MPI
import basix.ufl
import numpy as np

mesh = dolfinx.mesh.create_unit_square(MPI.COMM_WORLD, 3, 3, ghost_mode=dolfinx.mesh.GhostMode.shared_facet)
el = basix.ufl.element("Lagrange", mesh.topology.cell_name(), 2)


V = dolfinx.fem.functionspace(mesh, el)
u = dolfinx.fem.Function(V)

import numpy as np
def lower_edge(x):
    return np.isclose(x[1], 0)

entities = dolfinx.mesh.locate_entities_boundary(mesh, mesh.topology.dim-1, lower_edge)
sub_mesh, _,_,_ = dolfinx.mesh.create_submesh(mesh, mesh.topology.dim-1, entities)
sub_el = basix.ufl.element("Lagrange", sub_mesh.topology.cell_name(), 2, gdim=sub_mesh.geometry.dim)
V_sub = dolfinx.fem.functionspace(sub_mesh, sub_el)
u_sub = dolfinx.fem.Function(V_sub)
u_sub.interpolate(lambda x: np.sin(x[0]+0.1))

parent_coords = V.tabulate_dof_coordinates()
sub_coords = V_sub.tabulate_dof_coordinates()

def sub_to_parent(x):
    indices = np.asarray([np.flatnonzero(np.isclose(sub_coords.T[0], xi))[0] for xi in x[0]], dtype=np.int32)
    return u_sub.x.array[indices]
u.interpolate(sub_to_parent)

with dolfinx.io.VTKFile(mesh.comm, "mesh.pvd", "w") as vtk:
    vtk.write_mesh(mesh)
    vtk.write_function(u)