def test_direct_initializers(self):
np.testing.assert_equal(math.zeros([1, 16]), np.zeros([1, 16]))
self.assertEqual(math.zeros([1, 16]).dtype, np.float32)
np.testing.assert_equal(math.ones([1, 16, 1]), np.ones([1, 16, 1]))
np.testing.assert_equal(math.zeros_like(math.ones([1, 16, 1])), np.zeros([1, 16, 1]))
np.testing.assert_equal(math.randn([1, 4]).shape, [1, 4])
self.assertEqual(math.randn([1, 4]).dtype, np.float32)
def test_jit_compile(self):
@math.jit_compile
def scalar_mul(x, fac=1):
return x * fac
for backend in BACKENDS:
with backend:
x = math.ones(spatial(x=4))
trace_count_0 = len(scalar_mul.traces)
math.assert_close(scalar_mul(x, fac=1), 1, msg=backend)
if backend.supports(Backend.jit_compile):
self.assertEqual(len(scalar_mul.traces), trace_count_0 + 1)
math.assert_close(scalar_mul(x, fac=1), 1, msg=backend)
if backend.supports(Backend.jit_compile):
self.assertEqual(len(scalar_mul.traces), trace_count_0 + 1)
math.assert_close(scalar_mul(x, fac=2), 2, msg=backend)
if backend.supports(Backend.jit_compile):
self.assertEqual(len(scalar_mul.traces), trace_count_0 + 2)
math.assert_close(scalar_mul(math.zeros(spatial(x=4)), fac=2),
0,
msg=backend)
if backend.supports(Backend.jit_compile):
self.assertEqual(len(scalar_mul.traces), trace_count_0 + 2)
math.assert_close(scalar_mul(math.zeros(spatial(y=4)), fac=2),
0,
msg=backend)
if backend.supports(Backend.jit_compile):
self.assertEqual(len(scalar_mul.traces), trace_count_0 + 3)
def test_scatter_update_1d_batched(self):
for backend in BACKENDS:
with backend:
# Only base batched
base = math.zeros(spatial(x=4)) + math.tensor([0, 1])
indices = math.wrap([1, 2], instance('points'))
values = math.wrap([11, 12], instance('points'))
updated = math.scatter(base, indices, values, mode='update', outside_handling='undefined')
math.assert_close(updated, math.tensor([(0, 1), (11, 11), (12, 12), (0, 1)], spatial('x'), channel('vector')), msg=backend.name)
# Only values batched
base = math.ones(spatial(x=4))
indices = math.wrap([1, 2], instance('points'))
values = math.wrap([[11, 12], [-11, -12]], batch('batch'), instance('points'))
updated = math.scatter(base, indices, values, mode='update', outside_handling='undefined')
math.assert_close(updated, math.tensor([[1, 11, 12, 1], [1, -11, -12, 1]], batch('batch'), spatial('x')), msg=backend.name)
# Only indices batched
base = math.ones(spatial(x=4))
indices = math.wrap([[0, 1], [1, 2]], batch('batch'), instance('points'))
values = math.wrap([11, 12], instance('points'))
updated = math.scatter(base, indices, values, mode='update', outside_handling='undefined')
math.assert_close(updated, math.tensor([[11, 12, 1, 1], [1, 11, 12, 1]], batch('batch'), spatial('x')), msg=backend.name)
# Everything batched
base = math.zeros(spatial(x=4)) + math.tensor([0, 1], batch('batch'))
indices = math.wrap([[0, 1], [1, 2]], batch('batch'), instance('points'))
values = math.wrap([[11, 12], [-11, -12]], batch('batch'), instance('points'))
updated = math.scatter(base, indices, values, mode='update', outside_handling='undefined')
math.assert_close(updated, math.tensor([[11, 12, 0, 0], [1, -11, -12, 1]], batch('batch'), spatial('x')), msg=backend.name)
def test_staggered_interpolation(self):
# 2x2 cells
data_x = math.zeros([1, 2, 3, 1])
data_x[0, :, :, 0] = [[1, 2, 3], [4, 5, 6]]
data_y = math.zeros([1, 3, 2, 1])
data_y[0, :, :, 0] = [[-1, -2], [-3, -4], [-5, -6]]
v = StaggeredGrid([data_y, data_x])
centered = v.at_centers()
np.testing.assert_equal(centered.data.shape, [1, 2, 2, 2])
def test_assert_close(self):
a = spatial(a=10)
math.assert_close(math.zeros(a), math.zeros(a), math.zeros(a), rel_tolerance=0, abs_tolerance=0)
assert_not_close(math.zeros(a), math.ones(a), rel_tolerance=0, abs_tolerance=0)
for scale in (1, 0.1, 10):
math.assert_close(math.zeros(a), math.ones(a) * scale, rel_tolerance=0, abs_tolerance=scale * 1.001)
math.assert_close(math.zeros(a), math.ones(a) * scale, rel_tolerance=1, abs_tolerance=0)
assert_not_close(math.zeros(a), math.ones(a) * scale, rel_tolerance=0.9, abs_tolerance=0)
assert_not_close(math.zeros(a), math.ones(a) * scale, rel_tolerance=0, abs_tolerance=0.9 * scale)
with math.precision(64):
assert_not_close(math.zeros(a), math.ones(a) * 1e-100, rel_tolerance=0, abs_tolerance=0)
math.assert_close(math.zeros(a), math.ones(a) * 1e-100, rel_tolerance=0, abs_tolerance=1e-15)
def test_inner_interpolation(self):
data = math.zeros([1, 2, 3, 1])
data[0, :, :, 0] = [[1, 2, 3], [4, 5, 6]]
f = CenteredGrid(data, box[0:2, 0:3])
g = CenteredGrid(math.zeros([1, 2, 2, 1]), box[0:2, 0.5:2.5])
# Resample optimized
resampled = f.at(g)
self.assertTrue(resampled.compatible(g))
np.testing.assert_equal(resampled.data[0, ..., 0], [[1.5, 2.5], [4.5, 5.5]])
# Resample unoptimized
resampled2 = Field.at(f, g)
self.assertTrue(resampled2.compatible(g))
np.testing.assert_equal(resampled2.data[0, ..., 0], [[1.5, 2.5], [4.5, 5.5]])
def test_tensor_from_tensor(self):
ref = math.batch_stack([math.zeros(x=5), math.zeros(x=4)], 'stack')
for backend in (NUMPY_BACKEND, TORCH_BACKEND, TF_BACKEND):
with backend:
tens = math.tensor(ref, convert=False)
self.assertEqual(math.NUMPY_BACKEND, math.choose_backend(tens))
self.assertEqual(2, tens.shape.get_size('stack'))
self.assertEqual(('stack', 'x'), tens.shape.names)
tens = math.tensor(ref)
self.assertEqual(backend, math.choose_backend(tens))
self.assertEqual(backend, math.choose_backend(tens.stack[0]))
self.assertEqual(backend, math.choose_backend(tens.stack[1]))
tens = math.tensor(ref, names=('n1', 'n2'))
self.assertEqual(backend, math.choose_backend(tens))
def test_tensor_from_tensor(self):
ref = math.stack([math.zeros(spatial(x=5)),
math.zeros(spatial(x=4))], batch('stack'))
for backend in BACKENDS:
with backend:
tens = math.tensor(ref, convert=False)
self.assertEqual(math.NUMPY, math.choose_backend(tens))
self.assertEqual(2, tens.shape.get_size('stack'))
self.assertEqual(('stack', 'x'), tens.shape.names)
tens = math.tensor(ref)
self.assertEqual(backend, math.choose_backend(tens))
self.assertEqual(backend, math.choose_backend(tens.stack[0]))
self.assertEqual(backend, math.choose_backend(tens.stack[1]))
tens = math.tensor(ref, batch('n1', 'n2'))
self.assertEqual(backend, math.choose_backend(tens))
def test_cos(self):
for backend in BACKENDS:
with backend:
math.assert_close(math.cos(math.zeros(spatial(x=4))), 1, abs_tolerance=1e-6, msg=backend.name)
math.assert_close(math.cos(math.tensor(math.PI / 2)), 0, abs_tolerance=1e-6, msg=backend.name)
math.assert_close(math.cos(math.tensor(math.PI)), -1, abs_tolerance=1e-6, msg=backend.name)
math.assert_close(math.cos(math.tensor(math.PI * 3 / 2)), 0, abs_tolerance=1e-6, msg=backend.name)
def test_struct_initializers(self):
obj = ([4], CenteredGrid([1, 4, 1], box[0:1], content_type=struct.shape), ([9], [8, 2]))
z = math.zeros(obj)
self.assertIsInstance(z, tuple)
np.testing.assert_equal(z[0], np.zeros([4]))
z2 = math.zeros_like(z)
np.testing.assert_equal(math.shape(z)[0], math.shape(z2)[0])
def test_zeros_nonuniform(self):
nonuniform = shape_stack('stack', BATCH_DIM, shape(time=1, x=3, y=3),
shape(x=3, y=4), shape())
self.assertEqual(math.zeros(nonuniform).shape, nonuniform)
self.assertEqual(math.ones(nonuniform).shape, nonuniform)
self.assertEqual(math.random_normal(nonuniform).shape, nonuniform)
self.assertEqual(math.random_uniform(nonuniform).shape, nonuniform)
def test_flip_item_names(self):
t = math.zeros(spatial(x=4, y=3), channel(vector='x,y'))
self.assertEqual(('x', 'y'), t.vector.item_names)
t_ = t.vector.flip()
self.assertEqual(('y', 'x'), t_.vector.item_names)
t_ = t.vector[::-1]
self.assertEqual(('y', 'x'), t_.vector.item_names)
def test_collapsed(self):
scalar = math.zeros(x=4, y=3)
math.assert_close(scalar, 0)
self.assertEqual('(x=4, y=3)', repr(scalar.shape))
self.assertEqual('(x=4)', repr(scalar.y[0].shape))
self.assertEqual('()', repr(scalar.y[0].x[0].shape))
self.assertEqual(3, len(scalar.y.unstack()))
def test_collapsed(self):
scalar = math.zeros(spatial(x=4, y=3))
math.assert_close(scalar, 0)
self.assertEqual((4, 3), scalar.shape.sizes)
self.assertEqual(4, scalar.y[0].shape.size)
self.assertEqual(0, scalar.y[0].x[0].shape.rank)
self.assertEqual(3, len(scalar.y.unstack()))
def points(self,
points: Tensor or Number or tuple or list,
values: Tensor or Number = None,
radius: Tensor or float or int or None = None,
extrapolation: math.Extrapolation = math.extrapolation.ZERO,
color: str or Tensor or tuple or list or None = None) -> PointCloud:
"""
Create a `phi.field.PointCloud` from the given `points`.
The created field has no channel dimensions and all points carry the value `1`.
Args:
points: point locations in physical units
values: (optional) values of the particles, defaults to 1.
radius: (optional) size of the particles
extrapolation: (optional) extrapolation to use, defaults to extrapolation.ZERO
color: (optional) color used when plotting the points
Returns:
`phi.field.PointCloud` object
"""
extrapolation = extrapolation if isinstance(extrapolation, math.Extrapolation) else self.boundaries[extrapolation]
if radius is None:
radius = math.mean(self.bounds.size) * 0.005
# --- Parse points: tuple / list ---
if isinstance(points, (tuple, list)):
if len(points) == 0: # no points
points = math.zeros(instance(points=0), channel(vector=1))
elif isinstance(points[0], Number): # single point
points = math.tensor([points], instance('points'), channel('vector'))
else:
points = math.tensor(points, instance('points'), channel('vector'))
elements = Sphere(points, radius)
if values is None:
values = math.tensor(1.)
return PointCloud(elements, values, extrapolation, add_overlapping=False, bounds=self.bounds, color=color)
def sample(value, domain, batch_size=None, name=None):
assert isinstance(domain, Domain)
if isinstance(value, Field):
assert_same_rank(
value.rank, domain.rank,
'rank of value (%s) does not match domain (%s)' %
(value.rank, domain.rank))
if isinstance(value,
CenteredGrid) and value.box == domain.box and np.all(
value.resolution == domain.resolution):
data = value.data
else:
point_field = CenteredGrid.getpoints(domain.box,
domain.resolution)
point_field._batch_size = batch_size
data = value.at(point_field).data
else: # value is constant
if callable(value):
x = CenteredGrid.getpoints(
domain.box, domain.resolution).copied_with(
extrapolation=Material.extrapolation_mode(
domain.boundaries),
name=name)
value = value(x)
return value
components = math.staticshape(
value)[-1] if math.ndims(value) > 0 else 1
data = math.add(
math.zeros((batch_size, ) + tuple(domain.resolution) +
(components, )), value)
return CenteredGrid(data,
box=domain.box,
extrapolation=Material.extrapolation_mode(
domain.boundaries),
name=name)
def sample_at(self, points, collapse_dimensions=True):
if len(self.geometries) == 0:
return _expand_axes(math.zeros([1,1]), points, collapse_dimensions=collapse_dimensions)
if len(self.geometries) == 1:
result = self.geometries[0].value_at(points)
else:
result = math.max([geometry.value_at(points) for geometry in self.geometries], axis=0)
return math.mul(result, self.data)
def test_pad_collapsed(self):
a = math.zeros(b=2, x=10, y=10, batch=10)
p = math.pad(a, {'x': (1, 2)}, ZERO)
self.assertIsInstance(p, CollapsedTensor)
self.assertEqual((10, 2, 13, 10), p.shape.sizes)
p = math.pad(a, {'x': (1, 2)}, PERIODIC)
self.assertIsInstance(p, CollapsedTensor)
self.assertEqual((10, 2, 13, 10), p.shape.sizes)
def test_pad(self):
test_in_func_out = [
(math.zeros(spatial(x=3, y=4, z=5,
a=1)), lambda tensor: ConstantExtrapolation(0).
pad(tensor, dict(x=[1, 1], y=[1, 0], z=[0, 1], a=[0, 0])),
math.zeros(spatial(x=5, y=5, z=6, a=1))),
(math.ones(spatial(x=3, y=4, z=5,
a=1)), lambda tensor: ConstantExtrapolation(1).
pad(tensor, dict(x=[1, 1], y=[1, 0], z=[0, 1], a=[0, 0])),
math.ones(spatial(x=5, y=5, z=6, a=1))),
(-math.ones(spatial(x=3, y=4, z=5, a=1)),
lambda tensor: ConstantExtrapolation(-1).pad(
tensor, dict(x=[1, 1], y=[1, 0], z=[0, 1], a=[0, 0])),
-math.ones(spatial(x=5, y=5, z=6, a=1))),
]
for val_in, func, val_out in test_in_func_out:
math.assert_close(val_out, func(val_in))
def test_zeros_nonuniform(self):
nonuniform = shape_stack(batch('stack'),
batch(time=1) & spatial(x=3, y=3),
spatial(x=3, y=4), channel())
self.assertEqual(math.zeros(nonuniform).shape, nonuniform)
self.assertEqual(math.ones(nonuniform).shape, nonuniform)
self.assertEqual(math.random_normal(nonuniform).shape, nonuniform)
self.assertEqual(math.random_uniform(nonuniform).shape, nonuniform)
def staggered_curl_2d(grid, pad_width=(1, 2)):
assert isinstance(grid, CenteredGrid)
kernel = math.zeros((3, 3, 1, 2))
kernel[1, :, 0, 0] = [0, 1, -1] # y-component: - dz/dx
kernel[:, 1, 0, 1] = [0, -1, 1] # x-component: dz/dy
scalar_potential = grid.padded([pad_width, pad_width]).data
vector_field = math.conv(scalar_potential, kernel, padding='valid')
return StaggeredGrid(vector_field, box=grid.box)
def test_staggered_format_conversion(self):
tensor = math.zeros([1, 5, 5, 2])
tensor[:, 0, 0, :] = 1
components = unstack_staggered_tensor(tensor)
self.assertEqual(len(components), 2)
np.testing.assert_equal(components[0].shape, [1, 5, 4, 1])
np.testing.assert_equal(components[1].shape, [1, 4, 5, 1])
tensor2 = stack_staggered_components(components)
np.testing.assert_equal(tensor, tensor2)
def test_sparse_matrix(self):
for backend in BACKENDS:
with backend:
for f in ['csr', 'csc', 'coo']:
matrix = math.jit_compile_linear(
math.laplace).sparse_matrix(math.zeros(spatial(x=5)),
format=f)
self.assertEqual(f, matrix.indexing_type)
self.assertEqual((5, 5), matrix.shape)
def test_struct_initializers(self):
bounds = box[0:1] # outside unsafe
with struct.unsafe():
obj = ([4], CenteredGrid([1, 4, 1], bounds), ([9], [8, 2]))
z = math.zeros(obj)
self.assertIsInstance(z, tuple)
np.testing.assert_equal(z[0], np.zeros([4]))
z2 = math.zeros_like(z)
np.testing.assert_equal(math.shape(z)[0], math.shape(z2)[0])
def test_direct_placeholders(self):
tensorflow.reset_default_graph()
p = placeholder([4])
self.assertIsInstance(p, tensorflow.Tensor)
numpy.testing.assert_equal(p.shape.as_list(), [4])
self.assertEqual(p.name, 'Placeholder:0')
v = variable(math.zeros([2, 2]))
numpy.testing.assert_equal(v.shape.as_list(), [2, 2])
self.assertIsInstance(v, tensorflow.Variable)
self.assertEqual(v.name, 'Variable:0')
def test_tensor_from_tuple_of_tensor_like(self):
native = ((1, 2, 3), math.zeros(vector=3))
for backend in (NUMPY_BACKEND, TORCH_BACKEND, TF_BACKEND):
with backend:
tens = math.tensor(native, names=['stack', 'vector'], convert=False)
self.assertEqual(math.NUMPY_BACKEND, math.choose_backend(tens))
self.assertEqual(shape(stack=2, vector=3), tens.shape)
tens = math.tensor(native, names=['stack', 'vector'])
self.assertEqual(backend, math.choose_backend(tens))
self.assertEqual(shape(stack=2, vector=3), tens.shape)
def test_pad(self):
test_in_func_out = [
(math.zeros(x=3, y=4, z=5, a=1),
lambda tensor: ConstantExtrapolation(0).pad(tensor, dict(x=[1, 1], y=[1, 0], z=[0, 1], a=[0, 0])),
math.zeros(x=5, y=5, z=6, a=1)),
(math.ones(x=3, y=4, z=5, a=1),
lambda tensor: ConstantExtrapolation(1).pad(tensor, dict(x=[1, 1], y=[1, 0], z=[0, 1], a=[0, 0])),
math.ones(x=5, y=5, z=6, a=1)),
(-math.ones(x=3, y=4, z=5, a=1),
lambda tensor: ConstantExtrapolation(-1).pad(tensor, dict(x=[1, 1], y=[1, 0], z=[0, 1], a=[0, 0])),
- math.ones(x=5, y=5, z=6, a=1)),
]
for val_in, func, val_out in test_in_func_out:
try:
math.assert_close(val_out, func(val_in))
# TypeError('__bool__ should return bool, returned NotImplementedType')
# self.assertEqual(val_out, func(val_in))
except Exception as e:
raise BaseException(AssertionError(e, val_in, func, val_out))
def __init__(self, elements: Geometry, values: Tensor, extrapolation: float
or math.Extrapolation, resolution: Shape, bounds: Box):
if bounds.size.vector.item_names is None:
with NUMPY:
bounds = bounds.shifted(
math.zeros(channel(vector=spatial(values).names)))
SampledField.__init__(self, elements, values, extrapolation, bounds)
assert values.shape.spatial_rank == elements.spatial_rank, f"Spatial dimensions of values ({values.shape}) do not match elements {elements}"
assert values.shape.spatial_rank == bounds.spatial_rank, f"Spatial dimensions of values ({values.shape}) do not match elements {elements}"
assert values.shape.instance_rank == 0, f"Instance dimensions not supported for grids. Got values with shape {values.shape}"
self._resolution = resolution
def test_collapsed_op2(self):
# Collapsed + Collapsed
a = math.zeros(vector=4)
b = math.ones(batch=3)
c = a + b
self.assertIsInstance(c, CollapsedTensor)
self.assertEqual(c.shape.volume, 12)
self.assertEqual(c._inner.shape.volume, 1)
# Collapsed + Native
n = math.ones(vector=3) + (0, 1, 2)
math.assert_close(n, (1, 2, 3))
def test_tensor_from_tuple_of_tensor_like(self):
native = ([1, 2, 3], math.zeros(channel(vector=3)))
for backend in BACKENDS:
with backend:
tens = wrap(native, batch(stack=2), channel(vector=3))
self.assertEqual(math.NUMPY, math.choose_backend(tens))
self.assertEqual(
batch(stack=2) & channel(vector=3), tens.shape)
tens = tensor(native, batch(stack=2), channel(vector=3))
self.assertEqual(backend, math.choose_backend(tens))
self.assertEqual(
batch(stack=2) & channel(vector=3), tens.shape)
