pyop3

.github/workflows/core.yml

@@ -240,76 +240,77 @@ jobs:
           firedrake-run-split-tests 1 1 -n 8 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/tsfc
         timeout-minutes: 10
 
-      - name: Run PyOP2 tests
+      # TODO: parallel tests as well
+      - name: Run pyop3 tests
         if: inputs.run_tests && (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/pyop2
-          firedrake-run-split-tests 2 4 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/pyop2
-          firedrake-run-split-tests 3 2 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/pyop2
-          firedrake-run-split-tests 4 2 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/pyop2
+          firedrake-run-split-tests 1 1 -n 8 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/pyop3
         timeout-minutes: 10
 
-
       - name: Run Firedrake tests (nprocs = 1)
         if: inputs.run_tests && (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: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 2 4 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 60
+        # UNDO ME
+        timeout-minutes: 120
 
       - name: Run tests (nprocs = 3)
         if: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 3 2 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 60
+        # UNDO ME
+        timeout-minutes: 120
 
       - name: Run tests (nprocs = 4)
         if: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 4 2 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 15
+        # UNDO ME
+        timeout-minutes: 30
 
       - name: Run tests (nprocs = 5)
         if: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 5 1 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 15
+        # UNDO ME
+        timeout-minutes: 30
 
       - name: Run tests (nprocs = 6)
         if: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 6 1 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 15
+        # UNDO ME
+        timeout-minutes: 30
 
       - name: Run tests (nprocs = 7)
         if: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 7 1 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 15
+        # UNDO ME
+        timeout-minutes: 30
 
       - name: Run tests (nprocs = 8)
         if: inputs.run_tests && (success() || steps.install.conclusion == 'success')
         run: |
           . venv/bin/activate
           firedrake-run-split-tests 8 1 "$EXTRA_PYTEST_ARGS" firedrake-repo/tests/firedrake
-        timeout-minutes: 15
+        # UNDO ME
+        timeout-minutes: 30
 
       - name: Run Gusto smoke tests
         # Only test Gusto in real mode

.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,7 +185,7 @@ 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 = nodes[nodes >= 0]

demos/multicomponent/multicomponent.py.rst

@@ -524,7 +524,7 @@ 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 = nodes[nodes >= 0]

demos/netgen/netgen_mesh.py.rst

@@ -171,7 +171,7 @@ Then a SLEPc Eigenvalue Problem Solver (`EPS`) is initialised and set up to use
         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

@@ -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))

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
 

docs/source/petsc-interface.rst

@@ -59,14 +59,14 @@ read-write access to the PETSc object.  For read-only access, we use:
 
 .. code-block:: python3
 
-   with assemble(linear_form).dat.vec_ro as v:
+   with assemble(linear_form).vec_ro as v:
        petsc_vec_ro = v
 
 For write-only access, use ``.vec_wo``, and for read-write access, use:
 
 .. code-block:: python3
 
-   with assemble(linear_form).dat.vec as v:
+   with assemble(linear_form).vec as v:
        petsc_vec = v
 
 These context managers ensure that if PETSc writes to the vector,
@@ -140,10 +140,10 @@ newly defined class to compute the matrix action:
 
    # Now do the same for the linear forms for u and v, making a copy
 
-   with assemble(u_form).dat.vec_ro as u_vec:
+   with assemble(u_form).vec_ro as u_vec:
        u = u_vec.copy()
 
-   with assemble(v_form).dat.vec_ro as v_vec:
+   with assemble(v_form).vec_ro as v_vec:
        v = v_vec.copy()
 
 
@@ -179,8 +179,8 @@ Now we can solve a system using this ``ksp`` object:
 
    rhs = assemble(rhs_form)
 
-   with rhs.dat.vec_ro as b:
-       with solution.dat.vec as x:
+   with rhs.vec_ro as b:
+       with solution.vec as x:
            ksp.solve(b, x)
 
 
@@ -307,8 +307,8 @@ before going on to solve the system as before:
 
    rhs = assemble(rhs_form)
 
-   with rhs.dat.vec_ro as b:
-       with solution.dat.vec as x:
+   with rhs.vec_ro as b:
+       with solution.vec as x:
            ksp.solve(b, x)
 
 

firedrake/__init__.py

@@ -48,8 +48,9 @@
 from ufl import *
 from finat.ufl import *
 
-from pyop2 import op2                        # noqa: F401
-from pyop2.mpi import COMM_WORLD, COMM_SELF  # noqa: F401
+from pyop3.mpi import COMM_WORLD, COMM_SELF  # noqa: F401
+
+from pyop3 import READ, WRITE, RW, INC  # noqa: F401
 
 # Register possible citations
 import firedrake.citations  # noqa: F401
@@ -65,6 +66,7 @@
 from firedrake.exceptions import *
 from firedrake.function import *
 from firedrake.functionspace import *
+from firedrake.functionspaceimpl import InvalidFunctionSpaceLayoutException
 from firedrake.interpolation import *
 from firedrake.linear_solver import *
 from firedrake.preconditioners import *

firedrake/adjoint/ensemble_reduced_functional.py

@@ -1,6 +1,6 @@
 from pyadjoint.reduced_functional import AbstractReducedFunctional, ReducedFunctional
 from pyadjoint.enlisting import Enlist
-from pyop2.mpi import MPI
+from pyop3.mpi import MPI
 
 from firedrake.function import Function
 from firedrake.cofunction import Cofunction

firedrake/adjoint_utils/blocks/assembly.py

@@ -76,8 +76,8 @@ def compute_action_adjoint(self, adj_input, arity_form, form=None,
                 # Get PETSc matrix
                 dform_mat = assembled_dform.petscmat
                 # Action of the adjoint (Hermitian transpose)
-                with adj_input.dat.vec_ro as v_vec:
-                    with adj_output.dat.vec as res_vec:
+                with adj_input.vec_ro as v_vec:
+                    with adj_output.vec_wo as res_vec:
                         dform_mat.multHermitian(v_vec, res_vec)
             return adj_output, dform
         else:

firedrake/adjoint_utils/blocks/solving.py

@@ -882,7 +882,7 @@ def __init__(self, source, target_space, target, bcs=[], **kwargs):
 
     def apply_mixedmass(self, a):
         b = firedrake.Function(self.target_space.dual())
-        with a.dat.vec_ro as vsrc, b.dat.vec_wo as vrhs:
+        with a.vec_ro as vsrc, b.vec_wo as vrhs:
             self.mixed_mass.mult(vsrc, vrhs)
         return b
 
@@ -905,7 +905,7 @@ def _recompute_component_transpose(self, inputs):
         tmp = firedrake.Function(self.target_space)
         # Adjoint of step 2 (mass is self-adjoint)
         self.projector.apply_massinv(tmp, inputs[0])
-        with tmp.dat.vec_ro as vtmp, out.dat.vec_wo as vout:
+        with tmp.vec_ro as vtmp, out.vec_wo as vout:
             self.mixed_mass.multTranspose(vtmp, vout)  # Adjoint of step 1
         return out
 

firedrake/adjoint_utils/checkpointing.py

@@ -1,7 +1,7 @@
 """A module providing support for disk checkpointing of the adjoint tape."""
 from pyadjoint import get_working_tape, OverloadedType, disk_checkpointing_callback
 from pyadjoint.tape import TapePackageData
-from pyop2.mpi import COMM_WORLD
+from pyop3.mpi import COMM_WORLD
 import tempfile
 import os
 import shutil

firedrake/adjoint_utils/constant.py

@@ -98,7 +98,7 @@ def _ad_copy(self):
         return self._constant_from_values()
 
     def _ad_dim(self):
-        return self.dat.cdim
+        return self.dat.data_ro.size
 
     def _ad_imul(self, other):
         self.assign(self._constant_from_values(self.dat.data_ro.reshape(-1) * other))

firedrake/adjoint_utils/ensemble_function.py

@@ -31,7 +31,7 @@ def wrapper(self, *args, **kwargs):
 
     @staticmethod
     def _ad_to_list(m):
-        with m.vec_ro() as gvec:
+        with m.vec_ro as gvec:
             lvec = PETSc.Vec().createSeq(gvec.size,
                                          comm=PETSc.COMM_SELF)
             PETSc.Scatter().toAll(gvec).scatter(
@@ -40,7 +40,7 @@ def _ad_to_list(m):
 
     @staticmethod
     def _ad_assign_numpy(dst, src, offset):
-        with dst.vec_wo() as vec:
+        with dst.vec_wo as vec:
             begin, end = vec.owner_range
             vec.array[:] = src[offset + begin: offset + end]
             offset += vec.size

firedrake/adjoint_utils/function.py

@@ -276,15 +276,9 @@ def _ad_dot(self, other, options=None):
 
     @staticmethod
     def _ad_assign_numpy(dst, src, offset):
-        range_begin, range_end = dst.dat.dataset.layout_vec.getOwnershipRange()
-        m_a_local = src[offset + range_begin:offset + range_end]
-        if dst.function_space().ufl_element().family() == "Real":
-            # Real space keeps a redundant copy of the data on every rank
-            comm = dst.function_space().mesh()._comm
-            dst.dat.data_wo[...] = comm.bcast(m_a_local, root=0)
-        else:
-            dst.dat.data_wo[...] = m_a_local.reshape(dst.dat.data_wo.shape)
-        offset += dst.dat.dataset.layout_vec.size
+        range_begin, range_end = dst.function_space().template_vec.getOwnershipRange()
+        dst.dat.data_wo = src[offset + range_begin:offset + range_end]
+        offset += range_end - range_begin
         return dst, offset
 
     @staticmethod
@@ -327,11 +321,11 @@ def _applyBinary(self, f, y):
             self.dat.data_wo[i] = f(self.dat.data_ro[i], y.dat.data_ro[i])
 
     def _ad_from_petsc(self, vec):
-        with self.dat.vec_wo as self_v:
+        with self.vec_wo as self_v:
             vec.copy(result=self_v)
 
     def _ad_to_petsc(self, vec=None):
-        with self.dat.vec_ro as self_v:
+        with self.vec_ro as self_v:
             if vec:
                 self_v.copy(result=vec)
             else: