changed Q-transfer to work without u0

Author: pancetta

pySDC/core/BaseTransfer.py

@@ -2,6 +2,7 @@
 import logging
 
 from pySDC.helpers.pysdc_helper import FrozenClass
+from scipy import interpolate
 import pySDC.helpers.transfer_helper as th
 from pySDC.core.Errors import UnlockError
 
@@ -49,33 +50,11 @@ def __init__(self, pars):
         self.fine = fine_level
         self.coarse = coarse_level
 
-        # for Q-based transfer, check if we need to add 0 to the list of nodes
-        if not self.fine.sweep.coll.left_is_node:
-            fine_grid = np.concatenate(([0], self.fine.sweep.coll.nodes))
-            coarse_grid = np.concatenate(([0], self.coarse.sweep.coll.nodes))
-        else:
-            fine_grid = self.fine.sweep.coll.nodes
-            coarse_grid = self.coarse.sweep.coll.nodes
-
-        if self.params.coll_iorder > len(coarse_grid):
-            self.logger.warning('requested order of Q-interpolation is not valid, resetting to %s' % len(coarse_grid))
-            self.params.coll_iorder = len(coarse_grid)
-        if self.params.coll_rorder != 1:
-            self.logger.warning('requested order of Q-restriction is != 1, can lead to weird behavior!')
-
-        # set up preliminary transfer matrices for Q-based coarsening
-        Pcoll = th.interpolation_matrix_1d(fine_grid, coarse_grid, k=self.params.coll_iorder, pad=0).toarray()
-        Rcoll = th.restriction_matrix_1d(fine_grid, coarse_grid, k=self.params.coll_rorder, pad=0).toarray()
-
-        # pad transfer matrices if necessary
-        if self.fine.sweep.coll.left_is_node:
-            self.Pcoll = np.zeros((self.fine.sweep.coll.num_nodes + 1, self.coarse.sweep.coll.num_nodes + 1))
-            self.Rcoll = np.zeros((self.coarse.sweep.coll.num_nodes + 1, self.fine.sweep.coll.num_nodes + 1))
-            self.Pcoll[1:, 1:] = Pcoll
-            self.Rcoll[1:, 1:] = Rcoll
-        else:
-            self.Pcoll = Pcoll
-            self.Rcoll = Rcoll
+        fine_grid = self.fine.sweep.coll.nodes
+        coarse_grid = self.coarse.sweep.coll.nodes
+
+        self.Pcoll = th.interpolation_matrix_1d(fine_grid, coarse_grid, k=self.params.coll_iorder, pad=0).toarray()
+        self.Rcoll = th.restriction_matrix_1d(fine_grid, coarse_grid, k=self.params.coll_rorder, pad=0).toarray()
 
         # set up spatial transfer
         self.space_transfer = space_transfer_class(fine_prob=self.fine.prob, coarse_prob=self.coarse.prob,
@@ -105,16 +84,16 @@ def restrict(self):
             raise UnlockError('fine level is still locked, cannot use data from there')
 
         # restrict fine values in space
-        tmp_u = [self.space_transfer.restrict(F.u[0])]
+        tmp_u = []
         for m in range(1, SF.coll.num_nodes + 1):
             tmp_u.append(self.space_transfer.restrict(F.u[m]))
 
         # restrict collocation values
-        G.u[0] = tmp_u[0]
+        G.u[0] = self.space_transfer.restrict(F.u[0])
         for n in range(1, SG.coll.num_nodes + 1):
-            G.u[n] = self.Rcoll[n, 0] * tmp_u[0]
-            for m in range(1, SF.coll.num_nodes + 1):
-                G.u[n] += self.Rcoll[n, m] * tmp_u[m]
+            G.u[n] = self.Rcoll[n - 1, 0] * tmp_u[0]
+            for m in range(1, SF.coll.num_nodes):
+                G.u[n] += self.Rcoll[n - 1, m] * tmp_u[m]
 
         # re-evaluate f on coarse level
         G.f[0] = PG.eval_f(G.u[0], G.time)
@@ -129,15 +108,15 @@ def restrict(self):
 
         # restrict fine level tau correction part in space
         tmp_tau = []
-        for m in range(0, SF.coll.num_nodes):
+        for m in range(SF.coll.num_nodes):
             tmp_tau.append(self.space_transfer.restrict(tauF[m]))
 
         # restrict fine level tau correction part in collocation
         tauFG = []
         for n in range(1, SG.coll.num_nodes + 1):
-            tauFG.append(self.Rcoll[n, 1] * tmp_tau[0])
+            tauFG.append(self.Rcoll[n - 1, 0] * tmp_tau[0])
             for m in range(1, SF.coll.num_nodes):
-                tauFG[-1] += self.Rcoll[n, m + 1] * tmp_tau[m]
+                tauFG[-1] += self.Rcoll[n - 1, m] * tmp_tau[m]
 
         # build tau correction
         for m in range(SG.coll.num_nodes):
@@ -146,14 +125,13 @@ def restrict(self):
         if F.tau is not None:
             # restrict possible tau correction from fine in space
             tmp_tau = []
-            for m in range(0, SF.coll.num_nodes):
+            for m in range(SF.coll.num_nodes):
                 tmp_tau.append(self.space_transfer.restrict(F.tau[m]))
 
             # restrict possible tau correction from fine in collocation
-            for n in range(1, SG.coll.num_nodes + 1):
-                G.tau[n - 1] += self.Rcoll[n, 1] * tmp_tau[0]
-                for m in range(1, SF.coll.num_nodes):
-                    G.tau[n - 1] += self.Rcoll[n, m + 1] * tmp_tau[m]
+            for n in range(SG.coll.num_nodes):
+                for m in range(SF.coll.num_nodes):
+                    G.tau[n] += self.Rcoll[n, m] * tmp_tau[m]
         else:
             pass
 
@@ -203,8 +181,8 @@ def prolong(self):
         # interpolate values in collocation
         F.u[0] += tmp_u[0]
         for n in range(1, SF.coll.num_nodes + 1):
-            for m in range(0, SG.coll.num_nodes + 1):
-                F.u[n] += self.Pcoll[n, m] * tmp_u[m]
+            for m in range(1, SG.coll.num_nodes + 1):
+                F.u[n] += self.Pcoll[n - 1, m - 1] * tmp_u[m]
 
         # re-evaluate f on fine level
         F.f[0] = PF.eval_f(F.u[0], F.time)
@@ -250,8 +228,8 @@ def prolong_f(self):
         F.u[0] += tmp_u[0]
         F.f[0] += tmp_f[0]
         for n in range(1, SF.coll.num_nodes + 1):
-            for m in range(0, SG.coll.num_nodes + 1):
-                F.u[n] += self.Pcoll[n, m] * tmp_u[m]
-                F.f[n] += self.Pcoll[n, m] * tmp_f[m]
+            for m in range(1, SG.coll.num_nodes + 1):
+                F.u[n] += self.Pcoll[n - 1, m - 1] * tmp_u[m]
+                F.f[n] += self.Pcoll[n - 1, m - 1] * tmp_f[m]
 
         return None

pySDC/implementations/controller_classes/allinclusive_multigrid_nonMPI.py

@@ -455,6 +455,21 @@ def pfasst(self, MS):
                     # prolong values
                     S.transfer(source=S.levels[l], target=S.levels[l - 1])
 
+                    # send updated values forward
+                    if self.params.fine_comm and not S.status.last:
+                        self.logger.debug('Process %2i provides data on level %2i with tag %s'
+                                          % (S.status.slot, l - 1, S.status.iter))
+                        self.send(S.levels[l - 1], tag=(l - 1, S.status.iter, S.status.slot))
+
+                    # # receive values
+                    if self.params.fine_comm and not S.status.first:
+                        self.logger.debug('Process %2i receives from %2i on level %2i with tag %s' %
+                                          (S.status.slot, S.prev.status.slot, l - 1, S.status.iter))
+                        self.recv(S.levels[l - 1], S.prev.levels[l - 1], tag=(l - 1, S.status.iter,
+                                                                              S.prev.status.slot))
+
+                    S.levels[l - 1].sweep.compute_residual()
+
                 # on middle levels: do communication and sweep as usual
                 if l - 1 > 0:
 

pySDC/projects/matrixPFASST/compare_to_propagator.py

@@ -268,7 +268,7 @@ def compare_controllers(type=None, par=0.0, f=None):
 
 def main():
 
-    f = open('comparison_matrix_vs_propagator_detail.txt', 'a')
+    f = open('comparison_matrix_vs_propagator_detail.txt', 'w')
     # compare_controllers(type='diffusion', par=1E-00, f=f)
     # compare_controllers(type='advection', par=1E-00, f=f)
     compare_controllers(type='testequation', par=0.0, f=f)

pySDC/tests/test_Q_transfer.py

@@ -37,12 +37,8 @@ def check_Q_transfer(collclass):
 
         assert coll_fine.left_is_node == coll_coarse.left_is_node, 'ERROR: should be using the same class for coarse and fine Q'
 
-        if not coll_fine.left_is_node:
-            fine_grid = np.concatenate(([0], coll_fine.nodes))
-            coarse_grid = np.concatenate(([0], coll_coarse.nodes))
-        else:
-            fine_grid = coll_fine.nodes
-            coarse_grid = coll_coarse.nodes
+        fine_grid = coll_fine.nodes
+        coarse_grid = coll_coarse.nodes
 
         for order in range(2,coll_coarse.num_nodes+1):
 
@@ -88,12 +84,8 @@ def check_Q_transfer_minimal(collclass):
 
         assert coll_fine.left_is_node == coll_coarse.left_is_node, 'ERROR: should be using the same class for coarse and fine Q'
 
-        if not coll_fine.left_is_node:
-            fine_grid = np.concatenate(([0], coll_fine.nodes))
-            coarse_grid = np.concatenate(([0], coll_coarse.nodes))
-        else:
-            fine_grid = coll_fine.nodes
-            coarse_grid = coll_coarse.nodes
+        fine_grid = coll_fine.nodes
+        coarse_grid = coll_coarse.nodes
 
         Pcoll = th.interpolation_matrix_1d(fine_grid, coarse_grid, k=2, pad=0)
         Rcoll = th.restriction_matrix_1d(fine_grid, coarse_grid, k=2, pad=0)