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_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_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_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]) 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())