def __init__(self, generator, name=None, run=True, gtxt='-', non_relativistic_guess=False, xc='PBE'): if isinstance(generator, str): # treat 'generator' as symbol generator = Generator(generator, scalarrel=True, xcname=xc, txt=gtxt, nofiles=True) generator.N *= 4 self.generator = generator self.rgd = AERadialGridDescriptor(generator.beta, generator.N, default_spline_points=100) self.name = name if run: if non_relativistic_guess: ae0 = AllElectron(generator.symbol, scalarrel=False, nofiles=False, txt=gtxt, xcname=xc) ae0.N = generator.N ae0.beta = generator.beta ae0.run() # Now files will be stored such that they can # automagically be used by the next run() generator.run(write_xml=False, use_restart_file=False, **parameters[generator.symbol])
def gen(symbol, exx=False, name=None, **kwargs): if mpi.rank == 0: if 'scalarrel' not in kwargs: kwargs['scalarrel'] = True g = Generator(symbol, **kwargs) g.run(exx=exx, name=name, use_restart_file=False, **parameters[symbol]) mpi.world.barrier() if setup_paths[0] != '.': setup_paths.insert(0, '.')
def generate_old(self, fd, xc, scalar_relativistic, tag): from gpaw.atom.configurations import parameters from gpaw.atom.generator import Generator par = parameters[self.symbol] g = Generator(self.symbol, xc, scalarrel=scalar_relativistic, nofiles=True, txt=fd) g.run(exx=True, logderiv=False, use_restart_file=False, name=tag, **par)
def __init__(self, generator, name=None, run=True, gtxt='-', non_relativistic_guess=False, xc='PBE', save_setup=False): if isinstance(generator, str): # treat 'generator' as symbol generator = Generator(generator, scalarrel=True, xcname=xc, txt=gtxt, nofiles=True) generator.N *= 4 self.generator = generator self.rgd = AERadialGridDescriptor(generator.beta / generator.N, 1.0 / generator.N, generator.N, default_spline_points=100) self.name = name if run: if non_relativistic_guess: ae0 = AllElectron(generator.symbol, scalarrel=False, nofiles=False, txt=gtxt, xcname=xc) ae0.N = generator.N ae0.beta = generator.beta ae0.run() # Now files will be stored such that they can # automagically be used by the next run() setup = generator.run(write_xml=False, use_restart_file=False, name=name, **parameters[generator.symbol]) if save_setup: setup.write_xml() else: if save_setup: raise ValueError('cannot save setup here because setup ' 'was already generated before basis ' 'generation.')
def test(): # Generate setup symbol = 'He' if rank == 0: g = Generator(symbol, 'revPBE', scalarrel=True, nofiles=True) g.run(exx=True, **parameters[symbol]) barrier() setup_paths.insert(0, '.') a = 7.5 * Bohr n = 16 atoms = Atoms([Atom('He', (0.0, 0.0, 0.0))], cell=(a, a, a), pbc=True) calc = Calculator(gpts=(n, n, n), nbands=1, xc='revPBE') atoms.set_calculator(calc) e1 = atoms.get_potential_energy() calc.write('He') e2 = e1 + calc.get_xc_difference('vdWDF') print e1, e2
def gen(symbol, exx=False, name=None, **kwargs): setup = None if mpi.rank == 0: if 'scalarrel' not in kwargs: kwargs['scalarrel'] = True g = Generator(symbol, **kwargs) if 'orbital_free' in kwargs: setup = g.run(exx=exx, name=name, use_restart_file=False, **tf_parameters.get(symbol, {'rcut': 0.9})) else: setup = g.run(exx=exx, name=name, use_restart_file=False, **parameters[symbol]) setup = mpi.broadcast(setup, 0) if setup_paths[0] != '.': setup_paths.insert(0, '.') return setup
def generate_setup(self): if mpi.rank == 0: gen = Generator(self.symbol, 'PBE', scalarrel=True) gen.run(logderiv=True, **parameters[self.symbol]) data = analyse(gen, show=False) g = np.arange(gen.N) r_g = gen.r dr_g = gen.beta * gen.N / (gen.N - g)**2 rcutcomp = gen.rcutcomp rcutfilter = gen.rcutfilter # Find cutoff for core density: if gen.Nc == 0: rcore = 0.5 else: N = 0.0 g = gen.N - 1 while N < 1e-7: N += np.sqrt(4 * np.pi) * gen.nc[g] * r_g[g]**2 * dr_g[g] g -= 1 rcore = r_g[g] nlfer = [] for j in range(gen.njcore): nlfer.append( (gen.n_j[j], gen.l_j[j], gen.f_j[j], gen.e_j[j], 0.0)) for n, l, f, eps in zip(gen.vn_j, gen.vl_j, gen.vf_j, gen.ve_j): nlfer.append((n, l, f, eps, gen.rcut_l[l])) self.data = dict(Z=gen.Z, Nv=gen.Nv, Nc=gen.Nc, rcutcomp=rcutcomp, rcutfilter=rcutfilter, rcore=rcore, Ekin=gen.Ekin, Epot=gen.Epot, Exc=gen.Exc, nlfer=nlfer)
def gen(symbol, xcname): g = Generator(symbol, xcname, scalarrel=True, nofiles=True) g.run(exx=True, **parameters[symbol]) files.append('%s.%s' % (symbol, XCFunctional(xcname).get_name()))
def calculate(self): ESIC = 0 xc = self.paw.hamiltonian.xc assert xc.type == 'LDA' # Calculate the contribution from the core orbitals for a in self.paw.density.D_asp: setup = self.paw.density.setups[a] # TODO: Use XC which has been used to calculate the actual # calculation. # TODO: Loop over setups, not atoms. print('Atom core SIC for ', setup.symbol) print('%10s%10s%10s' % ('E_xc[n_i]', 'E_Ha[n_i]', 'E_SIC')) g = Generator(setup.symbol, xcname='LDA', nofiles=True, txt=None) g.run(**parameters[setup.symbol]) njcore = g.njcore for f, l, e, u in zip(g.f_j[:njcore], g.l_j[:njcore], g.e_j[:njcore], g.u_j[:njcore]): # Calculate orbital density # NOTE: It's spherically symmetrized! #n = np.dot(self.f_j, assert l == 0, ('Not tested for l>0 core states') na = np.where(abs(u) < 1e-160, 0, u)**2 / (4 * pi) na[1:] /= g.r[1:]**2 na[0] = na[1] nb = np.zeros(g.N) v_sg = np.zeros((2, g.N)) e_g = np.zeros(g.N) vHr = np.zeros(g.N) Exc = xc.calculate_spherical(g.rgd, np.array([na, nb]), v_sg) hartree(0, na * g.r * g.dr, g.r, vHr) EHa = 2 * pi * np.dot(vHr * na * g.r, g.dr) print( ('%10.2f%10.2f%10.2f' % (Exc * Hartree, EHa * Hartree, -f * (EHa + Exc) * Hartree))) ESIC += -f * (EHa + Exc) sic = SIC(finegrid=True, coulomb_factor=1, xc_factor=1) sic.initialize(self.paw.density, self.paw.hamiltonian, self.paw.wfs) sic.set_positions(self.paw.atoms.get_scaled_positions()) print('Valence electron sic ') print('%10s%10s%10s%10s%10s%10s' % ('spin', 'k-point', 'band', 'E_xc[n_i]', 'E_Ha[n_i]', 'E_SIC')) assert len( self.paw.wfs.kpt_u) == 1, ('Not tested for bulk calculations') for s, spin in sic.spin_s.items(): spin.initialize_orbitals() spin.update_optimal_states() spin.update_potentials() n = 0 for xc, c in zip(spin.exc_m, spin.ecoulomb_m): print(('%10i%10i%10i%10.2f%10.2f%10.2f' % (s, 0, n, -xc * Hartree, -c * Hartree, 2 * (xc + c) * Hartree))) n += 1 ESIC += spin.esic print('Total correction for self-interaction energy:') print('%10.2f eV' % (ESIC * Hartree)) print('New total energy:') total = (ESIC * Hartree + self.paw.get_potential_energy() + self.paw.get_reference_energy()) print('%10.2f eV' % total) return total
for name in all_names: check(con, name) data = {} for name in all_names: if '.' in name: symbol, e = name.split('.') params = parameters_extra[symbol] assert params['name'] == e else: symbol = name e = 'default' params = parameters[symbol] data[symbol] = [] gen = Generator(symbol, 'PBE', scalarrel=True, txt=None) gen.run(write_xml=False, **params) nlfer = [] for j in range(gen.njcore): nlfer.append((gen.n_j[j], gen.l_j[j], gen.f_j[j], gen.e_j[j], 0.0)) for n, l, f, eps in zip(gen.vn_j, gen.vl_j, gen.vf_j, gen.ve_j): nlfer.append((n, l, f, eps, gen.rcut_l[l])) energies = summary(con, name) data[symbol].append((e, nlfer, energies)) with open('datasets.json', 'w') as fd: fd.write(encode(data))
#!/usr/bin/env python from ase import * from gpaw import GPAW from gpaw.mpi import run, world from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters from gpaw import setup_paths # Generate setups for oxygen and hydrogen: if world.rank == 0: g = Generator('O', xcname='GLLBLDARCR', scalarrel=True, nofiles=True) g.run(**parameters['O']) g = Generator('H', xcname='GLLBLDARCR', scalarrel=True, nofiles=True) g.run(**parameters['H']) world.barrier() setup_paths.insert(0, '.') # Then, calculate the core-eigenvalue of H2O molecule a = 5.0 d = 0.9575 t = pi / 180 * 104.51 H2O = Atoms([ Atom('O', (0, 0, 0)), Atom('H', (d, 0, 0)), Atom('H', (d * cos(t), d * sin(t), 0)) ], cell=(a, a, a), pbc=False) H2O.center() calc = GPAW(nbands=10, h=0.2, xc='GLLBLDARCR')
def main(): parser = build_parser() opt, args = parser.parse_args() import sys from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters, tf_parameters from gpaw.atom.all_electron import AllElectron from gpaw import ConvergenceError if args: atoms = args else: atoms = parameters.keys() bad_density_warning = """\ Problem with initial electron density guess! Try to run the program with the '-nw' option (non-scalar-relativistic calculation + write density) and then try again without the '-n' option (this will generate a good initial guess for the density).""" for symbol in atoms: scalarrel = not opt.non_scalar_relativistic corehole = None if opt.core_hole is not None: state, occ = opt.core_hole.split(',') # Translate corestate string ('1s') to n and l: ncorehole = int(state[0]) lcorehole = 'spdf'.find(state[1]) fcorehole = float(occ) corehole = (ncorehole, lcorehole, fcorehole) if opt.all_electron_only: a = AllElectron(symbol, opt.xcfunctional, scalarrel, corehole, opt.configuration, not opt.write_files, '-', opt.points_per_node, opt.orbital_free, opt.tw_coefficient) try: a.run() except ConvergenceError: print(bad_density_warning, file=sys.stderr) continue g = Generator(symbol, opt.xcfunctional, scalarrel, corehole, opt.configuration, not opt.write_files, '-', opt.points_per_node, orbital_free=opt.orbital_free, tw_coeff=opt.tw_coefficient) if opt.orbital_free: p = tf_parameters.get(symbol, {'rcut': 0.9}) else: p = parameters.get(symbol, {}) if opt.core is not None: p['core'] = opt.core if opt.radius is not None: p['rcut'] = [float(x) for x in opt.radius.split(',')] if opt.extra_projectors is not None: extra = {} if opt.extra_projectors != '': for l, x in enumerate(opt.extra_projectors.split(';')): if x != '': extra[l] = [float(y) for y in x.split(',')] p['extra'] = extra if opt.normconserving is not None: p['normconserving'] = opt.normconserving if opt.filter is not None: p['filter'] = [float(x) for x in opt.filter.split(',')] if opt.compensation_charge_radius is not None: p['rcutcomp'] = opt.compensation_charge_radius if opt.zero_potential is not None: vbar = opt.zero_potential.split(',') p['vbar'] = (vbar[0], float(vbar[1])) if opt.empty_states is not None: p['empty_states'] = opt.empty_states try: g.run(logderiv=opt.logarithmic_derivatives, exx=opt.exact_exchange, name=opt.name, use_restart_file=opt.use_restart_file, **p) except ConvergenceError: print(bad_density_warning, file=sys.stderr) except RuntimeError as m: if len(m.__str__()) == 0: raise print(m) if opt.plot: from gpaw.atom.analyse_setup import analyse analyse(g, show=True)
import os from gpaw import Calculator from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters # Generate setups with 0.5, 1.0, 0.0 core holes in 1s elements = ['O', 'C', 'N'] coreholes = [0.5, 1.0, 0.0] names = ['hch1s', 'fch1s', 'xes1s'] functionals = ['LDA', 'PBE'] for el in elements: for name, ch in zip(names, coreholes): for funct in functionals: g = Generator(el, scalarrel=True, xcname=funct, corehole=(1, 0, ch), nofiles=True) g.run(name=name, **parameters[el])
from gpaw.atom.generator import Generator from gpaw.atom.basis import BasisMaker args = {'core': '[Kr]', 'rcut': 2.45} generator = Generator('Ag', 'GLLBSC', scalarrel=True) generator.N *= 2 # Increase grid resolution generator.run(**args) bm = BasisMaker(generator, name='GLLBSC', run=False) basis = bm.generate( zetacount=2, polarizationcount=0, energysplit=0.07, jvalues=[0, 1, 2], # include d, s and p rcutmax=12.0) basis.write_xml()
from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters from gpaw.atom.basis import BasisMaker symbol = 'Au' args = parameters[symbol] # Dictionary of default setup parameters args['rcut'] = 2.6 # Set cutoff of augmentation sphere generator = Generator(symbol, 'RPBE') generator.N *= 2 # Increase grid resolution generator.run(write_xml=False, **args) bm = BasisMaker(generator, name='special', run=False) # Create double-zeta RPBE basis where p orbital is considered a valence state # (ordinary dzp basis would use a smaller p-type Gaussian for polarization) # The list jvalues indicates which states should be included, and the # ordering corresponds to the valence states in the setup. basis = bm.generate(zetacount=2, polarizationcount=0, energysplit=0.1, jvalues=[0, 1, 2], rcutmax=12.0) basis.write_xml() # Dump to file 'Au.special.basis'
diff = e_HOMO_cs[atom] + e_homo print('%2s %8g %6.1f %4.1g' % (atom, e_HOMO_cs[atom], -e_homo, diff)) assert abs(diff) < 6 barrier() setup_paths.insert(0, '.') setups = {} print('**** 3D calculations') print('atom [refs] -e_homo diff all in mHa') for atom in e_HOMO_cs.keys(): e_ref = e_HOMO_cs[atom] # generate setup for the atom if rank == 0 and not setups.has_key(atom): g = Generator(atom, 'LB94', nofiles=True, txt=txt) g.run(**parameters[atom]) setups[atom] = 1 barrier() SS = Atoms([Atom(atom)], cell=(7, 7, 7), pbc=False) SS.center() c = GPAW(h=.3, xc='LB94', nbands=-2, txt=txt) if atom in ['Mg']: c.set(eigensolver='cg') c.calculate(SS) # find H**O energy eps_n = c.get_eigenvalues(kpt=0, spin=0) / 27.211 f_n = c.get_occupation_numbers(kpt=0, spin=0) for e, f in zip(eps_n, f_n): if f < 0.99:
import os from math import pi, cos, sin from ase import * from gpaw import GPAW from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters from gpaw import setup_paths from gpaw.mpi import world # Generate the setups if world.rank == 0: Generator('O', nofiles=True, xcname='LDA').run(**parameters['O']) Generator('O', nofiles=True, xcname='GLLBLDA').run(**parameters['O']) Generator('H', nofiles=True, xcname='LDA').run(**parameters['H']) Generator('H', nofiles=True, xcname='GLLBLDA').run(**parameters['H']) setup_paths.insert(0, '.') a = 4.0 d = 0.9575 t = pi / 180 * 104.51 system = [ Atom('O', (0, 0, 0)), Atom('H', (d, 0, 0)), Atom('H', (d * cos(t), d * sin(t), 0)) ] c = { 'energy': 1e-6, # eV / atom 'density': 1.0e-7,
elif symbol in ['Be', 'B', 'C', 'N', 'O', 'F', 'Ne']: rcut = 1.2 elif symbol in ['Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar']: rcut = 1.4 else: rcut = 1.0 # If the lambda scaling is used change name to differentiate the setup name = 'lambda_{0}'.format(lambda_coeff) # Use of Kinetic functional (minus the Tw contribution) inside the # xc definition #pauliname = '{0}_LDA_K_TF+1.0_LDA_X+1.0_LDA_C_PW'.format(gamma_coeff) #pauliname = '{0}_LDA_K_TF+1.0_LDA_K_LP+-1.0_LDA_K_LP+1.0_LDA_X+1.0_LDA_C_PW'.format(gamma_coeff) pauliname = '1.0_GGA_K_TFVW+-1.0_GGA_K_VW+1.0_GGA_X_PBE+1.0_GGA_C_PBE' print('Pauliname: ' + pauliname) # Calculate OFDFT density g = Generator(symbol, xcname=pauliname, scalarrel=False, orbital_free=True, tw_coeff=lambda_coeff, gpernode=gpernode) g.run(exx=False, name=name, use_restart_file=False, rcut=rcut, write_xml=True)
from gpaw import GPAW, restart, Davidson, Mixer from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters from gpaw import setup_paths from gpaw.mpi import world from gpaw.test import equal # This test calculates the derivative discontinuity of Ne-atom # first on 3D without restart. Then does restart and recalculates. atom = 'Ne' setup_paths.insert(0, '.') for xcname in ['GLLB', 'GLLBSC']: if world.rank == 0: g = Generator(atom, xcname=xcname, scalarrel=False, nofiles=True) g.run(**parameters[atom]) eps = g.e_j[-1] world.barrier() a = 10 Ne = Atoms([Atom(atom, (0, 0, 0))], cell=(a, a, a), pbc=False) Ne.center() calc = GPAW(eigensolver=Davidson(4), nbands=10, h=0.18, xc=xcname, basis='dzp', mixer=Mixer(0.6)) Ne.set_calculator(calc) e = Ne.get_potential_energy()
from ase import * from gpaw import GPAW from gpaw.utilities import equal from gpaw.atom.generator import Generator from gpaw.atom.configurations import parameters from gpaw import setup_paths Generator('Ne', nofiles=True, scalarrel=False, xcname='GLLBNORESP').run(**parameters['Ne']) setup_paths.insert(0, '.') a = 8 hydrogen = Atoms([Atom('Ne')], cell=(a, a, a), pbc=False) hydrogen.center() calc = GPAW(xc='GLLBNORESP') hydrogen.set_calculator(calc) e1 = hydrogen.get_potential_energy()