def test_bad_system():
N = 4
a = qutip.destroy(N)
H = (a.dag() + a)
with pytest.raises(TypeError):
qutip.steadystate(H, [], method='direct')
with pytest.raises(TypeError):
qutip.steadystate(qutip.basis(N, N - 1), [], method='direct')
def test_bad_options_steadystate():
N = 4
a = qutip.destroy(N)
H = (a.dag() + a)
c_ops = [a]
with pytest.raises(ValueError):
rho_ss = qutip.steadystate(H, c_ops, method='not a method')
with pytest.raises(TypeError):
rho_ss = qutip.steadystate(H, c_ops, method='direct', bad_opt=True)
with pytest.raises(ValueError):
rho_ss = qutip.steadystate(H, c_ops, method='direct', solver='Error')
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_qubit_power_gmres():
"Steady state: Thermal qubit - power-gmres solver"
# thermal steadystate of a qubit: compare numerics with analytical formula
sz = sigmaz()
sm = destroy(2)
H = 0.5 * 2 * np.pi * sz
gamma1 = 0.05
wth_vec = np.linspace(0.1, 3, 20)
p_ss = np.zeros(np.shape(wth_vec))
for idx, wth in enumerate(wth_vec):
n_th = 1.0 / (np.exp(1.0 / wth) - 1) # bath temperature
c_op_list = []
rate = gamma1 * (1 + n_th)
c_op_list.append(np.sqrt(rate) * sm)
rate = gamma1 * n_th
c_op_list.append(np.sqrt(rate) * sm.dag())
rho_ss = steadystate(H, c_op_list, method='power-gmres', mtol=1e-1)
p_ss[idx] = expect(sm.dag() * sm, rho_ss)
p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
delta = sum(abs(p_ss_analytic - p_ss))
assert_equal(delta < 1e-5, True)
def __init__(self, hamiltonian, jump_operators, drive_hamiltonian,
angular_frequency):
if isinstance(hamiltonian, qt.Qobj) and isinstance(
drive_hamiltonian, qt.Qobj):
self.hamiltonian = hamiltonian
self.v = drive_hamiltonian
else:
raise TypeError(
"The system Hamiltonian and drive Hamiltonian must both be a quantum object"
)
self.dim = self.hamiltonian.shape[0]
self.omega = angular_frequency
self.evals, self.evecs = self.hamiltonian.eigenstates()
self.jump_ops = jump_operators
# This initial steady-state is the thermal equilibrium state (bootstrapping)
self.rho_s = qt.steadystate(self.hamiltonian, self.jump_ops)
self.density_matrix = [[
(self.evecs[a].dag() * self.rho_s * self.evecs[b])[0]
for b in range(self.dim)
] for a in range(self.dim)]
self.density_matrix = np.asarray(self.density_matrix)
self.integer_list = [0 for k in range(self.dim)]
self.drive_term_list = []
self.rotating_frame_hamiltonian = self.hamiltonian
def find_expect(self, vg, pwr, fd):
if self.power_plot:
phi, pwr=vg
else:
phi, fd=vg
pwr_fridge=pwr-self.atten
lin_pwr=0.001*10**(pwr_fridge/10.0)
Omega=sqrt(lin_pwr/h*2.0)
gamma, Delta=self._get_GammaDelta(fd=fd, f0=self.f0, Np=self.Np, gamma=self.gamma)
g_el=self._get_Gamma_C(fd=fd)
wTvec=self._get_fTvec(phi=phi, gamma=gamma, Delta=Delta, fd=fd, Psaw=lin_pwr)
if self.acoustic_plot:
Om=Omega*sqrt(gamma/fd)
else:
Om=Omega*sqrt(g_el/fd)
wT = wTvec-fd*self.nvec #rotating frame of gate drive \omega_m-m*\omega_\gate
transmon_levels = Qobj(diag(wT[range(self.N_dim)]))
rate1 = (gamma+g_el)*(1.0 + self.N_gamma)
rate2 = (gamma+g_el)*self.N_gamma
c_ops=[sqrt(rate1)*self.a_op, sqrt(rate2)*self.a_dag]#, sqrt(rate3)*self.a_op, sqrt(rate4)*self.a_dag]
Omega_vec=-0.5j*(Om*self.a_dag - conj(Om)*self.a_op)
H=transmon_levels +Omega_vec
final_state = steadystate(H, c_ops) #solve master equation
fexpt=expect(self.a_op, final_state) #expectation value of relaxation operator
#return fexpt
if self.acoustic_plot:
return 1.0*gamma/Om*fexpt
else:
return 1.0*sqrt(g_el*gamma)/Om*fexpt
def test_correlation_2op_1t_known_cases(solver,
state,
is_e_op_hermitian,
w,
gamma,
):
"""This test compares the output correlation_2op_1 solution to an analytical
solution."""
a = qutip.destroy(_equivalence_dimension)
x = (a + a.dag())/np.sqrt(2)
H = w * a.dag() * a
a_op = x if is_e_op_hermitian else a
b_op = x if is_e_op_hermitian else a.dag()
c_ops = [np.sqrt(gamma) * a]
times = np.linspace(0, 1, 30)
# Handle the case state==None when computing expt values
rho0 = state if state else qutip.steadystate(H, c_ops)
if is_e_op_hermitian:
# Analitycal solution for x,x as operators.
base = 0
base += qutip.expect(a*x, rho0)*np.exp(-1j*w*times - gamma*times/2)
base += qutip.expect(a.dag()*x, rho0)*np.exp(1j*w*times - gamma*times/2)
base /= np.sqrt(2)
else:
# Analitycal solution for a,adag as operators.
base = qutip.expect(a*a.dag(), rho0)*np.exp(-1j*w*times - gamma*times/2)
cmp = qutip.correlation_2op_1t(H, state, times, c_ops, a_op, b_op, solver=solver)
np.testing.assert_allclose(base, cmp, atol=0.25 if solver == 'mc' else 2e-5)
def self_correlation(experiment, stop_time, steps=500, field='probe'):
"""Returns the self correlation of one of the cavity fields
:param experiment: The experiment on which the scan is performed
:type experiment: ntypecqed.simulation.NTypeExperiment
:param stop_time: Stop time of the correlation
:type stop_time: float
:param steps: Number of steps
:type steps: int
:param field: The field for which the self correlation is calculated, either 'probe' or 'signal'
:type field: str
:return: tuple(times, correlation value)
"""
if field == 'probe':
operator = experiment.environment.a
elif field == 'signal':
operator = experiment.environment.b
else:
raise (ValueError,
"No valid field name, valid fields are: 'probe' or 'signal'")
tau_list = np.linspace(0, stop_time, steps)
ss = steadystate(experiment.driven_hamiltonian,
experiment.environment.c_ops)
n = expect(operator.dag() * operator, ss)
corr_data = correlation_3op_1t(experiment.driven_hamiltonian, ss,
tau_list, experiment.environment.c_ops,
operator.dag(),
operator.dag() * operator, operator)
corr_data /= (n * n)
return tau_list, corr_data
def triple_coincidences(experiment, trigger_photon='probe', normed=True):
"""Returns the value of the triggered two photon self correlation at time 0
:param experiment: The experiment on which the scan is performed
:type experiment: ntypecqed.simulation.NTypeExperiment
:param trigger_photon: The photon which starts the self correlation, either 'probe' or 'signal'
:type trigger_photon: str
:param normed: Normalize to the power level
:type normed: bool
:return: correlation value
"""
if trigger_photon == 'probe':
trig_op = experiment.environment.a
self_op = experiment.environment.b
elif trigger_photon == 'signal':
trig_op = experiment.environment.b
self_op = experiment.environment.a
else:
raise (
ValueError,
"No valid trigger photon name, valid names are: 'probe' or 'signal'"
)
ss = steadystate(experiment.driven_hamiltonian,
experiment.environment.c_ops)
n_a, n_b = expect(experiment.environment.n_a,
ss), expect(experiment.environment.n_b, ss)
expectation_operator = trig_op.dag() * self_op.dag() * self_op.dag(
) * self_op * self_op * trig_op
corr_data = expect(expectation_operator, ss)
if normed:
if trigger_photon == 'probe':
corr_data /= (n_a * n_b * n_b)
else:
corr_data /= (n_b * n_a * n_a)
return corr_data
def test_ho_bicgstab():
"Steady state: Thermal HO - iterative-bicgstab solver"
# thermal steadystate of an oscillator: compare numerics with analytical
# formula
a = destroy(40)
H = 0.5 * 2 * np.pi * a.dag() * a
gamma1 = 0.05
wth_vec = np.linspace(0.1, 3, 20)
p_ss = np.zeros(np.shape(wth_vec))
for idx, wth in enumerate(wth_vec):
n_th = 1.0 / (np.exp(1.0 / wth) - 1) # bath temperature
c_op_list = []
rate = gamma1 * (1 + n_th)
c_op_list.append(np.sqrt(rate) * a)
rate = gamma1 * n_th
c_op_list.append(np.sqrt(rate) * a.dag())
rho_ss = steadystate(H, c_op_list, method='iterative-bicgstab')
p_ss[idx] = np.real(expect(a.dag() * a, rho_ss))
p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
delta = sum(abs(p_ss_analytic - p_ss))
assert_equal(delta < 1e-3, True)
def test_qubit(method, kwargs):
# thermal steadystate of a qubit: compare numerics with analytical formula
sz = qutip.sigmaz()
sm = qutip.destroy(2)
H = 0.5 * 2 * np.pi * sz
gamma1 = 0.05
wth_vec = np.linspace(0.1, 3, 20)
p_ss = np.zeros(np.shape(wth_vec))
with warnings.catch_warnings():
if 'use_wbm' in kwargs:
# The deprecation has been fixed in dev.major
warnings.simplefilter("ignore", category=DeprecationWarning)
for idx, wth in enumerate(wth_vec):
n_th = 1.0 / (np.exp(1.0 / wth) - 1) # bath temperature
c_op_list = []
rate = gamma1 * (1 + n_th)
c_op_list.append(np.sqrt(rate) * sm)
rate = gamma1 * n_th
c_op_list.append(np.sqrt(rate) * sm.dag())
rho_ss = qutip.steadystate(H, c_op_list, method=method, **kwargs)
if 'return_info' in kwargs:
rho_ss, info = rho_ss
assert isinstance(info, dict)
p_ss[idx] = qutip.expect(sm.dag() * sm, rho_ss)
p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
np.testing.assert_allclose(p_ss_analytic, p_ss, atol=1e-5)
def test_ho_lgmres():
"Steady state: Thermal HO - iterative-lgmres solver"
# thermal steadystate of an oscillator: compare numerics with analytical
# formula
a = destroy(40)
H = 0.5 * 2 * np.pi * a.dag() * a
gamma1 = 0.05
wth_vec = np.linspace(0.1, 3, 20)
p_ss = np.zeros(np.shape(wth_vec))
for idx, wth in enumerate(wth_vec):
n_th = 1.0 / (np.exp(1.0 / wth) - 1) # bath temperature
c_op_list = []
rate = gamma1 * (1 + n_th)
c_op_list.append(np.sqrt(rate) * a)
rate = gamma1 * n_th
c_op_list.append(np.sqrt(rate) * a.dag())
rho_ss = steadystate(H, c_op_list, method='iterative-lgmres')
p_ss[idx] = np.real(expect(a.dag() * a, rho_ss))
p_ss_analytic = 1.0 / (np.exp(1.0 / wth_vec) - 1)
delta = sum(abs(p_ss_analytic - p_ss))
assert_equal(delta < 1e-3, True)
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 steady(N = 20): # number of basis states to consider
n=num(N)
a = destroy(N)
H = a.dag() * a
print H.eigenstates()
#psi0 = basis(N, 10) # initial state
kappa = 0.1 # coupling to oscillator
c_op_list = []
n_th_a = 2 # temperature with average of 2 excitations
rate = kappa * (1 + n_th_a)
c_op_list.append(sqrt(rate) * a) # decay operators
rate = kappa * n_th_a
c_op_list.append(sqrt(rate) * a.dag()) # excitation operators
final_state = steadystate(H, c_op_list)
fexpt = expect(a.dag() * a, final_state)
#tlist = linspace(0, 100, 100)
#mcdata = mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=100)
#medata = mesolve(H, psi0, tlist, c_op_list, [a.dag() * a])
#plot(tlist, mcdata.expect[0],
#plt.plot(tlist, medata.expect[0], lw=2)
plt.axhline(y=fexpt, color='r', lw=1.5) # ss expt. value as horiz line (= 2)
plt.ylim([0, 10])
plt.show()
def test_qubit_power():
"Steady state: Thermal qubit - power solver"
# thermal steadystate of a qubit: compare numerics with analytical formula
sz = sigmaz()
sm = destroy(2)
H = 0.5 * 2 * np.pi * sz
gamma1 = 0.05
wth_vec = np.linspace(0.1, 3, 20)
p_ss = np.zeros(np.shape(wth_vec))
for idx, wth in enumerate(wth_vec):
n_th = 1.0 / (np.exp(1.0 / wth) - 1) # bath temperature
c_op_list = []
rate = gamma1 * (1 + n_th)
c_op_list.append(np.sqrt(rate) * sm)
rate = gamma1 * n_th
c_op_list.append(np.sqrt(rate) * sm.dag())
rho_ss = steadystate(H, c_op_list, method='power')
p_ss[idx] = expect(sm.dag() * sm, rho_ss)
p_ss_analytic = np.exp(-1.0 / wth_vec) / (1 + np.exp(-1.0 / wth_vec))
delta = sum(abs(p_ss_analytic - p_ss))
assert_equal(delta < 1e-5, True)
def generate_result_states(params, times, psi0=None, opt=None):
if opt is None:
opt = Options()
opt.atol = 1e-6
opt.rtol = 1e-6
args = {'params': params}
c_ops = c_ops_gen_jc(params)
e_ops = []
H = construct_ham(params)
if psi0 is None:
psi0 = steadystate(H[0], c_ops)
opt.store_states = True
trace = mesolve(H, psi0, times, c_ops, e_ops, args=args, options=opt)
size = 2 * params.c_levels
state_array = np.zeros([len(trace.states), size, size], dtype=complex)
for i, state in enumerate(trace.states):
state_array[i] = state.full()
frame_content = [[trace.times, state_array, params]]
columns = ['times', 'states', 'params']
results_frame = pd.DataFrame(frame_content, columns=columns)
results_frame['fd'] = params.fd
results_frame.set_index('fd', inplace=True)
return results_frame
def generate_result(params, times, psi0=None, opt=None, e_ops=None):
if opt is None:
opt = Options()
opt.atol = 1e-6
opt.rtol = 1e-6
args = {'params': params}
if e_ops is None:
e_ops = e_ops_gen(params)
c_ops = c_ops_gen_jc(params)
H = construct_ham(params)
if psi0 is None:
psi0 = steadystate(H[0], c_ops)
trace = mesolve(H, psi0, times, c_ops, e_ops, args=args, options=opt)
results_frame = pd.DataFrame(trace.expect, index=times)
results_frame.index.name = 'time'
results_frame['fd'] = params.fd
results_frame.set_index('fd', inplace=True, append=True)
results_frame = results_frame.reorder_levels(['fd', 'time'])
return results_frame
def cross_correlation(experiment,
start_time,
stop_time,
steps=500,
flip_time_axis=False):
"""Performs a cross correlation between signal and probe light field
:param experiment: The experiment on which the scan is performed
:type experiment: ntypecqed.simulation.NTypeExperiment
:param start_time: Start time of the correlation
:type start_time: float
:param stop_time: Stop time of the correlation
:type stop_time: float
:param steps: Number of steps
:type steps: int
:param flip_time_axis: if True the positive time direction is a signal photon first and a probe photon second
:type flip_time_axis: bool
:return: tuple(times, correlation value)
"""
if start_time > 0 or stop_time < 0 or start_time >= stop_time:
raise (
ValueError,
'Wrong times, conditions are start_time<0, stop_time>0 and start_time < stop_time'
)
tau_list_pos = np.linspace(0, abs(stop_time), steps)
tau_list_neg = np.linspace(0, abs(start_time), steps)
ss = steadystate(experiment.driven_hamiltonian,
experiment.environment.c_ops)
photon_number_field_1, photon_number_field_2 = expect(experiment.environment.n_a, ss), \
expect(experiment.environment.n_b, ss)
corr_data_pos = correlation_3op_1t(experiment.driven_hamiltonian, ss,
tau_list_pos,
experiment.environment.c_ops,
experiment.environment.b.dag(),
experiment.environment.n_a,
experiment.environment.b)
corr_data_neg = correlation_3op_1t(experiment.driven_hamiltonian, ss,
tau_list_neg,
experiment.environment.c_ops,
experiment.environment.a.dag(),
experiment.environment.n_b,
experiment.environment.a)
# norm the correlation
corr_data_pos /= (photon_number_field_1 * photon_number_field_2)
corr_data_neg /= (photon_number_field_1 * photon_number_field_2)
# change one of the correlations to negative times
if flip_time_axis:
tau_list_pos = -tau_list_pos[::-1]
corr_data_pos = corr_data_pos[::-1]
return np.concatenate((tau_list_pos, tau_list_neg)), np.concatenate(
(corr_data_pos, corr_data_neg))
else:
tau_list_neg = -tau_list_neg[::-1]
corr_data_neg = corr_data_neg[::-1]
return np.concatenate((tau_list_neg, tau_list_pos)), np.concatenate(
(corr_data_neg, corr_data_pos))
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 big_loop(num_qubits, num_states, g):
hilbert_space_dimension = 2**num_qubits
# num_states = hilbert_space_dimension // 2
random_indices = sorted(
random.sample(range(hilbert_space_dimension), num_states))
# print("The random indices are", random_indices)
# observable_one = hcp.generate_arbitary_observable(num_qubits, [1], ["1" + "0"*(num_qubits-1)])
# observable_two = hcp.generate_arbitary_observable(num_qubits, [1], ["2" + "0"*(num_qubits-1)])
# observable_three = hcp.generate_arbitary_observable(num_qubits, [1], ["3" + "0"*(num_qubits-1)])
# observables_list = [observable_one, observable_two, observable_three]
if sai_or_fuji == "fuji":
hamiltonian = generate_fuji_boy_hamiltonian(num_qubits, g)
gammas, L_terms = generate_fuji_boy_gamma_and_Lterms(num_qubits)
elif sai_or_fuji == "sai":
hamiltonian = generate_XXZ_hamiltonian(num_qubits, g)
gammas, L_terms = generate_nonlocaljump_gamma_and_Lterms(
num_qubits, Gamma, mu)
hamiltonian_matform = hamiltonian.to_matrixform()
L_terms_matform = [i.to_matrixform() for i in L_terms]
qtp_hamiltonian = qutip.Qobj(hamiltonian_matform)
qtp_Lterms = [qutip.Qobj(i) for i in L_terms_matform]
qtp_C_ops = [
np.sqrt(gammas[i]) * qtp_Lterms[i] for i in range(len(qtp_Lterms))
]
qtp_rho_ss = qutip.steadystate(qtp_hamiltonian,
qtp_C_ops,
method="iterative-gmres")
#generate matrices
E_matrix = generate_submatrix(np.eye(hilbert_space_dimension),
random_indices)
D_matrix = generate_submatrix(hamiltonian_matform, random_indices)
R_matrices = [
generate_submatrix(i, random_indices) for i in L_terms_matform
]
F_matrices = [
generate_submatrix(i.conj().T @ i, random_indices)
for i in L_terms_matform
]
beta = opt_package.cvxpy_density_matrix_feasibility_sdp_routine(
D_matrix, E_matrix, R_matrices, F_matrices, gammas, 0,
verbose=False)[0]
rho = submatrix_to_full_matrix(num_qubits, beta, random_indices)
rho_dot = evaluate_rho_dot(rho, hamiltonian, gammas, L_terms) #should be 0
print('Max value rho_dot is: ' + str(np.max(np.max(rho_dot))))
qtp_rho = qutip.Qobj(rho)
fidelity = qutip.metrics.fidelity(qtp_rho, qtp_rho_ss)
# print("The fidelity is", fidelity)
return fidelity
def steadystate_parfor_func(Delta, Delta_idx=0, Deltas=[], ob_obj=None):
print("Delta: " + str(Delta) + "\r")
Deltas[Delta_idx] = Delta
ob_obj.set_H_Delta(Deltas)
H = ob_obj.H_0 + ob_obj.H_Delta + ob_obj.H_I_sum()
return qu.steadystate(H, ob_obj.c_ops)
def rhos(self, nslice=None):
"""rho
return steadystate density matrices"""
self.precalc = True
if self.noisy:
print("N = {}, len() = {}".format(self.N_field_levels, len(self.long_range)))
def progress(*args):
if self.noisy:
print("|", sep="", end="", flush=True)
return args
if nslice is not None:
return np.asarray(
[progress(qt.steadystate(ham, self._c_ops())) for ham in list(self.hamiltonian())[nslice]]
).T
else:
return np.asarray([progress(qt.steadystate(ham, self._c_ops())) for ham in self.hamiltonian()]).T
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 test_exact_solution_for_simple_methods(method, kwargs):
# this tests that simple methods correctly determine the steadystate
# with high accuracy for a small Liouvillian requiring correct weighting.
H = qutip.identity(2)
c_ops = [qutip.sigmam(), 1e-8 * qutip.sigmap()]
rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
expected_rho_ss = np.array([
[1.e-16 + 0.j, 0.e+00 - 0.j],
[0.e+00 - 0.j, 1.e+00 + 0.j],
])
np.testing.assert_allclose(expected_rho_ss, rho_ss, atol=1e-16)
assert rho_ss.tr() == pytest.approx(1, abs=1e-14)
def steadystate(self, **kwargs):
""" Calculates the steady state of the system in the case of a
time-independent interaction, i.e. if we let time go to infinity.
Returns:
rho: The density matrix in the steady state.
"""
H = self.H_0 + self.H_Delta + self.H_I_sum()
self.rho = qu.steadystate(H, self.c_ops, **kwargs)
return self.rho
def single_photon_transmissivity(
hamiltonian: multi_emitter_hamiltonian.MultiEmitterHamiltonian,
input_freqs: np.ndarray,
amp_drive: float,
num_cav_states: int = 4) -> np.ndarray:
"""Computes the single photon transmissivity for the given Hamiltonian.
This function computes the transmittivity of a multi-emitter using qutip.
Args:
hamiltonian: The hamiltonian of the multi-emitter system, specified as a
multi_emitter_hamiltonian.MultiEmtterHamiltonian object.
input_freqs: The frequencies (relative to the reference frequency) at
which to compute the transmission. This should be an array rank 1.
amp_drive: The amplitude of the coherent drive used for driving the
cavity mode.
num_cav_states: The number of Fock states used for describing the
Hilbert space of the cavity.
Returns:
The transmissivity through the multi-emitter system at the specified
frequencies.
Raises:
ValueError: If the `frequencies` is not a one-dimensional array.
"""
if input_freqs.ndim != 1:
raise ValueError("Expected the `input_freqs` array to be a 1D array "
"instead got {} dimensions".format(input_freqs.ndim))
# List of transmissions for different frequencies.
transmissions = []
for freq in input_freqs:
# Get the hamiltonian and the operators for cavity and emitters.
qutip_hamiltonian, annihil_op, sigmas = _setup_qutip_hamiltonian(
hamiltonian, amp_drive, freq, num_cav_states)
# Setup the loss operators.
loss_ops = _setup_loss_operators(hamiltonian, annihil_op, sigmas)
# Calculate the steady state density matrix.
density_matrix_ss = qutip.steadystate(qutip_hamiltonian, loss_ops)
# Calculate the expectation value of the number of photons.
num_photons = qutip.expect(annihil_op.dag() * annihil_op,
density_matrix_ss)
# Calculate the transmission.
norm_factor = hamiltonian.kappa_in * hamiltonian.kappa_out
transmissions.append(norm_factor * num_photons / amp_drive**2)
return np.array(transmissions)
def find_expect(vg): #phi=0.1, Omega_vec=3.0):
phi, Omega=vg#.shape
Omega_vec=- 0.5j*(Omega*adag - conj(Omega)*a)
Ej = Ejmax*absolute(cos(pi*phi)) #Josephson energy as function of Phi.
wTvec = -Ej + sqrt(8.0*Ej*Ec)*(nvec+0.5)+Ecvec #\omega_m
wT = wTvec-wdvec #rotating frame of gate drive \omega_m-m*\omega_\gate
transmon_levels = Qobj(diag(wT[range(N)]))
H=transmon_levels +Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a)
final_state = steadystate(H, c_op_list) #solve master equation
return expect( a, final_state) #expectation value of relaxation operator
def find_expect(vg, self=a): #phi=0.1, Omega_vec=3.0):
phi, Omega=vg#.shape
Omega_vec=-0.5j*(Omega*self.a_dag - conj(Omega)*self.a_op)
Ej = self.Ejmax*absolute(cos(pi*phi)) #Josephson energy as function of Phi.
wTvec = (-Ej + sqrt(8.0*Ej*self.Ec)*(self.nvec+0.5)+self.Ecvec)/h #\omega_m
wT = wTvec-a.fdvec #rotating frame of gate drive \omega_m-m*\omega_\gate
transmon_levels = Qobj(diag(wT[range(self.N_dim)]))
H=transmon_levels +Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a)
final_state = steadystate(H, self.c_ops) #solve master equation
return expect( self.a_op, final_state) #expectation value of relaxation operator
def test_driven_cavity_power_bicgstab():
"Steady state: Driven cavity - power-bicgstab solver"
N = 30
Omega = 0.01 * 2 * np.pi
Gamma = 0.05
a = destroy(N)
H = Omega * (a.dag() + a)
c_ops = [np.sqrt(Gamma) * a]
M = build_preconditioner(H, c_ops, method='power')
rho_ss = steadystate(H, c_ops, method='power-bicgstab', M=M, use_precond=1)
rho_ss_analytic = coherent_dm(N, -1.0j * (Omega) / (Gamma / 2))
assert_((rho_ss - rho_ss_analytic).norm() < 1e-4)
def test_driven_cavity_power_bicgstab():
"Steady state: Driven cavity - power-bicgstab solver"
N = 30
Omega = 0.01 * 2 * np.pi
Gamma = 0.05
a = destroy(N)
H = Omega * (a.dag() + a)
c_ops = [np.sqrt(Gamma) * a]
M = build_preconditioner(H, c_ops, method='power')
rho_ss = steadystate(H, c_ops, method='power-bicgstab', M=M, use_precond=1)
rho_ss_analytic = coherent_dm(N, -1.0j * (Omega)/(Gamma/2))
assert_((rho_ss - rho_ss_analytic).norm() < 1e-4)
def test_driven_cavity(method, kwargs):
N = 30
Omega = 0.01 * 2 * np.pi
Gamma = 0.05
a = qutip.destroy(N)
H = Omega * (a.dag() + a)
c_ops = [np.sqrt(Gamma) * a]
if 'use_precond' in kwargs:
kwargs['M'] = qutip.build_preconditioner(H, c_ops, method=kwargs['M'])
rho_ss = qutip.steadystate(H, c_ops, method=method, **kwargs)
rho_ss_analytic = qutip.coherent_dm(N, -1.0j * (Omega) / (Gamma / 2))
np.testing.assert_allclose(rho_ss, rho_ss_analytic, atol=1e-4)
def additive_populations_and_current_vs_voltage(PARAMS, x_range=[0.6,1.6], num_voltages=35):
ti = time.time()
if PARAMS['T_L']<100:
number_of_voltages = int(1.8*num_voltages)
else:
number_of_voltages = num_voltages
#bias_voltages = np. linspace(x_range[0]*ev_to_inv_cm, x_range[1]*ev_to_inv_cm, number_of_voltages)
bias_voltages = np.concatenate((np.array([0]),
np.linspace(x_range[0]*ev_to_inv_cm, x_range[1]*ev_to_inv_cm, number_of_voltages)),
axis=0)
current = []
conduction_population = []
valence_population = []
ground_population = []
hole_population = []
electron_population = []
exciton_population = []
CC_population = []
ops = make_expectation_operators(PARAMS)
for i, bv in enumerate(bias_voltages):
PARAMS.update({'mu_R': PARAMS['mu']+bv/2, 'mu_L': PARAMS['mu']-bv/2})
#if i in [10, 90]:
# print_PARAMS(PARAMS)
L_Lindblad_dict = build_L(PARAMS, silent=True)
#ops = make_expectation_operators(PARAMS)
n_c = tensor(d_e.dag()*d_e, qeye(PARAMS['N']))
n_v = tensor(d_h.dag()*d_h, qeye(PARAMS['N']))
ss = steadystate(L_Lindblad_dict['H_S'], [L_Lindblad_dict['L_add_EM']])
current.append(current_from_ss(ss, L_Lindblad_dict['L_R'], n_c))
conduction_population.append((n_c*ss).tr())
valence_population.append((n_v*ss).tr())
ground_population.append((ops['vac']*ss).tr())
hole_population.append((ops['hole']*ss).tr())
electron_population.append((ops['electron']*ss).tr())
exciton_population.append((ops['exciton']*ss).tr())
CC_population.append((ops['CC_pop']*ss).tr())
bias_voltages/=ev_to_inv_cm
data_dict = {'bias_voltages':bias_voltages,
'current': current,
'conduction_population' : conduction_population,
'valence_population' : valence_population,
'ground_population': ground_population,
'hole_population' : hole_population,
'electron_population' : electron_population,
'exciton_population' : exciton_population,
'CC_population' : CC_population,
'PARAMS': PARAMS}
print("C-V data calculated in {:0.1f} seconds".format(time.time() - ti))
return data_dict
def rhos(self, nslice=None):
'''rho
return steadystate density matrices'''
self.precalc = True
if self.noisy:
print('N = {}, len() = {}'.format(self.N_field_levels,
len(self.long_range)))
def progress(*args):
if self.noisy:
print('|', sep='', end='', flush=True)
return args
if nslice is not None:
return np.asarray([
progress(qt.steadystate(ham, self._c_ops()))
for ham in list(self.hamiltonian())[nslice]
]).T
else:
return np.asarray([
progress(qt.steadystate(ham, self._c_ops()))
for ham in self.hamiltonian()
]).T
def test_driven_cavity_lgmres():
"Steady state: Driven cavity - iterative-lgmres solver"
N = 30
Omega = 0.01 * 2 * np.pi
Gamma = 0.05
a = destroy(N)
H = Omega * (a.dag() + a)
c_ops = [np.sqrt(Gamma) * a]
rho_ss = steadystate(H, c_ops, method='iterative-lgmres')
rho_ss_analytic = coherent_dm(N, -1.0j * (Omega)/(Gamma/2))
assert_((rho_ss - rho_ss_analytic).norm() < 1e-4)
def find_expect(vg):
phi, Omega = vg
H = make_H(phi, Omega, wdvec, 0.0)
#Omega_op=- 0.5j*(Omega*adag - conj(Omega)*a)
#Ej = Ejmax*absolute(cos(pi*phi)) #Josephson energy as function of Phi.
#wTvec = -Ej + sqrt(8.0*Ej*Ec)*(nvec+0.5)+Ecvec
#wT = wTvec-wdvec
#transmon_levels = Qobj(diag(wT[range(N)]))
#H=transmon_levels +Omega_op
final_state = steadystate(H, c_op_list)
return expect(a, final_state)
def test_driven_cavity_bicgstab():
"Steady state: Driven cavity - iterative-bicgstab solver"
N = 30
Omega = 0.01 * 2 * np.pi
Gamma = 0.05
a = destroy(N)
H = Omega * (a.dag() + a)
c_ops = [np.sqrt(Gamma) * a]
rho_ss = steadystate(H, c_ops, method='iterative-bicgstab')
rho_ss_analytic = coherent_dm(N, -1.0j * (Omega) / (Gamma / 2))
assert_((rho_ss - rho_ss_analytic).norm() < 1e-4)
def find_expect(vg, self=a): #phi=0.1, Omega_vec=3.0):
phi, Omega = vg #.shape
Omega_vec = -0.5j * (Omega * self.a_dag - conj(Omega) * self.a_op)
Ej = self.Ejmax * absolute(cos(
pi * phi)) #Josephson energy as function of Phi.
wTvec = (-Ej + sqrt(8.0 * Ej * self.Ec) *
(self.nvec + 0.5) + self.Ecvec) / h #\omega_m
wT = wTvec - a.fdvec #rotating frame of gate drive \omega_m-m*\omega_\gate
transmon_levels = Qobj(diag(wT[range(self.N_dim)]))
H = transmon_levels + Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a)
final_state = steadystate(H, self.c_ops) #solve master equation
return expect(self.a_op,
final_state) #expectation value of relaxation operator
def jc_steadystate(self, N, wc, wa, g, kappa, gamma,
pump, psi0, use_rwa, tlist):
# Hamiltonian
a = tensor(destroy(N), identity(2))
sm = tensor(identity(N), destroy(2))
if use_rwa:
# use the rotating wave approxiation
H = wc * a.dag(
) * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
else:
H = wc * a.dag() * a + wa * sm.dag() * sm + g * (
a.dag() + a) * (sm + sm.dag())
# collapse operators
c_op_list = []
n_th_a = 0.0 # zero temperature
rate = kappa * (1 + n_th_a)
c_op_list.append(np.sqrt(rate) * a)
rate = kappa * n_th_a
if rate > 0.0:
c_op_list.append(np.sqrt(rate) * a.dag())
rate = gamma
if rate > 0.0:
c_op_list.append(np.sqrt(rate) * sm)
rate = pump
if rate > 0.0:
c_op_list.append(np.sqrt(rate) * sm.dag())
# find the steady state
rho_ss = steadystate(H, c_op_list)
return expect(a.dag() * a, rho_ss), expect(sm.dag() * sm, rho_ss)
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 find_expect(phi=0.1, Omega_vec=3.0, wd=wd):
wdvec=nvec*wd
Ej = Ejmax*absolute(cos(pi*phi)) #; % Josephson energy as function of Phi.
wq0=sqrt(8*Ej*Ec)
X=Np*pi*(wq0-f0)/f0
Ba=-1*gamma*(sin(2.0*X)-2.0*X)/(2.0*X**2.0)
Ecp=Ec*(1-2*Ba/wq0)
Ecvec=-Ecp*(6.0*nvec**2+6.0*nvec+3.0)/12.0
wTvec = -Ej + sqrt(8.0*Ej*Ecp)*(nvec+0.5)+Ecvec
#print diff(wTvec)
if phi==0.4:
print Ba/wq0
if 0:
zr=zeros(N)
X=Np*pi*(diff(wTvec)-f0)/f0
Ba=-0*gamma*(sin(2.0*X)-2.0*X)/(2.0*X**2.0)
ls=-Ba#/(2*Ct)/(2*pi)#/1e6
zr[1:]=ls
#print Ga0/(2*Ct)/(2*pi)
#print zr
wTvec=wTvec+zr
wTvec = wTvec-wdvec
#print wTvec+diff(wTvec)
transmon_levels = Qobj(diag(wTvec[range(N)]))
H=transmon_levels +Omega_vec #- 0.5j*(Omega_true*adag - conj(Omega_true)*a)
final_state = steadystate(H, c_op_list)
return expect( tm_l, final_state)
# Calculating steady-state solutions using the qutip library
def H(w):
""" Hamiltonian of a spin 1/2 in B0 + Brf using the RWA. """
return (w0 - w)/2 * qt.sigmaz() + w1/2 * qt.sigmax()
# Collsapse operators which should describe the relaxation of the system
c1 = np.sqrt(1.0/T1) * qt.destroy(2)
c2 = np.sqrt(1.0/T2)/2 * qt.destroy(2)
c3 = np.sqrt(1.0/(T1*T2)) * qt.destroy(2)
c4 = np.sqrt(1.0/T2) /2 * qt.create(2)
c5 = np.sqrt(1.0/(T1*T2)) * qt.create(2)
wHVals = np.linspace(-2 * np.pi, 6 * np.pi, 31)
MxH = [qt.expect(qt.sigmax(), qt.steadystate(H(w), [c1,c2,c3], maxiter=10)) for w in wHVals]
MyH = [qt.expect(qt.sigmay(), qt.steadystate(H(w), [c2,c5], maxiter=10)) for w in wHVals]
MzH = [qt.expect(qt.sigmaz(), qt.steadystate(H(w), [c1], maxiter=10)) for w in wHVals]
wVals = np.linspace(-2 * np.pi, 6 * np.pi, 100)
# Plot results of the algebraic formula and the solution given by qutip
plt.ylim([-1.0, 1.0])
plt.plot(wVals, Mx(wVals), label='Mx')
plt.plot(wVals, My(wVals), label='My')
plt.plot(wVals, Mz(wVals), label='Mz')
plt.plot(wHVals, MxH, 'bo', label='MxH')
plt.plot(wHVals, MyH, 'go', label='MyH')
wVals = np.linspace(-2 * np.pi, 6 * np.pi, 100)
# Solving the dynamics of a spin 1/2 in B0 and Brf in the lab frame
def H(w):
""" Hamiltonian in the lab frame. """
return w0 / 2 * qt.sigmaz() + w1 * np.cos(w) * qt.sigmax()
c1 = np.sqrt(1.0/T1) * qt.destroy(2)
c2 = np.sqrt(1.0/T2) / 2 * qt.destroy(2)
c_op_list = [c1,c2]
wHVals = np.linspace(-2 * np.pi, 6 * np.pi, 51)
MxH = [qt.expect(qt.sigmax(), qt.steadystate(H(w), c_op_list, maxiter=100)) for w in wHVals]
MyH = [qt.expect(qt.sigmay(), qt.steadystate(H(w), c_op_list, maxiter=100)) for w in wHVals]
MzH = [qt.expect(qt.sigmaz(), qt.steadystate(H(w), c_op_list, maxiter=100)) for w in wHVals]
# Plot results of the algebraic formula and the solution given by qutip
plt.ylim([-1.0, 1.0])
plt.plot(wVals, Mx(wVals), label='Mx')
plt.plot(wVals, My(wVals), label='My')
plt.plot(wVals, Mz(wVals), label='Mz')
plt.plot(wHVals, MxH, 'bo', label='MxH')
plt.plot(wHVals, MyH, 'go', label='MyH')
plt.plot(wHVals, MzH, 'ro', label='MzH')
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)
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() print D.shape, D print diag(D) b = spre(p).full()-spost(p).full() a = spre(a).full()
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