def test_grid_data_rmul_1D_data(self):
x1 = (1., 2.)
x2 = (10, 20)
grid = gr.CartesianGrid((x1, x2))
d1 = np.array([[1., 2.], [3., 4.]])
d_sum = 2 * d1
expected = gr.GridData(d_sum, grid)
actual = 2 * gr.GridData(d1, grid)
self.assertEqual(expected, actual)
def test_grid_data_diff_1D_data(self):
x1 = (1., 2.)
x2 = (10, 20)
grid = gr.CartesianGrid((x1, x2))
d1 = np.array([[1., 2.], [3., 4.]])
d2 = np.array([[10., 20.], [30., 40.]])
d_sum = d1 - d2
expected = gr.GridData(d_sum, grid)
actual = gr.GridData(d1, grid) - gr.GridData(d2, grid)
self.assertEqual(expected, actual)
def test_grid_data_rmul_2D_data(self):
x1 = (1., 2.)
x2 = (10, 20)
grid = gr.CartesianGrid((x1, x2))
d1 = np.array([[1., 2.], [3., 4.]])
d2 = np.array([[10., 20.], [30., 40.]])
d_sum_0 = 2 * d1
d_sum_1 = 2 * d2
expected = gr.GridData((d_sum_0, d_sum_1), grid)
actual = 2 * gr.GridData((d1, d2), grid)
self.assertEqual(expected, actual)
def test_grid_data_like(self):
x1 = (1., 2.)
x2 = (100, 200)
data2d = (np.array([['a', 'b'], ['c', 'd']]), np.array([[1, 2], [3,
4]]))
grid2d = gr.CartesianGrid((x1, x2))
g_d = gr.GridData(data2d, grid2d)
data2d_other = (np.array([['e', 'f'],
['g', 'h']]), np.array([[10, 20], [30, 40]]))
g_expected = gr.GridData(data2d_other, grid2d)
g_test = g_d.like(data2d_other)
self.assertEqual(g_test, g_expected)
def test_grid_data_diff_2D_data(self):
x1 = (1., 2.)
x2 = (10, 20)
grid = gr.CartesianGrid((x1, x2))
d1 = np.array([[1., 2.], [3., 4.]])
d2 = np.array([[10., 20.], [30., 40.]])
d_sum_0 = d1 - d2
d_sum_1 = -2 * d2 - d1
expected = gr.GridData((d_sum_0, d_sum_1), grid)
actual = gr.GridData((d1, -1 * d1), grid) - gr.GridData(
(d2, 2 * d2), grid)
self.assertEqual(expected, actual)
def test_grid_data_getitem_overload_1D_data(self):
x1 = (1., 2.)
x2 = (100, 200)
grid2d = gr.CartesianGrid((x1, x2))
data1d = np.array([['a', 'b'], ['c', 'd']])
d1d2 = grid2d.grid[0] + grid2d.grid[1]
g_d = gr.GridData(data1d, grid2d)
g_d2 = gr.GridData(d1d2, grid2d)
self.assertEqual(('a', (1., 100)), g_d[0, 0])
self.assertEqual(('c', (2., 100)), g_d[1, 0])
self.assertEqual(('b', (1., 200)), g_d[0, 1])
self.assertEqual(('d', (2., 200)), g_d[1, 1])
self.assertEqual((101, (1., 100)), g_d2[0, 0])
self.assertEqual((102, (2., 100)), g_d2[1, 0])
self.assertEqual((201, (1., 200)), g_d2[0, 1])
self.assertEqual((202, (2., 200)), g_d2[1, 1])
def test_grid_data_getitem_overload_2D_data(self):
x1 = (1., 2.)
x2 = (100, 200)
grid2d = gr.CartesianGrid((x1, x2))
data2d = (np.array([['a', 'b'], ['c', 'd']]), np.array([[1, 2], [3,
4]]))
g_d = gr.GridData(data2d, grid2d)
self.assertEqual((('a', 1), (1., 100)), g_d[0, 0])
def test_vectorize_spherical(self):
si = la.SphericalSpinOperator((1, 0, 0, 0))
sx = la.SphericalSpinOperator((0, 1, pi / 2, 0))
sy = la.SphericalSpinOperator((0, 1, pi / 2, pi / 2))
sz = la.SphericalSpinOperator((0, 1, 0, 0))
ops = np.array([[si, sx], [sy, sz]])
expected = (np.array([[1, 0], [0, 0]]), np.array([[0, 1], [0, 0]]),
np.array([[0, 0], [1, 0]]), np.array([[0, 0], [0, 1]]))
x1 = (0, 1)
x2 = (0, 1)
grid = gr.CartesianGrid((x1, x2))
op_grid = gr.GridData(ops, grid)
expected = gr.GridData(expected, grid)
calculated = gr.vectorize_operator_grid(op_grid)
self.assertAlmostEqual(expected, calculated)
def test_grid_data_iter_overload_2D_data(self):
x1 = (1., 2.)
x2 = (100, 200)
data2d = (np.array([['a', 'b'], ['c', 'd']]), np.array([[1, 2], [3,
4]]))
data1f = data2d[0].flatten()
data2f = data2d[1].flatten()
grid2d = gr.CartesianGrid((x1, x2))
g_d = gr.GridData(data2d, grid2d)
for gdt, de1, de2, ge in zip(g_d, data1f, data2f, grid2d):
self.assertEqual(((de1, de2), ge), gdt)
def test_grid_data_iter_overload_1D_data(self):
x1 = (1., 2.)
x1r = (1., 1., 2., 2.)
x2 = (100, 200)
x2r = (100, 200, 100, 200)
data1d = np.array([['a', 'b'], ['c', 'd']])
data1d_flattened = data1d.flatten()
grid2d = gr.CartesianGrid((x1, x2))
g_d = gr.GridData(data1d, grid2d)
for gdt, de, ge in zip(g_d, data1d_flattened, grid2d):
self.assertEqual((de, ge), gdt)
for gdt, de, ge1, ge2 in zip(g_d, data1d_flattened, x1r, x2r):
self.assertEqual((de, (ge1, ge2)), gdt)
def test_unvectorize_cartesian(self):
si = la.CartesianSpinOperator((1, 0, 0, 0))
sx = la.CartesianSpinOperator((0, 1, 0, 0))
sy = la.CartesianSpinOperator((0, 0, 1, 0))
sz = la.CartesianSpinOperator((0, 0, 0, 1))
ops = np.array([[si, sx], [sy, sz]])
x1 = (0, 1)
x2 = (0, 1)
grid = gr.CartesianGrid((x1, x2))
op_grid = gr.GridData(ops, grid)
expected = op_grid
calculated = gr.vectorize_operator_grid(op_grid)
calculated = gr.unvectorize_operator_grid(calculated,
la.CartesianSpinOperator)
self.assertEqual(expected, calculated)
def test_nonzero_unitary_dynamics(self):
x1 = (1., 2.)
x2 = (10., 20.)
grid = gr.CartesianGrid((x1, x2))
rhoi = la.CartesianSpinOperator((0.5, 0., 0., 0.))
rhox = la.CartesianSpinOperator((0.5, 0.5, 0., 0.))
rhoy = la.CartesianSpinOperator((0.5, 0., 0.5, 0.))
rhoz = la.CartesianSpinOperator((0.5, 0., 0., 0.5))
rhos = np.array([[rhoi, rhox], [rhoy, rhoz]])
rho_grid = gr.GridData(rhos, grid)
rhoidot_expected = 1 / hbar * la.CartesianSpinOperator((0., 0., 0., 0.))
rhoxdot_expected = 1 / hbar * la.CartesianSpinOperator((0., 0., 1., 0.))
rhoydot_expected = 1 / hbar * la.CartesianSpinOperator((0., -1., 0., 0.))
rhozdot_expected = 1 / hbar * la.CartesianSpinOperator((0., 0., 0., 0.))
rhodots_expected = np.array([[rhoidot_expected, rhoxdot_expected], [rhoydot_expected, rhozdot_expected]])
rhodot_expected_grid = rho_grid.like(rhodots_expected)
ham = la.CartesianSpinOperator((0, 0, 0, 1))
rhodots_calc_grid = grid_unitary_derivative(rho_grid, ham)
self.assertEqual(rhodot_expected_grid, rhodots_calc_grid)
def test_initialization(self):
x = (0., 1.)
y = (0., 1.)
z = (0., 1.)
grid = gr.CartesianGrid((x, y, z))
s000 = la.CartesianSpinOperator((0., 0., 0., 0.))
s001 = la.CartesianSpinOperator((0., 0., 0., 1.))
s010 = la.CartesianSpinOperator((0., 0., 1., 0.))
s011 = la.CartesianSpinOperator((0., 0., 1., 1.))
s100 = la.CartesianSpinOperator((0., 1., 0., 0.))
s101 = la.CartesianSpinOperator((0., 1., 0., 1.))
s110 = la.CartesianSpinOperator((0., 1., 1., 0.))
s111 = la.CartesianSpinOperator((0., 1., 1., 1.))
ops = np.array([[[s000, s001], [s010, s011]],
[[s100, s101], [s110, s111]]])
o_grid_ex = gr.GridData(ops, grid)
o_grid_ac = gr.initialize_operator_grid(grid,
la.CartesianSpinOperator,
i_coord=0.)
self.assertEqual(o_grid_ac, o_grid_ex)
def test_bloch_derivative_all(self):
x1 = (1., 2.)
x2 = (10., 20.)
grid = gr.CartesianGrid((x1, x2))
ham = la.CartesianSpinOperator((0, 0, 0, 1))
rhoi = la.CartesianSpinOperator((0.5, 0., 0., 0.))
rhox = la.CartesianSpinOperator((0.5, 0.5, 0., 0.))
rhoy = la.CartesianSpinOperator((0.5, 0., 0.5, 0.))
rhoz = la.CartesianSpinOperator((0.5, 0., 0., 0.5))
rhos = np.array([[rhoi, rhox], [rhoy, rhoz]])
rho_grid = gr.GridData(rhos, grid)
uds = grid_unitary_derivative(rho_grid, ham)
nuds = rho_grid.like(
np.array([[
la.CartesianSpinOperator((0., 0., 0., 0.)),
la.CartesianSpinOperator((0., -0.5, 0., 0.))
],
[
la.CartesianSpinOperator((0., 0., -0.5, 0.)),
la.CartesianSpinOperator((0., 0., 0., 0.))
]]))
bd_es = uds + nuds
bd_cs = grid_bloch_derivative(rho_grid, ham, gdiss=0., gdeph=1.)
self.assertTrue(np.array_equal(bd_cs, bd_es))
import QuDiPy.visualization.isosurfaces as iso
from QuDiPy.visualization.formatting import red
# Make Cartesian Grid
res_x = 50
res_y = 50
res_z = 50
x = np.linspace(-0.5, 0.5, res_x)
y = np.linspace(-0.5, 0.5, res_y)
z = np.linspace(-0.5, 0.5, res_z)
cart_grid = gr.CartesianGrid((x, y, z))
xg, yg, zg = cart_grid.grid
data = np.exp(-(xg-0.25)**2/0.25 - (yg)**2/0.25 - (zg)**2/0.25)
funct_grid = gr.GridData(data, cart_grid)
# Make Spherical Grid
res_r = 50
res_theta = 50
res_phi = 50
r = np.linspace(0.0, 0.5, res_r)
theta = np.linspace(0., np.pi, res_theta)
phi = np.linspace(0., 2 * np.pi, res_phi)
spher_grid = gr.SphericalGrid((r, theta, phi))
xg, yg, zg = spher_grid.grid
data = np.exp(-(xg-0.25)**2/0.25 - yg**2/0.25 - zg**2/0.25)
spher_funct = gr.GridData(data, spher_grid)
iso.plot_cartesian_isosurface([funct_grid], [0.9], [1.5, 1.0], cont_kwargs=[{'color': red, 'alpha': 0.5}])