def poisson_gradient(_op, grad):
return poisson_solve(CenteredGrid.sample(
grad, poisson_domain.domain),
poisson_domain,
solver,
None,
gradient=gradient)[0].data
def centered_grid(self,
data,
components=1,
dtype=None,
name=None,
batch_size=None,
extrapolation=None):
warnings.warn(
"Domain.centered_shape and Domain.centered_grid are deprecated. Use CenteredGrid.sample() instead.",
DeprecationWarning)
from phi.physics.field import CenteredGrid
if callable(data): # data is an initializer
shape = self.centered_shape(components,
batch_size=batch_size,
name=name,
extrapolation=extrapolation,
age=())
try:
grid = data(shape, dtype=dtype)
except TypeError:
grid = data(shape)
if grid.age == ():
grid._age = 0.0
else:
grid = CenteredGrid.sample(data, self, batch_size=batch_size)
assert grid.component_count == components, "Field has %d components but %d are required for '%s'" % (
grid.component_count, components, name)
if dtype is not None and math.dtype(grid.data) != dtype:
grid = grid.copied_with(data=math.cast(grid.data, dtype))
if name is not None:
grid = grid.copied_with(name=name, tags=(name, ) + grid.tags)
if extrapolation is not None:
grid = grid.copied_with(extrapolation=extrapolation)
return grid
def test_subtraction_centered_grid(self):
"""subtract one field from another"""
shape = [32, 27]
for boundary in [CLOSED, PERIODIC, OPEN]:
domain = Domain(shape, boundaries=(boundary, boundary))
centered_grid = CenteredGrid.sample(Noise(), domain)
result_array = (centered_grid - centered_grid).data
np.testing.assert_array_equal(result_array, 0)
def test_addition_centered_grid(self):
"""add one field to another"""
shape = [32, 27]
for boundary in [CLOSED, PERIODIC, OPEN]:
domain = Domain(shape, boundaries=(boundary, boundary))
centered_grid = CenteredGrid.sample(1, domain)
result_array = (centered_grid + centered_grid).data
np.testing.assert_array_equal(result_array, 2)
def test_division_centered_grid(self):
"""divide one field by another"""
shape = [32, 27]
for boundary in [CLOSED, PERIODIC, OPEN]:
domain = Domain(shape, boundaries=(boundary, boundary))
centered_grid = CenteredGrid.sample(2, domain)
result_array = (centered_grid / centered_grid.copied_with(
data=4 * np.ones([1] + shape + [1]))).data
np.testing.assert_array_equal(result_array, 1. / 2)
def test_multiplication_centered_grid(self):
"""multiply one field with another"""
shape = [32, 27]
for boundary in [CLOSED, PERIODIC, OPEN]:
domain = Domain(shape, boundaries=(boundary, boundary))
centered_grid = CenteredGrid.sample(1, domain)
result_array = (centered_grid * centered_grid.copied_with(
data=2 * np.ones([1] + shape + [1]))).data
np.testing.assert_array_equal(result_array, 2)
def test_reconst(self, set_accuracy=1e-5, shape=[40, 40], first_order_tolerance=3, second_order_tolerance=40,
boundary_list=[PERIODIC, OPEN, CLOSED]):
for boundary in boundary_list:
domain = Domain(shape, boundaries=(boundary, boundary))
solver_list = [
('SparseCG', lambda field: poisson_solve(field, domain, SparseCG(accuracy=set_accuracy)), lambda field: field.laplace()),
('GeometricCG', lambda field: poisson_solve(field, domain, GeometricCG(accuracy=set_accuracy)), lambda field: field.laplace()),
#('SparseSciPy', lambda field: poisson_solve(field, domain, SparseSciPy()), lambda field: field.laplace()),
# ('Fourier', lambda field: poisson_solve(field, domain, Fourier()))] # TODO: poisson_solve() causes resolution to be empty
('FFT', math.fourier_poisson, math.fourier_laplace)]
in_data = CenteredGrid.sample(Noise(), domain)
sloped_data = (np.array([np.arange(shape[1]) for _ in range(shape[0])]).reshape([1] + shape + [1]) / 10 + 1)
in_data = in_data.copied_with(data=sloped_data)
for name, solver, laplace in solver_list:
print('Testing {} boundary with {} solver... '.format(boundary, name)),
_test_reconstruction_first_order(in_data, solver, laplace, set_accuracy, name, first_order_tolerance=first_order_tolerance)
_test_reconstruction_second_order(in_data, solver, laplace, set_accuracy, name, second_order_tolerance=second_order_tolerance)
print('Testing {} boundary with {} solver... '.format(boundary, 'higher order FFT')),
_run_higher_order_fft_reconstruction(in_data, set_accuracy, order=2, tolerance=second_order_tolerance)
def poisson_gradient(_op, grad):
return CenteredGrid.sample(
grad,
poisson_domain.domain).laplace(physical_units=False).data
def test_staggered_curl2d(self):
domain = Domain([32, 32])
pot = CenteredGrid.sample(Noise(), domain)
vel = staggered_curl_2d(pot)
div = vel.divergence()
np.testing.assert_almost_equal(div.data, 0, decimal=5)