def compare_kpts(fname_full, fname_sub, tol=1e-8):
wfn_full = wfnIO(fname_full)
wfn_sub = wfnIO(fname_sub)
kpts_full = (wfn_full.kpt + tol) % 1
kpts_sub = (wfn_sub.kpt + tol) % 1
tree = cKDTree(kpts_full.T)
d, ind = tree.query(kpts_sub.T)
return ind, kpts_full.shape[1]
def test_bse(fname_wfn, fname_evec):
from bgwtools.IO.wfn import wfnIO
from bgwtools.IO.bsemat import bsematIO
wfn = wfnIO(fname_wfn)
bsemat = bsematIO(fname_evec)
syms = wfn.mtrx
cond = syms[2,2,:] == 1
syms = syms[:,:,cond]
bsemat.kpt[np.fabs(bsemat.kpt)<1e-15] = 0
kg = Kgrids(syms, bsemat.kpt)
#print [ sum(kg.idx_sk[:,ik]==ik) for ik in xrange(kg.nk) ]
for ik in xrange(kg.nk):
print kg.idx_sk[:,ik]
print kg
def read_eqp(fname_wfn, fname_eqp, nv, nc):
wfn = wfnIO(fname_wfn)
n_occ = wfn.ifmax[0,0]
if fname_eqp is None:
#nv, nk
en_v = wfn.energies[n_occ-nv:n_occ,:,0][::-1]*ryd
#nc, nk
en_c = wfn.energies[n_occ:n_occ+nc,:,0]*ryd
else:
from bgwtools.converters.read_eqp import get_data_from_eqp
bands,kx,ky,kz,e_lda,e_gw = get_data_from_eqp(fname_eqp)
bands_range = np.arange(len(bands))
val_bands = bands_range[(bands<=n_occ) & (bands>n_occ-nv)][::-1]
cond_bands = bands_range[(bands>n_occ) & (bands<n_occ+nc+1)]
en_v = e_gw[:,val_bands].T
en_c = e_gw[:,cond_bands].T
return en_v, en_c
def truncate(wfn_in, fname_out, ik_keep):
print
print 'Truncating', wfn_in.fname, '->', fname_out
wfn_out = wfnIO()
wfn_out.__dict__ = wfn_in.__dict__.copy()
wfn_out.nk = len(ik_keep)
wfn_out.ngk = wfn_out.ngk[ik_keep]
wfn_out.ngkmax = amax(wfn_out.ngk)
wfn_out.kw = wfn_out.kw[ik_keep]
wfn_out.kw[:] = 1.0 / wfn_out.nk
wfn_out.kpt = wfn_out.kpt[:, ik_keep]
#HACK!
#wfn_out.ifmin[:] = 1
#wfn_out.ifmax[:] = 4
wfn_out.ifmin = wfn_out.ifmin[ik_keep, :]
wfn_out.ifmax = wfn_out.ifmax[ik_keep, :]
wfn_out.energies = wfn_out.energies[:, ik_keep, :]
wfn_out.occupations = wfn_out.occupations[:, ik_keep, :]
wfn_out.f = None
wfn_out.fname = fname_out
wfn_out.write_header(full=True)
ng_max = amax(wfn_in.ngk)
gvec = empty((3, ng_max), dtype=int, order='F')
data = empty((ng_max, wfn_in.ns),
dtype=get_numpy_flavor(wfn_in.flavor),
order='F')
k_done = 0
for ik in range(wfn_in.nk):
if ik in ik_keep:
k_done += 1
print k_done, '/', wfn_out.nk
wfn_in.read_gvectors(gvec)
wfn_out.write_gvectors(gvec[:, :wfn_in.ngk[ik]])
for ib in range(wfn_in.nbands):
wfn_in.read_data(data)
wfn_out.write_data(data[:wfn_in.ngk[ik], :])
if k_done == wfn_out.nk:
break
else:
wfn_in.read_gvectors()
for ib in range(wfn_in.nbands):
wfn_in.read_data()
print wfn_out
def decimate_to(self, fname_out, verbose=True):
wfn_in = self.wfn_in
keep_k = self.keep_k
nk_out = np.sum(keep_k)
wfn_out = wfnIO()
wfn_out.__dict__ = wfn_in.__dict__.copy()
wfn_out.nk = nk_out
wfn_out.ngk = wfn_out.ngk[keep_k]
wfn_out.ngkmax = np.amax(wfn_out.ngk)
wfn_out.kw = wfn_out.kw[keep_k]
wfn_out.kw[:] = 1.0 / wfn_out.nk
wfn_out.kpt = wfn_out.kpt[:, keep_k]
wfn_out.ifmin = wfn_out.ifmin[keep_k, :]
wfn_out.ifmax = wfn_out.ifmax[keep_k, :]
wfn_out.energies = wfn_out.energies[:, keep_k, :]
wfn_out.occupations = wfn_out.occupations[:, keep_k, :]
wfn_out.f = None
wfn_out.fname = fname_out
wfn_out.write_header(full=True)
ng_max = np.amax(wfn_in.ngk)
gvec = np.empty((3, ng_max), dtype=int, order='F')
data = np.empty((ng_max, wfn_in.ns),
dtype=get_numpy_flavor(wfn_in.flavor),
order='F')
k_done = 0
for ik in range(wfn_in.nk):
if keep_k[ik]:
k_done += 1
if verbose:
print k_done, '/', wfn_out.nk
wfn_in.read_gvectors(gvec)
wfn_out.write_gvectors(gvec[:, :wfn_in.ngk[ik]])
for ib in range(wfn_in.nbands):
wfn_in.read_data(data)
wfn_out.write_data(data[:wfn_in.ngk[ik], :])
if k_done == wfn_out.nk:
break
else:
wfn_in.read_gvectors()
for ib in range(wfn_in.nbands):
wfn_in.read_data()
sys.exit(1)
# Reading arguments and input files
qmax=float(sys.argv[1])
k_center=array([float(sys.argv[2]),float(sys.argv[3]),float(sys.argv[4])])
fname_in = sys.argv[5]
if write_wfn:
if not read_wfn:
print "Error: cannot write decimated wave function without input wave function"
sys.exit(1)
fname_out = sys.argv[6]
if read_wfn:
from bgwtools.IO.wfn import wfnIO
from bgwtools.common.common import get_numpy_flavor
from bgwtools.IO.fullbz import fullbzIO
wfn_in = wfnIO(fname_in, full=True)
M = wfn_in.bvec
# Convert to cartesian coordinates
rk_cart=tensordot(wfn_in.bvec,wfn_in.kpt, axes=([1],[0]))
fullbz=fullbzIO('fullbz.dat')
print "Dimensions of input k-grid: %i %i %i"%(wfn_in.kgrid[0],wfn_in.kgrid[1],wfn_in.kgrid[2])
else:
from bgwtools.IO.kgrid_log import kgridlogIO
fullbz = kgridlogIO(sys.argv[5])
norm = sqrt(fullbz.bvec[0,0]**2 +fullbz.bvec[1,0]**2)
fullbz.bvec =fullbz.bvec /norm
M = fullbz.bvec
print "Dimensions of input k-grid: %i %i %i"%(fullbz.kgrid[0],fullbz.kgrid[1],fullbz.kgrid[2])
fk_cart=tensordot(M,fullbz.fk, axes=([1],[0]))
nf = fullbz.nf
nrk = fullbz.nrk
import numpy as np
import sys
if len(sys.argv) != 3:
print('Usage: %s wfn_in wfn_out' % (sys.argv[0]))
sys.exit(1)
fname_in = sys.argv[1]
fname_out = sys.argv[2]
#copy *all* wfn file
import shutil
shutil.copyfile(fname_in, fname_out)
#open wfn file, write fixed header to file fname_tmp
from bgwtools.IO.wfn import wfnIO
fname_tmp = '_wfn_tmp_'
wfn = wfnIO(fname_in, full=False)
print 'Original sum of weights:', np.sum(wfn.kw)
wfn.kw[:] = 1.0 / wfn.nk
print 'New sum of weights:', np.sum(wfn.kw)
wfn.ngkmax = np.amax(wfn.ngk)
wfn.to_file(fname_tmp, full=False)
#copy fixed header to fname_out
f_tmp = open(fname_tmp, 'rb')
f_out = open(fname_out, 'r+b')
f_out.write(f_tmp.read())
f_out.close()
f_tmp.close()
#clean-up
import os
#!/usr/bin/env python
# This utility compares two wfn files and prints the larger difference.
# Felipe H. da Jornada, Apr 2013
from bgwtools.IO.wfn import wfnIO
from bgwtools.common.common import get_numpy_flavor
import sys
from numpy import amax, empty, empty_like
fname1 = sys.argv[1]
print('File #1: %s'%(fname1))
fname2 = sys.argv[2]
print('File #2: %s'%(fname2))
wfn1 = wfnIO(fname1)
wfn2 = wfnIO(fname2)
ng_max = amax(wfn1.ngk) * wfn1.nspinor
gvec = empty((3, ng_max), dtype=int, order='F')
data1 = empty((ng_max, wfn1.ns), dtype=get_numpy_flavor(wfn1.flavor), order='F')
data2 = empty_like(data1)
for ik in range(wfn1.nk):
print('ik = %d'%ik)
wfn1.read_gvectors(gvec)
wfn2.read_gvectors(gvec)
ngk = wfn1.ngk[ik] * wfn1.nspinor
for ib in range(wfn1.nbands):
wfn1.read_data(data1)
wfn2.read_data(data2)
diff = (data2 - data1)[:ngk]
def get_velocity_kp(wfn, same_order=True):
if not isinstance(wfn, wfnIO):
raise TypeError('Expected wfn type, got %s.'%(type(wfn)))
nb = wfn.nbands
ns = wfn.ns
kpts = wfn.kpt
nk = wfn.nk
ns = wfn.ns
#print en.flags['F_CONTIGUOUS']
#print kpts.flags['F_CONTIGUOUS']
for ik in xrange(len(kpts)):
# Consistency check: dk == 1/kgrid
for idim in range(3):
delta_k = all_delta_k[idim]
cond = delta_k>0
if any(cond):
dk[idim] = amin(delta_k[cond])
if any(fabs(dk - 1./kgrid) > TOL_SMALL):
print wfn.nk
print wfn.kgrid
print dk
print 1./kgrid
raise ValueError('kgrid not consistent.')
#dk = 1./kgrid
# It's easier to roll the axis and calculate the velocities if the
# energies are indexed like this:
en = en.reshape(nb, kgrid[2], kgrid[1], kgrid[0], ns, order='F')
# Calcualte band velocity
vel = zeros((3, nb, kgrid[2], kgrid[1], kgrid[0], ns), dtype=float, order='F')
for idim in range(3):
if kgrid[2-idim]<2: continue
# In principle we could calculate both the forward and
# backward derivatives...
#vel[2-idim] = 0.5*(roll(en, -1, idim+1) - roll(en, 1, idim+1))
vel[2-idim] = roll(en, -1, idim+1) - en
if same_order:
return vel.reshape(3, nb, nk, ns, order='F')
else:
return en, vel
if __name__=='__main__':
# A simple test, great for graphene, but should work for
# any system.
import sys
fname = sys.argv[1]
ib = 4
if len(sys.argv)>2:
ib = int(sys.argv[2])
plot_abs = True
plot_vel = True
plot_en = True
wfn = wfnIO(fname)
en, vel = get_velocity(wfn, same_order=False)
import matplotlib.pyplot as plt
import scipy.linalg
dk = 1./wfn.kgrid
shift = dk*wfn.kshift
x = arange(shift[0], 1.0, dk[0])
y = arange(shift[1], 1.0, dk[1])
X, Y = meshgrid(x, y)
Z = zeros_like(X)
XYZ = row_stack((X[newaxis],Y[newaxis],Z[newaxis]))
M = linalg.cholesky(wfn.bdot).T
#M = eye(3)
XYZ = tensordot(M, XYZ, (1,0))
M = linalg.inv(M)
vel = vel[:,ib,0,:,:,0]
vel = tensordot(M, vel, (0,0))
if plot_abs:
v = vel * wfn.kgrid[:,newaxis,newaxis]
v = sqrt(sum(v**2, axis=0))
from matplotlib.mlab import griddata
Ni = 1000
xi = linspace(amin(XYZ[0]), amax(XYZ[0]), Ni)
yi = linspace(amin(XYZ[1]), amax(XYZ[1]), Ni)
X_ = XYZ[0].flatten(order='F')
Y_ = XYZ[1].flatten(order='F')
V_ = v.flatten(order='F')
vi = griddata(X_,Y_,V_,xi,yi,interp='linear')
plt.imshow(vi, origin='lower', \
extent=(amin(xi), amax(xi), amin(yi), amax(yi)))
#plt.imshow(v, origin='lower', extent=(0,1,0,1))
plt.colorbar()
if plot_vel:
ds = 1
v = vel[:,::ds,::ds]*ds
scale = 2
plt.quiver(XYZ[0][::ds,::ds], XYZ[1][::ds,::ds], \
v[0], v[1], angles='xy', scale=scale, zorder=10,\
headwidth=5, headlength=5, width=1e-3)
if plot_en:
e = en[ib,0,:,:,0]
plt.contour(XYZ[0], XYZ[1], e, linewidths=2)
plt.show()
from bgwtools.IO.epsmat import epsmatIO
from bgwtools.IO.wfn import wfnIO
if len(sys.argv) < 5:
print "Usage: %s eps0mat epsmat WFN output" % (sys.argv[0])
sys.exit(1)
f_eps0mat = sys.argv[1]
f_epsmat = sys.argv[2]
f_wfn = sys.argv[3]
f_out = open(sys.argv[4], 'w')
f_out.write("%10s %10s %10s %5s %15s %10s \n" %
('# qx', 'qy', '|q|', 'Gz', 'eps', 'ekin'))
eps0mat = epsmatIO(f_eps0mat)
wfn = wfnIO(f_wfn)
print "Reading eps0mat"
print " Number of G-vectors: ", eps0mat.ng
for ig in range(eps0mat.ng):
g_indx = eps0mat.isort[0][ig]
g_indx_i = eps0mat.isort_i[0][g_indx - 1]
if eps0mat.gvec_k[0, g_indx - 1] == 0 and eps0mat.gvec_k[1,
g_indx - 1] == 0:
print " Found head"
print " Gvec: ", eps0mat.gvec_k[:, g_indx - 1]
print " isort,isort_i: ", g_indx, g_indx_i
print " ig", ig
Gz = eps0mat.gvec_k[2, g_indx - 1]
qG = [eps0mat.qpt[0, 0], eps0mat.qpt[1, 0], Gz]
def __init__(self, fname_in):
self.wfn_in = wfnIO(fname_in)
self.keep_k = np.ones(self.wfn_in.nk, dtype=bool)
# Felipe Homrich da Jornada (Feb 2013)
import numpy as np
from bgwtools.IO.wfn import wfnIO
import sys
from bgwtools.common.common import get_numpy_flavor
if len(sys.argv) != 3:
print('Usage: %s wfn_in wfn_out' % (sys.argv[0]))
sys.exit(1)
fname_in = sys.argv[1]
fname_out = sys.argv[2]
wfn_in = wfnIO(fname_in, full=True)
nb_out = np.amax(wfn_in.ifmax) + 1
wfn_out = wfnIO()
wfn_out.__dict__ = wfn_in.__dict__.copy()
wfn_out.energies = wfn_out.energies[:nb_out, :, :]
wfn_out.occupations = wfn_out.occupations[:nb_out, :, :]
wfn_out.f = None
wfn_out.fname = fname_out
wfn_out.nbands = nb_out
wfn_out.write_header(full=True)
ng_max = np.amax(wfn_in.ngk)
gvec = np.empty((3, ng_max), dtype=int, order='F')
data = np.empty((ng_max, wfn_in.ns),
dtype=get_numpy_flavor(wfn_in.flavor),
import sys
from bgwtools.common.common import get_numpy_flavor
ryd = 13.60569253
if len(sys.argv) != 5:
print('Usage: %s qshift wfn_in wfn_out wfnq_out' % (sys.argv[0]))
sys.exit(1)
qshift = array(map(float, sys.argv[1].split(',')))
fname_in = sys.argv[2]
fname_out = sys.argv[3]
fnameq_out = sys.argv[4]
print 'WFN:', fname_in
wfn_in = wfnIO(fname_in)
print 'q-shift', qshift
#c -> k
#v -> k + q
tol = 1e-8
#kpts_qmq0 = (wfnq_in.kpt - qshift[:,newaxis] + 1) % 1
# calculate k + q
#kpts_pq = wfn_in.kpt + qshift[:,newaxis]
iks = []
ikqs = []
for ik in range(wfn_in.nk):
ks_pq = wfn_in.kpt[:, ik] + qshift
delta = (wfn_in.kpt - ks_pq[:, newaxis] + tol) % 1
#delta = (kpts_qmq0 - wfn_in.kpt[:,ik][:,newaxis])
#kk_q = wfn_in.kpt[:,ik] + qshift
from bgwtools.common.common import get_numpy_flavor
ryd = 13.60569253
TOL = 1e-6
if len(sys.argv) != 5:
print('Usage: %s wfn_full wfn_reduced wfn_out qx,qy,qz' % (sys.argv[0]))
sys.exit(1)
fname_in = sys.argv[1]
fname_red = sys.argv[2]
fname_out = sys.argv[3]
q_shift = array(map(float, sys.argv[4].split(',')))
print q_shift
wfn_in = wfnIO(fname_in)
kpts_full = wfn_in.kpt
wfn_red = wfnIO(fname_red)
kpts_red = wfn_red.kpt
kpts_q = kpts_red + q_shift[:, newaxis]
should_keep = []
for jk in range(wfn_in.nk):
kpt = kpts_full[:, jk]
if any(all(abs(kpt[:, newaxis] - kpts_q) < TOL, axis=0)):
should_keep += [jk]
if raw_input('Writing data to %s. Are you sure? [y/N] ' % (fname_out)) != 'y':
sys.exit(0)
# Felipe Homrich da Jornada (Jun 2013)
from numpy import *
from bgwtools.IO.wfn import wfnIO
import sys
from bgwtools.common.common import get_numpy_flavor
if len(sys.argv) != 3:
print('Usage: %s wfn_in wfn_out' % (sys.argv[0]))
sys.exit(1)
fname_in = sys.argv[1]
fname_out = sys.argv[2]
wfn_in = wfnIO(fname_in)
def get_delta(kpts, idim):
delta = fabs(kpts[idim, :] - wfn_in.kpt[idim, 0])
cond = delta > 1e-8
return amin(delta[cond])
dx = get_delta(wfn_in.kpt, 0)
dy = get_delta(wfn_in.kpt, 1)
x0 = amin(wfn_in.kpt[0, :])
y0 = amin(wfn_in.kpt[1, :])
print x0, y0
print dx, dy
def write_decimated(wfn,keep,bz,use_symmetries):
if use_symmetries:
keep_reduced = keep
else:
keep_reduced = bz.indr[keep]-1
keep = keep[argsort(keep_reduced)] # sort k's by reduced index
wfn_out = wfnIO()
wfn_out.__dict__ = wfn.__dict__.copy()
wfn_out.nk = len(keep)
if use_symmetries:
wfn_out.ngk = wfn_out.ngk[keep]
wfn_out.kw = wfn_out.kw[keep]
else:
wfn_out.ngk = wfn_out.ngk[bz.indr[keep]-1]
wfn_out.kw = wfn_out.kw[bz.indr[keep]-1]
wfn_out.ngkmax = amax(wfn_out.ngk)
wfn_out.kw[:] = 1.0/wfn_out.nk
if use_symmetries:
wfn_out.kpt = wfn_out.kpt[:, keep]
wfn_out.ifmin = wfn_out.ifmin[keep, :]
wfn_out.ifmax = wfn_out.ifmax[keep, :]
wfn_out.energies = wfn_out.energies[:, keep, :]
wfn_out.occupations = wfn_out.occupations[:, keep, :]
else:
wfn_out.kpt = bz.fk[:, keep]
wfn_out.ifmin = wfn_out.ifmin[bz.indr[keep]-1, :]
wfn_out.ifmax = wfn_out.ifmax[bz.indr[keep]-1, :]
wfn_out.energies = wfn_out.energies[:, bz.indr[keep]-1, :]
wfn_out.occupations = wfn_out.occupations[:, bz.indr[keep]-1, :]
wfn_out.f = None
wfn_out.fname = fname_out
wfn_out.write_header(full=True)
ng_max = amax(wfn_in.ngk)
gvec = empty((3, ng_max), dtype=int, order='F')
if use_symmetries:
data = empty((ng_max, wfn_in.ns), dtype=get_numpy_flavor(wfn_in.flavor), order='F')
else:
data = empty((wfn_in.nbands,ng_max, wfn_in.ns), dtype=get_numpy_flavor(wfn_in.flavor), order='F')
k_done = 0
for ik in range(wfn_in.nk):
if ik in keep_reduced:
k_done += 1
print k_done,'/',wfn_out.nk
wfn_in.read_gvectors(gvec)
if use_symmetries:
wfn_out.write_gvectors(gvec[:,:wfn_in.ngk[ik]])
for ib in range(wfn_in.nbands):
wfn_in.read_data(data)
wfn_out.write_data(data[:wfn_in.ngk[ik],:])
if k_done==wfn_out.nk:
break
else:
# ik is the reduced index
# find places where ik occurs in indr
idx_k = where(keep_reduced==ik)[0]
for kk in range(len(idx_k)):
wfn_out.write_gvectors(gvec[:,:wfn_in.ngk[ik]])
for ib in range(wfn_in.nbands):
if kk==0:
wfn_in.read_data(data[ib,:,:])
wfn_out.write_data(data[ib,:wfn_in.ngk[ik],:])
if k_done==wfn_out.nk:
break
else:
wfn_in.read_gvectors()
for ib in range(wfn_in.nbands):
wfn_in.read_data()
print wfn_out
# any system.
import sys
if len(sys.argv) != 3:
print('usage: %s WFN band')
sys.exit(1)
fname = sys.argv[1]
ib = int(sys.argv[2])
plot_vel = True
plot_en = False
use_cartesian = False
wfn = wfnIO(fname)
vel = get_velocity_kp(wfn, ib)
kpts = wfn.kpt
import matplotlib.pyplot as plt
import scipy.linalg
if use_cartesian:
M = linalg.cholesky(wfn.bdot).T
kpts = dot(M, kpts)
M = linalg.inv(M)
vel = tensordot(M, vel, (0, 0))
if plot_vel:
scale = 10
head = 25
g[abs(g) < 1e-10] = 1e-10
#uninvert, do operations, invert back
#print mat.diagonal()
mat = linalg.inv(mat)
for ig in xrange(nmtx):
mat[ig, ig] -= 1.0
mat[:, :] = mat[:, :] / g[:, np.newaxis]
for ig in xrange(nmtx):
mat[ig, ig] += 1.0
mat = linalg.inv(mat)
#print mat.diagonal()
self.epsmat.epsmat[iq] = mat
if __name__ == '__main__':
import sys
if len(sys.argv) != 4:
print 'Usage: %s wfn epsmat_in epsmat_out' % (sys.argv[0])
exit(1)
wfn = wfnIO(sys.argv[1])
f_in = sys.argv[2]
f_out = sys.argv[3]
eps = epsmatIO(f_in)
conv = epsilon_truncator(eps, wfn, slab_truncator)
conv.truncate()
eps.to_file(f_out)
#!/usr/bin/env python
# This script calculates the phase of the G=0 component of the WFNs
# for all kpts and bands. This is useful when analyzing results from
# BSE calculations.
from bgwtools.IO.wfn import wfnIO
import sys
import numpy as np
fname_wfn = sys.argv[1]
fname_out = sys.argv[2]
wfn = wfnIO(fname_wfn)
gvecs = wfn.get_gvectors_bufer()
data = wfn.get_data_buffer()
heads = np.empty((wfn.nk, wfn.nbands), dtype='complex128')
print wfn.gvec
#exit()
for ik in xrange(wfn.nk):
wfn.read_gvectors(gvecs)
cond = np.all(gvecs[:, :wfn.ngk[ik]] == 0, axis=0)
idx = np.nonzero(cond)[0][0]
print ik, idx, gvecs[:, idx]
for ib in xrange(wfn.nbands):
wfn.read_data(data)
heads[ik, ib] = data[idx, 0]
np.save(fname_out, heads)
print('Usage: %s WFN.h5 WFN_out flavor \n' % (sys.argv[0]))
print(' Flavor: 1=real, 2=complex')
sys.exit(1)
fname_in = sys.argv[1]
fname_out = sys.argv[2]
flavor = int(sys.argv[3])
# Read WFN.h5
import h5py
wfn = h5py.File(fname_in, 'r')
# Copying Header
# File info
wfn_out = wfnIO()
wfn_out.fname = fname_out
if flavor == 2:
wfn_out.name = 'WFN-Complex'
else:
wfn_out.name = 'WFN-Real'
wfn_out.ftype = get_ftype('WFN')
wfn_out.flavor = flavor
wfn_out.date = ''
wfn_out.time = ''
# crystal
wfn_out.nat = int(wfn['/mf_header/crystal/nat'][...])
wfn_out.adot = wfn['/mf_header/crystal/adot'][...].T
wfn_out.alat = np.float(wfn['/mf_header/crystal/alat'][...])
wfn_out.apos = wfn['/mf_header/crystal/apos'][...].T
"--model",
default=1,
type="int",
help="which model to use (0-2).")
(options, args) = parser.parse_args()
if len(args) < 1:
parser.error('Insuficient number of arguments.')
elif len(args) == 1:
print "Reading model from file '%s'" % (args[0])
f = open(args[0], 'rb')
epsmat_modeler = cPickle.load(f)
f.close()
else:
print "Parsing wfn file '%s'" % (args[0])
wfn = wfnIO(args[0])
epsmat_modeler = EpsmatModeler(wfn, options.Gz_max, options.avgcut_xy)
for arg in args[1:]:
print "Parsing epsmat file '%s'" % (arg)
epsmat = epsmatIO(arg, read_all=False)
epsmat_modeler.add_epsmat(epsmat)
epsmat_modeler.commit_data()
epsmat_modeler.model(model=options.model,
smooth=options.smooth,
degree=options.degree)
epsmat_modeler.get_bgw_params()
if len(args) > 1:
print "Dumping model to file '%s'" % (options.dump)
f = open(options.dump, 'wb')
cPickle.dump(epsmat_modeler, f)
def __init__(self, fname):
self.wfn = wfnIO(fname)
