def _set_cavity_basis(self):
'''Get the basis states for the external coupled system in which to work in.
Parameters
--------------
types : string
Defines the types of cavity. Possible options include:
Uniform -- Boson cavity coupled to each site. Can have multiple modes
Local -- Individual boson coupled to each "SITES" number of sites. Can have multiple modes
fLocal -- Fermionic system coupled to each "SITES" number of sites. 1 mode.
'''
if self.types == 'Uniform':
basis = boson_basis_1d(L=1, sps=self.Ntot)
basis_ms = basis
for i in range(self.species - 1):
basis_ms = tensor_basis(basis_ms, basis)
self.basis = basis_ms
if self.types == 'Local':
basis = boson_basis_1d(L=self.sites, sps=self.Ntot)
basis_ms = basis
for i in range(self.species - 1):
basis_ms = tensor_basis(basis_ms, basis)
self.basis = basis_ms
if self.types == 'fLocal':
self.basis = spinless_fermion_basis_1d(L=self.sites,
Nf=None,
nf=None)
def get_operators(L):
if L % 2 == 1:
S = "{}/2".format(L)
else:
S = "{}".format(L // 2)
spin_basis = spin_basis_1d(L, pauli=True, kblock=0, pblock=1)
bath_basis = spin_basis_1d(1, S=S)
basis = tensor_basis(spin_basis, bath_basis)
J_list = [[-1, i, (i + 1) % L] for i in range(L)]
M_list = [[1.0 / L**2, i, j] for i in range(L) for j in range(L)]
N_list = [[1.0, 0]]
I_list = [[L / 2.0, 0]]
kwargs = dict(basis=basis,
dtype=np.float64,
check_symm=False,
check_pcon=False,
check_herm=False)
print basis.basis_left.L
H_S = hamiltonian([["zz|", J_list]], [], **kwargs)
M2 = hamiltonian([["zz|", M_list]], [], **kwargs)
n = hamiltonian([["|z", N_list], ["|I", I_list]], [], **kwargs)
return H_S, M2, n
def anneal_bath_4(L,Nb,T,gamma=0.2,omega=1.0,path="."):
ti = time.time()
filename = os.path.join(path,"spin_bath_exact_L_{}_Nb_{}_T_{}_gamma_{}_omega_{}.npz".format(L,Nb,T,gamma,omega))
if os.path.isfile(filename):
print "file_exists...exiting run."
exit()
if Nb%2 == 1:
S = "{}/2".format(Nb)
else:
S = "{}".format(Nb//2)
print "creating basis"
spin_basis = spin_basis_1d(L,pauli=True,kblock=0,pblock=1)
bath_basis = spin_basis_1d(1,S=S)
basis = tensor_basis(spin_basis,bath_basis)
print "L={}, H-space size: {}".format(L,basis.Ns)
bath_energy=[[-omega/Nb,0,0]]
SB_1_list = [[-gamma/Nb,i,0] for i in range(L)]
SB_2_list = [[-gamma/np.sqrt(Nb),i,0] for i in range(L)]
B_h_list = [[-1,0]]
h_list = [[-1,i] for i in range(L)]
J_list = [[-1,i,(i+1)%L] for i in range(L)]
A = lambda t:(t/T)**2
B = lambda t:(1-t/T)**2
static = [
["+|-",SB_2_list],
["-|+",SB_2_list],
]
dynamic = [
["x|",h_list,B,()],
["|+",B_h_list,B,()],
["|-",B_h_list,B,()],
["zz|",J_list,A,()],
["z|z",SB_1_list,A,()],
["|zz",bath_energy,A,()],
]
print "creating hamiltonian"
kwargs=dict(basis=basis,dtype=np.float64,
check_symm=False,check_pcon=False,check_herm=False)
H = hamiltonian(static,dynamic,**kwargs)
print "solving initial state"
E0,psi_0 = H.eigsh(k=1,which="SA",time=0)
psi_0 = psi_0.ravel()
print "evolving"
out = np.zeros(psi_0.shape,dtype=np.complex128)
psi_f = evolve(psi_0,0,T,H._hamiltonian__omp_SO,f_params = (out,),solver_name="dop853",atol=1.1e-10,rtol=1.1e-10)
print "saving"
np.savez_compressed(filename,psi=psi_f)
print "dome......{} sec".format(time.time()-ti)
def get_operators(size, Nb):
n, m = size
if Nb % 2 == 1:
S = "{}/2".format(Nb)
else:
S = "{}".format(Nb // 2)
bath_basis = spin_basis_general(1, S=S)
N = n**2 + m**2
Ns_block_est = max((2**N) / (N), 1000)
if n != 0:
T1, t1, T2, t2, Pr, pr, Tx, Ty = tilted_square_transformations(n, m)
blocks = dict(tx=(Tx, 0), ty=(Ty, 0), pb=(Pr, 0))
spin_basis = spin_basis_general(N,
S="1/2",
pauli=True,
Ns_block_est=Ns_block_est,
**blocks)
else:
L = m
tr = square_lattice_trans(L, L)
Tx = tr.T_x
Ty = tr.T_y
blocks = dict(tx=(Tx, 0),
ty=(Ty, 0),
px=(tr.P_x, 0),
py=(tr.P_y, 0),
pd=(tr.P_d, 0))
spin_basis = spin_basis_general(N,
S="1/2",
pauli=True,
Ns_block_est=Ns_block_est,
**blocks)
basis = tensor_basis(spin_basis, bath_basis)
J_list = [[-1.0, i, Tx[i]] for i in range(N)]
J_list.extend([-1.0, i, Ty[i]] for i in range(N))
M_list = [[1.0 / N**2, i, i] for i in range(N)]
M_list += [[2.0 / N**2, i, j] for i in range(N) for j in range(N) if i > j]
kwargs = dict(basis=basis,
dtype=np.float64,
check_symm=False,
check_pcon=False,
check_herm=False)
print size
H_S = hamiltonian([["zz|", J_list]], [], **kwargs)
M2 = hamiltonian([["zz|", M_list]], [], **kwargs)
return H_S, M2
def anneal_bath(L, T, gamma=0.2, omega=1.0, path="."):
filename = os.path.join(
path, "spin_bath_exact_L_{}_T_{}_gamma_{}_omega_{}.npz".format(
L, T, gamma, omega))
if os.path.isfile(filename):
print "file_exists...exiting run."
exit()
if L % 2 == 1:
S = "{}/2".format(L)
else:
S = "{}".format(L // 2)
print "creating basis"
spin_basis = spin_basis_1d(L, pauli=True, kblock=0, pblock=1)
bath_basis = spin_basis_1d(1, S=S)
basis = tensor_basis(spin_basis, bath_basis)
print "L={}, H-space size: {}".format(L, basis.Ns)
# exit()
bath_energy = [[omega / L, 0]] # photon energy
SB_list = [[gamma / np.sqrt(L), i, 0] for i in range(L)]
h_list = [[-1, i] for i in range(L)]
J_list = [[-1, i, (i + 1) % L] for i in range(L)]
static_SB = [["+|-", SB_list], ["-|+", SB_list]]
static = [["|z", bath_energy]]
dynamic = [
["x|", h_list, lambda t: (1 - t / T)**2, ()],
["zz|", J_list, lambda t: (t / T)**2, ()],
]
print "creating hamiltonian"
kwargs = dict(basis=basis,
dtype=np.float64,
check_symm=False,
check_pcon=False,
check_herm=False)
H_B = hamiltonian(static, [], **kwargs)
H_S = hamiltonian([], dynamic, **kwargs)
V = hamiltonian(static_SB, [], **kwargs)
n = H_B * (L / omega)
H = H_B + H_S + V
print "solving initial state"
E0, psi_0 = H.eigsh(k=1, which="SA", time=0)
psi_0 = psi_0.ravel()
print "evolving"
out = np.zeros(psi_0.shape, dtype=np.complex128)
psi_f = evolve(psi_0,
0,
T,
H._hamiltonian__omp_SO,
f_params=(out, ),
solver_name="dop853")
print "saving"
np.savez_compressed(filename, psi=psi_f)
print "dome."
#
from quspin.operators import hamiltonian # Hamiltonians and operators
from quspin.basis import spinless_fermion_basis_1d, tensor_basis # Hilbert space fermion and tensor bases
import numpy as np # generic math functions
##### define model parameters #####
L = 4 # system size
J = 1.0 # hopping
U = np.sqrt(2.0) # interaction
mu = 0.0 # chemical potential
##### construct Fermi-Hubbard Hamiltonian #####
# define boson basis with 3 states per site L bosons in the lattice
N_up = L // 2 + L % 2 # number of fermions with spin up
N_down = L // 2 # number of fermions with spin down
basis_up = spinless_fermion_basis_1d(L, Nf=N_up)
basis_down = spinless_fermion_basis_1d(L, Nf=N_down)
basis = tensor_basis(basis_up, basis_down) # spinful fermions
print(basis)
# define site-coupling lists
hop_right = [[-J, i, (i + 1) % L] for i in range(L)] #PBC
hop_left = [[+J, i, (i + 1) % L] for i in range(L)] #PBC
pot = [[-mu, i] for i in range(L)] # -\mu \sum_j n_{j \sigma}
interact = [[U, i, i] for i in range(L)] # U/2 \sum_j n_{j,up} n_{j,down}
# define static and dynamic lists
static = [
['+-|', hop_left], # up hops left
['-+|', hop_right], # up hops right
['|+-', hop_left], # down hops left
['|-+', hop_right], # down hops right
['n|', pot], # up on-site potention
['|n', pot], # down on-site potention
['n|n', interact] # up-down interaction
# define time-dependent perturbation
A = 2.0
Omega = 1.0
def drive(t, Omega):
return np.sin(Omega * t)
drive_args = [Omega]
#
###### create the basis
# build the two bases to tensor together to a bose-fermi mixture
basis_b = boson_basis_1d(L, Nb=Nb, sps=3) # boson basis
basis_f = spinless_fermion_basis_1d(L, Nf=Nf) # fermion basis
basis = tensor_basis(basis_b, basis_f) # BFM
#
##### create model
# define site-coupling lists
hop_b = [[-Jb, i, (i + 1) % L] for i in range(L)] # b hopping
int_list_bb = [[Ubb / 2.0, i, i] for i in range(L)] # bb onsite interaction
int_list_bb_lin = [[-Ubb / 2.0, i]
for i in range(L)] # bb interaction, linear term
#
hop_f_right = [[-Jf, i, (i + 1) % L] for i in range(L)] # f hopping right
hop_f_left = [[Jf, i, (i + 1) % L] for i in range(L)] # f hopping left
int_list_ff = [[Uff, i, (i + 1) % L]
for i in range(L)] # ff nearest-neighbour interaction
drive_f = [[A * (-1.0)**i, i] for i in range(L)] # density staggered drive
#
int_list_bf = [[Ubf, i, i] for i in range(L)] # bf onsite interaction
def makeBasis(N, S1, S2):
basis1 = spin_basis_general(N=N, S=S1)
basis2 = spin_basis_general(N=N, S=S2)
basis = tensor_basis(basis1, basis2)
return basis
Jp = [[1.0, i, tr.T_x[i]] for i in range(N)]
Jp.extend([[1.0, i, tr.T_y[i]] for i in range(N)])
Jm = [[-1.0, i, tr.T_x[i]] for i in range(N)]
Jm.extend([[-1.0, i, tr.T_y[i]] for i in range(N)])
U_onsite = [[1.0, i, i] for i in range(N)]
operator_list_0 = [["+-|", Jp], ["-+|", Jm], ["|+-", Jp], ["|-+", Jm]]
operator_list_1 = [["n|n", U_onsite]]
operator_dict = dict(H0=operator_list_0, H1=operator_list_1)
basis_f = spinless_fermion_basis_1d(L=N, Nf=2)
basis_1 = tensor_basis(basis_f, basis_f)
basis_f = spinless_fermion_basis_general(N, Nf=2)
basis_2 = tensor_basis(basis_f, basis_f)
basis_3 = spinful_fermion_basis_1d(L=N, Nf=(2, 2))
basis_4 = spinful_fermion_basis_general(N, Nf=(2, 2))
basis_dict = dict(tensored_spinless_fermion_basis_1d=basis_1,
spinful_fermion_basis_1d=basis_3,
tensored_spinless_fermion_basis_general=basis_2,
spinful_fermion_basis_general=basis_4)
for basis_name, basis in basis_dict.items():
H_U = quantum_operator(operator_dict,
basis=basis,
qspin_path = os.path.join(os.getcwd(), "../")
sys.path.insert(0, qspin_path)
from quspin.basis import spinless_fermion_basis_1d, spinful_fermion_basis_1d, tensor_basis
import numpy as np
import scipy.sparse as sp
from functools import reduce
L = 4
np.random.seed(2)
spinful_basis = spinful_fermion_basis_1d(L, Nf=(2, 2))
spinless_basis = spinless_fermion_basis_1d(L, Nf=2)
test_basis = tensor_basis(spinless_basis, spinless_basis)
psi = np.random.uniform(-1, 1,
size=(spinful_basis.Ns, )) + 1j * np.random.uniform(
-1, 1, size=(spinful_basis.Ns, ))
psi /= np.linalg.norm(psi)
sp_psi = sp.csr_matrix(psi).T
psis = np.random.uniform(
-1, 1, size=(spinful_basis.Ns, spinful_basis.Ns)) + 1j * np.random.uniform(
-1, 1, size=(spinful_basis.Ns, spinful_basis.Ns))
psis /= np.linalg.norm(psis, axis=0)
p_DM = np.random.uniform(size=spinful_basis.Ns)
p_DM /= p_DM.sum()
from __future__ import print_function, division
import sys, os
qspin_path = os.path.join(os.getcwd(), "../")
sys.path.insert(0, qspin_path)
from quspin.basis import tensor_basis, spin_basis_1d
from quspin.operators import hamiltonian
import numpy as np
L = 3
Li = 1
b1 = spin_basis_1d(Li)
basis2 = tensor_basis(*(b1 for i in range(L)))
J1 = [[1.0, i] for i in range(L - 1)]
J2 = [[1.0, 0]]
static1 = [["x", J1], ["y", J1], ["z", J1]]
static2 = [
["x||", J2],
["y||", J2],
["z||", J2],
["|x|", J2],
["|y|", J2],
["|z|", J2],
]
H1 = hamiltonian(static1, [], N=L)
H2 = hamiltonian(static2, [], basis=basis2, check_pcon=False, check_symm=False)
def plot(L,Nb,gamma,omega):
if Nb%2 == 1:
S = "{}/2".format(Nb)
else:
S = "{}".format(Nb//2)
print "creating basis"
spin_basis = spin_basis_1d(L,pauli=True,kblock=0,pblock=1)
bath_basis = spin_basis_1d(1,S=S)
basis = tensor_basis(spin_basis,bath_basis)
print "L={}, H-space size: {}".format(L,basis.Ns)
bath_energy_2=[[-omega/Nb,0,0]]
bath_energy_1=[[-omega/Nb,0]]
SB_1_list = [[-gamma/Nb,i,0] for i in range(L)]
SB_2_list = [[gamma/np.sqrt(Nb),i,0] for i in range(L)]
B_h_list = [[-1,0]]
h_list = [[-1,i] for i in range(L)]
hz_list = [[0.01,i] for i in range(L)]
J_list = [[-1,i,(i+1)%L] for i in range(L)]
A = lambda t:(t)**2
B = lambda t:(1-t)**2
# static = [
# ["+|-",SB_2_list],
# ["-|+",SB_2_list],
# ]
# dynamic = [
# ["x|",h_list,B,()],
# ["|+",B_h_list,B,()],
# ["|-",B_h_list,B,()],
# ["zz|",J_list,A,()],
# ["z|z",SB_1_list,A,()],
# ["|zz",bath_energy,A,()],
# ]
# static = [
# ]
# dynamic = [
# ["x|",h_list,B,()],
# ["|+",B_h_list,B,()],
# ["|-",B_h_list,B,()],
# ["zz|",J_list,A,()],
# ["z|z",SB_1_list,A,()],
# ["|zz",bath_energy_2,A,()],
# ]
static = [
["|z",bath_energy_1],
]
dynamic = [
["x|",h_list,B,()],
["-|+",SB_2_list,B,()],
["+|-",SB_2_list,B,()],
["zz|",J_list,A,()],
]
print "creating hamiltonian"
kwargs=dict(basis=basis,dtype=np.float64,
check_symm=False,check_pcon=False,check_herm=False)
H = hamiltonian(static,dynamic,**kwargs)
times = np.linspace(0,1,301)[1:-1]
gaps=[]
for t in times:
E,V = H.eigsh(k=100,which="SA",time=t,maxiter=100000)
gaps.append(E-E[0])
plt.plot(times,gaps,label="L={}".format(L),color="blue")
plt.show()
def anneal_bath_1(n, m, Nb, T, gamma=0.2, omega=1.0, path="."):
ti = time.time()
n, m = min(n, m), max(n, m)
filename = os.path.join(
path,
"spin_bath_exact_n_{}_m_{}_Nb_{}_T_{}_gamma_{}_omega_{}.npz".format(
n, m, Nb, T, gamma, omega))
if os.path.isfile(filename):
print "file_exists...exiting run."
exit()
if Nb % 2 == 1:
S = "{}/2".format(Nb)
else:
S = "{}".format(Nb // 2)
print "creating basis"
bath_basis = spin_basis_general(1, S=S)
N = n**2 + m**2
Ns_block_est = max((2**N) / (N), 1000)
if n != 0:
T1, t1, T2, t2, Pr, pr, Tx, Ty = tilted_square_transformations(n, m)
blocks = dict(tx=(Tx, 0), ty=(Ty, 0), pb=(Pr, 0))
spin_basis = spin_basis_general(N,
S="1/2",
pauli=True,
Ns_block_est=Ns_block_est,
**blocks)
else:
L = m
tr = square_lattice_trans(L, L)
Tx = tr.T_x
Ty = tr.T_y
blocks = dict(tx=(Tx, 0),
ty=(Ty, 0),
px=(tr.P_x, 0),
py=(tr.P_y, 0),
pd=(tr.P_d, 0))
spin_basis = spin_basis_general(N,
S="1/2",
pauli=True,
Ns_block_est=Ns_block_est,
**blocks)
basis = tensor_basis(spin_basis, bath_basis)
print "n,m={},{}, H-space size: {}".format(n, m, basis.Ns)
J_list = [[-1.0, i, Tx[i]] for i in range(N)]
J_list.extend([-1.0, i, Ty[i]] for i in range(N))
h_list = [[-1.0, i] for i in range(N)]
bath_energy = [[omega / Nb, 0]]
SB_xy_list = [[gamma / (4.0 * Nb), i, 0] for i in range(N)]
SB_zz_list = [[gamma / (2.0 * Nb), i, 0] for i in range(N)]
A = lambda t: (t / T)**2
B = lambda t: (1 - t / T)**2
static = [
["|z", bath_energy],
]
dynamic = [
["zz|", J_list, A, ()],
["x|", h_list, B, ()],
["+|-", SB_xy_list, B, ()],
["-|+", SB_xy_list, B, ()],
["z|z", SB_zz_list, B, ()],
]
print "creating hamiltonian"
kwargs = dict(basis=basis,
dtype=np.float64,
check_symm=False,
check_pcon=False,
check_herm=False)
H = hamiltonian(static, dynamic, **kwargs)
print "solving initial state"
E0, psi_0 = H.eigsh(k=1, which="SA", time=0)
psi_0 = psi_0.ravel()
print "evolving"
out = np.zeros(psi_0.shape, dtype=np.complex128)
psi_f = evolve(psi_0,
0,
T,
H._hamiltonian__omp_SO,
f_params=(out, ),
solver_name="dop853",
atol=1.1e-15,
rtol=1.1e-15)
print "saving"
np.savez_compressed(filename, psi=psi_f)
print "dome......{} sec".format(time.time() - ti)
