def __init__(self, states, init_state=None, amplitude=1):
Assert(isinstance(states, dict), "states is not dict", cf())
Assert(len(states) > 1, "w_0 is not set", cf())
self.states = states
super(WaveFunction, self).__init__(m=len(states),
n=1,
dtype=np.complex128)
if init_state is None:
return
Assert(isinstance(init_state, list), "init_state is not list", cf())
k_found = None
for k, v in states.items():
if init_state == v:
k_found = k
break
Assert(k_found, "w_0 is not set", cf())
super(WaveFunction, self).__init__(m=len(states),
n=1,
dtype=np.complex128)
self.data[k_found] = amplitude
def set_ampl(self, state, amplitude=1):
k_found = None
for k, v in self.states.items():
if state == v:
k_found = k
break
Assert(k_found is not None, "w_0 is not set", cf())
self.data[k_found] = amplitude
def check_states(self):
try:
Assert(len(self.states) > 0, "len(states) <= 0", cf())
for state in self.states.values():
ph = state[0]
at = state[1]
Assert(0 <= ph <= self.capacity,
"incorrect state " + str(state), cf())
Assert(ph + np.sum(at) == self.capacity,
"incorrect state " + str(state), cf())
for n_ in range(len(at)):
Assert(0 <= at[n_] <= 1, "incorrect state " + str(state),
cf())
except:
print_error("incorrect states generation", cf())
exit(1)
return
def __init__(self, n, wc, wa, g):
Assert(isinstance(n, int), "n is not integer", cf())
Assert(isinstance(wc, (int, float)), "wc is not numeric", cf())
Assert(isinstance(wa, (int, float)), "wa is not numeric", cf())
Assert(isinstance(g, (int, float)), "g is not numeric", cf())
Assert(n > 0, "n <= 0", cf())
Assert(wc > 0, "wc <= 0", cf())
Assert(wa > 0, "wa <= 0", cf())
Assert(g > 0, "g <= 0", cf())
self.n = n
self.wc = wc
self.wa = wa
self.g = g
def normalize(self):
norm = np.linalg.norm(self.data)
Assert(norm > 0, "norm <= 0", cf())
self.data /= norm
def __init__(self, capacity, cavity, mu):
Assert(isinstance(capacity, int), "capacity is not integer", cf())
Assert(capacity > 0, "capacity <= 0", cf())
Assert(isinstance(cavity, list), "capacity is not list", cf())
for _ in range(len(cavity)):
Assert(isinstance(cavity[_], Cavity), "is not cavity", cf())
self.capacity = capacity
self.cavity = cavity
self.n = []
self.wc = []
self.wa = []
self.g = []
for i in range(len(cavity)):
self.n.append(cavity[i].n)
self.wc.append(cavity[i].wc)
self.wa.append(cavity[i].wa)
self.g.append(cavity[i].g)
self.mu = mu
self.states = self.get_states()
self.get_states_bin()
# print(self.states)
# exit(1)
self.size = len(self.states)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
for i in range(self.size):
i_state = self.states[i]
i_ph = []
i_at = []
i_ph.append(i_state[0][0])
i_at.append(i_state[0][1])
i_ph.append(i_state[1][0])
i_at.append(i_state[1][1])
for j in range(self.size):
j_state = self.states[j]
j_ph = []
j_at = []
j_ph.append(j_state[0][0])
j_at.append(j_state[0][1])
j_ph.append(j_state[1][0])
j_at.append(j_state[1][1])
if i_state == j_state:
for _ in range(len(cavity)):
self.matrix.data[i, j] += self.wc[_] * i_ph[_]
for n_ in range(self.n[_]):
self.matrix.data[i,
j] += self.wa[_][n_] * i_at[_][n_]
else:
diff_cv = 0
for cv_ in range(2):
if i_state[cv_] != j_state[cv_]:
diff_cv += 1
cv = cv_
if diff_cv == 1:
d_ph = j_ph[cv] - i_ph[cv]
if abs(d_ph) == 1:
diff_at_cnt = 0
for n_ in range(len(i_at[cv])):
d_at = j_at[cv][n_] - i_at[cv][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:
self.matrix.data[i, j] = self.g[cv][diff_at_num] * \
sqrt(max(i_ph[cv], j_ph[cv]))
# print(self.states[i], '->', self.states[j], self.matrix.data[i, j])
else:
d_ph_0 = j_ph[0] - i_ph[0]
d_ph_1 = j_ph[1] - i_ph[1]
if abs(d_ph_0) == 1 and (d_ph_1 + d_ph_0 == 0):
if i_at[0] == j_at[0] and i_at[1] == j_at[1]:
if j_ph[0] > i_ph[0]:
self.matrix.data[i, j] += mu * \
a_plus(i_ph[0]) * a_minus(i_ph[1])
else:
self.matrix.data[i, j] += mu * \
a_plus(i_ph[1]) * a_minus(i_ph[0])
# print(self.states[i], '->', self.states[j], self.matrix.data[i, j])
# for i in range(self.size):
# for j in range(self.size):
# if self.matrix.data[i, j] != self.matrix.data[j, i]:
# print(self.states[i], self.states[j], self.matrix.data[i, j], self.matrix.data[j, i])
self.matrix.check_hermiticity()
return
def __init__(self, capacity, cavities, links, RWA=True):
# -------------------------------------------------
# < AssertION
Assert(isinstance(capacity, int), 'capacity is not int', cf())
Assert(capacity > 0, 'capacity <= 0', cf())
# Assert(isinstance(cv1, Cavity), 'cv1 is not Cavity')
# Assert(isinstance(cv2, Cavity), 'cv2 is not Cavity')
# Assert(isinstance(m, (int, float)), 'm is not real')
# > AssertION
# -------------------------------------------------
self.capacity = capacity
cv = self.cavities = cavities
ln = self.links = links
self.states = self.get_statesFull()
# -------------------------------------------------
self.size = len(self.states)
self.matrix = Matrix(self.size, self.size, dtype=np.complex128)
# ---------------------------------------
max_n = 0
for i in cv:
max_n = max(i.n, max_n)
# ---------------------------------------
cnk = Cnk(max_n)
# ---------------------------------------
cv_cnt = len(cv)
# ---------------------------------------
i_p = np.zeros(cv_cnt, dtype=int)
i_a = np.zeros(cv_cnt, dtype=int)
j_p = np.zeros(cv_cnt, dtype=int)
j_a = np.zeros(cv_cnt, dtype=int)
p = np.zeros(cv_cnt, dtype=int)
a = np.zeros(cv_cnt, dtype=int)
d_p = np.zeros(cv_cnt, dtype=int)
d_a = np.zeros(cv_cnt, dtype=int)
# ---------------------------------------
for i in range(self.size):
# -----------------------------------
i_p.fill(0)
i_a.fill(0)
st_i = self.states[i]
for c in range(cv_cnt):
i_p[c] = st_i[c][0]
if len(st_i[c]) == 2:
i_a[c] = st_i[c][1]
# -----------------------------------
for j in range(self.size):
# -------------------------------
j_p.fill(0)
j_a.fill(0)
st_j = self.states[j]
for c in range(cv_cnt):
j_p[c] = st_j[c][0]
if len(st_j[c]) == 2:
j_a[c] = st_j[c][1]
# -------------------------------
p = np.minimum(i_p, j_p)
a = np.minimum(i_a, j_a)
d_p = j_p - i_p
d_a = j_a - i_a
ne_cv = []
ne = 0
for c in range(cv_cnt):
if st_i[c] != st_j[c]:
ne += 1
ne_cv.append(c)
if ne == 0:
# print(st_i, p, a)
for c in range(cv_cnt):
self.matrix.data[i, j] += cv[c].wc * \
p[c] + cv[c].wa * a[c]
elif ne == 1:
cv_num = ne_cv[0]
if abs(d_p[cv_num]) == 1 and d_p[cv_num] == -d_a[cv_num]:
_g = cv[cv_num].g
_n = cv[cv_num].n
_p = p[cv_num]
_a = a[cv_num]
self.matrix.data[
i, j] = _g * (_n - _a) * sqrt((_p + 1) / (cnk.get(_n, _a) * cnk.get(_n, _a + 1)))
elif ne == 2:
_from = ne_cv[0]
_to = ne_cv[1]
if d_a[_from] == d_a[_to] == 0:
if d_p[_from] == 1 and d_p[_to] == -1 or d_p[_from] == -1 and d_p[_to] == 1:
_k = str(_from) + " <-> " + str(_to)
__k = str(_to) + " <-> " + str(_from)
for k, l in links.items():
if k == _k or k == __k:
if d_p[_to] > d_p[_from]:
self.matrix.data[i, j] = l * \
a_plus(i_p[_to]) * \
a_minus(i_p[_from])
else:
self.matrix.data[i, j] = l * \
a_plus(i_p[_from]) * \
a_minus(i_p[_to])
# if k == _k or k == __k:
# self.matrix.data[i, j] = v
# break
if not self.is_hermitian():
print("Hamiltonian is not hermitian")
exit(1)
self.H = self.matrix.data
#---------------------------------------------------------------------
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.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
