def test_liouvillian(): """Test conversion of Hamiltonian/Lindblad operators into a Liouvillian""" H = [ tensor(sigmaz(), identity(2)) + tensor(identity(2), sigmaz()), [tensor(sigmax(), identity(2)), lambda t, args: 1.0], [tensor(identity(2), sigmax()), lambda t, args: 1.0], ] c_ops = [tensor(sigmam(), identity(2)), tensor(identity(2), sigmam())] assert ( krotov.objectives.liouvillian(H[0], c_ops) - qutip.liouvillian(H[0], c_ops) ).norm('max') < 1e-15 L = krotov.objectives.liouvillian(H, c_ops) assert isinstance(L, list) assert len(L) == 3 assert (L[0] - qutip.liouvillian(H[0], c_ops)).norm('max') < 1e-15 assert (L[1][0] - qutip.liouvillian(H[1][0])).norm('max') < 1e-15 assert (L[2][0] - qutip.liouvillian(H[2][0])).norm('max') < 1e-15 assert L[1][1] is H[1][1] assert L[2][1] is H[2][1] with pytest.raises(ValueError): krotov.objectives.liouvillian(tuple(H), c_ops)
def liouvillian(omega, g, gamma, beta): """Liouvillian for the coupled system of qubit and TLS""" H0_q = omega*0.5*(-qutip.operators.sigmaz()+qutip.qeye(2)) # drive qubit Hamiltonian H1_q = -0.5*qutip.operators.sigmax() # drift TLS Hamiltonian H0_T = qutip.tensor(omega*0.5*(-qutip.operators.sigmaz()+qutip.qeye(2)), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2))\ +qutip.tensor(qutip.qeye(2), omega*0.5*(-qutip.operators.sigmaz()+qutip.qeye(2)), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2))\ +qutip.tensor(qutip.qeye(2), qutip.qeye(2), omega*0.5*(-qutip.operators.sigmaz()+qutip.qeye(2)), qutip.qeye(2), qutip.qeye(2))\ +qutip.tensor(qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), omega*0.5*(-qutip.operators.sigmaz()+qutip.qeye(2)), qutip.qeye(2))\ +qutip.tensor(qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), omega*0.5*(-qutip.operators.sigmaz() + qutip.qeye(2))) # Lift Hamiltonians to joint system operators H0 = qutip.tensor(H0_q, qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2)) + qutip.tensor(qutip.qeye(2), H0_T) H1 = qutip.tensor(H1_q, qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2), qutip.qeye(2)) # qubit-TLS interaction H_int = g*(qutip.tensor(qutip.destroy(2),qutip.create(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2))\ +qutip.tensor(qutip.create(2),qutip.destroy(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2))\ +qutip.tensor(qutip.destroy(2),qutip.qeye(2),qutip.create(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2))\ +qutip.tensor(qutip.create(2),qutip.qeye(2),qutip.destroy(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2))\ +qutip.tensor(qutip.destroy(2),qutip.qeye(2),qutip.qeye(2),qutip.create(2),qutip.qeye(2),qutip.qeye(2))\ +qutip.tensor(qutip.create(2),qutip.qeye(2),qutip.qeye(2),qutip.destroy(2),qutip.qeye(2),qutip.qeye(2))\ +qutip.tensor(qutip.destroy(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.create(2),qutip.qeye(2))\ +qutip.tensor(qutip.create(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.destroy(2),qutip.qeye(2))\ +qutip.tensor(qutip.destroy(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.create(2))\ +qutip.tensor(qutip.create(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.destroy(2))) # convert Hamiltonians to QuTiP objects H0 = qutip.Qobj(H0 + H_int) H1 = qutip.Qobj(H1) # Define Lindblad operators N = 1.0 / (np.exp(beta * omega) - 1.0) # Cooling on TLS L1 = np.sqrt(gamma * (N + 1)) * qutip.tensor(qutip.destroy(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2)) # Heating on TLS L2 = np.sqrt(gamma * N) *qutip.tensor(qutip.create(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2),qutip.qeye(2)) # convert Lindblad operators to QuTiP objects L1 = qutip.Qobj(L1) L2 = qutip.Qobj(L2) # generate the Liouvillian L0 = qutip.liouvillian(H=H0, c_ops=[L1, L2]) L1 = qutip.liouvillian(H=H1) # Shift the qubit and TLS into resonance by default eps0 = lambda t, args: 1 return [L0, [L1, eps0]]
def liouvillian(omega, g, gamma, beta,n,amp): """Liouvillian for the coupled system of qubit and TLS""" A=np.zeros((n,n)) B=np.zeros((n,n)) Mu=np.zeros((n,n)) for i in range (n): for j in range (n): if j-i==1: A[i,j]=0.5 elif i-j==1: B[i,j]=0.5 Mu=A+B H0_q = qutip.Qobj(omega*np.array(np.dot(qutip.create(n),qutip.destroy(n)))) # drive qubit Hamiltonian H1_q = omega*Mu # drift TLS Hamiltonian H0_T = omega*np.array(np.dot(qutip.create(n),qutip.destroy(n))) # Lift Hamiltonians to joint system operators H0 = np.kron(H0_q, np.identity(n)) + np.kron(np.identity(n), H0_T) H1 = np.kron(H1_q, np.identity(n)) # qubit-TLS interaction H_int = g*(np.kron(np.array(qutip.create(n)),np.array(qutip.destroy(n)))+np.kron(np.array(qutip.destroy(n)),np.array(qutip.create(n)))) # convert Hamiltonians to QuTiP objects H0 = qutip.Qobj(H0 + H_int) H1 = qutip.Qobj(H1) # Define Lindblad operators N = 1.0 / (np.exp(beta * omega) - 1.0) L=[] k=0 for i in range (0,n-1): # Cooling on TLS L.append(np.sqrt(gamma * (N + 1)) * np.kron(np.array(qutip.basis(n,i)*qutip.basis(n,i+1).dag()),np.identity(n))) L.append(np.sqrt(gamma * N) * np.kron(np.array(qutip.basis(n,i+1)*qutip.basis(n,i).dag()),np.identity(n))) L[k]=qutip.Qobj(L[k]) L[k+1]=qutip.Qobj(L[k+1]) k=2*(i+1) # convert Lindblad operators to QuTiP objects # generate the Liouvillian L0 = qutip.liouvillian(H=H0, c_ops=L) L1 = qutip.liouvillian(H=H1) # Shift the qubit and TLS into resonance by default eps0 = lambda t, args: amp return [L0, [L1, eps0]]
def test_dissipation_superop(tmpdir, request, H0, L1, L2): """Test that we can add a dissipatio superoperator as an alternative to Lindblad operators""" filename = request.module.__file__ test_dir, _ = os.path.splitext(filename) model = LevelModel() model.add_ham(H0) model.add_lindblad_op(L1) model.add_lindblad_op(L2) D = qutip.liouvillian(H=None, c_ops=[qutip.Qobj(L1), qutip.Qobj(L2)]) with pytest.raises(ValueError): model.set_dissipator(D) model._lindblad_ops = [] model.set_dissipator(D) with pytest.raises(ValueError): model.add_lindblad_op(L1) model.write_to_runfolder(str(tmpdir.join('model_rf')), config='dissipator.config') assert filecmp.cmp( os.path.join(test_dir, 'dissipator.config'), str(tmpdir.join('model_rf', 'dissipator.config')), shallow=False, )
def _spectrum_es(H, wlist, c_ops, a_op, b_op): """ Internal function for calculating the spectrum of the correlation function :math:`\left<A(\\tau)B(0)\\right>`. """ if debug: print(inspect.stack()[0][3]) # construct the Liouvillian L = liouvillian(H, c_ops) # find the steady state density matrix and a_op and b_op expecation values rho0 = steadystate(L) a_op_ss = expect(a_op, rho0) b_op_ss = expect(b_op, rho0) # eseries solution for (b * rho0)(t) es = ode2es(L, b_op * rho0) # correlation corr_es = expect(a_op, es) # covariance cov_es = corr_es - np.real(np.conjugate(a_op_ss) * b_op_ss) # spectrum spectrum = esspec(cov_es, wlist) return spectrum
def time_evolution(H_vec, c_ops, sim_step): ''' Arguments: H: list of Hamiltonians at different times, each on for a time = sim_step c_ops: list of collapse operators. if an element of the list is a single operator, then it is a time-independent one, otherwise, if it's a 2-list, then the first el. is the operator and the second one is a list of time-dependent coefficients. Note that in the first case the coefficient is included in the operator sim_step: time for which each H[t] is on. ''' exp_L_total = 1 for i in range(len(H_vec)): H = H_vec[i] if c_ops != []: c_ops_temp = [] for c in range(len(c_ops)): if isinstance(c_ops[c], list): c_ops_temp.append( c_ops[c][0] * c_ops[c][1][i]) # c_ops are already in the H_0 basis else: c_ops_temp.append(c_ops[c]) liouville_exp_t = (qtp.liouvillian(H, c_ops_temp) * sim_step).expm() else: liouville_exp_t = (-1j * H * sim_step).expm() exp_L_total = liouville_exp_t * exp_L_total return exp_L_total
def time_evolution_squarepulse(H, c_ops, time, initial_propagator=1): '''scalefactor=1e6 tlist_sim=tlist_sim*scalefactor eps_vec=eps_vec/scalefactor H_0=H_0/scalefactor if c_ops!=[]: # c_ops is a list of either operators or lists where the first element is # an operator and the second one is a list of the (time-dependent) coefficients for c in range(len(c_ops)): if isinstance(c_ops[c],list): c_ops[c][1]=c_ops[c][1]/np.sqrt(scalefactor) else: c_ops[c]=c_ops[c]/np.sqrt(scalefactor)''' exp_L_total = initial_propagator ''' if isinstance(tlist_sim,list): length_tlist=len(tlist_sim) else: length_tlist=np.size(tlist_sim)''' c_ops_temp = list() if c_ops != []: for c in range(len(c_ops)): if isinstance(c_ops[c], list): c_ops_temp.append(c_ops[c][0] * c_ops[c][1][i]) else: c_ops_temp.append(c_ops[c]) liouville_exp_t = (qtp.liouvillian(H, c_ops_temp) * time).expm() else: liouville_exp_t = (-1j * H * time).expm() exp_L_total = liouville_exp_t * exp_L_total return exp_L_total
def test_dissipation_superop(tmpdir, request, H0, L1, L2): """Test that we can add a dissipatio superoperator as an alternative to Lindblad operators""" filename = request.module.__file__ test_dir, _ = os.path.splitext(filename) model = LevelModel() model.add_ham(H0) model.add_lindblad_op(L1) model.add_lindblad_op(L2) D = qutip.liouvillian(H=None, c_ops=[qutip.Qobj(L1), qutip.Qobj(L2)]) with pytest.raises(ValueError): model.set_dissipator(D) model._lindblad_ops = [] model.set_dissipator(D) with pytest.raises(ValueError): model.add_lindblad_op(L1) model.write_to_runfolder( str(tmpdir.join('model_rf')), config='dissipator.config' ) assert filecmp.cmp( os.path.join(test_dir, 'dissipator.config'), str(tmpdir.join('model_rf', 'dissipator.config')), shallow=False, )
def test_pseudo_inverse(method, kwargs): N = 4 a = qutip.destroy(N) H = (a.dag() + a) L = qutip.liouvillian(H, [a]) rho = qutip.steadystate(L) Lpinv = qutip.pseudo_inverse(L, rho, method=method, **kwargs) np.testing.assert_allclose((L * Lpinv * L).full(), L.full()) np.testing.assert_allclose((Lpinv * L * Lpinv).full(), Lpinv.full())
def test_dqd_current(): "Counting statistics: current and current noise in a DQD model" G = 0 L = 1 R = 2 sz = qutip.projection(3, L, L) - qutip.projection(3, R, R) sx = qutip.projection(3, L, R) + qutip.projection(3, R, L) sR = qutip.projection(3, G, R) sL = qutip.projection(3, G, L) w0 = 1 tc = 0.6 * w0 GammaR = 0.0075 * w0 GammaL = 0.0075 * w0 nth = 0.00 eps_vec = np.linspace(-1.5 * w0, 1.5 * w0, 20) J_ops = [GammaR * qutip.sprepost(sR, sR.dag())] c_ops = [ np.sqrt(GammaR * (1 + nth)) * sR, np.sqrt(GammaR * (nth)) * sR.dag(), np.sqrt(GammaL * (nth)) * sL, np.sqrt(GammaL * (1 + nth)) * sL.dag() ] current = np.zeros(len(eps_vec)) noise = np.zeros(len(eps_vec)) for n, eps in enumerate(eps_vec): H = (eps / 2 * sz + tc * sx) L = qutip.liouvillian(H, c_ops) rhoss = qutip.steadystate(L) current[n], noise[n] = qutip.countstat_current_noise(L, [], rhoss=rhoss, J_ops=J_ops) current2 = qutip.countstat_current(L, rhoss=rhoss, J_ops=J_ops) assert abs(current[n] - current2) < 1e-8 current2 = qutip.countstat_current(L, c_ops, J_ops=J_ops) assert abs(current[n] - current2) < 1e-8 current_target = (tc**2 * GammaR / (tc**2 * (2 + GammaR / GammaL) + GammaR**2 / 4 + eps_vec**2)) noise_target = current_target * ( 1 - (8 * GammaL * tc**2 * (4 * eps_vec**2 * (GammaR - GammaL) + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8 * tc**2)) / (4 * tc**2 * (2 * GammaL + GammaR) + GammaL * GammaR**2 + 4 * eps_vec**2 * GammaL)**2)) np.testing.assert_allclose(current, current_target, atol=1e-4) np.testing.assert_allclose(noise, noise_target, atol=1e-4)
def generator(k,H,L1,L2): """ Create the generator for the cascaded chain of k system copies """ # create bare operators id = qt.qeye(H.dims[0][0]) Id = qt.spre(id)*qt.spost(id) Hlist = [] L1list = [] L2list = [] for l in range(1,k+1): h = H l1 = L1 l2 = L2 for i in range(1,l): h = qt.tensor(h,id) l1 = qt.tensor(l1,id) l2 = qt.tensor(l2,id) for i in range(l+1,k+1): h = qt.tensor(id,h) l1 = qt.tensor(id,l1) l2 = qt.tensor(id,l2) Hlist.append(h) L1list.append(l1) L2list.append(l2) # create Lindbladian L = qt.Qobj() H0 = 0.5*Hlist[0] L0 = L2list[0] #L0 = 0.*L2list[0] L += qt.liouvillian(H0,[L0]) E0 = Id for l in range(k-1): E0 = qt.composite(Id,E0) Hl = 0.5*(Hlist[l]+Hlist[l+1]+1j*(L1list[l].dag()*L2list[l+1] -L2list[l+1].dag()*L1list[l])) Ll = L1list[l] + L2list[l+1] L += qt.liouvillian(Hl,[Ll]) Hk = 0.5*Hlist[k-1] Hk = 0.5*Hlist[k-1] Lk = L1list[k-1] L += qt.liouvillian(Hk,[Lk]) E0.dims = L.dims return L,E0
def essolve(self, tlist, rho0=None, recalc=True, savefile=None): """ Evolution of the density matrix by expressing the ODE as an exponential series. Args: tlist: The list of times for which to find the density matrix. rho0: Define an initial density matrix. Default is ground state. recalc: Rerun the calculation if a saved file exists? savefile: (string) Save the data to savefile.qu Returns: result: qutip result object containing the solved data. Notes: QuTiP essolve method doesn't return the states properly so I use the underlying ode2es method. Unlike the mesolve method, the tlist here doesn't have any need for high resolution to solve. So better when the density matrix is only needed at a few points. """ if not rho0: rho0 = self.ground_state() * self.ground_state().dag() savefile_exists = os.path.isfile(str(savefile) + '.qu') # Solve if 1) we ask for it to be recalculated or 2) it *must* be # calculated because no savefile exists. if (recalc or not savefile_exists): H = self.H_0 + self.H_Delta + self.H_I_sum() L = qu.liouvillian(H, self.c_ops) es = qu.ode2es(L, rho0) states = es.value(tlist) self.result = qu.solver.Result() self.result.states = states self.result.solver = "essolve" self.result.times = tlist self.rho = self.result.states[-1] # Set rho to the final state. # Only save the file if we have a place to save it. if (savefile != None): qu.qsave(self.result, savefile) # Otherwise load the steady state rho_v_delta from file else: self.result = qu.qload(savefile) self.rho = self.result.states[-1] return self.result
def test_diag_liou_mult(dimension): "BR Tools : Diagonal Liouvillian mult" H = qutip.rand_dm(dimension, 0.5) evals, evecs = H.eigenstates() L = qutip.liouvillian(H.transform(evecs)) coefficients = np.ones((dimension * dimension, ), dtype=np.complex128) calculated = np.zeros_like(coefficients) target = L.data.dot(coefficients) _test_diag_liou_mult(evals, coefficients, calculated, dimension) np.testing.assert_allclose(target, calculated, atol=1e-11, rtol=1e-6)
def to_qobj(self) -> "qutip.liouvillian": # noqa: F821 r"""Convert the operator to a qutip's liouvillian Qobj. Returns: A `qutip.liouvillian` object. """ from qutip import liouvillian return liouvillian(self.hamiltonian.to_qobj(), [op.to_qobj() for op in self.jump_operators])
def test_diag_liou_mult(): "BR Tools : Diagonal Liouvillian mult" for dimension in range(2, 100): H = qutip.rand_dm(dimension, 0.5) evals, evecs = H.eigenstates() L = qutip.liouvillian(H.transform(evecs)) coefficients = np.ones((dimension*dimension,), dtype=np.complex128) calculated = np.zeros_like(coefficients) target = L.data.dot(coefficients) _test_diag_liou_mult(evals, coefficients, calculated, dimension) assert np.allclose(target, calculated)
def test_bad_options_pseudo_inverse(): N = 4 a = qutip.destroy(N) H = (a.dag() + a) L = qutip.liouvillian(H, [a]) with pytest.raises(TypeError): qutip.pseudo_inverse(L, method='splu', bad_opt=True) with pytest.raises(ValueError): qutip.pseudo_inverse(L, method='not a method', sparse=False) with pytest.raises(ValueError): qutip.pseudo_inverse(L, method='not a method')
def test_dqd_current(): "Counting statistics: current and current noise in a DQD model" G = 0 L = 1 R = 2 sz = projection(3, L, L) - projection(3, R, R) sx = projection(3, L, R) + projection(3, R, L) sR = projection(3, G, R) sL = projection(3, G, L) w0 = 1 tc = 0.6 * w0 GammaR = 0.0075 * w0 GammaL = 0.0075 * w0 nth = 0.00 eps_vec = np.linspace(-1.5*w0, 1.5*w0, 20) J_ops = [GammaR * sprepost(sR, sR.dag())] c_ops = [np.sqrt(GammaR * (1 + nth)) * sR, np.sqrt(GammaR * (nth)) * sR.dag(), np.sqrt(GammaL * (nth)) * sL, np.sqrt(GammaL * (1 + nth)) * sL.dag(), ] I = np.zeros(len(eps_vec)) S = np.zeros(len(eps_vec)) for n, eps in enumerate(eps_vec): H = (eps/2 * sz + tc * sx) L = liouvillian(H, c_ops) rhoss = steadystate(L) I[n], S[n] = countstat_current_noise(L, [], rhoss=rhoss, J_ops=J_ops) I2 = countstat_current(L, rhoss=rhoss, J_ops=J_ops) assert_(abs(I[n] - I2) < 1e-8) I2 = countstat_current(L, c_ops, J_ops=J_ops) assert_(abs(I[n] - I2) < 1e-8) Iref = tc**2 * GammaR / (tc**2 * (2 + GammaR/GammaL) + GammaR**2/4 + eps_vec**2) Sref = 1 * Iref * ( 1 - 8 * GammaL * tc**2 * (4 * eps_vec**2 * (GammaR - GammaL) + GammaR * (3 * GammaL * GammaR + GammaR**2 + 8*tc**2)) / (4 * tc**2 * (2 * GammaL + GammaR) + GammaL * GammaR**2 + 4 * eps_vec**2 * GammaL)**2 ) assert_allclose(I, Iref, 1e-4) assert_allclose(S, Sref, 1e-4)
def two_tone(vg, listening=False, use_pinv=True): phi, wd = vg H = make_H(phi, Omega, wd * nvec, 0.0) if listening: final_state = steadystate(H, c_op_list) return expect(a, final_state) L = liouvillian(H, c_op_list) #tr_mat = tensor([qeye(n) for n in L.dims[0][0]]) #N = prod(L.dims[0][0]) A = L.full() #tr_vec = transpose(mat2vec(tr_mat.full())) rho_ss = steadystate(L) rho = transpose(mat2vec(rho_ss.full())) #P = kron(transpose(rho), tr_vec) #Q = I - P w = wp - wd if 1: D, U = eig(A) Uinv = inv(U) #spectrum = zeros(len(wlist)) #for idx, w in enumerate(wlist): if 1: if use_pinv: MMR = pinv(-1.0j * w * I + A) #MMR = A*MMR*inv(A) elif use_pinv == 1: MMR = dot(Q, solve(-1.0j * w * I + A, Q)) else: MMR = diag(1.0 / (1.0j * w * diag(I) + diag(D))) Lint = U * MMR * Uinv #Chi_temp[i,j] += (1/theta_steps)*1j*trace(reshape(tm_l*Lint*(p_l - p_r)*rho_ss_c,dim,dim)) #rho_tr=transpose(rho) #p1=dot(b_sup, rho_tr) #p2=dot(rho_tr, b_sup) #s = dot(tr_vec, # dot(a_sup, dot(MMR, p1-p2))) s1 = dot(tr_vec, dot(a_sup, dot(MMR, dot(b_sup, transpose(rho))))) s2 = dot(tr_vec, dot(b_sup, dot(MMR, dot(a_sup, transpose(rho))))) s = s1 - s2 #spectrum[idx] = return -2 * real(s[0, 0]) return spectrum
def test_general_stochastic(): "Stochastic: general_stochastic" "Reproduce smesolve homodyne" tol = 0.025 N = 4 gamma = 0.25 ntraj = 20 nsubsteps = 50 a = destroy(N) H = [[a.dag() * a, f]] psi0 = coherent(N, 0.5) sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5] e_ops = [a.dag() * a, a + a.dag(), (-1j) * (a - a.dag())] L = liouvillian(QobjEvo([[a.dag() * a, f]], args={"a": 2}), c_ops=sc_ops) L.compile() sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops] [op.compile() for op in sc_opsM] e_opsM = [spre(op) for op in e_ops] def d1(t, vec): return L.mul_vec(t, vec) def d2(t, vec): out = [] for op in sc_opsM: out.append(op.mul_vec(t, vec) - op.expect(t, vec) * vec) return np.stack(out) times = np.linspace(0, 0.5, 13) res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a": 2}) list_methods_tol = ['euler-maruyama', 'platen', 'explicit15'] for solver in list_methods_tol: res = general_stochastic(ket2dm(psi0), times, d1, d2, len_d2=2, e_ops=e_opsM, normalize=False, ntraj=ntraj, nsubsteps=nsubsteps, solver=solver) assert_( all([ np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol for idx in range(len(e_ops)) ])) assert_(len(res.measurement) == ntraj)
def test_cop_super_mult(): "BR Tools : cop_super_mult" dimension = 10 for _ in range(50): H = qutip.rand_herm(dimension, 0.5) basis = H.eigenstates()[1] a = qutip.destroy(dimension) L = qutip.liouvillian(None, [a.transform(basis)]) vec = np.ones((dimension * dimension, ), dtype=np.complex128) target = L.data.dot(vec) calculated = np.zeros_like(target) _eigenvalues = np.empty((dimension, ), dtype=np.float64) _cop_super_mult(a.full('F'), _test_zheevr(H.full('F'), _eigenvalues), vec, 1, calculated, dimension, qutip.settings.atol) np.testing.assert_allclose(target, calculated, atol=1e-12)
def liouvillian(H, c_ops): """Convert Hamiltonian and Lindblad operators into a Liouvillian. This is like :func:`qutip.superoperator.liouvillian`, but `H` may be a time-dependent Hamiltonian in nested-list format. `H` is assumed to contain a drift Hamiltonian, and the Lindblad operators in `c_ops` cannot be time-dependent. """ if isinstance(H, qutip.Qobj): return qutip.liouvillian(H, c_ops) elif isinstance(H, list): res = [] for spec in H: if isinstance(spec, qutip.Qobj): res.append(qutip.liouvillian(spec, c_ops)) c_ops = [] else: res.append([qutip.liouvillian(spec[0]), spec[1]]) assert len(c_ops) == 0, "No drift Hamiltonian" return res else: raise ValueError( "H must either be a Qobj, or a time-dependent Hamiltonian in " "nested-list format")
def test_graph_rcm_qutip(): "Graph: Reverse Cuthill-McKee Ordering (qutip)" kappa = 1 gamma = 0.01 g = 1 wc = w0 = wl = 0 N = 2 E = 1.5 a = tensor(destroy(N), qeye(2)) sm = tensor(qeye(N), sigmam()) H = (w0-wl)*sm.dag( )*sm+(wc-wl)*a.dag()*a+1j*g*(a.dag()*sm-sm.dag()*a)+E*(a.dag()+a) c_ops = [np.sqrt(2*kappa)*a, np.sqrt(gamma)*sm] L = liouvillian(H, c_ops) perm = reverse_cuthill_mckee(L.data) ans = np.array([12, 14, 4, 6, 10, 8, 2, 15, 0, 13, 7, 5, 9, 11, 1, 3]) assert_equal(perm, ans)
def test_general_stochastic(): "Stochastic: general_stochastic" "Reproduce smesolve homodyne" tol = 0.025 N = 4 gamma = 0.25 ntraj = 20 nsubsteps = 50 a = destroy(N) H = [[a.dag() * a,f]] psi0 = coherent(N, 0.5) sc_ops = [np.sqrt(gamma) * a, np.sqrt(gamma) * a * 0.5] e_ops = [a.dag() * a, a + a.dag(), (-1j)*(a - a.dag())] L = liouvillian(QobjEvo([[a.dag() * a,f]], args={"a":2}), c_ops = sc_ops) L.compile() sc_opsM = [QobjEvo(spre(op) + spost(op.dag())) for op in sc_ops] [op.compile() for op in sc_opsM] e_opsM = [spre(op) for op in e_ops] def d1(t, vec): return L.mul_vec(t,vec) def d2(t, vec): out = [] for op in sc_opsM: out.append(op.mul_vec(t,vec)-op.expect(t,vec)*vec) return np.stack(out) times = np.linspace(0, 0.5, 13) res_ref = mesolve(H, psi0, times, sc_ops, e_ops, args={"a":2}) list_methods_tol = ['euler-maruyama', 'platen', 'explicit15'] for solver in list_methods_tol: res = general_stochastic(ket2dm(psi0),times,d1,d2,len_d2=2, e_ops=e_opsM, normalize=False, ntraj=ntraj, nsubsteps=nsubsteps, solver=solver) assert_(all([np.mean(abs(res.expect[idx] - res_ref.expect[idx])) < tol for idx in range(len(e_ops))])) assert_(len(res.measurement) == ntraj)
def calculate_first_order_correction(self, cutoff_matrix_element, L0, **kwargs): """Calculates the first order correction to the steady-state density matrix due to drive term, and thereby calculating the corresponding relevance parameter returns: relevance parameter, Delta_{nm} @param cutoff_matrix_element: (float) @param **kwargs: (dictionary) of relevant drive term indices, usually n labels ket, m for bra @param L0: (QObj) the Liouvillian superoperator L_0 needed to solve for the correction, independent of indices so not needed to be re-evaluated every time this function is called """ n = kwargs['ket_index'] m = kwargs['bra_index'] if n >= m: return 0.0 evecs = self.evecs evals = self.evals # ignore drive terms whose matrix elements are beneath a specificied cutoff for speed-up. v_nm = (evecs[n].dag() * (self.v * evecs[m]))[0][0][0] if abs(v_nm) <= cutoff_matrix_element: return 0.0 k = self.integer_list rho_s_vectorform = np.reshape(self.density_matrix, (self.dim**2, 1), order='F') V_nm = (evecs[n] * evecs[m].dag() * (evecs[n].dag() * (self.v * evecs[m]))) L_nm = qt.liouvillian(V_nm) #b = np.dot(L_nm.full(),rho_0) b = (L_nm * rho_s_vectorform).data omega_of_k = (k[n] - k[m] + 1) * self.omega A = 1j * omega_of_k * qt.identity(self.dim**2).data - L0.data #A = A.full() #del_rho = la.lstsq(A,b,rcond = 1e-6)[0] if omega_of_k == 0: del_rho = la.lsmr(A, b)[0] else: del_rho = spsolve(A, b) return nla.norm(del_rho)
def test_br_term_mult(secular): "BR Tools : br_term_mult" dimension = 10 time = 1.0 atol = 1e-12 for _ in range(10): H = qutip.rand_herm(dimension, 0.5) basis = H.eigenstates()[1] L_diagonal = qutip.liouvillian(H.transform(basis)) evals = np.empty((dimension,), dtype=np.float64) evecs = _test_zheevr(H.full('F'), evals) operator = qutip.rand_herm(dimension, 0.5) a_ops = [[operator, lambda w: 1.0]] vec = np.ones((dimension*dimension,), dtype=np.complex128) br_tensor, _ = qutip.bloch_redfield_tensor(H, a_ops, use_secular=secular) target = (br_tensor - L_diagonal).data.dot(vec) calculated = np.zeros_like(target) _test_br_term_mult(time, operator.full('F'), evecs, evals, vec, calculated, secular, 0.1, atol) assert np.allclose(target, calculated)
def _spectrum_pi(H, wlist, c_ops, a_op, b_op, use_pinv=False): """ Internal function for calculating the spectrum of the correlation function :math:`\left<A(\\tau)B(0)\\right>`. """ #print issuper(H) L = H if issuper(H) else liouvillian(H, c_ops) tr_mat = tensor([qeye(n) for n in L.dims[0][0]]) N = prod(L.dims[0][0]) A = L.full() b = spre(b_op).full() a = spre(a_op).full() tr_vec = transpose(mat2vec(tr_mat.full())) rho_ss = steadystate(L) rho = transpose(mat2vec(rho_ss.full())) I = identity(N * N) P = kron(transpose(rho), tr_vec) Q = I - P spectrum = zeros(len(wlist)) for idx, w in enumerate(wlist): if use_pinv: MMR = pinv(-1.0j * w * I + A) else: MMR = dot(Q, solve(-1.0j * w * I + A, Q)) s = dot(tr_vec, dot(a, dot(MMR, dot(b, transpose(rho))))) spectrum[idx] = -2 * real(s[0, 0]) return spectrum
def _run_solver() -> CoherentResults: """Returns CoherentResults: Object containing evolution results.""" # Decide if progress bar will be fed to QuTiP solver p_bar: Optional[bool] if progress_bar is True: p_bar = True elif (progress_bar is False) or (progress_bar is None): p_bar = None else: raise ValueError("`progress_bar` must be a bool.") if "dephasing" in self.config.noise: # temporary workaround due to a qutip bug when using mesolve liouvillian = qutip.liouvillian(self._hamiltonian, self._collapse_ops) result = qutip.mesolve( liouvillian, self.initial_state, self._eval_times_array, progress_bar=p_bar, options=solv_ops, ) else: result = qutip.sesolve( self._hamiltonian, self.initial_state, self._eval_times_array, progress_bar=p_bar, options=solv_ops, ) return CoherentResults( result.states, self._size, self.basis_name, self._eval_times_array, self._meas_basis, meas_errors, )
def test_pure_dephasing_model_drude_lorentz_baths(self, terminator, bath_cls, atol=1e-3): dlm = DrudeLorentzPureDephasingModel( lam=0.025, gamma=0.05, T=1 / 0.95, Nk=2, ) bath = bath_cls( Q=dlm.Q, lam=dlm.lam, gamma=dlm.gamma, T=dlm.T, Nk=dlm.Nk, ) if terminator: _, terminator_op = bath.terminator() H_sys = liouvillian(dlm.H) + terminator_op else: H_sys = dlm.H options = Options(nsteps=15000, store_states=True) hsolver = HEOMSolver(H_sys, bath, 14, options=options) tlist = np.linspace(0, 10, 21) result = hsolver.run(dlm.rho(), tlist) test = dlm.state_results(result.states) expected = dlm.analytic_results(tlist) np.testing.assert_allclose(test, expected, atol=atol) rho_final, ado_state = hsolver.steady_state() test = dlm.state_results([rho_final]) expected = dlm.analytic_results([100]) np.testing.assert_allclose(test, expected, atol=atol) assert rho_final == ado_state.extract(0)
def _generator(k, H, L1, L2, S=None, c_ops_markov=None): """ Create a Liouvillian for a cascaded chain of k system copies """ id = qt.qeye(H.dims[0][0]) Id = qt.sprepost(id, id) if S is None: S = np.identity(len(L1)) # create Lindbladian L = qt.Qobj() E0 = Id # first system L += qt.liouvillian(None, [_localop(c, 1, k) for c in L2]) for l in range(1, k): # Identiy superoperator E0 = qt.composite(E0, Id) # Bare Hamiltonian Hl = _localop(H, l, k) L += qt.liouvillian(Hl, []) # Markovian Decay channels if c_ops_markov is not None: for c in c_ops_markov: cl = _localop(c, l, k) L += qt.liouvillian(None, [cl]) # Cascade coupling c1 = np.array([_localop(c, l, k) for c in L1]) c2 = np.array([_localop(c, l+1, k) for c in L2]) c2dag = np.array([c.dag() for c in c2]) Hcasc = -0.5j*np.dot(c2dag, np.dot(S, c1)) Hcasc += Hcasc.dag() Lvec = c2 + np.dot(S, c1) L += qt.liouvillian(Hcasc, [c for c in Lvec]) # last system L += qt.liouvillian(_localop(H, k, k), [_localop(c, k, k) for c in L1]) if c_ops_markov is not None: for c in c_ops_markov: cl = _localop(c, k, k) L += qt.liouvillian(None, [cl]) E0.dims = L.dims # return generator and identity superop E0 return L, E0
def two_tone(vg): phi, wd=vg Ej = Ejmax*absolute(cos(pi*phi))#(phi**2)/(8*Ec) # #; % Josephson energy as function of Phi. wTvec = -Ej + sqrt(8.0*Ej*Ec)*(nvec+0.5)+Ecvec wdvec=nvec*wd wT = wTvec-wdvec transmon_levels = Qobj(diag(wT[range(N)])) for Om in Omega_op: H = transmon_levels + Om exp1=spectrum(H, wlist2, c_op_list, a, p, solver="pi", use_pinv=False) exp2=spectrum(H, wlist2, c_op_list, p, a, solver="pi", use_pinv=False) return exp1-exp2 #H_comm = -1j*(kron(It,H) - kron(transpose(H),It)); #L = H_comm + Lindblad_tm + Lindblad_tp #+ Lindblad_deph; #print L #L2 = [reshape(eye(N),1,N**2); L]; %Add the condition trace(rho) = 1 #rho_ss = L2\[1;zeros(dim^2,1)]; % Steady state density matrix #rho_ss_c = rho_ss; %Column vector form L = liouvillian(H, c_op_list) #D, V=L.eigenstates() #print "D", D.shape #print "V", V.shape #print L.diag() #print L.diag().shape #raise Exception A = L.full() rho_ss = steadystate(L) rho = transpose(mat2vec(rho_ss.full())) P = kron(transpose(rho), tr_vec) Q = I - P if 1: w=wp-wd #MMR = pinv(-1.0j * w * I + A) MMR = dot(Q, solve(-1.0j * w * I + A, Q)) #Lexp=L.expm() #MMR=Lexp*MMR*Lexp.dag() # MMR = np.dot(Q, np.linalg.solve(-1.0j * w * I + A, Q)) #print p_l.shape #print p_l #print transpose(rho).shape #print dot(p_l.full(), transpose(rho)) s = dot(tr_vec, dot(tm_l, dot(MMR, dot(p_l_m_p_r, transpose(rho))))) return -2 * real(s[0, 0]) D,U = eig(L.full()) Uinv = inv(U) Dint = diag(1.0/(1.0j*(wp-wd)*Idiag + diag(D))) Lint = U*Dint*Uinv #H_comm = -1.0j*(kron(It,H) - kron(transpose(H),It)) #print H #print H.shape, H.full().shape #print H_comm, H_comm.shape #L = H_comm + Lindblad_tm + Lindblad_tp + Lindblad_deph #p_l=spre(p) #p_r=spost(p) #tm_l=spre(a) #print L.shape, A.shape, #print dir(L) #print L.eigenenergies().shape #print L.eigenstates()#.shape #L2 = [reshape(eye(dim),1,dim^2);L]; %Add the condition trace(rho) = 1 #rho_ss = L2\[1;zeros(dim^2,1)]; % Steady state density matrix #rho_ss_c = rho_ss; %Column vector form #print "tm_l", tm_l.full().shape #print "Lint", Lint.shape #print "pl", p_l.full().shape #print "pr", p_r.full().shape #print rho.shape, to_super(rho_ss).full().shape #print "rho", to_super(rho_ss) #rho_ss.full().shape #rho.shape #print (tm_l.full()*Lint*(p_l.full() - p_r.full())*rho).shape #raise Exception return 1j*trace(tm_l*Lint*(p_l_m_p_r)*rho_ss)
def hsolve(H, psi0, tlist, Q, gam, lam0, Nc, N, w_th, options=None): """ Function to solve for an open quantum system using the hierarchy model. Parameters ---------- H: Qobj The system hamiltonian. psi0: Qobj Initial state of the system. tlist: List. Time over which system evolves. Q: Qobj The coupling between system and bath. gam: Float Bath cutoff frequency. lam0: Float Coupling strength. Nc: Integer Cutoff parameter. N: Integer Number of matsubara terms. w_th: Float Temperature. options : :class:`qutip.Options` With options for the solver. Returns ------- output: Result System evolution. """ if options is None: options = Options() # Set up terms of the matsubara and tanimura boundaries # Parameters and hamiltonian hbar = 1. kb = 1. # Set by system dimensions = dims(H) Nsup = dimensions[0][0] * dimensions[0][0] unit = qeye(dimensions[0]) # Ntot is the total number of ancillary elements in the hierarchy Ntot = int(round(factorial(Nc+N) / (factorial(Nc) * factorial(N)))) c0 = (lam0 * gam * (_cot(gam * hbar / (2. * kb * w_th)) - (1j))) / hbar LD1 = (-2. * spre(Q) * spost(Q.dag()) + spre(Q.dag()*Q) + spost(Q.dag()*Q)) pref = ((2. * lam0 * kb * w_th / (gam * hbar)) - 1j * lam0) / hbar gj = 2 * np.pi * kb * w_th / hbar L12 = -pref * LD1 + (c0 / gam) * LD1 for i1 in range(1, N): num = (4 * lam0 * gam * kb * w_th * i1 * gj/((i1 * gj)**2 - gam**2)) ci = num / (hbar**2) L12 = L12 + (ci / gj) * LD1 # Setup liouvillian L = liouvillian(H, [L12]) Ltot = L.data unit = sp.eye(Ntot,format='csr') Lbig = sp.kron(unit, Ltot) rho0big1 = np.zeros((Nsup * Ntot), dtype=complex) # Prepare initial state: rhotemp = mat2vec(np.array(psi0.full(), dtype=complex)) for idx, element in enumerate(rhotemp): rho0big1[idx] = element[0] nstates, state2idx, idx2state = enr_state_dictionaries([Nc+1]*(N), Nc) for nlabelt in state_number_enumerate([Nc+1]*(N), Nc): nlabel = list(nlabelt) ntotalcheck = 0 for ncheck in range(N): ntotalcheck = ntotalcheck + nlabel[ncheck] current_pos = int(round(state2idx[tuple(nlabel)])) Ltemp = sp.lil_matrix((Ntot, Ntot)) Ltemp[current_pos, current_pos] = 1 Ltemp.tocsr() Lbig = Lbig + sp.kron(Ltemp, (-nlabel[0] * gam * spre(unit).data)) for kcount in range(1, N): counts = -nlabel[kcount] * kcount * gj * spre(unit).data Lbig = Lbig + sp.kron(Ltemp, counts) for kcount in range(N): if nlabel[kcount] >= 1: # find the position of the neighbour nlabeltemp = copy(nlabel) nlabel[kcount] = nlabel[kcount] - 1 current_pos2 = int(round(state2idx[tuple(nlabel)])) Ltemp = sp.lil_matrix((Ntot, Ntot)) Ltemp[current_pos, current_pos2] = 1 Ltemp.tocsr() # renormalized version: ci = (4 * lam0 * gam * kb * w_th * kcount * gj/((kcount * gj)**2 - gam**2)) / (hbar**2) if kcount == 0: Lbig = Lbig + sp.kron(Ltemp, (-1j * (np.sqrt(nlabeltemp[kcount] / abs(c0))) * ((c0) * spre(Q).data - (np.conj(c0)) * spost(Q).data))) if kcount > 0: ci = (4 * lam0 * gam * kb * w_th * kcount * gj/((kcount * gj)**2 - gam**2)) / (hbar**2) Lbig = Lbig + sp.kron(Ltemp, (-1j * (np.sqrt(nlabeltemp[kcount] / abs(ci))) * ((ci) * spre(Q).data - (np.conj(ci)) * spost(Q).data))) nlabel = copy(nlabeltemp) for kcount in range(N): if ntotalcheck <= (Nc-1): nlabeltemp = copy(nlabel) nlabel[kcount] = nlabel[kcount] + 1 current_pos3 = int(round(state2idx[tuple(nlabel)])) if current_pos3 <= (Ntot): Ltemp = sp.lil_matrix((Ntot, Ntot)) Ltemp[current_pos, current_pos3] = 1 Ltemp.tocsr() # renormalized if kcount == 0: Lbig = Lbig + sp.kron(Ltemp, -1j * (np.sqrt((nlabeltemp[kcount]+1) * abs(c0))) * (spre(Q) - spost(Q)).data) if kcount > 0: ci = (4 * lam0 * gam * kb * w_th * kcount * gj/((kcount * gj)**2 - gam**2)) / (hbar**2) Lbig = Lbig + sp.kron(Ltemp, -1j * (np.sqrt((nlabeltemp[kcount]+1) * abs(ci))) * (spre(Q) - spost(Q)).data) nlabel = copy(nlabeltemp) output = [] for element in rhotemp: output.append([]) r = scipy.integrate.ode(cy_ode_rhs) Lbig2 = Lbig.tocsr() r.set_f_params(Lbig2.data, Lbig2.indices, Lbig2.indptr) r.set_integrator('zvode', method=options.method, order=options.order, atol=options.atol, rtol=options.rtol, nsteps=options.nsteps, first_step=options.first_step, min_step=options.min_step, max_step=options.max_step) r.set_initial_value(rho0big1, tlist[0]) dt = tlist[1] - tlist[0] for t_idx, t in enumerate(tlist): r.integrate(r.t + dt) for idx, element in enumerate(rhotemp): output[idx].append(r.y[idx]) return output
print transmon_levels #Omega_vec=- 0.5j*(Omega*adag - conj(Omega)*a) theta=0.0 Omega_vec= 0.5*Omega*(a*exp(-1j*theta)+adag*exp(1j*theta)) print Omega_vec H=transmon_levels +Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a) print H #Ht = H.data.T #from qutip.cy.spmath import zcsr_kron #from qutip.fastsparse import fast_csr_matrix, fast_identity #spI=fast_identity(N) #data = -1j * zcsr_kron(spI, H.data) #data += 1j * zcsr_kron(Ht, spI) #print data.toarray() L=liouvillian(H, c_op_list) #ends at same thing as L = H_comm + Lindblad_tm ; #print L #print dir(L) rho_ss = steadystate(L) #same as rho_ss_c but that's in column vector form print rho_ss wlist = linspace(-500.0, 500.0, 201) use_pinv=True tr_mat = tensor([qeye(n) for n in L.dims[0][0]]) N = prod(L.dims[0][0]) A = L.full() D, U= L.eigenstates()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Aug 1 07:15:05 2018 @author: huang """ import qutip as qt import numpy as np H = 10 * qt.sigmaz() c1 = qt.destroy(2) L = qt.liouvillian(H, [c1]) print(L) S = (12 * L).expm() print("S: ", S)
if 0: value_grid = array(meshgrid(phi_arr, Omega_sim_vec)) vg = zip(value_grid[0, :, :].flatten(), value_grid[1, :, :].flatten()) fexpt = parallel_map(find_expect, vg, progress_bar=True) fexpt = reshape(fexpt, (31, 101)) pcolormesh(phi_arr, sample_power_sim_dBm, absolute(fexpt), cmap="RdBu_r") show() #w01_vec(i) = wT_vec(2)- wT_vec(1); % Transition energies. #w12_vec(i) = wT_vec(3)- wT_vec(2); #w23_vec(i) = wT_vec(4)- wT_vec(3); #w34_vec(i) = wT_vec(5)- wT_vec(4); H = make_H(0.2, 190, 4000.0) print H L = liouvillian(H, c_op_list) print L tr_mat = tensor([qeye(n) for n in L.dims[0][0]]) print tr_mat tr_vec = transpose(mat2vec(tr_mat.full())) print tr_vec N = prod(L.dims[0][0]) print N A = L.full() a_sup = spre(a).full() b_sup = spre(p).full() D, U = eig(A) print "D", D I = identity(N * N)
def simulate_quantities_of_interest_superoperator(H_0, tlist, c_ops, eps_vec, sim_step, verbose: bool = True): """ Calculates the quantities of interest from the propagator U Args: H_0 (Qobj): static hamiltonian, see "coupled_transmons_hamiltonian" for the expected form of the Hamiltonian. tlist (array): times in s, describes the x component of the trajectory to simulate c-ops (list of Qobj): list of jump operators, time-independent at the momennt eps_vec(array): detuning describes the y-component of the trajectory to simulate. Returns phi_cond (float): conditional phase (deg) L1 (float): leakage L2 (float): seepage avgatefid (float): average gate fidelity in full space avgatefid_compsubspace (float): average gate fidelity only in the computational subspace """ scalefactor = 1e6 # otherwise qtp.propagator in parallel mode doesn't work # time is multiplied by scalefactor and frequency is divided by it tlist = tlist * scalefactor eps_vec = eps_vec / scalefactor sim_step = sim_step * scalefactor H_0 = H_0 / scalefactor if c_ops != []: # c_ops is a list of either operators or lists where the first element is # an operator and the second one is a list of the (time-dependent) coefficients for c in range(len(c_ops)): if isinstance(c_ops[c], list): c_ops[c][1] = c_ops[c][1] / np.sqrt(scalefactor) else: c_ops[c] = c_ops[c] / np.sqrt(scalefactor) H_c = n_q0 ''' # step of 1/sampling_rate=1/2.4e9=0.4 ns seems good by itself sim_step_new=sim_step*2 eps_interp = interp1d(tlist, eps_vec, fill_value='extrapolate') tlist_new = (np.linspace(0, np.max(tlist), 576/2)) eps_vec_new=eps_interp(tlist_new) c_ops_new=[] for c in range(len(c_ops)): if isinstance(c_ops[c],list): c_ops_interp=interp1d(tlist,c_ops[c][1], fill_value='extrapolate') c_ops_new.append([c_ops[c][0],c_ops_interp(tlist_new)]) else: c_ops_new.append(c_ops[c]) # function only exists to wrap #def eps_t(t, args=None): # return eps_interp(t) print(len(eps_vec),len(eps_vec_new)) t0 = time.time() exp_L_total_new=1 for i in range(len(tlist_new)): H=H_0+eps_vec_new[i]*H_c c_ops_temp=[] for c in range(len(c_ops_new)): if isinstance(c_ops_new[c],list): c_ops_temp.append(c_ops_new[c][0]*c_ops_new[c][1][i]) else: c_ops_temp.append(c_ops_new[c]) liouville_exp_t=(qtp.liouvillian(H,c_ops_temp)*sim_step_new).expm() exp_L_total_new=liouville_exp_t*exp_L_total_new #exp_L_oneway=(qtp.liouvillian(H_0,c_ops)*240e-3).expm() t1 = time.time() print('\n alternative propagator_new',t1-t0) ''' t0 = time.time() exp_L_total = 1 for i in range(len(tlist)): H = H_0 + eps_vec[i] * H_c c_ops_temp = [] for c in range(len(c_ops)): if isinstance(c_ops[c], list): c_ops_temp.append(c_ops[c][0] * c_ops[c][1][i]) else: c_ops_temp.append(c_ops[c]) liouville_exp_t = (qtp.liouvillian(H, c_ops_temp) * sim_step).expm() exp_L_total = liouville_exp_t * exp_L_total #exp_L_oneway=(qtp.liouvillian(H_0,c_ops)*240e-3).expm() t1 = time.time() print('\n alternative propagator', t1 - t0) ''' # qutip propagator not used anymore because it takes too much time t0 = time.time() if c_ops==[]: nstepsmax=1000 else: nstepsmax=100000 H_t = [H_0, [H_c, eps_vec]] U_t = qtp.propagator(H_t, tlist, c_ops, parallel=True, options=qtp.Options(nsteps=nstepsmax)) # returns unitary 'oper' if c_ops=[], otherwise 'super' t1 = time.time() print('/n propagator',t1-t0) if verbose: print('simulation took {:.2f}s'.format(t1-t0)) ''' U_final = exp_L_total phases = phases_from_superoperator(U_final) phi_cond = phases[-1] L1 = leakage_from_superoperator(U_final) L2 = seepage_from_superoperator(U_final) avgatefid = pro_avfid_superoperator_phasecorrected(U_final, phases) avgatefid_compsubspace = pro_avfid_superoperator_compsubspace_phasecorrected( U_final, L1, phases) # leakage has to be taken into account, see Woods & Gambetta print('avgatefid_compsubspace', avgatefid_compsubspace) ''' U_final = exp_L_total_new phases2 = phases_from_superoperator(U_final) phi_cond2 = phases2[-1] L12 = leakage_from_superoperator(U_final) L22 = seepage_from_superoperator(U_final) avgatefid2 = pro_avfid_superoperator_phasecorrected(U_final,phases2) avgatefid_compsubspace2 = pro_avfid_superoperator_compsubspace_phasecorrected(U_final,L12,phases2) print(phi_cond-phi_cond2,phi_cond) print(L1-L12,L1) print(L2-L22,L2) print(avgatefid-avgatefid2,avgatefid) print(avgatefid_compsubspace-avgatefid_compsubspace2,avgatefid_compsubspace) ''' return { 'phi_cond': phi_cond, 'L1': L1, 'L2': L2, 'avgatefid_pc': avgatefid, 'avgatefid_compsubspace_pc': avgatefid_compsubspace }
def find_expect(phi=0.1, Omega_vec=3.0, wd=wd, use_pinv=True): Ej = (phi**2)/(8*Ec) #Ejmax*absolute(cos(pi*phi)) #; % Josephson energy as function of Phi. wTvec = -Ej + sqrt(8.0*Ej*Ec)*(nvec+0.5)+Ecvec #wdvec=nvec*sqrt(8.0*Ej*Ec) #wdvec=nvec*wd wT = wTvec-wdvec transmon_levels = Qobj(diag(wT[range(N)])) H=transmon_levels +Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a) L=liouvillian(H, c_op_list) #ends at same thing as L = H_comm + Lindblad_tm ; rho_ss = steadystate(L) #same as rho_ss_c but that's in column vector form tr_mat = tensor([qeye(n) for n in L.dims[0][0]]) #N = prod(L.dims[0][0]) A = L.full() #D, U= L.eigenstates() #print D.shape, D #print diag(D) b = spre(p).full()-spost(p).full() a2 = spre(a).full() tr_vec = transpose(mat2vec(tr_mat.full())) rho = transpose(mat2vec(rho_ss.full())) I = identity(N * N) P = kron(transpose(rho), tr_vec) Q = I - P #wp=4.9 #w=-(wp-wd) spectrum = zeros(len(wlist2), dtype=complex) for idx, w in enumerate(wlist2): if use_pinv: MMR = pinv(-1.0j * w * I + A) #eig(MMR)[0] is equiv to Dint else: MMR = dot(Q, solve(-1.0j * w * I + A, Q)) #print diag(1.0/(1j*(wp-wd)*ones(N**2)+D)) #Dint = diag(1./(1i*(wp-wd)*diag(eye(dim^2)) + diag(D))) #print 1.0/(1j*(wp-wd)*ones(N**2)+D) #Dint = diag(1./(1i*(wp-wd)*diag(eye(dim^2)) + diag(D))) #U2=squeeze([u.full() for u in U]).transpose() #Dint=eig(MMR)[0] #print "MMR", eig(MMR)[1] #print "Umult", U2*Dint*inv(U2) s = dot(tr_vec, dot(a2, dot(MMR, dot(b, transpose(rho))))) #spectrum[idx] = -2 * real(s[0, 0]) spectrum[idx]=1j*s[0][0] #matches Chi_temp result #(1/theta_steps) return spectrum #final_state = steadystate(H, c_op_list) #print H.shape #print dir(H) #U,D = eig(H.full()) #print D #Uinv = Qobj(inv(D)) #U=Qobj(D) # Doing the chi integral (gives the susceptibility) #Dint = 1.0/(1.0j*(wp-wd)) #Qobj(1.0/(1.0j*(wp-wd)*diag(qeye(N**2))))# + diag(D)))) #Hint = H.expm() #U*H*Uinv #Chi_temp(i,j) += (1.0/theta_steps)*1j*trace(reshape(tm_l*Lint*(p_l - p_r)*rho_ss_c,dim,dim)) #exp1=correlation_2op_1t(H, None, wlist2, c_op_list, a, p, solver="es") #exp2=correlation_2op_1t(H, None, wlist2, c_op_list, p, a, solver="es", reverse=True) #exp1=correlation_2op_1t(H, None, wlist2, c_op_list, a, p_l-p_r, solver="es") #exp1=correlation_ss(H, wlist2, c_op_list, a, p) #exp2=correlation_ss(H, wlist2, c_op_list, p, a, reverse=True) exp1=spectrum(H, wlist2, c_op_list, a, p, solver="pi", use_pinv=False) exp2=spectrum(H, wlist2, c_op_list, p, a, solver="pi", use_pinv=False) return exp1-exp2 return expect( a, final_state) #tm_l
def find_expect(phi=0.1, Omega_vec=3.0, wd=wd, use_pinv=True): Ej = (phi**2) / ( 8 * Ec ) #Ejmax*absolute(cos(pi*phi)) #; % Josephson energy as function of Phi. wTvec = -Ej + sqrt(8.0 * Ej * Ec) * (nvec + 0.5) + Ecvec #wdvec=nvec*sqrt(8.0*Ej*Ec) #wdvec=nvec*wd wT = wTvec - wdvec transmon_levels = Qobj(diag(wT[range(N)])) H = transmon_levels + Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a) L = liouvillian( H, c_op_list) #ends at same thing as L = H_comm + Lindblad_tm ; rho_ss = steadystate(L) #same as rho_ss_c but that's in column vector form tr_mat = tensor([qeye(n) for n in L.dims[0][0]]) #N = prod(L.dims[0][0]) A = L.full() #D, U= L.eigenstates() #print D.shape, D #print diag(D) b = spre(p).full() - spost(p).full() a2 = spre(a).full() tr_vec = transpose(mat2vec(tr_mat.full())) rho = transpose(mat2vec(rho_ss.full())) I = identity(N * N) P = kron(transpose(rho), tr_vec) Q = I - P #wp=4.9 #w=-(wp-wd) spectrum = zeros(len(wlist2), dtype=complex) for idx, w in enumerate(wlist2): if use_pinv: MMR = pinv(-1.0j * w * I + A) #eig(MMR)[0] is equiv to Dint else: MMR = dot(Q, solve(-1.0j * w * I + A, Q)) #print diag(1.0/(1j*(wp-wd)*ones(N**2)+D)) #Dint = diag(1./(1i*(wp-wd)*diag(eye(dim^2)) + diag(D))) #print 1.0/(1j*(wp-wd)*ones(N**2)+D) #Dint = diag(1./(1i*(wp-wd)*diag(eye(dim^2)) + diag(D))) #U2=squeeze([u.full() for u in U]).transpose() #Dint=eig(MMR)[0] #print "MMR", eig(MMR)[1] #print "Umult", U2*Dint*inv(U2) s = dot(tr_vec, dot(a2, dot(MMR, dot(b, transpose(rho))))) #spectrum[idx] = -2 * real(s[0, 0]) spectrum[idx] = 1j * s[0][0] #matches Chi_temp result #(1/theta_steps) return spectrum #final_state = steadystate(H, c_op_list) #print H.shape #print dir(H) #U,D = eig(H.full()) #print D #Uinv = Qobj(inv(D)) #U=Qobj(D) # Doing the chi integral (gives the susceptibility) #Dint = 1.0/(1.0j*(wp-wd)) #Qobj(1.0/(1.0j*(wp-wd)*diag(qeye(N**2))))# + diag(D)))) #Hint = H.expm() #U*H*Uinv #Chi_temp(i,j) += (1.0/theta_steps)*1j*trace(reshape(tm_l*Lint*(p_l - p_r)*rho_ss_c,dim,dim)) #exp1=correlation_2op_1t(H, None, wlist2, c_op_list, a, p, solver="es") #exp2=correlation_2op_1t(H, None, wlist2, c_op_list, p, a, solver="es", reverse=True) #exp1=correlation_2op_1t(H, None, wlist2, c_op_list, a, p_l-p_r, solver="es") #exp1=correlation_ss(H, wlist2, c_op_list, a, p) #exp2=correlation_ss(H, wlist2, c_op_list, p, a, reverse=True) exp1 = spectrum(H, wlist2, c_op_list, a, p, solver="pi", use_pinv=False) exp2 = spectrum(H, wlist2, c_op_list, p, a, solver="pi", use_pinv=False) return exp1 - exp2 return expect(a, final_state) #tm_l
def Liouvillian_func(t, args): c = np.sqrt(kappa * np.exp(-t)) * a data = liouvillian(H, [c]).data return data