Beispiel #1
0
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)]))
Beispiel #2
0
    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)
Beispiel #3
0
    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]))
Beispiel #4
0
    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)