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'))
