Пример #1
0
def test_mcsolve_bad_e_ops():
    H = qutip.sigmaz()
    c_ops = [qutip.sigmax()]
    psi0 = qutip.basis(2, 0)
    tlist = np.linspace(0, 20, 200)
    with pytest.raises(TypeError) as exc:
        qutip.mcsolve(H, psi0, tlist=tlist, c_ops=c_ops, e_ops=[qutip.qeye(3)])
Пример #2
0
 def test_seeds_can_be_reused(self):
     args = (self.H, self.state, self.times)
     kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
     first = qutip.mcsolve(*args, **kwargs)
     options = qutip.Options(seeds=first.seeds)
     second = qutip.mcsolve(*args, options=options, **kwargs)
     for first_t, second_t in zip(first.col_times, second.col_times):
         np.testing.assert_equal(first_t, second_t)
     for first_w, second_w in zip(first.col_which, second.col_which):
         np.testing.assert_equal(first_w, second_w)
Пример #3
0
 def test_seeds_are_not_reused_by_default(self):
     args = (self.H, self.state, self.times)
     kwargs = {'c_ops': self.c_ops, 'ntraj': self.ntraj}
     first = qutip.mcsolve(*args, **kwargs)
     second = qutip.mcsolve(*args, **kwargs)
     assert not all(
         np.array_equal(first_t, second_t)
         for first_t, second_t in zip(first.col_times, second.col_times))
     assert not all(
         np.array_equal(first_w, second_w)
         for first_w, second_w in zip(first.col_which, second.col_which))
Пример #4
0
def run(neq=10, ntraj=100, solver='both', ncpus=1):
    # sparse initial state
    # psi0 = basis(neq,neq-1)
    # dense initial state
    psi0 = qt.Qobj(np.ones((neq, 1))).unit()
    a = qt.destroy(neq)
    ad = a.dag()
    H = ad * a
    # c_ops = [gamma*a]
    c_ops = [qt.qeye(neq)]
    e_ops = [ad * a]

    # Times
    T = 10.0
    dt = 0.1
    nstep = int(T / dt)
    tlist = np.linspace(0, T, nstep)

    # set options
    opts = qt.Options()
    opts.num_cpus = ncpus
    opts.gui = False

    mcf90_time = 0.
    mc_time = 0.
    if (solver == 'mcf90' or solver == 'both'):
        start_time = time.time()
        mcf90.mcsolve_f90(H,
                          psi0,
                          tlist,
                          c_ops,
                          e_ops,
                          ntraj=ntraj,
                          options=opts)

        mcf90_time = time.time() - start_time
        print("mcsolve_f90 solutiton took", mcf90_time, "s")

    if (solver == 'mc' or solver == 'both'):
        start_time = time.time()
        qt.mcsolve(H,
                   psi0,
                   tlist,
                   c_ops,
                   e_ops,
                   ntraj=ntraj,
                   options=opts,
                   progress_bar=False)
        mc_time = time.time() - start_time
        print("mcsolve solutiton took", mc_time, "s")

    return mcf90_time, mc_time
Пример #5
0
def solve(Data, ntraj):
    #run monte-carlo solver

    print "running Monte Carlo Solver..."
    raw = qt.mcsolve(
        Data.H, Data.psi0, Data.tlist, Data.slist, [], ntraj
    )  #This runs the solver with whichever collapse operators and hamiltonian are chosen
    Data.entire_raw = raw
    raw = raw.states
    Data.rawq = raw
    #Since the analysis always bogs down, and the raw.states data structure can be very large,
    #This will turn it into a numpy array rather than a qobj for purposes of speed.

    u = raw.shape
    rawarray = np.zeros([u[0], u[1]], dtype=np.ndarray)
    for i in range(u[0]):  #Each Trajectory
        for j in range(u[1]):  #Each Timestep
            rawij = raw[
                i, j]  #Calls the i,jth element of the state vector structure
            xary = np.zeros(
                [8, 1],
                dtype=complex)  #Defines the new array for the state vectors
            for q in range(8):
                xary[q, 0] = rawij[q, 0]  #Turns the qobj to a numpy array
            rawarray[i, j] = xary  #Writes the element to the array
    Data.raw = rawarray  #Removes the old data structure.

    return
Пример #6
0
    def trajectory(self, exps=None, initial_state=None, draw=False):
        '''for convenience. Calculates the trajectory of an
        observable for one montecarlo run. Default expectation is
        cavity amplitude, default initial state is bipartite
        vacuum. todo: draw: draw trajectory on bloch sphere.
        Write in terms of mcsolve??'''
        if exps is None or draw is True:
            exps = []
        if initial_state is None:
            initial_state = qt.tensor(qt.basis(self.N_field_levels, 0),
                                      qt.basis(2, 0))

        self.one_traj_soln = qt.mcsolve(self.hamiltonian(),
                                        initial_state,
                                        self.tlist,
                                        self._c_ops(),
                                        exps,
                                        ntraj=1)
        if self.noisy:
            print(self.one_traj_soln.states[0][2].ptrace(1))

        if not draw:
            return self.one_traj_soln
        else:
            self.b_sphere = qt.Bloch()
            self.b_sphere.add_states(
                [state.ptrace(1) for state in self.one_traj_soln.states[0]],
                'point')
            self.b_sphere.point_markers = ['o']
            self.b_sphere.size = (10, 10)
            self.b_sphere.show()
Пример #7
0
def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):

    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()

    c_op_list = []

    rate = g1
    if rate > 0.0:
        c_op_list.append(np.sqrt(rate) * sigmam())

    rate = g2
    if rate > 0.0:
        c_op_list.append(np.sqrt(rate) * sigmaz())

    e_ops = [sigmax(), sigmay(), sigmaz()]

    if solver == "me":
        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
    elif solver == "es":
        output = essolve(H, psi0, tlist, c_op_list, e_ops)
    elif solver == "mc":
        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
    else:
        raise ValueError("unknown solver")

    return output.expect[0], output.expect[1], output.expect[2]
Пример #8
0
def _qubit_integrate(tlist, psi0, epsilon, delta, g1, g2, solver):

    H = epsilon / 2.0 * sigmaz() + delta / 2.0 * sigmax()

    c_op_list = []

    rate = g1
    if rate > 0.0:
        c_op_list.append(np.sqrt(rate) * sigmam())

    rate = g2
    if rate > 0.0:
        c_op_list.append(np.sqrt(rate) * sigmaz())

    e_ops = [sigmax(), sigmay(), sigmaz()]

    if solver == "me":
        output = mesolve(H, psi0, tlist, c_op_list, e_ops)
    elif solver == "es":
        output = essolve(H, psi0, tlist, c_op_list, e_ops)
    elif solver == "mc":
        output = mcsolve(H, psi0, tlist, c_op_list, e_ops, ntraj=750)
    else:
        raise ValueError("unknown solver")

    return output.expect[0], output.expect[1], output.expect[2]
Пример #9
0
def time_evolution_mc(psi, H, t, c_op):
    """ Monte-Carlo evolution in the case of a noisy system.

    Parameters
    ----------
    psi: qutip.Qobj()
        quantum state under evolution
    H: qutip.Qobj()
        Hamiltonian
    t: scalar
        time during which H is applied to psi
    c_op: list
        single collapse operator or a list of collapse operators.

    Returns
    ------
    psi2: qutip.Qobj()
        final state
    """
    tlist = np.linspace(0, t, 50)
    psi2 = qutip.mcsolve(H,
                         psi,
                         tlist,
                         c_ops=c_op,
                         ntraj=100,
                         progress_bar=None).states[0][-1]
    return psi2
Пример #10
0
def test_mc_dtypes2():
    "Monte-carlo: check for correct dtypes (average_states=False)"
    # set system parameters
    kappa = 2.0  # mirror coupling
    gamma = 0.2  # spontaneous emission rate
    g = 1  # atom/cavity coupling strength
    wc = 0  # cavity frequency
    w0 = 0  # atom frequency
    wl = 0  # driving frequency
    E = 0.5  # driving amplitude
    N = 5  # number of cavity energy levels (0->3 Fock states)
    tlist = np.linspace(0, 10, 5)  # times for expectation values
    # construct Hamiltonian
    ida = qeye(N)
    idatom = qeye(2)
    a = tensor(destroy(N), idatom)
    sm = tensor(ida, sigmam())
    H = (w0 - wl) * sm.dag() * sm + (wc - wl) * a.dag() * a + \
        1j * g * (a.dag() * sm - sm.dag() * a) + E * (a.dag() + a)
    # collapse operators
    C1 = np.sqrt(2 * kappa) * a
    C2 = np.sqrt(gamma) * sm
    C1dC1 = C1.dag() * C1
    C2dC2 = C2.dag() * C2
    # intial state
    psi0 = tensor(basis(N, 0), basis(2, 1))
    opts = Options(average_expect=False)
    data = mcsolve(
        H, psi0, tlist, [C1, C2], [C1dC1, C2dC2, a], ntraj=5, options=opts)
    assert_equal(isinstance(data.expect[0][0][1], float), True)
    assert_equal(isinstance(data.expect[0][1][1], float), True)
    assert_equal(isinstance(data.expect[0][2][1], complex), True)
Пример #11
0
def test_mc_dtypes2():
    "Monte-carlo: check for correct dtypes (average_states=False)"
    # set system parameters
    kappa = 2.0  # mirror coupling
    gamma = 0.2  # spontaneous emission rate
    g = 1  # atom/cavity coupling strength
    wc = 0  # cavity frequency
    w0 = 0  # atom frequency
    wl = 0  # driving frequency
    E = 0.5  # driving amplitude
    N = 5  # number of cavity energy levels (0->3 Fock states)
    tlist = np.linspace(0, 10, 5)  # times for expectation values
    # construct Hamiltonian
    ida = qeye(N)
    idatom = qeye(2)
    a = tensor(destroy(N), idatom)
    sm = tensor(ida, sigmam())
    H = (w0 - wl) * sm.dag() * sm + (wc - wl) * a.dag() * a + \
        1j * g * (a.dag() * sm - sm.dag() * a) + E * (a.dag() + a)
    # collapse operators
    C1 = np.sqrt(2 * kappa) * a
    C2 = np.sqrt(gamma) * sm
    C1dC1 = C1.dag() * C1
    C2dC2 = C2.dag() * C2
    # intial state
    psi0 = tensor(basis(N, 0), basis(2, 1))
    opts = Options(average_expect=False)
    data = mcsolve(H,
                   psi0,
                   tlist, [C1, C2], [C1dC1, C2dC2, a],
                   ntraj=5,
                   options=opts)
    assert_equal(isinstance(data.expect[0][0][1], float), True)
    assert_equal(isinstance(data.expect[0][1][1], float), True)
    assert_equal(isinstance(data.expect[0][2][1], complex), True)
Пример #12
0
 def test_states_and_expect(self, hamiltonian, args, c_ops, expected, tol):
     options = qutip.Options(average_states=True, store_states=True)
     result = qutip.mcsolve(hamiltonian, self.state, self.times, args=args,
                            c_ops=c_ops, e_ops=self.e_ops, ntraj=self.ntraj,
                            options=options)
     self._assert_expect(result, expected, tol)
     self._assert_states(result, expected, tol)
Пример #13
0
def test_mc_seed_noreuse():
    "Monte-carlo: check not reusing seeds"
    N0 = 6
    N1 = 6
    N2 = 6
    # damping rates
    gamma0 = 0.1
    gamma1 = 0.4
    gamma2 = 0.1
    alpha = np.sqrt(2)  # initial coherent state param for mode 0
    tlist = np.linspace(0, 10, 2)
    ntraj = 500  # number of trajectories
    # define operators
    a0 = tensor(destroy(N0), qeye(N1), qeye(N2))
    a1 = tensor(qeye(N0), destroy(N1), qeye(N2))
    a2 = tensor(qeye(N0), qeye(N1), destroy(N2))
    # number operators for each mode
    num0 = a0.dag() * a0
    num1 = a1.dag() * a1
    num2 = a2.dag() * a2
    # dissipative operators for zero-temp. baths
    C0 = np.sqrt(2.0 * gamma0) * a0
    C1 = np.sqrt(2.0 * gamma1) * a1
    C2 = np.sqrt(2.0 * gamma2) * a2
    # initial state: coherent mode 0 & vacuum for modes #1 & #2
    psi0 = tensor(coherent(N0, alpha), basis(N1, 0), basis(N2, 0))
    # trilinear Hamiltonian
    H = 1j * (a0 * a1.dag() * a2.dag() - a0.dag() * a1 * a2)
    # run Monte-Carlo
    data1 = mcsolve(H,
                    psi0,
                    tlist, [C0, C1, C2], [num0, num1, num2],
                    ntraj=ntraj)
    data2 = mcsolve(H,
                    psi0,
                    tlist, [C0, C1, C2], [num0, num1, num2],
                    ntraj=ntraj)
    diff_flag = False
    for k in range(ntraj):
        if len(data1.col_times[k]) != len(data2.col_times[k]):
            diff_flag = 1
            break
        else:
            if not np.allclose(data1.col_which[k], data2.col_which[k]):
                diff_flag = 1
                break
    assert_equal(diff_flag, 1)
Пример #14
0
def evolution_mcsolve_microwave(system,
                                H_drive,
                                initial_state,
                                c_ops,
                                e_ops,
                                num_cpus=0,
                                nsteps=2000,
                                ntraj=1000,
                                t_points=None,
                                **kwargs):
    """
    Calculates the expectation values vs time for a dissipative system
    for the gate activated by a microwave drive.

    Parameters
    ----------
    system : :class:`coupobj.CoupledObjects` or similar
        An object of a quantum system supporting system.H() method
        for the Hamiltonian.
    H_drive : :class:`qutip.Qobj`
        The time-independent part of the driving term.
        Example: f * (a + a.dag()) or f * qubit.n()
        Normalization: see `H_drive_coeff_gate` function.
    initial_state : :class:`qutip.Qobj`
        Initial state of the system.
    c_ops : *list* of :class:`qutip.Qobj`
        The list of collaps operators for MC solver.
    e_ops : *list* of :class:`qutip.Qobj`
        The list of operators to calculate expectation values.
    num_cpus, nsteps, ntraj : int
        Parameters for MC solver
    t_points : *array* of float (optional)
        Times at which the evolution operator is returned.
        If None, it is generated from `kwargs['T_gate']`.
    **kwargs:
        Contains gate parameters such as pulse shape and gate time.

    Returns
    -------
    *array*
        result.expect of mcsolve (time-dependent expectation values)
        result.expect[0] for the expectation value of the first operator
    """
    if t_points is None:
        T_gate = kwargs['T_gate']
        t_points = np.linspace(0, T_gate, 2 * int(T_gate) + 1)
    H_nodrive = system.H()
    H = [2 * np.pi * H_nodrive, [H_drive, H_drive_coeff_gate]]

    options = qt.Options(num_cpus=num_cpus, nsteps=nsteps)
    result = qt.mcsolve(H,
                        initial_state,
                        t_points,
                        c_ops=c_ops,
                        e_ops=e_ops,
                        args=kwargs,
                        ntraj=ntraj,
                        options=options)
    return result.expect
Пример #15
0
def do_qt_mcsolve(state,H,lindblads,steps,tau,**kwargs):
    progress = kwargs.pop('progress_bar',None)
    times = kwargs.pop('times',None)
    if times is None:
        times = np.linspace(0,steps*tau,steps,dtype=np.float_)
    return qt.mcsolve(H,state,times,lindblads,[],
                             options=qt.Options(**kwargs),
                             progress_bar=progress).states
Пример #16
0
 def test_expect_only(self, hamiltonian, args, c_ops, expected, tol):
     result = qutip.mcsolve(hamiltonian,
                            self.state,
                            self.times,
                            args=args,
                            c_ops=c_ops,
                            e_ops=self.e_ops,
                            ntraj=self.ntraj)
     self._assert_expect(result, expected, tol)
Пример #17
0
def correlation_ss_mc(H, tlist, c_op_list, a_op, b_op, rho0=None):
    """
    Internal function for calculating correlation functions using the Monte
    Carlo solver. See :func:`correlation_ss` usage.
    """

    if rho0 == None:
        rho0 = steadystate(H, co_op_list)

    return mcsolve(H, b_op * rho0, tlist, c_op_list, [a_op]).expect[0]
Пример #18
0
def correlation_ss_mc(H, tlist, c_op_list, a_op, b_op, rho0=None):
    """
    Internal function for calculating correlation functions using the Monte
    Carlo solver. See :func:`correlation_ss` usage.
    """

    if rho0 == None:
        rho0 = steadystate(H, co_op_list)

    return mcsolve(H, b_op * rho0, tlist, c_op_list, [a_op]).expect[0]
Пример #19
0
def test_mc_seed_noreuse():
    "Monte-carlo: check not reusing seeds"
    N0 = 6
    N1 = 6
    N2 = 6
    # damping rates
    gamma0 = 0.1
    gamma1 = 0.4
    gamma2 = 0.1
    alpha = np.sqrt(2)  # initial coherent state param for mode 0
    tlist = np.linspace(0, 10, 2)
    ntraj = 500  # number of trajectories
    # define operators
    a0 = tensor(destroy(N0), qeye(N1), qeye(N2))
    a1 = tensor(qeye(N0), destroy(N1), qeye(N2))
    a2 = tensor(qeye(N0), qeye(N1), destroy(N2))
    # number operators for each mode
    num0 = a0.dag() * a0
    num1 = a1.dag() * a1
    num2 = a2.dag() * a2
    # dissipative operators for zero-temp. baths
    C0 = np.sqrt(2.0 * gamma0) * a0
    C1 = np.sqrt(2.0 * gamma1) * a1
    C2 = np.sqrt(2.0 * gamma2) * a2
    # initial state: coherent mode 0 & vacuum for modes #1 & #2
    psi0 = tensor(coherent(N0, alpha), basis(N1, 0), basis(N2, 0))
    # trilinear Hamiltonian
    H = 1j * (a0 * a1.dag() * a2.dag() - a0.dag() * a1 * a2)
    # run Monte-Carlo
    data1 = mcsolve(H, psi0, tlist, [C0, C1, C2], [num0, num1, num2],
                    ntraj=ntraj)
    data2 = mcsolve(H, psi0, tlist, [C0, C1, C2], [num0, num1, num2],
                    ntraj=ntraj)
    diff_flag = False
    for k in range(ntraj):
        if len(data1.col_times[k]) != len(data2.col_times[k]):
            diff_flag = 1
            break
        else:
            if not np.allclose(data1.col_which[k],data2.col_which[k]):
                diff_flag = 1
                break
    assert_equal(diff_flag, 1)
Пример #20
0
def test_regression_490():
    """Test for regression of gh-490."""
    h = [qutip.sigmax(),
         [qutip.sigmay(), _regression_490_f1],
         [qutip.sigmaz(), _regression_490_f2]]
    state = (qutip.basis(2, 0) + qutip.basis(2, 1)).unit()
    times = np.linspace(0, 3, 10)
    result_me = qutip.mesolve(h, state, times)
    result_mc = qutip.mcsolve(h, state, times, ntraj=1)
    for state_me, state_mc in zip(result_me.states, result_mc.states):
        np.testing.assert_allclose(state_me.full(), state_mc.full(), atol=1e-8)
Пример #21
0
def do_qt_mcsolve(state, H, lindblads, steps, tau, **kwargs):
    progress = kwargs.pop('progress_bar', None)
    times = kwargs.pop('times', None)
    if times is None:
        times = np.linspace(0, steps * tau, steps, dtype=np.float_)
    return qt.mcsolve(H,
                      state,
                      times,
                      lindblads, [],
                      options=qt.Options(**kwargs),
                      progress_bar=progress).states
Пример #22
0
def test_dynamic_arguments():
    """Test dynamically updated arguments are usable."""
    size = 5
    a = qutip.destroy(size)
    H = qutip.num(size)
    times = np.linspace(0, 1, 11)
    state = qutip.basis(size, 2)

    c_ops = [[a, _dynamic], [a.dag(), _dynamic]]
    mc = qutip.mcsolve(H, state, times, c_ops, ntraj=25, args={"collapse": []})
    assert all(len(collapses) <= 1 for collapses in mc.col_which)
Пример #23
0
def run(neq=10, ntraj=100, solver='both', ncpus=1):
    # sparse initial state
    # psi0 = basis(neq,neq-1)
    # dense initial state
    psi0 = qt.Qobj(np.ones((neq, 1))).unit()
    a = qt.destroy(neq)
    ad = a.dag()
    H = ad*a
    # c_ops = [gamma*a]
    c_ops = [qt.qeye(neq)]
    e_ops = [ad*a]

    # Times
    T = 10.0
    dt = 0.1
    nstep = int(T/dt)
    tlist = np.linspace(0, T, nstep)

    # set options
    opts = qt.Options()
    opts.num_cpus = ncpus
    opts.gui = False

    mcf90_time = 0.
    mc_time = 0.
    if (solver == 'mcf90' or solver == 'both'):
        start_time = time.time()
        mcf90.mcsolve_f90(H, psi0, tlist, c_ops, e_ops,
                          ntraj=ntraj, options=opts)

        mcf90_time = time.time()-start_time
        print("mcsolve_f90 solutiton took", mcf90_time, "s")

    if (solver == 'mc' or solver == 'both'):
        start_time = time.time()
        qt.mcsolve(H, psi0, tlist, c_ops, e_ops, ntraj=ntraj,
                   options=opts, progress_bar=False)
        mc_time = time.time()-start_time
        print("mcsolve solutiton took", mc_time, "s")

    return mcf90_time, mc_time
Пример #24
0
 def mcsolve(self, ntrajs=500, exps=[], initial_state=None):
     """mcsolve
     Interface to qutip mcsolve for the system
     :param ntrajs: number of quantum trajectories to average.
     Default is QuTiP
     default of 500
     :param exps: List of expectation values to calculate at
     each timestep
     """
     if initial_state is None:
         initial_state = qt.tensor(qt.basis(self.N_field_levels, 0), qt.basis(2, 0))
     return qt.mcsolve(self.hamiltonian()[0], initial_state, self.tlist, self._c_ops(), exps, ntraj=ntrajs)
Пример #25
0
def test_MCCollapseTimesOperators():
    "Monte-carlo: Check for stored collapse operators and times"
    N = 10
    kappa = 5.0
    times = np.linspace(0, 10, 100)
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)
    c_ops = [np.sqrt(kappa) * a, np.sqrt(kappa) * a]
    result = mcsolve(H, psi0, times, c_ops, [], ntraj=1)
    assert_(len(result.col_times[0]) > 0)
    assert_(len(result.col_which) == len(result.col_times))
    assert_(set(result.col_which[0]) == {0, 1})
Пример #26
0
def correlation_mc(H, psi0, tlist, taulist, c_op_list, a_op, b_op):
    """
    Internal function for calculating correlation functions using the Monte
    Carlo solver. See :func:`correlation` usage.
    """

    C_mat = zeros([size(tlist),size(taulist)],dtype=complex)

    ntraj = 100

    mc_opt = Mcoptions()
    mc_opt.progressbar = False

    psi_t = mcsolve(H, psi0, tlist, ntraj, c_op_list, [], mc_opt).states

    for t_idx in range(len(tlist)):

        psi0_t = psi_t[0][t_idx]

        C_mat[t_idx, :] = mcsolve(H, b_op * psi0_t, tlist, ntraj, c_op_list, [a_op], mc_opt).expect[0]

    return C_mat
Пример #27
0
def test_MCCollapseTimesOperators():
    "Monte-carlo: Check for stored collapse operators and times"
    N = 10
    kappa = 5.0
    times = np.linspace(0, 10, 100)
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)
    c_ops = [np.sqrt(kappa) * a, np.sqrt(kappa) * a]
    result = mcsolve(H, psi0, times, c_ops, [], ntraj=1)
    assert_(len(result.col_times[0]) > 0)
    assert_(len(result.col_which) == len(result.col_times))
    assert_(set(result.col_which[0]) == {0, 1})
Пример #28
0
def test_MCSimpleSingleExpect():
    """Monte-carlo: Constant H with single expect operator"""
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [np.sqrt(kappa) * a]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, a.dag() * a, ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.exp(-kappa * tlist)
    avg_diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(avg_diff < mc_error, True)
Пример #29
0
def test_MCSimpleConstFunc():
    "Monte-carlo: Collapse terms constant (func format)"
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [[a, sqrt_kappa]]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.exp(-kappa * tlist)
    avg_diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(avg_diff < mc_error, True)
Пример #30
0
def correlation_mc(H, psi0, tlist, taulist, c_op_list, a_op, b_op):
    """
    Internal function for calculating correlation functions using the Monte
    Carlo solver. See :func:`correlation` usage.
    """

    C_mat = zeros([size(tlist), size(taulist)], dtype=complex)

    ntraj = 100

    mc_opt = Mcoptions()
    mc_opt.progressbar = False

    psi_t = mcsolve(H, psi0, tlist, ntraj, c_op_list, [], mc_opt).states

    for t_idx in range(len(tlist)):

        psi0_t = psi_t[0][t_idx]

        C_mat[t_idx, :] = mcsolve(H, b_op * psi0_t, tlist, ntraj, c_op_list,
                                  [a_op], mc_opt).expect[0]

    return C_mat
Пример #31
0
def test_MCNoCollExpt():
    "Monte-carlo: Constant H with no collapse ops (expect)"
    error = 1e-8
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    c_op_list = []
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.ones(len(tlist))
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #32
0
def test_MCSimpleConstFunc():
    "Monte-carlo: Collapse terms constant (func format)"
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [[a, sqrt_kappa]]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.exp(-kappa * tlist)
    avg_diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(avg_diff < mc_error, True)
Пример #33
0
def test_MCNoCollExpt():
    "Monte-carlo: Constant H with no collapse ops (expect)"
    error = 1e-8
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    c_op_list = []
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.ones(len(tlist))
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #34
0
def test_MCSimpleSingleExpect():
    """Monte-carlo: Constant H with single expect operator"""
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [np.sqrt(kappa) * a]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, a.dag() * a, ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.exp(-kappa * tlist)
    avg_diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(avg_diff < mc_error, True)
Пример #35
0
def test_MCTDFunc():
    "Monte-carlo: Time-dependent H (func format)"
    error = 5e-2
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [[a, sqrt_kappa2]]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.exp(-kappa * (1.0 - np.exp(-tlist)))
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #36
0
def test_MCNoCollFuncStates():
    "Monte-carlo: Constant H (func format) with no collapse ops (states)"
    error = 1e-8
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = [a.dag() * a, [a.dag() * a, const_H1_coeff]]
    psi0 = basis(N, 9)  # initial state
    c_op_list = []
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [], ntraj=ntraj)
    states = mcdata.states
    expt = expect(a.dag() * a, states)
    actual_answer = 9.0 * np.ones(len(tlist))
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #37
0
def test_MCTDFunc():
    "Monte-carlo: Time-dependent H (func format)"
    error = 5e-2
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [[a, sqrt_kappa2]]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj)
    expt = mcdata.expect[0]
    actual_answer = 9.0 * np.exp(-kappa * (1.0 - np.exp(-tlist)))
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #38
0
def test_stored_collapse_operators_and_times():
    """
    Test that the output contains information on which collapses happened and
    at what times, and make sure that this information makes sense.
    """
    size = 10
    a = qutip.destroy(size)
    H = qutip.num(size)
    state = qutip.basis(size, size - 1)
    times = np.linspace(0, 10, 100)
    c_ops = [a, a]
    result = qutip.mcsolve(H, state, times, c_ops, ntraj=1)
    assert len(result.col_times[0]) > 0
    assert len(result.col_which) == len(result.col_times)
    assert all(col in [0, 1] for col in result.col_which[0])
Пример #39
0
def test_MCNoCollFuncStates():
    "Monte-carlo: Constant H (func format) with no collapse ops (states)"
    error = 1e-8
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = [a.dag() * a, [a.dag() * a, const_H1_coeff]]
    psi0 = basis(N, 9)  # initial state
    c_op_list = []
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [], ntraj=ntraj)
    states = mcdata.states
    expt = expect(a.dag() * a, states)
    actual_answer = 9.0 * np.ones(len(tlist))
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #40
0
def test_mc_ntraj_list():
    "Monte-carlo: list of trajectories"
    N = 5
    a = destroy(N)
    H = a.dag() * a  # Simple oscillator Hamiltonian
    psi0 = basis(N, 1)  # Initial Fock state with one photon
    kappa = 1.0 / 0.129  # Coupling rate to heat bath
    nth = 0.063  # Temperature with <n>=0.063
    # Build collapse operators for the thermal bath
    c_ops = []
    c_ops.append(np.sqrt(kappa * (1 + nth)) * a)
    c_ops.append(np.sqrt(kappa * nth) * a.dag())
    ntraj = [1, 5, 15, 904]  # number of MC trajectories
    tlist = np.linspace(0, 0.8, 100)
    mc = mcsolve(H, psi0, tlist, c_ops, [a.dag() * a], ntraj)
    assert_equal(len(mc.expect), 4)
Пример #41
0
def test_mc_ntraj_list():
    "Monte-carlo: list of trajectories"
    N = 5
    a = destroy(N)
    H = a.dag()*a       # Simple oscillator Hamiltonian
    psi0 = basis(N, 1)  # Initial Fock state with one photon
    kappa = 1.0/0.129   # Coupling rate to heat bath
    nth = 0.063         # Temperature with <n>=0.063
    # Build collapse operators for the thermal bath
    c_ops = []
    c_ops.append(np.sqrt(kappa * (1 + nth)) * a)
    c_ops.append(np.sqrt(kappa * nth) * a.dag())
    ntraj = [1, 5, 15, 904]  # number of MC trajectories
    tlist = np.linspace(0, 0.8, 100)
    mc = mcsolve(H, psi0, tlist, c_ops, [a.dag()*a], ntraj)
    assert_equal(len(mc.expect), 4)
Пример #42
0
def test_list_ntraj():
    """Test that `ntraj` can be a list."""
    size = 5
    a = qutip.destroy(size)
    H = qutip.num(size)
    state = qutip.basis(size, 1)
    times = np.linspace(0, 0.8, 100)
    # Arbitrary coupling and bath temperature.
    coupling = 1 / 0.129
    n_th = 0.063
    c_ops = [np.sqrt(coupling * (n_th + 1)) * a,
             np.sqrt(coupling * n_th) * a.dag()]
    e_ops = [qutip.num(size)]
    ntraj = [1, 5, 15, 100]
    mc = qutip.mcsolve(H, state, times, c_ops, e_ops, ntraj=ntraj)
    assert len(ntraj) == len(mc.expect)
Пример #43
0
def test_MCSimpleConstStates():
    "Monte-carlo: Constant H with constant collapse (states)"
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [np.sqrt(kappa) * a]
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [], ntraj=ntraj,
                     options=Options(average_states=True))
    assert_(len(mcdata.states) == len(tlist))
    assert_(isinstance(mcdata.states[0], Qobj))
    expt = expect(a.dag() * a, mcdata.states)
    actual_answer = 9.0 * np.exp(-kappa * tlist)
    avg_diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(avg_diff < mc_error, True)
Пример #44
0
def test_TDStr():
    "Monte-carlo: Time-dependent H (str format)"
    error = 5e-2
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    kappa = 0.2  # coupling to oscillator
    c_op_list = [[a, 'sqrt(k*exp(-t))']]
    args = {'k': kappa}
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], args=args,
                     ntraj=ntraj)
    expt = mcdata.expect[0]
    actual = 9.0 * np.exp(-kappa * (1.0 - np.exp(-tlist)))
    diff = np.mean(abs(actual - expt) / actual)
    assert_equal(diff < error, True)
Пример #45
0
def test_expectation_dtype(options):
    # We're just testing the output value, so it's important whether certain
    # things are complex or real, but not what the magnitudes of constants are.
    focks = 5
    a = qutip.tensor(qutip.destroy(focks), qutip.qeye(2))
    sm = qutip.tensor(qutip.qeye(focks), qutip.sigmam())
    H = 1j*a.dag()*sm + a
    H = H + H.dag()
    state = qutip.basis([focks, 2], [0, 1])
    times = np.linspace(0, 10, 5)
    c_ops = [a, sm]
    e_ops = [a.dag()*a, sm.dag()*sm, a]
    data = qutip.mcsolve(H, state, times, c_ops, e_ops, ntraj=5,
                         options=options)
    assert isinstance(data.expect[0][1], float)
    assert isinstance(data.expect[1][1], float)
    assert isinstance(data.expect[2][1], complex)
Пример #46
0
 def mcsolve(self, ntrajs=500, exps=[], initial_state=None):
     """mcsolve
     Interface to qutip mcsolve for the system
     :param ntrajs: number of quantum trajectories to average.
     Default is QuTiP
     default of 500
     :param exps: List of expectation values to calculate at
     each timestep
     """
     if initial_state is None:
         initial_state = qt.tensor(qt.basis(self.N_field_levels, 0),
                                   qt.basis(2, 0))
     return qt.mcsolve(self.hamiltonian()[0],
                       initial_state,
                       self.tlist,
                       self._c_ops(),
                       exps,
                       ntraj=ntrajs)
Пример #47
0
def steady_state_mc(Ej,
                    Ec,
                    ng,
                    g,
                    wr,
                    kappa,
                    gamma,
                    gamma_phi,
                    N,
                    J,
                    xi,
                    wd,
                    ntraj,
                    ti,
                    tf,
                    tsteps,
                    cpus=None):
    values = locals()
    p = SimpleNamespace()
    p.__dict__.update(values)
    times = np.linspace(p.ti, p.tf, p.tsteps)
    ham = jaynes_cummings(p)
    psi0 = jaynes_cummings(p, driven=False).groundstate()[1]

    opts = qt.Odeoptions()
    if cpus:
        opts.num_cpus = cpus

    actualstdout = sys.stdout
    sys.stdout = cStringIO.StringIO()  # avoids prints to stdout
    t_evol = qt.mcsolve(ham,
                        psi0,
                        times,
                        decoherence(p),
                        op_list(p),
                        p.ntraj,
                        options=opts)
    sys.stdout = actualstdout  # reactivates stdout

    result = np.array([i[-1] for i in t_evol.expect])
    result[-1] = np.abs(result[-1])
    return tuple(np.real(result))
Пример #48
0
def test_MCNoCollExpectStates():
    "Monte-carlo: Constant H with no collapse ops (expect and states)"
    error = 1e-8
    N = 10  # number of basis states to consider
    a = destroy(N)
    H = a.dag() * a
    psi0 = basis(N, 9)  # initial state
    c_op_list = []
    tlist = np.linspace(0, 10, 100)
    mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=ntraj,
                     options=Options(store_states=True))
    actual_answer = 9.0 * np.ones(len(tlist))
    expt = mcdata.expect[0]
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
    assert_(len(mcdata.states) == len(tlist))
    assert_(isinstance(mcdata.states[0], Qobj))
    expt = expect(a.dag() * a, mcdata.states)
    diff = np.mean(abs(actual_answer - expt) / actual_answer)
    assert_equal(diff < error, True)
Пример #49
0
def solve_lindblad(gamma1, gamma2, nbar_omega, nbar_delta, kappa,
                   rho0, tlist, is_mc=False, opts=None):
    # define system
    adag = qutip.create(N)
    a = adag.dag()
    H = hbar * omega * adag * a
    nbar2_omega = nbar_omega ** 2 / (1 + 2 * nbar_omega)
    # define collapse operators
    C_arr = []
    C_arr.append(gamma1 * (1 + nbar_omega) * a)
    C_arr.append(gamma2 * (1 + nbar2_omega) * a * a)
    C_arr.append(kappa * (1 + nbar_delta) * adag)
    if nbar_omega > 0:
        C_arr.append(gamma1 * nbar_omega * adag)
        C_arr.append(gamma2 * nbar2_omega * adag * adag)
    if nbar_delta > 0:
        C_arr.append(kappa * nbar_delta * a)
    # solve master eq.
    if is_mc:
        return qutip.mcsolve(H, rho0, tlist, C_arr, [])
    else:
        return qutip.mesolve(H, rho0, tlist, C_arr, [], options=opts)
Пример #50
0
    def trajectory(self, exps=None, initial_state=None, draw=False):
        """for convenience. Calculates the trajectory of an
        observable for one montecarlo run. Default expectation is
        cavity amplitude, default initial state is bipartite
        vacuum. todo: draw: draw trajectory on bloch sphere.
        Write in terms of mcsolve??"""
        if exps is None or draw is True:
            exps = []
        if initial_state is None:
            initial_state = qt.tensor(qt.basis(self.N_field_levels, 0), qt.basis(2, 0))

        self.one_traj_soln = qt.mcsolve(self.hamiltonian(), initial_state, self.tlist, self._c_ops(), exps, ntraj=1)
        if self.noisy:
            print(self.one_traj_soln.states[0][2].ptrace(1))

        if not draw:
            return self.one_traj_soln
        else:
            self.b_sphere = qt.Bloch()
            self.b_sphere.add_states([state.ptrace(1) for state in self.one_traj_soln.states[0]], "point")
            self.b_sphere.point_markers = ["o"]
            self.b_sphere.size = (10, 10)
            self.b_sphere.show()
Пример #51
0
def test():
    gamma = 1.
    neq = 2
    psi0 = qt.basis(neq,neq-1)
    #a = qt.destroy(neq)
    #ad = a.dag()
    #H = ad*a
    #c_ops = [gamma*a]
    #e_ops = [ad*a]
    H = qt.sigmax()
    c_ops = [np.sqrt(gamma)*qt.sigmax()]
    #c_ops = []
    e_ops = [qt.sigmam()*qt.sigmap(),qt.sigmap()*qt.sigmam()]
    #e_ops = []

    # Times
    T = 2.0
    dt = 0.1
    nstep = int(T/dt)
    tlist = np.linspace(0,T,nstep)

    ntraj=100

    # set options
    opts = qt.Odeoptions()
    opts.num_cpus=2
    #opts.mc_avg = True
    #opts.gui=False
    #opts.max_step=1000
    #opts.atol =
    #opts.rtol =

    sol_f90 = qt.Odedata()
    start_time = time.time()
    sol_f90 = mcf90.mcsolve_f90(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj,options=opts)
    print "mcsolve_f90 solutiton took", time.time()-start_time, "s"

    sol_me = qt.Odedata()
    start_time = time.time()
    sol_me = qt.mesolve(H,psi0,tlist,c_ops,e_ops,options=opts)
    print "mesolve solutiton took", time.time()-start_time, "s"

    sol_mc = qt.Odedata()
    start_time = time.time()
    sol_mc = qt.mcsolve(H,psi0,tlist,c_ops,e_ops,ntraj=ntraj,options=opts)
    print "mcsolve solutiton took", time.time()-start_time, "s"

    if (e_ops == []):
        e_ops = [qt.sigmam()*qt.sigmap(),qt.sigmap()*qt.sigmam()]
        sol_f90expect = [np.array([0.+0.j]*nstep)]*len(e_ops)
        sol_mcexpect = [np.array([0.+0.j]*nstep)]*len(e_ops)
        sol_meexpect = [np.array([0.+0.j]*nstep)]*len(e_ops)
        for i in range(len(e_ops)):
            if (not opts.mc_avg):
                sol_f90expect[i] = sum([qt.expect(e_ops[i],
                    sol_f90.states[j]) for j in range(ntraj)])/ntraj
                sol_mcexpect[i] = sum([qt.expect(e_ops[i],
                    sol_mc.states[j]) for j in range(ntraj)])/ntraj
            else:
                sol_f90expect[i] = qt.expect(e_ops[i],sol_f90.states)
                sol_mcexpect[i] = qt.expect(e_ops[i],sol_mc.states)
            sol_meexpect[i] = qt.expect(e_ops[i],sol_me.states)
    elif (not opts.mc_avg):
        sol_f90expect = sum(sol_f90.expect,0)/ntraj
        sol_mcexpect = sum(sol_f90.expect,0)/ntraj
        sol_meexpect = sol_me.expect
    else:
        sol_f90expect = sol_f90.expect
        sol_mcexpect = sol_mc.expect
        sol_meexpect = sol_me.expect

    plt.figure()
    for i in range(len(e_ops)):
        plt.plot(tlist,sol_f90expect[i],'b')
        plt.plot(tlist,sol_mcexpect[i],'g')
        plt.plot(tlist,sol_meexpect[i],'k')

    return sol_f90, sol_mc