Oasicsx convergence problems

General
2

You are missing several key definitions for boundary conditions.
Here is a mwe:

from mpi4py import MPI
import dolfinx
import numpy as np
import oasisx
from oasisx import DirichletBC, LocatorMethod, FractionalStep_AB_CN
from typing import List


def inlet(x):
    return np.isclose(x[0], 0)


def wall(x):
    return np.logical_or(np.isclose(x[1], 0), np.isclose(x[1], 1))


def outlet(x):
    return np.isclose(x[0], 10)


domain = dolfinx.mesh.create_rectangle(MPI.COMM_WORLD, [np.array([0, 0]), np.array([10, 1])], [
    50, 5], cell_type=dolfinx.mesh.CellType.triangle)

bcs_p: List[oasisx.PressureBC] = []
bc_inlet_x = DirichletBC(dolfinx.fem.Constant(domain, 1.),
                         method=LocatorMethod.GEOMETRICAL, marker=inlet)
bc_inlet_y = DirichletBC(dolfinx.fem.Constant(domain, 0.),
                         method=LocatorMethod.GEOMETRICAL, marker=inlet)
bc_wall = DirichletBC(dolfinx.fem.Constant(domain, 0.), method=LocatorMethod.GEOMETRICAL,
                      marker=wall)

outlet_facets = dolfinx.mesh.locate_entities_boundary(domain, domain.topology.dim - 1, outlet)
ft = dolfinx.mesh.meshtags(domain, domain.topology.dim-1, outlet_facets,
                           np.full_like(outlet_facets, 1, dtype=np.int32))
bcs_p: List[oasisx.PressureBC] = [oasisx.PressureBC(
    0., (ft, 1))]
bcs_u = [[bc_inlet_x, bc_wall], [bc_wall, bc_inlet_y]]

# fractional step solver
solver = FractionalStep_AB_CN(
    mesh=domain,
    u_element=("Lagrange", 2),
    p_element=("Lagrange", 1),
    bcs_u=bcs_u,
    bcs_p=bcs_p,
    solver_options={"tentative": {"ksp_type": "preonly", "pc_type": "lu"}, "pressure": {
        "ksp_type": "preonly", "pc_type": "lu"}, "scalar": {"ksp_type": "preonly", "pc_type": "lu"}},
    body_force=None
)


# Time-stepping
T_start, T_end, dt = 0.0, 1, 0.001
num_steps = int((T_end - T_start) // dt)
with dolfinx.io.VTXWriter(domain.comm, "poisseuille.bp", [solver.u], engine="BP4") as writer:
    for step in range(num_steps):
        solver.solve(dt, nu=0.01, max_iter=10)
        writer.write(dt*step)