def _gen_hamiltonian_block(HL0, HR0, hgen_l, hgen_r, interop, blockinfo):
'''Get the combined hamiltonian for specific block.'''
ndiml, ndimr = HL0.shape[0], HR0.shape[0]
bm_tot, pm = blockinfo['bmg'].join_bms(
[blockinfo['bml'], blockinfo['bmr']]).compact_form()
pm = ((blockinfo['pml'] * ndimr)[:, newaxis] +
blockinfo['pmr']).ravel()[pm]
indices = pm[bm_tot.get_slice(blockinfo['target_block'], uselabel=True)]
cinds = ind2c(indices, N=[ndiml, ndimr])
t0 = time.time()
H1 = fget_subblock_dmrg(hl=HL0.toarray(),
hr=identity(ndimr),
indices=cinds,
is_identity=2)
H2 = fget_subblock_dmrg(hl=identity(ndiml),
hr=HR0.toarray(),
indices=cinds,
is_identity=1)
Hc = H1 + H2
t1 = time.time()
sb = SuperBlock(hgen_l, hgen_r)
for op in interop:
Hc = Hc + sb.get_op(op, indices=cinds)
t2 = time.time()
print 'Generate Hamiltonian %s, %s' % (t1 - t0, t2 - t1)
return sps.csr_matrix(Hc), bm_tot, pm
def _gen_hamiltonian_full(HL0, HR0, hgen_l, hgen_r, interop):
'''Get the full hamiltonian.'''
ndiml, ndimr = HL0.shape[0], HR0.shape[0]
H1, H2 = kron(HL0, sps.identity(ndimr)), kron(sps.identity(ndiml), HR0)
H = H1 + H2
#get the link hamiltonians
sb = SuperBlock(hgen_l, hgen_r)
Hin = []
for op in interop:
Hin.append(sb.get_op(op))
H = H + sum(Hin)
H = _eliminate_zeros(H, ZERO_REF)
return H
def left_sweep(self,m): '''sweep one site towards left''' self.lblocks.pop(-1) psi0_guess=np.reshape(self.sblock.full_psi0,(-1,self.rblocks[-2].D*self.d)) psi0_guess=psi0_guess.dot(self.rblocks[-1].V.todense()) psi0_guess=psi0_guess.reshape(self.lblocks[-1].D,-1) psi0_guess=self.lblocks[-1].U.todense().dot(psi0_guess) psi0_guess=psi0_guess.reshape(-1,1) self.lblocks.pop(-1) self.lhgen=deepcopy(self.lblocks[-1]) self.rhgen=deepcopy(self.rblocks[-1]) self.lhgen.enlarge() self.rhgen.enlarge() self.sblock=SuperBlock(self.lhgen,self.rhgen) E,psi=self.sblock.eigen(psi0_guess) print '='*(self.lblocks[-1].l)+'++'+'-'*(self.rblocks[-1].l) print 'E=',float(E)/self.L U=self.sblock.transmat(m);self.lhgen.U=U V=self.sblock.rtransmat(m);self.rhgen.V=V self.lhgen.transform(U) self.rhgen.transform(V) self.lhgen.basis_sector_array=self.sblock.new_sector_array self.lhgen.basis_by_sector=self.sblock.new_basis_by_sector self.rhgen.basis_sector_array=self.sblock.rnew_sector_array self.rhgen.basis_by_sector=self.sblock.rnew_basis_by_sector self.lblocks.append(deepcopy(self.lhgen)) self.rblocks.append(deepcopy(self.rhgen))
def _gen_hamiltonian_block0(HL0, HR0, hgen_l, hgen_r, interop, blockinfo):
'''Get the combined hamiltonian for specific block.'''
ndiml, ndimr = HL0.shape[0], HR0.shape[0]
bml, bmr, pml, pmr, bmg, target_block = blockinfo['bml'], blockinfo[
'bmr'], blockinfo['pml'], blockinfo['pmr'], blockinfo[
'bmg'], blockinfo['target_block']
bm_tot, pm = bmg.join_bms([bml, bmr]).compact_form()
pm = ((pml * len(pmr))[:, newaxis] + pmr).ravel()[pm]
t0 = time.time()
H1, H2 = kron(HL0, sps.identity(ndimr)), kron(sps.identity(ndiml), HR0)
t1 = time.time()
indices = pm[bm_tot.get_slice(target_block, uselabel=True)]
H1, H2 = H1.tocsr()[indices][:, indices], H2.tocsr()[indices][:, indices]
Hc = H1 + H2
sb = SuperBlock(hgen_l, hgen_r)
for op in interop:
Hc = Hc + (sb.get_op(op)).tocsr()[indices][:, indices]
t2 = time.time()
print 'Generate Hamiltonian %s, %s' % (t1 - t0, t2 - t1)
return Hc, bm_tot, pm
def createSuperBlock(self, fsimg, superBlockOffset, superBlockSize, mode,
data):
superBlock = SuperBlock()
if mode == 0: # If we work locally
superBlock.createFromBytes(fsimg, superBlockOffset, superBlockSize,
mode, None)
return superBlock
elif mode == 1: # If we work remotely
superBlock.createFromBytes(None, None, None, mode, data)
print superBlock.inodeCount
def __init__(self, disk='foo.img', *args, **kw):
fuse.Fuse.__init__(self, *args, **kw)
self.disk = disk
with open(self.disk, 'rb') as f:
f.seek(1024)
data = f.read(SuperBlockSize)
self.sb = SuperBlock(data)
first_group_pos = max(2048, self.sb.get_block_size())
f.seek(first_group_pos)
data = f.read(BlockGroupSize)
self.first_bg = BlockGroup(data)
root_i_pos = (self.sb.get_block_size() *
self.first_bg.get_inode_table() +
InodeSize)
f.seek(root_i_pos)
data = f.read(InodeSize)
self.root_i = Inode(data)
def single_step(self,m): #only for infinite '''single dmrg step.m:number of kept states''' self.lhgen.enlarge() self.rhgen.enlarge() self.sblock=SuperBlock(self.lhgen,self.rhgen,joint=True) E,psi=self.sblock.eigen() print '*'*(self.lhgen.l-1)+'++'+'*'*(self.rhgen.l-1) print 'E=',float(E)/self.sblock.L U=self.sblock.transmat(m);self.lhgen.U=U self.lhgen.transform(U) V=self.sblock.rtransmat(m);self.rhgen.V=V self.rhgen.transform(V) self.lhgen.basis_sector_array=self.sblock.new_sector_array self.lhgen.basis_by_sector=self.sblock.new_basis_by_sector self.rhgen.basis_sector_array=self.sblock.rnew_sector_array self.rhgen.basis_by_sector=self.sblock.rnew_basis_by_sector self.lblocks.append(deepcopy(self.lhgen)) self.rblocks.append(deepcopy(self.rhgen))
class Ext2(fuse.Fuse):
def __init__(self, disk='foo.img', *args, **kw):
fuse.Fuse.__init__(self, *args, **kw)
self.disk = disk
with open(self.disk, 'rb') as f:
f.seek(1024)
data = f.read(SuperBlockSize)
self.sb = SuperBlock(data)
first_group_pos = max(2048, self.sb.get_block_size())
f.seek(first_group_pos)
data = f.read(BlockGroupSize)
self.first_bg = BlockGroup(data)
root_i_pos = (self.sb.get_block_size() *
self.first_bg.get_inode_table() +
InodeSize)
f.seek(root_i_pos)
data = f.read(InodeSize)
self.root_i = Inode(data)
def find_inode(self, path):
if path == '/':
return self.root_i
dirs = path.split('/')[1:]
with open(self.disk, 'rb') as f:
# TODO: deal with multiple-blocks directories
next_de_pos = (self.root_i.get_blocks()[0] *
self.sb.get_block_size())
while dirs != []:
f.seek(next_de_pos)
data = f.read(DirEntrySize)
de = DirEntry(data)
if de.get_name_length() == 0:
raise NotFound("File %s not found" % path)
if de.get_name() == dirs[0]:
dirs.pop()
inode_pos = (self.sb.get_block_size() *
self.first_bg.get_inode_table() +
(de.get_inode()-1) * InodeSize)
f.seek(inode_pos)
data = f.read(InodeSize)
i = Inode(data)
if dirs == []: # we found it
return i
if i.is_file():
raise NotFound("%s is a file, not a directory" %
de.get_name())
# TODO
next_de_pos = (i.get_blocks()[0] *
self.sb.get_block_size())
next_de_pos += de.get_length()
raise NotFound("Invalid path: %s" % path)
def getattr(self, path):
inode = self.find_inode(path)
stat = fuse.Stat()
stat.st_mode = inode.get_mode()
stat.st_atime = inode.get_atime()
stat.st_mtime = inode.get_mtime()
stat.st_ctime = inode.get_ctime()
stat.st_uid = inode.get_uid()
stat.st_gid = inode.get_gid()
stat.st_size = inode.get_size()
stat.st_nlink = inode.get_links_count()
stat.st_ino = 0 # TODO
stat.st_dev = 0
return stat
def readdir(self, path, offset):
inode = self.find_inode(path)
with open(self.disk, 'rb') as f:
next_de_pos = (inode.get_blocks()[0] *
self.sb.get_block_size())
while True:
f.seek(next_de_pos)
data = f.read(DirEntrySize)
de = DirEntry(data)
if de.get_name_length() == 0:
break
yield fuse.Direntry(de.get_name())
next_de_pos += de.get_length()
return
def mknod(self, path, mode, dev):
return 0
def unlink(self, path):
return 0
def read(self, path, size, offset):
blocks_read = 0
inode = self.find_inode(path)
first_block = offset/self.sb.get_block_size()
data = ''
with open(self.disk, 'rb') as f:
all_blocks = (inode.get_blocks() +
inode.get_indirect_blocks(f, self.sb.get_block_size(), 1))
for block in all_blocks[first_block:]:
if block != 0:
blocks_read += 1
if blocks_read >= MaxBlocksRead:
# we can't give too much data at once
return data
block_pos = (block * self.sb.get_block_size())
f.seek(block_pos)
data += f.read(self.sb.get_block_size())
return data
def write(self, path, buf, offset):
return 0
def release(self, path, flags):
return 0
def open(self, path, flags):
return 0
def truncate(self, path, size):
return 0
def utime(self, path, times):
return 0
def mkdir(self, path, mode):
return 0
def rmdir(self, path):
return 0
def rename(self, pathfrom, pathto):
return 0
def fsync(self, path, isfsyncfile):
return 0
class DMRGEngine(object): ''' dmrg engine construct:DMRGEngine(lhgen,rhgen) attributes: lhgen:left hamiltonian generator rhgen:right hamiltonian generator N:length of whole chain lblocks:a list to store left generators rblocks:a list to store right generators sblock:super block ''' def __init__(self,lhgen,rhgen): self.lhgen=lhgen self.rhgen=rhgen self.L=self.rhgen.L self.lblocks=[deepcopy(self.lhgen)] self.rblocks=[deepcopy(self.rhgen)] self.d=self.lhgen.d def single_step(self,m): #only for infinite '''single dmrg step.m:number of kept states''' self.lhgen.enlarge() self.rhgen.enlarge() self.sblock=SuperBlock(self.lhgen,self.rhgen,joint=True) E,psi=self.sblock.eigen() print '*'*(self.lhgen.l-1)+'++'+'*'*(self.rhgen.l-1) print 'E=',float(E)/self.sblock.L U=self.sblock.transmat(m);self.lhgen.U=U self.lhgen.transform(U) V=self.sblock.rtransmat(m);self.rhgen.V=V self.rhgen.transform(V) self.lhgen.basis_sector_array=self.sblock.new_sector_array self.lhgen.basis_by_sector=self.sblock.new_basis_by_sector self.rhgen.basis_sector_array=self.sblock.rnew_sector_array self.rhgen.basis_by_sector=self.sblock.rnew_basis_by_sector self.lblocks.append(deepcopy(self.lhgen)) self.rblocks.append(deepcopy(self.rhgen)) def infinite(self,m): '''infinite algorithm''' for i in range(self.L/2-1): self.single_step(m) def right_sweep(self,m): '''sweep one site towards right''' self.rblocks.pop(-1) psi0_guess=np.reshape(self.sblock.full_psi0,(self.lblocks[-2].D*self.d,-1)) psi0_guess=self.lblocks[-1].U.conjugate().transpose().todense().dot(psi0_guess) psi0_guess=psi0_guess.reshape(-1,self.rblocks[-1].D) psi0_guess=psi0_guess.dot(self.rblocks[-1].V.conjugate().transpose().todense()) psi0_guess=psi0_guess.reshape(-1,1) self.rblocks.pop(-1) self.lhgen=deepcopy(self.lblocks[-1]) self.rhgen=deepcopy(self.rblocks[-1]) self.lhgen.enlarge();self.rhgen.enlarge() self.sblock=SuperBlock(self.lhgen,self.rhgen) E,psi=self.sblock.eigen(psi0_guess) print '-'*(self.lblocks[-1].l)+'++'+'='*(self.rblocks[-1].l) print 'E=',float(E)/self.L U=self.sblock.transmat(m);self.lhgen.U=U V=self.sblock.rtransmat(m);self.rhgen.V=V self.lhgen.transform(U) self.rhgen.transform(V) self.lhgen.basis_sector_array=self.sblock.new_sector_array self.lhgen.basis_by_sector=self.sblock.new_basis_by_sector self.rhgen.basis_sector_array=self.sblock.rnew_sector_array self.rhgen.basis_by_sector=self.sblock.rnew_basis_by_sector self.lblocks.append(deepcopy(self.lhgen)) self.rblocks.append(deepcopy(self.rhgen)) def left_sweep(self,m): '''sweep one site towards left''' self.lblocks.pop(-1) psi0_guess=np.reshape(self.sblock.full_psi0,(-1,self.rblocks[-2].D*self.d)) psi0_guess=psi0_guess.dot(self.rblocks[-1].V.todense()) psi0_guess=psi0_guess.reshape(self.lblocks[-1].D,-1) psi0_guess=self.lblocks[-1].U.todense().dot(psi0_guess) psi0_guess=psi0_guess.reshape(-1,1) self.lblocks.pop(-1) self.lhgen=deepcopy(self.lblocks[-1]) self.rhgen=deepcopy(self.rblocks[-1]) self.lhgen.enlarge() self.rhgen.enlarge() self.sblock=SuperBlock(self.lhgen,self.rhgen) E,psi=self.sblock.eigen(psi0_guess) print '='*(self.lblocks[-1].l)+'++'+'-'*(self.rblocks[-1].l) print 'E=',float(E)/self.L U=self.sblock.transmat(m);self.lhgen.U=U V=self.sblock.rtransmat(m);self.rhgen.V=V self.lhgen.transform(U) self.rhgen.transform(V) self.lhgen.basis_sector_array=self.sblock.new_sector_array self.lhgen.basis_by_sector=self.sblock.new_basis_by_sector self.rhgen.basis_sector_array=self.sblock.rnew_sector_array self.rhgen.basis_by_sector=self.sblock.rnew_basis_by_sector self.lblocks.append(deepcopy(self.lhgen)) self.rblocks.append(deepcopy(self.rhgen)) def finite(self,mwarmup,mlist): '''finite algorithm''' self.infinite(mwarmup) #mind the initialize problem for m in mlist: for i in range(self.L/2,self.L-2): self.right_sweep(m) for i in range(1,self.L-3): self.left_sweep(m) for i in range(1,self.L/2-1): self.right_sweep(m) def tomps(self): As=[np.array([[1.,0],[0,1.]])] As[0]=As[0].reshape(-1,2,As[0].shape[-1]) Bs=[np.array([[1.,0],[0,1.]])] Bs[0]=Bs[0].reshape(Bs[0].shape[0],2,-1) for lhgen in self.lblocks[1:]: A=copy(lhgen.U) A=A.toarray() A=A.reshape(-1,2,A.shape[-1]) As.append(A) for rhgen in self.rblocks[1:]: B=copy(rhgen.V) B=B.toarray() B=B.conjugate().transpose() B=B.reshape(B.shape[0],2,-1) Bs.append(B) Bs.reverse() S=self.sblock.s return MPS(self.d,self.L,As,Bs,S)
