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