def load_data(train, N, average, runs, Tcrit=0.0, h=0.0):
X_train = []
Y_train = []
magn_list = []
for t in temp:
if train:
filename = ('data_no_field/uniform_field_spin_hmax_' + str(h) +
'T_' + str(t) + 'N_' + str(N) +
'_number_of_config_per_temp_' + str(average) +
'runs_' + str(runs) + '_0')
else:
filename = ('data_field_h1_5/uniform_field_spin_hmax_' + str(h) +
'T_' + str(t) + 'N_' + str(N) +
'_number_of_config_per_temp_' + str(average) +
'runs_' + str(runs) + '_0')
a = qt.qload(filename)
magn = 0
for i in a:
magn += abs(np.sum(i))
i = (i + 1) / 2 # renormalize
X_train.append(i.reshape(1, 20, 20))
if t < Tcrit:
Y_train.append([1, 0])
else:
Y_train.append([0, 1])
magn_list.append(magn / (N**2 * average))
X_train = np.array(X_train)
return X_train, Y_train
def test_evolution_operator(n_qubits, n_levels):
#generate random parameters
params = 0.01*np.random.rand(2, n_levels)
gammas = params[0]
betas = params[1]
#generate random graph
edges = []
while len(edges) < 1:
prob = 0.5
graph = erdos_renyi_graph(n_qubits, prob)
edges = list(graph.edges)
#generate random n-qubits state
list_gen_state = qucs.n_rand_qubits(n_qubits)
gen_state = qu.tensor(list_gen_state)
#Test if it works as expected
obs = qaoa.evolution_operator(n_qubits, edges, gammas, betas)*gen_state
exp = gen_state
for i in range(len(gammas)):
u_mix_hamilt_i = (-complex(0,betas[i])*qaoa.mix_hamilt(n_qubits)).expm()
u_prob_hamilt_i = (-complex(0,gammas[i])*qaoa.prob_hamilt(n_qubits, edges)).expm()
exp = u_mix_hamilt_i*u_prob_hamilt_i*exp
assert (np.round(np.array(exp.full()), 8) == (np.round(np.array(obs.full()), 8))).all()
#test if it evolves a state for known parameters
exp = qu.qload('final_state_simple_graph_p=1')
obs = qaoa.evolution_operator(3, [(0,1),(1,2)], [1.0], [0.4])*qaoa.initial_state(3)
def steadystate_parfor(self,
Deltas,
num_cpus=None,
recalc=True,
savefile=None):
savefile_exists = os.path.isfile(str(savefile) + '.qu')
# If 1) we ask for it to be recalculated or 2) it *must* be calculated
# because no savefile exists: do the steady state calc. Else load file.
if (recalc or not savefile_exists):
# Reset rho_Delta in case of multiple calcs
self.rho_Delta = [None] * len(self.Delta_range)
Deltas_i = list(Deltas) # Make copy, don't modify in place
Delta_steps = len(self.Delta_range) - 1
self.rho_Delta = qu.parfor(steadystate_parfor_func,
self.Delta_range,
Delta_idx=self.Delta_idx,
Deltas=Deltas_i,
ob_obj=self.ob_obj,
num_cpus=num_cpus)
# Only save the file if we have a place to save it
if (savefile != None):
qu.qsave(self.rho_Delta, savefile)
# Otherwise load the steady state rho_v_delta from file
else:
self.rho_Delta = qu.qload(savefile)
return self.rho_Delta
def mesolve(self,
tlist,
rho0=None,
td=False,
e_ops=[],
args={},
opts=qu.Options(),
recalc=True,
savefile=None,
show_pbar=False):
if not rho0:
rho0 = self.ground_state()
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:
# Is the Hamiltonian time-dependent?
if td: # If so H is a list of [H_i, t_func_i] pairs.
H = [self.H_0, self.H_Delta]
H.extend(self.H_I_list())
else: # If not it's a single QObj
H = self.H_0 + self.H_Delta + self.H_I_sum()
if show_pbar:
pbar = qu.ui.progressbar.TextProgressBar()
else:
pbar = qu.ui.progressbar.BaseProgressBar()
self.result = qu.mesolve(H,
rho0,
tlist,
self.c_ops,
e_ops,
args=args,
options=opts,
progress_bar=pbar)
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:
print('Saving OBBase to {0}.qu'.format(savefile))
qu.qsave(self.result, savefile)
# Otherwise load the steady state rho_v_delta from file
else:
print('Loading from {0}.qu'.format(savefile))
self.result = qu.qload(savefile)
self.rho = self.result.states[-1]
return self.result
def load_results(self):
""" Loads the solution from a QuTiP pickle file.
Notes:
- The path from which the results will be loaded is taken from
self.savefile.
"""
self.Omegas_zt, self.states_zt = qu.qload(self.savefile)
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_qsave_qload():
ops_in = [
qutip.sigmax(),
qutip.num(_dimension),
qutip.coherent_dm(_dimension, 1j)
]
filename = _random_file_name()
qutip.qsave(ops_in, filename)
ops_out = qutip.qload(filename)
assert ops_in == ops_out
def test_qsave_qload(use_path, suffix):
ops_in = [
qutip.sigmax(),
qutip.num(_dimension),
qutip.coherent_dm(_dimension, 1j)
]
filename = _random_file_name() + suffix
if use_path:
filename = Path.cwd() / filename
qutip.qsave(ops_in, filename)
ops_out = qutip.qload(filename)
assert ops_in == ops_out
def test_qsave_qload():
# qsave _always_ appends a suffix to the file name at the time of writing,
# but in case this changes in the future, to ensure that we never leak a
# temporary file into the user's folders, we simply apply this test in a
# temporary directory rather than manually creating a temporary file and
# modifying the name.
ops_in = [
qutip.sigmax(),
qutip.num(_dimension),
qutip.coherent_dm(_dimension, 1j)
]
filename = "qsave_qload_test"
qutip.qsave(ops_in, filename)
ops_out = qutip.qload(filename)
assert ops_in == ops_out
def essolve(self, Deltas, tlist, rho0=None, recalc=True, savefile=None):
savefile_exists = os.path.isfile(str(savefile) + '.qu')
# If 1) we ask for it to be recalculated or 2) it *must* be calculated
# because no savefile exists: do the steady state calc. Else load file.
if (recalc or not savefile_exists):
# Reset rho_Delta in case of multiple calcs
self.rho_Delta = [None] * len(self.Delta_range)
self.result_Delta = [None] * len(self.Delta_range)
Deltas_i = list(Deltas) # Make copy, don't modify in place
Delta_steps = len(self.Delta_range) - 1
for i, Delta_i in enumerate(self.Delta_range):
print("\rDelta: " + str(Delta_i) + ", " + str(i) + "/" +
str(Delta_steps))
# Set the omega of the chosen beam to the current delta step.
Deltas_i[self.Delta_idx] = Delta_i
self.ob_obj.set_H_Delta(Deltas_i)
try:
result = self.ob_obj.essolve(tlist, rho0=rho0)
except ValueError:
print("Failed to solve.")
self.result_Delta[i] = result
self.rho_Delta[i] = result.states[-1]
# Only save the file if we have a place to save it
if (savefile != None):
qu.qsave((self.rho_Delta, self.result_Delta), savefile)
# Otherwise load the steady state rho_v_delta from file
else:
(self.rho_Delta, self.result_Delta) = qu.qload(savefile)
return self.rho_Delta, self.result_Delta
def excitation(args):
H0 = args['parity']*args['vFermi']*(args['kpoint'][0]*qp.sigmax() + args['kpoint'][1]*qp.sigmay())
H1 = qp.sigmax()
H2 = qp.sigmay()
Hamiltonian = [H0,[H1,HCoeff]]
states = H0.eigenstates()
psi0 = states[1][0]
psi1 = states[1][1]
import hashlib
label = hashlib.sha224(str(args)).hexdigest()
import os
if os.path.exists('Data/'+label+'.qu'):
result = qp.qload('Data/'+label)
print 'Loading'
else:
result = qp.mesolve(Hamiltonian, psi0, args['times'], [], [], args=args)
print 'Recalculate'
qp.qsave(result, 'Data/'+ label)
proj0 = np.array([(state.dag()*psi0).norm() for state in result.states])
proj1 = np.array([(state.dag()*psi1).norm() for state in result.states])
return result, proj0, proj1
pm = 0.003
pg = 0.003
a0 = 5.0
a1 = 1 / 30.
eta = 1 / 100.
theta = .63
ghz_size = 4
protocol = "thres_eta"
ghz_ref = qt.ghz_state(4) * qt.ghz_state(4).dag()
ghz_file = names.ghz(ps, pm, pg, eta, a0, a1, theta, ghz_size, protocol)
times_file = names.ghz_times(ps, pm, pg, eta, a0, a1, theta, ghz_size,
protocol)
ghzs = qt.qload(ghz_file)
times = np.load(times_file)
print("N: ", len(times))
fidelities = []
for i in ghzs:
fidelities += [qt.fidelity(i, ghz_ref)]
fidelities = np.array(fidelities)
indices_sorted = np.argsort(times)
times = times[indices_sorted][:-1]
fidelities = fidelities[indices_sorted][:-1]
ignore_number = int(len(times) / 100 * 5.)
t_max = times[:-ignore_number][-1]
def load_results(self):
self.Omegas_zt, self.states_zt = qu.qload(self.savefile)
"""
import qutip
import sys
if len(sys.argv) ==5:
inputfilenameA = str(sys.argv[1])
indexA = int(sys.argv[2])
inputfilenameB = str(sys.argv[3])
indexB = int(sys.argv[4])
if inputfilenameA[-3:]==".qu":
inputfilenameA = inputfilenameA[:-3]
if inputfilenameB[-3:]==".qu":
inputfilenameB = inputfilenameB[:-3]
listA=qutip.qload(inputfilenameA)
A=listA[indexA]
listB=qutip.qload(inputfilenameB)
B=listB[indexB]
elif len(sys.argv) ==4:
inputfilename = str(sys.argv[1])
indexA = int(sys.argv[2])
indexB = int(sys.argv[3])
if inputfilename[-3:]==".qu":
inputfilename = inputfilename[:-3]
mylist=qutip.qload(inputfilename)
A=mylist[indexA]
B=mylist[indexB]
print("Loaded two objects")
def get_state(system_size, time_index):
return qt.qload(get_state_path(system_size, time_index))
#Set the time of simulation
T = np.pi / delta
Tgate_tab.append(T)
T1 = 0
T2 = T1 + T
T_final = T2 + T / 4
if ratio < 10:
n_t = 301 #number of points from T1 to T2
elif ratio <= 20:
n_t = 401
elif ratio <= 40:
n_t = 501
elif ratio <= 50:
nt = 601
res_CNOT = qt.qload(
path + 'Simus_CNOT_without_lossdensity_without_loss_k2_over_%d' %
(ratio))
tlist = np.linspace(0, T_final, n_t)
tlist = np.array(tlist)
#States
Na = trunc
Nb = trunc
alpha = size_cat #alpha of initial state
beta = size_cat
C_alpha_plus = qt.coherent(Na, alpha) + qt.coherent(Na, -alpha)
C_alpha_plus = C_alpha_plus / C_alpha_plus.norm()
C_beta_plus = qt.coherent(Nb, beta) + qt.coherent(Nb, -beta)
C_beta_plus = C_beta_plus / C_beta_plus.norm()
final_state_C = C_alpha_plus
final_state_T = C_beta_plus
# for pg in [0.0031, 0.0032, 0.0033, 0.0034, 0.0035, 0.0036, 0.0037, 0.0038, 0.0039, 0.0040, 0.0041]:
# for pg in [0.0032, 0.0033, 0.0034, 0.0035, 0.0036, 0.0037, 0.0038, 0.0039, 0.0040, 0.0041, 0.0042, 0.0043, 0.0044, 0.0045]:
for tau in range(10):
f, g, h = fgh.fgh(mode)
a0 = f(tau)
eta = g(tau)
pg = h(tau)
ps = pg
pm = pg
# Load GHZ state files
ghz_file = names.ghz(ps, pm, pg, eta, a0, a12, theta, ghz_size, protocol)
times_file = names.ghz_times(ps, pm, pg, eta, a0, a12, theta, ghz_size,
protocol)
ghzs = qt.qload(ghz_file)
times = np.load(times_file)
if extra:
ghz_file2 = names.ghz(ps, pm, pg, eta, a0, a1, theta, ghz_size,
protocol + "2")
times_file2 = names.ghz_times(ps, pm, pg, eta, a0, a1, theta, ghz_size,
protocol + "2")
ghzs = np.append(ghzs, qt.qload(ghz_file2))
times = np.append(times, np.load(times_file2))
###################################################################
# CHOSE PERCENTILE
N = len(times)
ignore_number = int(N * ignore_percent / 100)
def get_state(state_name, L):
return qt.qload(get_state_path(state_name, L))
if 0: # squeezed
N = 70
db_val = 8
z = db_val / (20 * np.log10(np.e))
target_state = qt.tensor(qt.basis(2,0), qt.squeeze(N,z)*qt.basis(N,0))
if 0: # binomial
N = 60
pz = (qt.basis(N,0) + qt.basis(N,4))/np.sqrt(2.0)
mz = qt.basis(N,2)
py = (pz + 1j*mz)/np.sqrt(2.0)
target_state = qt.tensor(qt.basis(2,0), py)
if 0: # GKP
target_state_cav = qt.qload('E:\data\gkp_sims\PPO\ECD\GKP_state_delta_0p25')
target_state = qt.tensor(qt.basis(2,0), target_state_cav)
N = target_state_cav.dims[0][0] # 200
# reward_kwargs = {'reward_mode' : 'tomography',
# 'tomography' : 'characteristic_fn',
# 'target_state' : target_state,
# 'window_size' : 16}
reward_kwargs = {'reward_mode' : 'tomography',
'tomography' : 'wigner',
'target_state' : target_state,
'sampling_type' : 'abs',
'N_alpha' : 100,
'N_msmt' : 10,
path +
'wigner_TARGET_size%.0f_trunc%.0f_k1_%.0f_coefspeed_%.1f_control_on%r.png'
% (size_cat, trunc, k1, prop, control_on))
ind_T2 = int(n_t * T2 / T_final)
#partial trace
#res_tab=np.load(path+'tab_size2_k2isdeltaover10.npy')
#ptrace_T=[]
#p_trace_C=[]
#for (ii, res) in enumerate res_tab:
# p_trace_T.append()
path = 'C:/Users/berdou/Documents/Thèse/Posters/Images-poster/Images_CNOT/'
res_CNOT = qt.qload(path + 'density_plus_k2over10')
# Draw indiv Wigner
fig, ax = plt.subplots()
ii = int(n_t * T2 * 1.1 * 1 / T_final)
space_size = [-4, 4, 1001]
space_size = np.linspace(space_size[0], space_size[1], space_size[2])
wig = qt.wigner(res_CNOT.states[ii].ptrace(1), space_size, space_size, g=2)
ax.pcolor(space_size,
space_size,
wig,
cmap='bwr',
vmin=[-2 / np.pi, 2 / np.pi])
ax.set_aspect('equal')
#
#class compute_Wigner:
# def __init__(self, space_size, nbWigner,nbCols, tempsSimul, syst):
