def TestPulseConstructor():
"""
Test for creating empty Pulse, Pulse with constant coefficients etc.
"""
coeff = np.array([0.1, 0.2, 0.3, 0.4])
tlist = np.array([0., 1., 2., 3.])
ham = sigmaz()
# Special ways of initializing pulse
pulse2 = Pulse(sigmax(), 0, tlist, True)
assert_allclose(pulse2.get_ideal_qobjevo(2).ops[0].qobj,
tensor(sigmax(), identity(2)))
pulse3 = Pulse(sigmay(), 0)
assert_allclose(pulse3.get_ideal_qobjevo(2).cte.norm(), 0.)
pulse4 = Pulse(None, None) # Dummy empty ham
assert_allclose(pulse4.get_ideal_qobjevo(2).cte.norm(), 0.)
tlist_noise = np.array([1., 2.5, 3.])
coeff_noise = np.array([0.5, 0.1, 0.5])
tlist_noise2 = np.array([0.5, 2, 3.])
coeff_noise2 = np.array([0.1, 0.2, 0.3])
# Pulse with different dims
random_qobj = Qobj(np.random.random((3, 3)))
pulse5 = Pulse(sigmaz(), 1, tlist, True)
pulse5.add_coherent_noise(sigmay(), 1, tlist_noise, coeff_noise)
pulse5.add_lindblad_noise(
random_qobj, 0, tlist=tlist_noise2, coeff=coeff_noise2)
qu, c_ops = pulse5.get_noisy_qobjevo(dims=[3, 2])
assert_allclose(qu.ops[0].qobj, tensor([identity(3), sigmaz()]))
assert_allclose(qu.ops[1].qobj, tensor([identity(3), sigmay()]))
assert_allclose(c_ops[0].ops[0].qobj, tensor([random_qobj, identity(2)]))
def test_decoherence_noise(self):
"""
Test for the decoherence noise
"""
tlist = np.array([0, 1, 2, 3, 4, 5, 6])
coeff = np.array([1, 1, 1, 1, 1, 1, 1])
# Time-dependent
decnoise = DecoherenceNoise(sigmaz(),
coeff=coeff,
tlist=tlist,
targets=[1])
dims = [2] * 2
systematic_noise = Pulse(None,
None,
label="systematic_noise",
spline_kind="step_func")
pulses, systematic_noise = decnoise.get_noisy_pulses(
systematic_noise=systematic_noise, dims=dims)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
assert_allclose(c_ops[0](0).full(), tensor(qeye(2), sigmaz()).full())
# Time-independent and all qubits
decnoise = DecoherenceNoise(sigmax(), all_qubits=True)
pulses, systematic_noise = decnoise.get_noisy_pulses(dims=dims)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
c_ops = [qu(0) for qu in c_ops]
assert_(tensor([qeye(2), sigmax()]) in c_ops)
assert_(tensor([sigmax(), qeye(2)]) in c_ops)
# Time-denpendent and all qubits
decnoise = DecoherenceNoise(sigmax(),
all_qubits=True,
coeff=coeff * 2,
tlist=tlist)
systematic_noise = Pulse(None,
None,
label="systematic_noise",
spline_kind="step_func")
pulses, systematic_noise = decnoise.get_noisy_pulses(
systematic_noise=systematic_noise, dims=dims)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
assert_allclose(c_ops[0](0).full(),
tensor(sigmax(), qeye(2)).full() * 2)
assert_allclose(c_ops[1](0).full(),
tensor(qeye(2), sigmax()).full() * 2)
def test_relaxation_noise(self):
"""
Test for the relaxation noise
"""
# only t1
a = destroy(2)
dims = [2] * 3
relnoise = RelaxationNoise(t1=[1., 1., 1.], t2=None)
systematic_noise = Pulse(None, None, label="system")
pulses, systematic_noise = relnoise.get_noisy_pulses(
dims=dims, systematic_noise=systematic_noise)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
assert_(len(c_ops) == 3)
assert_allclose(c_ops[1](0).full(),
tensor([qeye(2), a, qeye(2)]).full())
# no relaxation
dims = [2] * 2
relnoise = RelaxationNoise(t1=None, t2=None)
systematic_noise = Pulse(None, None, label="system")
pulses, systematic_noise = relnoise.get_noisy_pulses(
dims=dims, systematic_noise=systematic_noise)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
assert_(len(c_ops) == 0)
# only t2
relnoise = RelaxationNoise(t1=None, t2=[0.2, 0.7])
systematic_noise = Pulse(None, None, label="system")
pulses, systematic_noise = relnoise.get_noisy_pulses(
dims=dims, systematic_noise=systematic_noise)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
assert_(len(c_ops) == 2)
# t1+t2 and systematic_noise = None
relnoise = RelaxationNoise(t1=[1., 1.], t2=[0.5, 0.5])
pulses, systematic_noise = relnoise.get_noisy_pulses(dims=dims)
noisy_qu, c_ops = systematic_noise.get_noisy_qobjevo(dims=dims)
assert_(len(c_ops) == 4)
def test_pulse_constructor(self):
"""
Test for creating empty Pulse, Pulse with constant coefficients etc.
"""
coeff = np.array([0.1, 0.2, 0.3, 0.4])
tlist = np.array([0., 1., 2., 3.])
ham = sigmaz()
# Special ways of initializing pulse
pulse2 = Pulse(sigmax(), 0, tlist, True)
assert_allclose(
pulse2.get_ideal_qobjevo(2)(0).full(),
tensor(sigmax(), identity(2)).full())
pulse3 = Pulse(sigmay(), 0)
assert_allclose(pulse3.get_ideal_qobjevo(2)(0).norm(), 0.)
pulse4 = Pulse(None, None) # Dummy empty ham
assert_allclose(pulse4.get_ideal_qobjevo(2)(0).norm(), 0.)
tlist_noise = np.array([1., 2.5, 3.])
coeff_noise = np.array([0.5, 0.1, 0.5])
tlist_noise2 = np.array([0.5, 2, 3.])
coeff_noise2 = np.array([0.1, 0.2, 0.3])
# Pulse with different dims
random_qobj = Qobj(np.random.random((3, 3)))
pulse5 = Pulse(sigmaz(), 1, tlist, True)
pulse5.add_coherent_noise(sigmay(), 1, tlist_noise, coeff_noise)
pulse5.add_lindblad_noise(random_qobj,
0,
tlist=tlist_noise2,
coeff=coeff_noise2)
qu, c_ops = pulse5.get_noisy_qobjevo(dims=[3, 2])
if parse_version(qutip.__version__) >= parse_version('5.dev'):
expected = QobjEvo([
tensor([identity(3), sigmaz()]),
[tensor([identity(3), sigmay()]), coeff_noise]
],
tlist=tlist_noise,
order=0)
else:
expected = QobjEvo([
tensor([identity(3), sigmaz()]),
[tensor([identity(3), sigmay()]), coeff_noise]
],
tlist=tlist_noise,
args={"_step_func_coeff": True})
_compare_qobjevo(qu, expected, 0, 3)
def test_coherent_noise(self):
"""
Test for pulse genration with coherent noise.
"""
coeff = np.array([0.1, 0.2, 0.3, 0.4])
tlist = np.array([0., 1., 2., 3.])
ham = sigmaz()
pulse1 = Pulse(ham, 1, tlist, coeff)
# Add coherent noise with the same tlist
pulse1.add_coherent_noise(sigmay(), 0, tlist, coeff)
assert_allclose(
pulse1.get_ideal_qobjevo(2)(0).full(),
tensor(identity(2), sigmaz()).full() * 0.1)
assert_(len(pulse1.coherent_noise) == 1)
noise_qu, c_ops = pulse1.get_noisy_qobjevo(2)
assert_allclose(c_ops, [])
assert_allclose(pulse1.get_full_tlist(), np.array([0., 1., 2., 3.]))
def testNoisyPulse(self):
"""
Test for lindblad noise and different tlist
"""
coeff = np.array([0.1, 0.2, 0.3, 0.4])
tlist = np.array([0., 1., 2., 3.])
ham = sigmaz()
pulse1 = Pulse(ham, 1, tlist, coeff)
# Add coherent noise and lindblad noise with different tlist
pulse1.spline_kind = "step_func"
tlist_noise = np.array([1., 2.5, 3.])
coeff_noise = np.array([0.5, 0.1, 0.5])
pulse1.add_coherent_noise(sigmay(), 0, tlist_noise, coeff_noise)
tlist_noise2 = np.array([0.5, 2, 3.])
coeff_noise2 = np.array([0.1, 0.2, 0.3])
pulse1.add_lindblad_noise(sigmax(), 1, coeff=True)
pulse1.add_lindblad_noise(sigmax(),
0,
tlist=tlist_noise2,
coeff=coeff_noise2)
assert_allclose(
pulse1.get_ideal_qobjevo(2).ops[0].qobj,
tensor(identity(2), sigmaz()))
noise_qu, c_ops = pulse1.get_noisy_qobjevo(2)
assert_allclose(noise_qu.tlist, np.array([0., 0.5, 1., 2., 2.5, 3.]))
for ele in noise_qu.ops:
if ele.qobj == tensor(identity(2), sigmaz()):
assert_allclose(ele.coeff,
np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4]))
elif ele.qobj == tensor(sigmay(), identity(2)):
assert_allclose(ele.coeff,
np.array([0., 0., 0.5, 0.5, 0.1, 0.5]))
for c_op in c_ops:
if len(c_op.ops) == 0:
assert_allclose(c_ops[0].cte, tensor(identity(2), sigmax()))
else:
assert_allclose(c_ops[1].ops[0].qobj,
tensor(sigmax(), identity(2)))
assert_allclose(c_ops[1].tlist,
np.array([0., 0.5, 1., 2., 2.5, 3.]))
assert_allclose(c_ops[1].ops[0].coeff,
np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3]))
def TestCoherentNoise():
"""
Test for pulse genration with coherent noise.
"""
coeff = np.array([0.1, 0.2, 0.3, 0.4])
tlist = np.array([0., 1., 2., 3.])
ham = sigmaz()
pulse1 = Pulse(ham, 1, tlist, coeff)
# Add coherent noise with the same tlist
pulse1.add_coherent_noise(sigmay(), 0, tlist, coeff)
assert_allclose(
pulse1.get_ideal_qobjevo(2).ops[0].qobj, tensor(identity(2), sigmaz()))
assert_(len(pulse1.coherent_noise) == 1)
noise_qu, c_ops = pulse1.get_noisy_qobjevo(2)
assert_allclose(c_ops, [])
assert_allclose(noise_qu.tlist, np.array([0., 1., 2., 3.]))
qobj_list = [ele.qobj for ele in noise_qu.ops]
assert_(tensor(identity(2), sigmaz()) in qobj_list)
assert_(tensor(sigmay(), identity(2)) in qobj_list)
for ele in noise_qu.ops:
assert_allclose(ele.coeff, coeff)
def test_noisy_pulse(self):
"""
Test for lindblad noise and different tlist
"""
coeff = np.array([0.1, 0.2, 0.3, 0.4])
tlist = np.array([0., 1., 2., 3.])
ham = sigmaz()
pulse1 = Pulse(ham, 1, tlist, coeff)
# Add coherent noise and lindblad noise with different tlist
pulse1.spline_kind = "step_func"
tlist_noise = np.array([0., 1., 2.5, 3.])
coeff_noise = np.array([0., 0.5, 0.1, 0.5])
pulse1.add_coherent_noise(sigmay(), 0, tlist_noise, coeff_noise)
tlist_noise2 = np.array([0., 0.5, 2, 3.])
coeff_noise2 = np.array([0., 0.1, 0.2, 0.3])
pulse1.add_lindblad_noise(sigmax(), 1, coeff=True)
pulse1.add_lindblad_noise(sigmax(),
0,
tlist=tlist_noise2,
coeff=coeff_noise2)
assert_allclose(
pulse1.get_ideal_qobjevo(2)(0).full(),
tensor(identity(2), sigmaz()).full() * 0.1)
noise_qu, c_ops = pulse1.get_noisy_qobjevo(2)
assert_allclose(pulse1.get_full_tlist(),
np.array([0., 0.5, 1., 2., 2.5, 3.]))
if parse_version(qutip.__version__) >= parse_version('5.dev'):
expected = QobjEvo([[
tensor(identity(2), sigmaz()),
np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4])
],
[
tensor(sigmay(), identity(2)),
np.array([0., 0., 0.5, 0.5, 0.1, 0.5])
]],
tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),
order=0)
else:
expected = QobjEvo([[
tensor(identity(2), sigmaz()),
np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4])
],
[
tensor(sigmay(), identity(2)),
np.array([0., 0., 0.5, 0.5, 0.1, 0.5])
]],
tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),
args={"_step_func_coeff": True})
_compare_qobjevo(noise_qu, expected, 0, 3)
for c_op in c_ops:
try:
isconstant = c_op.isconstant
except AttributeError:
isconstant = (len(c_op.ops) == 0)
if isconstant:
assert_allclose(
c_op(0).full(),
tensor(identity(2), sigmax()).full())
else:
if parse_version(qutip.__version__) >= parse_version('5.dev'):
expected = QobjEvo([
tensor(sigmax(), identity(2)),
np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3])
],
tlist=np.array(
[0., 0.5, 1., 2., 2.5, 3.]),
order=0)
else:
expected = QobjEvo([
tensor(sigmax(), identity(2)),
np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3])
],
tlist=np.array(
[0., 0.5, 1., 2., 2.5, 3.]),
args={"_step_func_coeff": True})
_compare_qobjevo(c_op, expected, 0, 3)