def test_data_grid_add_raises_unequal_grid_exception(self):
data_1 = np.ones(s_grid.shape)
data_2 = 2 * data_1
data_grid_1 = gr.DataGrid(data_1, s_grid)
data_grid_2 = gr.DataGrid(data_2, c_grid)
with self.assertRaises(AssertionError):
data_grid_3 = data_grid_1 + data_grid_2
def test_data_grid_sub(self):
data_1 = np.ones(s_grid.shape)
data_2 = 2 * data_1
data_3 = data_1 - data_2
data_grid_1 = gr.DataGrid(data_1, s_grid)
data_grid_2 = gr.DataGrid(data_2, s_grid)
data_grid_3_e = gr.DataGrid(data_3, s_grid)
data_grid_3_c = data_grid_1 - data_grid_2
self.assertEqual(data_grid_3_c, data_grid_3_e)
def test_grid_meshitem(self):
data = np.ones(s_grid.shape)
data_grid = gr.DataGrid(data, s_grid)
expected_000 = (1, s_grid.mesh_item(0, 0, 0))
expected_210 = (1, s_grid.mesh_item(2, 1, 0))
self.assertEqual(data_grid.mesh_item(0, 0, 0), expected_000)
self.assertEqual(data_grid.mesh_item(2, 1, 0), expected_210)
def test_grid_getitem(self):
data = np.ones(s_grid.shape)
data_grid = gr.DataGrid(data, s_grid)
expected_000 = (1, s_grid[0, 0, 0])
expected_210 = (1, s_grid[2, 1, 0])
self.assertEqual(data_grid[0, 0, 0], expected_000)
self.assertEqual(data_grid[2, 1, 0], expected_210)
def test_spherical_radial_divergence(self):
v_funct = (s_grid.mesh[0], np.zeros(s_grid.shape),
np.zeros(s_grid.shape))
vector_grid = gr.VectorGrid(v_funct,
s_grid,
operator_type=la.SphericalSpinOperator)
expected_data = 3 * np.ones(s_grid.shape)
data_grid = gr.DataGrid(expected_data, s_grid)
self.assertAlmostEqual(data_grid, vector_grid.divergence())
def test_spherical_gradient(self):
funct = s_grid.mesh[0]
data_grid = gr.DataGrid(funct, s_grid)
ops = []
for xx in r:
for yy in t:
for zz in p:
ops.append(la.SphericalSpinOperator((0, 1, 0, 0)))
ops = np.reshape(ops, s_grid.shape)
vector_grid = gr.VectorGrid(ops, s_grid)
self.assertAlmostEqual(
vector_grid, data_grid.gradient(la.SphericalSpinOperator, tuple))
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.DataGrid(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))
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.DataGrid(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_data_grid_abs_spherical(self):
data = np.ones(s_grid.shape)
data_grid = gr.DataGrid(data, s_grid)
vol = 4 * pi / 3
self.assertAlmostEqual(vol, abs(data_grid),
2) # Note 1% numerical error
def test_data_grid_abs_cartesian(self):
data = np.ones(c_grid.shape)
data_grid = gr.DataGrid(data, c_grid)
self.assertEqual(8, abs(data_grid))
def test_data_grid_mesh_iter(self):
data = np.ones(s_grid.shape)
data_grid = gr.DataGrid(data, s_grid)
for dg, g in zip(data_grid.mesh_iter(), s_grid.mesh_iter()):
self.assertEqual(dg, (1, g))
def test_data_grid_eq_returns_not_equality_different_grids(self):
data_1 = np.ones_like(s_grid.mesh[0])
data_2 = np.ones(s_grid.shape)
data_grid_1 = gr.DataGrid(data_1, s_grid)
data_grid_2 = gr.DataGrid(data_2, c_grid)
self.assertNotEqual(data_grid_1, data_grid_2)
def test_data_grid_eq_returns_equality(self):
data_1 = np.ones_like(s_grid.mesh[0])
data_2 = np.ones(s_grid.shape)
data_grid_1 = gr.DataGrid(data_1, s_grid)
data_grid_2 = gr.DataGrid(data_2, s_grid)
self.assertEqual(data_grid_1, data_grid_2)
def test_data_grid_init_raises_unequal_shape_assertion_error(self):
data = np.ones_like(short_s_grid.mesh[0])
with self.assertRaises(AssertionError):
gr.DataGrid(data, s_grid)
def test_data_grid_init_spherical_grid(self):
data = np.ones_like(s_grid.mesh[0])
data_grid = gr.DataGrid(data, s_grid)
self.assertTrue(np.array_equal(data_grid.data, data))
self.assertEqual(data_grid.grid, s_grid)
self.assertIs(data_grid.grid, s_grid)
def test_data_grid_init_cartesian_grid(self):
data = np.ones_like(c_grid.mesh[0])
data_grid = gr.DataGrid(data, c_grid)
self.assertTrue(np.array_equal(data_grid.data, data))
self.assertEqual(data_grid.grid, c_grid)
self.assertIs(data_grid.grid, c_grid)
cart_ops = gr.VectorGrid(cart_grid.cartesian,
cart_grid,
operator_type=la.CartesianSpinOperator)
spher_ops = gr.VectorGrid(spher_grid.mesh,
spher_grid,
operator_type=la.SphericalSpinOperator)
# Calculate Unitary Derivatives for Both Grids
cart_rho_dot = grid_unitary_derivative(cart_ops, ham)
spher_rho_dot = grid_bloch_derivative(spher_ops, ham, g_diss, g_diss, r_pump)
# Mask Cartesian Plots on the Bloch Sphere
x_g, y_g, z_g = cart_grid.mesh
bloch_mask = np.heaviside(1. - 2 * np.sqrt(x_g * x_g + y_g * y_g + z_g * z_g),
1)
bloch_mask = gr.DataGrid(bloch_mask, cart_grid)
cart_ops = cart_ops * bloch_mask
cart_rho_dot = cart_rho_dot * bloch_mask
# Set Formatting for Plots
quiver_kwargs = [
{
'linewidth': 2.,
'colors': red
},
{
'linewidth': 2.,
'colors': green
},
]
proj_quiver_kwargs = [{
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.mesh data = np.exp(-(xg - 0.25)**2 / 0.25 - (yg)**2 / 0.25 - (zg)**2 / 0.25) funct_grid = gr.DataGrid(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.mesh data = np.exp(-(xg - 0.25)**2 / 0.25 - yg**2 / 0.25 - zg**2 / 0.25) spher_funct = gr.DataGrid(data, spher_grid) iso.plot_cartesian_isosurface([funct_grid], [0.9], [1.5, 1.0],
