def test_matmul_overload(self):
prodiz = self.si @ self.sz
self.assertEqual(prodiz, self.sz)
prodxz = self.sx @ self.sz
prodzx = self.sz @ self.sx
self.assertEqual(prodxz, la.CartesianSpinOperator((0., 0., -1.j, 0.)))
self.assertEqual(prodzx, la.CartesianSpinOperator((0., 0., 1.j, 0.)))
def test_round_overload(self):
test_vec = (1.1, 0., 0., 0.)
rounded_vec = (1., 0., 0., 0.)
test_op = la.CartesianSpinOperator(test_vec)
expected = la.CartesianSpinOperator(rounded_vec)
calculated = round(test_op)
self.assertEqual(expected, calculated)
def test_bloch_derivative_all(self):
ham = la.CartesianSpinOperator((0, 0, 0, 1))
rho = la.CartesianSpinOperator((0.5, 0, 0.5, 0))
bd_c = bloch_derivative(rho, ham, gdiss=0., gdeph=1.)
ud = unitary_derivative(rho, ham)
nud = -1 * la.CartesianSpinOperator((0, 0, 0.5, 0))
bd_e = ud + nud
self.assertEqual(bd_c, bd_e)
def test_cartesian_commutator(self):
# Define Spin Basis Operators
s0 = la.CartesianSpinOperator((0, 0, 0, 0))
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))
self.assertEqual(s0, la.commutator(si, sx))
self.assertEqual(la.commutator(sx, sy), -1 * la.commutator(sy, sx))
self.assertEqual(2j * sz, la.commutator(sx, sy))
def test_get_1D_array_cartesian_vectors(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))
spins = np.array([si, sx, sy, sz])
calc = la.get_cartesian_vectors(spins)
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]))
for c, e in zip(calc, expected):
self.assertTrue(np.array_equal(c, e))
def test_get_2D_array_cartesian_vectors(self):
s1 = la.CartesianSpinOperator((1., 2., 3., 4.))
s2 = la.CartesianSpinOperator((1.1, 1.2, 1.3, 1.4))
s3 = la.CartesianSpinOperator((1.5, 2.5, 3.5, 4.5))
s4 = la.CartesianSpinOperator((10., 20., 30., 40.))
spins = np.array([[s1, s2], [s3, s4]])
calc = la.get_cartesian_vectors(spins)
expected = (np.array([[1., 1.1],
[1.5, 10.]]), np.array([[2., 1.2], [2.5, 20.]]),
np.array([[3., 1.3],
[3.5, 30.]]), np.array([[4., 1.4], [4.5, 40.]]))
for c, e in zip(calc, expected):
self.assertTrue(np.array_equal(c, e))
def test_vector_grid_init_from_cartesian_operator_mesh(self):
ops = []
for xx in x:
for yy in y:
for zz in z:
ops.append(la.CartesianSpinOperator((0, xx, yy, zz)))
ops = np.reshape(ops, c_grid.shape)
vector_grid = gr.VectorGrid(ops, c_grid)
self.assertIs(vector_grid._operator_type, la.CartesianSpinOperator)
self.assertIs(vector_grid._container_type, tuple)
self.assertEqual(vector_grid._operator_dim, 4)
self.assertTrue(np.array_equal(ops, vector_grid.data))
self.assertEqual(vector_grid[0, 0, 0], (la.CartesianSpinOperator(
(0, -1, -1, -1)), (-1, -1, -1)))
def bloch_derivative(rho, ham, gdiss, gdeph, rpump=0.):
ud = unitary_derivative(rho, ham)
i, x, y, z = rho.convert_cartesian()
xdot = -(gdeph + 0.5 * gdiss + 0.5 * rpump) * x
ydot = -(gdeph + 0.5 * gdiss + 0.5 * rpump) * y
zdot = rpump * (1 - z) - gdiss * (1 + z)
bd = la.CartesianSpinOperator((0, xdot, ydot, zdot))
return ud + bd
def test_mixed_commutator(self):
# Define Spin Basis Operators
s0c = la.CartesianSpinOperator((0, 0, 0, 0))
sic = la.CartesianSpinOperator((1, 0, 0, 0))
sxc = la.CartesianSpinOperator((0, 1, 0, 0))
syc = la.CartesianSpinOperator((0, 0, 1, 0))
szc = la.CartesianSpinOperator((0, 0, 0, 1))
# Define Spin Basis Operators
s0s = la.SphericalSpinOperator((0, 0, 0, 0))
sis = la.SphericalSpinOperator((1, 0, 0, 0))
sxs = la.SphericalSpinOperator((0, 1, np.pi / 2, 0))
sys = la.SphericalSpinOperator((0, 1, np.pi / 2, np.pi / 2))
szs = la.SphericalSpinOperator((0, 1, 0, 0))
self.assertAlmostEqual(s0c, la.commutator(sis, sxc))
self.assertAlmostEqual(la.commutator(sxs, syc),
-1 * la.commutator(sys, sxc))
self.assertAlmostEqual(2j * szs, la.commutator(sxc, sys))
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_bloch_derivative_all(self):
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])
uds = array_unitary_derivative(rhos, ham)
nuds = 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 = array_bloch_derivative(rhos, ham, gdiss=0., gdeph=1.)
self.assertTrue(np.array_equal(bd_cs, bd_es))
def test_nonzero_unitary_dynamics(self):
rhox = la.CartesianSpinOperator((0.5, 0.5, 0., 0.))
rhoy = la.CartesianSpinOperator((0.5, 0., 0.5, 0.))
rhoxy = la.CartesianSpinOperator((0.5, 0.5, 0.5, 0.))
rhos = np.array([rhox, rhoy, rhoxy])
rhoxdot_expected = 1 / hbar * la.CartesianSpinOperator((0., 0., 1., 0.))
rhoydot_expected = 1 / hbar * la.CartesianSpinOperator((0., -1., 0., 0.))
rhoxydot_expected = 1 / hbar * la.CartesianSpinOperator((0., -1., 1., 0.))
rhodots_expected = np.array([rhoxdot_expected, rhoydot_expected, rhoxydot_expected])
ham = la.CartesianSpinOperator((0, 0, 0, 1))
rhodots_calc = array_unitary_derivative(rhos, ham)
self.assertTrue(np.array_equal(rhodots_expected, rhodots_calc))
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_nonzero_unitary_dynamics_cartesian_spin_operator(self):
rhox = la.CartesianSpinOperator((0.5, 0.5, 0., 0.))
rhoy = la.CartesianSpinOperator((0.5, 0., 0.5, 0.))
rhoxy = la.CartesianSpinOperator((0.5, 0.5, 0.5, 0.))
rhoxdot_expected = 1 / hbar * la.CartesianSpinOperator((0., 0., 1., 0.))
rhoydot_expected = 1 / hbar * la.CartesianSpinOperator((0., -1., 0., 0.))
rhoxydot_expected = 1 / hbar * la.CartesianSpinOperator((0., -1., 1., 0.))
ham = la.CartesianSpinOperator((0, 0, 0, 1))
rhoxdot_calc = unitary_derivative(rhox, ham)
rhoydot_calc = unitary_derivative(rhoy, ham)
rhoxydot_calc = unitary_derivative(rhoxy, ham)
self.assertEqual(rhoxdot_calc, rhoxdot_expected)
self.assertEqual(rhoydot_calc, rhoydot_expected)
self.assertEqual(rhoxydot_calc, rhoxydot_expected)
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.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_mixed_spin_operator(self):
rhox = la.CartesianSpinOperator((0.5, 0.5, 0., 0.))
rhoy = la.CartesianSpinOperator((0.5, 0., 0.5, 0.))
rhoxy = la.CartesianSpinOperator((0.5, 0.5, 0.5, 0.))
rhoxdot_expected = la.CartesianSpinOperator((0., 0., 1., 0.))
rhoydot_expected = la.CartesianSpinOperator((0., -1., 0., 0.))
rhoxydot_expected = la.CartesianSpinOperator((0., -1., 1., 0.))
ham = la.SphericalSpinOperator((0, 1, 0, 0))
rhoxdot_calc = hbar * unitary_derivative(rhox, ham)
rhoydot_calc = hbar * unitary_derivative(rhoy, ham)
rhoxydot_calc = hbar * unitary_derivative(rhoxy, ham)
self.assertAlmostEqual(rhoxdot_calc, rhoxdot_expected)
self.assertAlmostEqual(rhoydot_calc, rhoydot_expected)
self.assertAlmostEqual(rhoxydot_calc, rhoxydot_expected)
def setUp(self):
""" Generates Basis Observables and a list of 10 random matrices for testing"""
self.i = (1., 0., 0., 0.)
self.x = (0., 1., 0., 0.)
self.y = (0., 0., 1., 0.)
self.z = (0., 0., 0., 1.)
self.basis_vectors = [self.i, self.x, self.y, self.z]
self.rands = [(rn.rand(), rn.rand(), rn.rand(), rn.rand())
for i in range(10)]
self.vectors = self.basis_vectors + self.rands
self.si = la.CartesianSpinOperator(self.i)
self.si2 = la.CartesianSpinOperator(self.i)
self.sx = la.CartesianSpinOperator(self.x)
self.sy = la.CartesianSpinOperator(self.y)
self.sz = la.CartesianSpinOperator(self.z)
self.basis_operators = [self.si, self.sx, self.sy, self.sz]
self.srands = [la.CartesianSpinOperator(rand) for rand in self.rands]
self.operators = self.basis_operators + self.srands
pass
def test_add_overload(self):
sum_ix = self.si + self.sx
expected_sum_ix = la.CartesianSpinOperator((1, 1, 0, 0))
self.assertEqual(sum_ix, expected_sum_ix)
def test_sub_overload(self):
calc = self.si - self.sx
expected = la.CartesianSpinOperator((1, -1, 0, 0))
self.assertAlmostEqual(calc, expected)
def test_rmult_real_overload(self):
calc = -2 * self.sx
expected = la.CartesianSpinOperator((0, -2, 0, 0))
self.assertAlmostEqual(calc, expected)
def test_steady_state_unitary_dynamics_mixed_spin_operator(self):
rho0 = la.SphericalSpinOperator((1 / 2, 0, 0, 0))
rhodot_expected = la.SphericalSpinOperator((0, 0, 0, 0))
ham = la.CartesianSpinOperator((0, 0, 0, 1))
self.assertEqual(unitary_derivative(rho0, ham), rhodot_expected)
def test_get_single_cartesian_vector(self):
sx = la.CartesianSpinOperator((0, 1, 0, 0))
self.assertEqual((0, 1, 0, 0), la.get_cartesian_vector(sx))
self.assertEqual((0, 1, 0, 0), la.get_cartesian_vectors(sx))
def test_init_length_assertion(self):
""" Tests that the constructor correctly raises initialization error if the wrong length input provided """
with self.assertRaises(AssertionError):
la.CartesianSpinOperator((1., 0., 0.))
with self.assertRaises(AssertionError):
la.CartesianSpinOperator((1., 0., 0., 0., 0., 0.))
import numpy as np import QuDiPy.math.linear_algebra as la import QuDiPy.containers.grids as gr from QuDiPy.dynamics.unitary_dynamics import grid_unitary_derivative from QuDiPy.dynamics.bloch_dynamics import grid_bloch_derivative import QuDiPy.visualization.quiver as bq from QuDiPy.visualization.formatting import red, green from QuDiPy.util.constants import hbar # Dynamics Properties delta = hbar * 1.0 vv = 0.0 g_diss = 1.0 g_deph = 1.0 r_pump = 0.5 ham = la.CartesianSpinOperator((0., vv.real, vv.imag, delta)) # Make Cartesian Grid res_x = 5 res_y = 5 res_z = 5 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)) # Make Spherical Grid res_r = 5 res_theta = 5 res_phi = 5
def test_sub_overload(self):
diff_ix = self.si - self.sx
expected_diff_ix = la.CartesianSpinOperator((1, -1, 0, 0))
self.assertEqual(diff_ix, expected_diff_ix)
def test_rmult_complex_overload(self):
calc = (1 + 1j) * self.sx
expected = la.CartesianSpinOperator((0, 1 + 1j, 0, 0))
self.assertEqual(calc, expected)
def test_rmult_real_overload(self):
mult_2i = 2 * self.si
expected_mult_2i = la.CartesianSpinOperator((2, 0, 0, 0))
self.assertEqual(mult_2i, expected_mult_2i)
def test_cross_equality(self):
cart_x = la.CartesianSpinOperator((0, 1, 0, 0))
self.assertAlmostEqual(self.sx, cart_x)
def test_bloch_derivative_no_unitary_part(self):
ham = la.CartesianSpinOperator((0, 0, 0, 0))
rho = la.CartesianSpinOperator((0.5, 0, 0.5, 0))
bd_c = bloch_derivative(rho, ham, gdiss=0., gdeph=1.)
bd_e = -1 * la.CartesianSpinOperator((0, 0, 0.5, 0))
self.assertEqual(bd_c, bd_e)
