def __init__(self,
N,
padding_factor=1.,
domain=(0, 2 * np.pi),
dealias_direct=False):
self.dealias_direct = dealias_direct
SpectralBase.__init__(self, N, '', padding_factor, domain)
def __init__(self,
N,
quad="JG",
alpha=0,
beta=0,
domain=(-1., 1.),
dtype=np.float,
padding_factor=1,
dealias_direct=False,
coordinates=None):
SpectralBase.__init__(self,
N,
quad=quad,
domain=domain,
dtype=dtype,
padding_factor=padding_factor,
dealias_direct=dealias_direct,
coordinates=coordinates)
self.alpha = alpha
self.beta = beta
self.forward = functools.partial(self.forward, fast_transform=False)
self.backward = functools.partial(self.backward, fast_transform=False)
self.scalar_product = functools.partial(self.scalar_product,
fast_transform=False)
self.plan(int(N * padding_factor), 0, dtype, {})
def __init__(self, N, quad="LG", dtype=np.float, padding_factor=1, dealias_direct=False, coordinates=None):
SpectralBase.__init__(self, N, quad=quad, domain=(0., np.inf), dtype=dtype,
padding_factor=padding_factor, dealias_direct=dealias_direct,
coordinates=coordinates)
self.forward = functools.partial(self.forward, fast_transform=False)
self.backward = functools.partial(self.backward, fast_transform=False)
self.scalar_product = functools.partial(self.scalar_product, fast_transform=False)
def evaluate_expansion_all(self,
input_array,
output_array,
fast_transform=True):
if fast_transform is False:
SpectralBase.evaluate_expansion_all(self, input_array,
output_array, False)
else:
self.backward.xfftn(normalise_idft=False)
def __init__(self,
N,
padding_factor=1.,
domain=(0, 2 * np.pi),
dealias_direct=False):
self.dealias_direct = dealias_direct
self._k = None
self._planned_axes = None # Collapsing of axes means that this base can be used to plan transforms over several collapsed axes. Store the axes planned for here.
SpectralBase.__init__(self, N, '', padding_factor, domain)
def evaluate_expansion_all(self, input_array, output_array, fast_transform=True):
if fast_transform is False:
SpectralBase.evaluate_expansion_all(self, input_array, output_array, False)
return
w_hat = work[(input_array, 0)]
self.set_factor_arrays(input_array)
w_hat = self.set_w_hat(w_hat, input_array, self._factor1, self._factor2)
self.CT.backward(w_hat)
assert input_array is self.backward.input_array
assert output_array is self.backward.output_array
def evaluate_expansion_all(self, input_array, output_array, fast_transform=True):
if fast_transform is False:
SpectralBase.evaluate_expansion_all(self, input_array, output_array, False)
return
w_hat = work[(input_array, 0)]
self.set_factor_array(input_array)
s0 = self.sl(slice(0, -2))
s1 = self.sl(slice(2, None))
w_hat[s0] = input_array[s0]
w_hat[s1] -= self._factor*input_array[s0]
self.CT.backward(w_hat)
assert output_array is self.CT.backward.output_array
def evaluate_expansion_all(self, input_array, output_array, fast_transform=True):
if fast_transform is False:
SpectralBase.evaluate_expansion_all(self, input_array, output_array, False)
return
w_hat = work[(input_array, 0)]
s0 = self.sl(slice(0, -2))
s1 = self.sl(slice(2, None))
w_hat[s0] = input_array[s0]
w_hat[s1] -= input_array[s0]
self.bc.apply_before(w_hat, False, (0.5, 0.5))
self.CT.backward(w_hat)
assert output_array is self.CT.backward.output_array
def _evaluate_expansion_all(self,
input_array,
output_array,
x=None,
fast_transform=True):
if fast_transform is False:
SpectralBase._evaluate_expansion_all(self, input_array,
output_array, x, False)
return
assert input_array is self.backward.tmp_array
assert output_array is self.backward.output_array
self.backward.xfftn(normalise_idft=False)
def __init__(self,
N,
padding_factor=1,
domain=(0, 2 * np.pi),
dtype=float,
dealias_direct=False,
coordinates=None):
self._k = None
self._planned_axes = None # Collapsing of axes means that this base can be used to plan transforms over several collapsed axes. Store the axes planned for here.
SpectralBase.__init__(self,
N,
dtype=dtype,
padding_factor=padding_factor,
dealias_direct=dealias_direct,
domain=domain,
coordinates=coordinates)
def __init__(self,
N,
quad="LG",
domain=(-1., 1.),
padding_factor=1,
dealias_direct=False):
SpectralBase.__init__(self,
N,
quad=quad,
domain=domain,
padding_factor=padding_factor,
dealias_direct=dealias_direct)
self.forward = functools.partial(self.forward, fast_transform=False)
self.backward = functools.partial(self.backward, fast_transform=False)
self.scalar_product = functools.partial(self.scalar_product,
fast_transform=False)
def forward(self,
input_array=None,
output_array=None,
fast_transform=True,
padding_factor=1):
if padding_factor > 1:
assert self._padded_basis is not None
output_array = self._padded_basis.forward(
input_array, output_array, fast_transform=fast_transform)
return output_array
if fast_transform is False:
return SpectralBase.forward(self, input_array, output_array, False)
if input_array is not None:
self.forward.input_array[...] = input_array
self.forward.xfftn()
self._truncation_forward(self.forward.tmp_array,
self.forward.output_array)
M = self.get_normalization()
self.forward._output_array *= M
if output_array is not None:
output_array[...] = self.forward.output_array
return output_array
return self.forward.output_array
def scalar_product(self,
input_array=None,
output_array=None,
fast_transform=False):
output = SpectralBase.scalar_product(self, input_array, output_array,
False)
output[self.si[0]] = self.mean * np.pi
output[self.sl[slice(-2, None)]] = 0
return output
def evaluate_expansion_all(self, input_array, output_array, fast_transform=True):
if fast_transform is False:
SpectralBase.evaluate_expansion_all(self, input_array, output_array, False)
return
output_array = self.backward.xfftn()
s0 = self.sl(slice(0, 1))
if self.quad == "GC":
output_array *= 0.5
output_array += input_array[s0]/2
elif self.quad == "GL":
output_array *= 0.5
output_array += input_array[s0]/2
s0[self.axis] = slice(-1, None)
s2 = self.sl(slice(0, None, 2))
output_array[s2] += input_array[s0]/2
s2[self.axis] = slice(1, None, 2)
output_array[s2] -= input_array[s0]/2
def forward(self, input_array=None, output_array=None, fast_transform=True):
if fast_transform is False:
return SpectralBase.forward(self, input_array, output_array, False)
if input_array is not None:
self.forward.input_array[...] = input_array
self.forward.xfftn()
self._truncation_forward(self.forward.tmp_array,
self.forward.output_array)
M = self.get_normalization()
self.forward._output_array *= M
if output_array is not None:
output_array[...] = self.forward.output_array
return output_array
return self.forward.output_array
def forward(self,
input_array=None,
output_array=None,
fast_transform=True):
if fast_transform is False:
return SpectralBase.forward(self, input_array, output_array, False)
if input_array is not None:
self.forward.input_array[...] = input_array
self.forward.xfftn()
self._truncation_forward(self.forward.tmp_array,
self.forward.output_array)
self.forward._output_array *= (1. / self.N / self.padding_factor)
if output_array is not None:
output_array[...] = self.forward.output_array
return output_array
return self.forward.output_array
def __init__(self, N=0, quad="GC", domain=(-1., 1.)):
assert quad in ('GC', 'GL')
SpectralBase.__init__(self, N, quad, domain=domain)
def vandermonde_scalar_product(self, input_array, output_array):
SpectralBase.vandermonde_scalar_product(self, input_array,
output_array)
output_array[self.si[-2]] = 0
output_array[self.si[-1]] = 0
def _evaluate_scalar_product(self, fast_transform=True):
SpectralBase._evaluate_scalar_product(self)
self.scalar_product.output_array[self.sl[slice(-6, None)]] = 0
def apply_inverse_mass(self, array):
if not self.coors.is_cartesian: # mass matrix may not be diagonal
return SpectralBase.apply_inverse_mass(self, array)
return array
def _evaluate_scalar_product(self, fast_transform=True):
if fast_transform is False:
SpectralBase._evaluate_scalar_product(self)
return
output = self.scalar_product.xfftn()
output *= self.get_normalization()
def apply_inverse_mass(self, array):
coors = self.tensorproductspace.coors if self.tensorproductspace else self.coors
if not coors.is_cartesian: # mass matrix may not be diagonal, or there is scaling
return SpectralBase.apply_inverse_mass(self, array)
return array
def __init__(self, N=0, quad="LG", domain=(-1., 1.)):
SpectralBase.__init__(self, N, quad, domain=domain)
self.forward = functools.partial(self.forward, fast_transform=False)
self.backward = functools.partial(self.backward, fast_transform=False)
self.scalar_product = functools.partial(self.scalar_product, fast_transform=False)
def __init__(self, N=0, quad="HG", bc=(0., 0.)):
SpectralBase.__init__(self, N, quad, domain=(-np.inf, np.inf))
self.forward = functools.partial(self.forward, fast_transform=False)
self.backward = functools.partial(self.backward, fast_transform=False)
self.scalar_product = functools.partial(self.scalar_product, fast_transform=False)
self.plan(N, 0, np.float, {})
def vandermonde_scalar_product(self, input_array, output_array):
SpectralBase.vandermonde_scalar_product(self, input_array, output_array)
output_array *= 0.5/np.pi
def vandermonde_scalar_product(self, input_array, output_array):
SpectralBase.vandermonde_scalar_product(self, input_array,
output_array)
output_array[self.sl[slice(-6, None)]] = 0
