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)