LCPQ/dft_tools
3
0
Fork 0
mirror of https://github.com/triqs/dft_tools synced 2024-07-11 05:43:48 +02:00
Code Issues Releases Wiki Activity

Write shell equivalency information directly into h5 at conversion

Browse Source 
* changed shellmap and invshellmap to corr_to_inequiv and inequiv_to_corr
* update_archive now calculates and stores these quantities for old archives
This commit is contained in:
Priyanka Seth 2014-11-15 18:15:45 +01:00
parent b672839f83
commit 518cbccd8c
11 changed files with 111 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
python/TODOFIX
View File

@ -18,7 +18,9 @@ n_spin_blocks_gf -> n_spin_blocks
block_names -> spin_block_names block_names -> spin_block_names
a_list -> block_ind_list a_list -> block_ind_list
a,al -> block,inner a,al -> block,inner
shellmap -> corr_to_inequiv
invshellmap -> inequiv_to_corr
n_inequiv_corr_shells -> n_inequiv_shells
********** **********
* changed default h5 subgroup names * changed default h5 subgroup names

31
python/converters/converter_tools.py
View File

@ -49,30 +49,29 @@ class ConverterTools:
subprocess.call(["mv","-f","temphgfrt.h5","%s"%self.hdf_file]) subprocess.call(["mv","-f","temphgfrt.h5","%s"%self.hdf_file])
def inequiv_shells(self,lst): def det_shell_equivalence(self,lst):
""" """
The number of inequivalent shells is calculated from lst, and a mapping is given as The number of inequivalent shells is determined from lst, and a mapping is given as
map(i_corr_shells) = i_inequiv_corr_shells corr_to_inequiv(i_corr_shells) = i_inequiv_corr_shells
invmap(i_inequiv_corr_shells) = i_corr_shells inequiv_to_corr(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
""" """
tmp = [] corr_to_inequiv = [0 for i in range(len(lst))]
self.shellmap = [0 for i in range(len(lst))] inequiv_to_corr = [0]
self.invshellmap = [0] n_inequiv_shells = 1
self.n_inequiv_corr_shells = 1 tmp = [ lst[0][1:3] ]
tmp.append( lst[0][1:3] )
if (len(lst)>1): if (len(lst)>1):
for i in range(len(lst)-1): for i in range(len(lst)-1):
fnd = False fnd = False
for j in range(self.n_inequiv_corr_shells): for j in range(n_inequiv_shells):
if (tmp[j]==lst[i+1][1:3]): if (tmp[j]==lst[i+1][1:3]):
fnd = True fnd = True
self.shellmap[i+1] = j corr_to_inequiv[i+1] = j
if (fnd==False): if (fnd==False):
self.shellmap[i+1] = self.n_inequiv_corr_shells corr_to_inequiv[i+1] = n_inequiv_shells
self.n_inequiv_corr_shells += 1 n_inequiv_shells += 1
tmp.append( lst[i+1][1:3] ) tmp.append( lst[i+1][1:3] )
self.invshellmap.append(i+1) inequiv_to_corr.append(i+1)
return [n_inequiv_shells, corr_to_inequiv, inequiv_to_corr]

16
python/converters/hk_converter.py
View File

@ -82,24 +82,25 @@ class HkConverter(ConverterTools):
# now read the information about the shells: # now read the information about the shells:
corr_shells = [ [ int(R.next()) for i in range(6) ] for icrsh in range(n_corr_shells) ] # reads iatom, sort, l, dim, SO flag, irep corr_shells = [ [ int(R.next()) for i in range(6) ] for icrsh in range(n_corr_shells) ] # reads iatom, sort, l, dim, SO flag, irep
ConverterTools.inequiv_shells(self,corr_shells) # determine the number of inequivalent correlated shells, needed for further reading # determine the number of inequivalent correlated shells and maps, needed for further reading
[n_inequiv_shells, corr_to_inequiv, inequiv_to_corr] = ConverterTools.det_shell_equivalence(self,corr_shells)
use_rotations = 0 use_rotations = 0
rot_mat = [numpy.identity(corr_shells[icrsh][3],numpy.complex_) for icrsh in xrange(n_corr_shells)] rot_mat = [numpy.identity(corr_shells[icrsh][3],numpy.complex_) for icrsh in xrange(n_corr_shells)]
rot_mat_time_inv = [0 for i in range(n_corr_shells)] rot_mat_time_inv = [0 for i in range(n_corr_shells)]
# Representative representations are read from file # Representative representations are read from file
n_reps = [1 for i in range(self.n_inequiv_corr_shells)] n_reps = [1 for i in range(n_inequiv_shells)]
dim_reps = [0 for i in range(self.n_inequiv_corr_shells)] dim_reps = [0 for i in range(n_inequiv_shells)]
T = [] T = []
for icrsh in range(self.n_inequiv_corr_shells): for icrsh in range(n_inequiv_shells):
n_reps[icrsh] = int(R.next()) # number of representatives ("subsets"), e.g. t2g and eg n_reps[icrsh] = int(R.next()) # number of representatives ("subsets"), e.g. t2g and eg
dim_reps[icrsh] = [int(R.next()) for i in range(n_reps[icrsh])] # dimensions of the subsets dim_reps[icrsh] = [int(R.next()) for i in range(n_reps[icrsh])] # dimensions of the subsets
# The transformation matrix: # The transformation matrix:
# is of dimension 2l+1, it is taken to be standard d (as in Wien2k) # is of dimension 2l+1, it is taken to be standard d (as in Wien2k)
ll = 2*corr_shells[self.invshellmap[icrsh]][2]+1 ll = 2*corr_shells[inequiv_to_corr[icrsh]][2]+1
lmax = ll * (corr_shells[self.invshellmap[icrsh]][4] + 1) lmax = ll * (corr_shells[inequiv_to_corr[icrsh]][4] + 1)
T.append(numpy.zeros([lmax,lmax],numpy.complex_)) T.append(numpy.zeros([lmax,lmax],numpy.complex_))
T[icrsh] = numpy.array([[0.0, 0.0, 1.0, 0.0, 0.0], T[icrsh] = numpy.array([[0.0, 0.0, 1.0, 0.0, 0.0],
@ -196,6 +197,7 @@ class HkConverter(ConverterTools):
if not (self.lda_subgrp in ar): ar.create_group(self.lda_subgrp) if not (self.lda_subgrp in ar): ar.create_group(self.lda_subgrp)
things_to_save = ['energy_unit','n_k','k_dep_projection','SP','SO','charge_below','density_required', things_to_save = ['energy_unit','n_k','k_dep_projection','SP','SO','charge_below','density_required',
'symm_op','n_shells','shells','n_corr_shells','corr_shells','use_rotations','rot_mat', 'symm_op','n_shells','shells','n_corr_shells','corr_shells','use_rotations','rot_mat',
'rot_mat_time_inv','n_reps','dim_reps','T','n_orbitals','proj_mat','bz_weights','hopping'] 'rot_mat_time_inv','n_reps','dim_reps','T','n_orbitals','proj_mat','bz_weights','hopping',
'n_inequiv_shells', 'corr_to_inequiv', 'inequiv_to_corr']
for it in things_to_save: ar[self.lda_subgrp][it] = locals()[it] for it in things_to_save: ar[self.lda_subgrp][it] = locals()[it]
del ar del ar

16
python/converters/wien2k_converter.py
View File

@ -90,7 +90,8 @@ class Wien2kConverter(ConverterTools):
# now read the information about the shells: # now read the information about the shells:
corr_shells = [ [ int(R.next()) for i in range(6) ] for icrsh in range(n_corr_shells) ] # reads iatom, sort, l, dim, SO flag, irep corr_shells = [ [ int(R.next()) for i in range(6) ] for icrsh in range(n_corr_shells) ] # reads iatom, sort, l, dim, SO flag, irep
ConverterTools.inequiv_shells(self,corr_shells) # determine the number of inequivalent correlated shells, needed for further reading # determine the number of inequivalent correlated shells and maps, needed for further reading
[n_inequiv_shells, corr_to_inequiv, inequiv_to_corr] = ConverterTools.det_shell_equivalence(self,corr_shells)
use_rotations = 1 use_rotations = 1
rot_mat = [numpy.identity(corr_shells[icrsh][3],numpy.complex_) for icrsh in xrange(n_corr_shells)] rot_mat = [numpy.identity(corr_shells[icrsh][3],numpy.complex_) for icrsh in xrange(n_corr_shells)]
@ -110,17 +111,17 @@ class Wien2kConverter(ConverterTools):
rot_mat_time_inv[icrsh] = int(R.next()) rot_mat_time_inv[icrsh] = int(R.next())
# Read here the info for the transformation of the basis: # Read here the info for the transformation of the basis:
n_reps = [1 for i in range(self.n_inequiv_corr_shells)] n_reps = [1 for i in range(n_inequiv_shells)]
dim_reps = [0 for i in range(self.n_inequiv_corr_shells)] dim_reps = [0 for i in range(n_inequiv_shells)]
T = [] T = []
for icrsh in range(self.n_inequiv_corr_shells): for icrsh in range(n_inequiv_shells):
n_reps[icrsh] = int(R.next()) # number of representatives ("subsets"), e.g. t2g and eg n_reps[icrsh] = int(R.next()) # number of representatives ("subsets"), e.g. t2g and eg
dim_reps[icrsh] = [int(R.next()) for i in range(n_reps[icrsh])] # dimensions of the subsets dim_reps[icrsh] = [int(R.next()) for i in range(n_reps[icrsh])] # dimensions of the subsets
# The transformation matrix: # The transformation matrix:
# is of dimension 2l+1 without SO, and 2*(2l+1) with SO! # is of dimension 2l+1 without SO, and 2*(2l+1) with SO!
ll = 2*corr_shells[self.invshellmap[icrsh]][2]+1 ll = 2*corr_shells[inequiv_to_corr[icrsh]][2]+1
lmax = ll * (corr_shells[self.invshellmap[icrsh]][4] + 1) lmax = ll * (corr_shells[inequiv_to_corr[icrsh]][4] + 1)
T.append(numpy.zeros([lmax,lmax],numpy.complex_)) T.append(numpy.zeros([lmax,lmax],numpy.complex_))
# now read it from file: # now read it from file:
@ -192,7 +193,8 @@ class Wien2kConverter(ConverterTools):
# The subgroup containing the data. If it does not exist, it is created. If it exists, the data is overwritten! # The subgroup containing the data. If it does not exist, it is created. If it exists, the data is overwritten!
things_to_save = ['energy_unit','n_k','k_dep_projection','SP','SO','charge_below','density_required', things_to_save = ['energy_unit','n_k','k_dep_projection','SP','SO','charge_below','density_required',
'symm_op','n_shells','shells','n_corr_shells','corr_shells','use_rotations','rot_mat', 'symm_op','n_shells','shells','n_corr_shells','corr_shells','use_rotations','rot_mat',
'rot_mat_time_inv','n_reps','dim_reps','T','n_orbitals','proj_mat','bz_weights','hopping'] 'rot_mat_time_inv','n_reps','dim_reps','T','n_orbitals','proj_mat','bz_weights','hopping',
'n_inequiv_shells', 'corr_to_inequiv', 'inequiv_to_corr']
for it in things_to_save: ar[self.lda_subgrp][it] = locals()[it] for it in things_to_save: ar[self.lda_subgrp][it] = locals()[it]
del ar del ar

103
python/sumk_lda.py
View File

@ -55,18 +55,14 @@ class SumkLDA:
# read input from HDF: # read input from HDF:
things_to_read = ['energy_unit','n_k','k_dep_projection','SP','SO','charge_below','density_required', things_to_read = ['energy_unit','n_k','k_dep_projection','SP','SO','charge_below','density_required',
'symm_op','n_shells','shells','n_corr_shells','corr_shells','use_rotations','rot_mat', 'symm_op','n_shells','shells','n_corr_shells','corr_shells','use_rotations','rot_mat',
'rot_mat_time_inv','n_reps','dim_reps','T','n_orbitals','proj_mat','bz_weights','hopping'] 'rot_mat_time_inv','n_reps','dim_reps','T','n_orbitals','proj_mat','bz_weights','hopping',
'n_inequiv_shells', 'corr_to_inequiv', 'inequiv_to_corr']
self.subgroup_present, self.value_read = self.read_input_from_hdf(subgrp = self.lda_data, things_to_read = things_to_read) self.subgroup_present, self.value_read = self.read_input_from_hdf(subgrp = self.lda_data, things_to_read = things_to_read)
if (self.SO) and (abs(self.h_field)>0.000001): if (self.SO) and (abs(self.h_field)>0.000001):
self.h_field=0.0 self.h_field=0.0
mpi.report("For SO, the external magnetic field is not implemented, setting it to 0!") mpi.report("For SO, the external magnetic field is not implemented, setting it to 0!")
# FIXME -- REMOVE THIS, WRITE DATA IN CONVERTER
# determine the number of inequivalent correlated shells (self.n_inequiv_corr_shells)
# and related maps (self.shellmap, self.invshellmap)
self.inequiv_shells(self.corr_shells)
self.spin_block_names = [ ['up','down'], ['ud'] ] self.spin_block_names = [ ['up','down'], ['ud'] ]
self.n_spin_blocks = [2,1] self.n_spin_blocks = [2,1]
# convert spin_block_names to indices -- if spin polarized, differentiate up and down blocks # convert spin_block_names to indices -- if spin polarized, differentiate up and down blocks
@ -87,16 +83,16 @@ class SumkLDA:
optional_things = optional_things) optional_things = optional_things)
if (not self.subgroup_present) or (not self.value_read['gf_struct_solver']): if (not self.subgroup_present) or (not self.value_read['gf_struct_solver']):
# No gf_struct was stored in HDF, so first set a standard one: # No gf_struct was stored in HDF, so first set a standard one:
self.gf_struct_solver = [ dict([ (b, range(self.corr_shells[self.invshellmap[i]][3]) ) self.gf_struct_solver = [ dict([ (b, range(self.corr_shells[self.inequiv_to_corr[i]][3]) )
for b in self.spin_block_names[self.corr_shells[self.invshellmap[i]][4]] ]) for b in self.spin_block_names[self.corr_shells[self.inequiv_to_corr[i]][4]] ])
for i in range(self.n_inequiv_corr_shells) for i in range(self.n_inequiv_shells)
] ]
# 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_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_shells) ]
self.solver_to_sumk_block = [ {} for ish in range(self.n_inequiv_corr_shells) ] self.solver_to_sumk_block = [ {} for ish in range(self.n_inequiv_shells) ]
for ish in range(self.n_inequiv_corr_shells): for ish in range(self.n_inequiv_shells):
for block,inner_list in self.gf_struct_sumk[self.invshellmap[ish]]: for block,inner_list in self.gf_struct_sumk[self.inequiv_to_corr[ish]]:
self.solver_to_sumk_block[ish][block] = block 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)
@ -109,7 +105,7 @@ class SumkLDA:
self.chemical_potential = mu self.chemical_potential = mu
if (not self.subgroup_present) or (not self.value_read['deg_shells']): if (not self.subgroup_present) or (not self.value_read['deg_shells']):
self.deg_shells = [ [] for i in range(self.n_inequiv_corr_shells)] self.deg_shells = [ [] for i in range(self.n_inequiv_shells)]
#----- #-----
if self.symm_op: if self.symm_op:
@ -412,19 +408,19 @@ class SumkLDA:
if dm is None: dm = self.simple_point_dens_mat() if dm is None: dm = self.simple_point_dens_mat()
dens_mat = [dm[self.invshellmap[ish]] for ish in xrange(self.n_inequiv_corr_shells) ] dens_mat = [dm[self.inequiv_to_corr[ish]] for ish in xrange(self.n_inequiv_shells) ]
self.sumk_to_solver = [ {} for ish in range(self.n_inequiv_corr_shells) ] self.sumk_to_solver = [ {} for ish in range(self.n_inequiv_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_shells) ]
self.solver_to_sumk_block = [ {} for ish in range(self.n_inequiv_corr_shells) ] self.solver_to_sumk_block = [ {} for ish in range(self.n_inequiv_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_shells)
for ish in include_shells: for ish in include_shells:
self.gf_struct_solver[ish] = {} self.gf_struct_solver[ish] = {}
gf_struct_temp = [] gf_struct_temp = []
block_ind_list = [block for block,inner in self.gf_struct_sumk[self.invshellmap[ish]] ] block_ind_list = [block for block,inner in self.gf_struct_sumk[self.inequiv_to_corr[ish]] ]
for block in block_ind_list: for block in block_ind_list:
dm = dens_mat[ish][block] dm = dens_mat[ish][block]
dmbool = (abs(dm) > threshold) # gives an index list of entries larger that threshold dmbool = (abs(dm) > threshold) # gives an index list of entries larger that threshold
@ -511,25 +507,25 @@ class SumkLDA:
for bl in degsh: ss += gf_to_symm[bl] / (1.0*Ndeg) for bl in degsh: ss += gf_to_symm[bl] / (1.0*Ndeg)
for bl in degsh: gf_to_symm[bl] << ss for bl in degsh: gf_to_symm[bl] << ss
# for simply dft input, get crystal field splittings. # for simple dft input, get crystal field splittings.
def eff_atomic_levels(self): def eff_atomic_levels(self):
"""Calculates the effective atomic levels needed as input for the Hubbard I Solver.""" """Calculates the effective atomic levels needed as input for the Hubbard I Solver."""
# define matrices for inequivalent shells: # define matrices for inequivalent shells:
eff_atlevels = [ {} for ish in range(self.n_inequiv_corr_shells) ] eff_atlevels = [ {} for ish in range(self.n_inequiv_shells) ]
for ish in range(self.n_inequiv_corr_shells): for ish in range(self.n_inequiv_shells):
for bn in self.spin_block_names[self.corr_shells[self.invshellmap[ish]][4]]: for bn in self.spin_block_names[self.corr_shells[self.inequiv_to_corr[ish]][4]]:
eff_atlevels[ish][bn] = numpy.identity(self.corr_shells[self.invshellmap[ish]][3], numpy.complex_) eff_atlevels[ish][bn] = numpy.identity(self.corr_shells[self.inequiv_to_corr[ish]][3], numpy.complex_)
# Chemical Potential: # Chemical Potential:
for ish in xrange(self.n_inequiv_corr_shells): for ish in xrange(self.n_inequiv_shells):
for ii in eff_atlevels[ish]: eff_atlevels[ish][ii] *= -self.chemical_potential for ii in eff_atlevels[ish]: eff_atlevels[ish][ii] *= -self.chemical_potential
# double counting term: # double counting term:
#if hasattr(self,"dc_imp"): #if hasattr(self,"dc_imp"):
for ish in xrange(self.n_inequiv_corr_shells): for ish in xrange(self.n_inequiv_shells):
for ii in eff_atlevels[ish]: for ii in eff_atlevels[ish]:
eff_atlevels[ish][ii] -= self.dc_imp[self.invshellmap[ish]][ii] eff_atlevels[ish][ii] -= self.dc_imp[self.inequiv_to_corr[ish]][ii]
# sum over k: # sum over k:
if not hasattr(self,"Hsumk"): if not hasattr(self,"Hsumk"):
@ -567,9 +563,9 @@ class SumkLDA:
self.rot_mat[icrsh] ) self.rot_mat[icrsh] )
# add to matrix: # add to matrix:
for ish in xrange(self.n_inequiv_corr_shells): for ish in xrange(self.n_inequiv_shells):
for bn in eff_atlevels[ish]: for bn in eff_atlevels[ish]:
eff_atlevels[ish][bn] += self.Hsumk[self.invshellmap[ish]][bn] eff_atlevels[ish][bn] += self.Hsumk[self.inequiv_to_corr[ish]][bn]
return eff_atlevels return eff_atlevels
@ -599,7 +595,7 @@ class SumkLDA:
for icrsh in xrange(self.n_corr_shells): for icrsh in xrange(self.n_corr_shells):
iorb = self.shellmap[icrsh] # iorb is the index of the inequivalent shell corresponding to icrsh iorb = self.corr_to_inequiv[icrsh] # iorb is the index of the inequivalent shell corresponding to icrsh
if (iorb==orb): if (iorb==orb):
# do this orbital # do this orbital
@ -681,7 +677,7 @@ class SumkLDA:
"""Puts the impurity self energies for inequivalent atoms into the class, respects the multiplicity of the atoms.""" """Puts the impurity self energies for inequivalent atoms into the class, respects the multiplicity of the atoms."""
assert isinstance(Sigma_imp,list), "Sigma_imp has to be a list of Sigmas for the correlated shells, even if it is of length 1!" assert isinstance(Sigma_imp,list), "Sigma_imp has to be a list of Sigmas for the correlated shells, even if it is of length 1!"
assert len(Sigma_imp)==self.n_inequiv_corr_shells, "give exactly one Sigma for each inequivalent corr. shell!" assert len(Sigma_imp)==self.n_inequiv_shells, "give exactly one Sigma for each inequivalent corr. shell!"
# init self.Sigma_imp: # init self.Sigma_imp:
if all(type(gf) == GfImFreq for bname,gf in Sigma_imp[0]): if all(type(gf) == GfImFreq for bname,gf in Sigma_imp[0]):
@ -697,7 +693,7 @@ 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):
ish = self.shellmap[icrsh] # ish is the index of the inequivalent shell corresponding to icrsh ish = self.corr_to_inequiv[icrsh] # ish is the index of the inequivalent shell corresponding to icrsh
for block,inner in self.gf_struct_solver[ish].iteritems(): for block,inner in self.gf_struct_solver[ish].iteritems():
for ind1 in inner: for ind1 in inner:
@ -821,15 +817,15 @@ class SumkLDA:
# 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[ish].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 ish in xrange(self.n_inequiv_corr_shells) ] make_copies = False) for ish in xrange(self.n_inequiv_shells) ]
for ish in xrange(self.n_inequiv_corr_shells): for ish in xrange(self.n_inequiv_shells):
for block,inner in self.gf_struct_solver[ish].iteritems(): for block,inner in self.gf_struct_solver[ish].iteritems():
for ind1 in inner: for ind1 in inner:
for ind2 in inner: for ind2 in inner:
block_imp,ind1_imp = self.solver_to_sumk[ish][(block,ind1)] block_imp,ind1_imp = self.solver_to_sumk[ish][(block,ind1)]
block_imp,ind2_imp = self.solver_to_sumk[ish][(block,ind2)] block_imp,ind2_imp = self.solver_to_sumk[ish][(block,ind2)]
Glocret[ish][block][ind1,ind2] << Gloc[self.invshellmap[ish]][block_imp][ind1_imp,ind2_imp] Glocret[ish][block][ind1,ind2] << Gloc[self.inequiv_to_corr[ish]][block_imp][ind1_imp,ind2_imp]
# return only the inequivalent shells: # return only the inequivalent shells:
return Glocret return Glocret
@ -925,7 +921,7 @@ class SumkLDA:
if (orb is None): if (orb is None):
dens = 0.0 dens = 0.0
for ish in range(self.n_inequiv_corr_shells): for ish in range(self.n_inequiv_shells):
dens += gnonint[ish].total_density() dens += gnonint[ish].total_density()
else: else:
dens = gnonint[orb].total_density() dens = gnonint[orb].total_density()
@ -1014,34 +1010,3 @@ class SumkLDA:
atomlst = [ lst[i][0] for i in range(len(lst)) ] atomlst = [ lst[i][0] for i in range(len(lst)) ]
atoms = len(set(atomlst)) atoms = len(set(atomlst))
return atoms return atoms
##############################
# DUPLICATED, NEED TO REMOVE #
##############################
def inequiv_shells(self,lst):
"""
The number of inequivalent shells is calculated from lst, and a mapping is given as
shellmap(i_corr_shells) = i_inequiv_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
"""
tmp = []
self.shellmap = [0 for i in range(len(lst))]
self.invshellmap = [0]
self.n_inequiv_corr_shells = 1
tmp.append( lst[0][1:3] )
if (len(lst)>1):
for i in range(len(lst)-1):
fnd = False
for j in range(self.n_inequiv_corr_shells):
if (tmp[j]==lst[i+1][1:3]):
fnd = True
self.shellmap[i+1] = j
if (fnd==False):
self.shellmap[i+1] = self.n_inequiv_corr_shells
self.n_inequiv_corr_shells += 1
tmp.append( lst[i+1][1:3] )
self.invshellmap.append(i+1)

20
python/sumk_lda_tools.py
View File

@ -155,11 +155,11 @@ class SumkLDATools(SumkLDA):
for bn in self.spin_block_names[self.SO]: for bn in self.spin_block_names[self.SO]:
DOS[bn] = numpy.zeros([n_om],numpy.float_) DOS[bn] = numpy.zeros([n_om],numpy.float_)
DOSproj = [ {} for icrsh in range(self.n_inequiv_corr_shells) ] DOSproj = [ {} for icrsh in range(self.n_inequiv_shells) ]
DOSproj_orb = [ {} for icrsh in range(self.n_inequiv_corr_shells) ] DOSproj_orb = [ {} for icrsh in range(self.n_inequiv_shells) ]
for icrsh in range(self.n_inequiv_corr_shells): for icrsh in range(self.n_inequiv_shells):
for bn in self.spin_block_names[self.corr_shells[self.invshellmap[icrsh]][4]]: for bn in self.spin_block_names[self.corr_shells[self.inequiv_to_corr[icrsh]][4]]:
dl = self.corr_shells[self.invshellmap[icrsh]][3] dl = self.corr_shells[self.inequiv_to_corr[icrsh]][3]
DOSproj[icrsh][bn] = numpy.zeros([n_om],numpy.float_) DOSproj[icrsh][bn] = numpy.zeros([n_om],numpy.float_)
DOSproj_orb[icrsh][bn] = numpy.zeros([n_om,dl,dl],numpy.float_) DOSproj_orb[icrsh][bn] = numpy.zeros([n_om,dl,dl],numpy.float_)
@ -197,8 +197,8 @@ class SumkLDATools(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')
# Gloc can now also be used to look at orbitally resolved quantities # Gloc can now also be used to look at orbitally resolved quantities
for ish in range(self.n_inequiv_corr_shells): for ish in range(self.n_inequiv_shells):
for bname,gf in Gloc[self.invshellmap[ish]]: # loop over spins for bname,gf in Gloc[self.inequiv_to_corr[ish]]: # loop over spins
for iom in range(n_om): DOSproj[ish][bname][iom] += gf.data[iom,:,:].imag.trace()/(-3.1415926535) for iom in range(n_om): DOSproj[ish][bname][iom] += gf.data[iom,:,:].imag.trace()/(-3.1415926535)
DOSproj_orb[ish][bname][:,:,:] += gf.data[:,:,:].imag/(-3.1415926535) DOSproj_orb[ish][bname][:,:,:] += gf.data[:,:,:].imag/(-3.1415926535)
@ -210,13 +210,13 @@ class SumkLDATools(SumkLDA):
for i in range(n_om): f.write("%s %s\n"%(om_mesh[i],DOS[bn][i])) for i in range(n_om): f.write("%s %s\n"%(om_mesh[i],DOS[bn][i]))
f.close() f.close()
for ish in range(self.n_inequiv_corr_shells): for ish in range(self.n_inequiv_shells):
f=open('DOS%s_proj%s.dat'%(bn,ish),'w') f=open('DOS%s_proj%s.dat'%(bn,ish),'w')
for i in range(n_om): f.write("%s %s\n"%(om_mesh[i],DOSproj[ish][bn][i])) for i in range(n_om): f.write("%s %s\n"%(om_mesh[i],DOSproj[ish][bn][i]))
f.close() f.close()
for i in range(self.corr_shells[self.invshellmap[ish]][3]): for i in range(self.corr_shells[self.inequiv_to_corr[ish]][3]):
for j in range(i,self.corr_shells[self.invshellmap[ish]][3]): for j in range(i,self.corr_shells[self.inequiv_to_corr[ish]][3]):
Fname = 'DOS'+bn+'_proj'+str(ish)+'_'+str(i)+'_'+str(j)+'.dat' Fname = 'DOS'+bn+'_proj'+str(ish)+'_'+str(i)+'_'+str(j)+'.dat'
f=open(Fname,'w') f=open(Fname,'w')
for iom in range(n_om): f.write("%s %s\n"%(om_mesh[iom],DOSproj_orb[ish][bn][iom,i,j])) for iom in range(n_om): f.write("%s %s\n"%(om_mesh[iom],DOSproj_orb[ish][bn][iom,i,j]))

2
python/trans_basis.py
View File

@ -63,7 +63,7 @@ class TransBasis:
gfrotated = BlockGf( name_block_generator = [ (block,GfImFreq(indices = inner, mesh = gf_to_rot.mesh)) for block,inner in self.SK.gf_struct_sumk[0] ], make_copies = False) gfrotated = BlockGf( name_block_generator = [ (block,GfImFreq(indices = inner, mesh = gf_to_rot.mesh)) for block,inner in self.SK.gf_struct_sumk[0] ], make_copies = False)
# transform the CTQMC blocks to the full matrix: # transform the CTQMC blocks to the full matrix:
ish = self.SK.shellmap[0] # ish is the index of the inequivalent shell corresponding to icrsh ish = self.SK.corr_to_inequiv[0] # ish is the index of the inequivalent shell corresponding to icrsh
for block, inner in self.gf_struct_solver[ish].iteritems(): for block, inner in self.gf_struct_solver[ish].iteritems():
for ind1 in inner: for ind1 in inner:
for ind2 in inner: for ind2 in inner:

30
python/update_archive.py
View File

@ -1,3 +1,4 @@
from pytriqs.archive import HDFArchive
import h5py import h5py
import sys import sys
import numpy import numpy
@ -14,6 +15,27 @@ Please keep a copy of your old archive as this script is
If you encounter any problem please report it on github! If you encounter any problem please report it on github!
""" """
def det_shell_equivalence(lst):
corr_to_inequiv = [0 for i in range(len(lst))]
inequiv_to_corr = [0]
n_inequiv_shells = 1
tmp = [ lst[0][1:3] ]
if (len(lst)>1):
for i in range(len(lst)-1):
fnd = False
for j in range(n_inequiv_shells):
if (tmp[j]==lst[i+1][1:3]):
fnd = True
corr_to_inequiv[i+1] = j
if (fnd==False):
corr_to_inequiv[i+1] = n_inequiv_shells
n_inequiv_shells += 1
tmp.append( lst[i+1][1:3] )
inequiv_to_corr.append(i+1)
return [n_inequiv_shells, corr_to_inequiv, inequiv_to_corr]
### Main ###
filename = sys.argv[1] filename = sys.argv[1]
A = h5py.File(filename) A = h5py.File(filename)
@ -38,6 +60,14 @@ for obj in move_to_output:
A.copy('lda_input/'+obj,'lda_output/'+obj) A.copy('lda_input/'+obj,'lda_output/'+obj)
del(A['lda_input'][obj]) del(A['lda_input'][obj])
# Add shell equivalency quantities
B = A['lda_input']
corr_shells = HDFArchive(filename,'r')['lda_input']['corr_shells']
equiv_shell_info = det_shell_equivalence(corr_shells)
B['n_inequiv_shells'] = equiv_shell_info[0]
B['corr_to_inequiv'] = equiv_shell_info[1]
B['inequiv_to_corr'] = equiv_shell_info[2]
# Rename variables # Rename variables
groups = ['lda_symmcorr_input','lda_symmpar_input'] groups = ['lda_symmcorr_input','lda_symmpar_input']

BIN
test/SrVO3.h5
View File

Binary file not shown.

BIN
test/hk_convert.output.h5
View File

Binary file not shown.

BIN
test/wien2k_convert.output.h5
View File

Binary file not shown.