def two_conn_max(k, q, band1, band2):
qmk = q - k
ek, tmp = GLSW.eigensystem(k)
eqmk, tmp = GLSW.eigensystem(qmk)
funval = -(ek[band1] + eqmk[band2])
return funval
def integrand_decay(ndim, xx, ncopm, ff, userdata):
"""
Integrand passed to cuba.
Parameters
----------
ndim : int
dimension of integration.
xx : np.array((3, ))
input momentum.
ncopm : int
number of components.
ff : np.array()
integrand.
userdata : c-type
I don't know how to use this for python. try to avoid it
Returns
-------
int
value not relevent unless -999, see mannual.
"""
# integration variable: k
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
qmk = q - k
ek, ubov_k = GLSW.eigensystem(k)
eqmk, ubov_qmk = GLSW.eigensystem(qmk)
tmp, ubov_mk = GLSW.eigensystem(-k)
tmp, ubov_mqmk = GLSW.eigensystem(-qmk)
tmpmat1 = ek[:2 * num_sub][:, None]
tmpmat2 = eqmk[:2 * num_sub][None, :]
esum = tmpmat1 + tmpmat2
#denomin = eq[:2*num_sub, None, None] - esum[None, :, :] + 1j*cgf
denomin = eq[None, None, :2 * num_sub] - esum[:, :, None] + 1j * cgf
#v_decay = vertex.V_cubic_decay(q, k, qmk, ubov_q, ubov_k, ubov_qmk, \
# ubov_mq, ubov_mk, ubov_mqmk)
v_decay = vertex.V_cubic_decay(k, qmk, q, ubov_k, ubov_qmk, ubov_q, \
ubov_mk, ubov_mqmk, ubov_mq)
Intmat = (v_decay.conj() * v_decay) / denomin
# 0.5 is the symmetry factor, return to the "on-shell" self-energy
# for all bands
Intvec = 0.5 * Intmat.sum(axis=(0, 1))
for band in range(2 * num_sub):
ff[2 * band] = np.real(Intvec[band])
ff[2 * band + 1] = np.imag(Intvec[band])
return 0
def integrand_barN_onsite(ndim, xx, comp, ff, userdata):
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
tmp, ubov = GLSW.eigensystem(k)
ubov11 = ubov[:2 * num_sub, :2 * num_sub]
ubov21 = ubov[2 * num_sub:, :2 * num_sub]
ubov11_c = ubov11.conj()
ubov21_c = ubov21.conj()
for sub_lat in range(num_sub):
counter = 0
for flavor1 in range(2):
for flavor2 in range(2):
X1 = num_sub * flavor1 + sub_lat
X2 = num_sub * flavor2 + sub_lat
# integration of barN_onsite must be real, because
# it corresponds to local boson number reduction
barN_onsite = (ubov21[X1, :] * ubov21_c[X2, :]).sum()
ff[4 * sub_lat + counter] = np.real(barN_onsite)
counter += 1
return 0
def integrand_barDelta_onsite(ndim, xx, comp, ff, userdata):
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
tmp, ubov = GLSW.eigensystem(k)
ubov11 = ubov[:2 * num_sub, :2 * num_sub]
ubov21 = ubov[2 * num_sub:, :2 * num_sub]
ubov11_c = ubov11.conj()
ubov21_c = ubov21.conj()
for sub_lat in range(num_sub):
counter = 0
for flavor1 in range(2):
for flavor2 in range(2):
X1 = num_sub * flavor1 + sub_lat
X2 = num_sub * flavor2 + sub_lat
# integration of Delta_onsite is real
# need to think about the reason
barDelta_onsite = (ubov21[X1, :] * ubov11_c[X2, :]).sum()
ff[4 * sub_lat + counter] = np.real(barDelta_onsite)
counter += 1
return 0
def integrand_N_onsite(ndim, xx, comp, ff, userdata):
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
tmp, ubov = GLSW.eigensystem(k)
ubov11 = ubov[:2 * num_sub, :2 * num_sub]
ubov21 = ubov[2 * num_sub:, :2 * num_sub]
ubov11_c = ubov11.conj()
ubov21_c = ubov21.conj()
for sub_lat in range(num_sub):
counter = 0
for flavor1 in range(2):
for flavor2 in range(2):
X1 = num_sub * flavor1 + sub_lat
X2 = num_sub * flavor2 + sub_lat
# N_onsite is pure real, imaginary part zero
N_onsite = (ubov11[X1, :] * ubov11_c[X2, :]).sum()
ff[4 * sub_lat + counter] = np.real(N_onsite)
counter += 1
return 0
def integrand_N(ndim, xx, comp, ff, userdata):
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
tmp, ubov = GLSW.eigensystem(k)
ubov11 = ubov[:2 * num_sub, :2 * num_sub]
ubov21 = ubov[2 * num_sub:, :2 * num_sub]
ubov11_c = ubov11.conj()
ubov21_c = ubov21.conj()
for bond in range(num_bond):
counter = 0
bond_vec = delta_ij[:, bond]
cphase = np.exp(-1j * 2.0 * np.pi * k @ bond_vec)
sub1 = sub_idx[bond, 0]
sub2 = sub_idx[bond, 1]
for flavor1 in range(2):
for flavor2 in range(2):
X1 = num_sub * flavor1 + sub1
X2 = num_sub * flavor2 + sub2
# N_onsite is pure real, imaginary part zero
N_ij = (ubov11[X1, :] * ubov11_c[X2, :] * cphase).sum()
ff[8 * bond + 2 * counter] = np.real(N_ij)
ff[8 * bond + 2 * counter + 1] = np.imag(N_ij)
counter += 1
return 0
def intensity(omega, qx, qy, qz, selfE_re, selfE_im):
"""
output neutron intensity up to 1/NS order for given qx, qy, and qz
WARNING: ignores H-F corrections (quartic), because they are small!
"""
qq = np.array([qx, qy, qz])
q1, q2, q3 = cf.kxyTok12(qx, qy, qz)
len_omega = len(omega)
q = np.array([q1, q2, q3])
chi_mat = np.zeros((len_omega, 3, 3), dtype=complex)
gf = greenfunction_gnlsw(omega, q, selfE_re, selfE_im)
gf11 = gf[:, :2 * num_sub, :2 * num_sub]
gf12 = gf[:, :2 * num_sub, 2 * num_sub:]
gf21 = gf[:, 2 * num_sub:, :2 * num_sub]
gf22 = gf[:, 2 * num_sub:, 2 * num_sub:]
for sub1 in range(num_sub):
for sub2 in range(num_sub):
for m in range(2):
for mp in range(2):
mat1, mat2, mat3, mat4 = GLSW.int_mat(sub1, sub2, m, mp)
element1 = gf12[:, 4 * m + sub1, 4 * mp + sub2]
element2 = gf21[:, 4 * m + sub1, 4 * mp + sub2]
element3 = gf11[:, 4 * m + sub1, 4 * mp + sub2]
element4 = gf22[:, 4 * m + sub1, 4 * mp + sub2]
chi_mat += (-1/num_sub)\
* (element1[:, None, None]*mat1 + element2[:, None, None]*mat2 \
+ element3[:, None, None]*mat3 + element4[:, None, None]*mat4)
sqw_mat = -2.0 * np.imag(chi_mat)
ff = cf.formfactor(qq)
sc_inten = ff * cf.projector(qx, qy, qz, sqw_mat)
return sc_inten
data_min = np.loadtxt(fname2)
data_max = np.loadtxt(fname3)
lenk = len(data_min[:, 0])
k = np.arange(lenk)
ek = np.zeros((lenk, 2 * num_sub))
for flag in range(lenk):
k1 = data_min[flag, 1]
k2 = data_min[flag, 2]
k3 = data_min[flag, 3]
kk = np.array([k1, k2, k3])
omegak, tmp = GLSW.eigensystem(kk)
ek[flag, :] = omegak[:2 * num_sub]
fig, ax = plt.subplots()
for band in range(2 * num_sub):
plt.plot(k, ek[:, band], 'k-')
for flag1 in range((2 * num_sub)**2):
plt.plot(k, data_min[:, 4 + flag1], 'r-.')
plt.plot(k, data_max[:, 4 + flag1], 'b-.')
for band1 in range(2 * num_sub):
for band2 in range(2 * num_sub):
tmin = data_min[:, 4 + 8 * band1 + band2]
# ReJJI_mat[boson1, ctt] = np.real(JJI_bond10[boson1, boson2, boson3]) # ImJJI_mat[boson1, ctt] = np.imag(JJI_bond10[boson1, boson2, boson3]) # ctt += 1 # np.savetxt(fn1, ReJJI_mat) # np.savetxt(fn2, ImJJI_mat) #q = np.array([-0.45, -0.44, 0.0]) q1 = np.array([-0.89, -0.79, 0.0]) q2 = np.array([0.11, 0.26, 0.0]) q3 = q1 - q2 # q1 = np.array([0.0, 0.0, 0.0]) # q2 = np.array([0.0, 0.0, 0.0]) # q3 = q1-q2 hsw1 = GLSW.sw_hamiltonian(q1) hsw2 = GLSW.sw_hamiltonian(q2) hsw3 = GLSW.sw_hamiltonian(q3) # fname = 'tmp/hamq1.txt' # np.savetxt(fname, hsw1) # fname = 'tmp/hamq2.txt' # np.savetxt(fname, hsw2) # fname = 'tmp/hamq3.txt' # np.savetxt(fname, hsw3) # tmp, ubov1 = GLSW.eigensystem(q1) # fname = 'tmp/ubov_mq1.txt' # np.savetxt(fname, ubov1)
# Author : Hao Zhang <*****@*****.**>
# Date : 01.16.2020
# Last Modified Date: 01.18.2020
# Last Modified By : Hao Zhang <*****@*****.**>
import numpy as np
import GLSW
from matplotlib import pyplot as plt
kk = np.arange(100)
lenk = len(kk)
omega = np.zeros((6, lenk))
omega_imag = np.zeros((6, lenk))
for flag in range(lenk):
k3 = 4.0 / lenk * flag
k = np.array([0.0, 0.0, k3])
ek, tmp, imagpart = GLSW.eigensystem(k)
omega[:, flag] = ek[:6]
omega_imag[:, flag] = imagpart[:6]
print(imagpart)
fig, ax = plt.subplots(2, 1)
for band in range(6):
ax[0].plot(kk, omega[band, :])
ax[1].plot(kk, omega_imag[band, :])
plt.ylim(0, 20)
plt.show()
#import cofig as cf
#import ex_info as exi
path_H = 0.5
path_K = 0.0
#q0 = np.array([0.34, 0.18, 0.0])
q = np.zeros((3))
q[0] = 4.0 * path_H + 2.0 * path_K
q[1] = path_K
q[2] = 0.5 * path_K - path_H
q1 = np.array([0.23, -0.55, 0.0])
q2 = np.array([1.33, 0.87, 0.0])
q3 = -(q1 + q2)
tmp, ubov1 = GLSW.eigensystem(q1)
print(tmp)
tmp, ubov2 = GLSW.eigensystem(q2)
tmp, ubov3 = GLSW.eigensystem(q3)
tmp, ubovm1 = GLSW.eigensystem(-q1)
tmp, ubovm2 = GLSW.eigensystem(-q2)
tmp, ubovm3 = GLSW.eigensystem(-q3)
num_sub = 4
band1 = 1
for band2 in range(2 * num_sub):
for band3 in range(2 * num_sub):
#import numpy.testing as npt import GLSW import GNLSW_vertex_new as vertex import GNLSW_vertex as vertex_old import cofig as cf import time num_sub = cf.num_sub # the self energy input omega = np.array([0.12, 0.22, 0.13]) # incoming particle q = np.array([0.12, 0.53, 0.0]) eq, ubov_q = GLSW.eigensystem(q) tmp, ubov_mq = GLSW.eigensystem(-q) # intermediate particles k = np.array([0.2, 0.1, 0.0]) qmk = q - k ek, ubov_k = GLSW.eigensystem(k) eqmk, ubov_qmk = GLSW.eigensystem(qmk) tmp, ubov_mk = GLSW.eigensystem(-k) tmp, ubov_mqmk = GLSW.eigensystem(-qmk) # ============================================================================= # V2_old = vertex_old.V2_cubic_bm(1, 7, 6, q, k, qmk, \ # ubov_q, ubov_k, ubov_qmk, \ # ubov_mq, ubov_mk, ubov_mqmk) # =============================================================================
# -*- coding: utf-8 -*-
"""
Created on Sat Nov 30 21:19:47 2019
@author: hao
"""
import numpy as np
import fun_generators as fg
import GLSW
h = np.array([0.0, 1.0, 3.0, 4.0, 4.74])
lenh = len(h)
xs = range(lenh)
q = np.array([0.0, 0.0, 0.0])
ham = GLSW.sw_hamiltonian(q)
for flag in xs:
field = h[flag]
fname = 'gs_info/h=' + str(field) + 'T/opt_angles.txt'
angles = np.load(fname)
print('h= ', field, '\n')
for flag1 in range(4):
theta = angles[flag1 * 4 + 2]
phi = angles[flag1 * 4 + 3]
Sz = fg.fun_sz(theta, phi)
Szsq = fg.fun_sz_sq(theta)
print('sublattice: ', flag1, '\n')
print('Sz = ', Sz, 'Sz**2= ', Szsq, '\n')
def greenfunction_gnlsw(omega, q, selfE_re, selfE_im):
"""
calculates the green function of H-P bosons after 1/NS correction
Parameters
----------
omega : np.array((anylength,))
the frequency
q : np.array((3,))
input momentum
selfE_re: np.array((2*num_sub, ))
real part self-energy using on-shell approximation
selfE_im: np.array((2*num_sub, ))
imag part self-energy using on-shell approximation
Returns
-------
gf: np.array((4*num_sub, 4*num_sub))
"""
len_omega = len(omega)
gf = np.zeros([len_omega, 4 * num_sub, 4 * num_sub], dtype=complex)
ek, ubov = GLSW.eigensystem(q)
ek_m, ubov_m = GLSW.eigensystem(-q)
ubov_m = ubov_m.conj()
minus_mat = np.zeros([4 * num_sub, 4 * num_sub], dtype=complex)
plus_mat = np.zeros([4 * num_sub, 4 * num_sub], dtype=complex)
u11 = ubov[:2 * num_sub, :2 * num_sub]
u21 = ubov[2 * num_sub:, :2 * num_sub]
u11_m = ubov_m[:2 * num_sub, :2 * num_sub]
u21_m = ubov_m[2 * num_sub:, :2 * num_sub]
for band in range(2 * num_sub):
minus_mat[:2 * num_sub, :2 * num_sub] = np.outer(
u11[:, band], u11[:, band].conj())
minus_mat[:2 * num_sub,
2 * num_sub:] = np.outer(u11[:, band], u21[:, band].conj())
minus_mat[2 * num_sub:, :2 * num_sub] = np.outer(
u21[:, band], u11[:, band].conj())
minus_mat[2 * num_sub:,
2 * num_sub:] = np.outer(u21[:, band], u21[:, band].conj())
plus_mat[:2 * num_sub, :2 * num_sub] = np.outer(
u21_m[:, band], u21_m[:, band].conj())
plus_mat[:2 * num_sub,
2 * num_sub:] = np.outer(u21_m[:, band], u11_m[:,
band].conj())
plus_mat[2 * num_sub:, :2 * num_sub] = np.outer(
u11_m[:, band], u21_m[:, band].conj())
plus_mat[2 * num_sub:,
2 * num_sub:] = np.outer(u11_m[:, band], u11_m[:,
band].conj())
tmp1 = np.reshape(
omega - (ek[band] + selfE_re[band]) - 1j * selfE_im[band] +
1j * 0.06, len_omega)
tmp2 = np.reshape(
omega + (ek_m[band] + selfE_re[band]) - 1j * selfE_im[band] +
1j * 0.06, len_omega)
# use this to avoid loop
gf += -minus_mat / (tmp1[:, None, None]) + plus_mat / (tmp2[:, None,
None])
return gf
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 10 15:16:55 2019
@author: Hao
"""
import numpy as np
import GLSW
import GNLSW_selfE as selfE
import time
st = time.time()
q = np.array([0.1, 0.2, 0.0])
eq, ubov_q = GLSW.eigensystem(q)
tmp, ubov_mq = GLSW.eigensystem(-q)
E1 = selfE.Sigma_decay(q, eq, ubov_q, ubov_mq)
et = time.time()
print(E1)
print('time elapse =', et-st, 's')
data = np.loadtxt(inFile)
lenf = len(data[:, 0])
k = np.arange(lenf)
num_sub = cf.num_sub
ek = np.zeros((lenf, 2*num_sub))
omega = np.zeros((lenf, 2*num_sub))
Gamma = np.zeros((lenf, 2*num_sub))
for flag in range(lenf):
q1 = data[flag, 1]
q2 = data[flag, 2]
q3 = data[flag, 3]
q = np.array([q1, q2, q3])
energy, tmp = GLSW.eigensystem(q)
ek[flag, :] = energy[:2*num_sub]
for band in range(2*num_sub):
spec_nlsw = energy[band] + data[flag, 2*band+4] + data[flag, band+20]
omega[flag, band] = spec_nlsw
decay_rate = data[flag, 2*band+5]
Gamma[flag, band] = decay_rate
ekmax = omega + Gamma
ekmin = omega - Gamma
fig, ax = plt.subplots()
for band in range(2*num_sub-1):
intensity_sc1 = np.zeros((Nw, lenk1))
# intensity_sc2 = np.zeros((Nw, lenk1))
# intensity_sc3 = np.zeros((Nw, lenk1))
"""
when adding the magnetic field in experiments,
one domain was selected out
"""
for flag in range(lenk1):
q1 = domain1[flag, 0]
q2 = domain1[flag, 1]
q3 = domain1[flag, 2]
kx, ky, kz = cf.k12Tokxy(q1, q2, q3)
intensity_sc1[:, flag] = GLSW.intensity(omega, kx, ky, kz)
# =============================================================================
# for flag in range(lenk1):
#
# q1 = domain2[flag, 0]
# q2 = domain2[flag, 1]
# q3 = domain2[flag, 2]
#
# kx, ky, kz = cf.k12Tokxy(q1, q2, q3)
# intensity_sc2[:, flag] = GLSW.intensity(omega, kx, ky, kz)
#
# for flag in range(lenk1):
#
# q1 = domain3[flag, 0]
# q2 = domain3[flag, 1]
import numpy as np
#import cofig as cf
import GLSW
import GNLSW_vertex_new as vertex
import GNLSW_vertex as vertex_old
from matplotlib import pyplot as plt
path_H = 0.5
path_K = 0.0
q = np.zeros((3))
q[0] = 4.0 * path_H + 2.0 * path_K
q[1] = path_K
q[2] = 0.5 * path_K - path_H
eq, ubov_q = GLSW.eigensystem(q)
tmp, ubov_mq = GLSW.eigensystem(-q)
print("incoming energy is", )
kk = np.linspace(0.0, 1.0, num=40)
v1 = np.zeros((len(kk)))
v2 = np.zeros((len(kk)))
for flag in range(len(kk)):
k = np.array([0.0, kk[flag], 0.0])
q2 = k
q3 = q - k
e2, ubov_2 = GLSW.eigensystem(q2)
tmp, ubov_m2 = GLSW.eigensystem(-q2)
e3, ubov_3 = GLSW.eigensystem(q3)
K = -0.5
inputpath1 = 'cuts/K=' + str(K) + '/path_domain1.dat'
field = cf.field
#inputpath2 = 'cuts/K=' + str(K) + '/path_domain2.dat'
#inputpath3 = 'cuts/K=' + str(K) + '/path_domain3.dat'
domain1 = np.loadtxt(inputpath1)
# domain2 = np.loadtxt(inputpath2)
# domain3 = np.loadtxt(inputpath3)
lenk1 = len(domain1[:, 0])
k = np.arange(lenk1)
omega = np.zeros((8, lenk1))
for flag in range(lenk1):
q1 = domain1[flag, 0]
q2 = domain1[flag, 1]
q3 = domain1[flag, 2]
q = np.array([q1, q2, q3])
ek, tmp = GLSW.eigensystem(q)
omega[:, flag] = ek[:8]
fname = 'disp.txt'
np.savetxt(fname, omega)
for band in range(8):
plt.plot(k, omega[band, :])
plt.show()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Dec 4 15:43:53 2019 @author: Hao """ import GLSW import numpy as np import cofig as cf qq = np.array([0.1, 0.2, 0.3]) hsw = GLSW.sw_hamiltonian(qq) omega = np.array([4.427]) #gf1 = -(omega + 1j*cf.broadening) * cf.A_mat + 2.0*hsw qx, qy, qz = cf.k12Tokxy(qq[0], qq[1], qq[2]) chi, sqw = GLSW.intensity(omega, qx, qy, qz) #print(chi) print(sqw) #eigval, eigvec = GLSW.eigensystem(qq) #resd = gf1 @ gf2[0, :, :] #print(resd - np.eye(16))
# Date : 02.17.2020
# Last Modified Date: 02.17.2020
# Last Modified By : Hao Zhang <*****@*****.**>
import numpy as np
import GLSW
num_sub = 4
q = np.array([0.1, 0.1, 0.1])
G1 = np.array([1.0, 0.0, 0.0])
G2 = np.array([2.0, 1.0, 3.0])
G3 = np.array([0.0, 0.0, 1.0])
q1 = q + G1
q2 = q + G2
q3 = q + G3
e1, ubov1 = GLSW.eigensystem(q1)
e2, ubov2 = GLSW.eigensystem(q2)
e3, ubov3 = GLSW.eigensystem(q3)
ubov1_11 = ubov1[:2 * num_sub, :2 * num_sub]
ubov2_11 = ubov2[:2 * num_sub, :2 * num_sub]
ubov1_21 = ubov1[2 * num_sub:, :2 * num_sub]
ubov2_21 = ubov2[2 * num_sub:, :2 * num_sub]
print('ubov11/ubov11')
print(ubov1_11[:, 0] / ubov2_11[:, 0])
print('difference between e2, e3 is ')
print(e2 - e3)