def __init__(self, capacity, cavity, RWA=True, reduced=True):
self.capacity = capacity
self.cavity = cavity
self.size = 0
HC = {}
size_start = 0
self.states = {}
for c in range(capacity, -1, -1):
print("c=", c)
Hc = H(capacity=c, cavity=cavity, RWA=RWA, reduced=reduced)
HC[c] = Hc
for k, v in Hc.states.items():
self.states[size_start + k] = v
size_start += HC[c].size
self.size += Hc.size
print("_H done")
I = np.zeros([self.size, self.size], dtype=np.complex128)
size_start = 0
for c in range(capacity, -1, -1):
I[size_start:size_start + HC[c].size,
size_start:size_start + HC[c].size] = HC[c].matrix.data
size_start += HC[c].size
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
self.matrix.data = I
def __init__(self, capacity, cavity, RWA=True):
Assert(isinstance(capacity, int), "capacity is not integer", FILE(),
LINE())
Assert(capacity > 0, "capacity <= 0", FILE(), LINE())
Assert(isinstance(cavity, Cavity), "cavity is not Cavity", FILE(),
LINE())
self.capacity = capacity
self.cavity = cavity
self.n = cavity.n
self.get_states()
self.size = len(self.states)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
# ------------------------------------------------------------------------------------------------------------------
H_field = self.get_H_field()
H_atoms = self.get_H_atoms()
H = H_field + H_atoms
if RWA:
H += self.get_H_int_RWA()
else:
H += self.get_H_int_EXACT()
self.matrix.data = np.matrix(H)
def __init__(self, capacity, cavity, RWA=True, reduced=True):
self.capacity = capacity
self.cavity = cavity
print("Hamiltonian naive", capacity)
H_field = get_Hfield(capacity, cavity.n_atoms, cavity.n_levels,
cavity.wc, cavity.wa, cavity.g)
print("get_Hfield", capacity)
H_atoms = get_Hatoms(capacity, cavity.n_atoms, cavity.n_levels,
cavity.wc, cavity.wa, cavity.g)
print("get_Hatoms", capacity)
if RWA:
H_int = get_Hint_RWA(
capacity, cavity.n_atoms, cavity.n_levels, cavity.wc, cavity.wa, cavity.g)
else:
H_int = get_Hint_EXACT(
capacity, cavity.n_atoms, cavity.n_levels, cavity.wc, cavity.wa, cavity.g)
print("get_Hint", capacity)
Assert(np.shape(H_field) == np.shape(H_atoms), "size mismatch", FILE(), LINE())
Assert(np.shape(H_atoms) == np.shape(H_int), "size mismatch", FILE(), LINE())
H = H_field + H_atoms + H_int
# H = lil_matrix(H_field + H_atoms + H_int)
self.size = np.shape(H)[0]
self.matrix = Matrix(self.size, self.size, dtype=np.double)
self.matrix.data = H
at = AtomicBasis(count=cavity.n_atoms, n_levels=cavity.n_levels)
base = Base(capacity, at)
print("at, base", capacity)
self.set_base(base)
print("self.set_base(base)", capacity)
if reduced:
self.reduce()
print("self.reduce()", capacity)
self.set_states()
print("self.set_states()", capacity)
# print(self.states)
# print(self.states)
# self.to_html("H.html")
H = H_Full(capacity, cavity)
def __init__(self, capacity, cavity, RWA=True, reduced=True):
self.capacity = capacity
self.cavity = cavity
self.size = 0
HC = {}
size_start = 0
self.states = {}
for c in range(capacity, -1, -1):
Hc = Hamiltonian(capacity=c,
cavity=cavity,
RWA=RWA,
reduced=reduced)
HC[c] = Hc
for i in Hc.base.base:
# for i in Hc.states.values():
print(i)
print()
for k, v in Hc.states.items():
self.states[size_start + k] = v
size_start += HC[c].size
# self.states += Hc.states
# print(Hc.states)
self.size += Hc.size
# for i in self.states.values():
# print(i)
I = np.zeros([self.size, self.size], dtype=np.complex128)
# print(self.states)
size_start = 0
for c in range(capacity, -1, -1):
# print("c=", c)
# print(HC[c])
# print(HC[c].size)
# print(HC[c].states)
# print(HC[c].matrix.data)
I[size_start:size_start + HC[c].size,
size_start:size_start + HC[c].size] = HC[c].matrix.data
size_start += HC[c].size
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
self.matrix.data = I
def __init__(self, capacity, at_count, wc, wa, g, RWA=True):
H_field = get_Hfield(capacity, at_count, wc, wa, g)
H_field_size = np.shape(H_field)
H_atoms = get_Hatoms(capacity, at_count, wc, wa, g)
H_atoms_size = np.shape(H_atoms)
H_int_RWA = get_Hint_RWA(capacity, at_count, wc, wa, g)
H_int_size = np.shape(H_int_RWA)
H = np.matrix(H_field + H_atoms + H_int_RWA)
self.size = np.shape(H)[0]
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
self.matrix.data = H
def __init__(self, capacity, cavity, RWA=True, reduced=True):
self.capacity = capacity
self.cavity = cavity
H_field = get_Hfield(capacity, cavity.n_atoms, cavity.n_levels,
cavity.wc, cavity.wa, cavity.g)
H_atoms = get_Hatoms(capacity, cavity.n_atoms, cavity.n_levels,
cavity.wc, cavity.wa, cavity.g)
if RWA:
H_int = get_Hint_RWA(capacity, cavity.n_atoms, cavity.n_levels,
cavity.wc, cavity.wa, cavity.g)
else:
H_int = get_Hint_EXACT(capacity, cavity.n_atoms, cavity.n_levels,
cavity.wc, cavity.wa, cavity.g)
Assert(np.shape(H_field) == np.shape(H_atoms), "size mismatch", cf())
Assert(np.shape(H_atoms) == np.shape(H_int), "size mismatch", cf())
H = np.matrix(H_field + H_atoms + H_int)
self.size = np.shape(H)[0]
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
self.matrix.data = H
at = AtomicBasis(count=cavity.n_atoms, n_levels=cavity.n_levels)
base = Base(capacity, at)
self.set_base(base)
if reduced:
self.reduce()
# print(self.matrix.data)
# exit(1)
self.set_states()
def __init__(self, capacity, cavity):
Assert(isinstance(capacity, int), "capacity is not integer", FILE(), LINE())
Assert(capacity >= 0, "capacity <= 0", FILE(), LINE())
print("Hamiltonian", capacity)
# Assert(isinstance(cavity, "BipartiteGeneral.Cavity.Cavity"), "capacity is not integer", FILE(), LINE())
self.capacity = capacity
self.cavity = cavity
self.n_atoms = cavity.n_atoms
self.wc = cavity.wc
self.wa = cavity.wa
self.g = cavity.g
self.n_levels = cavity.n_levels
self.states = self.get_states()
self.get_states_bin()
self.size = len(self.states)
self.matrix = Matrix(self.size, self.size, dtype=np.longdouble)
for i in range(self.size):
i_state = self.states[i]
i_ph = i_state[0]
i_at = i_state[1]
for j in range(self.size):
j_state = self.states[j]
j_ph = j_state[0]
j_at = j_state[1]
if i_state == j_state:
self.matrix.data[i, j] = self.wc * i_ph
for n_ in range(len(i_at)):
if i_at[n_] != 0:
# print(i, j, i_at[n_], self.wa * i_at[n_])
self.matrix.data[i, j] += self.wa * i_at[n_]
# self.matrix.data[i, j] += self.wa[n_] * i_at[n_]
else:
d_ph = j_ph - i_ph
if abs(d_ph) == 1:
diff_at_cnt = 0
for n_ in range(len(i_at)):
d_at = j_at[n_] - i_at[n_]
if d_ph + d_at == 0:
diff_at_cnt += 1
diff_at_num = n_
elif d_at != 0:
diff_at_cnt = 0
break
if diff_at_cnt > 1:
break
if diff_at_cnt == 1:
if d_ph > 0:
k = a_cross(i_ph) * i_at[diff_at_num]
self.matrix.data[i,
j] = self.g * k
else:
k = a_cross(j_ph) * j_at[diff_at_num]
self.matrix.data[i,
# j] = self.g[diff_at_num] * k
j] = self.g * k
# self.matrix.check_hermiticity()
return
def __init__(self, capacity, cavity):
Assert(isinstance(capacity, int), "capacity is not integer", cf())
Assert(capacity > 0, "capacity <= 0", cf())
# Assert(isinstance(cavity, "BipartiteGeneral.Cavity.Cavity"), "capacity is not integer", cf())
self.capacity = capacity
self.cavity = cavity
self.n = cavity.n
self.wc = cavity.wc
self.wa = cavity.wa
self.g = cavity.g
self.states = self.get_states()
self.size = len(self.states)
# print(len(self.states))
# exit(1)
self.get_states_bin()
# self.print_bin_states()
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
# self.matrix_html = np.empty([self.size, self.size], dtype=">U900")
for i in range(self.size):
i_state = self.states[i]
i_ph = i_state[0]
i_at = i_state[1]
for j in range(self.size):
j_state = self.states[j]
j_ph = j_state[0]
j_at = j_state[1]
if i_state == j_state:
self.matrix.data[i, j] = self.wc * i_ph
# self.matrix_html[i][j] += "wc" + DOT() + str(i_ph) + " "
for n_ in range(len(i_at)):
self.matrix.data[i, j] += self.wa[n_] * i_at[n_]
# self.matrix_html[i][j] += "wa" + SUB(n_) + DOT() + str(i_at[n_]) + " "
else:
d_ph = j_ph - i_ph
if abs(d_ph) == 1:
diff_at_cnt = 0
for n_ in range(len(i_at)):
d_at = j_at[n_] - i_at[n_]
if d_ph + d_at == 0:
diff_at_cnt += 1
diff_at_num = n_
elif d_at != 0:
diff_at_cnt = 0
break
if diff_at_cnt > 1:
break
if diff_at_cnt == 1:
if d_ph > 0:
k = a_cross(i_ph) * i_at[diff_at_num]
self.matrix.data[i,
j] = self.g[diff_at_num] * k
else:
k = a_cross(j_ph) * j_at[diff_at_num]
self.matrix.data[i,
j] = self.g[diff_at_num] * k
# k = a_cross(i_ph) * i_at[diff_at_num]
# self.matrix.data[i, j] = self.g[diff_at_num]
self.matrix.check_hermiticity()
return
alpha = complex(1.0 / sqrt(3), 0)
beta = complex(sqrt(2) / sqrt(3), 0)
# beta = complex(1.0 / sqrt(2), 0)
ro_0 = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0],
[0, 0, abs(alpha)**2, alpha * beta.conjugate(), 0],
[0, 0, beta * alpha.conjugate(),
abs(beta)**2, 0], [0, 0, 0, 0, 0]]
# for i in ro_0:
# print(i)
_a = [[0, 0, 1, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
a = Matrix(m=len(_a), n=len(_a), dtype=np.complex128)
a.data = csc_matrix(_a)
across = Matrix(m=len(_a), n=len(_a), dtype=np.complex128)
across.data = a.data.getH()
# ro_t = copy.deepcopy(ro_0)
# ro_t = Matrix(m=len(ro_0), n=len(ro_0), dtype=np.complex128)
# ro_t.data = csc_matrix(ro_0)
# config.l = 0.01*config.g
dt = 0.1 * 1e-9
# dt = 0.01 / config.l
config.l = 1.0 / dt
# print('n_atoms', n_atoms)
for n_levels in range(N_LEVELS_1, N_LEVELS_2 + 1):
# print('n_levels', n_levels)
for i in range(n_levels):
# print('i', i, end='')
for j in range(i):
# print('j', j)
for i_atom in range(1, n_atoms + 1):
s = op.Sigma2(i_=i,
j_=j,
num=i_atom,
n_atoms=n_atoms,
n_levels=n_levels)
# filename = 'dark_dense/' + '_'.join(str(i)
# for i in [n_atoms, n_levels, i, j, i_atom]) + '.csv'
# print(filename)
m = Matrix(m=np.shape(s)[0], n=np.shape(s)[0], dtype=float)
# print(s)
m.data = s.todense()
m.to_csv('dark_dense/' + '_'.join(
str(i)
for i in [n_atoms, n_levels, i, j, i_atom]) + '.csv',
precision=0)
# for p in s.todense():
# print(p)
def __init__(self, capacity, cavity):
Assert(isinstance(capacity, int), "capacity is not integer", cf())
Assert(capacity > 0, "capacity <= 0", cf())
# Assert(isinstance(cavity, "BipartiteGeneral.Cavity.Cavity"), "capacity is not integer", cf())
self.capacity = capacity
self.cavity = cavity
self.n = cavity.n
self.wc = cavity.wc
self.wa = cavity.wa
self.g = cavity.g
self.states = self.get_states()
self.get_states_bin()
# self.print_states()
self.size = len(self.states)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
# self.matrix_html = np.empty([self.size, self.size], dtype=">U900")
for i in range(self.size):
i_state = self.states[i]
i_ph = i_state[0]
i_at = i_state[1]
for j in range(self.size):
j_state = self.states[j]
j_ph = j_state[0]
j_at = j_state[1]
# self.matrix_html[i, j] = ""
if i_state == j_state:
self.matrix.data[i, j] = self.wc * i_ph
# if(self.matrix_html[i][j] != ""):
# self.matrix_html[i][j] += "+"
# self.matrix_html[i][j] += "wc" + DOT() + str(i_ph) + " "
for n_ in range(len(i_at)):
if i_at[n_] != 0:
self.matrix.data[i, j] += self.wa[n_] * i_at[n_]
# if(self.matrix_html[i][j] != ""):
# self.matrix_html[i][j] += "+"
# self.matrix_html[i][j] += "wa" + SUB(n_) + DOT() + str(i_at[n_]) + " "
else:
d_ph = j_ph - i_ph
if abs(d_ph) == 1:
diff_at_cnt = 0
for n_ in range(len(i_at)):
d_at = j_at[n_] - i_at[n_]
if d_ph + d_at == 0:
diff_at_cnt += 1
diff_at_num = n_
elif d_at != 0:
diff_at_cnt = 0
break
if diff_at_cnt > 1:
break
if diff_at_cnt == 1:
if d_ph > 0:
k = a_cross(i_ph) * i_at[diff_at_num]
self.matrix.data[i,
j] = self.g[diff_at_num] * k
# self.matrix_html[i][j] = "g" + SUB(diff_at_num) + DOT() + A_CROSS(i_ph) + \
# """<math display="block"><mrow><msqrt><mn> · """ + \
# A_CROSS(i_ph) + """</mn></msqrt><mo>=</mo></mrow></math>"""
else:
k = a_cross(j_ph) * j_at[diff_at_num]
self.matrix.data[i,
j] = self.g[diff_at_num] * k
# self.matrix_html[i][j] = "g" + SUB(diff_at_num) + DOT() + A_CROSS(j_ph)
self.matrix.check_hermiticity()
return
def __init__(self, capacity, cavity):
self.cavity = cavity
self.states = {}
count = 0
self.capacity = capacity
M = capacity
self.n = n = cavity.n
wc = cavity.wc
wa = cavity.wa
g = cavity.g
self.DIME = []
self.H_dims = {}
# ---------------------------------------
for I in range(M, -1, -1):
_min = min(I, n)
dime = (_min + 1)**2
self.DIME.append(dime)
# for I in range(M, -1, -1):
# _min = min(I, n)
# count = 0
# for i1 in range(0, _min + 1):
# for i2 in range(0, min(n, I - i1) + 1):
# count += 1
# self.DIME.append(count)
self.size = np.sum(self.DIME)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
d = 0
for I in range(M, -1, -1):
i = 1
COUNT = count
for i1 in range(0, min(I, n) + 1):
for i2 in range(0, min(n, I - i1) + 1):
j = 1
self.states[count] = [I - i1 - i2, i1, i2]
for j1 in range(0, min(I, n) + 1):
for j2 in range(0, min(n, I - j1) + 1):
if i1 != j1:
p = [i1, j1]
elif i2 != j2:
p = [i2, j2]
else:
p = [1, 2]
mi = min(p[0], p[1])
kappa = sqrt((n - mi) * (mi + 1))
count += (i == j)
if abs(i1 - j1) + abs(i2 - j2) == 1:
self.matrix.data[
COUNT + i - 1, COUNT + j - 1] = g * sqrt(
max(I - i1 - i2, I - j1 - j2)) * kappa
elif abs(i1 - j1) + abs(i2 - j2) == 0:
self.matrix.data[
COUNT + i - 1, COUNT + j -
1] = (I - (i1 + i2)) * wc + (i1 + i2) * wa
else:
self.matrix.data[COUNT + i - 1,
COUNT + j - 1] = 0
j += 1
i += 1
self.matrix.data = self.matrix.data[0:count, 0:count]
self.data = self.matrix.data
self.size = np.shape(self.matrix.data)[0]
self.matrix.m = self.matrix.n = self.size
def __init__(self, capacity, cv_chain, RWA, mu):
Assert(isinstance(capacity, int), "capacity is not integer", cf())
Assert(capacity > 0, "capacity <= 0", cf())
Assert(isinstance(cv_chain, CavityChain),
"cv_chain is not CavityChain", cf())
# for cv in cavities:
# Assert(isinstance(cv_chain, CavityChain),
# "cavity is not Cavity", cf())
self.capacity = capacity
self.cv_chain = cv_chain
# self.n = cavity.n
self.get_states()
self.size = len(self.states)
# print("size =", self.size)
# exit(0)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
self.matrix_symb = Matrix(self.size, self.size, dtype=str)
for i in range(self.size):
i_state = self.states[i]
for j in range(self.size):
j_state = self.states[j]
if i == j:
self.diag(i, j)
else:
# # jump
ne_cv = []
ne_cnt = 0
for cv in range(0, len(self.cv_chain.cavities)):
if i_state[cv] != j_state[cv]:
ne_cnt += 1
if ne_cnt > 2:
break
ne_cv.append(cv)
if ne_cnt == 2:
d_ph_i = i_state[ne_cv[0]][0] - \
i_state[ne_cv[1]][0]
d_ph_j = j_state[ne_cv[0]][0] - \
j_state[ne_cv[1]][0]
if abs(d_ph_i) == 1 and d_ph_i == - d_ph_j \
and np.all(i_state[ne_cv[0]][1] == j_state[ne_cv[1]][1]):
# print(self.states[i], self.states[j])
# exit(0)
self.matrix.data[i, j] = mu
self.matrix_symb.data[i, j] = 'mu'
continue
elif ne_cnt == 1:
# g
at_i = i_state[ne_cv[0]][1]
at_j = j_state[ne_cv[0]][1]
ne_at_cnt = 0
ne_at_ind = []
for at_ind in range(0, len(at_i)):
if at_i[at_ind] != at_j[at_ind]:
ne_at_ind.append(at_ind)
ne_at_cnt += 1
ne_at = at_ind
if ne_at_cnt > 2:
break
if ne_at_cnt == 2:
if at_i[ne_at_ind[0]] ^ at_i[ne_at_ind[1]]:
# print(at_i, at_j)
self.matrix.data[i, j] = self.cv_chain.cavity(
ne_cv[0]).g
self.matrix_symb.data[i,
j] = 'g' + str(ne_cv[0] +
1)
continue
self.matrix_symb.data[i, j] = '0'
def __init__(self, capacity, cavity):
Assert(isinstance(cavity, Cavity), "cavity is not Cavity", cf())
Assert(isinstance(capacity, int), "capacity is not int", cf())
Assert(capacity > 0, "capacity <=0", cf())
self.cavity = cavity
self.D = {}
# ------------
n = cavity.n
wc = cavity.wc
wa = cavity.wa
g = cavity.g
# ------------
_min = min(capacity, n)
self.states = {}
# ---------------------------------------
self.init_states(capacity, n)
# ---------------------------------------
self.size = len(self.states)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
i = 1
for i1 in range(0, _min + 1):
for i2 in range(0, min(n, capacity - i1) + 1):
j = 1
for j1 in range(0, _min + 1):
for j2 in range(0, min(n, capacity - j1) + 1):
if i1 != j1:
p = [i1, j1]
elif i2 != j2:
p = [i2, j2]
else:
p = [1, 2]
mi = min(p[0], p[1])
kappa = sqrt((n - mi) * (mi + 1))
if abs(i1 - j1) + abs(i2 - j2) == 1:
_max = max(capacity - i1 - i2, capacity - j1 - j2)
self.matrix.data[i - 1, j - 1] = g * \
sqrt(max(capacity - i1 - i2,
capacity - j1 - j2)) * kappa
elif abs(i1 - j1) + abs(i2 - j2) == 0:
self.matrix.data[
i - 1,
j - 1] = (capacity -
(i1 + i2)) * wc + (i1 + i2) * wa
else:
self.matrix.data[i - 1, j - 1] = 0
j += 1
i += 1
