pyop3

.github/actions/install/action.yml

@@ -79,7 +79,7 @@ runs:
       run: |
         : # Clone PETSc
         if [ ${{ inputs.base_ref }} = 'main' ]; then
-          git clone --depth 1 https://gitlab.com/petsc/petsc.git
+          git clone --depth 1 https://gitlab.com/petsc/petsc.git --branch connorjward/pcpatch-fixups
         elif [ ${{ inputs.base_ref }} = 'release' ]; then
           git clone --depth 1 \
             --branch $(python3 ./firedrake-repo/scripts/firedrake-configure --show-petsc-version) \

.github/workflows/core.yml

@@ -123,27 +123,21 @@ jobs:
           firedrake-run-split-tests 1 1 -n 8 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/tsfc
         timeout-minutes: 10
 
-      - name: Run PyOP2 tests
-        if: success() || steps.install.conclusion == 'success'
-        run: |
-          . venv/bin/activate
-          : # Use pytest-xdist here so we can have a single collated output (not possible
-          : # for parallel tests)
-          firedrake-run-split-tests 1 1 -n 8 "$EXTRA_PYTEST_ARGS" --timeout 30 firedrake-repo/tests/pyop2
-          firedrake-run-split-tests 2 4 "$EXTRA_PYTEST_ARGS" --timeout 30 firedrake-repo/tests/pyop2
-          firedrake-run-split-tests 3 2 "$EXTRA_PYTEST_ARGS" --timeout 30 firedrake-repo/tests/pyop2
-          firedrake-run-split-tests 4 2 "$EXTRA_PYTEST_ARGS" --timeout 30 firedrake-repo/tests/pyop2
-        timeout-minutes: 10
-
+      # TODO: parallel tests as well
+      # - name: Run pyop3 tests
+      #   if: success() || steps.install.conclusion == 'success'
+      #   run: |
+      #     . venv/bin/activate
+      #     firedrake-run-split-tests 1 1 -n 8 "$EXTRA_PYTEST_ARGS" --timeout 30 firedrake-repo/tests/pyop3
+      #   timeout-minutes: 10
 
       - name: Run Firedrake tests (nprocs = 1)
         if: success() || steps.install.conclusion == 'success'
         run: |
           . venv/bin/activate
-          : # Use pytest-xdist here so we can have a single collated output (not possible
-          : # for parallel tests)
           firedrake-run-split-tests 1 1 -n 8 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 90
+        # UNDO ME
+        timeout-minutes: 180
 
       - name: Run tests (nprocs = 2)
         if: success() || steps.install.conclusion == 'success'

.gitignore

@@ -45,6 +45,7 @@ PyOP2.egg-info
 sparsity.so
 sparsity.c
 sparsity.cpython*.so
+*_cy.c
 # Docs
 pyop2.coffee.rst
 pyop2.rst

demos/boussinesq/boussinesq.py.rst

@@ -185,9 +185,9 @@ implements a boundary condition that fixes a field at a single point. ::
            # Take the basis function with the largest abs value at bc_point
            v = TestFunction(V)
            F = assemble(interpolate(inner(v, v), Fvom))
-           with F.dat.vec as Fvec:
+           with F.vec_ro as Fvec:
                max_index, _ = Fvec.max()
-           nodes = V.dof_dset.lgmap.applyInverse([max_index])
+           nodes = V._lgmap.applyInverse([max_index])
            nodes = nodes[nodes >= 0]
            return nodes
 

demos/fast_diagonalisation/fast_diagonalisation_poisson.py.rst

@@ -102,7 +102,7 @@ using a sparse direct LU factorization. ::
 Moving on to a more complicated solver, we'll employ a two-level solver with
 the lowest-order coarse space via :class:`~.P1PC`.  As the fine level
 relaxation we define an additive Schwarz method on vertex-star patches
-implemented via :class:`~.ASMExtrudedStarPC` as we have an extruded mesh.
+implemented via :class:`~.ASMStarPC`.
 In addition we specify `"use_coloring"` to group non-overlapping subsets of
 patches into sparse block-diagonal matrices via a mesh coloring, which reduces
 the overhead of calling many KSP solves for each patch.::
@@ -116,7 +116,8 @@ the overhead of calling many KSP solves for each patch.::
           "ksp_max_it": 1,
           "ksp_type": "chebyshev",
           "pc_type": "python",
-          "pc_python_type": "firedrake.ASMExtrudedStarPC",
+          "pc_python_type": "firedrake.ASMStarPC",
+          "pc_star_column": 0,
           "pc_star_use_coloring": True,
           "pc_star_sub_sub_pc_type": "lu",
       },

demos/immersed_fem/immersed_fem.py.rst

@@ -294,7 +294,7 @@ We can load and check the generated meshes in Firedrake. ::
    fig, ax = plt.subplots(len(meshes), 1, figsize = (8, len(meshes)*3), tight_layout=True)
    for m, ax in zip(meshes, ax):
       triplot(m, axes=ax)
-      ax.set_title(f'Mesh via {m.name}, # cells: {m.num_cells()}')
+      ax.set_title(f'Mesh via {m.name}, # cells: {m.num_cells}')
       ax.legend(loc='upper left')   
 
    fig.savefig("gmsh_demo.png", dpi = 400)

demos/multicomponent/multicomponent.py.rst

@@ -534,9 +534,9 @@ mathematically valid to do this)::
            # Take the basis function with the largest abs value at bc_point
            v = TestFunction(V)
            F = assemble(interpolate(inner(v, v), Fvom))
-           with F.dat.vec as Fvec:
+           with F.vec as Fvec:
                max_index, _ = Fvec.max()
-           nodes = V.dof_dset.lgmap.applyInverse([max_index])
+           nodes = V._lgmap.applyInverse([max_index])
            nodes = nodes[nodes >= 0]
            return nodes
 

demos/netgen/netgen_mesh.py.rst

@@ -171,7 +171,7 @@ Then a SLEPc Eigenvalue Problem Solver (``EPS``) is initialised and set up to us
         E.setST(ST)
         E.solve()
         vr, vi = Asc.getVecs()
-        with uh.dat.vec_wo as vr:
+        with uh.vec_wo as vr:
             lam = E.getEigenpair(0, vr, vi)
         return (lam, uh, V)
 
@@ -198,8 +198,8 @@ In order to do so we begin by computing the value of the indicator using a piece
         part = .2
         mark = Function(W)
         # Filling in the marked element vector using eta.
-        with mark.dat.vec as markedVec:
-            with eta.dat.vec as etaVec:
+        with mark.vec as markedVec:
+            with eta.vec as etaVec:
                 sum_eta = etaVec.sum()
                 if sum_eta < tolerance:
                     return markedVec

demos/parallel-printing/parprint.py.rst

@@ -33,7 +33,7 @@ reports on the portion of the mesh it owns::
 
     mesh = UnitSquareMesh(3, 3)
     PETSc.Sys.Print('  rank %d owns %d elements and can access %d vertices' \
-                    % (mesh.comm.rank, mesh.num_cells(), mesh.num_vertices()),
+                    % (mesh.comm.rank, mesh.num_cells, mesh.num_vertices),
                     comm=COMM_SELF)
 
 The *elements* of the mesh are owned uniquely in parallel, while the
@@ -64,15 +64,15 @@ To print the solution vector in serial one could write ``print(u.dat.data)``
 but then in parallel each processor would show its data separately.
 So using PETSc we do a "view" of the solution vector::
 
-    with u.dat.vec_ro as vu:
+    with u.vec_ro as vu:
         vu.view()
 
 Here ``vu`` is an instance of the PETSc.Vec class and ``vu.view()`` is the
 equivalent of ``VecView(vu,NULL)`` using PETSc's C API.  This Vec is "global",
 meaning that each degree of freedom is stored on a unique process.  The context manager
 in the above usage (i.e. ``with ...``) allows Firedrake to generate a global Vec
 by halo exchanges if needed.  Here we only need read-only access here so we use
-``u.dat.vec_ro``; note ``u.dat.vec`` would allow read-write access.
+``u.vec_ro``; note ``u.vec`` would allow read-write access.
 
 Finally we compute and print the numerical error, relative to the exact
 solution, in two norms.  The :math:`L^2` norm is computed with
@@ -88,7 +88,7 @@ gets the max over the process-owned entries.  So again we use the ``PETSc.Vec``
 approach::
 
     udiffabs = Function(V).interpolate(abs(udiff))
-    with udiffabs.dat.vec_ro as v:
+    with udiffabs.vec_ro as v:
         L_inf_err = v.max()[1]
     PETSc.Sys.Print('L_2 error norm = %g, L_inf error norm = %g' \
                     % (L_2_err,L_inf_err))

demos/saddle_point_pc/saddle_point_systems.py.rst

@@ -180,7 +180,7 @@ Finally, at each mesh size, we print out the number of cells in the
 mesh and the number of iterations the solver took to converge ::
 
     #
-        print(w.function_space().mesh().unique().num_cells(), solver.snes.ksp.getIterationNumber())
+        print(w.function_space().mesh().unique().num_cells, solver.snes.ksp.getIterationNumber())
 
 The resulting convergence is unimpressive:
 
@@ -282,7 +282,7 @@ applying the action of blocks, so we can use a block matrix format. ::
     for n in range(8):
         solver, w = build_problem(n, parameters, block_matrix=True)
         solver.solve()
-        print(w.function_space().mesh().unique().num_cells(), solver.snes.ksp.getIterationNumber())
+        print(w.function_space().mesh().unique().num_cells, solver.snes.ksp.getIterationNumber())
 
 The resulting convergence is algorithmically good, however, the larger
 problems still take a long time.
@@ -367,7 +367,7 @@ Let's see what happens. ::
     for n in range(8):
         solver, w = build_problem(n, parameters, block_matrix=True)
         solver.solve()
-        print(w.function_space().mesh().unique().num_cells(), solver.snes.ksp.getIterationNumber())
+        print(w.function_space().mesh().unique().num_cells, solver.snes.ksp.getIterationNumber())
 
 This is much better, the problem takes much less time to solve and
 when observing the iteration counts for inverting :math:`S` we can see
@@ -422,7 +422,7 @@ and so we no longer need a flexible Krylov method. ::
     for n in range(8):
         solver, w = build_problem(n, parameters, block_matrix=True)
         solver.solve()
-        print(w.function_space().mesh().unique().num_cells(), solver.snes.ksp.getIterationNumber())
+        print(w.function_space().mesh().unique().num_cells, solver.snes.ksp.getIterationNumber())
 
 This results in the following GMRES iteration counts
 
@@ -487,7 +487,7 @@ variable. We can provide it as an :class:`~.AuxiliaryOperatorPC` via a python pr
     for n in range(8):
         solver, w = build_problem(n, parameters, aP=None, block_matrix=False)
         solver.solve()
-        print(w.function_space().mesh().unique().num_cells(), solver.snes.ksp.getIterationNumber())
+        print(w.function_space().mesh().unique().num_cells, solver.snes.ksp.getIterationNumber())
 
 This actually results in slightly worse convergence than the diagonal
 approximation we used above.
@@ -571,7 +571,7 @@ Let's see what the iteration count looks like now. ::
     for n in range(8):
         solver, w = build_problem(n, parameters, aP=riesz, block_matrix=True)
         solver.solve()
-        print(w.function_space().mesh().unique().num_cells(), solver.snes.ksp.getIterationNumber())
+        print(w.function_space().mesh().unique().num_cells, solver.snes.ksp.getIterationNumber())
 
 ============== ==================
  Mesh elements  GMRES iterations

docs/source/conf.py

@@ -109,7 +109,7 @@
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ['old_pyop2']
+exclude_patterns = []
 
 # The reST default role (used for this markup: `text`) to use for all documents.
 #default_role = None
@@ -141,10 +141,6 @@
     (r'py:.*', r'ufl\..*'),
     (r'py:.*', r'PETSc\..*'),
     (r'py:.*', r'progress\..*'),
-    # Ignore undocumented PyOP2
-    ('py:class', 'pyop2.caching.Cached'),
-    ('py:class', 'pyop2.op2.Kernel'),
-    ('py:class', 'pyop2.types.mat.Mat'),
     # Ignore mission docs from Firedrake internal "private" code
     # Any "Base" class eg:
     #   firedrake.adjoint.checkpointing.CheckpointBase
@@ -425,7 +421,6 @@
 # -- Options for intersphinx ---------------------------------------------
 
 intersphinx_mapping = {
-    'pyop2': ('https://op2.github.io/PyOP2', None),
     'ufl': ('https://docs.fenicsproject.org/ufl/main/', None),
     'FIAT': ('https://firedrakeproject.org/fiat', None),
     'petsctools': ('https://firedrakeproject.org/petsctools/', None),

docs/source/ensemble_parallelism.rst

@@ -204,10 +204,10 @@ on each ensemble member.
 Internally, the :class:`~.EnsembleFunction` creates a ``PETSc.Vec``
 on the ``Ensemble.global_comm`` which contains the data for all
 local components on all ensemble members. This ``Vec`` can be accessed
-with a context manager, similarly to the ``Function.dat.vec`` context
+with a context manager, similarly to the ``Function.vec`` context
 managers used to access :class:`~.Function` data. There are also
 analogous ``vec_ro`` and ``vec_wo`` context managers for read/write
-only accesses. However note that, unlike the ``Function.dat.vec``
+only accesses. However note that, unlike the ``Function.vec``
 context managers, the ``EnsembleFunction.vec`` context managers
 need braces i.e. ``vec()`` not ``vec``.
 

docs/source/external_operators.rst

@@ -391,7 +391,7 @@ of `N` can be assembled:
         integral_types = set(['cell'])
         assembly_opts = kwargs.get('assembly_opts')
         J = self._matrix_builder((), assembly_opts, integral_types)
-        with dNdu.dat.vec as vec:
+        with dNdu.vec_ro as vec:
             J.petscmat.setDiagonal(vec)
         return J