A = k2**0.5*a**2
B = -k2**0.5*alpha_inf_abs**2*Ia
cops = [k1**0.5*a,]
cops.append([A, funcA])
cops.append([B, funcB])
cops.append([A+B, funcApB])
cops.append([A+1j*B, funcApiB])
init_state=C_alpha_plus#initial state
tlist = np.linspace(0, T_final, n_t)
res_NOT = qt.mesolve(0*a, init_state, tlist, cops)#,progress_bar=TextProgressBar())
res_NOT_Wigner = compute_Wigner([-6, 6, 51], nbWignerPlot,nbCols, n_t,-1)
res_NOT_Wigner.draw_Wigner(res_NOT.states, title='Simulations NOT')
if False :
"Calculates the coefficient of the hamiltonian time-dependant terms"
def coeff_rot(t):
return(np.exp(1j*2*delta*(t-T1)*(t>=T1 and t<=T2)))
H_NOT=0*a
#H=-1j*(a**2*eps_2-a.dag()**2*np.conjugate(eps_2))
cops1=[k1**0.5*a]
cops2_bis=convert_time_dependant_cops_2(k2**0.5*a**2,coeff_rot,-k2**0.5*alpha_inf_abs**2*Ia)
cops_bis=cops1+cops2_bis
cops_noNOT=[k1**0.5*a,k2**0.5*(a**2-alpha_inf_abs**2*Ia)]
"Resolution of the equation over time with mesolve"
n_t = 101
tlist = np.linspace(0, Tp, n_t)
# return the average value evolution of given operators
##print(H_pcc.shape)
#print(H_inter.shape)
#print(storage_0.shape)
#print(PCC_0.shape)
#print(qt.tensor(storage_0,PCC_0).shape)
res = qt.mesolve([chi0*H_inter+H_storage+H_pcc,], qt.tensor(storage_0,PCC_0), tlist,cops,progress_bar=TextProgressBar())
print("solved")
print("Wigner storage")
test_Wigner1 = compute_Wigner([-4, 4, 51], 10, n_t, 0)
test_Wigner1.draw_Wigner(res)
print("Wigner PCC")
test_Wigner2 = compute_Wigner([-4, 4, 51], 10, n_t, 1)
test_Wigner2.draw_Wigner(res)
proba_PCC = []
proba_storage = []
fidelity_PCC = []
fidelity_storage = []
for ii, t in enumerate(tlist):
rho_PCC = res.states[ii].ptrace(1)
rho_storage = res.states[ii].ptrace(0)
proba_PCC.append((PCC_0.dag()*rho_PCC*PCC_0)[0][0][0])
proba_storage.append((storage_0.dag()*rho_storage*storage_0)[0][0][0])
fidelity_PCC.append(qt.fidelity(PCC_0,rho_PCC)**2)
H=0*A
#H=-1j*(a**2*eps_2-a.dag()**2*np.conjugate(eps_2))
cops=[k2**0.5*(A**2-alpha**2),
time_dependant_c_ops]
"Resolution of the equation over time with mesolve"
init_state= C_alpha_plus #initial state
n_t = 1001
T=np.pi /delta #total time of simulation
tlist = np.linspace(0, 2*T, n_t)
res = qt.mesolve(H, init_state, tlist, cops, progress_bar=TextProgressBar())
#Wigner
test_Wigner = compute_Wigner([-4, 4, 51], nbWignerPlot,nbCols, n_t,-1)
test_Wigner.draw_Wigner(res)
"Plot the evolution of fidelity over time"
fidelity_list=[]
for ii,t in enumerate(tlist):
if t<T/2:
fidelity_list.append(qt.fidelity(res.states[ii],C_alpha_plus))
elif t>3*T/2:
fidelity_list.append(qt.fidelity(res.states[ii],C_alpha_plus))
else:
theta=np.exp(-1j*delta*(t-T/2))
C_alpha_plus_rot=qt.coherent(Na, alpha*theta)+qt.coherent(Na, -alpha*theta)
C_alpha_plus_rot=C_alpha_plus_rot/C_alpha_plus_rot.norm()
fidelity_list.append(qt.fidelity(res.states[ii],C_alpha_plus_rot))
H_NOT = [[a**2, coef_eps], [a.dag()**2, coef_eps_conj]]
#H=-1j*(a**2*eps_2-a.dag()**2*np.conjugate(eps_2))
cops = [k1**0.5 * a, k2**0.5 * a**2]
"Resolution of the equation over time with mesolve"
init_state = qt.coherent(Na, alpha) #initial state
tlist = np.linspace(0, T_final, n_t)
res_NOT = qt.mesolve(H_NOT,
init_state,
tlist,
cops,
progress_bar=TextProgressBar())
##Wigner
res_NOT_Wigner = compute_Wigner([-6, 6, 51], nbWignerPlot, nbCols, n_t, -1)
res_NOT_Wigner.draw_Wigner(res_NOT.states, title='Simulations with NOT')
# res_free_Wigner= compute_Wigner([-6,6, 51], nbWignerPlot,nbCols, n_t,-1)
# res_free_Wigner.draw_Wigner(res_free.states, title='Simulations without NOT')
"Plot the evolution of fidelity over time"
target_res = [] #to check the Wigner
fidelity_NOT_list = []
for ii, t in enumerate(tlist):
if t <= T1:
current_theta = 0
elif (t > T1) and (t < T2):
current_theta = delta * (t - T1)
else:
current_theta = np.pi
state_rot = (-1j * current_theta * a.dag() * a).expm() * init_state
psi_plus = psi_plus/psi_plus.norm() # even cat /!\ normalisation
def dissipative_operator(t, args):
return k2**0.5*(a**2-(alpha*np.exp(1j*np.pi*t*delta))**2)
H = 0*a
# see Wigner : it seems that the pumping is not rotating
# if one does not want to display wigners of the time evolution and
# only evolution of average quantities, one can put a list of operator
# in the following list
eops = [parity_a,
a,
n_a,
]
c_ops = []
tlist = np.linspace(0, T_gate, n_t)
res = qt.mesolve(dissipative_operator, psi_plus, tlist, c_ops,progress_bar=TextProgressBar())
test_Wigner = compute_Wigner([-4, 4, 51], 10, n_t,-1)
test_Wigner.draw_Wigner(res)
number_t = []
for ii, t in enumerate(tlist):
number_t.append(qt.expect(n_a, res.states[ii]))
#fig, ax = plt.subplots(3)
#plt.plot(tlist, number_t)
#ax[1].plot(tlist, na_t)
#ax[2].plot(tlist, np.real(a_t))
#ax[2].plot(tlist, np.imag(a_t), linestyle='dashed')
## Checking the good proba decrease
Tf = 10 * np.pi / k2
n_t = 501
k1 = k2 / 1000
a = qt.destroy(Na)
cops_decrease = [k1**0.5 * a, k2**0.5 * (a**2 - size_cat**2)]
tlist = np.linspace(0, Tf, n_t)
init_state = C_alpha_plus
res = qt.mesolve(0 * a,
init_state,
tlist,
cops_decrease,
progress_bar=TextProgressBar())
#visual checking with Wigner
res_Wigner = compute_Wigner([-4, 4, 101], nbWignerPlot, nbCols, n_t, -1)
res_Wigner.draw_Wigner(res.states, title='Decrease')
proba_tab = []
for (ii, t) in enumerate(tlist):
proba_tab.append(qt.expect(res.states[ii], init_state))
#Fitting
T_phi = 1 / (2 * size_cat**2 * k1)
fitting_tab = 1 / 2 * (1 + np.exp(-tlist / T_phi))
fig, ax = plt.subplots()
ax.plot(tlist, proba_tab, '+', label='From simu')
ax.plot(tlist, fitting_tab, '+', label='fitting')
ax.set_xlabel('Time')
ax.set_ylabel('Proba, expect value againts init state')
cops,
progress_bar=TextProgressBar()) #,progress_bar=TextProgressBar())
#np.save(path+'tab_values',res_CNOT.states)
# cannot save the data because it is an array of Quantum objects
#qt.qsave(res_CNOT,path+ 'density_test')
#Saving res
if False:
res_data = []
for (ii, t) in enumerate(tlist):
res_data.append(res_CNOT.states[ii].data)
np.save(path + 'tab_size2_k2isdelta', res_data)
#res_CNOT=qt.qload(path+ 'density_plus_k2over10')
res_CNOT_Wigner_C = compute_Wigner([-4, 4, 101], nbWignerPlot, nbCols, n_t, 0)
res_CNOT_Wigner_C.draw_Wigner(
res_CNOT.states,
title=
r'CNOT-control // $\alpha, \beta=$ %.0f -Trunc=%.0f //$\kappa_2=$%.0f - $\kappa_1=$%.0f// $\Delta=\frac{\alpha^2 \kappa_2}{c}$, c=%.0f //Control is on : %r//'
% (size_cat, trunc, k2, k1, prop, control_on))
plt.savefig(
path +
'wigner_CONTROL_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.png'
% (size_cat, trunc, k1, prop, control_on))
res_CNOT_Wigner_T = compute_Wigner([-4, 4, 101], nbWignerPlot, nbCols, n_t, 1)
res_CNOT_Wigner_T.draw_Wigner(
res_CNOT.states,
title=
r'CNOT-target // $\alpha, \beta=$ %.0f -Trunc=%.0f //$\kappa_2=$%.0f - $\kappa_1=$%.0f// $\Delta=\frac{\alpha^2 \kappa_2}{c}$, c=%.0f //Control is on : %r// '
#
#path='C:/Users\Camille/Documents/GitHub/CNOT_simus/Images/CNOT_coeff_depending_on_time/Cat_size2/'
#np.save(path+'table_resCNOT_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.npy'%(size_cat,trunc,k1,prop,control_on),res_CNOT.states)
"Plot the evolution of fidelity over time"
distance_nth_list = [
] #not fidelity because it computes square root and it creates numerics errors;
distance_witness_list = []
for ii, t in enumerate(tlist):
distance_nth_list.append(qt.expect(res_nth.states[ii], init_state))
distance_witness_list.append(qt.expect(res.states[ii], init_state))
#
#Wigner of target res (to check the rotated states does the job)
plot_Wigner = compute_Wigner([-6, 6, 51], nbWignerPlot, nbCols, n_t, -1)
plot_Wigner.draw_Wigner(res_nth.states, "Evolution with nth")
#Plot
fig, axs = plt.subplots()
axs.plot(tlist, distance_nth_list, '+', label='N_thermal')
axs.plot(tlist, distance_witness_list, '+', label='Without n_th')
axs.set_xlabel('Time (s)')
axs.set_ylabel('Distance')
axs.legend()
axs.set_title(
r'$\alpha = $ %.0f -Trunc=%.0f //$\kappa_2=$%.1f - $\kappa_1=$%.4f // $\omega /2 \pi=$ %.0f GHz'
% (alpha_inf_abs, trunc, k2, k1, f / (1e9)))
#axs.set_title(r'$\alpha = $ %.0f -Trunc=%.0f //$\kappa_2=$%.1f KHz- $\kappa_1=$%.1f MHz// $\omega /2 \pi=$ %.0f GHz'%(alpha_inf_abs,trunc,k2/(1e3),k1/(1e6),f/(1e9)))
#plt.savefig(path+'fidelity_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.png'%(size_cat,trunc,k1,prop,control_on))
cops.append([A, funcA])
cops.append([B, funcB])
cops.append([A+B, funcApB])
cops.append([A+1j*B, funcApiB])
init_state_C=qt.coherent(Na,-alpha)
control_on=True
init_state_T=C_beta_plus
init_state_tensor=qt.tensor(init_state_C,init_state_T)#initial state
tlist = np.linspace(0,T_final, n_t)
res_CNOT = qt.mesolve(0*a_tensor, init_state_tensor, tlist, cops,progress_bar=TextProgressBar())#,progress_bar=TextProgressBar())
res_CNOT_Wigner_C = compute_Wigner([-4,4, 51], nbWignerPlot,nbCols, n_t,0)
res_CNOT_Wigner_C.draw_Wigner(res_CNOT.states, title=r'CNOT-control // $\alpha, \beta=$ %.0f -Trunc=%.0f //$\kappa_2=$%.0f - $\kappa_1=$%.0f// $\Delta=\frac{\alpha^2 \kappa_2}{c}$, c=%.0f //Control is on : %r//'%(size_cat,trunc,k2,k1,prop,control_on))
plt.savefig(path+'wigner_CONTROL_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.png'%(size_cat,trunc,k1,prop,control_on))
res_CNOT_Wigner_T = compute_Wigner([-4,4, 51], nbWignerPlot,nbCols, n_t,1)
res_CNOT_Wigner_T.draw_Wigner(res_CNOT.states, title=r'CNOT-target // $\alpha, \beta=$ %.0f -Trunc=%.0f //$\kappa_2=$%.0f - $\kappa_1=$%.0f// $\Delta=\frac{\alpha^2 \kappa_2}{c}$, c=%.0f //Control is on : %r// '%(size_cat,trunc,k2,k1,prop,control_on))
plt.savefig(path+'wigner_TARGET_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.png'%(size_cat,trunc,k1,prop,control_on))
#Save the table of value
path='C:/Users\Camille/Documents/GitHub/CNOT_simus/Images/CNOT_coeff_depending_on_time/Cat_size2/'
np.save(path+'table_resCNOT_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.npy'%(size_cat,trunc,k1,prop,control_on),res_CNOT.states)
# #Wigner
# res_CNOT_Wigner_C = compute_Wigner([-4,4, 51], nbWignerPlot,nbCols, n_t,0)