def test(): vdw = FFTVDWFunctional('vdW-DF', verbose=1) d = 3.9 x = d / sqrt(3) L = 3.0 + 2 * 4.0 dimer = Atoms('Ar2', [(0, 0, 0), (x, x, x)], cell=(L, L, L)) dimer.center() calc = GPAW(h=0.2, xc='revPBE') dimer.set_calculator(calc) e2 = dimer.get_potential_energy() niter2 = calc.get_number_of_iterations() calc.write('Ar2.gpw') e2vdw = calc.get_xc_difference(vdw) e2vdwb = GPAW('Ar2.gpw').get_xc_difference(vdw) print e2vdwb - e2vdw assert abs(e2vdwb - e2vdw) < 1e-9 del dimer[1] e = dimer.get_potential_energy() niter = calc.get_number_of_iterations() evdw = calc.get_xc_difference(vdw) E = 2 * e - e2 Evdw = E + 2 * evdw - e2vdw print E, Evdw assert abs(E - -0.0048) < 6e-3, abs(E) assert abs(Evdw - +0.0223) < 3e-2, abs(Evdw) print e2, e equal(e2, -0.001581923, energy_tolerance) equal(e, -0.003224226, energy_tolerance)
def check_diff(g1, g2, gd, txt): # print rank, txt, "shapes", g1.shape, g2.shape intd = gd.integrate(np.abs(g1 - g2)) parprint(txt, "integrated diff=", intd, end="") maxd = np.max(np.abs(g1 - g2)) parprint("max diff=", maxd) equal(intd, 0, 1.0e-8) equal(maxd, 0, 1.0e-9)
def test(gd1, gd2, pd1, pd2, R1, R2): a1 = gd1.zeros(dtype=pd1.dtype) a1[R1] = 1 a2 = pd1.interpolate(a1, pd2)[0] x = a2[R2] a2 = gd2.zeros(dtype=pd2.dtype) a2[R2] = 1 y = pd2.restrict(a2, pd1)[0][R1] * a2.size / a1.size equal(x, y, 1e-9) return x
def paired(): xc = XC('vdW-DF') n = 0.3 * np.ones((1, N, N, N)) n += 0.01 * np.cos(np.arange(N) * 2 * pi / N) v = 0.0 * n xc.calculate(gd, n, v) n2 = 1.0 * n i = 1 n2[0, i, i, i] += 0.00002 x = v[0, i, i, i] * gd.dv E2 = xc.calculate(gd, n2, v) n2[0, i, i, i] -= 0.00004 E2 -= xc.calculate(gd, n2, v) x2 = E2 / 0.00004 print(i, x, x2, x - x2, x / x2) equal(x, x2, 2e-11)
def polarized(): xc = XC('vdW-DF') n = 0.04 * np.ones((2, N, N, N)) n[1] = 0.3 n[0] += 0.02 * np.sin(np.arange(N) * 2 * pi / N) n[1] += 0.2 * np.cos(np.arange(N) * 2 * pi / N) v = 0.0 * n xc.calculate(gd, n, v) n2 = 1.0 * n i = 1 n2[0, i, i, i] += 0.00002 x = v[0, i, i, i] * gd.dv E2 = xc.calculate(gd, n2, v) n2[0, i, i, i] -= 0.00004 E2 -= xc.calculate(gd, n2, v) x2 = E2 / 0.00004 print(i, x, x2, x - x2, x / x2) equal(x, x2, 1e-10)
def testSTM(calc): stm = SimpleStm(calc) stm.write_3D([1,0,0], f3dname) # single wf wf = stm.gd.integrate(stm.ldos) ## print "wf=", wf if size == 1: # XXXX we have problem with reading plt in parallel stm2 = SimpleStm(f3dname) wf2 = stm2.gd.integrate(stm2.ldos) print('Integrals: written, read=', wf, wf2) equal(wf, wf2, 2.e-7) ## print eigenvalue_string(calc) stm.write_3D(3.1, f3dname) wf2 = stm.gd.integrate(stm.ldos) ## print "wf2=", wf2 equal(wf2, 2, 0.12) return wf
def check(calc): wannier = Wannier(calc, nbands=6) wannier.localize() centers = wannier.get_centers() print centers expected = [[1.950, 2.376, 3.000], [1.950, 3.624, 3.000], [3.000, 3.000, 2.671], [3.000, 3.000, 3.329], [4.050, 2.376, 3.000], [4.050, 3.624, 3.000]] equal(13.7995, wannier.value, 0.016) for center in centers: i = 0 while np.sum((expected[i] - center)**2) > 0.01: i += 1 if i == len(expected): raise RuntimeError, 'Correct center not found' expected.pop(i)
def run(lastres=[]): results = [] # Hirshfeld ---------------------------------------- if 1: hd = HirshfeldDensity(calc) # check for the number of electrons expected = [[None, 10], [[0, 1, 2], 10], [[1, 2], 2], [[0], 8], ] #expected = [[[0, 2], 9], ] #expected = [[None, 10], ] for gridrefinement in [1, 2, 4]: #Test for all gridrefinements for get_all_electron_density parprint('grid refinement', gridrefinement) for result in expected: indicees, result = result full, gd = hd.get_density(indicees, gridrefinement) parprint('indicees', indicees, end=': ') parprint('result, expected:', gd.integrate(full), result) if gridrefinement < 4: #The highest level of gridrefinement gets wrong electron numbers equal(gd.integrate(full), result, 1.e-8) else: equal(gd.integrate(full), result, 1.e-5) hp = HirshfeldPartitioning(calc) vr = hp.get_effective_volume_ratios() parprint('Hirshfeld:', vr) if len(lastres): equal(vr, lastres.pop(0), 1.e-10) results.append(vr) # Wigner-Seitz ---------------------------------------- if 1: ws = WignerSeitz(calc.density.finegd, mol, calc) vr = ws.get_effective_volume_ratios() parprint('Wigner-Seitz:', vr) if len(lastres): equal(vr, lastres.pop(0), 1.e-10) results.append(vr) return results
# without spin lr = LrTDDFT(calc, xc=xc) lr.diagonalize() t1 = lr[0] lr_calc = lr ex = ExcitedState(lr, 0) den = ex.get_pseudo_density() * Bohr**3 # course grids for finegrid in [1,0]: lr = LrTDDFT(calc, xc=xc, finegrid=finegrid) lr.diagonalize() t3 = lr[0] parprint('finegrid, t1, t3=', finegrid, t1 ,t3) equal(t1.get_energy(), t3.get_energy(), 5.e-4) # with spin lr_vspin = LrTDDFT(calc, xc=xc, nspins=2) singlet, triplet = lr_vspin.singlets_triplets() lr_vspin.diagonalize() # the triplet is lower, so that the second is the first singlet # excited state t2 = lr_vspin[1] ex_vspin = ExcitedState(lr_vspin, 1) den_vspin = ex_vspin.get_pseudo_density() * Bohr**3 parprint('with virtual/wo spin t2, t1=', t2.get_energy(), t1 .get_energy()) equal(t1.get_energy(), t2.get_energy(), 5.e-7)
from ase import Atoms from gpaw import GPAW from gpaw.spinorbit import get_spinorbit_eigenvalues from gpaw.test import equal a = Atoms('Kr') a.center(vacuum=3.0) calc = GPAW(mode='pw', xc='LDA') a.calc = calc a.get_potential_energy() e_n = calc.get_eigenvalues() e_m = get_spinorbit_eigenvalues(calc) equal(e_n[0] - e_m[0], 0.0, 1.0e-3) equal(e_n[1] - e_m[2], 0.452, 1.0e-3) equal(e_n[2] - e_m[4], -0.226, 1.0e-3)
l = 2 # d-orbitals U_ev = 6 # U in eV U_au = U_ev / Hartree # U in atomic units scale = 1 # Do not scale (does not seem to matter much) store = 0 # Do not store (not in use yet) for a in np.arange(2): # Loops though all Ni atoms calc.hamiltonian.setups[a].set_hubbard_u(U_au, l, scale, store) # Apply U ############################################################################## ## Make ready for scf with the DFT+U functional and converge this new system ## and get new band bag.....which should be much larger: calc.scf.reset() e2 = calc.get_potential_energy() niter2 = calc.get_number_of_iterations() Eg_Hub = band_gab(calc) ############################################################################## ## Now we expect that one effect of the Hubbard U is the opening of the band ## gab, so the band gab shall we test parameter: ## Let's compare the new and old band gab and require that is has opened by ## at least 0.2 eV assert (Eg_Hub - Eg_non_Hub > 1.9) energy_tolerance = 0.0004 niter_tolerance = 0 equal(e1, -28.43826, energy_tolerance) # svnversion 5252 equal(niter1, 13, niter_tolerance) # svnversion 5252 equal(e2, -27.70915, energy_tolerance) # svnversion 5252 equal(niter2, 9, niter_tolerance) # svnversion 7411
h =.3 box = 4. energy_tolerance = 0.0004 l=2 # d-orbitals U_ev=3 # U in eV U_au=U_ev / Hartree # U in atomic units scale=1 # Do not scale (does not seem to matter much) store=0 # Do not store (not in use yet) s = Cluster([Atom('Zn')]) s.minimal_box(box, h=h) E = {} E_U = {} for spin in [0, 1]: c = GPAW(h=h, spinpol=bool(spin), charge=1, occupations=FermiDirac(width=0.1) ) s.set_calculator(c) E[spin] = s.get_potential_energy() for setup in c.hamiltonian.setups: setup.set_hubbard_u(U_au, l, scale, store) # Apply U c.scf.reset() E_U[spin] = s.get_potential_energy() print "E=", E equal(E[0], E[1], energy_tolerance) print "E_U=", E_U equal(E_U[0], E_U[1], energy_tolerance)
bulk = Atoms("Li", pbc=True) k = 4 g = 8 calc = GPAW(gpts=(g, g, g), kpts=(k, k, k), mode="lcao", basis="dzp") bulk.set_calculator(calc) e = [] niter = [] A = [2.6, 2.65, 2.7, 2.75, 2.8] for a in A: bulk.set_cell((a, a, a)) e.append(bulk.get_potential_energy()) niter.append(calc.get_number_of_iterations()) a = np.roots(np.polyder(np.polyfit(A, e, 2), 1))[0] print("a =", a) equal(a, 2.63781, 0.0001) e_ref = [-1.8677343236247692, -1.8690343169380492, -1.8654175796625045, -1.8566274574918875, -1.8432374955346396] niter_ref = [6, 6, 6, 6, 6] print(e) energy_tolerance = 0.00003 niter_tolerance = 0 for i in range(len(A)): equal(e[i], e_ref[i], energy_tolerance) equal(niter[i], niter_ref[i], niter_tolerance) wf1 = calc.get_pseudo_wave_function(kpt=3, band=0) calc.write("Li", mode="all") calc2 = GPAW("Li")
poissonsolver=PoissonSolver(nn="M"), occupations=FermiDirac(width=0.01), kpts=(3, 3, 3), convergence={"eigenstates": 9.2e-11, "bands": 8}, xc=xc, eigensolver="cg", ) bulk.set_calculator(calc) e[xc] = {"direct": bulk.get_potential_energy()} niter[xc] = {"direct": calc.get_number_of_iterations()} print(calc.get_ibz_k_points()) old_eigs = calc.get_eigenvalues(kpt=3) calc.write("Si_gs.gpw") del bulk del calc bulk, calc = restart("Si_gs.gpw", fixdensity=True, kpts=[[0, 0, 0], [1.0 / 3, 1.0 / 3, 1.0 / 3]]) e[xc] = {"restart": bulk.get_potential_energy()} niter[xc] = {"restart": calc.get_number_of_iterations()} if world.rank == 0: os.remove("Si_gs.gpw") diff = calc.get_eigenvalues(kpt=1)[:6] - old_eigs[:6] if world.rank == 0: print("occ. eig. diff.", diff) error = max(abs(diff)) assert error < 5e-6 for mode in e[xc].keys(): equal(e[xc][mode], e_ref[xc][mode], energy_tolerance)
#!/usr/bin/env python from ase import Atom, Atoms from gpaw import GPAW from gpaw.test import equal a = 6. b = a / 2 mol = Atoms([Atom('O',(b, b, 0.1219 + b)), Atom('H',(b, 0.7633 + b, -0.4876 + b)), Atom('H',(b, -0.7633 + b, -0.4876 + b))], pbc=False, cell=[a, a, a]) calc = GPAW(gpts=(32, 32, 32), nbands=4, mode='lcao') mol.set_calculator(calc) e = mol.get_potential_energy() niter = calc.get_number_of_iterations() eref = -10.39054 err = abs(e - eref) print 'Energy', e print 'Ref', eref print 'Err', err assert err < 1e-4 equal(niter, 8, 0)
extra_parameters['usenewxc'] = True from gpaw.utilities.kspot import AllElectronPotential try: if 1: be = Atoms(symbols='Be', positions=[(0, 0, 0)]) be.center(vacuum=5) calc = GPAW(gpts=(64, 64, 64), xc='LDA', nbands=1) #0.1 required for accuracy be.set_calculator(calc) e = be.get_potential_energy() niter = calc.get_number_of_iterations() #calc.write("be.gpw") energy_tolerance = 0.00001 niter_tolerance = 0 equal(e, 0.00246471, energy_tolerance) equal(niter, 16, niter_tolerance) #be, calc = restart("be.gpw") AllElectronPotential(calc).write_spherical_ks_potentials('bepot.txt') f = open('bepot.txt') lines = f.readlines() f.close() mmax = 0 for l in lines: mmax = max(abs(eval(l.split(' ')[3])), mmax) print "Max error: ", mmax assert mmax < 0.009 except: extra_parameters['usenewxc'] = usenewxc
calc = prepare({0: 'paw', 1: 'ghost'}) system.set_calculator(calc) e_bsse = system.get_potential_energy() niter_bsse = calc.get_number_of_iterations() c_nM = calc.wfs.kpt_u[0].C_nM print('coefs') print(c_nM) print('energy', e_bsse) # Reference system which is just a hydrogen sys0 = system[0:1].copy() calc = prepare('paw') sys0.set_calculator(calc) e0 = sys0.get_potential_energy() niter0 = calc.get_number_of_iterations() print('e0, e_bsse = ', e0, e_bsse) # One coefficient should be very small (0.012), the other very large (0.99) assert abs(1.0 - abs(c_nM[0, 0])) < 0.02 assert abs(c_nM[0, 1]) < 0.02 assert abs(e_bsse - e0) < 2e-3 energy_tolerance = 0.0002 niter_tolerance = 1 equal(e_bsse, 0.0287208853911, energy_tolerance) # svnversion 5252 equal(niter_bsse, 7, niter_tolerance) # svnversion 5252 equal(e0, 0.0299220702846, energy_tolerance) # svnversion 5252 equal(niter0, 6, niter_tolerance) # svnversion 5252
from gpaw.test import equal from gpaw.grid_descriptor import GridDescriptor from gpaw.spline import Spline import gpaw.mpi as mpi from gpaw.lfc import LocalizedFunctionsCollection as LFC s = Spline(0, 1.0, [1.0, 0.5, 0.0]) n = 40 a = 8.0 gd = GridDescriptor((n, n, n), (a, a, a), comm=mpi.serial_comm) c = LFC(gd, [[s], [s], [s]]) c.set_positions([(0.5, 0.5, 0.25 + 0.25 * i) for i in [0, 1, 2]]) b = gd.zeros() c.add(b) x = gd.integrate(b) gd = GridDescriptor((n, n, n), (a, a, a), comm=mpi.serial_comm) c = LFC(gd, [[s], [s], [s]]) c.set_positions([(0.5, 0.5, 0.25 + 0.25 * i) for i in [0, 1, 2]]) b = gd.zeros() c.add(b) y = gd.integrate(b) equal(x, y, 1e-13)
## with fractional translations calc = GPAW(mode=PW(), xc='LDA', kpts=(3, 3, 3), nbands=42, symmetry={'symmorphic': False}, gpts=(20, 20, 24), eigensolver='rmm-diis') atoms.set_calculator(calc) energy_fractrans = atoms.get_potential_energy() assert (len(calc.wfs.kd.ibzk_kc) == 7) assert (len(calc.wfs.kd.symmetry.op_scc) == 6) ## without fractional translations calc = GPAW(mode=PW(), xc='LDA', kpts=(3, 3, 3), nbands=42, gpts=(20, 20, 24), eigensolver='rmm-diis') atoms.set_calculator(calc) energy_no_fractrans = atoms.get_potential_energy() assert (len(calc.wfs.kd.ibzk_kc) == 10) assert (len(calc.wfs.kd.symmetry.op_scc) == 2) equal(energy_fractrans, energy_no_fractrans, 1e-3)
rpa = RPACorrelation('N2.gpw', nfrequencies=8) E_n2_rpa = rpa.calculate(ecut=[ecut]) N = molecule('N') N.set_cell(N2.cell) calc = GPAW(mode=PW(force_complex_dtype=True), xc='PBE', parallel={'domain': 1}, eigensolver='rmm-diis') N.set_calculator(calc) E_n_pbe = N.get_potential_energy() calc.diagonalize_full_hamiltonian(nbands=104, scalapack=True) calc.write('N.gpw', mode='all') exx = EXX('N.gpw') exx.calculate() E_n_hf = exx.get_total_energy() rpa = RPACorrelation('N.gpw', nfrequencies=8) E_n_rpa = rpa.calculate(ecut=[ecut]) print('Atomization energies:') print('PBE: ', E_n2_pbe - 2 * E_n_pbe) print('HF: ', E_n2_hf - 2 * E_n_hf) print('HF+RPA: ', E_n2_hf - 2 * E_n_hf + E_n2_rpa[0] - 2 * E_n_rpa[0]) equal(E_n2_rpa - 2 * E_n_rpa, -1.68, 0.02)
for xcname in libxc_set: ra.seed(8) xc = XC(xcname) s = create_setup('N', xc) ni = s.ni nii = ni * (ni + 1) // 2 D_p = 0.1 * ra.random(nii) + 0.4 H_p = np.zeros(nii) E1 = s.xc_correction.calculate(xc, D_p.reshape(1, -1), H_p.reshape(1, -1)) dD_p = x * ra.random(nii) D_p += dD_p dE = np.dot(H_p, dD_p) / x E2 = s.xc_correction.calculate(xc, D_p.reshape(1, -1)) print xcname, dE, (E2 - E1) / x equal(dE, (E2 - E1) / x, 0.003) E2s = s.xc_correction.calculate(xc, np.array([0.5 * D_p, 0.5 * D_p]), np.array([H_p, H_p])) print E2, E2s equal(E2, E2s, 1.0e-12) if xcname in reference: # compare with old gpaw print 'A:', E2, reference[xcname] equal(E2, reference[xcname], tolerance) if xc in reference_libxc: # compare with reference libxc print 'B:', E2, reference_libxc[xcname] equal(E2, reference_libxc[xcname], tolerance) D_sp = 0.1 * ra.random((2, nii)) + 0.2
atoms[0].magmom = 1 calc.set(charge=-1, setups={'O': 'fch1s'}, occupations=FermiDirac(0.0, fixmagmom=True)) e2 = atoms.get_potential_energy() + calc.get_reference_energy() niter2 = calc.get_number_of_iterations() atoms[0].magmom = 0 calc.set(charge=0, setups={'O': 'fch1s'}, occupations=FermiDirac(0.0, fixmagmom=True), spinpol=True) e3 = atoms.get_potential_energy() + calc.get_reference_energy() niter3 = calc.get_number_of_iterations() print 'Energy difference %.3f eV' % (e2 - e1) print 'XPS %.3f eV' % (e3 - e1) assert abs(e2 - e1 - 533.349) < 0.001 assert abs(e3 - e1 - 538.844) < 0.001 energy_tolerance = 0.00002 niter_tolerance = 0 equal(e1, -2080.0831386228238, energy_tolerance) equal(niter1, 25, niter_tolerance) equal(e2, -1546.7345330563153, energy_tolerance) equal(niter2, 24, niter_tolerance) equal(e3, -1541.2394024, energy_tolerance) equal(niter3, 20, niter_tolerance)
from ase.calculators.test import numeric_force from gpaw import GPAW, Mixer from gpaw.test import equal a = 4.0 n = 16 atoms = Atoms([Atom('H', [1.234, 2.345, 3.456])], cell=(a, a, a), pbc=True) calc = GPAW(nbands=1, gpts=(n, n, n), txt=None, mixer=Mixer(0.25, 3, 1), convergence={'energy': 1e-7}) atoms.set_calculator(calc) e1 = atoms.get_potential_energy() niter1 = calc.get_number_of_iterations() f1 = atoms.get_forces()[0] for i in range(3): f2i = numeric_force(atoms, 0, i) print f1[i]-f2i equal(f1[i], f2i, 0.00025) energy_tolerance = 0.00006 force_tolerance = 0.0001 niter_tolerance = 0 equal(e1, -0.531042, energy_tolerance) f1_ref = [-0.291893, -0.305174, -0.35329] for i in range(3): equal(f1[i], f1_ref[i], force_tolerance) assert 34 <= niter1 <= 35, niter1
txt=txt) else: name = 'zero_bc' calc = GPAW(h=0.25, nbands=4, mode=mode, eigensolver=eigensolver, txt=txt) Be.set_calculator(calc) Be.get_potential_energy() kss = KSSingles(calc, eps=0.9) # all s->p transitions at the same energy [Ha] and # oscillator_strength for ks in kss: equal(ks.get_energy(), kss[0].get_energy(), 5.e-3) equal(ks.get_oscillator_strength()[0], kss[0].get_oscillator_strength()[0], 5.e-3) equal(ks.get_oscillator_strength()[0], ks.get_oscillator_strength()[1:].sum() / 3, 1.e-15) for c in range(3): equal(ks.get_oscillator_strength()[1 + c], ks.get_dipole_tensor()[c, c], 1.e-15) energy[name] = np.array([ks.get_energy() * Hartree for ks in kss]).mean() osz[name] = np.array([ks.get_oscillator_strength()[0] for ks in kss]).sum() parprint(name + ':') parprint(kss)
calc = prepare({0 : 'paw', 1 : 'ghost'}) system.set_calculator(calc) e_bsse = system.get_potential_energy() niter_bsse = calc.get_number_of_iterations() c_nM = calc.wfs.kpt_u[0].C_nM print('coefs') print(c_nM) print('energy', e_bsse) # Reference system which is just a hydrogen sys0 = system[0:1].copy() calc = prepare('paw') sys0.set_calculator(calc) e0 = sys0.get_potential_energy() niter0 = calc.get_number_of_iterations() print('e0, e_bsse = ', e0, e_bsse) # One coefficient should be very small (0.012), the other very large (0.99) assert abs(1.0 - abs(c_nM[0, 0])) < 0.02 assert abs(c_nM[0, 1]) < 0.02 assert abs(e_bsse - e0) < 2e-3 energy_tolerance = 0.0002 niter_tolerance = 1 equal(e_bsse, 0.0287208853911, energy_tolerance) # svnversion 5252 equal(niter_bsse, 7, niter_tolerance) # svnversion 5252 equal(e0, 0.0299220702846, energy_tolerance) # svnversion 5252 equal(niter0, 6, niter_tolerance) # svnversion 5252
# full information c = GPAW(fwfname, txt=txt) E_PBE = c.get_potential_energy() try: # number of iterations needed in restart niter_PBE = c.get_number_of_iterations() except: pass dE = c.get_xc_difference('TPSS') E_1 = E_PBE + dE print "E PBE, TPSS=", E_PBE, E_1 # no wfs c = GPAW(fname, txt=txt) E_PBE_no_wfs = c.get_potential_energy() try: # number of iterations needed in restart niter_PBE_no_wfs = c.get_number_of_iterations() except: pass dE = c.get_xc_difference('TPSS') E_2 = E_PBE_no_wfs + dE print "E PBE, TPSS=", E_PBE_no_wfs, E_2 print "diff=", E_1 - E_2 assert abs(E_1 - E_2) < 0.005 energy_tolerance = 0.00004 niter_tolerance = 0 equal(E_PBE, -5.33901, energy_tolerance) equal(E_PBE_no_wfs, -5.33901, energy_tolerance) equal(E_1, -5.6435, energy_tolerance) equal(E_2, -5.64352, energy_tolerance)
assert ferr < 0.015, 'forces do not match FD check' # Sanity check. In HGH, the atomic Hamiltonian is constant. # Also the projectors should be normalized for a, dH_sp in dH_asp.items(): dH_p = dH_sp[0] K_p = wfs.setups[a].K_p #B_ii = wfs.setups[a].B_ii #assert np.abs(B_ii.diagonal() - 1).max() < 1e-3 #print 'B_ii' #print wfs.setups[a].B_ii # Actually, H2O might not be such a good test, since there'll only # be one element in the atomic Hamiltonian for O and zero for H. #print 'dH_p', dH_p #print 'K_p', K_p assert np.abs(dH_p - K_p).max() < 1e-10, 'atomic Hamiltonian changed' #h_ii = setup.data.h_ii #print 'h_ii', h_ii #print 'dH_ii', dH_ii # Sanity check: HGH is normconserving for psit_G in psit_nG: norm = gd.integrate(psit_G**2) # Around 1e-15 ! Surprisingly good. assert abs(1 - norm) < 1e-10, 'Not normconserving' energy_tolerance = 0.00002 niter_tolerance = 0 equal(e, eref, energy_tolerance) # svnversion 5252
from ase.build import bulk from gpaw import GPAW, FermiDirac from gpaw.test import equal a = 5.475 calc = GPAW(h=0.24, kpts=(4, 4, 4), poissonsolver={'name': 'fft'}, occupations=FermiDirac(width=0.0), nbands=5) atoms = bulk('Si', 'diamond', a=a) atoms.set_calculator(calc) E = atoms.get_potential_energy() equal(E, -11.8699605591, 0.0002) niter = calc.get_number_of_iterations() equal(atoms.calc.get_fermi_level(), 5.17751284, 0.005) h**o, lumo = calc.get_homo_lumo() equal(lumo - h**o, 1.11445025, 0.002) calc.write('si_primitive.gpw', 'all') calc = GPAW('si_primitive.gpw', parallel={'domain': 1, 'band': 1}, idiotproof=False, txt=None)
from ase import Atoms from gpaw import GPAW from gpaw.test import equal h = 0.2 n = 24 a = n * h b = a / 2 H = Atoms('H', [(b - 0.1, b, b)], pbc=True, cell=(a, a, a)) calc = GPAW(nbands=1, gpts=(n, n, n), txt='ltt.txt') H.set_calculator(calc) e0 = H.get_potential_energy() for i in range(50): e = H.get_potential_energy() H.positions += (0.09123456789, 0.0423456789, 0.03456789) equal(e, e0, 0.0006) print e, e0, e-e0
E = xc.calculate(gd, n, v) here = (gd.beg_c[0] <= 1 < gd.end_c[0] and gd.beg_c[1] <= 2 < gd.end_c[1] and gd.beg_c[2] <= 3 < gd.end_c[2]) if here: x = v[-1, 1, 2, 3] * gd.dv n[-1, 1, 2, 3] += 0.000001 Ep = xc.calculate(gd, n, v) if here: n[-1, 1, 2, 3] -= 0.000002 Em = xc.calculate(gd, n, v) x2 = (Ep - Em) / 0.000002 if here: print(xc.name, E, x, x2, x - x2) equal(x, x2, 1e-11) n[-1, 1, 2, 3] += 0.000001 if 0:#xc.type == 'LDA': xc = XC(NonCollinearLDAKernel()) else: xc = NonCollinearFunctional(xc) n2 = gd.zeros(4) n2[0] = n.sum(0) n2[3] = n[0] - n[1] E2 = xc.calculate(gd, n2) print(E, E2-E) assert abs(E2 - E) < 1e-11 n2[1] = 0.1 * n2[3] n2[2] = 0.2 * n2[3]
from gpaw import GPAW from gpaw.eigensolvers.rmm_diis_old import RMM_DIIS from ase import Atoms from gpaw.test import equal atoms = Atoms("H") atoms.center(3.0) convergence = {"eigenstates": 1e-2, "density": 1e-2} # Keep htpsit calc = GPAW(nbands=2, eigensolver=RMM_DIIS(keep_htpsit=True), convergence=convergence, maxiter=20) atoms.set_calculator(calc) e0 = atoms.get_potential_energy() # Do not keep htpsit calc = GPAW(nbands=2, eigensolver=RMM_DIIS(keep_htpsit=False), convergence=convergence, maxiter=20) atoms.set_calculator(calc) e1 = atoms.get_potential_energy() equal(e0, e1, 1e-12)
print F_ac print print 'Reference result' print F_ac_ref print print 'Error' print err_ac print print 'Max error' print err # ASE uses dx = [+|-] 0.001 by default, # error should be around 2e-3. In fact 4e-3 would probably be acceptable equal(err, 0, 1e-3) # Set boolean to run new FD check fd = False if fd: from ase.calculators.test import numeric_forces calc.set(usesymm=False) F_ac_fd = numeric_forces(system) print 'Self-consistent forces' print F_ac print 'FD' print F_ac_fd print repr(F_ac_fd) print F_ac - F_ac_fd, np.abs(F_ac - F_ac_fd).max()
from __future__ import print_function from ase import Atoms from gpaw import GPAW, restart from gpaw.test import equal from gpaw.utilities.kspot import AllElectronPotential if 1: be = Atoms(symbols='Be',positions=[(0,0,0)]) be.center(vacuum=5) calc = GPAW(gpts=(64,64,64), xc='LDA', nbands=1) #0.1 required for accuracy be.set_calculator(calc) e = be.get_potential_energy() niter = calc.get_number_of_iterations() #calc.write("be.gpw") energy_tolerance = 0.00001 niter_tolerance = 0 equal(e, 0.00246471, energy_tolerance) #be, calc = restart("be.gpw") AllElectronPotential(calc).write_spherical_ks_potentials('bepot.txt') f = open('bepot.txt') lines = f.readlines() f.close() mmax = 0 for l in lines: mmax = max(abs(eval(l.split(' ')[3])), mmax) print("Max error: ", mmax) assert mmax<0.009
H2.get_potential_energy() xc='LDA' # without spin lr = LrTDDFT(calc, xc=xc) lr.diagonalize() t1 = lr[0] # course grids for finegrid in [1,0]: lr = LrTDDFT(calc, xc=xc, finegrid=finegrid) lr.diagonalize() t3 = lr[0] print 'finegrid, t1, t3=', finegrid, t1 ,t3 equal(t1.get_energy(), t3.get_energy(), 5.e-4) # with spin lr_vspin = LrTDDFT(calc, xc=xc, nspins=2) singlet, triplet = lr_vspin.singlets_triplets() lr_vspin.diagonalize() # the triplet is lower, so that the second is the first singlet # excited state t2 = lr_vspin[1] print 'with virtual/wo spin t2, t1=', t2.get_energy(), t1 .get_energy() equal(t1.get_energy(), t2.get_energy(), 5.e-7) if not load: c_spin = GPAW(xc='PBE', nbands=2,
from math import exp, pi, sqrt import numpy as np from gpaw.gauss import Gauss from gpaw.test import equal from gpaw.utilities.folder import Folder, Lorentz, Voigt # noqa # Gauss and Lorentz functions width = 0.5 x = 1.5 equal(Gauss(width).get(x), exp(- x**2 / 2 / width**2) / sqrt(2 * pi) / width, 1.e-15) equal(Gauss(width).fwhm, width * np.sqrt(8 * np.log(2)), 1.e-15) equal(Lorentz(width).get(x), width / (x**2 + width**2) / pi, 1.e-15) equal(Lorentz(width).fwhm, width * 2, 1.e-15) # folder function for func in [Gauss, Lorentz, Voigt]: folder = Folder(width, func(width).__class__.__name__) x = [0, 2] y = [[2, 0, 1], [1, 1, 1]] xl, yl = folder.fold(x, y, dx=.7)
'energy': 1e-5, 'density': 1e-5 }) # Calculate potential energy per atom for orthogonal unitcell atoms = hcp0001('C', a=a / sqrt(3), vacuum=d, size=(3, 2, 1), orthogonal=True) del atoms[[1, -1]] atoms.center(axis=0) atoms.set_calculator(calc) kpts_c = np.ceil(50 / np.sum(atoms.get_cell()**2, axis=1)**0.5).astype(int) kpts_c[~atoms.get_pbc()] = 1 calc.set(kpts=kpts_c) eppa1 = atoms.get_potential_energy() / len(atoms) F1_av = atoms.get_forces() equal(np.abs(F1_av).max(), 0, 5e-3) # Redo calculation with non-orthogonal unitcell atoms = Atoms(symbols='C2', pbc=(True, True, False), positions=[(a / 2, -sqrt(3) / 6 * a, d), (a / 2, sqrt(3) / 6 * a, d)], cell=[(a / 2, -sqrt(3) / 2 * a, 0), (a / 2, sqrt(3) / 2 * a, 0), (0, 0, 2 * d)]) atoms.set_calculator(calc) kpts_c = np.ceil(50 / np.sum(atoms.get_cell()**2, axis=1)**0.5).astype(int) kpts_c[~atoms.get_pbc()] = 1 calc.set(kpts=kpts_c) eppa2 = atoms.get_potential_energy() / len(atoms) F2_av = atoms.get_forces()
EHOMO = {'Be': -0.309 + 0.008, 'Ne': -0.851 + 0.098, 'Mg': -0.253 + 0.006} eignum = {'Be': 0, 'Ne': 3, 'Mg': 0} for xcname in ['GLLB', 'GLLBSC']: atoms = ['Be', 'Ne', 'Mg'] for atom in atoms: # Test AllElectron GLLB GLLB = AllElectron(atom, xcname=xcname, scalarrel=False, gpernode=600) GLLB.run() out("Total energy", xcname + "1D", atom, ETotal[atom], GLLB.ETotal, "Ha") out("Exchange energy", xcname + "1D", atom, EX[atom], GLLB.Exc, "Ha") out("H**O Eigenvalue", xcname + "1D", atom, EHOMO[atom], GLLB.e_j[-1], "Ha") if xcname == 'GLLB': equal(GLLB.ETotal, ETotal[atom], tolerance=1e-2) equal(GLLB.Exc, EX[atom], tolerance=1e-2) equal(GLLB.e_j[-1], EHOMO[atom], tolerance=1e-2) print( " Quanity Method Symbol Ref[1] GPAW Unit " ) for a, b, c, d, e, f in data: print("%20s %10s %10s %10.3f %10.3f %5s" % (a, b, c, d, e, f)) print("""References: [1] Self-consistent approximation to the Kohn-Sham exchange potential Gritsenko, Oleg; Leeuwen, Robert van; Lenthe, Erik van; Baerends, Evert Jan Phys. Rev. A Vol. 51 p. 1944""")
nbands=nbands, occupations=ZeroKelvin(True), convergence=convergence, txt=txt) H2.set_calculator(c) E_zk = H2.get_potential_energy() c = GPAW(h=h, nbands=nbands, occupations=FixedOccupations([[2, 0]]), convergence=convergence, txt=txt) H2.set_calculator(c) E_fo = H2.get_potential_energy() parprint(E_zk, E_fo) equal(E_zk, E_fo, 1.e-10) if 1: # test spin-paired vs spin-polarized c = GPAW(h=h, nbands=nbands, occupations=FixedOccupations([[1, 1]]), convergence=convergence, txt=txt) H2.set_calculator(c) E_ns = H2.get_potential_energy() if 1: c = GPAW(h=h, nbands=nbands, spinpol=True, occupations=FixedOccupations([[0.5, 0.5]] * 2),
frequencies=np.linspace(0, 14, 141), hilbert=not True, eta=0.1, ecut=10, truncation='wigner-seitz') a0_ws, a_ws = df_ws.get_polarizability(filename=None, direction='z') w0_ = 5.60491055 I0_ = 244.693028 w_ = 5.696528390 I_ = 207.8 w, I = findpeak(np.linspace(0, 14., 141), b0.imag) equal(w, w0_, 0.05) equal(6**3 * I / (4 * np.pi), I0_, 0.5) w, I = findpeak(np.linspace(0, 14., 141), a0.imag) equal(w, w0_, 0.05) equal(I, I0_, 0.5) w, I = findpeak(np.linspace(0, 14., 141), a0_ws.imag) equal(w, w0_, 0.05) equal(I, I0_, 0.5) w, I = findpeak(np.linspace(0, 14., 141), b.imag) equal(w, w_, 0.05) equal(6**3 * I / (4 * np.pi), I_, 0.5) w, I = findpeak(np.linspace(0, 14., 141), a.imag) equal(w, w_, 0.05) equal(I, I_, 0.5) # The Wigner-Seitz truncation does not give exactly the same for small cell w, I = findpeak(np.linspace(0, 14., 141), a_ws.imag)
[30.0, 25.0, 14.9]])) # Wrap calculators qsfdtd = QSFDTD(classical_material=classical_material, atoms=None, cells=(cell, 2.00), spacings=[1.60, 0.40], remove_moments=(1, 1)) # Run energy = qsfdtd.ground_state('gs.gpw', eigensolver='cg', nbands=-1) qsfdtd.time_propagation('gs.gpw', kick_strength=[0.000, 0.000, 0.001], time_step=10, iterations=5, dipole_moment_file='dmCl.dat') # Restart and run qsfdtd.write('td.gpw', mode='all') qsfdtd.time_propagation('td.gpw', kick_strength=None, time_step=10, iterations=5, dipole_moment_file='dmCl.dat') # Test ref_cl_dipole_moment = [-1.01218549e-04, -3.03603883e-05, 1.86063875e-01] tol = 1e-6 equal(qsfdtd.td_calc.hamiltonian.poisson.get_classical_dipole_moment(), ref_cl_dipole_moment, tol)
m_xg[x] += eps d_xg[x] = 0.5 * f1(m_xg, xc)[0] / eps m_xg[x] -= 2 * eps d_xg[x] -= 0.5 * f1(m_xg, xc)[0] / eps ns_xg = np.empty((7, len(n_g))) ns_xg[:2] = n_xg[0] / 2 ns_xg[2:5] = n_xg[1] / 4 ns_xg[5:] = n_xg[2] / 2 es_g, ds_xg = f2(ns_xg, xc) error = (abs(d0_xg-d_xg).max() + abs(es_g - e0_g).max() + abs(ds_xg[:2] - d0_xg[0]).max() + abs(ds_xg[2:5].sum(0) / 4 - d0_xg[1]).max() + abs(ds_xg[5:] - d0_xg[2]).max()) #print xc.name, error equal(error, 0, 6e-9) del xc # Numbers from old lxc_xc.py test: na = 2.0 nb = 1.0 sigma0 = 2.0 # (0.0, 1.0, 1.0) sigma1 = 2.0 sigma2 = 5.0 # (1.0, 2.0, 0.0) taua=(3.*np.pi**2)**(2./3.)*na**(5./3.)/2.*sigma0 taub=(3.*np.pi**2)**(2./3.)*nb**(5./3.)/2.*sigma2 n_xg = np.array( [[na, nb, sigma0, sigma1, sigma2, taua, taub], [0.1, 0.1, 0.025, 0.025, 0.025, 0.25, 0.25], [0.1, 0.1, 0.125, 0.125, 0.125, 0.0025, 0.025],
kpts={ 'size': (2, 2, 2), 'gamma': True }, xc='LDA', eigensolver='rmm-diis', occupations=FermiDirac(0.001)) atoms.set_calculator(calc) e0 = atoms.get_potential_energy() calc.diagonalize_full_hamiltonian(scalapack=True) calc.write('BN_bulk_k2_ecut400_allbands.gpw', mode='all') gw = G0W0('BN_bulk_k2_ecut400_allbands.gpw', bands=(3, 5), nbands=9, nblocks=1, method='GW0', maxiter=5, ecut=40) result = gw.calculate() gaps = [3.256, 4.746, 4.937, 4.952, 4.948, 4.946] for i in range(result['iqp'].shape[0]): equal( np.min(result['iqp'][i, 0, :, 1]) - np.max(result['iqp'][i, 0, :, 0]), gaps[i], 0.03)
for mode in ['fd', 'pw']: print(mode) hydrogen = Atoms('H', cell=(2.5, 3, 3.5), pbc=1, calculator=GPAW(txt=None, mode=mode)) hydrogen.get_potential_energy() dens = hydrogen.calc.density ham = hydrogen.calc.hamiltonian ham.poisson.eps = 1e-20 dens.interpolate_pseudo_density() dens.calculate_pseudo_charge() ham.update(dens) ham.get_energy(hydrogen.calc.occupations) y = (ham.vt_sG[0, 0, 0, 0] - ham.vt_sG[0, 0, 0, 1]) * ham.gd.dv x = 0.0001 dens.nt_sG[0, 0, 0, 0] += x dens.nt_sG[0, 0, 0, 1] -= x dens.interpolate_pseudo_density() dens.calculate_pseudo_charge() ham.update(dens) e1 = ham.get_energy(hydrogen.calc.occupations) - ham.Ekin dens.nt_sG[0, 0, 0, 0] -= 2 * x dens.nt_sG[0, 0, 0, 1] += 2 * x dens.interpolate_pseudo_density() dens.calculate_pseudo_charge() ham.update(dens) e2 = ham.get_energy(hydrogen.calc.occupations) - ham.Ekin equal(y, (e1 - e2) / (2 * x), 2e-8)
# Sanity check. In HGH, the atomic Hamiltonian is constant. # Also the projectors should be normalized for a, dH_sp in dH_asp.items(): dH_p = dH_sp[0] K_p = wfs.setups[a].K_p #B_ii = wfs.setups[a].B_ii #assert np.abs(B_ii.diagonal() - 1).max() < 1e-3 #print 'B_ii' #print wfs.setups[a].B_ii # Actually, H2O might not be such a good test, since there'll only # be one element in the atomic Hamiltonian for O and zero for H. #print 'dH_p', dH_p #print 'K_p', K_p assert np.abs(dH_p - K_p).max() < 1e-10, 'atomic Hamiltonian changed' #h_ii = setup.data.h_ii #print 'h_ii', h_ii #print 'dH_ii', dH_ii # Sanity check: HGH is normconserving for psit_G in psit_nG: norm = gd.integrate(psit_G**2) # Around 1e-15 ! Surprisingly good. assert abs(1 - norm) < 1e-10, 'Not normconserving' energy_tolerance = 0.000001 niter_tolerance = 0 equal(e, eref, energy_tolerance) # svnversion 5252 equal(niter, 31, niter_tolerance) # svnversion 5252
xc = XC(name) for nspins in [1, 2]: n = rgd.zeros(nspins) v = rgd.zeros(nspins) n[:] = np.exp(-rgd.r_g**2) n[-1] *= 2 E = xc.calculate_spherical(rgd, n, v) i = 23 x = v[-1, i] * rgd.dv_g[i] n[-1, i] += 0.000001 Ep = xc.calculate_spherical(rgd, n, v) n[-1, i] -= 0.000002 Em = xc.calculate_spherical(rgd, n, v) x2 = (Ep - Em) / 0.000002 print(name, nspins, E, x, x2, x - x2) equal(x, x2, 1e-9) n[-1, i] += 0.000001 if nspins == 1: ns = rgd.empty(2) ns[:] = n / 2 Es = xc.calculate_spherical(rgd, ns, 0 * ns) equal(E, Es, 1e-13) N = 20 a = 1.0 gd = GridDescriptor((N, N, N), (a, a, a)) for name in ['LDA', 'PBE']: xc = XC(name) for nspins in [1, 2]:
calc.write(fname) # Check that a / h = 10 is rounded up to 12 as always: assert (calc.wfs.gd.N_c == (12, 12, 16)).all() ############ AngularIntegral gd = calc.density.gd ai = AngularIntegral(H2.positions.mean(0), calc.wfs.gd, Rmax=1.5) unity_g = gd.zeros() + 1. average_R = ai.average(unity_g) integral_R = ai.integrate(unity_g) for V, average, integral, R, Rm in zip(ai.V_R, average_R, integral_R, ai.radii(), ai.radii('mean')): if V > 0: equal(average, 1, 1.e-9) equal(integral / (4 * pi * Rm**2), 1, 0.61) equal(Rm / R, 1, 0.61) ############ ExpandYl yl = ExpandYl(H2.positions.mean(0), calc.wfs.gd, Rmax=1.5) def max_index(l): mi = 0 limax = l[0] for i, li in enumerate(l): if limax < li: limax = li mi = i
h=.4 q=3 spin=True s = Atoms([Atom('Fe')]) s.center(vacuum=2.5) convergence={'eigenstates':0.01, 'density':0.1, 'energy':0.1} # use Hunds rules c = GPAW(charge=q, h=h, nbands=5, hund=True, eigensolver='rmm-diis', occupations=FermiDirac(width=0.1), convergence=convergence ) c.calculate(s) equal(c.get_magnetic_moment(0), 5, 0.1) # set magnetic moment mm = [5] s.set_initial_magnetic_moments(mm) c = GPAW(charge=q, h=h, nbands=5, occupations=FermiDirac(width=0.1, fixmagmom=True), convergence=convergence ) c.calculate(s) equal(c.get_magnetic_moment(0), 5, 0.1)
Atom('H', (x, -x, -x)), Atom('H', (-x, x, -x)) ], cell=(a, a, a), pbc=False) atoms.positions[:] += a / 2 calc = GPAW(h=0.25, nbands=4, convergence={'eigenstates': 7.8e-10}) atoms.calc = calc energy = atoms.get_potential_energy() niter = calc.get_number_of_iterations() # The three eigenvalues e[1], e[2], and e[3] must be degenerate: e = calc.get_eigenvalues() print(e[1] - e[3]) equal(e[1], e[3], 9.3e-8) energy_tolerance = 0.0003 niter_tolerance = 0 equal(energy, -23.6277, energy_tolerance) # Calculate non-selfconsistent PBE eigenvalues: from gpaw.xc.tools import vxc epbe0 = e - vxc(calc)[0, 0] + vxc(calc, 'PBE')[0, 0] # Calculate selfconsistent PBE eigenvalues: calc.set(xc='PBE') energy = atoms.get_potential_energy() epbe = calc.get_eigenvalues()
b[:] = np.zeros(b.shape) op = Laplace(gd, 1.0, 3) if offload_enabled: offl_a = device.bind(a) offl_b = device.bind(b) print "--------------------------------------------------------------" print "Starting relaxation step" relax_start = time.time() if offload_enabled: op.relax(2, offl_b.array, offl_a.array, 4, 2.0 / 3.0) else: op.relax(2, b, a, 4, 2.0 / 3.0) relax_end = time.time() print "--------------------------------------------------------------" print "time needed: " + str(relax_end-relax_start) s = np.sum(b) # print "Checksum: {0}".format(s) if gpts == 64: equal(s, -10.4429888082, 1e-5) if gpts == 128: equal(s, -20.9047491129, 1e-5) #if __name__ == '__main__': # print timeit.repeat('op.relax(2, b, a, 4, 2.0 / 3.0)', setup='from __main__ import op, a, b', number=100, repeat=5)
LiH.set_calculator(calc) e_LiH = LiH.get_potential_energy() niter_LiH = calc.get_number_of_iterations() energies, Li_orbitalweight = raw_orbital_LDOS(calc, a=0, spin=0, angular=None) energies, H_orbitalweight = raw_orbital_LDOS(calc, a=1, spin=0, angular=None) energies, Li_wzweight = raw_wignerseitz_LDOS(calc, a=0, spin=0) energies, H_wzweight = raw_wignerseitz_LDOS(calc, a=1, spin=0) n_a = calc.get_wigner_seitz_densities(spin=0) print sweight, pdfweight print sweight_spin print Li_wzweight print H_wzweight print n_a equal(sweight[0], 1., .06) equal(pdfweight[0], 0., .0001) equal(sweight_spin[0], 1.14, .06) assert ((Li_wzweight - [.13, .93]).round(2) == 0).all() assert ((H_wzweight - [.87, .07]).round(2) == 0).all() assert ((Li_wzweight + H_wzweight).round(5) == 1).all() equal(n_a.sum(), 0., 1e-5) equal(n_a[1], .737, .001) print Li_orbitalweight print H_orbitalweight # H**O s py pz px *s Li_orbitalweight[0] -= [.5, .0, .6, .0, .0] H_orbitalweight[0] -= [.7, .0, .0, .0, .0] # LUMO s py pz px *s
from __future__ import print_function from ase import Atom, Atoms from gpaw import GPAW from gpaw.test import equal a = 4.05 d = a / 2 ** 0.5 bulk = Atoms([Atom("Al", (0, 0, 0)), Atom("Al", (0, 0, d))], cell=(4 * d, 4 * d, 2 * d), pbc=1) n = 16 calc = GPAW(gpts=(2 * n, 2 * n, 1 * n), nbands=1 * 8, kpts=(1, 1, 4), convergence={"eigenstates": 2.3e-9}, xc="LDA") bulk.set_calculator(calc) e2 = bulk.get_potential_energy() niter2 = calc.get_number_of_iterations() bulk = bulk.repeat((1, 1, 2)) bulk.set_calculator(calc) calc.set(nbands=16, kpts=(1, 1, 2), gpts=(2 * n, 2 * n, 2 * n)) e4 = bulk.get_potential_energy() niter4 = calc.get_number_of_iterations() # checks energy_tolerance = 0.00007 niter_tolerance = 0 print(e2, e4) equal(e4 / 2, e2, 48e-6) equal(e2, -3.41595, energy_tolerance) equal(e4, -6.83191, energy_tolerance)
calc.write('N2.gpw', mode='all') ralda = FXCCorrelation('N2.gpw', xc='rALDA') Ec_N2 = ralda.calculate(ecut=[50]) # N N = Atoms('N', [(0, 0, 0)]) N.set_cell((2.5, 2.5, 3.5)) N.center() calc = GPAW(mode=PW(force_complex_dtype=True), eigensolver='rmm-diis', xc='LDA', basis='dzp', nbands=8, hund=True, convergence={'density': 1.e-6}) N.set_calculator(calc) N.get_potential_energy() calc.diagonalize_full_hamiltonian(nbands=80, scalapack=scalapack2) calc.write('N.gpw', mode='all') ralda = FXCCorrelation('N.gpw', xc='rALDA') Ec_N = ralda.calculate(ecut=[50]) equal( Ec_N2, -6.1651, 0.001, ) equal(Ec_N, -1.1085, 0.001)
from gpaw.xc.fxc_correlation_energy import FXCCorrelation import numpy as np a0 = 5.43 Ni = bulk('Ni', 'fcc') Ni.set_initial_magnetic_moments([0.7]) kpts = monkhorst_pack((3,3,3)) calc = GPAW(mode='pw', kpts=kpts, occupations=FermiDirac(0.001), setups={'Ni': '10'}, communicator=serial_comm) Ni.set_calculator(calc) E = Ni.get_potential_energy() calc.diagonalize_full_hamiltonian(nbands=50) rpa = RPACorrelation(calc) E_rpa = rpa.get_rpa_correlation_energy(ecut=50, skip_gamma=True, gauss_legendre=8) fxc = FXCCorrelation(calc, xc='RPA') E_fxc = fxc.get_fxc_correlation_energy(ecut=50, skip_gamma=True, gauss_legendre=8) equal(E_rpa, -7.826, 0.01) equal(E_fxc, -7.827, 0.01)
bulk.set_cell((d, d, a), scale_atoms=True) h = 0.25 calc = GPAW(h=h, nbands=2 * 8, kpts=(2, 2, 2), convergence={ 'eigenstates': 7.2e-9, 'energy': 1e-5 }) bulk.set_calculator(calc) e0 = bulk.get_potential_energy() niter0 = calc.get_number_of_iterations() calc = GPAW(h=h, nbands=2 * 8, kpts=(2, 2, 2), convergence={ 'eigenstates': 7.2e-9, 'energy': 1e-5, 'bands': 5 }, eigensolver='dav') bulk.set_calculator(calc) e1 = bulk.get_potential_energy() niter1 = calc.get_number_of_iterations() equal(e0, e1, 5.0e-5) energy_tolerance = 0.00004 niter_tolerance = 0 equal(e0, -6.97626, energy_tolerance) equal(e1, -6.976265, energy_tolerance)
#!/usr/bin/env python from ase import Atoms from gpaw import GPAW, restart from gpaw.test import equal from gpaw.utilities.kspot import CoreEigenvalues a = 7.0 calc = GPAW(h=0.1) system = Atoms('Ne', calculator=calc) system.center(vacuum=a / 2) e0 = system.get_potential_energy() niter0 = calc.get_number_of_iterations() calc.write('Ne.gpw') del calc, system atoms, calc = restart('Ne.gpw') calc.restore_state() e_j = CoreEigenvalues(calc).get_core_eigenvalues(0) assert abs(e_j[0] - (-30.344066)) * 27.21 < 0.1 # Error smaller than 0.1 eV energy_tolerance = 0.0004 equal(e0, -0.0107707223, energy_tolerance)
E = lr[n].get_energy() * Hartree osz = lr[n].get_oscillator_strength() print('Original object :', E, osz[0]) # Test the output of analyse origstdout = sys.stdout sys.stdout = sio = StringIO() lr.analyse(n) s = sio.getvalue() sys.stdout = origstdout match = re.findall(r'%i: E=([0-9]*\.[0-9]*) eV, f=([0-9]*\.[0-9]*)*' % n, s) Eanalyse = float(match[0][0]) oszanalyse = float(match[0][1]) print('From analyse :', Eanalyse, oszanalyse) equal(E, Eanalyse, 1e-3) # Written precision in analyse equal(osz[0], oszanalyse, 1e-3) E2 = lr2[n].get_energy() * Hartree osz2 = lr2[n].get_oscillator_strength() print('Written and read object:', E2, osz2[0]) # Compare values of original and written/read objects equal(E, E2, 1e-4) for i in range(len(osz)): equal(osz[i], osz2[i], 1.7e-4) width = 0.05 photoabsorption_spectrum(lr, spectrum_file='lrtddft3-spectrum.dat', width=width)
E = lr[n].get_energy() * Hartree osz = lr[n].get_oscillator_strength() print 'Original object :', E, osz[0] # Test the output of analyse origstdout = sys.stdout sys.stdout = sio = StringIO() lr.analyse(n) s = sio.getvalue() sys.stdout = origstdout match = re.findall(r'%i: E=([0-9]*\.[0-9]*) eV, f=([0-9]*\.[0-9]*)*' % n, s) Eanalyse = float(match[0][0]) oszanalyse = float(match[0][1]) print 'From analyse :', Eanalyse, oszanalyse equal(E, Eanalyse, 1e-3) # Written precision in analyse equal(osz[0], oszanalyse, 1e-3) E2 = lr2[n].get_energy() * Hartree osz2 = lr2[n].get_oscillator_strength() print 'Written and read object:', E2, osz2[0] # Compare values of original and written/read objects equal(E, E2, 1e-4) for i in range(len(osz)): equal(osz[i], osz2[i], 1.7e-4) width = 0.05 photoabsorption_spectrum(lr, spectrum_file = 'lrtddft3-spectrum.dat', width = width)
h2 = Atoms('H2', [[0, 0, 0], [0, 0, d]]) h2.center(vacuum=2) h2.calc = GPAW(txt='H2-' + xc + '.txt', convergence=c) h2.get_potential_energy() h2.calc.set(xc=xc) h2.get_potential_energy() h2.get_forces() ens = BEEFEnsemble(h2.calc) e_h2 = ens.get_ensemble_energies() # H atom: h = Atoms('H', cell=h2.cell, magmoms=[1]) h.center() h.calc = GPAW(txt='H-' + xc + '.txt', convergence=c) h.get_potential_energy() h.calc.set(xc=xc) h.get_potential_energy() ens = BEEFEnsemble(h.calc) e_h = ens.get_ensemble_energies() # binding energy ae = 2 * e_h - e_h2 print(ae.mean(), ae.std()) equal(ae.mean(), E0, 0.015) equal(ae.std(), dE0, 0.015) ens.write('H') world.barrier() energies = readbee('H') equal(abs(energies - e_h).max(), 0, 1e-12)
## with fractional translations calc = GPAW(mode=PW(), xc='LDA', kpts=(3, 3, 3), nbands=42, symmetry={'symmorphic': False}, gpts=(20, 20, 24), eigensolver='rmm-diis') atoms.set_calculator(calc) energy_fractrans = atoms.get_potential_energy() assert(len(calc.wfs.kd.ibzk_kc) == 7) assert(len(calc.wfs.kd.symmetry.op_scc) == 6) ## without fractional translations calc = GPAW(mode=PW(), xc='LDA', kpts=(3, 3, 3), nbands=42, gpts=(20, 20, 24), eigensolver='rmm-diis') atoms.set_calculator(calc) energy_no_fractrans = atoms.get_potential_energy() assert(len(calc.wfs.kd.ibzk_kc) == 10) assert(len(calc.wfs.kd.symmetry.op_scc) == 2) equal(energy_fractrans, energy_no_fractrans, 1e-3)
# 1 potential if True: if txt: print('################## 1 potential') cp1 = ConstantPotential(-1.0 / Hartree) c1 = GPAW(h=0.3, nbands=-2, external=cp1, convergence=convergence, txt=txt) c1.calculate(H2) for i in range(c00.get_number_of_bands()): f00 = c00.get_occupation_numbers()[i] if f00 > 0.01: e00 = c00.get_eigenvalues()[i] e1 = c1.get_eigenvalues()[i] print('Eigenvalues no pot, expected, error=', e00, e1 + 1, e00 - e1 - 1) equal(e00, e1 + 1., 0.007) E_c00 = c00.get_potential_energy() niter_c00 = c00.get_number_of_iterations() E_c1 = c1.get_potential_energy() niter_c1 = c1.get_number_of_iterations() DeltaE = E_c00 - E_c1 print('Energy diff, expected, error=', DeltaE, nelectrons, DeltaE - nelectrons) equal(DeltaE, nelectrons, 0.002) energy_tolerance = 0.00001 niter_tolerance = 0 #equal(E_c00, 10.4409370467, energy_tolerance) # svnversion 5252 #equal(niter_c00, 14, niter_tolerance) # svnversion 5252