def calculate(self, e_g, n_sg, dedn_sg, sigma_xg=None, dedsigma_xg=None, tau_sg=None, dedtau_sg=None): n_g = n_sg[0] m_vg = n_sg[1:4] m_g = (m_vg**2).sum(0)**0.5 nnew_sg = np.empty((2,) + n_g.shape) nnew_sg[:] = n_g nnew_sg[0] += m_g nnew_sg[1] -= m_g nnew_sg *= 0.5 vnew_sg = np.zeros_like(nnew_sg) LibXC.calculate(self, e_g, nnew_sg, vnew_sg) dedn_sg[0] += 0.5 * vnew_sg.sum(0) vnew_sg /= np.where(m_g < 1e-15, 1, m_g) dedn_sg[1:4] += 0.5 * vnew_sg[0] * m_vg dedn_sg[1:4] -= 0.5 * vnew_sg[1] * m_vg
def calculate(self, e_g, n_sg, dedn_sg, sigma_xg=None, dedsigma_xg=None, tau_sg=None, dedtau_sg=None): n_g = n_sg[0] m_vg = n_sg[1:4] m_g = (m_vg**2).sum(0)**0.5 nnew_sg = np.empty((2, ) + n_g.shape) nnew_sg[:] = n_g nnew_sg[0] += m_g nnew_sg[1] -= m_g nnew_sg *= 0.5 vnew_sg = np.zeros_like(nnew_sg) LibXC.calculate(self, e_g, nnew_sg, vnew_sg) dedn_sg[0] += 0.5 * vnew_sg.sum(0) vnew_sg /= np.where(m_g < 1e-15, 1, m_g) dedn_sg[1:4] += 0.5 * vnew_sg[0] * m_vg dedn_sg[1:4] -= 0.5 * vnew_sg[1] * m_vg
class VDWFunctional(GGA): """Base class for vdW-DF.""" def __init__( self, name, world=None, q0cut=5.0, phi0=0.5, ds=1.0, Dmax=20.0, nD=201, ndelta=21, soft_correction=False, kernel=None, Zab=None, vdwcoef=1.0, verbose=False, energy_only=False, ): """vdW-DF. parameters: name: str Name of functional. world: MPI communicator Communicator to parallelize over. Defaults to gpaw.mpi.world. q0cut: float Maximum value for q0. phi0: float Smooth value for phi(0,0). ds: float Cutoff for smooth kernel. Dmax: float Maximum value for D. nD: int Number of values for D in kernel-table. ndelta: int Number of values for delta in kernel-table. soft_correction: bool Correct for soft kernel. kernel: Which kernel to use. Zab: parameter in nonlocal kernel. vdwcoef: float Scaling of vdW energy. verbose: bool Print useful information. """ if world is None: self.world = mpi.world else: self.world = world self.q0cut = q0cut self.phi0 = phi0 self.ds = ds self.delta_i = np.linspace(0, 1.0, ndelta) self.D_j = np.linspace(0, Dmax, nD) self.verbose = verbose self.read_table() self.soft_correction = soft_correction if soft_correction: dD = self.D_j[1] self.C_soft = np.dot(self.D_j ** 2, self.phi_ij[0]) * 4 * pi * dD self.gd = None self.energy_only = energy_only self.timer = nulltimer if name == "vdW-DF": assert kernel is None and Zab is None kernel = LibXC("GGA_X_PBE_R+LDA_C_PW") Zab = -0.8491 elif name == "vdW-DF2": assert kernel is None and Zab is None kernel = LibXC("GGA_X_RPW86+LDA_C_PW") Zab = -1.887 elif name == "optPBE-vdW": assert kernel is None and Zab is None kernel = LibXC("GGA_X_OPTPBE_VDW+LDA_C_PW") Zab = -0.8491 elif name == "optB88-vdW": assert kernel is None and Zab is None kernel = LibXC("GGA_X_OPTB88_VDW+LDA_C_PW") Zab = -0.8491 elif name == "C09-vdW": assert kernel is None and Zab is None kernel = LibXC("GGA_X_C09X+LDA_C_PW") Zab = -0.8491 else: assert kernel is not None and Zab is not None self.Zab = Zab GGA.__init__(self, kernel) self.vdwcoef = vdwcoef self.name = name self.LDAc = LibXC("LDA_C_PW") def get_setup_name(self): return "revPBE" def initialize(self, density, hamiltonian, wfs, occupations): self.timer = wfs.timer def get_Ecnl(self): return self.Ecnl def calculate_gga(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg): GGA.calculate_gga(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg) eLDAc_g = self.gd.empty() vLDAc_sg = self.gd.zeros(1) if self.vdwcoef == 0.0: return if len(n_sg) == 1: self.LDAc.calculate(eLDAc_g, n_sg, vLDAc_sg) e = self.get_non_local_energy(n_sg[0], sigma_xg[0], eLDAc_g, vLDAc_sg[0], dedn_sg[0], dedsigma_xg[0]) else: n_sg = n_sg.sum(0) n_sg.shape = (1,) + n_sg.shape self.LDAc.calculate(eLDAc_g, n_sg, vLDAc_sg) v_g = np.zeros_like(e_g) deda2nl_g = np.zeros_like(e_g) a2_g = sigma_xg[0] + 2 * sigma_xg[1] + sigma_xg[2] e = self.get_non_local_energy(n_sg[0], a2_g, eLDAc_g, vLDAc_sg[0], v_g, deda2nl_g) dedsigma_xg[0] += self.vdwcoef * deda2nl_g dedsigma_xg[1] += self.vdwcoef * 2 * deda2nl_g dedsigma_xg[2] += self.vdwcoef * deda2nl_g dedn_sg += self.vdwcoef * v_g if self.gd.comm.rank == 0: e_g[0, 0, 0] += self.vdwcoef * e / self.gd.dv def get_non_local_energy(self, n_g=None, a2_g=None, e_LDAc_g=None, v_LDAc_g=None, v_g=None, deda2_g=None): """Calculate non-local correlation energy. parameters: n_g: ndarray Density. a2_g: ndarray Absolute value of the gradient of the density - squared. e_LDAc_g: ndarray LDA correlation energy density. """ gd = self.gd n_g = n_g.clip(1e-7, np.inf) # Calculate q0 and cut it off smoothly at q0cut: kF_g = (3 * pi ** 2 * n_g) ** (1.0 / 3.0) q0_g, dhdx_g = hRPS(kF_g - 4 * pi / 3 * e_LDAc_g / n_g - self.Zab / 36 / kF_g * a2_g / n_g ** 2, self.q0cut) if self.verbose: print ("VDW: q0 (min, mean, max): (%f, %f, %f)" % (q0_g.min(), q0_g.mean(), q0_g.max())) if self.soft_correction: dEcnl = gd.integrate(n_g ** 2 / q0_g ** 3) * 0.5 * self.C_soft else: dEcnl = 0.0 # Distribute density and q0 to all processors: n_g = gd.collect(n_g, broadcast=True) q0_g = gd.collect(q0_g, broadcast=True) if not self.energy_only: self.dhdx_g = gd.collect(dhdx_g, broadcast=True) Ecnl = self.calculate_6d_integral(n_g, q0_g, a2_g, e_LDAc_g, v_LDAc_g, v_g, deda2_g) Ecnl += dEcnl self.Ecnl = Ecnl return Ecnl def read_table(self): name = "phi-%.3f-%.3f-%.3f-%d-%d.pckl" % (self.phi0, self.ds, self.D_j[-1], len(self.delta_i), len(self.D_j)) if "GPAW_VDW" in os.environ: print "Use of GPAW_VDW is deprecated." print "Put", name, "in your GPAW_SETUP_PATH directory." dirs = [os.environ["GPAW_VDW"]] else: dirs = setup_paths + ["."] for dir in dirs: filename = os.path.join(dir, name) if os.path.isfile(filename): self.phi_ij = pickle.load(open(filename)) if self.verbose: print "VDW: using", filename return print "VDW: Could not find table file:", name self.make_table(name) def make_table(self, name): print "VDW: Generating vdW-DF kernel ..." print "VDW:", ndelta = len(self.delta_i) nD = len(self.D_j) self.phi_ij = np.zeros((ndelta, nD)) for i in range(self.world.rank, ndelta, self.world.size): print ndelta - i, sys.stdout.flush() delta = self.delta_i[i] for j in range(nD - 1, -1, -1): D = self.D_j[j] d = D * (1.0 + delta) dp = D * (1.0 - delta) if d ** 2 + dp ** 2 > self.ds ** 2: self.phi_ij[i, j] = phi(d, dp) else: P = np.polyfit( [0, self.D_j[j + 1] ** 2, self.D_j[j + 2] ** 2], [self.phi0, self.phi_ij[i, j + 1], self.phi_ij[i, j + 2]], 2, ) self.phi_ij[i, : j + 3] = np.polyval(P, self.D_j[: j + 3] ** 2) break self.world.sum(self.phi_ij) print print "VDW: Done!" if self.world.rank == 0: pickle.dump(self.phi_ij, open(name, "w"), pickle.HIGHEST_PROTOCOL) def make_prl_plot(self, multiply_by_4_pi_D_squared=True): import pylab as plt x = np.linspace(0, 8.0, 100) for delta in [0, 0.5, 0.9]: y = [self.phi(D * (1.0 + delta), D * (1.0 - delta)) for D in x] if multiply_by_4_pi_D_squared: y *= 4 * pi * x ** 2 plt.plot(x, y, label=r"$\delta=%.1f$" % delta) plt.legend(loc="best") plt.plot(x, np.zeros(len(x)), "k-") plt.xlabel("D") plt.ylabel(r"$4\pi D^2 \phi(\rm{Hartree})$") plt.show() def phi(self, d, dp): """Kernel function. Uses bi-linear interpolation and returns zero for D > Dmax. """ P = self.phi_ij D = (d + dp) / 2.0 if D < 1e-14: return P[0, 0] if D >= self.D_j[-1]: return 0.0 delta = abs((d - dp) / (2 * D)) ddelta = self.delta_i[1] x = delta / ddelta i = int(x) if i == len(self.delta_i) - 1: i -= 1 x = 1.0 else: x -= i dD = self.D_j[1] y = D / dD j = int(y) y -= j return x * (y * P[i + 1, j + 1] + (1 - y) * P[i + 1, j]) + (1 - x) * (y * P[i, j + 1] + (1 - y) * P[i, j])
class BEEVDWKernel(XCKernel): """Kernel for BEEVDW functionals.""" def __init__(self, bee, xcoefs, ldac, ggac): """BEEVDW kernel. parameters: bee : str choose BEE1 or BEE2 exchange basis expansion. xcoefs : array coefficients for exchange. ldac : float coefficient for LDA correlation. pbec : float coefficient for PBE correlation. """ if bee == 'BEE2': self.BEE = BEE2(xcoefs) self.GGAc = LibXC('GGA_C_PBE') self.xtype = 'GGA' self.type = 'GGA' elif bee == 'BEE3': self.BEE = LibXC('MGGA_X_MBEEFVDW') self.GGAc = LibXC('GGA_C_PBE_SOL') self.xtype = 'MGGA' self.type = 'MGGA' else: raise ValueError('Unknown BEE exchange: %s', bee) self.LDAc = LibXC('LDA_C_PW') self.ldac = ldac self.ggac = ggac if bee in ['BEE1', 'BEE2']: self.ggac -= 1.0 self.name = 'BEEVDW' def calculate(self, e_g, n_sg, dedn_sg, sigma_xg=None, dedsigma_xg=None, tau_sg=None, dedtau_sg=None): if debug: self.check_arguments(e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg, tau_sg, dedtau_sg) if self.xtype == 'GGA': self.BEE.calculate(e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg) elif self.xtype == 'MGGA': self.BEE.calculate(e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg, tau_sg, dedtau_sg) else: raise ValueError('Unexpected value of xtype:', self.xtype) e0_g = np.empty_like(e_g) dedn0_sg = np.empty_like(dedn_sg) dedsigma0_xg = np.empty_like(dedsigma_xg) for coef, kernel in [(self.ldac, self.LDAc), (self.ggac, self.GGAc)]: dedn0_sg[:] = 0.0 kernel.calculate(e0_g, n_sg, dedn0_sg, sigma_xg, dedsigma0_xg) e_g += coef * e0_g dedn_sg += coef * dedn0_sg if kernel.type == 'GGA': dedsigma_xg += coef * dedsigma0_xg
class CXGGAKernel: def __init__(self, just_kidding=False): self.just_kidding = just_kidding self.type = 'GGA' self.lda_c = LibXC('LDA_C_PW') if self.just_kidding: self.name = 'purepython rPW86_with_%s' % self.lda_c.name else: self.name = 'purepython cx' def calculate(self, e_g, n_sg, v_sg, sigma_xg, dedsigma_xg): e_g[:] = 0.0 dedsigma_xg[:] = 0.0 self.lda_c.calculate(e_g, n_sg, v_sg, sigma_xg, dedsigma_xg) for arr in [n_sg, v_sg, sigma_xg, dedsigma_xg]: assert len(arr) == 1 self._exchange(n_sg[0], sigma_xg[0], e_g, v_sg[0], dedsigma_xg[0]) def _exchange(self, rho, grho, sx, v1x, v2x): """Calculate cx local exchange. Note that this *adds* to the energy density sx so that it can be called after LDA correlation part without ruining anything. Also it adds to v1x and v2x as is normal in GPAW.""" tol = 1e-20 rho[rho < tol] = tol grho[grho < tol] = tol alp = 0.021789 beta = 1.15 a = 1.851 b = 17.33 c = 0.163 mu_LM = 0.09434 s_prefactor = 6.18733545256027 Ax = -0.738558766382022 # = -3./4. * (3./pi)**(1./3) four_thirds = 4. / 3. grad_rho = np.sqrt(grho) # eventually we need s to power 12. Clip to avoid overflow # (We have individual tolerances on both rho and grho, but # they are not sufficient to guarantee this) s_1 = (grad_rho / (s_prefactor * rho**four_thirds)).clip(0.0, 1e20) s_2 = s_1 * s_1 s_3 = s_2 * s_1 s_4 = s_3 * s_1 s_5 = s_4 * s_1 s_6 = s_5 * s_1 fs_rPW86 = (1.0 + a * s_2 + b * s_4 + c * s_6)**(1. / 15.) if self.just_kidding: fs = fs_rPW86 else: fs = (1.0 + mu_LM * s_2) / (1.0 + alp * s_6) \ + alp * s_6 / (beta + alp * s_6) * fs_rPW86 # the energy density for the exchange. sx[:] += Ax * rho**four_thirds * fs df_rPW86_ds = (1. / (15. * fs_rPW86**14.0)) * \ (2 * a * s_1 + 4 * b * s_3 + 6 * c * s_5) if self.just_kidding: df_ds = df_rPW86_ds # XXXXXXXXXXXXXXXXXXXX else: df_ds = 1. / (1. + alp * s_6)**2 \ * (2.0 * mu_LM * s_1 * (1. + alp * s_6) - 6.0 * alp * s_5 * (1. + mu_LM * s_2)) \ + alp * s_6 / (beta + alp * s_6) * df_rPW86_ds \ + 6.0 * alp * s_5 * fs_rPW86 / (beta + alp * s_6) \ * (1. - alp * s_6 / (beta + alp * s_6)) # de/dn. This is the partial derivative of sx wrt. n, for s constant v1x[:] += Ax * four_thirds * (rho**(1. / 3.) * fs - grad_rho / (s_prefactor * rho) * df_ds) # de/d(nabla n). The other partial derivative v2x[:] += 0.5 * Ax * df_ds / (s_prefactor * grad_rho)
class VDWFunctionalBase: """Base class for vdW-DF.""" def __init__(self, world=None, Zab=-0.8491, vdwcoef=1.0, q0cut=5.0, phi0=0.5, ds=1.0, Dmax=20.0, nD=201, ndelta=21, soft_correction=False, setup_name='revPBE', verbose=False, energy_only=False): """vdW-DF. parameters: name: str Name of functional. world: MPI communicator Communicator to parallelize over. Defaults to gpaw.mpi.world. q0cut: float Maximum value for q0. phi0: float Smooth value for phi(0,0). ds: float Cutoff for smooth kernel. Dmax: float Maximum value for D. nD: int Number of values for D in kernel-table. ndelta: int Number of values for delta in kernel-table. soft_correction: bool Correct for soft kernel. kernel: Which kernel to use. Zab: parameter in nonlocal kernel. vdwcoef: float Scaling of vdW energy. verbose: bool Print useful information. """ if world is None: self.world = mpi.world else: self.world = world self.Zab = Zab self.vdwcoef = vdwcoef self.q0cut = q0cut self.phi0 = phi0 self.ds = ds self.delta_i = np.linspace(0, 1.0, ndelta) self.D_j = np.linspace(0, Dmax, nD) self.verbose = verbose self.read_table() self.soft_correction = soft_correction if soft_correction: dD = self.D_j[1] self.C_soft = np.dot(self.D_j**2, self.phi_ij[0]) * 4 * pi * dD self.gd = None self.energy_only = energy_only self.timer = nulltimer self.LDAc = LibXC('LDA_C_PW') self.setup_name = setup_name def get_setup_name(self): return self.setup_name def get_Ecnl(self): return self.Ecnl def calculate_impl(self, gd, n_sg, v_sg, e_g): sigma_xg, dedsigma_xg, gradn_svg = gga_vars(gd, self.grad_v, n_sg) self.calculate_exchange(e_g, n_sg, v_sg, sigma_xg, dedsigma_xg) self.calculate_correlation(e_g, n_sg, v_sg, sigma_xg, dedsigma_xg) add_gradient_correction(self.grad_v, gradn_svg, sigma_xg, dedsigma_xg, v_sg) def calculate_exchange(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg): raise NotImplementedError def calculate_correlation(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg): eLDAc_g = self.gd.empty() vLDAc_sg = self.gd.zeros(1) if self.vdwcoef == 0.0: return if len(n_sg) == 1: self.LDAc.calculate(eLDAc_g, n_sg, vLDAc_sg) e = self.get_non_local_energy(n_sg[0], sigma_xg[0], eLDAc_g, vLDAc_sg[0], dedn_sg[0], dedsigma_xg[0]) else: n_sg = n_sg.sum(0) n_sg.shape = (1, ) + n_sg.shape self.LDAc.calculate(eLDAc_g, n_sg, vLDAc_sg) v_g = np.zeros_like(e_g) deda2nl_g = np.zeros_like(e_g) a2_g = sigma_xg[0] + 2 * sigma_xg[1] + sigma_xg[2] e = self.get_non_local_energy(n_sg[0], a2_g, eLDAc_g, vLDAc_sg[0], v_g, deda2nl_g) dedsigma_xg[0] += self.vdwcoef * deda2nl_g dedsigma_xg[1] += self.vdwcoef * 2 * deda2nl_g dedsigma_xg[2] += self.vdwcoef * deda2nl_g dedn_sg += self.vdwcoef * v_g if self.gd.comm.rank == 0: e_g[0, 0, 0] += self.vdwcoef * e / self.gd.dv def get_non_local_energy(self, n_g=None, a2_g=None, e_LDAc_g=None, v_LDAc_g=None, v_g=None, deda2_g=None): """Calculate non-local correlation energy. parameters: n_g: ndarray Density. a2_g: ndarray Absolute value of the gradient of the density - squared. e_LDAc_g: ndarray LDA correlation energy density. """ gd = self.gd n_g = n_g.clip(1e-7, np.inf) # Calculate q0 and cut it off smoothly at q0cut: kF_g = (3 * pi**2 * n_g)**(1.0 / 3.0) q0_g, dhdx_g = hRPS( kF_g - 4 * pi / 3 * e_LDAc_g / n_g - self.Zab / 36 / kF_g * a2_g / n_g**2, self.q0cut) if self.verbose: print(('VDW: q0 (min, mean, max): (%f, %f, %f)' % (q0_g.min(), q0_g.mean(), q0_g.max()))) if self.soft_correction: dEcnl = -gd.integrate(n_g**2 / q0_g**3) * 0.5 * self.C_soft else: dEcnl = 0.0 # Distribute density and q0 to all processors: n_g = gd.collect(n_g, broadcast=True) q0_g = gd.collect(q0_g, broadcast=True) if not self.energy_only: self.dhdx_g = gd.collect(dhdx_g, broadcast=True) Ecnl = self.calculate_6d_integral(n_g, q0_g, a2_g, e_LDAc_g, v_LDAc_g, v_g, deda2_g) Ecnl += dEcnl self.Ecnl = Ecnl return Ecnl def read_table(self): name = ('phi-%.3f-%.3f-%.3f-%d-%d.txt' % (self.phi0, self.ds, self.D_j[-1], len( self.delta_i), len(self.D_j))) dirs = setup_paths + ['.'] for dir in dirs: filename = os.path.join(dir, name) if os.path.isfile(filename): self.phi_ij = np.loadtxt(filename) if self.verbose: print('VDW: using', filename) return if sys.version_info[0] == 2: oldname = name[:-3] + 'pckl' for dir in dirs: filename = os.path.join(dir, oldname) if os.path.isfile(filename): self.phi_ij = pickle.load(open(filename, 'rb')) if self.verbose: print('VDW: using', filename) return print('VDW: Could not find table file:', name) self.make_table(name) def make_table(self, name): print('VDW: Generating vdW-DF kernel ...') print('VDW:', end=' ') ndelta = len(self.delta_i) nD = len(self.D_j) self.phi_ij = np.zeros((ndelta, nD)) for i in range(self.world.rank, ndelta, self.world.size): print(ndelta - i, end=' ') sys.stdout.flush() delta = self.delta_i[i] for j in range(nD - 1, -1, -1): D = self.D_j[j] d = D * (1.0 + delta) dp = D * (1.0 - delta) if d**2 + dp**2 > self.ds**2: with seterr(divide='ignore'): self.phi_ij[i, j] = phi(d, dp) else: P = np.polyfit([0, self.D_j[j + 1]**2, self.D_j[j + 2]**2], [ self.phi0, self.phi_ij[i, j + 1], self.phi_ij[i, j + 2] ], 2) self.phi_ij[i, :j + 3] = np.polyval(P, self.D_j[:j + 3]**2) break self.world.sum(self.phi_ij) print() print('VDW: Done!') header = ('phi0={0:.3f}, ds={1:.3f}, Dmax={2:.3f}, nD={3}, ndelta={4}'. format(self.phi0, self.ds, self.D_j[-1], len(self.delta_i), len(self.D_j))) if self.world.rank == 0: np.savetxt(name, self.phi_ij, header=header) def make_prl_plot(self, multiply_by_4_pi_D_squared=True): import pylab as plt x = np.linspace(0, 8.0, 100) for delta in [0, 0.5, 0.9]: y = [self.phi(D * (1.0 + delta), D * (1.0 - delta)) for D in x] if multiply_by_4_pi_D_squared: y *= 4 * pi * x**2 plt.plot(x, y, label=r'$\delta=%.1f$' % delta) plt.legend(loc='best') plt.plot(x, np.zeros(len(x)), 'k-') plt.xlabel('D') plt.ylabel(r'$4\pi D^2 \phi(\rm{Hartree})$') plt.show() def phi(self, d, dp): """Kernel function. Uses bi-linear interpolation and returns zero for D > Dmax. """ P = self.phi_ij D = (d + dp) / 2.0 if D < 1e-14: return P[0, 0] if D >= self.D_j[-1]: return 0.0 delta = abs((d - dp) / (2 * D)) ddelta = self.delta_i[1] x = delta / ddelta i = int(x) if i == len(self.delta_i) - 1: i -= 1 x = 1.0 else: x -= i dD = self.D_j[1] y = D / dD j = int(y) y -= j return (x * (y * P[i + 1, j + 1] + (1 - y) * P[i + 1, j]) + (1 - x) * (y * P[i, j + 1] + (1 - y) * P[i, j]))
class TB09Kernel: name = 'TB09' type = 'MGGA' alpha = -0.012 beta = 1.023 def __init__(self, c=None): self.tb09 = LibXC('MGGA_X_TB09').xc.tb09 self.ldac = LibXC('LDA_C_PW') self.fixedc = c is not None # calculate c or use fixed value self.c = c # amount of "exact exchange" self.n = 0 # Lebedev quadrature point number (0-49) self.sign = 1.0 # sign of PAW correction: +1 for AE and -1 for PS self.I = None # integral from Eq. (3) def calculate(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg, tau_sg, dedtau_sg): ns = len(n_sg) n_sg[n_sg < 1e-6] = 1e-6 if n_sg.ndim == 4: if not self.fixedc: if self.c is None: # We don't have the integral yet - just use 1.0: self.c = 1.0 else: self.I = self.world.sum(self.I) self.c = (self.alpha + self.beta * (self.I / self.gd.volume)**0.5) # Start calculation of c for use in the next SCF step: if ns == 1: gradn_g = sigma_xg[0]**0.5 else: gradn_g = (sigma_xg[0] + 2 * sigma_xg[1] + sigma_xg[2])**0.5 self.I = self.gd.integrate(gradn_g / n_sg.sum(0)) # The domain is not distributed like the PAW corrections: self.I /= self.world.size lapl_sg = self.gd.empty(ns) for n_g, lapl_g in zip(n_sg, lapl_sg): self.lapl.apply(n_g, lapl_g) else: rgd = self.rgd lapl_sg = [] for n_Lg in self.n_sLg: lapl_g = rgd.laplace(np.dot(self.Y_L, n_Lg)) l = 0 L1 = 0 while L1 < len(self.Y_L): L2 = L1 + 2 * l + 1 n_g = np.dot(self.Y_L[L1:L2], n_Lg[L1:L2]) with seterr(divide='ignore', invalid='ignore'): lapl_g -= l * (l + 1) * n_g / rgd.r_g**2 lapl_g[0] = 0.0 L1 = L2 l += 1 lapl_sg.append(lapl_g) if not self.fixedc: # PAW corrections to integral: w = self.sign * weight_n[self.n] if ns == 1: gradn_g = sigma_xg[0]**0.5 else: gradn_g = (sigma_xg[0] + 2 * sigma_xg[1] + sigma_xg[2])**0.5 self.I += w * rgd.integrate(gradn_g / n_sg.sum(0)) self.n += 1 if self.n == len(weight_n): self.n = 0 self.sign = -self.sign # dedn_sg[:] = 0.0 sigma_xg[sigma_xg < 1e-10] = 1e-10 tau_sg[tau_sg < 1e-10] = 1e-10 for n_g, sigma_g, lapl_g, tau_g, v_g in zip(n_sg, sigma_xg[::2], lapl_sg, tau_sg, dedn_sg): self.tb09(self.c, n_g.ravel(), sigma_g, lapl_g, tau_g, v_g, dedsigma_xg) self.ldac.calculate(e_g, n_sg, dedn_sg) e_g[:] = 0.0 dedsigma_xg[:] = 0.0 dedtau_sg[:] = 0.0
class BEEVDWKernel(XCKernel): """Kernel for BEEVDW functionals.""" def __init__(self, bee, xcoefs, ldac, ggac): """BEEVDW kernel. parameters: bee : str choose BEE1 or BEE2 exchange basis expansion. xcoefs : array coefficients for exchange. ldac : float coefficient for LDA correlation. pbec : float coefficient for PBE correlation. """ if bee == 'BEE2': self.BEE = BEE2(xcoefs) self.GGAc = LibXC('GGA_C_PBE') self.xtype = 'GGA' self.type = 'GGA' elif bee == 'BEE3': self.BEE = LibXC('MGGA_X_MBEEFVDW') self.GGAc = LibXC('GGA_C_PBE_SOL') self.xtype = 'MGGA' self.type = 'MGGA' else: raise ValueError('Unknown BEE exchange: %s', bee) self.LDAc = LibXC('LDA_C_PW') self.ldac = ldac self.ggac = ggac if bee in ['BEE1', 'BEE2']: self.ggac -= 1.0 self.name = 'BEEVDW' def calculate(self, e_g, n_sg, dedn_sg, sigma_xg=None, dedsigma_xg=None, tau_sg=None, dedtau_sg=None): if debug: self.check_arguments(e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg, tau_sg, dedtau_sg) if self.xtype == 'GGA': self.BEE.calculate(e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg) elif self.xtype == 'MGGA': self.BEE.calculate(e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg, tau_sg, dedtau_sg) else: raise ValueError('Unexpected value of xtype:', self.xtype) e0_g = np.empty_like(e_g) dedn0_sg = np.empty_like(dedn_sg) dedsigma0_xg = np.empty_like(dedsigma_xg) for coef, kernel in [(self.ldac, self.LDAc), (self.ggac, self.GGAc)]: dedn0_sg[:] = 0.0 kernel.calculate(e0_g, n_sg, dedn0_sg, sigma_xg, dedsigma0_xg) e_g += coef * e0_g dedn_sg += coef * dedn0_sg if kernel.type == 'GGA': dedsigma_xg += coef * dedsigma0_xg
class VDWFunctional(GGA): """Base class for vdW-DF.""" def __init__(self, name, world=None, q0cut=5.0, phi0=0.5, ds=1.0, Dmax=20.0, nD=201, ndelta=21, soft_correction=False, kernel=None, Zab=None, vdwcoef=1.0, verbose=False, energy_only=False): """vdW-DF. parameters: name: str Name of functional. world: MPI communicator Communicator to parallelize over. Defaults to gpaw.mpi.world. q0cut: float Maximum value for q0. phi0: float Smooth value for phi(0,0). ds: float Cutoff for smooth kernel. Dmax: float Maximum value for D. nD: int Number of values for D in kernel-table. ndelta: int Number of values for delta in kernel-table. soft_correction: bool Correct for soft kernel. kernel: Which kernel to use. Zab: parameter in nonlocal kernel. vdwcoef: float Scaling of vdW energy. verbose: bool Print useful information. """ if world is None: self.world = mpi.world else: self.world = world self.q0cut = q0cut self.phi0 = phi0 self.ds = ds self.delta_i = np.linspace(0, 1.0, ndelta) self.D_j = np.linspace(0, Dmax, nD) self.verbose = verbose self.read_table() self.soft_correction = soft_correction if soft_correction: dD = self.D_j[1] self.C_soft = np.dot(self.D_j**2, self.phi_ij[0]) * 4 * pi * dD self.gd = None self.energy_only = energy_only self.timer = nulltimer if name == 'vdW-DF': assert kernel is None and Zab is None kernel = LibXC('GGA_X_PBE_R+LDA_C_PW') Zab = -0.8491 elif name == 'vdW-DF2': assert kernel is None and Zab is None kernel = LibXC('GGA_X_PW86+LDA_C_PW') Zab = -1.887 self.Zab = Zab GGA.__init__(self, kernel) self.vdwcoef = vdwcoef self.name = name self.LDAc = LibXC('LDA_C_PW') def get_setup_name(self): return 'revPBE' def initialize(self, density, hamiltonian, wfs, occupations): self.timer = wfs.timer def calculate_gga(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg): GGA.calculate_gga(self, e_g, n_sg, dedn_sg, sigma_xg, dedsigma_xg) eLDAc_g = self.gd.empty() vLDAc_sg = self.gd.zeros(1) if self.vdwcoef == 0.0: return if len(n_sg) == 1: self.LDAc.calculate(eLDAc_g, n_sg, vLDAc_sg) e = self.get_non_local_energy(n_sg[0], sigma_xg[0], eLDAc_g, vLDAc_sg[0], dedn_sg[0], dedsigma_xg[0]) else: n_sg = n_sg.sum(0) n_sg.shape = (1, ) + n_sg.shape self.LDAc.calculate(eLDAc_g, n_sg, vLDAc_sg) v_g = np.zeros_like(e_g) deda2nl_g = np.zeros_like(e_g) a2_g = sigma_xg[0] + 2 * sigma_xg[1] + sigma_xg[2] e = self.get_non_local_energy(n_sg[0], a2_g, eLDAc_g, vLDAc_sg[0], v_g, deda2nl_g) dedsigma_xg[0] += self.vdwcoef * deda2nl_g dedsigma_xg[1] += self.vdwcoef * 2 * deda2nl_g dedsigma_xg[2] += self.vdwcoef * deda2nl_g dedn_sg += self.vdwcoef * v_g if self.gd.comm.rank == 0: e_g[0, 0, 0] += self.vdwcoef * e / self.gd.dv def get_non_local_energy(self, n_g=None, a2_g=None, e_LDAc_g=None, v_LDAc_g=None, v_g=None, deda2_g=None): """Calculate non-local correlation energy. parameters: n_g: ndarray Density. a2_g: ndarray Absolute value of the gradient of the density - squared. e_LDAc_g: ndarray LDA correlation energy density. """ gd = self.gd n_g = n_g.clip(1e-7, np.inf) # Calculate q0 and cut it off smoothly at q0cut: kF_g = (3 * pi**2 * n_g)**(1.0 / 3.0) q0_g, dhdx_g = hRPS( kF_g - 4 * pi / 3 * e_LDAc_g / n_g - self.Zab / 36 / kF_g * a2_g / n_g**2, self.q0cut) if self.verbose: print('VDW: q0 (min, mean, max): (%f, %f, %f)' % (q0_g.min(), q0_g.mean(), q0_g.max())) if self.soft_correction: dEcnl = gd.integrate(n_g**2 / q0_g**3) * 0.5 * self.C_soft else: dEcnl = 0.0 # Distribute density and q0 to all processors: n_g = gd.collect(n_g, broadcast=True) q0_g = gd.collect(q0_g, broadcast=True) if not self.energy_only: self.dhdx_g = gd.collect(dhdx_g, broadcast=True) Ecnl = self.calculate_6d_integral(n_g, q0_g, a2_g, e_LDAc_g, v_LDAc_g, v_g, deda2_g) return Ecnl + dEcnl def read_table(self): name = ('phi-%.3f-%.3f-%.3f-%d-%d.pckl' % (self.phi0, self.ds, self.D_j[-1], len( self.delta_i), len(self.D_j))) if 'GPAW_VDW' in os.environ: print 'Use of GPAW_VDW is deprecated.' print 'Put', name, 'in your GPAW_SETUP_PATH directory.' dirs = [os.environ['GPAW_VDW']] else: dirs = setup_paths + ['.'] for dir in dirs: filename = os.path.join(dir, name) if os.path.isfile(filename): self.phi_ij = pickle.load(open(filename)) if self.verbose: print 'VDW: using', filename return print 'VDW: Could not find table file:', name self.make_table(name) def make_table(self, name): print 'VDW: Generating vdW-DF kernel ...' print 'VDW:', ndelta = len(self.delta_i) nD = len(self.D_j) self.phi_ij = np.zeros((ndelta, nD)) for i in range(self.world.rank, ndelta, self.world.size): print ndelta - i, sys.stdout.flush() delta = self.delta_i[i] for j in range(nD - 1, -1, -1): D = self.D_j[j] d = D * (1.0 + delta) dp = D * (1.0 - delta) if d**2 + dp**2 > self.ds**2: self.phi_ij[i, j] = phi(d, dp) else: P = np.polyfit([0, self.D_j[j + 1]**2, self.D_j[j + 2]**2], [ self.phi0, self.phi_ij[i, j + 1], self.phi_ij[i, j + 2] ], 2) self.phi_ij[i, :j + 3] = np.polyval(P, self.D_j[:j + 3]**2) break self.world.sum(self.phi_ij) print print 'VDW: Done!' if self.world.rank == 0: pickle.dump(self.phi_ij, open(name, 'w'), pickle.HIGHEST_PROTOCOL) def make_prl_plot(self, multiply_by_4_pi_D_squared=True): import pylab as plt x = np.linspace(0, 8.0, 100) for delta in [0, 0.5, 0.9]: y = [self.phi(D * (1.0 + delta), D * (1.0 - delta)) for D in x] if multiply_by_4_pi_D_squared: y *= 4 * pi * x**2 plt.plot(x, y, label=r'$\delta=%.1f$' % delta) plt.legend(loc='best') plt.plot(x, np.zeros(len(x)), 'k-') plt.xlabel('D') plt.ylabel(r'$4\pi D^2 \phi(\rm{Hartree})$') plt.show() def phi(self, d, dp): """Kernel function. Uses bi-linear interpolation and returns zero for D > Dmax. """ P = self.phi_ij D = (d + dp) / 2.0 if D < 1e-14: return P[0, 0] if D >= self.D_j[-1]: return 0.0 delta = abs((d - dp) / (2 * D)) ddelta = self.delta_i[1] x = delta / ddelta i = int(x) if i == len(self.delta_i) - 1: i -= 1 x = 1.0 else: x -= i dD = self.D_j[1] y = D / dD j = int(y) y -= j return (x * (y * P[i + 1, j + 1] + (1 - y) * P[i + 1, j]) + (1 - x) * (y * P[i, j + 1] + (1 - y) * P[i, j]))