def test_SE(self): """Spin echo""" tau = np.pi tau_pi = 1e-8 n = 1 H_c, dt = testutil.generate_dd_hamiltonian(n, tau=tau, tau_pi=tau_pi, dd_type='cpmg') H_n = [[util.paulis[3] / 2, np.ones_like(dt)]] SE_pulse = ff.PulseSequence(H_c, H_n, dt) omega = util.get_sample_frequencies(SE_pulse, 100, spacing='linear') # Comparison to filter function defined with omega**2 F = SE_pulse.get_filter_function(omega)[0, 0] * omega**2 self.assertArrayAlmostEqual(F, analytic.SE(omega * tau), atol=1e-10) # Test again with a factor of one between the noise operators and # coefficients r = rng.standard_normal() H_n = [[util.paulis[3] / 2 * r, np.ones_like(dt) / r]] SE_pulse = ff.PulseSequence(H_c, H_n, dt) # Comparison to filter function defined with omega**2 F = SE_pulse.get_filter_function(omega)[0, 0] * omega**2 self.assertArrayAlmostEqual(F, analytic.SE(omega * tau), atol=1e-10)
def test_concatenate_with_filter_function_SE12(self): """Concatenate two Spin Echos with both having a filter function.""" tau = 10 tau_pi = 1e-4 omega = np.logspace(-1, 2, 500) n = 1 H_c_SE, dt_SE = testutil.generate_dd_hamiltonian(n, tau=tau, tau_pi=tau_pi, dd_type='cpmg') H_n_SE = [[util.paulis[3], np.ones_like(dt_SE)]] SE_1 = ff.PulseSequence(H_c_SE, H_n_SE, dt_SE) SE_2 = ff.PulseSequence(H_c_SE, H_n_SE, dt_SE) H_c_CPMG, dt_CPMG = testutil.generate_dd_hamiltonian(2 * n, tau=2 * tau, tau_pi=tau_pi, dd_type='cpmg') H_n_CPMG = [[util.paulis[3], np.ones_like(dt_CPMG)]] CPMG = ff.PulseSequence(H_c_CPMG, H_n_CPMG, dt_CPMG) SE_1.cache_filter_function(omega) SE_2.cache_filter_function(omega) CPMG.cache_filter_function(omega) CPMG_concat = SE_1 @ SE_2 self.assertIsNotNone(SE_1._total_phases) self.assertIsNotNone(SE_1._total_Q) self.assertIsNotNone(SE_1._total_Q_liouville) self.assertIsNotNone(SE_2._total_phases) self.assertIsNotNone(SE_2._total_Q) self.assertIsNotNone(SE_2._total_Q_liouville) self.assertIsNotNone(CPMG._total_phases) self.assertIsNotNone(CPMG._total_Q) self.assertIsNotNone(CPMG._total_Q_liouville) self.assertIsNotNone(CPMG_concat._total_phases) self.assertIsNotNone(CPMG_concat._total_Q) self.assertIsNotNone(CPMG_concat._total_Q_liouville) self.assertEqual(CPMG_concat, CPMG) self.assertArrayAlmostEqual(CPMG_concat._F, CPMG._F, rtol=1e-11)
def test_concatenate_4_spin_echos(self): """Concatenate four Spin Echos with a random one having a filter function """ tau = 1 tau_pi = 1e-4 omega = np.logspace(-2, 1, 200) n = 1 H_c_SE, dt_SE = testutil.generate_dd_hamiltonian(n, tau=tau, tau_pi=tau_pi, dd_type='cpmg') H_n_SE = [[util.paulis[3], np.ones_like(dt_SE)]] SE = [ff.PulseSequence(H_c_SE, H_n_SE, dt_SE) for _ in range(4)] H_c_CPMG, dt_CPMG = testutil.generate_dd_hamiltonian(4*n, tau=4*tau, tau_pi=tau_pi, dd_type='cpmg') H_n_CPMG = [[util.paulis[3], np.ones_like(dt_CPMG)]] CPMG = ff.PulseSequence(H_c_CPMG, H_n_CPMG, dt_CPMG) SE[rng.randint(0, len(SE)-1)].cache_filter_function(omega) CPMG.cache_filter_function(omega) CPMG_concat_1 = ff.concatenate(SE) # Clean up so that we start from one SE with cached filter_function again for se in SE: se.cleanup('all') SE[rng.randint(0, len(SE)-1)].cache_filter_function(omega) CPMG_concat_2 = SE[0] @ SE[1] @ SE[2] @ SE[3] self.assertEqual(CPMG, CPMG_concat_1) self.assertEqual(CPMG, CPMG_concat_2) self.assertArrayAlmostEqual(CPMG_concat_1._filter_function, CPMG._filter_function, rtol=1e-10) self.assertArrayAlmostEqual(CPMG_concat_2._filter_function, CPMG._filter_function, rtol=1e-10)
def test_6_pulse_CPMG(self): """6-pulse CPMG""" tau = np.pi tau_pi = 1e-9 n = 6 H_c, dt = testutil.generate_dd_hamiltonian(n, tau=tau, tau_pi=tau_pi, dd_type='cpmg') H_n = [[util.paulis[3] / 2, np.ones_like(dt)]] CPMG_pulse = ff.PulseSequence(H_c, H_n, dt) omega = util.get_sample_frequencies(CPMG_pulse, 100, spacing='log') # Comparison to filter function defined with omega**2 F = CPMG_pulse.get_filter_function(omega)[0, 0] * omega**2 self.assertArrayAlmostEqual(F, analytic.CPMG(omega * tau, n), atol=1e-10)
def test_5_pulse_CDD(self): """5-pulse CDD""" tau = np.pi tau_pi = 1e-9 omega = np.logspace(0, 3, 100) omega = np.concatenate([-omega[::-1], omega]) n = 3 H_c, dt = testutil.generate_dd_hamiltonian(n, tau=tau, tau_pi=tau_pi, dd_type='cdd') H_n = [[util.paulis[3] / 2, np.ones_like(dt)]] CDD_pulse = ff.PulseSequence(H_c, H_n, dt) # Comparison to filter function defined with omega**2 F = CDD_pulse.get_filter_function(omega)[0, 0] * omega**2 self.assertArrayAlmostEqual(F, analytic.CDD(omega * tau, n), atol=1e-10)
def test_concatenate_without_filter_function(self): """Concatenate two Spin Echos without filter functions.""" tau = 10 tau_pi = 1e-4 n = 1 H_c_SE, dt_SE = testutil.generate_dd_hamiltonian(n, tau=tau, tau_pi=tau_pi, dd_type='cpmg') n_oper = util.paulis[3] H_n_SE = [[n_oper, np.ones_like(dt_SE)]] SE_1 = ff.PulseSequence(H_c_SE, H_n_SE, dt_SE) SE_2 = ff.PulseSequence(H_c_SE, H_n_SE, dt_SE) H_c_CPMG, dt_CPMG = testutil.generate_dd_hamiltonian(2*n, tau=2*tau, tau_pi=tau_pi, dd_type='cpmg') H_n_CPMG = [[n_oper, np.ones_like(dt_CPMG)]] CPMG = ff.PulseSequence(H_c_CPMG, H_n_CPMG, dt_CPMG) CPMG_concat = SE_1 @ SE_2 self.assertEqual(CPMG_concat, CPMG) # Should still be None self.assertEqual(CPMG_concat._filter_function, CPMG._filter_function) # Test if calculation of composite filter function can be enforced with # omega != None omega = util.get_sample_frequencies(SE_1) CPMG_concat = ff.concatenate((SE_1, SE_2), omega=omega) self.assertIsNotNone(CPMG_concat._filter_function) pulse = testutil.rand_pulse_sequence(2, 1, 2, 3) # Concatenate pulses without filter functions with self.assertRaises(TypeError): # Not all pulse sequence pulse_sequence.concatenate_without_filter_function([pulse, 2]) with self.assertRaises(TypeError): # Not iterable pulse_sequence.concatenate_without_filter_function(pulse) with self.assertRaises(ValueError): # Incompatible Hamiltonian shapes pulse_sequence.concatenate_without_filter_function( [testutil.rand_pulse_sequence(2, 1), testutil.rand_pulse_sequence(3, 1)] ) with self.assertRaises(ValueError): # Incompatible bases pulse = testutil.rand_pulse_sequence(4, 1, btype='GGM') cpulse = copy(pulse) cpulse.basis = ff.Basis.pauli(2) pulse_sequence.concatenate_without_filter_function([pulse, cpulse]) pulse = pulse_sequence.concatenate_without_filter_function( [pulse, pulse], return_identifier_mappings=False ) self.assertFalse(pulse.is_cached('filter function'))