Homec4science
Diffusion BosonicCodes (master) Browse

R10106/upb.py
22796502c783master

Last Change
Raw File

upb.py
View Options

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Apr 9 17:51:44 2020
@author: ddavidsgl
Unconventional photon blockade with three cavities and x-Kerr?
"""
import qutip
import numpy as np
from hm import hamiltonian, a_tensor_list
from scipy.optimize import shgo
""""
Indexing of the cavities:
0 <-> 1 <-> 2
"""
f = 0.1
Nmodes = 3
aa = np.array(a_tensor_list(Nmodes = 3, Nmax = 4), dtype = qutip.Qobj)
def g2(coeffs, rho):
"""
calculate g2 based on the the given density matrix and output mixing coeffs
"""
c = coeffs.reshape((Nmodes, 2))
c = c[:,0] + 1j * c[:,1]
a_mixed = sum(aa * c)
G2 = qutip.expect(a_mixed.dag()*a_mixed.dag()*a_mixed*a_mixed, rho)
n = qutip.expect(a_mixed.dag()*a_mixed, rho)
# qutip.coherence_function_g2(H = h, state0 = rho, taulist = [0],
# cops = aa, a_op = sum(aa * coeffs))[0]
try:
res = abs(G2/n**2)
except ZeroDivisionError:
res = np.inf
return res
# def dummy(args, rho_ss):
# print('kwargs')
# print(rho_ss.dims)
# print('exiting')
# exit
def constraint(w):
"define constraints for the absolut values of the mixing coeffs"
return sum(abs(w)**2) - 1 # returns zero if constraint is satisfied
def minimizing_function(delta, u_xkerr):
k = np.array([[0. , -u_xkerr, 0.],
[0. , 0., -u_xkerr],
[0. , 0., 0. ]])
print("delta: ", delta, " cross-Kerr: ", u_xkerr)
# construct hamiltonian
h = hamiltonian([delta]*3, U=0, K=k, J=0, F = [f]*3, Nmodes = 3, Nmax = 4)
rho_ss, info = qutip.steadystate(h, aa, solver='mkl', return_info = True)
# initial random mixing of modes
x0 = np.random.uniform(-1, 1, (Nmodes * 2))
x0/= np.sqrt(sum(abs(x0)**2))
optimizer_args = {'method':'SLSQP','options':{'disp': True},'args':[rho_ss],
'constraints' : {"type":"eq", "fun": constraint}}
bounds = list(zip(-np.ones(2*Nmodes), np.ones(2*Nmodes)))
res = shgo(g2, bounds, args = [rho_ss],
constraints = {"type":"eq", "fun": constraint}, iters = 3,
minimizer_kwargs = optimizer_args)#, options = {'disp' : True,
# 'minimize_every_iter' : True, 'symmetry': False})
# res = basinhopping(error_fidelity, x0 = x0, niter = 15,
# minimizer_kwargs = optimizer_args, disp = True)
c = res.x.reshape((Nmodes, 2))
c = c[:,0] + 1j * c[:,1]
a_mixed = sum(aa * c)
n_out_opt = qutip.expect(a_mixed.dag() * a_mixed, rho_ss)
n1 = qutip.expect(aa[0].dag() * aa[0], rho_ss)
n2 = qutip.expect(aa[1].dag() * aa[1], rho_ss)
print("opt g2: ", res.fun)
print("opt n_out: ", n_out_opt)
return delta, u_xkerr, res.x, res.fun, n_out_opt.real, n1.real, n2.real
UcK = np.logspace(-6, 4, 200)
Delta = np.linspace(-10, 10, 200)
n_out = np.zeros((200, 200))
g2_opt = np.zeros((200, 200))
for i, d in enumerate(Delta):
for j, u in enumerate(UcK):
opt = minimizing_function(d, u)
n_out[i,j] = opt[4]
g2_opt[i,j] = opt[3]
import pickle
res = {'Delta': Delta, 'UcK': UcK, 'n_out': n_out, 'g2_opt': g2_opt}
with open('upb_out.p', 'wb') as f:
pickle.dump(res, f)
c4science · Help