MLSDC run

Author: pancetta

pySDC/implementations/datatype_classes/petsc_vec.py

@@ -41,7 +41,7 @@ def isend(self, dest=None, tag=None, comm=None):
         Returns:
             request handle
         """
-        return comm.Issend(self[:], dest=dest, tag=tag)
+        return comm.Issend(self.getArray(), dest=dest, tag=tag)
 
     def irecv(self, source=None, tag=None, comm=None):
         """
@@ -55,7 +55,7 @@ def irecv(self, source=None, tag=None, comm=None):
         Returns:
             None
         """
-        return comm.Irecv(self[:], source=source, tag=tag)
+        return comm.Irecv(self.getArray(), source=source, tag=tag)
 
     def bcast(self, root=None, comm=None):
         """
@@ -68,7 +68,7 @@ def bcast(self, root=None, comm=None):
         Returns:
             broadcasted values
         """
-        comm.Bcast(self[:], root=root)
+        comm.Bcast(self.getArray(), root=root)
         return self
 
 
@@ -104,3 +104,37 @@ def __init__(self, init, val=0.0):
         # something is wrong, if none of the ones above hit
         else:
             raise DataError('something went wrong during %s initialization' % type(self))
+
+
+class petsc_vec_comp2(object):
+    """
+    RHS data type for Vec with implicit and explicit components
+
+    This data type can be used to have RHS with 2 components (here implicit and explicit)
+
+    Attributes:
+        impl (petsc_vec): implicit part
+        expl (petsc_vec): explicit part
+    """
+
+    def __init__(self, init, val=0.0):
+        """
+        Initialization routine
+
+        Args:
+            init: can either be a tuple (one int per dimension) or a number (if only one dimension is requested)
+                  or another imex_mesh object
+            val (float): an initial number (default: 0.0)
+        Raises:
+            DataError: if init is none of the types above
+        """
+
+        if isinstance(init, type(self)):
+            self.comp1 = petsc_vec(init.comp1)
+            self.comp2 = petsc_vec(init.comp2)
+        elif isinstance(init, PETSc.DMDA):
+            self.comp1 = petsc_vec(init, val=val)
+            self.comp2 = petsc_vec(init, val=val)
+        # something is wrong, if none of the ones above hit
+        else:
+            raise DataError('something went wrong during %s initialization' % type(self))

pySDC/implementations/transfer_classes/TransferPETScDMDA.py

@@ -1,7 +1,7 @@
 
 from pySDC.core.Errors import TransferError
 from pySDC.core.SpaceTransfer import space_transfer
-from pySDC.implementations.datatype_classes.petsc_dmda_grid import petsc_data, rhs_imex_petsc_data, rhs_2comp_petsc_data
+from pySDC.implementations.datatype_classes.petsc_vec import petsc_vec, petsc_vec_imex, petsc_vec_comp2
 
 
 class mesh_to_mesh_petsc_dmda(space_transfer):
@@ -36,17 +36,17 @@ def restrict(self, F):
         Args:
             F: the fine level data
         """
-        if isinstance(F, petsc_data):
+        if isinstance(F, petsc_vec):
             u_coarse = self.coarse_prob.dtype_u(self.coarse_prob.init)
-            self.inject.mult(F.values, u_coarse.values)
-        elif isinstance(F, rhs_imex_petsc_data):
+            self.inject.mult(F, u_coarse)
+        elif isinstance(F, petsc_vec_imex):
             u_coarse = self.coarse_prob.dtype_f(self.coarse_prob.init)
-            self.inject.mult(F.impl.values, u_coarse.impl.values)
-            self.inject.mult(F.expl.values, u_coarse.expl.values)
-        elif isinstance(F, rhs_2comp_petsc_data):
+            self.inject.mult(F.impl, u_coarse.impl)
+            self.inject.mult(F.expl, u_coarse.expl)
+        elif isinstance(F, petsc_vec_comp2):
             u_coarse = self.coarse_prob.dtype_f(self.coarse_prob.init)
-            self.inject.mult(F.comp1.values, u_coarse.comp1.values)
-            self.inject.mult(F.comp2.values, u_coarse.comp2.values)
+            self.inject.mult(F.comp1, u_coarse.comp1)
+            self.inject.mult(F.comp2, u_coarse.comp2)
         else:
             raise TransferError('Unknown type of fine data, got %s' % type(F))
 
@@ -59,17 +59,17 @@ def prolong(self, G):
         Args:
             G: the coarse level data
         """
-        if isinstance(G, petsc_data):
+        if isinstance(G, petsc_vec):
             u_fine = self.fine_prob.dtype_u(self.fine_prob.init)
-            self.interp.mult(G.values, u_fine.values)
-        elif isinstance(G, rhs_imex_petsc_data):
+            self.interp.mult(G, u_fine)
+        elif isinstance(G, petsc_vec_imex):
             u_fine = self.fine_prob.dtype_f(self.fine_prob.init)
-            self.interp.mult(G.impl.values, u_fine.impl.values)
-            self.interp.mult(G.expl.values, u_fine.expl.values)
-        elif isinstance(G, rhs_2comp_petsc_data):
+            self.interp.mult(G.impl, u_fine.impl)
+            self.interp.mult(G.expl, u_fine.expl)
+        elif isinstance(G, petsc_vec_comp2):
             u_fine = self.fine_prob.dtype_f(self.fine_prob.init)
-            self.interp.mult(G.comp1.values, u_fine.comp1.values)
-            self.interp.mult(G.comp2.values, u_fine.comp2.values)
+            self.interp.mult(G.comp1, u_fine.comp1)
+            self.interp.mult(G.comp2, u_fine.comp2)
         else:
             raise TransferError('Unknown type of coarse data, got %s' % type(G))
 

pySDC/playgrounds/other/petsc_datatype.py

@@ -64,15 +64,16 @@ def __abs__(self):
 da = PETSc.DMDA().create([4, 4], stencil_width=1)
 
 u = mymesh(da, val=9.0)
-uarr = da.getVecArray(u)
+uarr = u.getArray()
 
 v = mymesh(u)
-varr = da.getVecArray(v)
+varr = v.getArray()
 if v.comm.getRank() == 0:
-    uarr[0, 0] = 7
+    uarr[0] = 7
+uarr = da.getVecArray(u)
 print(uarr[:], uarr.shape, type(u))
 print(varr[:], v.getOwnershipRange(), type(v))
-
+exit()
 w = np.float(1.0) * (u + v)
 warr = da.getVecArray(w)
 print(warr[:], da.getRanges(), type(w))

pySDC/tutorial/step_7/C_pySDC_with_PETSc.py

@@ -56,7 +56,7 @@ def main():
     problem_params['nu'] = 1.0  # diffusion coefficient
     problem_params['freq'] = 2  # frequency for the test value
     problem_params['cnvars'] = [(65, 65)]  # number of degrees of freedom for the coarsest level
-    problem_params['refine'] = [1]  # number of refinements
+    problem_params['refine'] = [1, 0]  # number of refinements
     problem_params['comm'] = space_comm  # pass space-communicator to problem class
     problem_params['sol_tol'] = 1E-12  # set tolerance to PETSc' linear solver