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 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 save_results(self):
""" Saves the solution to a QuTiP pickle file.
Notes:
- The path to which the results will be saved is taken from
self.savefile.
"""
# Only save the file if we have a place to save it.
if self.savefile:
print('Saving MBSolve to', self.savefile+'.qu')
qu.qsave((self.Omegas_zt, self.states_zt), self.savefile)
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 _default_save_element_fun(save_path, output, ii):
""" Saves the element using qutip qsave function
Parameters
----------
save_path : str
The path to which the data is saved.
output : obj
The object to save.
ii : int
The serial index of the output element in the simulation.
"""
import qutip as qutip
qutip.qsave(output, os.path.join(save_path, 'qobject_' + str(ii)))
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
print("Errors:")
print("OK: ", I_OK)
print("NOK: ", I_NOK)
print("E: ", E)
print("Env E: ", env_error_rate(t_max, a1))
print("TOTAL E: ", env_error_rate(t_max, a1) + E)
print("-------------")
############################################
############################################
##################### SAVE DATA ############
name = names.ghz(ps, pm, pg, eta, a0, a1, theta, len(rho.dims[0]),
protocol_name)
print(name)
qt.qsave(rhos, name)
name_time = names.ghz_times(ps, pm, pg, eta, a0, a1, theta,
len(rho.dims[0]), protocol_name)
# np.save("FIDELITY_EPL" + str(a0) + ".npy", fidelity)
np.save(name_time, times)
############################################
# plt.plot(times[indices_sorted], fidelity[indices_sorted], "k.")
# if ignore_number != 0:
# vline = np.linspace(min(fidelity), max(fidelity))
# o = np.ones_like(vline)*(t_max)
# plt.plot(o, vline, 'r--')
#
# plt.ylabel(r"Fidelity", fontsize=17)
# plt.xlabel(r"Time (seg)", fontsize=17)
ylab = rhoLis[np.clip(np.int_((xlab - eMin)/binSize), 0, 47)]
plt.plot(xlab, ylab)
"""
# Normalized Energy Spacing
grp = 4
per = 0.1 * nEigs
half = int(per/2)
spc = []
for j in range(int((nEigs - per)/grp)):
avg = (eigs[half + grp*j] - eigs[half + grp*(j-1)])/grp
for i in range(grp*(j-1), grp*j):
spc.append((eigs[half + i] - eigs[half + i -1])/avg)
binSize = 0.1
spcM = np.max(spc)
dELis = binSize * (np.arange(int(spcM/binSize)) - 1.)
spcLis = np.zeros(len(dELis) - 1)
for i in range(len(dELis) - 1):
spcLis[i] = len([x for x in spc if dELis[i] <= x <= dELis[i+1]])
spcLis = np.array(spcLis)/sum(spcLis * binSize)
xlab = np.linspace(0.,spcM,200)
ylab = spcLis[np.clip(np.int_((xlab)/binSize), 0, len(spcLis) - 1)]
wiglab = np.pi * xlab/2. * np.exp(-np.pi * xlab**2 /4.)
poilab = np.exp(- xlab)
fig, ax = plt.subplots(figsize = (10,6))
ax.plot(xlab, ylab, label = "Energy Spacing")
ax.plot(xlab, wiglab, label = "Wigner-like Spacing")
ax.plot(xlab, poilab, label = "Poisson-like Spacing")
quantum.qsave()
imrhoVVTekk=0.5*((LDVVT-LAVVT-RDVVT+RAVVT)+(DLVVT-DRVVT-ALVVT+ARVVT))/normconstant
rerhoHHTekkCorrection=rerhoHHTekkComplete-rerhoHHTekk
imrhoHHTekkCorrection=imrhoHHTekkComplete-imrhoHHTekk
rerhoHVTekkCorrection=rerhoHVTekkComplete-rerhoHVTekk
imrhoHVTekkCorrection=imrhoHVTekkComplete-imrhoHVTekk
rerhoVHTekkCorrection=rerhoVHTekkComplete-rerhoVHTekk
imrhoVHTekkCorrection=imrhoVHTekkComplete-imrhoVHTekk
rerhoVVTekkCorrection=rerhoVVTekkComplete-rerhoVVTekk
imrhoVVTekkCorrection=imrhoVVTekkComplete-imrhoVVTekk
resultTekkComplete=qutip.Qobj([[rerhoHHTekkComplete+imrhoHHTekkComplete*1j , rerhoHVTekkComplete+imrhoHVTekkComplete*1j],[rerhoVHTekkComplete+imrhoVHTekkComplete*1j, rerhoVVTekkComplete+imrhoVVTekkComplete*1j]])
resultTekk=qutip.Qobj([[rerhoHHTekk+imrhoHHTekk*1j , rerhoHVTekk+imrhoHVTekk*1j],[rerhoVHTekk+imrhoVHTekk*1j, rerhoVVTekk+imrhoVVTekk*1j]])
resultTekkCorrection=qutip.Qobj([[rerhoHHTekkCorrection+imrhoHHTekkCorrection*1j , rerhoHVTekkCorrection+imrhoHVTekkCorrection*1j],[rerhoVHTekkCorrection+imrhoVHTekkCorrection*1j, rerhoVVTekkCorrection+imrhoVVTekkCorrection*1j]])
#save qobjs
qutip.qsave([resultQST, resultDirac, resultTwoAnc, resultTekkComplete, resultTekk, resultTekkCorrection], outputfilename[:-4])
#output of final results
print("Final result")
print("rawResultQST = ", rawResultQST)
print("resultQST = ", resultQST)
print("resultDirac = ", resultDirac)
print("resultTwoAnc = ", resultTwoAnc)
print("resultTekkComplete = ", resultTekkComplete)
print("resultTekk = ", resultTekk)
print("resultTekkCorrection = ", resultTekkCorrection)
print("Final result", file = outputFile)
print("rawResultQST = ", rawResultQST, file = outputFile)
print("resultQST = ", resultQST, file = outputFile)
print("resultDirac = ", resultDirac, file = outputFile)
def save_results(self):
# Only save the file if we have a place to save it.
if self.savefile:
print('Saving MBSolve to', self.savefile + '.qu')
qu.qsave((self.Omegas_zt, self.states_zt), self.savefile)
VVVV = measure(rotQWP1Angle0, rotHWP1Angle0, rotQWP2Angle45, rotHWP2Angle315, rotHWPFinAngle45, lcc1Voltage180, lcc2Voltage0)
print("Counts for VVVV = ", VVVV)
print("Counts for VVVV = ", VVVV, file = outputFile)
resultdata.update({"VVVV": VVVV})
normconstant=4*(VVHH+VVVV)/(np.sin(np.radians(strengthA))**2 * np.sin(np.radians(strengthB))**2)
rhoHHTwoAnc=4*VVHH/normconstant/(np.sin(np.radians(strengthA))**2 * np.sin(np.radians(strengthB))**2)
rhoVVTwoAnc=4*VVVV/normconstant/(np.sin(np.radians(strengthA))**2 * np.sin(np.radians(strengthB))**2)
rerhoHVTwoAnc=strSignA*(RLHV+LRHV-RRHV-LLHV)/normconstant/(np.sin(np.radians(strengthA)) * np.sin(np.radians(strengthB)))
imrhoHVTwoAnc=strSignA*(DLHV-DRHV+ARHV-ALHV)/normconstant/(np.sin(np.radians(strengthA)) * np.sin(np.radians(strengthB)))
rerhoVHTwoAnc=strSignA*(RLVH+LRVH-RRVH-LLVH)/normconstant/(np.sin(np.radians(strengthA)) * np.sin(np.radians(strengthB)))
imrhoVHTwoAnc=strSignA*(DLVH-DRVH+ARVH-ALVH)/normconstant/(np.sin(np.radians(strengthA)) * np.sin(np.radians(strengthB)))
resultTwoAnc=qutip.Qobj([[rhoHHTwoAnc , rerhoHVTwoAnc+imrhoHVTwoAnc*1j],[rerhoVHTwoAnc+imrhoVHTwoAnc*1j, rhoVVTwoAnc]])
qutip.qsave([resultTwoAnc], outputfilename[:-4])
#output of final results
print("Final result")
print("Result = ", resultTwoAnc)
print("The following results are obtained using the diagonal measurements for normalization", file = outputFile)
print("Corrected normalization constant = {0}".format(normconstant), file = outputFile)
print("rhoHH = {0}".format(rhoHHTwoAnc), file = outputFile)
print("\nrhoVV = {0}".format(rhoVVTwoAnc), file = outputFile)
print("\nrerhoHV = {0}".format(rerhoHVTwoAnc), file = outputFile)
print("\nimrhoHV = {0}".format(imrhoHVTwoAnc), file = outputFile)
print("\nrerhoVH = {0}".format(rerhoVHTwoAnc), file = outputFile)
print("\nimrhoVH = {0}".format(imrhoVHTwoAnc), file = outputFile)
print("\nresult = ", resultTwoAnc, file = outputFile)
return val**0.5
def funcApiB(t, args=0):
val = complex(i(t))
return val**0.5
A =k2**0.5*(b_tensor**2-1./2*alpha_inf_abs*(a_tensor+alpha_inf_abs*I_tensor))
B =k2**0.5*(1./2*alpha_inf_abs*(a_tensor-alpha_inf_abs*I_tensor))
cops = [k1**0.5*a_tensor,k1**0.5*b_tensor]
cops.append(k2**0.5*(a_tensor**2-alpha_inf_abs**2*I_tensor)) #stabilization control cat
cops.append([A, funcA])
cops.append([B, funcB])
cops.append([A+B, funcApB])
cops.append([A+1j*B, funcApiB])
init_state_C=C_alpha_plus
control_on=True
init_state_T=C_alpha_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())
#np.save(path+'tab_values',res_CNOT.states)
# cannot save the data because it is an array of Quantum objects
name='density_with_loss_k2_over_%d'%(ratio)
qt.qsave(res_CNOT,path+name)
import numpy as np
import sys
import json
import os
import qutip as qt
sys.path.append('..')
ROOT = "/Users/btimar/Code/quantum-data-gen"
sys.path.append(ROOT)
from timeev import generate_xy_states
system_sizes = [2, 4, 6, 8, 10]
times = list(np.linspace(0, .01, 5))
SAVEDIR = "/Users/btimar/Dropbox/data/states/qutip/timeev/generate_timeev_states_001"
settings = {'model': 'xy', 'system_sizes': system_sizes, 'times': times}
with open(os.path.join(SAVEDIR, 'settings.json'), 'w') as f:
json.dump(settings, f)
for L in system_sizes:
states = generate_xy_states(L, times).states
for i in range(len(states)):
qt.qsave(
states[i],
os.path.join(SAVEDIR, 'xy_timeev_L={0}_tindex={1}'.format(L, i)))
rerhoVVCorrection = rerhoVV-rerhoVVTekk
imrhoVV=0.5*((CLDVV-CLAVV-CRDVV+CRAVV)+(CDLVV-CDRVV-CALVV+CARVV)+2*(CLVVV-CRVVV))/normconstant
imrhoVVTekk=0.5*((CLDVV-CLAVV-CRDVV+CRAVV)+(CDLVV-CDRVV-CALVV+CARVV))/normconstant
imrhoVVCorrection = imrhoVV-imrhoVVTekk
result=qutip.Qobj([[rerhoHH+imrhoHH*1j , rerhoHV+imrhoHV*1j],[rerhoVH+imrhoVH*1j, rerhoVV+imrhoVV*1j]])
resquad=result**2
purity= resquad.tr()
resultTekk=qutip.Qobj([[rerhoHHTekk+imrhoHHTekk*1j , rerhoHVTekk+imrhoHVTekk*1j],[rerhoVHTekk+imrhoVHTekk*1j, rerhoVVTekk+imrhoVVTekk*1j]])
resquadTekk=result**2
purityTekk= resquad.tr()
resultCorrection=qutip.Qobj([[rerhoHHCorrection+imrhoHHCorrection*1j , rerhoHVCorrection+imrhoHVCorrection*1j],[rerhoVHCorrection+imrhoVHCorrection*1j, rerhoVVCorrection+imrhoVVCorrection*1j]])
#save qobjs
qutip.qsave([result, resquad, resultTekk, resquadTekk, resultCorrection], outputfilename[:-4])
jsonfilename=outputfilename[:-4]+".json"
with open(jsonfilename, 'w') as outfile:
json.dump(resultdata, outfile)
#output of final results
print("Final result")
print("Result = ", result)
print("Resquad = ", resquad)
print("Purity (as trace of resquad) = ", purity)
print("ResultTekk = ", resultTekk)
print("ResquadTekk = ", resquadTekk)
print("Purity (as trace of resquad) = ", purityTekk)
print("Correction = ", resultCorrection)
normconstant= QSTH+QSTV
rhoHHQST=QSTH/normconstant
rhoVVQST=QSTV/normconstant
rerhoHVQST=strSignA*0.5*(QSTD-QSTA)/(QSTD+QSTA)
imrhoHVQST=strSignA*0.5*(QSTR-QSTL)/(QSTR+QSTL)
rerhoVHQST=rerhoHVQST
imrhoVHQST=-imrhoHVQST
rawresult=qutip.Qobj([[rhoHHQST , rerhoHVQST+imrhoHVQST*1j],[rerhoVHQST+imrhoVHQST*1j, rhoVVQST]])
correction = qutip.Qobj([[1,0],[0,-1]])
result=correction.dag()*rawresult*correction
#save qobjs
qutip.qsave([result, rawresult], outputfilename[:-4])
#output of final results
print("Final results")
print("Raw result = ", rawresult)
print("Corrected result = ", result)
print("Final results", file=outputFile)
print("Raw result = ", rawresult, file=outputFile)
print("Corrected result = ", result, file=outputFile)
stoptime=datetime.datetime.now()
resultdata.update({ "StartTime":str(starttime), "StopTime":str(stoptime)})
jsonfilename=outputfilename[:-4]+".json"
with open(jsonfilename, 'w') as outfile:
#useful values
rho10HA = 0.5* (CDHA-CAHA+1.0j*(CLHA-CRHA))/normconstant
rho10VA = 0.5* (CDVA-CAVA+1.0j*(CLVA-CRVA))/normconstant
d=2
rhoHH=(d*rho11HD+ rho10HA+rho10HD )
rhoHV=(rho10HD-rho10HA )
rhoVH=(rho10VD-rho10VA )
rhoVV=(d*rho11VD+ rho10VA+rho10VD )
result=qutip.Qobj([[rhoHH , rhoHV],[rhoVH, rhoVV]])
resquad=result**2
purity= resquad.tr()
#save qobjs
qutip.qsave([result, resquad], outputfilename[:-4])
jsonfilename=outputfilename[:-4]+".json"
with open(jsonfilename, 'w') as outfile:
json.dump(resultdata, outfile)
print("\n\n\n")
print("\n\n\n", file = outputFile)
print("Finished all measurements\n\n")
print("\n\n\n")
print("\n\n\n", file = outputFile)
#output of final results
print("Final result")
print("Measuring QSTD")
QSTD = measure(rotQWP1Angle0, rotHWP1Angle45, rotQWP2Angle45, rotHWP2Angle0, rotHWPFinAngle225, lcc1Voltage180, lcc2Voltage90)
print("Counts for QSTD = ", QSTD)
print("Counts for QSTD = ", QSTD, file = outputFile)
resultdata.update({"QSTD": QSTD})
normconstant= QSTH+QSTV
rhoHHQST=QSTH/normconstant
rhoVVQST=QSTV/normconstant
rerhoHVQST=QSTD/normconstant-0.5
imrhoHVQST=QSTR/normconstant-0.5
rerhoVHQST=rerhoHVQST
imrhoVHQST=-imrhoHVQST
resultQST=qutip.Qobj([[rhoHHQST , rerhoHVQST+imrhoHVQST*1j],[rerhoVHQST+imrhoVHQST*1j, rhoVVQST]])
#save qobjs
qutip.qsave([resultQST], outputfilename[:-4])
#output of final results
print("Final result")
print("Result = ", resultQST)
stoptime=datetime.datetime.now()
resultdata.update({ "StartTime":str(starttime), "StopTime":str(stoptime)})
jsonfilename=outputfilename[:-4]+".json"
with open(jsonfilename, 'w') as outfile:
json.dump(resultdata, outfile)
print("Finished all measurements\n\n")
print("\n\n\n")
print("\n\n\n", file = outputFile)
result=qutip.Qobj([[rhoHH , rerhoHV+imrhoHV*1j],[rerhoVH+imrhoVH*1j, rhoVV]])
resquad=result**2
purity= resquad.tr()
resultscheme=qutip.Qobj([[rhoHHscheme , rerhoHVscheme+imrhoHVscheme*1j],[rerhoVHscheme+imrhoVHscheme*1j, rhoVVscheme]])
resquadscheme=resultscheme**2
purityscheme= resquadscheme.tr()
#save qobjs
qutip.qsave([result, resquad, resultscheme, resquadscheme], outputfilename[:-4])
jsonfilename=outputfilename[:-4]+".json"
with open(jsonfilename, 'w') as outfile:
json.dump(resultdata, outfile)
#output of final results
print("Final result")
print("Result = ", result)
print("Resquad = ", resquad)
print("Purity (as trace of resquad) = ", purity)
print("The following results are obtained using the diagonal measurements for normalization", file = outputFile)
print("Corrected normalization constant = {0}".format(normconstant), file = outputFile)
print("rhoHH = {0}".format(rhoHH), file = outputFile)
print("\nrhoVV = {0}".format(rhoVV), file = outputFile)
'rydberg': rydberg_params,
'heisenberg': heisenberg_params,
'tfim': tfim_params,
'ghz': ghz_params
}
SAVEDIR = "/Users/btimar/Dropbox/data/states/qutip"
def get_state(state_name, system_size):
if state_name == 'ghz':
param_dict = {**params['ghz'], 'L': system_size}
return get_ghz_state(param_dict)
else:
model_name = state_name.split('_')[0]
param_dict = {**params[model_name], 'L': system_size}
return get_ground_state(model_name, param_dict)
with open(os.path.join(SAVEDIR, 'settings.json'), 'w') as f:
settings = dict(params=params,
system_sizes=list(system_sizes),
state_names=state_names)
json.dump(settings, f)
for L in system_sizes:
for state_name in state_names:
print("computing state {0} for system size {1}".format(state_name, L))
psi = get_state(state_name, L)
qt.qsave(psi, os.path.join(SAVEDIR, "{0}_L={1}".format(state_name, L)))
