def test_dim_alternate_condition(self):
g1 = Mock(axes=["x"],
positions={"x": np.array([1, 2, 3])},
bounds={"x": np.array([0.5, 1.5, 2.5, 3.5])},
size=3,
alternate=True)
g2 = Mock(axes=["y"],
positions={"y": np.array([1, 2, 3])},
bounds={"y": np.array([0.5, 1.5, 2.5, 3.5])},
size=3,
alternate=False)
g3 = Mock(axes=["z"],
positions={"z": np.array([1, 2, 3])},
bounds={"z": np.array([0.5, 1.5, 2.5, 3.5])},
size=3,
alternate=True)
d1 = Dimension([g1, g3])
d2 = Dimension([g2, g3])
self.assertEqual(True, d1.alternate)
self.assertEqual(False, d2.alternate)
d1.prepare()
d2.prepare()
self.assertEqual(True, d1.alternate)
self.assertEqual(False, d2.alternate)
def test_positions_non_alternate(self):
g1, g2, g3 = Mock(), Mock(), Mock()
g1.axes, g2.axes, g3.axes = ["g1"], ["g2"], ["g3"]
g1.size, g2.size, g3.size = 3, 4, 5
g1.positions = {"g1": np.array([0, 1, 2])}
g1.bounds = {"g1": np.array([-0.5, 0.5, 1.5, 2.5])}
g2.positions = {"g2": np.array([-1, 0, 1, 2])}
g2.bounds = {"g2": np.array([-1.5, -0.5, 0.5, 1.5, 2.5])}
g3.positions = {"g3": np.array([-2, 0, 2, 4, 6])}
g3.bounds = {"g3": np.array([-3, -1, 1, 3, 5, 7])}
g1.alternate = False
g2.alternate = False
g3.alternate = False
e1, e2 = Mock(), Mock()
e1.axes = ["g1", "g2"]
e2.axes = ["g2", "g3"]
m1 = np.repeat(np.array([0, 1, 0, 1, 1, 0]), 10)
m2 = np.tile(np.array([1, 0, 0, 1, 1, 1]), 10)
e1.create_mask.return_value = m1
e2.create_mask.return_value = m2
d = Dimension([g1, g2, g3], [e1, e2])
d.prepare()
expected_mask = m1 & m2
expected_indices = expected_mask.nonzero()[0]
expected_g1 = np.repeat(g1.positions["g1"], 5 * 4)[expected_indices]
expected_g2 = np.tile(np.repeat(g2.positions["g2"], 5),
3)[expected_indices]
expected_g3 = np.tile(g3.positions["g3"], 3 * 4)[expected_indices]
self.assertEqual(expected_mask.tolist(), d.mask.tolist())
self.assertEqual(expected_indices.tolist(), d.indices.tolist())
self.assertEqual(expected_g1.tolist(), d.positions["g1"].tolist())
self.assertEqual(expected_g2.tolist(), d.positions["g2"].tolist())
self.assertEqual(expected_g3.tolist(), d.positions["g3"].tolist())
def test_get_mesh_map(self):
# Set up a generator, with 3x4 grid with alternating x and a circular
# excluder such that the four 'corners' of the grid are excluded
gx_pos = np.array([0.1, 0.2, 0.3])
gx_bounds = np.array([0.05, 0.15, 0.25, 0.35])
gy_pos = np.array([1.1, 1.2, 1.3, 1.4])
mask_func = lambda px, py: (px - 0.2)**2 + (py - 1.25)**2 <= 0.0225
gx = Mock(axes=["gx"],
positions={"gx": gx_pos},
bounds={"gx": gx_bounds},
size=3,
alternate=True)
gy = Mock(axes=["gy"],
positions={"gy": gy_pos},
size=4,
alternate=False)
e = Mock(axes=["gx", "gy"], create_mask=Mock(side_effect=mask_func))
d = Dimension([gy, gx], [e])
d.prepare()
self.assertEqual([1, 2, 1, 0, 0, 1, 2, 1],
d.get_mesh_map("gx").tolist())
self.assertEqual([0, 1, 1, 1, 2, 2, 2, 3],
d.get_mesh_map("gy").tolist())
def test_mixed_alternating_generators(self):
x_pos = np.array([0, 1, 2])
x_bounds = np.array([-0.5, 0.5, 1.5, 2.5])
y_pos = np.array([10, 11, 12])
z_pos = np.array([20, 21, 22])
w_pos = np.array([30, 31, 32])
gx = Mock(axes=["x"],
positions={"x": x_pos},
bounds={"x": x_bounds},
size=3,
alternate=True)
gy = Mock(axes=["y"], positions={"y": y_pos}, size=3, alternate=True)
gz = Mock(axes=["z"], positions={"z": z_pos}, size=3, alternate=False)
gw = Mock(axes=["w"], positions={"w": w_pos}, size=3, alternate=False)
mask = np.array([1, 1, 0, 1, 1, 1, 1, 0, 1] * 9)
indices = np.nonzero(mask)[0]
e = Mock(axes=["x", "y", "z", "w"])
e.create_mask.return_value = mask
d = Dimension([gw, gz, gy, gx], [e])
d.prepare()
expected_x = np.append(np.tile(np.append(x_pos, x_pos[::-1]), 13),
x_pos)[indices]
expected_y = np.repeat(
np.append(np.tile(np.append(y_pos, y_pos[::-1]), 4), y_pos),
3)[indices]
expected_z = np.tile(np.repeat(z_pos, 9), 3)[indices]
expected_w = np.repeat(w_pos, 27)[indices]
self.assertEqual(False, d.alternate)
self.assertEqual(expected_x.tolist(), d.get_positions("x").tolist())
self.assertEqual(expected_y.tolist(), d.get_positions("y").tolist())
self.assertEqual(expected_z.tolist(), d.get_positions("z").tolist())
self.assertEqual(expected_w.tolist(), d.get_positions("w").tolist())
def test_single_alternating_generator_with_excluder(self):
x_pos = np.array([0, 1, 2, 3, 4, 5])
x_bounds = np.array([-0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5])
y_pos = np.array([10, 11, 12, 13, 14, 15])
y_bounds = np.array([9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5])
g = Mock(axes=["x", "y"],
positions={
"x": x_pos,
"y": y_pos
},
bounds={
"x": x_bounds,
"y": y_bounds
},
size=6)
g.alternate = True
mask = np.array([1, 1, 0, 1, 0, 0], dtype=np.int8)
e = Mock(axes=["x", "y"], create_mask=Mock(return_value=mask))
d = Dimension([g], [e])
self.assertTrue(d.alternate)
d.prepare()
expected_x = [0, 1, 3]
expected_y = [10, 11, 13]
self.assertEqual(expected_x, d.positions["x"].tolist())
self.assertEqual(expected_y, d.positions["y"].tolist())
def test_prepare(self):
d = Dimension(
Mock(axes=["x", "y"],
positions={
"x": np.array([0]),
"y": np.array([0])
},
size=30))
m1 = np.array([0, 1, 0, 1, 1, 0], dtype=np.int8)
m2 = np.array([1, 1, 0, 0, 1], dtype=np.int8)
d._masks = [{
"repeat": 2,
"tile": 2.5,
"mask": m1
}, {
"repeat": 2,
"tile": 3,
"mask": m2
}]
e1 = np.array([0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0], dtype=np.int8)
e1 = np.append(np.tile(e1, 2), e1[:len(e1) // 2])
e2 = np.array([1, 1, 1, 1, 0, 0, 0, 0, 1, 1], dtype=np.int8)
e2 = np.tile(e2, 3)
expected = e1 & e2
d.prepare()
self.assertEqual(expected.tolist(), d.mask.tolist())
def test_get_positions_single_gen(self):
gx_pos = np.tile(np.array([0, 1, 2, 3]), 4)
gy_pos = np.repeat(np.array([0, 1, 2, 3]), 4)
mask_func = lambda px, py: (px-1)**2 + (py-2)**2 <= 1
g = Mock(axes=["gx", "gy"], positions={"gx":gx_pos, "gy":gy_pos}, size=16, alternate=False)
e = Mock(axes=["gx", "gy"], create_mask=Mock(side_effect=mask_func))
d = Dimension(g)
d.apply_excluder(e)
d.prepare()
self.assertEqual([1, 0, 1, 2, 1], d.get_positions("gx").tolist())
self.assertEqual([1, 2, 2, 2, 3], d.get_positions("gy").tolist())
def test_single_axis_excluder(self):
x_pos = np.array([0, 1, 2, 3, 4, 5])
y_pos = np.array([10, 11, 12, 13, 14, 15])
g = Mock(axes=["x", "y"], positions={"x":x_pos, "y":y_pos}, size=len(x_pos))
g.alternate = False
e = Mock(axes=["x"], create_mask=lambda x: (2 <= x) & (x < 4) | (x == 5))
d = Dimension(g)
d.apply_excluder(e)
d.prepare()
self.assertEqual([2, 3, 5], d.get_positions('x').tolist())
self.assertEqual([12, 13, 15], d.get_positions('y').tolist())
def test_excluder_over_spread_axes(self):
gw_pos = np.array([0.1, 0.2])
gw_bounds = np.array([0.05, 0.15, 0.25])
gx_pos = np.array([0, 1, 2, 3])
gy_pos = np.array([10, 11, 12, 13])
gz_pos = np.array([100, 101, 102, 103])
go_pos = np.array([1000, 1001, 1002])
mask_xz_func = lambda px, pz: (px - 1)**2 + (pz - 102)**2 <= 1
exz = Mock(axes=["gx", "gz"],
create_mask=Mock(side_effect=mask_xz_func))
gw = Mock(axes=["gw"],
positions={"gw": gw_pos},
bounds={"gw": gw_bounds},
size=2,
alternate=False)
gx = Mock(axes=["gx"],
positions={"gx": gx_pos},
size=4,
alternate=False)
gy = Mock(axes=["gy"],
positions={"gy": gy_pos},
size=4,
alternate=False)
gz = Mock(axes=["gz"],
positions={"gz": gz_pos},
size=4,
alternate=False)
go = Mock(axes=["go"],
positions={"go": go_pos},
size=3,
alternate=False)
d = Dimension([go, gz, gy, gx, gw], [exz])
d.prepare()
x_positions = np.tile(np.array([0, 1, 2, 3]), 16)
y_positions = np.repeat(np.tile(np.array([10, 11, 12, 13]), 4), 4)
z_positions = np.repeat(np.array([100, 101, 102, 103]), 16)
x_positions = np.tile(np.repeat(x_positions, gw.size), go.size)
y_positions = np.tile(np.repeat(y_positions, gw.size), go.size)
z_positions = np.tile(np.repeat(z_positions, gw.size), go.size)
mask = mask_xz_func(x_positions, z_positions)
expected_x = x_positions[mask].tolist()
expected_y = y_positions[mask].tolist()
expected_z = z_positions[mask].tolist()
self.assertEqual(expected_x, d.get_positions("gx").tolist())
self.assertEqual(expected_y, d.get_positions("gy").tolist())
self.assertEqual(expected_z, d.get_positions("gz").tolist())
def test_init(self):
g = Mock()
g.axes = ["x", "y"]
g.positions = {"x":np.array([0, 1, 2]), "y":np.array([10, 11, 12])}
g.size = 3
d = Dimension(g)
d.prepare()
self.assertEqual([g], d.generators)
self.assertEqual(["x", "y"], d.axes)
self.assertEqual([], d._masks)
self.assertEqual(g.alternate, d.alternate)
self.assertEqual(g.size, d.size)
self.assertEqual([2, 12], d.upper)
self.assertEqual([0, 10], d.lower)
def test_high_dimensional_excluder(self):
w_pos = np.array([0, 1, 2, 3, 4, 5])
w_bounds = np.array([-0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5])
x_pos = np.array([0, 1, 2, 3, 4, 5])
y_pos = np.array([0, 1, 2, 3, 4, 5])
z_pos = np.array([0, 1, 2, 3, 4, 5])
mask_function = lambda pw, px, py, pz: (pw - 2)**2 + (px - 2)**2 + (
py - 1)**2 + (pz - 3)**2 <= 1.1
excluder = Mock(axes=["w", "x", "y", "z"],
create_mask=Mock(side_effect=mask_function))
gw = Mock(axes=["w"],
positions={"w": w_pos},
bounds={"w": w_bounds},
size=len(w_pos),
alternate=False)
gx = Mock(axes=["x"],
positions={"x": x_pos},
size=len(x_pos),
alternate=False)
gy = Mock(axes=["y"],
positions={"y": y_pos},
size=len(y_pos),
alternate=False)
gz = Mock(axes=["z"],
positions={"z": z_pos},
size=len(z_pos),
alternate=False)
d = Dimension([gz, gy, gx, gw], [excluder])
d.prepare()
w_positions = np.tile(w_pos, len(x_pos) * len(y_pos) * len(z_pos))
x_positions = np.repeat(np.tile(x_pos,
len(y_pos) * len(z_pos)), len(w_pos))
y_positions = np.repeat(np.tile(y_pos, len(z_pos)),
len(w_pos) * len(x_pos))
z_positions = np.repeat(z_pos, len(w_pos) * len(x_pos) * len(y_pos))
mask = mask_function(w_positions, x_positions, y_positions,
z_positions)
w_expected = w_positions[mask].tolist()
x_expected = x_positions[mask].tolist()
y_expected = y_positions[mask].tolist()
z_expected = z_positions[mask].tolist()
self.assertEqual(w_expected, d.get_positions("w").tolist())
self.assertEqual(x_expected, d.get_positions("x").tolist())
self.assertEqual(y_expected, d.get_positions("y").tolist())
self.assertEqual(z_expected, d.get_positions("z").tolist())
def test_spread_excluder_multi_axes_per_gen(self):
gx1_pos = np.array([1, 2, 3, 4, 5])
gx1_bounds = np.array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5])
gx2_pos = np.array([11, 10, 9, 8, 7])
gx2_bounds = np.array([11.5, 10.5, 9.5, 8.5, 7.5, 6.5])
gy_pos = np.array([-1, 0, 1])
gz_pos = np.array([1, 0, -1, -2, -3])
mask_x1z_func = lambda px, pz: (px - 4)**2 + (pz + 1)**2 <= 1
exz = Mock(axes=["gx1", "gz"],
create_mask=Mock(side_effect=mask_x1z_func))
gx = Mock(axes=["gx1", "gx2"],
positions={
"gx1": gx1_pos,
"gx2": gx2_pos
},
bounds={
"gx1": gx1_bounds,
"gx2": gx2_bounds
},
size=5,
alternate=False)
gy = Mock(axes=["gy"],
positions={"gy": gy_pos},
size=3,
alternate=False)
gz = Mock(axes=["gz"],
positions={"gz": gz_pos},
size=5,
alternate=False)
d = Dimension([gz, gy, gx], [exz])
d.prepare()
x1_positions = np.tile(gx1_pos, 15)
x2_positions = np.tile(gx2_pos, 15)
y_positions = np.repeat(np.tile(gy_pos, 5), 5)
z_positions = np.repeat(gz_pos, 15)
mask = mask_x1z_func(x1_positions, z_positions)
expected_x1 = x1_positions[mask].tolist()
expected_x2 = x2_positions[mask].tolist()
expected_y = y_positions[mask].tolist()
expected_z = z_positions[mask].tolist()
self.assertEqual(expected_x1, d.get_positions("gx1").tolist())
self.assertEqual(expected_x2, d.get_positions("gx2").tolist())
self.assertEqual(expected_y, d.get_positions("gy").tolist())
self.assertEqual(expected_z, d.get_positions("gz").tolist())
def test_init(self):
g = Mock()
g.axes = ["x", "y"]
g.positions = {"x": np.array([0, 1, 2]), "y": np.array([10, 11, 12])}
g.bounds = {
"x": np.array([-0.5, 0.5, 1.5, 2.5]),
"y": np.array([9.5, 10.5, 11.5, 12.5])
}
g.size = 3
d = Dimension([g])
d.prepare()
self.assertEqual([g], d.generators)
self.assertEqual([], d.excluders)
self.assertEqual(["x", "y"], d.axes)
self.assertEqual(g.alternate, d.alternate)
self.assertEqual(g.size, d.size)
self.assertEqual([2, 12], d.upper)
self.assertEqual([0, 10], d.lower)
def test_positions_alternating(self):
g1, g2 = Mock(), Mock()
g1.axes = ["z"]
g2.axes = ["x", "y"]
g1.positions = {"z": np.array([100, 200, 300, 400])}
g1.bounds = {"z": np.array([50, 150, 250, 350, 450])}
g2.positions = {
"x": np.array([10, 11, 12]),
"y": np.array([-1, -2, -3])
}
g2.bounds = {
"x": np.array([9.5, 10.5, 11.5, 12.5]),
"y": np.array([-0.5, -1.5, -2.5, -3.5])
}
g1.size, g2.size = 4, 3
g1.alternate, g2.alternate = False, True
e1, e2 = Mock(), Mock()
e1.axes = ["x", "y"]
e2.axes = ["x", "z"]
m1 = np.array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1])
m2 = np.array([1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1])
e1.create_mask.return_value = m1
e2.create_mask.return_value = m2
d = Dimension([g1, g2], [e1, e2])
d.prepare()
expected_mask = m1 & m2
expected_indices = expected_mask.nonzero()[0]
expected_x = [10, 11, 12, 11, 12, 11, 10]
expected_y = [-1, -2, -3, -2, -3, -2, -1]
expected_z = [100, 100, 200, 200, 300, 400, 400]
self.assertEqual(7, d.size)
self.assertEqual(expected_mask.tolist(), d.mask.tolist())
self.assertEqual(expected_indices.tolist(), d.indices.tolist())
self.assertEqual(expected_x, d.positions["x"].tolist())
self.assertEqual(expected_y, d.positions["y"].tolist())
self.assertEqual(expected_z, d.positions["z"].tolist())
def test_single_axis_excluder(self):
x_pos = np.array([0, 1, 2, 3, 4, 5])
x_bounds = np.array([-0.5, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5])
y_pos = np.array([10, 11, 12, 13, 14, 15])
y_bounds = np.array([9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5])
g = Mock(axes=["x", "y"],
positions={
"x": x_pos,
"y": y_pos
},
bounds={
"x": x_bounds,
"y": y_bounds
},
size=len(x_pos))
g.alternate = False
e = Mock(axes=["x"],
create_mask=lambda x: (2 <= x) & (x < 4) | (x == 5))
d = Dimension([g], [e])
d.prepare()
self.assertEqual([2, 3, 5], d.get_positions('x').tolist())
self.assertEqual([12, 13, 15], d.get_positions('y').tolist())
