def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ if isinstance(F, parallel_mesh): G = self.coarse_prob.dtype_u(self.coarse_prob.init) for l in range(self.coarse_prob.init[0][-1]): FG = self.fine_prob.domain.new_field() FG['g'] = F[..., l] FG.set_scales(scales=1.0 / self.ratio[0]) G[..., l] = FG['g'] elif isinstance(F, parallel_imex_mesh): G = self.coarse_prob.dtype_f(self.coarse_prob.init) for l in range(self.fine_prob.init[0][-1]): FG = self.fine_prob.domain.new_field() FG['g'] = F.impl[..., l] FG.set_scales(scales=1.0 / self.ratio[0]) G.impl[..., l] = FG['g'] FG = self.fine_prob.domain.new_field() FG['g'] = F.expl[..., l] FG.set_scales(scales=1.0 / self.ratio[0]) G.expl[..., l] = FG['g'] else: raise TransferError('Unknown data type, got %s' % type(F)) return G
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, mesh): F = mesh(self.fine_prob.init, val=0.0) tmpG = np.fft.rfft(G.values) tmpF = np.zeros(self.fine_prob.init // 2 + 1, dtype=np.complex128) halfG = int(self.coarse_prob.init / 2) tmpF[0:halfG] = tmpG[0:halfG] tmpF[-1] = tmpG[-1] F.values[:] = np.fft.irfft(tmpF) * self.ratio elif isinstance(G, rhs_imex_mesh): F = rhs_imex_mesh(G) tmpG_impl = np.fft.rfft(G.impl.values) tmpF_impl = np.zeros(self.fine_prob.init // 2 + 1, dtype=np.complex128) halfG = int(self.coarse_prob.init / 2) tmpF_impl[0:halfG] = tmpG_impl[0:halfG] tmpF_impl[-1] = tmpG_impl[-1] F.impl.values[:] = np.fft.irfft(tmpF_impl) * self.ratio tmpG_expl = np.fft.rfft(G.expl.values) tmpF_expl = np.zeros(self.fine_prob.init // 2 + 1, dtype=np.complex128) halfG = int(self.coarse_prob.init / 2) tmpF_expl[0:halfG] = tmpG_expl[0:halfG] tmpF_expl[-1] = tmpG_expl[-1] F.expl.values[:] = np.fft.irfft(tmpF_expl) * self.ratio else: raise TransferError('Unknown data type, got %s' % type(G)) return F
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, parallel_mesh): F = self.fine_prob.dtype_u(self.fine_prob.init) for l in range(self.fine_prob.init[0][-1]): GF = self.coarse_prob.domain.new_field() GF['g'] = G[..., l] GF.set_scales(scales=self.ratio[0]) F[..., l] = GF['g'] elif isinstance(G, parallel_imex_mesh): F = self.fine_prob.dtype_f(self.fine_prob.init) for l in range(self.coarse_prob.init[0][-1]): GF = self.coarse_prob.domain.new_field() GF['g'] = G.impl[..., l] GF.set_scales(scales=self.ratio[0]) F.impl[..., l] = GF['g'] GF = self.coarse_prob.init[0].new_field() GF['g'] = G.expl[..., l] GF.set_scales(scales=self.ratio[0]) F.expl[..., l] = GF['g'] else: raise TransferError('Unknown data type, got %s' % type(G)) return F
def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ if isinstance(F, parallel_mesh): if self.spectral: G = self.coarse_prob.dtype_u(self.coarse_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpF = newDistArray(self.fine_prob.fft, False) tmpF = self.fine_prob.fft.backward(F[..., i], tmpF) tmpG = tmpF[::int(self.ratio[0]), ::int(self.ratio[1])] G[..., i] = self.coarse_prob.fft.forward(tmpG, G[..., i]) else: tmpF = self.fine_prob.fft.backward(F) tmpG = tmpF[::int(self.ratio[0]), ::int(self.ratio[1])] G[:] = self.coarse_prob.fft.forward(tmpG, G) else: G = self.coarse_prob.dtype_u(self.coarse_prob.init) G[:] = F[::int(self.ratio[0]), ::int(self.ratio[1])] else: raise TransferError('Unknown data type, got %s' % type(F)) return G
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, parallel_mesh): if self.spectral: F = self.fine_prob.dtype_u(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpF = self.fft_pad.backward(G[..., i]) F[..., i] = self.fine_prob.fft.forward(tmpF, F[..., i]) else: tmpF = self.fft_pad.backward(G) F[:] = self.fine_prob.fft.forward(tmpF, F) else: F = self.fine_prob.dtype_u(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): G_hat = self.coarse_prob.fft.forward(G[..., i]) F[..., i] = self.fft_pad.backward(G_hat, F[..., i]) else: G_hat = self.coarse_prob.fft.forward(G) F[:] = self.fft_pad.backward(G_hat, F) elif isinstance(G, parallel_imex_mesh): if self.spectral: F = self.fine_prob.dtype_f(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpF = self.fft_pad.backward(G.impl[..., i]) F.impl[..., i] = self.fine_prob.fft.forward(tmpF, F.impl[..., i]) tmpF = self.fft_pad.backward(G.expl[..., i]) F.expl[..., i] = self.fine_prob.fft.forward(tmpF, F.expl[..., i]) else: tmpF = self.fft_pad.backward(G.impl) F.impl[:] = self.fine_prob.fft.forward(tmpF, F.impl) tmpF = self.fft_pad.backward(G.expl) F.expl[:] = self.fine_prob.fft.forward(tmpF, F.expl) else: F = self.fine_prob.dtype_f(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): G_hat = self.coarse_prob.fft.forward(G.impl[..., i]) F.impl[..., i] = self.fft_pad.backward(G_hat, F.impl[..., i]) G_hat = self.coarse_prob.fft.forward(G.expl[..., i]) F.expl[..., i] = self.fft_pad.backward(G_hat, F.expl[..., i]) else: G_hat = self.coarse_prob.fft.forward(G.impl) F.impl[:] = self.fft_pad.backward(G_hat, F.impl) G_hat = self.coarse_prob.fft.forward(G.expl) F.expl[:] = self.fft_pad.backward(G_hat, F.expl) else: raise TransferError('Unknown data type, got %s' % type(G)) return F
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, mesh): F = mesh(self.fine_prob.init) tmpG = self.fft_object_coarse(G.values) / ( self.coarse_prob.init[0] * self.coarse_prob.init[1]) tmpF = np.zeros(self.fine_prob.init, dtype=np.complex128) halfG = int(self.coarse_prob.init[0] / 2) tmpF[0:halfG, 0:halfG] = tmpG[0:halfG, 0:halfG] tmpF[self.fine_prob.init[0] - halfG:, 0:halfG] = tmpG[halfG:, 0:halfG] tmpF[0:halfG, self.fine_prob.init[0] - halfG:] = tmpG[0:halfG, halfG:] tmpF[self.fine_prob.init[0] - halfG:, self.fine_prob.init[0] - halfG:] = tmpG[halfG:, halfG:] F.values[:] = np.real( self.ifft_object_fine(tmpF, normalise_idft=False)) elif isinstance(G, rhs_imex_mesh): F = rhs_imex_mesh(G) tmpG_impl = self.fft_object_coarse(G.impl.values) / ( self.coarse_prob.init[0] * self.coarse_prob.init[1]) tmpF_impl = np.zeros(self.fine_prob.init, dtype=np.complex128) halfG = int(self.coarse_prob.init[0] / 2) tmpF_impl[0:halfG, 0:halfG] = tmpG_impl[0:halfG, 0:halfG] tmpF_impl[self.fine_prob.init[0] - halfG:, 0:halfG] = tmpG_impl[halfG:, 0:halfG] tmpF_impl[0:halfG, self.fine_prob.init[0] - halfG:] = tmpG_impl[0:halfG, halfG:] tmpF_impl[self.fine_prob.init[0] - halfG:, self.fine_prob.init[0] - halfG:] = tmpG_impl[halfG:, halfG:] F.impl.values[:] = np.real( self.ifft_object_fine(tmpF_impl, normalise_idft=False)) tmpG_expl = self.fft_object_coarse(G.expl.values) / ( self.coarse_prob.init[0] * self.coarse_prob.init[1]) tmpF_expl = np.zeros(self.fine_prob.init, dtype=np.complex128) halfG = int(self.coarse_prob.init[0] / 2) tmpF_expl[0:halfG, 0:halfG] = tmpG_expl[0:halfG, 0:halfG] tmpF_expl[self.fine_prob.init[0] - halfG:, 0:halfG] = tmpG_expl[halfG:, 0:halfG] tmpF_expl[0:halfG, self.fine_prob.init[0] - halfG:] = tmpG_expl[0:halfG, halfG:] tmpF_expl[self.fine_prob.init[0] - halfG:, self.fine_prob.init[0] - halfG:] = tmpG_expl[halfG:, halfG:] F.expl.values[:] = np.real( self.ifft_object_fine(tmpF_expl, normalise_idft=False)) else: raise TransferError('Unknown data type, got %s' % type(G)) return F
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, mesh): F = self.fine_prob.dtype_u(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpG = G.values[..., i].flatten() tmpF = self.Pspace.dot(tmpG) F.values[..., i] = tmpF.reshape(self.fine_prob.params.nvars) else: tmpG = G.values.flatten() tmpF = self.Pspace.dot(tmpG) F.values[:] = tmpF.reshape(self.fine_prob.params.nvars) elif isinstance(G, rhs_imex_mesh): F = self.fine_prob.dtype_f(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpG = G.impl.values[..., i].flatten() tmpF = self.Pspace.dot(tmpG) F.impl.values[..., i] = tmpF.reshape(self.fine_prob.params.nvars) tmpG = G.expl.values[..., i].flatten() tmpF = self.Rspace.dot(tmpG) F.expl.values[..., i] = tmpF.reshape(self.fine_prob.params.nvars) else: tmpG = G.impl.values.flatten() tmpF = self.Pspace.dot(tmpG) F.impl.values = tmpF.reshape(self.fine_prob.params.nvars) tmpG = G.expl.values.flatten() tmpF = self.Pspace.dot(tmpG) F.expl.values = tmpF.reshape(self.fine_prob.params.nvars) elif isinstance(G, rhs_comp2_mesh): F = self.fine_prob.dtype_f(self.fine_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpG = G.comp1.values[..., i].flatten() tmpF = self.Pspace.dot(tmpG) F.comp1.values[..., i] = tmpF.reshape(self.fine_prob.params.nvars) tmpG = G.comp2.values[..., i].flatten() tmpF = self.Rspace.dot(tmpG) F.comp2.values[..., i] = tmpF.reshape(self.fine_prob.params.nvars) else: tmpG = G.comp1.values.flatten() tmpF = self.Pspace.dot(tmpG) F.comp1.values = tmpF.reshape(self.fine_prob.params.nvars) tmpG = G.comp2.values.flatten() tmpF = self.Pspace.dot(tmpG) F.comp2.values = tmpF.reshape(self.fine_prob.params.nvars) else: raise TransferError('Wrong data type for prolongation, got %s' % type(G)) return F
def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ if isinstance(F, mesh): G = self.coarse_prob.dtype_u(self.coarse_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpF = F.values[..., i].flatten() tmpG = self.Rspace.dot(tmpF) G.values[..., i] = tmpG.reshape(self.coarse_prob.params.nvars) else: tmpF = F.values.flatten() tmpG = self.Rspace.dot(tmpF) G.values[:] = tmpG.reshape(self.coarse_prob.params.nvars) elif isinstance(F, rhs_imex_mesh): G = self.coarse_prob.dtype_f(self.coarse_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpF = F.impl.values[..., i].flatten() tmpG = self.Rspace.dot(tmpF) G.impl.values[..., i] = tmpG.reshape(self.coarse_prob.params.nvars) tmpF = F.expl.values[..., i].flatten() tmpG = self.Rspace.dot(tmpF) G.expl.values[..., i] = tmpG.reshape(self.coarse_prob.params.nvars) else: tmpF = F.impl.values.flatten() tmpG = self.Rspace.dot(tmpF) G.impl.values = tmpG.reshape(self.coarse_prob.params.nvars) tmpF = F.expl.values.flatten() tmpG = self.Rspace.dot(tmpF) G.expl.values = tmpG.reshape(self.coarse_prob.params.nvars) elif isinstance(F, rhs_comp2_mesh): G = self.coarse_prob.dtype_f(self.coarse_prob.init) if hasattr(self.fine_prob, 'ncomp'): for i in range(self.fine_prob.ncomp): tmpF = F.comp1.values[..., i].flatten() tmpG = self.Rspace.dot(tmpF) G.comp1.values[..., i] = tmpG.reshape(self.coarse_prob.params.nvars) tmpF = F.comp2.values[..., i].flatten() tmpG = self.Rspace.dot(tmpF) G.comp2.values[..., i] = tmpG.reshape(self.coarse_prob.params.nvars) else: tmpF = F.comp1.values.flatten() tmpG = self.Rspace.dot(tmpF) G.comp1.values = tmpG.reshape(self.coarse_prob.params.nvars) tmpF = F.comp2.values.flatten() tmpG = self.Rspace.dot(tmpF) G.comp2.values = tmpG.reshape(self.coarse_prob.params.nvars) else: raise TransferError('Wrong data type for restriction, got %s' % type(F)) return G
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, mesh): F = mesh(G) elif isinstance(G, rhs_imex_mesh): F = rhs_imex_mesh(G) else: raise TransferError('Unknown data type, got %s' % type(G)) return F
def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ if isinstance(F, mesh): G = mesh(F) elif isinstance(F, rhs_imex_mesh): G = rhs_imex_mesh(F) else: raise TransferError('Unknown data type, got %s' % type(F)) return G
def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ t0 = time.time() if isinstance(F, pmesh_datatype): G = self.coarse_prob.dtype_u(self.coarse_prob.init) # convert numpy array to RealField tmp_F = self.fine_prob.pm.create(type='complex', value=F.values) # tmp_G = self.coarse_prob.pm.create(type='complex') # resample fine to coarse # tmp_G = self.coarse_prob.pm.upsample(tmp_F, keep_mean=True) # tmp_F.resample(tmp_G) tmp_F = tmp_F.c2r(out=Ellipsis) tmp_G = self.coarse_prob.pm.upsample(tmp_F, keep_mean=True) tmp_G = tmp_G.r2c(out=Ellipsis) # copy values to data structure G.values = tmp_G.value elif isinstance(F, rhs_imex_pmesh): G = self.coarse_prob.dtype_f(self.coarse_prob.init) # convert numpy array to RealField tmp_F = self.fine_prob.pm.create(type='complex', value=F.impl.values) # tmp_G = self.coarse_prob.pm.create(type='complex') # resample fine to coarse # tmp_G = self.coarse_prob.pm.upsample(tmp_F, keep_mean=True) # tmp_F.resample(tmp_G) tmp_F = tmp_F.c2r(out=Ellipsis) tmp_G = self.coarse_prob.pm.upsample(tmp_F, keep_mean=True) tmp_G = tmp_G.r2c(out=Ellipsis) # copy values to data structure G.impl.values[:] = tmp_G.value # convert numpy array to RealField tmp_F = self.fine_prob.pm.create(type='complex', value=F.expl.values) # tmp_G = self.coarse_prob.pm.create(type='complex') # resample fine to coarse # tmp_G = self.coarse_prob.pm.upsample(tmp_F, keep_mean=True) # tmp_F.resample(tmp_G) tmp_F = tmp_F.c2r(out=Ellipsis) tmp_G = self.coarse_prob.pm.upsample(tmp_F, keep_mean=True) tmp_G = tmp_G.r2c(out=Ellipsis) # copy values to data structure G.expl.values[:] = tmp_G.value else: raise TransferError('Unknown data type, got %s' % type(F)) t1 = time.time() print(f'Space restrict: {t1-t0}') return G
def restrict(self, F): """ Dummy restriction routine Args: F: the fine level data """ if isinstance(F, particles): G = particles(F) elif isinstance(F, fields): G = fields(F) else: raise TransferError("Unknown type of fine data, got %s" % type(F)) return G
def prolong(self, G): """ Dummy prolongation routine Args: G: the coarse level data """ if isinstance(G, particles): F = particles(G) elif isinstance(G, fields): F = fields(G) else: raise TransferError("Unknown type of coarse data, got %s" % type(G)) return F
def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ if isinstance(F, mesh): G = mesh(self.coarse_prob.init, val=0.0) G.values = F.values[::self.ratio] elif isinstance(F, rhs_imex_mesh): G = rhs_imex_mesh(self.coarse_prob.init, val=0.0) G.impl.values = F.impl.values[::self.ratio] G.expl.values = F.expl.values[::self.ratio] else: raise TransferError('Unknown data type, got %s' % type(F)) return G
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data """ if isinstance(G, fenics_mesh): u_fine = fenics_mesh(self.fine_prob.init) u_fine.values = df.interpolate(G.values, u_fine.V) elif isinstance(G, rhs_fenics_mesh): u_fine = rhs_fenics_mesh(self.fine_prob.init) u_fine.impl.values = df.interpolate(G.impl.values, u_fine.impl.V) u_fine.expl.values = df.interpolate(G.expl.values, u_fine.expl.V) else: raise TransferError('Unknown type of coarse data, got %s' % type(G)) return u_fine
def project(self, F): """ Restriction implementation via projection Args: F: the fine level data """ if isinstance(F, fenics_mesh): u_coarse = fenics_mesh(df.project(F.values, self.coarse_prob.init)) elif isinstance(F, rhs_fenics_mesh): u_coarse = rhs_fenics_mesh(self.coarse_prob.init) u_coarse.impl.values = df.project(F.impl.values, self.coarse_prob.init) u_coarse.expl.values = df.project(F.expl.values, self.coarse_prob.init) else: raise TransferError('Unknown type of fine data, got %s' % type(F)) return u_coarse
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ t0 = time.time() if isinstance(G, pmesh_datatype): F = self.fine_prob.dtype_u(self.fine_prob.init) # convert numpy array to RealField tmp_F = self.fine_prob.pm.create(type='real', value=0.0) tmp_G = self.coarse_prob.pm.create(type='real', value=G.values) # resample coarse to fine tmp_G.resample(tmp_F) # copy values to data structure F.values = tmp_F.value elif isinstance(G, rhs_imex_pmesh): F = self.fine_prob.dtype_f(self.fine_prob.init) # convert numpy array to RealField tmp_F = self.fine_prob.pm.create(type='real', value=0.0) tmp_G = self.coarse_prob.pm.create(type='real', value=G.impl.values) # resample coarse to fine tmp_G.resample(tmp_F) # copy values to data structure F.impl.values = tmp_F.value # convert numpy array to RealField tmp_F = self.fine_prob.pm.create(type='real', value=0.0) tmp_G = self.coarse_prob.pm.create(type='real', value=G.expl.values) # resample coarse to fine tmp_G.resample(tmp_F) # copy values to data structure F.expl.values = tmp_F.value / 2 else: raise TransferError('Unknown data type, got %s' % type(G)) t1 = time.time() print(f'Space interpolate: {t1 - t0}') return F
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data """ if isinstance(G, petsc_data): 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): 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): 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) else: raise TransferError('Unknown type of coarse data, got %s' % type(G)) return u_fine
def restrict(self, F): """ Restriction implementation Args: F: the fine level data """ if isinstance(F, petsc_data): 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): 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): 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) else: raise TransferError('Unknown type of fine data, got %s' % type(F)) return u_coarse
def restrict(self, F): """ Restriction implementation Args: F: the fine level data (easier to access than via the fine attribute) """ if isinstance(F, mesh): F.values = F.values.flatten() G = F.apply_mat(self.Rspace) G.values = G.values.reshape(self.coarse_prob.params.nvars) F.values = F.values.reshape(self.fine_prob.params.nvars) elif isinstance(F, rhs_imex_mesh): F.impl.values = F.impl.values.flatten() F.expl.values = F.expl.values.flatten() G = F.apply_mat(self.Rspace) G.impl.values = G.impl.values.reshape( self.coarse_prob.params.nvars) G.expl.values = G.expl.values.reshape( self.coarse_prob.params.nvars) F.impl.values = F.impl.values.reshape(self.fine_prob.params.nvars) F.expl.values = F.expl.values.reshape(self.fine_prob.params.nvars) elif isinstance(F, rhs_comp2_mesh): F.comp1.values = F.comp1.values.flatten() F.comp2.values = F.comp2.values.flatten() G = F.apply_mat(self.Rspace) G.comp1.values = G.comp1.values.reshape( self.coarse_prob.params.nvars) G.comp2.values = G.comp2.values.reshape( self.coarse_prob.params.nvars) F.comp1.values = F.comp1.values.reshape( self.fine_prob.params.nvars) F.comp2.values = F.comp2.values.reshape( self.fine_prob.params.nvars) else: raise TransferError('Wrong data type for restriction, got %s' % type(F)) return G
def prolong(self, G): """ Prolongation implementation Args: G: the coarse level data (easier to access than via the coarse attribute) """ if isinstance(G, mesh): G.values = G.values.flatten() F = G.apply_mat(self.Pspace) F.values = F.values.reshape(self.fine_prob.params.nvars) G.values = G.values.reshape(self.coarse_prob.params.nvars) elif isinstance(G, rhs_imex_mesh): G.impl.values = G.impl.values.flatten() G.expl.values = G.expl.values.flatten() F = G.apply_mat(self.Pspace) F.impl.values = F.impl.values.reshape(self.fine_prob.params.nvars) F.expl.values = F.expl.values.reshape(self.fine_prob.params.nvars) G.impl.values = G.impl.values.reshape( self.coarse_prob.params.nvars) G.expl.values = G.expl.values.reshape( self.coarse_prob.params.nvars) elif isinstance(G, rhs_comp2_mesh): G.comp1.values = G.comp1.values.flatten() G.comp2.values = G.comp2.values.flatten() F = G.apply_mat(self.Pspace) F.comp1.values = F.comp1.values.reshape( self.fine_prob.params.nvars) F.comp2.values = F.comp2.values.reshape( self.fine_prob.params.nvars) G.comp1.values = G.comp1.values.reshape( self.coarse_prob.params.nvars) G.comp2.values = G.comp2.values.reshape( self.coarse_prob.params.nvars) else: raise TransferError('Wrong data type for prolongation, got %s' % type(G)) return F
def __init__(self, fine_prob, coarse_prob, params): """ Initialization routine Args: fine_prob: fine problem coarse_prob: coarse problem params: parameters for the transfer operators """ if 'iorder' not in params: raise TransferError('Need iorder parameter for spatial transfer') if 'rorder' not in params: raise TransferError('Need rorder parameter for spatial transfer') # invoke super initialization super(mesh_to_mesh, self).__init__(fine_prob, coarse_prob, params) if type(self.fine_prob.params.nvars) is tuple: if type(self.coarse_prob.params.nvars) is not tuple: raise TransferError( 'nvars parameter of coarse problem needs to be a tuple') if not len(self.fine_prob.params.nvars) == len( self.coarse_prob.params.nvars): raise TransferError( 'nvars parameter of fine and coarse level needs to have the same length' ) elif type(self.fine_prob.params.nvars) is int: if type(self.coarse_prob.params.nvars) is not int: raise TransferError( 'nvars parameter of coarse problem needs to be an int') else: raise TransferError("unknow type of nvars for transfer, got %s" % self.fine_prob.params.nvars) # we have a 1d problem if type(self.fine_prob.params.nvars) is int: # if number of variables is the same on both levels, Rspace and Pspace are identity if self.coarse_prob.params.nvars == self.fine_prob.params.nvars: self.Rspace = sp.eye(self.coarse_prob.params.nvars) self.Pspace = sp.eye(self.fine_prob.params.nvars) # assemble restriction as transpose of interpolation else: if not self.params.periodic: fine_grid = np.array([ (i + 1) * self.fine_prob.dx for i in range(self.fine_prob.params.nvars) ]) coarse_grid = np.array([ (i + 1) * self.coarse_prob.dx for i in range(self.coarse_prob.params.nvars) ]) else: fine_grid = np.array([ i * self.fine_prob.dx for i in range(self.fine_prob.params.nvars) ]) coarse_grid = np.array([ i * self.coarse_prob.dx for i in range(self.coarse_prob.params.nvars) ]) if self.params.rorder <= 1: self.Rspace = th.restriction_matrix_1d( fine_grid, coarse_grid, k=self.params.rorder, periodic=self.params.periodic) else: self.Rspace = 0.5 * th.interpolation_matrix_1d( fine_grid, coarse_grid, k=self.params.rorder, periodic=self.params.periodic).T self.Pspace = th.interpolation_matrix_1d( fine_grid, coarse_grid, k=self.params.iorder, periodic=self.params.periodic) # we have an n-d problem else: Rspace = [] Pspace = [] for i in range(len(self.fine_prob.params.nvars)): # if number of variables is the same on both levels, Rspace and Pspace are identity if self.coarse_prob.params.nvars == self.fine_prob.params.nvars: Rspace.append(sp.eye(self.coarse_prob.params.nvars[i])) Pspace.append(sp.eye(self.fine_prob.params.nvars[i])) # assemble restriction as transpose of interpolation else: if not self.params.periodic: fine_grid = np.array([ (j + 1) * self.fine_prob.dx for j in range(self.fine_prob.params.nvars[i]) ]) coarse_grid = np.array([ (j + 1) * self.coarse_prob.dx for j in range(self.coarse_prob.params.nvars[i]) ]) else: fine_grid = np.array([ j * self.fine_prob.dx for j in range(self.fine_prob.params.nvars[i]) ]) coarse_grid = np.array([ j * self.coarse_prob.dx for j in range(self.coarse_prob.params.nvars[i]) ]) if self.params.iorder <= 1: Rspace.append( th.restriction_matrix_1d( fine_grid, coarse_grid, k=self.params.iorder, periodic=self.params.periodic).T) else: Rspace.append(0.5 * th.interpolation_matrix_1d( fine_grid, coarse_grid, k=self.params.iorder, periodic=self.params.periodic).T) Pspace.append( th.interpolation_matrix_1d( fine_grid, coarse_grid, k=self.params.iorder, periodic=self.params.periodic)) # kronecker 1-d operators for n-d self.Pspace = Pspace[0] for i in range(1, len(Pspace)): self.Pspace = sp.kron(self.Pspace, Pspace[i], format='csc') self.Rspace = Rspace[0] for i in range(1, len(Rspace)): self.Rspace = sp.kron(self.Rspace, Rspace[i], format='csc')