LCPQ/dft_tools
3
0
Fork 0
mirror of https://github.com/triqs/dft_tools synced 2024-08-29 15:23:41 +02:00
Code Issues Releases Wiki Activity

Use solver_to_sumk and solver_to_sumk_block instead of previous maps

Browse Source
This commit is contained in:
Priyanka Seth 2014-11-15 14:16:52 +01:00
parent b05c5c443a
commit 2126541774
2 changed files with 81 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
python/sumk_lda.py
View File

@ -82,6 +82,7 @@ class SumkLDA:
#----- #-----
# If these quantities are not in HDF, set them up # If these quantities are not in HDF, set them up
# FIXME READ AND WRITE sumk_to_solver AND solver_to_sumk
optional_things = ['gf_struct_solver','map_inv','map','chemical_potential','dc_imp','dc_energ','deg_shells'] optional_things = ['gf_struct_solver','map_inv','map','chemical_potential','dc_imp','dc_energ','deg_shells']
self.subgroup_present, self.value_read = self.read_input_from_hdf(subgrp = self.lda_output, things_to_read = [], self.subgroup_present, self.value_read = self.read_input_from_hdf(subgrp = self.lda_output, things_to_read = [],
optional_things = optional_things) optional_things = optional_things)
@ -99,11 +100,14 @@ class SumkLDA:
self.map_inv[i][b] = b self.map_inv[i][b] = b
# Set standard (identity) maps from gf_struct_sumk <-> gf_struct_solver # Set standard (identity) maps from gf_struct_sumk <-> gf_struct_solver
self.sumk_to_solver = [ {} for ish in range(self.n_inequiv_corr_shells) ] self.sumk_to_solver = [ {} for ish in range(self.n_inequiv_corr_shells) ]
self.solver_to_sumk = [ {} for ish in range(self.n_inequiv_corr_shells) ]
self.solver_to_sumk_block = [ {} for ish in range(self.n_inequiv_corr_shells) ]
for ish in range(self.n_inequiv_corr_shells): for ish in range(self.n_inequiv_corr_shells):
for block,inner_list in self.gf_struct_sumk[self.invshellmap[ish]]: for block,inner_list in self.gf_struct_sumk[self.invshellmap[ish]]:
self.solver_to_sumk_block[ish][block] = block
for inner in inner_list: for inner in inner_list:
self.sumk_to_solver[ish][(block,inner)] = (block,inner) self.sumk_to_solver[ish][(block,inner)] = (block,inner)
self.solver_to_sumk = self.sumk_to_solver self.solver_to_sumk[ish][(block,inner)] = (block,inner)
if (not self.subgroup_present) or (not self.value_read['dc_imp']): if (not self.subgroup_present) or (not self.value_read['dc_imp']):
self.__init_dc() # initialise the double counting self.__init_dc() # initialise the double counting
@ -419,6 +423,7 @@ class SumkLDA:
self.sumk_to_solver = [ {} for ish in range(self.n_inequiv_corr_shells) ] self.sumk_to_solver = [ {} for ish in range(self.n_inequiv_corr_shells) ]
self.solver_to_sumk = [ {} for ish in range(self.n_inequiv_corr_shells) ] self.solver_to_sumk = [ {} for ish in range(self.n_inequiv_corr_shells) ]
self.solver_to_sumk_block = [ {} for ish in range(self.n_inequiv_corr_shells) ]
if include_shells is None: include_shells=range(self.n_inequiv_corr_shells) if include_shells is None: include_shells=range(self.n_inequiv_corr_shells)
for ish in include_shells: for ish in include_shells:
@ -466,6 +471,7 @@ class SumkLDA:
inner_solv = j inner_solv = j
self.sumk_to_solver[ish][(block_sumk,inner_sumk)] = (block_solv,inner_solv) self.sumk_to_solver[ish][(block_sumk,inner_sumk)] = (block_solv,inner_solv)
self.solver_to_sumk[ish][(block_solv,inner_solv)] = (block_sumk,inner_sumk) self.solver_to_sumk[ish][(block_solv,inner_solv)] = (block_sumk,inner_sumk)
self.solver_to_sumk_block[ish][block_solv] = block_sumk
# map is the mapping of the blocs from the SK blocs to the CTQMC blocs: # map is the mapping of the blocs from the SK blocs to the CTQMC blocs:
self.map[ish][block] = range(len(dmbool)) self.map[ish][block] = range(len(dmbool))
@ -483,7 +489,8 @@ class SumkLDA:
dm[bln] = numpy.zeros([len(ind),len(ind)],numpy.complex_) dm[bln] = numpy.zeros([len(ind),len(ind)],numpy.complex_)
for i in range(len(ind)): for i in range(len(ind)):
for j in range(len(ind)): for j in range(len(ind)):
dm[bln][i,j] = dens_mat[ish][self.map_inv[ish][bln]][ind[i],ind[j]] # TODELETE dm[bln][i,j] = dens_mat[ish][self.map_inv[ish][bln]][ind[i],ind[j]]
dm[bln][i,j] = dens_mat[ish][self.solver_to_sumk_block[ish][bln]][ind[i],ind[j]]
for bl in gf_struct_temp: for bl in gf_struct_temp:
for bl2 in gf_struct_temp: for bl2 in gf_struct_temp:
@ -620,9 +627,11 @@ class SumkLDA:
Ncr[blname] = 0.0 Ncr[blname] = 0.0
for block,inner in self.gf_struct_solver[iorb].iteritems(): for block,inner in self.gf_struct_solver[iorb].iteritems():
bl = self.map_inv[iorb][block] # TODELETE bl = self.map_inv[iorb][block]
bl = self.solver_to_sumk_block[iorb][block]
Ncr[bl] += dens_mat[block].real.trace() Ncr[bl] += dens_mat[block].real.trace()
M = self.corr_shells[icrsh][3] M = self.corr_shells[icrsh][3]
Ncrtot = 0.0 Ncrtot = 0.0
@ -704,29 +713,42 @@ class SumkLDA:
# transform the CTQMC blocks to the full matrix: # transform the CTQMC blocks to the full matrix:
for icrsh in xrange(self.n_corr_shells): for icrsh in xrange(self.n_corr_shells):
s = self.shellmap[icrsh] # s is the index of the inequivalent shell corresponding to icrsh ish = self.shellmap[icrsh] # ish is the index of the inequivalent shell corresponding to icrsh
# setting up the index map: ######## START TODELETE
map_ind={} # # setting up the index map:
cnt = {} # map_ind={}
for blname in self.map[s]: # cnt = {}
cnt[blname] = 0 # for blname in self.map[ish]:
# cnt[blname] = 0
#
# for block,inner in self.gf_struct_solver[ish].iteritems():
## TODELETE blname = self.map_inv[ish][block]
# blname = self.solver_to_sumk_block[ish][block]
# map_ind[block] = range(len(inner))
# for i in inner:
# map_ind[block][i] = cnt[blname]
# cnt[blname]+=1
# print "map_ind =", map_ind #FIXME
######## END TODELETE
for block,inner in self.gf_struct_solver[s].iteritems(): # for block,inner in self.gf_struct_solver[ish].iteritems():
blname = self.map_inv[s][block] # for i in range(len(inner)):
map_ind[block] = range(len(inner)) # for j in range(len(inner)):
for i in inner: # ind1 = inner[i]
map_ind[block][i] = cnt[blname] # ind2 = inner[j]
cnt[blname]+=1 for block,inner in self.gf_struct_solver[ish].iteritems():
for ind1 in inner:
for block,inner in self.gf_struct_solver[s].iteritems(): for ind2 in inner:
for i in range(len(inner)): # ind1 = inner[i]
for j in range(len(inner)): # ind2 = inner[j]
ind1 = inner[i] # TODELETE ind1_imp = map_ind[block][ind1]
ind2 = inner[j] # TODELETE ind2_imp = map_ind[block][ind2]
ind1_imp = map_ind[block][ind1] block_imp,ind1_imp = self.solver_to_sumk[ish][(block,ind1)]
ind2_imp = map_ind[block][ind2] block_imp,ind2_imp = self.solver_to_sumk[ish][(block,ind2)]
self.Sigma_imp[icrsh][self.map_inv[s][block]][ind1_imp,ind2_imp] << Sigma_imp[s][block][ind1,ind2] # TODELETE self.Sigma_imp[icrsh][self.map_inv[ish][block]][ind1_imp,ind2_imp] << Sigma_imp[ish][block][ind1,ind2]
# TODELETE self.Sigma_imp[icrsh][self.solver_to_sumk_block[ish][block]][ind1_imp,ind2_imp] << Sigma_imp[ish][block][ind1,ind2]
self.Sigma_imp[icrsh][block_imp][ind1_imp,ind2_imp] << Sigma_imp[ish][block][ind1,ind2]
# rotation from local to global coordinate system: # rotation from local to global coordinate system:
if (self.use_rotations): if (self.use_rotations):
@ -812,7 +834,7 @@ class SumkLDA:
if (mu is None): mu = self.chemical_potential if (mu is None): mu = self.chemical_potential
Gloc = [ self.Sigma_imp[icrsh].copy() for icrsh in xrange(self.n_corr_shells) ] # this list will be returned Gloc = [ self.Sigma_imp[icrsh].copy() for icrsh in xrange(self.n_corr_shells) ] # this list will be returned
for icrsh in xrange(self.n_corr_shells): Gloc[icrsh].zero() # initialize to zero for icrsh in xrange(self.n_corr_shells): Gloc[icrsh].zero() # initialize to zero
beta = Gloc[0].mesh.beta beta = Gloc[0].mesh.beta
ikarray=numpy.array(range(self.n_k)) ikarray=numpy.array(range(self.n_k))
@ -832,7 +854,6 @@ class SumkLDA:
Gloc[icrsh] << mpi.all_reduce(mpi.world,Gloc[icrsh],lambda x,y : x+y) Gloc[icrsh] << mpi.all_reduce(mpi.world,Gloc[icrsh],lambda x,y : x+y)
mpi.barrier() mpi.barrier()
# Gloc[:] is now the sum over k projected to the local orbitals. # Gloc[:] is now the sum over k projected to the local orbitals.
# here comes the symmetrisation, if needed: # here comes the symmetrisation, if needed:
if (self.symm_op!=0): Gloc = self.symmcorr.symmetrize(Gloc) if (self.symm_op!=0): Gloc = self.symmcorr.symmetrize(Gloc)
@ -843,32 +864,38 @@ class SumkLDA:
for bname,gf in Gloc[icrsh]: Gloc[icrsh][bname] << self.rotloc(icrsh,gf,direction='toLocal') for bname,gf in Gloc[icrsh]: Gloc[icrsh][bname] << self.rotloc(icrsh,gf,direction='toLocal')
# transform to CTQMC blocks: # transform to CTQMC blocks:
Glocret = [ BlockGf( name_block_generator = [ (block,GfImFreq(indices = inner, mesh = Gloc[0].mesh)) for block,inner in self.gf_struct_solver[i].iteritems() ], Glocret = [ BlockGf( name_block_generator = [ (block,GfImFreq(indices = inner, mesh = Gloc[0].mesh)) for block,inner in self.gf_struct_solver[ish].iteritems() ],
make_copies = False) for i in xrange(self.n_inequiv_corr_shells) ] make_copies = False) for ish in xrange(self.n_inequiv_corr_shells) ]
for ish in xrange(self.n_inequiv_corr_shells): for ish in xrange(self.n_inequiv_corr_shells):
# setting up the index map: # # setting up the index map:
map_ind={} # map_ind={}
cnt = {} # cnt = {}
for blname in self.map[ish]: # for blname in self.map[ish]:
cnt[blname] = 0 # cnt[blname] = 0
#
# for block,inner in self.gf_struct_solver[ish].iteritems():
## TODELETE blname = self.map_inv[ish][block]
# blname = self.solver_to_sumk_block[ish][block]
# map_ind[block] = range(len(inner))
# for i in inner:
# map_ind[block][i] = cnt[blname]
# cnt[blname]+=1
for block,inner in self.gf_struct_solver[ish].iteritems(): for block,inner in self.gf_struct_solver[ish].iteritems():
blname = self.map_inv[ish][block] # for i in range(len(inner)):
map_ind[block] = range(len(inner)) # for j in range(len(inner)):
for i in inner: for ind1 in inner:
map_ind[block][i] = cnt[blname] for ind2 in inner:
cnt[blname]+=1 # ind1 = inner[i]
# ind2 = inner[j]
for block,inner in self.gf_struct_solver[ish].iteritems(): # ind1_imp = map_ind[block][ind1]
for i in range(len(inner)): # ind2_imp = map_ind[block][ind2]
for j in range(len(inner)): block_imp,ind1_imp = self.solver_to_sumk[ish][(block,ind1)]
ind1 = inner[i] block_imp,ind2_imp = self.solver_to_sumk[ish][(block,ind2)]
ind2 = inner[j] # TODELETE Glocret[ish][block][ind1,ind2] << Gloc[self.invshellmap[ish]][self.map_inv[ish][block]][ind1_imp,ind2_imp]
ind1_imp = map_ind[block][ind1] # Glocret[ish][block][ind1,ind2] << Gloc[self.invshellmap[ish]][self.solver_to_sumk_block[ish][block]][ind1_imp,ind2_imp]
ind2_imp = map_ind[block][ind2] Glocret[ish][block][ind1,ind2] << Gloc[self.invshellmap[ish]][block_imp][ind1_imp,ind2_imp]
Glocret[ish][block][ind1,ind2] << Gloc[self.invshellmap[ish]][self.map_inv[ish][block]][ind1_imp,ind2_imp]
# return only the inequivalent shells: # return only the inequivalent shells:
return Glocret return Glocret
@ -1071,8 +1098,8 @@ class SumkLDA:
def inequiv_shells(self,lst): def inequiv_shells(self,lst):
""" """
The number of inequivalent shells is calculated from lst, and a mapping is given as The number of inequivalent shells is calculated from lst, and a mapping is given as
map(i_corr_shells) = i_inequiv_corr_shells shellmap(i_corr_shells) = i_inequiv_corr_shells
invmap(i_inequiv_corr_shells) = i_corr_shells invshellmap(i_inequiv_corr_shells) = i_corr_shells
in order to put the Self energies to all equivalent shells, and for extracting Gloc in order to put the Self energies to all equivalent shells, and for extracting Gloc
""" """

6
python/trans_basis.py
View File

@ -82,7 +82,8 @@ class TransBasis:
for j in range(len(inner)): for j in range(len(inner)):
ind1 = inner[i] ind1 = inner[i]
ind2 = inner[j] ind2 = inner[j]
gfrotated[self.SK.map_inv[s][block]][ind1,ind2] << gf_to_rot[block][ind1,ind2] # TODELETE gfrotated[self.SK.map_inv[s][block]][ind1,ind2] << gf_to_rot[block][ind1,ind2]
gfrotated[self.SK.solver_to_sumk_block[s][block]][ind1,ind2] << gf_to_rot[block][ind1,ind2]
# Rotate using the matrix w # Rotate using the matrix w
for bname,gf in gfrotated: for bname,gf in gfrotated:
@ -95,7 +96,8 @@ class TransBasis:
for j in range(len(inner)): for j in range(len(inner)):
ind1 = inner[i] ind1 = inner[i]
ind2 = inner[j] ind2 = inner[j]
gfreturn[block][ind1,ind2] << gfrotated[self.SK.map_inv[0][block]][ind1,ind2] # TODELETE gfreturn[block][ind1,ind2] << gfrotated[self.SK.map_inv[0][block]][ind1,ind2]
gfreturn[block][ind1,ind2] << gfrotated[self.SK.solver_to_sumk_block[0][block]][ind1,ind2]
return gfreturn return gfreturn