Attempting to create a mesh of streamlines returns an empty mesh each time. My mesh is 2D and the cells are 2D as well. #7737

Brotherman-Bi11 · 2025-07-20T09:04:52Z

Brotherman-Bi11
Jul 20, 2025

First check

I added a very descriptive title here.
I used the GitHub search to find a similar question and didn't find it.
I searched the PyVista documentation, with the integrated search.
I already searched in Google "How to X in PyVista" and didn't find any information.
I already read and followed all the tutorial in the docs and didn't find an answer.
I will NOT make duplicate discussions or issues in the future.

Commit to Help

I commit to help with one of those options.

Sample Code What is the problem, question, or error?

Write a short description telling me what you are doing, what you expect to happen, and what is currently happening.

I've created a 2D mesh with 2D cells of shape quadrilateral in which I've computed the vector field `vc`, and when I try to create streamlines out of the vector field, it just returns empty each time. I've tried different start and stop points and different central radii, but it returns empty each time. I don't understand what is wrong with my grid or data.

Description

In the code below, I have created my original mesh as domain in dolfinx with cell type quadrilateral which is 2D, the domain is then used to created a mesh in Pyvista called grid using UnstructuredGrid and dolfinx's vtk_mesh to output the necessary input information, and this was inputted along with the topological dimension of the entities in domain extracted which is 2. In the screenshots section, I added an image showing the dimensionality and type of the cells in grid.

After going through the process of solving for chi, I've subsequently computed the vector quantity vc and put the values stored in this variable inside the grid and then successfully created a mesh of glyphs out of this variable. When attempting to create a mesh of streamlines out of vc, it fails each time.

Below is the entirety of my code, hopefully users here have dolfinx and are able to run this:

from dolfinx import default_scalar_type
from dolfinx.fem import dirichletbc, Expression, Function, functionspace, locate_dofs_topological, Constant, locate_dofs_topological
from dolfinx.fem.petsc import LinearProblem
from dolfinx.io import XDMFFile
from dolfinx.io.gmshio import model_to_mesh
from dolfinx.mesh import compute_midpoints, locate_entities_boundary, create_unit_square, CellType, exterior_facet_indices
from dolfinx.plot import vtk_mesh

from ufl import TestFunction, TrialFunction, as_vector, dot, dx, grad, inner
from mpi4py import MPI

import numpy as np
import pyvista as pv

# Define mesh
import dolfinx as df
N,M = 61, 61
bounds = [[0.0, 0.0], [1.0, 1.0]]
domain = df.mesh.create_rectangle(MPI.COMM_WORLD, bounds, [N, M],cell_type=CellType.quadrilateral)

# Define functionspace for u and s
V = functionspace(domain, ("Lagrange", 1))

# Define BCs
tdim = domain.topology.dim
fdim = domain.topology.dim-1 # Dimension of entities one is mapping to
facets = locate_entities_boundary(domain, tdim - 1, lambda x: np.full(x.shape[1], True))
dofs = locate_dofs_topological(V, tdim - 1, facets)
bc = dirichletbc(default_scalar_type(0), dofs, V)

# Define trial and test functions
u = TrialFunction(V)
s = TestFunction(V)

# Define functionspace for f
Q = functionspace(domain, ("DG",0))

# Define source
f = Constant(domain, default_scalar_type(4))

import ufl
# Define variational form comps
# a(u,s)
a = dot(grad(u),grad(s)) * dx
# L(f,s)
L = -f*s*dx

# Define problem and solution
chi = Function(V)
problem = LinearProblem(a, L, u = chi, bcs= [bc])
# Solve
chi = problem.solve()

# Define new functionspace for post-processed quantities from solution
W = functionspace(domain, ("DG",0, (domain.geometry.dim,)),) # Create new function space, make it discontinuous unlike V, and 1 order lower than V
vc = Function(W) # Instantiate function on W functionspace
vc_expr = Expression(as_vector((chi.dx(0),chi.dx(1))),W.element.interpolation_points()) # Create Expression
vc.interpolate(vc_expr) # Interpolate expression onto function

# Plotting
## Create Grid
grid = pv.UnstructuredGrid(*vtk_mesh(domain, tdim))

## pre-processing for vectors
top_imap = domain.topology.index_map(domain.topology.dim)
num_cells = top_imap.size_local + top_imap.num_ghosts
domain.topology.create_connectivity(domain.topology.dim, domain.topology.dim)
num_dofs = W.dofmap.index_map.size_local
num_verts = W.mesh.topology.index_map(0).size_local
assert (num_cells == num_dofs)
values = np.zeros((num_dofs, 3), dtype=np.float64)
values[:, :domain.geometry.dim] = vc.x.array.real.reshape(num_dofs, W.dofmap.index_map_bs)
values2 = np.zeros((num_verts, 3), dtype=np.float64)
values2[:, :domain.geometry.dim] = chi.x.array.real.reshape(num_verts, V.dofmap.index_map_bs)

# Glyphs first
grid["vc"] = values
grid.set_active_vectors("vc")
glyphs = grid.glyph(orient = "vc", scale = "vc",factor = 200/num_dofs, tolerance= 2/np.sqrt(num_dofs))

# Streamlines second
streamlines = grid.streamlines(vectors="vc", return_source=False, source_radius=0.5, n_points=150)

# Solution last
grid.point_data["chi"] = chi.x.array.real
grid.set_active_scalars("chi")
contours = grid.contour(isosurfaces = 11)

#Plot
plotter = pv.Plotter()
plotter.set_position([0, 0, 5])
plotter.add_mesh(grid, show_edges=False,show_scalar_bar=True, cmap = 'gist_heat')
plotter.add_mesh(glyphs)
plotter.add_mesh(contours, color ='white')
plotter.add_mesh(streamlines.tube(radius=0.001))
plotter.view_xy()
plotter.show()

Here is a plot of the solution and the associated vector field ignoring the streamlines error message about streamlines being empty:

My goal is to have a set of streamlines pointing out from the center connecting the arrows, but I can't get a single streamline to work. Not sure why as in another post, one of the requirements for streamlines was that the cells had to be 2D or 3D, so I have that requirement down.

System Information

--------------------------------------------------------------------------------
  Date: Sun Jul 20 02:43:24 2025 MDT

                OS : Linux (Ubuntu 24.04)
            CPU(s) : 32
           Machine : x86_64
      Architecture : 64bit
               RAM : 15.6 GiB
       Environment : Jupyter
       File system : ext4
        GPU Vendor : Microsoft Corporation
      GPU Renderer : D3D12 (NVIDIA GeForce RTX 4080 SUPER)
       GPU Version : 4.6 (Core Profile) Mesa 24.2.8-1ubuntu1~24.04.1
     Render Window : vtkXOpenGLRenderWindow
  MathText Support : True

  Python 3.13.5 | packaged by conda-forge | (main, Jun 13 2025, 01:14:40) [GCC
  13.3.0]

           pyvista : 0.45.2
               vtk : 9.4.2
             numpy : 2.3.0
        matplotlib : 3.10.3
            scooby : 0.10.1
             pooch : 1.8.2
            pillow : 11.2.1
           IPython : 9.3.0
        ipywidgets : 8.1.7
             scipy : 1.15.3
        jupyterlab : 4.4.3
      nest_asyncio : 1.6.0
--------------------------------------------------------------------------------

Screenshots

MatthewFlamm · 2025-07-22T16:43:36Z

MatthewFlamm
Jul 22, 2025
Maintainer

streamlines = grid.streamlines(vectors="vc", return_source=False, source_radius=0.5, n_points=150)

The default behavior of streamlines filter is to use starting points on a sphere. Since your grid is a 2D surface, it is nearly gauranteed that no starting point on the 3D surface of the sphere will land exactly on your grid. See streamlines documentation

You could use the start_position or pointa and pointb parameters if you wanted to use a single point or a line of points on a 2D plane. More likely it seems like you'd want to use a circular ring of points. To do this, you can use streamlines_from_source. See the example, which extracts part of the mesh to use as a starting source. In your case, you could specify a bunch of points as a source like in this psuedocode for a circle in the xy-plane:

import pyvista as pv
import numpy as np

center = (0, 0, 0)
n=15
radius = 1
theta = np.linspace(0, 2 * np.pi, n, endpoint=False)

x_coords = radius * np.cos(angles) + center[0]
y_coords = radius * np.sin(angles) + center[1]
z_coords = np.zeros(n) + center[2]

points = np.column_stack((x_coords, y_coords, z_coords))
source = pv.PolyData(points)
grid.streamlines_from_source(source, surface_streamlines=True, ...)

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Attempting to create a mesh of streamlines returns an empty mesh each time. My mesh is 2D and the cells are 2D as well. #7737

Uh oh!

{{title}}

Uh oh!

Replies: 1 comment

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Attempting to create a mesh of streamlines returns an empty mesh each time. My mesh is 2D and the cells are 2D as well. #7737

Uh oh!

Brotherman-Bi11 Jul 20, 2025

First check

Commit to Help

Sample Code What is the problem, question, or error?

Description

System Information

Screenshots

Replies: 1 comment

Uh oh!

MatthewFlamm Jul 22, 2025 Maintainer

Brotherman-Bi11
Jul 20, 2025

MatthewFlamm
Jul 22, 2025
Maintainer