def main(): p = build_parser() opts, args = p.parse_args() if opts.file: for fname in args: tokens = fname.split('.') symbol = tokens[0] xc = tokens[1] name = tokens[2] if tokens[-1] == 'gz': import gzip fopen = gzip.open else: fopen = open source = fopen(fname).read() from gpaw.setup_data import SetupData s = SetupData(symbol, xc, name, readxml=False) s.read_xml(source=source) basis = get_orbitals_by_energy_shift(opts, s, xc=xc) basis.write_xml() else: for arg in args: setup = hgh_setups.get(arg) if setup is None: setup = hgh_sc_setups.get(arg.split('.')[0]) if setup is None: raise ValueError('Unknown setup %s' % arg) print(setup) basis = get_orbitals_by_energy_shift(opts, HGHSetupData(setup)) basis.write_xml()
def main(): p = build_parser() opts, args = p.parse_args() if opts.file: for fname in args: tokens = fname.split('.') symbol = tokens[0] xc = tokens[1] name = tokens[2] if tokens[-1] == 'gz': import gzip fopen = gzip.open else: fopen = open source = fopen(fname).read() from gpaw.setup_data import SetupData s = SetupData(symbol, xc, name, readxml=False) s.read_xml(source=source) basis = get_orbitals_by_energy_shift(opts, s, xc=xc) basis.write_xml() else: for arg in args: setup = hgh_setups.get(arg) if setup is None: setup = hgh_sc_setups.get(arg.split('.')[0]) if setup is None: raise ValueError('Unknown setup %s' % arg) print setup basis = get_orbitals_by_energy_shift(opts, HGHSetupData(setup)) basis.write_xml()
def print_projectors(setup): """Print information on the projectors of input nucleus object. If nucleus is a string, treat this as an element name. """ if isinstance(setup, str): setup = SetupData(setup, 'LDA', 'paw') n_j = setup.n_j l_j = setup.l_j else: n_j = setup.n_j l_j = setup.l_j angular = [ ['1'], ['y', 'z', 'x'], ['xy', 'yz', '3z^2-r^2', 'xz', 'x^2-y^2'], [ '3x^2y-y^3', 'xyz', '5yz^2-yr^2', '5z^3-3zr^2', '5xz^2-xr^2', 'x^2z-y^2z', 'x^3-3xy^2' ], ] print(' i n l m') print('--------') i = 0 for n, l in zip(n_j, l_j): for m in range(2 * l + 1): if n == -1: n = '*' print('%2s %s %s_%s' % (i, n, 'spdf'[l], angular[l][m])) i += 1
def create_setup(symbol, xc='LDA', lmax=0, type='paw', basis=None, setupdata=None, filter=None, world=None): if isinstance(xc, str): xc = XC(xc) if isinstance(type, str) and ':' in type: # Parse DFT+U parameters from type-string: # Examples: "type:l,U" or "type:l,U,scale" type, lu = type.split(':') if type == '': type = 'paw' l = 'spdf'.find(lu[0]) assert lu[1] == ',' U = lu[2:] if ',' in U: U, scale = U.split(',') else: scale = True U = float(U) / units.Hartree scale = int(scale) else: U = None if setupdata is None: if type == 'hgh' or type == 'hgh.sc': lmax = 0 from gpaw.hgh import HGHSetupData, setups, sc_setups if type == 'hgh.sc': table = sc_setups else: table = setups parameters = table[symbol] setupdata = HGHSetupData(parameters) elif type == 'ah': from gpaw.ah import AppelbaumHamann ah = AppelbaumHamann() ah.build(basis) return ah elif type == 'ae': from gpaw.ae import HydrogenAllElectronSetup assert symbol == 'H' ae = HydrogenAllElectronSetup() ae.build(basis) return ae elif type == 'ghost': from gpaw.lcao.bsse import GhostSetupData setupdata = GhostSetupData(symbol) else: setupdata = SetupData(symbol, xc.get_setup_name(), type, True, world=world) if hasattr(setupdata, 'build'): setup = LeanSetup(setupdata.build(xc, lmax, basis, filter)) if U is not None: setup.set_hubbard_u(U, l, scale) return setup else: return setupdata
def number_of_projectors(setup): """Returns the number of the bound state projectors. If setup is a string, treat this as an element name. """ if isinstance(setup, str): setup = SetupData(setup, 'LDA', 'paw') n_j = setup.n_j l_j = setup.l_j else: n_j = setup.n_j l_j = setup.l_j i = 0 for n, l in zip(n_j, l_j): for m in range(2 * l + 1): if n != -1: i += 1 return i
def make_paw_setup(self, tag=None): aea = self.aea setup = SetupData(aea.symbol, aea.xc.name, tag, readxml=False) nj = sum(len(waves) for waves in self.waves_l) setup.e_kin_jj = np.zeros((nj, nj)) setup.id_j = [] j1 = 0 for l, waves in enumerate(self.waves_l): ne = 0 for n, f, e, phi_g, phit_g, pt_g in zip(waves.n_n, waves.f_n, waves.e_n, waves.phi_ng, waves.phit_ng, waves.pt_ng): setup.append(n, l, f, e, waves.rcut, phi_g, phit_g, pt_g) if n == -1: ne += 1 id = '%s-%s%d' % (aea.symbol, 'spdf'[l], ne) else: id = '%s-%d%s' % (aea.symbol, n, 'spdf'[l]) setup.id_j.append(id) j2 = j1 + len(waves) setup.e_kin_jj[j1:j2, j1:j2] = waves.dekin_nn j1 = j2 setup.nc_g = self.nc_g * sqrt(4 * pi) setup.nct_g = self.nct_g * sqrt(4 * pi) setup.e_kinetic_core = self.ekincore setup.vbar_g = self.v0r_g * sqrt(4 * pi) setup.vbar_g[1:] /= self.rgd.r_g[1:] setup.vbar_g[0] = setup.vbar_g[1] setup.Z = aea.Z setup.Nc = self.ncore setup.Nv = self.nvalence setup.e_kinetic = aea.ekin setup.e_xc = aea.exc setup.e_electrostatic = aea.eH + aea.eZ setup.e_total = aea.exc + aea.ekin + aea.eH + aea.eZ setup.rgd = self.rgd setup.rcgauss = 1 / sqrt(self.alpha) self.calculate_exx_integrals() setup.ExxC = self.exxcc setup.X_p = pack2(self.exxcv_ii) setup.tauc_g = self.rgd.zeros() setup.tauct_g = self.rgd.zeros() #print 'no tau!!!!!!!!!!!' if self.aea.scalar_relativistic: reltype = 'scalar-relativistic' else: reltype = 'non-relativistic' attrs = [('type', reltype), ('version', 2), ('name', 'gpaw-%s' % version)] setup.generatorattrs = attrs setup.l0 = self.l0 setup.e0 = self.e0 setup.r0 = self.r0 setup.nderiv0 = self.nderiv0 return setup
def run(self, core='', rcut=1.0, extra=None, logderiv=False, vbar=None, exx=False, name=None, normconserving='', filter=(0.4, 1.75), rcutcomp=None, write_xml=True, use_restart_file=True, empty_states=''): self.name = name self.core = core if type(rcut) is float: rcut_l = [rcut] else: rcut_l = rcut rcutmax = max(rcut_l) rcutmin = min(rcut_l) self.rcut_l = rcut_l if rcutcomp is None: rcutcomp = rcutmin self.rcutcomp = rcutcomp hfilter, xfilter = filter Z = self.Z n_j = self.n_j l_j = self.l_j f_j = self.f_j e_j = self.e_j if vbar is None: vbar = ('poly', rcutmin * 0.9) vbar_type, rcutvbar = vbar normconserving_l = [x in normconserving for x in 'spdf'] # Parse core string: j = 0 if core.startswith('['): a, core = core.split(']') core_symbol = a[1:] j = len(configurations[core_symbol][1]) while core != '': assert n_j[j] == int(core[0]) assert l_j[j] == 'spdf'.find(core[1]) if j != self.jcorehole: assert f_j[j] == 2 * (2 * l_j[j] + 1) j += 1 core = core[2:] njcore = j self.njcore = njcore lmaxocc = max(l_j[njcore:]) while empty_states != '': n = int(empty_states[0]) l = 'spdf'.find(empty_states[1]) assert n == 1 + l + l_j.count(l) n_j.append(n) l_j.append(l) f_j.append(0.0) e_j.append(-0.01) empty_states = empty_states[2:] if 2 in l_j[njcore:]: # We have a bound valence d-state. Add bound s- and # p-states if not already there: for l in [0, 1]: if l not in l_j[njcore:]: n_j.append(1 + l + l_j.count(l)) l_j.append(l) f_j.append(0.0) e_j.append(-0.01) if l_j[njcore:] == [0] and Z > 2: # We have only a bound valence s-state and we are not # hydrogen and not helium. Add bound p-state: n_j.append(n_j[njcore]) l_j.append(1) f_j.append(0.0) e_j.append(-0.01) nj = len(n_j) self.Nv = sum(f_j[njcore:]) self.Nc = sum(f_j[:njcore]) # Do all-electron calculation: AllElectron.run(self, use_restart_file) # Highest occupied atomic orbital: self.emax = max(e_j) N = self.N r = self.r dr = self.dr d2gdr2 = self.d2gdr2 beta = self.beta dv = r**2 * dr t = self.text t() t('Generating PAW setup') if core != '': t('Frozen core:', core) # So far - no ghost-states: self.ghost = False # Calculate the kinetic energy of the core states: Ekincore = 0.0 j = 0 for f, e, u in zip(f_j[:njcore], e_j[:njcore], self.u_j[:njcore]): u = np.where(abs(u) < 1e-160, 0, u) # XXX Numeric! k = e - np.sum((u**2 * self.vr * dr)[1:] / r[1:]) Ekincore += f * k if j == self.jcorehole: self.Ekincorehole = k j += 1 # Calculate core density: if njcore == 0: nc = np.zeros(N) else: uc_j = self.u_j[:njcore] uc_j = np.where(abs(uc_j) < 1e-160, 0, uc_j) # XXX Numeric! nc = np.dot(f_j[:njcore], uc_j**2) / (4 * pi) nc[1:] /= r[1:]**2 nc[0] = nc[1] self.nc = nc # Calculate core kinetic energy density if njcore == 0: tauc = np.zeros(N) else: tauc = self.radial_kinetic_energy_density(f_j[:njcore], l_j[:njcore], self.u_j[:njcore]) t('Kinetic energy of the core from tauc =', np.dot(tauc * r * r, dr) * 4 * pi) lmax = max(l_j[njcore:]) # Order valence states with respect to angular momentum # quantum number: self.n_ln = n_ln = [] self.f_ln = f_ln = [] self.e_ln = e_ln = [] for l in range(lmax + 1): n_n = [] f_n = [] e_n = [] for j in range(njcore, nj): if l_j[j] == l: n_n.append(n_j[j]) f_n.append(f_j[j]) e_n.append(e_j[j]) n_ln.append(n_n) f_ln.append(f_n) e_ln.append(e_n) # Add extra projectors: if extra is not None: if len(extra) == 0: lmaxextra = 0 else: lmaxextra = max(extra.keys()) if lmaxextra > lmax: for l in range(lmax, lmaxextra): n_ln.append([]) f_ln.append([]) e_ln.append([]) lmax = lmaxextra for l in extra: nn = -1 for e in extra[l]: n_ln[l].append(nn) f_ln[l].append(0.0) e_ln[l].append(e) nn -= 1 else: # Automatic: # Make sure we have two projectors for each occupied channel: for l in range(lmaxocc + 1): if len(n_ln[l]) < 2 and not normconserving_l[l]: # Only one - add one more: assert len(n_ln[l]) == 1 n_ln[l].append(-1) f_ln[l].append(0.0) e_ln[l].append(1.0 + e_ln[l][0]) if lmaxocc < 2 and lmaxocc == lmax: # Add extra projector for l = lmax + 1: n_ln.append([-1]) f_ln.append([0.0]) e_ln.append([0.0]) lmax += 1 self.lmax = lmax rcut_l.extend([rcutmin] * (lmax + 1 - len(rcut_l))) t('Cutoffs:') for rc, s in zip(rcut_l, 'spdf'): t('rc(%s)=%.3f' % (s, rc)) t('rc(vbar)=%.3f' % rcutvbar) t('rc(comp)=%.3f' % rcutcomp) t('rc(nct)=%.3f' % rcutmax) t() t('Kinetic energy of the core states: %.6f' % Ekincore) # Allocate arrays: self.u_ln = u_ln = [] # phi * r self.s_ln = s_ln = [] # phi-tilde * r self.q_ln = q_ln = [] # p-tilde * r for l in range(lmax + 1): nn = len(n_ln[l]) u_ln.append(np.zeros((nn, N))) s_ln.append(np.zeros((nn, N))) q_ln.append(np.zeros((nn, N))) # Fill in all-electron wave functions: for l in range(lmax + 1): # Collect all-electron wave functions: u_n = [self.u_j[j] for j in range(njcore, nj) if l_j[j] == l] for n, u in enumerate(u_n): u_ln[l][n] = u # Grid-index corresponding to rcut: gcut_l = [1 + int(rc * N / (rc + beta)) for rc in rcut_l] rcutfilter = xfilter * rcutmax self.rcutfilter = rcutfilter gcutfilter = 1 + int(rcutfilter * N / (rcutfilter + beta)) gcutmax = 1 + int(rcutmax * N / (rcutmax + beta)) # Outward integration of unbound states stops at 3 * rcut: gmax = int(3 * rcutmax * N / (3 * rcutmax + beta)) assert gmax > gcutfilter # Calculate unbound extra states: c2 = -(r / dr)**2 c10 = -d2gdr2 * r**2 for l, (n_n, e_n, u_n) in enumerate(zip(n_ln, e_ln, u_ln)): for n, e, u in zip(n_n, e_n, u_n): if n < 0: u[:] = 0.0 shoot(u, l, self.vr, e, self.r2dvdr, r, dr, c10, c2, self.scalarrel, gmax=gmax) u *= 1.0 / u[gcut_l[l]] charge = Z - self.Nv - self.Nc t('Charge: %.1f' % charge) t('Core electrons: %.1f' % self.Nc) t('Valence electrons: %.1f' % self.Nv) # Construct smooth wave functions: coefs = [] for l, (u_n, s_n) in enumerate(zip(u_ln, s_ln)): nodeless = True gc = gcut_l[l] for u, s in zip(u_n, s_n): s[:] = u if normconserving_l[l]: A = np.zeros((5, 5)) A[:4, 0] = 1.0 A[:4, 1] = r[gc - 2:gc + 2]**2 A[:4, 2] = A[:4, 1]**2 A[:4, 3] = A[:4, 1] * A[:4, 2] A[:4, 4] = A[:4, 2]**2 A[4, 4] = 1.0 a = u[gc - 2:gc + 3] / r[gc - 2:gc + 3]**(l + 1) a = np.log(a) def f(x): a[4] = x b = solve(A, a) r1 = r[:gc] r2 = r1**2 rl1 = r1**(l + 1) y = b[0] + r2 * (b[1] + r2 * (b[2] + r2 * (b[3] + r2 * b[4]))) y = np.exp(y) s[:gc] = rl1 * y return np.dot(s**2, dr) - 1 x1 = 0.0 x2 = 0.001 f1 = f(x1) f2 = f(x2) while abs(f1) > 1e-6: x0 = (x1 / f1 - x2 / f2) / (1 / f1 - 1 / f2) f0 = f(x0) if abs(f1) < abs(f2): x2, f2 = x1, f1 x1, f1 = x0, f0 else: A = np.ones((4, 4)) A[:, 0] = 1.0 A[:, 1] = r[gc - 2:gc + 2]**2 A[:, 2] = A[:, 1]**2 A[:, 3] = A[:, 1] * A[:, 2] a = u[gc - 2:gc + 2] / r[gc - 2:gc + 2]**(l + 1) if 0:#l < 2 and nodeless: a = np.log(a) a = solve(A, a) r1 = r[:gc] r2 = r1**2 rl1 = r1**(l + 1) y = a[0] + r2 * (a[1] + r2 * (a[2] + r2 * (a[3]))) if 0:#l < 2 and nodeless: y = np.exp(y) s[:gc] = rl1 * y coefs.append(a) if nodeless: if not np.alltrue(s[1:gc] > 0.0): raise RuntimeError( 'Error: The %d%s pseudo wave has a node!' % (n_ln[l][0], 'spdf'[l])) # Only the first state for each l must be nodeless: nodeless = False # Calculate pseudo core density: gcutnc = 1 + int(rcutmax * N / (rcutmax + beta)) self.nct = nct = nc.copy() A = np.ones((4, 4)) A[0] = 1.0 A[1] = r[gcutnc - 2:gcutnc + 2]**2 A[2] = A[1]**2 A[3] = A[1] * A[2] a = nc[gcutnc - 2:gcutnc + 2] a = solve(np.transpose(A), a) r2 = r[:gcutnc]**2 nct[:gcutnc] = a[0] + r2 * (a[1] + r2 * (a[2] + r2 * a[3])) t('Pseudo-core charge: %.6f' % (4 * pi * np.dot(nct, dv))) # ... and the pseudo core kinetic energy density: tauct = tauc.copy() a = tauc[gcutnc - 2:gcutnc + 2] a = solve(np.transpose(A), a) tauct[:gcutnc] = a[0] + r2 * (a[1] + r2 * (a[2] + r2 * a[3])) # ... and the soft valence density: nt = np.zeros(N) for f_n, s_n in zip(f_ln, s_ln): nt += np.dot(f_n, s_n**2) / (4 * pi) nt[1:] /= r[1:]**2 nt[0] = nt[1] nt += nct self.nt = nt # Calculate the shape function: x = r / rcutcomp gaussian = np.zeros(N) self.gamma = gamma = 10.0 gaussian[:gmax] = np.exp(-gamma * x[:gmax]**2) gt = 4 * (gamma / rcutcomp**2)**1.5 / sqrt(pi) * gaussian t('Shape function alpha=%.3f' % (gamma / rcutcomp**2)) norm = np.dot(gt, dv) #print norm, norm-1 assert abs(norm - 1) < 1e-2 gt /= norm # Calculate smooth charge density: Nt = np.dot(nt, dv) rhot = nt - (Nt + charge / (4 * pi)) * gt t('Pseudo-electron charge', 4 * pi * Nt) vHt = np.zeros(N) hartree(0, rhot * r * dr, self.beta, self.N, vHt) vHt[1:] /= r[1:] vHt[0] = vHt[1] vXCt = np.zeros(N) extra_xc_data = {} if self.xc.type != 'GLLB': Exct = self.xc.calculate_spherical(self.rgd, nt.reshape((1, -1)), vXCt.reshape((1, -1))) else: Exct = self.xc.get_smooth_xc_potential_and_energy_1d(vXCt) # Calculate extra-stuff for non-local functionals self.xc.get_extra_setup_data(extra_xc_data) vt = vHt + vXCt # Construct zero potential: gc = 1 + int(rcutvbar * N / (rcutvbar + beta)) if vbar_type == 'f': assert lmax == 2 uf = np.zeros(N) l = 3 # Solve for all-electron f-state: eps = 0.0 shoot(uf, l, self.vr, eps, self.r2dvdr, r, dr, c10, c2, self.scalarrel, gmax=gmax) uf *= 1.0 / uf[gc] # Fit smooth pseudo f-state polynomium: A = np.ones((4, 4)) A[:, 0] = 1.0 A[:, 1] = r[gc - 2:gc + 2]**2 A[:, 2] = A[:, 1]**2 A[:, 3] = A[:, 1] * A[:, 2] a = uf[gc - 2:gc + 2] / r[gc - 2:gc + 2]**(l + 1) a0, a1, a2, a3 = solve(A, a) r1 = r[:gc] r2 = r1**2 rl1 = r1**(l + 1) y = a0 + r2 * (a1 + r2 * (a2 + r2 * a3)) sf = uf.copy() sf[:gc] = rl1 * y # From 0 to gc, use analytic formula for kinetic energy operator: r4 = r2**2 r6 = r4 * r2 enumerator = (a0 * l * (l + 1) + a1 * (l + 2) * (l + 3) * r2 + a2 * (l + 4) * (l + 5) * r4 + a3 * (l + 6) * (l + 7) * r6) denominator = a0 + a1 * r2 + a2 * r4 + a3 * r6 ekin_over_phit = - 0.5 * (enumerator / denominator - l * (l + 1)) ekin_over_phit[1:] /= r2[1:] vbar = eps - vt vbar[:gc] -= ekin_over_phit vbar[0] = vbar[1] # Actually we can collect the terms into # a single fraction without poles, so as to avoid doing this, # but this is good enough # From gc to gmax, use finite-difference formula for kinetic # energy operator: vbar[gc:gmax] -= self.kin(l, sf)[gc:gmax] / sf[gc:gmax] vbar[gmax:] = 0.0 else: assert vbar_type == 'poly' A = np.ones((2, 2)) A[0] = 1.0 A[1] = r[gc - 1:gc + 1]**2 a = vt[gc - 1:gc + 1] a = solve(np.transpose(A), a) r2 = r**2 vbar = a[0] + r2 * a[1] - vt vbar[gc:] = 0.0 vt += vbar # Construct projector functions: for l, (e_n, s_n, q_n) in enumerate(zip(e_ln, s_ln, q_ln)): for e, s, q in zip(e_n, s_n, q_n): q[:] = self.kin(l, s) + (vt - e) * s q[gcutmax:] = 0.0 filter = Filter(r, dr, gcutfilter, hfilter).filter vbar = filter(vbar * r) # Calculate matrix elements: self.dK_lnn = dK_lnn = [] self.dH_lnn = dH_lnn = [] self.dO_lnn = dO_lnn = [] for l, (e_n, u_n, s_n, q_n) in enumerate(zip(e_ln, u_ln, s_ln, q_ln)): A_nn = np.inner(s_n, q_n * dr) # Do a LU decomposition of A: nn = len(e_n) L_nn = np.identity(nn, float) U_nn = A_nn.copy() # Keep all bound states normalized if sum([n > 0 for n in n_ln[l]]) <= 1: for i in range(nn): for j in range(i + 1, nn): L_nn[j, i] = 1.0 * U_nn[j, i] / U_nn[i, i] U_nn[j, :] -= U_nn[i, :] * L_nn[j, i] dO_nn = (np.inner(u_n, u_n * dr) - np.inner(s_n, s_n * dr)) e_nn = np.zeros((nn, nn)) e_nn.ravel()[::nn + 1] = e_n dH_nn = np.dot(dO_nn, e_nn) - A_nn q_n[:] = np.dot(inv(np.transpose(U_nn)), q_n) s_n[:] = np.dot(inv(L_nn), s_n) u_n[:] = np.dot(inv(L_nn), u_n) dO_nn = np.dot(np.dot(inv(L_nn), dO_nn), inv(np.transpose(L_nn))) dH_nn = np.dot(np.dot(inv(L_nn), dH_nn), inv(np.transpose(L_nn))) ku_n = [self.kin(l, u, e) for u, e in zip(u_n, e_n)] ks_n = [self.kin(l, s) for s in s_n] dK_nn = 0.5 * (np.inner(u_n, ku_n * dr) - np.inner(s_n, ks_n * dr)) dK_nn += np.transpose(dK_nn).copy() dK_lnn.append(dK_nn) dO_lnn.append(dO_nn) dH_lnn.append(dH_nn) for n, q in enumerate(q_n): q[:] = filter(q, l) * r**(l + 1) A_nn = np.inner(s_n, q_n * dr) q_n[:] = np.dot(inv(np.transpose(A_nn)), q_n) self.vt = vt self.vbar = vbar t('state eigenvalue norm') t('--------------------------------') for l, (n_n, f_n, e_n) in enumerate(zip(n_ln, f_ln, e_ln)): for n in range(len(e_n)): if n_n[n] > 0: f = '(%d)' % f_n[n] t('%d%s%-4s: %12.6f %12.6f' % ( n_n[n], 'spdf'[l], f, e_n[n], np.dot(s_ln[l][n]**2, dr))) else: t('*%s : %12.6f' % ('spdf'[l], e_n[n])) t('--------------------------------') self.logd = {} if logderiv: ni = 300 self.elog = np.linspace(-5.0, 1.0, ni) # Calculate logarithmic derivatives: gld = gcutmax + 10 self.rlog = r[gld] assert gld < gmax t('Calculating logarithmic derivatives at r=%.3f' % r[gld]) t('(skip with [Ctrl-C])') try: u = np.zeros(N) for l in range(4): self.logd[l] = (np.empty(ni), np.empty(ni)) if l <= lmax: dO_nn = dO_lnn[l] dH_nn = dH_lnn[l] q_n = q_ln[l] fae = open(self.symbol + '.ae.ld.' + 'spdf'[l], 'w') fps = open(self.symbol + '.ps.ld.' + 'spdf'[l], 'w') for i, e in enumerate(self.elog): # All-electron logarithmic derivative: u[:] = 0.0 shoot(u, l, self.vr, e, self.r2dvdr, r, dr, c10, c2, self.scalarrel, gmax=gld) dudr = 0.5 * (u[gld + 1] - u[gld - 1]) / dr[gld] ld = dudr / u[gld] - 1.0 / r[gld] print >> fae, e, ld self.logd[l][0][i] = ld # PAW logarithmic derivative: s = self.integrate(l, vt, e, gld) if l <= lmax: A_nn = dH_nn - e * dO_nn s_n = [self.integrate(l, vt, e, gld, q) for q in q_n] B_nn = np.inner(q_n, s_n * dr) a_n = np.dot(q_n, s * dr) B_nn = np.dot(A_nn, B_nn) B_nn.ravel()[::len(a_n) + 1] += 1.0 c_n = solve(B_nn, np.dot(A_nn, a_n)) s -= np.dot(c_n, s_n) dsdr = 0.5 * (s[gld + 1] - s[gld - 1]) / dr[gld] ld = dsdr / s[gld] - 1.0 / r[gld] print >> fps, e, ld self.logd[l][1][i] = ld except KeyboardInterrupt: pass self.write(nc,'nc') self.write(nt, 'nt') self.write(nct, 'nct') self.write(vbar, 'vbar') self.write(vt, 'vt') self.write(tauc, 'tauc') self.write(tauct, 'tauct') for l, (n_n, f_n, u_n, s_n, q_n) in enumerate(zip(n_ln, f_ln, u_ln, s_ln, q_ln)): for n, f, u, s, q in zip(n_n, f_n, u_n, s_n, q_n): if n < 0: self.write(u, 'ae', n=n, l=l) self.write(s, 'ps', n=n, l=l) self.write(q, 'proj', n=n, l=l) # Test for ghost states: for h in [0.05]: self.diagonalize(h) self.vn_j = vn_j = [] self.vl_j = vl_j = [] self.vf_j = vf_j = [] self.ve_j = ve_j = [] self.vu_j = vu_j = [] self.vs_j = vs_j = [] self.vq_j = vq_j = [] j_ln = [[0 for f in f_n] for f_n in f_ln] j = 0 for l, n_n in enumerate(n_ln): for n, nn in enumerate(n_n): if nn > 0: vf_j.append(f_ln[l][n]) vn_j.append(nn) vl_j.append(l) ve_j.append(e_ln[l][n]) vu_j.append(u_ln[l][n]) vs_j.append(s_ln[l][n]) vq_j.append(q_ln[l][n]) j_ln[l][n] = j j += 1 for l, n_n in enumerate(n_ln): for n, nn in enumerate(n_n): if nn < 0: vf_j.append(0) vn_j.append(nn) vl_j.append(l) ve_j.append(e_ln[l][n]) vu_j.append(u_ln[l][n]) vs_j.append(s_ln[l][n]) vq_j.append(q_ln[l][n]) j_ln[l][n] = j j += 1 nj = j self.dK_jj = np.zeros((nj, nj)) for l, j_n in enumerate(j_ln): for n1, j1 in enumerate(j_n): for n2, j2 in enumerate(j_n): self.dK_jj[j1, j2] = self.dK_lnn[l][n1, n2] if exx: X_p = constructX(self) ExxC = atomic_exact_exchange(self, 'core-core') else: X_p = None ExxC = None sqrt4pi = sqrt(4 * pi) setup = SetupData(self.symbol, self.xc.name, self.name, readxml=False) def divide_by_r(x_g, l): r = self.r #for x_g, l in zip(x_jg, l_j): p = x_g.copy() p[1:] /= self.r[1:] # XXXXX go to higher order!!!!! if l == 0:#l_j[self.jcorehole] == 0: p[0] = (p[2] + (p[1] - p[2]) * (r[0] - r[2]) / (r[1] - r[2])) return p def divide_all_by_r(x_jg): return [divide_by_r(x_g, l) for x_g, l in zip(x_jg, vl_j)] setup.l_j = vl_j setup.n_j = vn_j setup.f_j = vf_j setup.eps_j = ve_j setup.rcut_j = [rcut_l[l] for l in vl_j] setup.nc_g = nc * sqrt4pi setup.nct_g = nct * sqrt4pi setup.nvt_g = (nt - nct) * sqrt4pi setup.e_kinetic_core = Ekincore setup.vbar_g = vbar * sqrt4pi setup.tauc_g = tauc * sqrt4pi setup.tauct_g = tauct * sqrt4pi setup.extra_xc_data = extra_xc_data setup.Z = Z setup.Nc = self.Nc setup.Nv = self.Nv setup.e_kinetic = self.Ekin setup.e_xc = self.Exc setup.e_electrostatic = self.Epot setup.e_total = self.Epot + self.Exc + self.Ekin setup.rgd = self.rgd setup.rcgauss = self.rcutcomp / sqrt(self.gamma) setup.e_kin_jj = self.dK_jj setup.ExxC = ExxC setup.phi_jg = divide_all_by_r(vu_j) setup.phit_jg = divide_all_by_r(vs_j) setup.pt_jg = divide_all_by_r(vq_j) setup.X_p = X_p if self.jcorehole is not None: setup.has_corehole = True setup.lcorehole = l_j[self.jcorehole] # l_j or vl_j ????? XXX setup.ncorehole = n_j[self.jcorehole] setup.phicorehole_g = divide_by_r(self.u_j[self.jcorehole], setup.lcorehole) setup.core_hole_e = self.e_j[self.jcorehole] setup.core_hole_e_kin = self.Ekincorehole setup.fcorehole = self.fcorehole if self.ghost: raise RuntimeError('Ghost!') if self.scalarrel: reltype = 'scalar-relativistic' else: reltype = 'non-relativistic' attrs = [('type', reltype), ('name', 'gpaw-%s' % version)] data = 'Frozen core: '+ (self.core or 'none') setup.generatorattrs = attrs setup.generatordata = data self.id_j = [] for l, n in zip(vl_j, vn_j): if n > 0: id = '%s-%d%s' % (self.symbol, n, 'spdf'[l]) else: id = '%s-%s%d' % (self.symbol, 'spdf'[l], -n) self.id_j.append(id) setup.id_j = self.id_j if write_xml: setup.write_xml() return setup
def make_paw_setup(self, tag=None): aea = self.aea from gpaw.setup_data import SetupData setup = SetupData(aea.symbol, aea.xc.name, tag, readxml=False) setup.id_j = [] J = [] # new reordered j and i indices I = [] # Bound states: j = 0 i = 0 for l, waves in enumerate(self.waves_l): for n, f, e, phi_g, phit_g, pt_g in zip(waves.n_n, waves.f_n, waves.e_n, waves.phi_ng, waves.phit_ng, waves.pt_ng): if n != -1: setup.append(n, l, f, e, waves.rcut, phi_g, phit_g, pt_g) id = '%d%s' % (n, 'spdf'[l]) setup.id_j.append(id) J.append(j) I.extend(range(i, i + 2 * l + 1)) j += 1 i += 2 * l + 1 # Excited states: j = 0 i = 0 for l, waves in enumerate(self.waves_l): ne = 0 for n, f, e, phi_g, phit_g, pt_g in zip(waves.n_n, waves.f_n, waves.e_n, waves.phi_ng, waves.phit_ng, waves.pt_ng): if n == -1: setup.append(n, l, f, e, waves.rcut, phi_g, phit_g, pt_g) ne += 1 id = '%s%d' % ('spdf'[l], ne) setup.id_j.append(id) J.append(j) I.extend(range(i, i + 2 * l + 1)) j += 1 i += 2 * l + 1 nj = sum(len(waves) for waves in self.waves_l) e_kin_jj = np.zeros((nj, nj)) j1 = 0 for waves in self.waves_l: j2 = j1 + len(waves) e_kin_jj[j1:j2, j1:j2] = waves.dekin_nn j1 = j2 setup.e_kin_jj = e_kin_jj[J][:, J].copy() setup.nc_g = self.nc_g * sqrt(4 * pi) setup.nct_g = self.nct_g * sqrt(4 * pi) setup.e_kinetic_core = self.ekincore setup.vbar_g = self.v0r_g * sqrt(4 * pi) setup.vbar_g[1:] /= self.rgd.r_g[1:] setup.vbar_g[0] = setup.vbar_g[1] setup.Z = aea.Z setup.Nc = self.ncore setup.Nv = self.nvalence setup.e_kinetic = aea.ekin setup.e_xc = aea.exc setup.e_electrostatic = aea.eH + aea.eZ setup.e_total = aea.exc + aea.ekin + aea.eH + aea.eZ setup.rgd = self.rgd setup.rcgauss = 1 / sqrt(self.alpha) self.calculate_exx_integrals() setup.ExxC = self.exxcc setup.X_p = pack2(self.exxcv_ii[I][:, I]) setup.tauc_g = self.tauc_g * (4 * pi)**0.5 setup.tauct_g = self.tauct_g * (4 * pi)**0.5 if self.aea.scalar_relativistic: reltype = 'scalar-relativistic' else: reltype = 'non-relativistic' attrs = [('type', reltype), ('version', 2), ('name', 'gpaw-%s' % version)] setup.generatorattrs = attrs setup.l0 = self.l0 setup.e0 = 0.0 setup.r0 = self.r0 setup.nderiv0 = self.nderiv0 setup.basis = self.basis if self.core_hole: n, l, occ = self.core_hole phi_g = self.aea.channels[l].phi_ng[n - l - 1] setup.ncorehole = n setup.lcorehole = l setup.fcorehole = occ setup.phicorehole_g = phi_g setup.has_corehole = True return setup
def run(self, core='', rcut=1.0, extra=None, logderiv=False, vbar=None, exx=False, name=None, normconserving='', filter=(0.4, 1.75), rcutcomp=None, write_xml=True, use_restart_file=True, empty_states=''): self.name = name self.core = core if type(rcut) is float: rcut_l = [rcut] else: rcut_l = rcut rcutmax = max(rcut_l) rcutmin = min(rcut_l) self.rcut_l = rcut_l if rcutcomp is None: rcutcomp = rcutmin self.rcutcomp = rcutcomp hfilter, xfilter = filter Z = self.Z n_j = self.n_j l_j = self.l_j f_j = self.f_j e_j = self.e_j if vbar is None: vbar = ('poly', rcutmin * 0.9) vbar_type, rcutvbar = vbar normconserving_l = [x in normconserving for x in 'spdf'] # Parse core string: j = 0 if core.startswith('['): a, core = core.split(']') core_symbol = a[1:] j = len(configurations[core_symbol][1]) while core != '': assert n_j[j] == int(core[0]) assert l_j[j] == 'spdf'.find(core[1]) if j != self.jcorehole: assert f_j[j] == 2 * (2 * l_j[j] + 1) j += 1 core = core[2:] njcore = j self.njcore = njcore lmaxocc = max(l_j[njcore:]) while empty_states != '': n = int(empty_states[0]) l = 'spdf'.find(empty_states[1]) print l_j assert n == 1 + l + l_j.count(l) n_j.append(n) l_j.append(l) f_j.append(0.0) e_j.append(-0.01) empty_states = empty_states[2:] if 2 in l_j[njcore:]: # We have a bound valence d-state. Add bound s- and # p-states if not already there: for l in [0, 1]: if l not in l_j[njcore:]: n_j.append(1 + l + l_j.count(l)) l_j.append(l) f_j.append(0.0) e_j.append(-0.01) if l_j[njcore:] == [0] and Z > 2: # We have only a bound valence s-state and we are not # hydrogen and not helium. Add bound p-state: n_j.append(n_j[njcore]) l_j.append(1) f_j.append(0.0) e_j.append(-0.01) nj = len(n_j) self.Nv = sum(f_j[njcore:]) self.Nc = sum(f_j[:njcore]) # Do all-electron calculation: AllElectron.run(self, use_restart_file) # Highest occupied atomic orbital: self.emax = max(e_j) N = self.N r = self.r dr = self.dr d2gdr2 = self.d2gdr2 beta = self.beta dv = r**2 * dr t = self.text t() t('Generating PAW setup') if core != '': t('Frozen core:', core) # So far - no ghost-states: self.ghost = False # Calculate the kinetic energy of the core states: Ekincore = 0.0 j = 0 for f, e, u in zip(f_j[:njcore], e_j[:njcore], self.u_j[:njcore]): u = np.where(abs(u) < 1e-160, 0, u) # XXX Numeric! k = e - np.sum((u**2 * self.vr * dr)[1:] / r[1:]) Ekincore += f * k if j == self.jcorehole: self.Ekincorehole = k j += 1 # Calculate core density: if njcore == 0: nc = np.zeros(N) else: uc_j = self.u_j[:njcore] uc_j = np.where(abs(uc_j) < 1e-160, 0, uc_j) # XXX Numeric! nc = np.dot(f_j[:njcore], uc_j**2) / (4 * pi) nc[1:] /= r[1:]**2 nc[0] = nc[1] self.nc = nc # Calculate core kinetic energy density if njcore == 0: tauc = np.zeros(N) else: tauc = self.radial_kinetic_energy_density(f_j[:njcore], l_j[:njcore], self.u_j[:njcore]) t('Kinetic energy of the core from tauc =', np.dot(tauc * r * r, dr) * 4 * pi) lmax = max(l_j[njcore:]) # Order valence states with respect to angular momentum # quantum number: self.n_ln = n_ln = [] self.f_ln = f_ln = [] self.e_ln = e_ln = [] for l in range(lmax + 1): n_n = [] f_n = [] e_n = [] for j in range(njcore, nj): if l_j[j] == l: n_n.append(n_j[j]) f_n.append(f_j[j]) e_n.append(e_j[j]) n_ln.append(n_n) f_ln.append(f_n) e_ln.append(e_n) # Add extra projectors: if extra is not None: if len(extra) == 0: lmaxextra = 0 else: lmaxextra = max(extra.keys()) if lmaxextra > lmax: for l in range(lmax, lmaxextra): n_ln.append([]) f_ln.append([]) e_ln.append([]) lmax = lmaxextra for l in extra: nn = -1 for e in extra[l]: n_ln[l].append(nn) f_ln[l].append(0.0) e_ln[l].append(e) nn -= 1 else: # Automatic: # Make sure we have two projectors for each occupied channel: for l in range(lmaxocc + 1): if len(n_ln[l]) < 2 and not normconserving_l[l]: # Only one - add one more: assert len(n_ln[l]) == 1 n_ln[l].append(-1) f_ln[l].append(0.0) e_ln[l].append(1.0 + e_ln[l][0]) if lmaxocc < 2 and lmaxocc == lmax: # Add extra projector for l = lmax + 1: n_ln.append([-1]) f_ln.append([0.0]) e_ln.append([0.0]) lmax += 1 self.lmax = lmax rcut_l.extend([rcutmin] * (lmax + 1 - len(rcut_l))) t('Cutoffs:') for rc, s in zip(rcut_l, 'spdf'): t('rc(%s)=%.3f' % (s, rc)) t('rc(vbar)=%.3f' % rcutvbar) t('rc(comp)=%.3f' % rcutcomp) t() t('Kinetic energy of the core states: %.6f' % Ekincore) # Allocate arrays: self.u_ln = u_ln = [] # phi * r self.s_ln = s_ln = [] # phi-tilde * r self.q_ln = q_ln = [] # p-tilde * r for l in range(lmax + 1): nn = len(n_ln[l]) u_ln.append(np.zeros((nn, N))) s_ln.append(np.zeros((nn, N))) q_ln.append(np.zeros((nn, N))) # Fill in all-electron wave functions: for l in range(lmax + 1): # Collect all-electron wave functions: u_n = [self.u_j[j] for j in range(njcore, nj) if l_j[j] == l] for n, u in enumerate(u_n): u_ln[l][n] = u # Grid-index corresponding to rcut: gcut_l = [1 + int(rc * N / (rc + beta)) for rc in rcut_l] rcutfilter = xfilter * rcutmax self.rcutfilter = rcutfilter gcutfilter = 1 + int(rcutfilter * N / (rcutfilter + beta)) gcutmax = 1 + int(rcutmax * N / (rcutmax + beta)) # Outward integration of unbound states stops at 3 * rcut: gmax = int(3 * rcutmax * N / (3 * rcutmax + beta)) assert gmax > gcutfilter # Calculate unbound extra states: c2 = -(r / dr)**2 c10 = -d2gdr2 * r**2 for l, (n_n, e_n, u_n) in enumerate(zip(n_ln, e_ln, u_ln)): for n, e, u in zip(n_n, e_n, u_n): if n < 0: u[:] = 0.0 shoot(u, l, self.vr, e, self.r2dvdr, r, dr, c10, c2, self.scalarrel, gmax=gmax) u *= 1.0 / u[gcut_l[l]] charge = Z - self.Nv - self.Nc t('Charge: %.1f' % charge) t('Core electrons: %.1f' % self.Nc) t('Valence electrons: %.1f' % self.Nv) # Construct smooth wave functions: coefs = [] for l, (u_n, s_n) in enumerate(zip(u_ln, s_ln)): nodeless = True gc = gcut_l[l] for u, s in zip(u_n, s_n): s[:] = u if normconserving_l[l]: A = np.zeros((5, 5)) A[:4, 0] = 1.0 A[:4, 1] = r[gc - 2:gc + 2]**2 A[:4, 2] = A[:4, 1]**2 A[:4, 3] = A[:4, 1] * A[:4, 2] A[:4, 4] = A[:4, 2]**2 A[4, 4] = 1.0 a = u[gc - 2:gc + 3] / r[gc - 2:gc + 3]**(l + 1) a = np.log(a) def f(x): a[4] = x b = solve(A, a) r1 = r[:gc] r2 = r1**2 rl1 = r1**(l + 1) y = b[0] + r2 * (b[1] + r2 * (b[2] + r2 * (b[3] + r2 * b[4]))) y = np.exp(y) s[:gc] = rl1 * y return np.dot(s**2, dr) - 1 x1 = 0.0 x2 = 0.001 f1 = f(x1) f2 = f(x2) while abs(f1) > 1e-6: x0 = (x1 / f1 - x2 / f2) / (1 / f1 - 1 / f2) f0 = f(x0) if abs(f1) < abs(f2): x2, f2 = x1, f1 x1, f1 = x0, f0 else: A = np.ones((4, 4)) A[:, 0] = 1.0 A[:, 1] = r[gc - 2:gc + 2]**2 A[:, 2] = A[:, 1]**2 A[:, 3] = A[:, 1] * A[:, 2] a = u[gc - 2:gc + 2] / r[gc - 2:gc + 2]**(l + 1) if 0: #l < 2 and nodeless: a = np.log(a) a = solve(A, a) r1 = r[:gc] r2 = r1**2 rl1 = r1**(l + 1) y = a[0] + r2 * (a[1] + r2 * (a[2] + r2 * (a[3]))) if 0: #l < 2 and nodeless: y = np.exp(y) s[:gc] = rl1 * y coefs.append(a) if nodeless: if not np.alltrue(s[1:gc] > 0.0): raise RuntimeError( 'Error: The %d%s pseudo wave has a node!' % (n_ln[l][0], 'spdf'[l])) # Only the first state for each l must be nodeless: nodeless = False # Calculate pseudo core density: gcutnc = 1 + int(rcutmax * N / (rcutmax + beta)) self.nct = nct = nc.copy() A = np.ones((4, 4)) A[0] = 1.0 A[1] = r[gcutnc - 2:gcutnc + 2]**2 A[2] = A[1]**2 A[3] = A[1] * A[2] a = nc[gcutnc - 2:gcutnc + 2] a = solve(np.transpose(A), a) r2 = r[:gcutnc]**2 nct[:gcutnc] = a[0] + r2 * (a[1] + r2 * (a[2] + r2 * a[3])) t('Pseudo-core charge: %.6f' % (4 * pi * np.dot(nct, dv))) # ... and the pseudo core kinetic energy density: tauct = tauc.copy() a = tauc[gcutnc - 2:gcutnc + 2] a = solve(np.transpose(A), a) tauct[:gcutnc] = a[0] + r2 * (a[1] + r2 * (a[2] + r2 * a[3])) # ... and the soft valence density: nt = np.zeros(N) for f_n, s_n in zip(f_ln, s_ln): nt += np.dot(f_n, s_n**2) / (4 * pi) nt[1:] /= r[1:]**2 nt[0] = nt[1] nt += nct self.nt = nt # Calculate the shape function: x = r / rcutcomp gaussian = np.zeros(N) self.gamma = gamma = 10.0 gaussian[:gmax] = np.exp(-gamma * x[:gmax]**2) gt = 4 * (gamma / rcutcomp**2)**1.5 / sqrt(pi) * gaussian norm = np.dot(gt, dv) #print norm, norm-1 assert abs(norm - 1) < 1e-2 gt /= norm # Calculate smooth charge density: Nt = np.dot(nt, dv) rhot = nt - (Nt + charge / (4 * pi)) * gt t('Pseudo-electron charge', 4 * pi * Nt) vHt = np.zeros(N) hartree(0, rhot * r * dr, self.beta, self.N, vHt) vHt[1:] /= r[1:] vHt[0] = vHt[1] vXCt = np.zeros(N) extra_xc_data = {} if self.xc.type != 'GLLB': Exct = self.xc.calculate_spherical(self.rgd, nt.reshape((1, -1)), vXCt.reshape((1, -1))) else: Exct = self.xc.get_smooth_xc_potential_and_energy_1d(vXCt) # Calculate extra-stuff for non-local functionals self.xc.get_extra_setup_data(extra_xc_data) vt = vHt + vXCt # Construct zero potential: gc = 1 + int(rcutvbar * N / (rcutvbar + beta)) if vbar_type == 'f': assert lmax == 2 uf = np.zeros(N) l = 3 # Solve for all-electron f-state: eps = 0.0 shoot(uf, l, self.vr, eps, self.r2dvdr, r, dr, c10, c2, self.scalarrel, gmax=gmax) uf *= 1.0 / uf[gc] # Fit smooth pseudo f-state polynomium: A = np.ones((4, 4)) A[:, 0] = 1.0 A[:, 1] = r[gc - 2:gc + 2]**2 A[:, 2] = A[:, 1]**2 A[:, 3] = A[:, 1] * A[:, 2] a = uf[gc - 2:gc + 2] / r[gc - 2:gc + 2]**(l + 1) a0, a1, a2, a3 = solve(A, a) r1 = r[:gc] r2 = r1**2 rl1 = r1**(l + 1) y = a0 + r2 * (a1 + r2 * (a2 + r2 * a3)) sf = uf.copy() sf[:gc] = rl1 * y # From 0 to gc, use analytic formula for kinetic energy operator: r4 = r2**2 r6 = r4 * r2 enumerator = (a0 * l * (l + 1) + a1 * (l + 2) * (l + 3) * r2 + a2 * (l + 4) * (l + 5) * r4 + a3 * (l + 6) * (l + 7) * r6) denominator = a0 + a1 * r2 + a2 * r4 + a3 * r6 ekin_over_phit = -0.5 * (enumerator / denominator - l * (l + 1)) ekin_over_phit[1:] /= r2[1:] vbar = eps - vt vbar[:gc] -= ekin_over_phit vbar[0] = vbar[1] # Actually we can collect the terms into # a single fraction without poles, so as to avoid doing this, # but this is good enough # From gc to gmax, use finite-difference formula for kinetic # energy operator: vbar[gc:gmax] -= self.kin(l, sf)[gc:gmax] / sf[gc:gmax] vbar[gmax:] = 0.0 else: assert vbar_type == 'poly' A = np.ones((2, 2)) A[0] = 1.0 A[1] = r[gc - 1:gc + 1]**2 a = vt[gc - 1:gc + 1] a = solve(np.transpose(A), a) r2 = r**2 vbar = a[0] + r2 * a[1] - vt vbar[gc:] = 0.0 vt += vbar # Construct projector functions: for l, (e_n, s_n, q_n) in enumerate(zip(e_ln, s_ln, q_ln)): for e, s, q in zip(e_n, s_n, q_n): q[:] = self.kin(l, s) + (vt - e) * s q[gcutmax:] = 0.0 filter = Filter(r, dr, gcutfilter, hfilter).filter vbar = filter(vbar * r) # Calculate matrix elements: self.dK_lnn = dK_lnn = [] self.dH_lnn = dH_lnn = [] self.dO_lnn = dO_lnn = [] for l, (e_n, u_n, s_n, q_n) in enumerate(zip(e_ln, u_ln, s_ln, q_ln)): A_nn = np.inner(s_n, q_n * dr) # Do a LU decomposition of A: nn = len(e_n) L_nn = np.identity(nn, float) U_nn = A_nn.copy() # Keep all bound states normalized if sum([n > 0 for n in n_ln[l]]) <= 1: for i in range(nn): for j in range(i + 1, nn): L_nn[j, i] = 1.0 * U_nn[j, i] / U_nn[i, i] U_nn[j, :] -= U_nn[i, :] * L_nn[j, i] dO_nn = (np.inner(u_n, u_n * dr) - np.inner(s_n, s_n * dr)) e_nn = np.zeros((nn, nn)) e_nn.ravel()[::nn + 1] = e_n dH_nn = np.dot(dO_nn, e_nn) - A_nn q_n[:] = np.dot(inv(np.transpose(U_nn)), q_n) s_n[:] = np.dot(inv(L_nn), s_n) u_n[:] = np.dot(inv(L_nn), u_n) dO_nn = np.dot(np.dot(inv(L_nn), dO_nn), inv(np.transpose(L_nn))) dH_nn = np.dot(np.dot(inv(L_nn), dH_nn), inv(np.transpose(L_nn))) ku_n = [self.kin(l, u, e) for u, e in zip(u_n, e_n)] ks_n = [self.kin(l, s) for s in s_n] dK_nn = 0.5 * (np.inner(u_n, ku_n * dr) - np.inner(s_n, ks_n * dr)) dK_nn += np.transpose(dK_nn).copy() dK_lnn.append(dK_nn) dO_lnn.append(dO_nn) dH_lnn.append(dH_nn) for n, q in enumerate(q_n): q[:] = filter(q, l) * r**(l + 1) A_nn = np.inner(s_n, q_n * dr) q_n[:] = np.dot(inv(np.transpose(A_nn)), q_n) self.vt = vt self.vbar = vbar t('state eigenvalue norm') t('--------------------------------') for l, (n_n, f_n, e_n) in enumerate(zip(n_ln, f_ln, e_ln)): for n in range(len(e_n)): if n_n[n] > 0: f = '(%d)' % f_n[n] t('%d%s%-4s: %12.6f %12.6f' % (n_n[n], 'spdf'[l], f, e_n[n], np.dot(s_ln[l][n]**2, dr))) else: t('*%s : %12.6f' % ('spdf'[l], e_n[n])) t('--------------------------------') self.logd = {} if logderiv: ni = 300 self.elog = np.linspace(-5.0, 1.0, ni) # Calculate logarithmic derivatives: gld = gcutmax + 10 self.rlog = r[gld] assert gld < gmax t('Calculating logarithmic derivatives at r=%.3f' % r[gld]) t('(skip with [Ctrl-C])') try: u = np.zeros(N) for l in range(4): self.logd[l] = (np.empty(ni), np.empty(ni)) if l <= lmax: dO_nn = dO_lnn[l] dH_nn = dH_lnn[l] q_n = q_ln[l] fae = open(self.symbol + '.ae.ld.' + 'spdf'[l], 'w') fps = open(self.symbol + '.ps.ld.' + 'spdf'[l], 'w') for i, e in enumerate(self.elog): # All-electron logarithmic derivative: u[:] = 0.0 shoot(u, l, self.vr, e, self.r2dvdr, r, dr, c10, c2, self.scalarrel, gmax=gld) dudr = 0.5 * (u[gld + 1] - u[gld - 1]) / dr[gld] ld = dudr / u[gld] - 1.0 / r[gld] print >> fae, e, ld self.logd[l][0][i] = ld # PAW logarithmic derivative: s = self.integrate(l, vt, e, gld) if l <= lmax: A_nn = dH_nn - e * dO_nn s_n = [ self.integrate(l, vt, e, gld, q) for q in q_n ] B_nn = np.inner(q_n, s_n * dr) a_n = np.dot(q_n, s * dr) B_nn = np.dot(A_nn, B_nn) B_nn.ravel()[::len(a_n) + 1] += 1.0 c_n = solve(B_nn, np.dot(A_nn, a_n)) s -= np.dot(c_n, s_n) dsdr = 0.5 * (s[gld + 1] - s[gld - 1]) / dr[gld] ld = dsdr / s[gld] - 1.0 / r[gld] print >> fps, e, ld self.logd[l][1][i] = ld except KeyboardInterrupt: pass self.write(nc, 'nc') self.write(nt, 'nt') self.write(nct, 'nct') self.write(vbar, 'vbar') self.write(vt, 'vt') self.write(tauc, 'tauc') self.write(tauct, 'tauct') for l, (n_n, f_n, u_n, s_n, q_n) in enumerate(zip(n_ln, f_ln, u_ln, s_ln, q_ln)): for n, f, u, s, q in zip(n_n, f_n, u_n, s_n, q_n): if n < 0: self.write(u, 'ae', n=n, l=l) self.write(s, 'ps', n=n, l=l) self.write(q, 'proj', n=n, l=l) # Test for ghost states: for h in [0.05]: self.diagonalize(h) self.vn_j = vn_j = [] self.vl_j = vl_j = [] self.vf_j = vf_j = [] self.ve_j = ve_j = [] self.vu_j = vu_j = [] self.vs_j = vs_j = [] self.vq_j = vq_j = [] j_ln = [[0 for f in f_n] for f_n in f_ln] j = 0 for l, n_n in enumerate(n_ln): for n, nn in enumerate(n_n): if nn > 0: vf_j.append(f_ln[l][n]) vn_j.append(nn) vl_j.append(l) ve_j.append(e_ln[l][n]) vu_j.append(u_ln[l][n]) vs_j.append(s_ln[l][n]) vq_j.append(q_ln[l][n]) j_ln[l][n] = j j += 1 for l, n_n in enumerate(n_ln): for n, nn in enumerate(n_n): if nn < 0: vf_j.append(0) vn_j.append(nn) vl_j.append(l) ve_j.append(e_ln[l][n]) vu_j.append(u_ln[l][n]) vs_j.append(s_ln[l][n]) vq_j.append(q_ln[l][n]) j_ln[l][n] = j j += 1 nj = j self.dK_jj = np.zeros((nj, nj)) for l, j_n in enumerate(j_ln): for n1, j1 in enumerate(j_n): for n2, j2 in enumerate(j_n): self.dK_jj[j1, j2] = self.dK_lnn[l][n1, n2] if exx: X_p = constructX(self) ExxC = atomic_exact_exchange(self, 'core-core') else: X_p = None ExxC = None sqrt4pi = sqrt(4 * pi) setup = SetupData(self.symbol, self.xc.name, self.name, readxml=False) def divide_by_r(x_g, l): r = self.r #for x_g, l in zip(x_jg, l_j): p = x_g.copy() p[1:] /= self.r[1:] # XXXXX go to higher order!!!!! if l == 0: #l_j[self.jcorehole] == 0: p[0] = (p[2] + (p[1] - p[2]) * (r[0] - r[2]) / (r[1] - r[2])) return p def divide_all_by_r(x_jg): return [divide_by_r(x_g, l) for x_g, l in zip(x_jg, vl_j)] setup.l_j = vl_j setup.n_j = vn_j setup.f_j = vf_j setup.eps_j = ve_j setup.rcut_j = [rcut_l[l] for l in vl_j] setup.nc_g = nc * sqrt4pi setup.nct_g = nct * sqrt4pi setup.nvt_g = (nt - nct) * sqrt4pi setup.e_kinetic_core = Ekincore setup.vbar_g = vbar * sqrt4pi setup.tauc_g = tauc * sqrt4pi setup.tauct_g = tauct * sqrt4pi setup.extra_xc_data = extra_xc_data setup.Z = Z setup.Nc = self.Nc setup.Nv = self.Nv setup.e_kinetic = self.Ekin setup.e_xc = self.Exc setup.e_electrostatic = self.Epot setup.e_total = self.Epot + self.Exc + self.Ekin setup.beta = self.beta setup.ng = self.N setup.rcgauss = self.rcutcomp / sqrt(self.gamma) setup.e_kin_jj = self.dK_jj setup.ExxC = ExxC setup.phi_jg = divide_all_by_r(vu_j) setup.phit_jg = divide_all_by_r(vs_j) setup.pt_jg = divide_all_by_r(vq_j) setup.X_p = X_p if self.jcorehole is not None: setup.has_corehole = True setup.lcorehole = l_j[self.jcorehole] # l_j or vl_j ????? XXX setup.ncorehole = n_j[self.jcorehole] setup.phicorehole_g = divide_by_r(self.u_j[self.jcorehole], setup.lcorehole) setup.core_hole_e = self.e_j[self.jcorehole] setup.core_hole_e_kin = self.Ekincorehole setup.fcorehole = self.fcorehole if self.ghost: raise RuntimeError('Ghost!') if self.scalarrel: reltype = 'scalar-relativistic' else: reltype = 'non-relativistic' attrs = [('type', reltype), ('name', 'gpaw-%s' % version)] data = 'Frozen core: ' + (self.core or 'none') setup.generatorattrs = attrs setup.generatordata = data self.id_j = [] for l, n in zip(vl_j, vn_j): if n > 0: id = '%s-%d%s' % (self.symbol, n, 'spdf'[l]) else: id = '%s-%s%d' % (self.symbol, 'spdf'[l], -n) self.id_j.append(id) setup.id_j = self.id_j if write_xml: setup.write_xml() return setup
def create_setup(symbol, xc='LDA', lmax=0, type='paw', basis=None, setupdata=None, filter=None, world=None): if isinstance(xc, basestring): xc = XC(xc) if isinstance(type, basestring) and ':' in type: # Parse DFT+U parameters from type-string: # Examples: "type:l,U" or "type:l,U,scale" type, lu = type.split(':') if type == '': type = 'paw' l = 'spdf'.find(lu[0]) assert lu[1] == ',' U = lu[2:] if ',' in U: U, scale = U.split(',') else: scale = True U = float(U) / units.Hartree scale = int(scale) else: U = None if setupdata is None: if type == 'hgh' or type == 'hgh.sc': lmax = 0 from gpaw.hgh import HGHSetupData, setups, sc_setups if type == 'hgh.sc': table = sc_setups else: table = setups parameters = table[symbol] setupdata = HGHSetupData(parameters) elif type == 'ah': from gpaw.ah import AppelbaumHamann ah = AppelbaumHamann() ah.build(basis) return ah elif type == 'ae': from gpaw.ae import HydrogenAllElectronSetup assert symbol == 'H' ae = HydrogenAllElectronSetup() ae.build(basis) return ae elif type == 'ghost': from gpaw.lcao.bsse import GhostSetupData setupdata = GhostSetupData(symbol) elif type == 'sg15': from gpaw.upf import UPFSetupData upfname = '%s_ONCV_PBE-*.upf' % symbol upfpath, source = search_for_file(upfname, world=world) if source is None: raise IOError('Could not find pseudopotential file %s ' 'in any GPAW search path. ' 'Please install the SG15 setups using, ' 'e.g., "gpaw install-data".' % upfname) setupdata = UPFSetupData(upfpath) if xc.name != 'PBE': raise ValueError('SG15 pseudopotentials support only the PBE ' 'functional. This calculation would use ' 'the %s functional.' % xc.name) else: setupdata = SetupData(symbol, xc.get_setup_name(), type, True, world=world) if hasattr(setupdata, 'build'): setup = LeanSetup(setupdata.build(xc, lmax, basis, filter)) if U is not None: setup.set_hubbard_u(U, l, scale) return setup else: return setupdata
def main(): parser = OptionParser(usage='%prog [OPTION...] [SYMBOL...]', description=description) parser.add_option('--xc', metavar='FUNCTIONAL', default='PBE', help='generate basis sets for FUNCTIONAL[=%default]') parser.add_option('--from', metavar='SYMBOL', dest='_from', help='generate starting from SYMBOL if generating ' 'for all elements') opts, symbols = parser.parse_args() if len(symbols) == 0: symbols = sorted(parameters.keys()) othersymbols = [] for symbol in parameters_extra: name = parameters_extra[symbol]['name'] code = '%s.%s' % (symbol, name) othersymbols.append(code) trouble = set(['Os.8', 'Ta.5', 'V.5', 'W.6', 'Ir.9']) othersymbols = [ symbol for symbol in othersymbols if symbol not in trouble ] symbols.extend(sorted(othersymbols)) if opts._from: index = symbols.index(opts._from) symbols = symbols[index:] specifications = [] for sym in symbols: try: s = SetupData(sym, opts.xc) except RuntimeError as e: if str(e).startswith('Could not find'): #print 'No %s' % sym continue else: raise # One could include basis functions also for the ``virtual'' states # (marked with negative n) jvalues = [] jextra = [] for j in range(len(s.f_j)): if s.eps_j[j] < 0: jvalues.append(j) if s.f_j[j] == 0.0 and s.n_j[j] > 0: jextra.append(j) if len(jextra) > 0: specifications.append(BasisSpecification(s, jvalues, jextra)) #print sym, jvalues # XXX check whether automatic settings coincide with those of official # setups distribution #bm = BasisMaker(sym, '' if world.rank == 0: print('Generating basis sets for: %s' % ' '.join(spec.setup.symbol for spec in specifications)) sys.stdout.flush() world.barrier() for i, spec in enumerate(specifications): if i % world.size != world.rank: continue if world.size > 1: print(world.rank, spec) else: print(spec) gtxt = None # XXX figure out how to accept Ag.11 tokens = spec.setup.symbol.split('.') sym = tokens[0] if len(tokens) == 1: p = parameters name = 'pvalence' elif len(tokens) == 2: p = parameters_extra name = '%s.pvalence' % tokens[1] else: raise ValueError('Strange setup specification') type = 'dz' # XXXXXXXXX bm = BasisMaker(sym, '%s.%s' % (name, type), run=False, gtxt=gtxt, xc=opts.xc) bm.generator.run(write_xml=False, use_restart_file=False, **p[sym]) basis = bm.generate(2, 0, txt=None, jvalues=spec.jvalues) basis.write_xml()
def read_GPAW_all(name='OUTPUT.gpw', fermi=None, orbs='sp', pbc=(1, 1), imaginary=False, cut_min=-15.0, cut_max=5.0, cut_at=-1, lower_atoms=[], lower_coefs=[]): ''' read_GPAW_all(name = 'OUTPUT.gpw', fermi = None, orbs = 'sp', pbc=(1,1), imaginary = False, cut_min=-15.0, cut_max=5.0, cut_at=-1, lower_atoms=[], lower_coefs=[]): This procedure nead to import ASE and GPAW read eigen energies, coffecients, Fermi Level and geometry from the GPAW *.gpw file. If fermi = None then Fermi comes from the GPAW calculation orbs - only 'sp' works can read only sp structure of valence orbitals (hydrogens_has to be at the end !!!!) pbc (1,1) - means 3 times 3 cell around the original, (0,0) cluster, (0.5,0.5) 2x2 cell etc. imaginary = False (other options for future k-points dependency cut_min = -15.0, cut_max = 5.0 - cut off states(=mol orbitals) bellow cut_min and above cut_max; energy in eV cut_at = -1 .. all atoms; eg. cut_at = 15 --> only first fifteen atoms for the current calculations (mostly the 1st layer is the important one) lower_atotms=[], lower_coefs=[] ... do nothing; lower_atoms=[0,1,2,3], lower_coefs=[0.5,0.5,0.5,0.5] lower coefficients (=hoppings) for the first four atoms by 0.5 ''' initial_check(orbs=orbs, pbc=pbc, imaginary=imaginary, cut_min=cut_min, cut_max=cut_max, cut_at=cut_at, lower_atoms=lower_atoms, lower_coefs=lower_coefs) # obtaining the geometry : from ase import Atoms from gpaw import GPAW calc = GPAW(name) slab = calc.get_atoms() Ratin = get_GPAW_geom(geom=slab) # getting eigen-energies n_bands = calc.get_number_of_bands() eig = calc.get_eigenvalues(kpt=0, spin=0, broadcast=True) at_num = slab.get_atomic_numbers() eig = to_fermi(eig, fermi, orig_fermi=calc.get_fermi_level()) eig = cut_eigenenergies(eig) print("eigen-energies read") # obtaining the LCAO coefficients (automatically removed unwanted states - molecular orbitals - and atoms) coef = np.zeros((n_max_ - n_min_, num_at_, Ynum_)) if (orbs == 'spd'): print( "!!! WARNING: d-orbitals should be in principle working, but coefficients can be wrong, according to my experiences !!!" ) print( "DEBUG: going to crazy procedure, which finds, where the d-orbs starts" ) print( "from gpaw.utilities.dos import print_projectors; print_projectors('X')" ) print("this prints you where the d-orb should start") from gpaw.setup_data import SetupData chem_sym = slab.get_chemical_symbols() d_orb = np.zeros((num_at_)) for i in range(num_at_): if at_num[i] > 2: setup = SetupData(chem_sym[i], 'LDA', 'paw') l_j = setup.l_j tmp = l_j[:l_j.index(2)] a = [1, 3] oo = 0 for j in range(len(tmp)): oo += a[tmp[j]] d_orb[i] = oo for i in range(n_min_, n_max_): h = 0 for j in range(num_at_): ii = i - n_min_ coef[ii, j, 0] = calc.wfs.kpt_u[0].C_nM[i, h] if (at_num[j] > 2): coef[ii, j, 1] = calc.wfs.kpt_u[0].C_nM[i, h + 1] coef[ii, j, 2] = calc.wfs.kpt_u[0].C_nM[i, h + 2] coef[ii, j, 3] = calc.wfs.kpt_u[0].C_nM[i, h + 3] if ((orbs == 'spd') and (d_orb[j] > 1)): coef[ii, j, 4] = calc.wfs.kpt_u[0].C_nM[i, h + d_orb[j]] coef[ii, j, 5] = calc.wfs.kpt_u[0].C_nM[i, h + d_orb[j] + 1] coef[ii, j, 6] = calc.wfs.kpt_u[0].C_nM[i, h + d_orb[j] + 2] coef[ii, j, 7] = calc.wfs.kpt_u[0].C_nM[i, h + d_orb[j] + 3] coef[ii, j, 8] = calc.wfs.kpt_u[0].C_nM[i, h + d_orb[j] + 4] h += calc.wfs.setups[j].nao #from gpaw.utilities.dos import print_projectors; print_projectors('Cu') #print "DEBUG: Cu coeffs:" #for i in range(n_min,n_max): # for j in range(15): # print j, calc.wfs.kpt_u[0].C_nM[i,j] # print "DEBUG: coef[sth,0,:]" , coef[i-n_min,0,:] # lowering tunneling for predefined atoms # lowering over atoms and applying PBC coeffs = handle_coef(coef) print("All coefficients read") return eig.copy(), coeffs.copy(), Ratin.copy()