def eggbox(self): atom = Atoms(self.symbol, pbc=True, cell=(self.a, self.a, self.a)) negg = 25 self.Eegg = np.zeros((self.ng, negg)) self.Fegg = np.zeros((self.ng, negg)) eigensolver = 'rmm-diis' if self.symbol in ['Ti', 'Sn', 'Te', 'Ba']: eigensolver = 'cg' for i in range(self.ng): h = self.gridspacings[i] calc = GPAW(h=h, txt='%s-eggbox-%.3f.txt' % (self.symbol, h), mixer=Mixer(beta=0.1, nmaxold=5, weight=50), eigensolver=eigensolver, maxiter=300, nbands=-10, **self.parameters) atom.set_calculator(calc) for j in range(negg): x = h * j / (2 * negg - 2) atom[0].x = x try: e = calc.get_potential_energy(atom, force_consistent=True) self.Eegg[i, j] = e except ConvergenceError: raise self.Fegg[i, j] = atom.get_forces()[0, 0]
def calculate_isolate_molecular_levels(self, tp): atoms = self.isolate_atoms atoms.pbc = True p = tp.gpw_kwargs.copy() p['nbands'] = None if 'mixer' in p: if not tp.spinpol: p['mixer'] = Mixer(0.1, 5, weight=100.0) else: p['mixer'] = MixerDif(0.1, 5, weight=100.0) p['poissonsolver'] = PoissonSolver(nn=2) if type(p['basis']) is dict and len(p['basis']) == len(tp.atoms): p['basis'] = 'dzp' raise Warning('the dict basis is not surpported in isolate atoms') if 'txt' in p and p['txt'] != '-': p['txt'] = 'isolate_' + p['txt'] atoms.set_calculator(GPAW(**p)) atoms.get_potential_energy() setups = atoms.calc.wfs.setups self.project_basis_in_molecule = get_atom_indices( self.project_atoms_in_molecule, setups) kpt = atoms.calc.wfs.kpt_u[0] s_mm = atoms.calc.wfs.S_qMM[0] c_nm = eig_states_norm(kpt.C_nM, s_mm) self.isolate_eigen_values = kpt.eps_n self.isolate_eigen_vectors = c_nm self.isolate_s_mm = s_mm
def makeGPAWcalc(): from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac, setup_paths if p['psp'] == 'oldpaw': setup_paths.insert( 0, '/scratch/users/ksb/gpaw/oldpaw/gpaw-setups-0.6.6300/') psp = 'paw' else: psp = p['psp'] return GPAW( mode=PW(p['pw']), xc=p['xc'], kpts=json.loads(p['kpts']), spinpol=p['spinpol'], convergence={'energy': p['econv']} #eV/electron , mixer=((MixerSum(beta=p['mixing'], nmaxold=p['nmix'], weight=100)) if p['spinpol'] else (Mixer(beta=p['mixing'], nmaxold=p['nmix'], weight=100))), maxiter=p['maxstep'], nbands=p['nbands'], occupations=FermiDirac(p['sigma']), setups=psp, eigensolver=Davidson(5), poissonsolver=None, txt='log', symmetry={'do_not_symmetrize_the_density': True})
def gpawRestart(calc): from gpaw import restart, PW, Davidson, Mixer, MixerSum, FermiDirac return restart( 'preCalc_inp.gpw', mode=PW(calc.pw), xc=calc.xc, kpts={ 'density': calc.kpt, 'gamma': True } if isinstance(calc.kpt, int) else calc.kpt, spinpol=calc.magmom > 0, convergence={'energy': calc.eConv} #eV/electron , mixer=((MixerSum(beta=calc.mixing, nmaxold=calc.nmix, weight=100)) if calc.magmom > 0 else (Mixer(beta=calc.mixing, nmaxold=calc.nmix, weight=100))), maxiter=calc.maxsteps, nbands=-1 * calc.nbands, occupations=FermiDirac(calc.sigma), setups='sg15' #(pspDict[calc.psp]).pthFunc[cluster] , eigensolver=Davidson(5), poissonsolver= None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None , txt=str(calc) + '.txt', symmetry={'do_not_symmetrize_the_density': True} #ERROR IN LI bcc 111 surface )
def gpawRestart(self): from gpaw import restart, PW, Davidson, Mixer, MixerSum, FermiDirac spinpol = any([x > 0 for x in self.magmomsinit()]) return restart( 'preCalc_inp.gpw', mode=PW(self.pw), xc=self.xc, kpts=self.kpt(), spinpol=spinpol, convergence={'energy': self.econv()} #eV/electron , mixer=( (MixerSum(beta=self.mixing(), nmaxold=self.nmix(), weight=100)) if spinpol else (Mixer(beta=self.mixing(), nmaxold=self.nmix(), weight=100))), maxiter=self.maxstep(), nbands=self.nbands(), occupations=FermiDirac(self.sigma()), setups=self.psp #(pspDict[calc.psp]).pthFunc[cluster] , eigensolver=Davidson(5), poissonsolver= None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None , txt='%d_%s.txt' % (self.pw, self.xc), symmetry={'do_not_symmetrize_the_density': True}) #ERROR IN LI bcc 111 surface
def gpawCalc(calc, restart=False, surf=False): """ Accepts a job (either Surface or Bulk) and returns a Calculator """ from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac return GPAW( mode=PW(calc.pw) #eV , xc=calc.xc, kpts={ 'density': calc.kpt, 'gamma': True } if isinstance(calc.kpt, int) else calc.kpt, spinpol=calc.magmom > 0, convergence={'energy': calc.eConv} #eV/electron , mixer=((MixerSum(beta=calc.mixing, nmaxold=calc.nmix, weight=100)) if calc.magmom > 0 else (Mixer(beta=calc.mixing, nmaxold=calc.nmix, weight=100))), maxiter=calc.maxsteps, nbands=-1 * calc.nbands, occupations=FermiDirac(calc.sigma), setups='sg15', eigensolver=Davidson(5), poissonsolver= None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None , txt=str(calc) + '.txt', symmetry={'do_not_symmetrize_the_density': True} #ERROR IN LI bcc 111 surface )
def PBEcalc(self): from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac return GPAW( mode=PW(self.pw()) #eV , xc='PBE', kpts=self.kpt(), spinpol=self.spinpol(), convergence={'energy': self.econv()} #eV/electron , mixer=( (MixerSum(beta=self.mixing(), nmaxold=self.nmix(), weight=100)) if self.spinpol() else (Mixer(beta=self.mixing(), nmaxold=self.nmix(), weight=100))), maxiter=self.maxstep(), nbands=self.nbands(), occupations=FermiDirac(self.sigma()), setups=self.psp(), eigensolver=Davidson(5), poissonsolver= None # {'dipolelayer': 'xy'} if isinstance(self,SurfaceJob) else None , txt='%d_%s.txt' % (self.pw(), self.xc()), symmetry={'do_not_symmetrize_the_density': True}) #ERROR IN LI bcc 111 surface
def eggbox(self, fd, setup='de'): energies = [] for h in [0.16, 0.18, 0.2]: a0 = 16 * h atoms = Atoms(self.symbol, cell=(a0, a0, 2 * a0), pbc=True) if 58 <= self.Z <= 70 or 90 <= self.Z <= 102: M = 999 mixer = {'mixer': Mixer(0.01, 5)} else: M = 333 mixer = {} atoms.calc = GPAW(h=h, xc='PBE', symmetry='off', setups=self.setup, maxiter=M, txt=fd, **mixer) atoms.positions += h / 2 # start with broken symmetry e0 = atoms.get_potential_energy() atoms.positions -= h / 6 e1 = atoms.get_potential_energy() atoms.positions -= h / 6 e2 = atoms.get_potential_energy() atoms.positions -= h / 6 e3 = atoms.get_potential_energy() energies.append(np.ptp([e0, e1, e2, e3])) # print(energies) return energies
def convergence(self, n, fd): a = 3.0 atoms = Atoms(self.symbol, cell=(a, a, a), pbc=True) M = 333 if 58 <= self.Z <= 70 or 90 <= self.Z <= 102: M = 999 mixer = {'mixer': Mixer(0.01, 5)} else: mixer = {} atoms.calc = GPAW(mode=PW(1500), xc='PBE', setups='ga' + str(n), symmetry='off', maxiter=M, txt=fd, **mixer) e0 = atoms.get_potential_energy() de0 = 0.0 for ec in range(800, 200, -100): atoms.calc.set(mode=PW(ec)) atoms.calc.set(eigensolver='rmm-diis') de = abs(atoms.get_potential_energy() - e0) if de > 0.1: ec0 = ec + (de - 0.1) / (de - de0) * 100 return ec0 de0 = de return 250
def eggbox(self, n, fd): h = 0.18 a0 = 16 * h atoms = Atoms(self.symbol, cell=(a0, a0, 2 * a0), pbc=True) M = 333 if 58 <= self.Z <= 70 or 90 <= self.Z <= 102: M = 999 mixer = {'mixer': Mixer(0.01, 5)} else: mixer = {} atoms.calc = GPAW(h=h, xc='PBE', symmetry='off', setups='ga' + str(n), maxiter=M, txt=fd, **mixer) atoms.positions += h / 2 # start with broken symmetry e0 = atoms.get_potential_energy() atoms.positions -= h / 6 e1 = atoms.get_potential_energy() atoms.positions -= h / 6 e2 = atoms.get_potential_energy() atoms.positions -= h / 6 e3 = atoms.get_potential_energy() return np.ptp([e0, e1, e2, e3])
def test(): vdw = VDWFunctional('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=dict(name='revPBE', stencil=1), mixer=Mixer(0.8, 7, 50.0), eigensolver=Davidson(5)) dimer.set_calculator(calc) e2 = dimer.get_potential_energy() 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() 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 dimer(self): dimer = Atoms([self.symbol, self.symbol], pbc=True, cell=(self.a, self.a, self.a)) self.Edimer = np.zeros((self.ng, 7)) self.Fdimer = np.zeros((self.ng, 7, 2)) q0 = self.d0 / np.sqrt(3) eigensolver = 'rmm-diis' if self.symbol in ['Ti', 'Sn', 'Te', 'Ba']: eigensolver = 'cg' for i in range(self.ng): h = self.gridspacings[i] calc = GPAW( h=h, txt='%s-dimer-%.3f.txt' % (self.symbol, h), mixer=Mixer(beta=0.1, nmaxold=5, weight=50), #mixer=Mixer(beta=0.05, nmaxold=7, weight=100), eigensolver=eigensolver, maxiter=300, nbands=-10, **self.parameters) dimer.set_calculator(calc) y = [] for j in range(-3, 4): q = q0 * (1 + j * 0.02) dimer.positions[1] = (q, q, q) try: e = calc.get_potential_energy(dimer, force_consistent=True) self.Edimer[i, j + 3] = e except ConvergenceError: raise self.Fdimer[i, j + 3] = dimer.get_forces()[:, 0]
def get_calculator(): calc = GPAW(h=0.2, mode = 'lcao', basis = 'szp(dzp)', mixer=Mixer(beta=0.1, nmaxold=5, weight=50.0), poissonsolver=PoissonSolver(nn='M', relax='GS'), txt='C5H12.txt') return calc
def create_gpaw(comm): from gpaw import GPAW, FermiDirac, PoissonSolver, setup_paths from gpaw import Mixer setup_paths.insert(0, '.') calc = GPAW(xc='PBE', occupations=FermiDirac(width=0.02), mixer=Mixer(beta=0.10, nmaxold=5, weight=100.0), communicator=comm) return calc
def GLLBSC_work(): calc = GPAW(xc='GLLBSC', mixer=Mixer(0.5, 5, 50.0), eigensolver='cg', kpts=(4, 1, 1), convergence={'density': 1e-8}) atoms.set_calculator(calc) return atoms.get_potential_energy()
def MGGA_fail(): calc = GPAW(xc='TPSS', mixer=Mixer(0.5, 5, 50.0), eigensolver='cg', kpts=(1, 2, 1), convergence={'density': 1e-8}) atoms.set_calculator(calc) atoms.get_potential_energy() calc.set(kpts=(4, 1, 1)) return atoms.get_potential_energy()
def relaxGPAW(structure, label, forcemax=0.1, niter_max=1, steps=10): ''' Relax a structure and saves the trajectory based in the index i Parameters ---------- structure : ase Atoms object to be relaxed i : index which the trajectory is saved under ranks: ranks of the processors to relax the structure Returns ------- structure : relaxed Atoms object ''' # Create calculator calc=GPAW(#poissonsolver = PoissonSolver(relax = 'GS',eps = 1.0e-7), # C mode = 'lcao', basis = 'dzp', xc='PBE', #gpts = h2gpts(0.2, structure.get_cell(), idiv = 8), # C occupations=FermiDirac(0.1), #maxiter=99, # C maxiter=49, # Sn3O3 mixer=Mixer(nmaxold=5, beta=0.05, weight=75), nbands=-50, #kpts=(1,1,1), # C kpts=(2,2,1), # Sn3O3 txt = label+ '_lcao.txt') # Set calculator structure.set_calculator(calc) # loop a number of times to capture if minimization stops with high force # due to the VariansBreak calls niter = 0 # If the structure is already fully relaxed just return it if (structure.get_forces()**2).sum(axis = 1).max()**0.5 < forcemax: return structure traj = Trajectory(label+'_lcao.traj','w', structure) while (structure.get_forces()**2).sum(axis = 1).max()**0.5 > forcemax and niter < niter_max: dyn = BFGS(structure, logfile=label+'.log') vb = VariansBreak(structure, dyn, min_stdev = 0.01, N = 15) dyn.attach(traj) dyn.attach(vb) dyn.run(fmax = forcemax, steps = steps) niter += 1 return structure
def getcalc(**kwargs): kwargs1 = dict( xc='oldLDA', gpts=(32, 24, 32), setups={'Ag': '11'}, #h=0.24, poissonsolver=PoissonSolver(relax='GS'), mixer=Mixer(0.5, 5, 50.0), mode='lcao', basis='sz(dzp)') kwargs1.update(kwargs) return GPAW(**kwargs1)
def calculate(**kwargs1): kwargs = dict(mode=mode, basis='sz(dzp)', eigensolver=Davidson(4) if mode != 'lcao' else None, xc=vdw_df(), h=0.25, convergence=dict(energy=1e-6), mixer=Mixer(0.5, 5, 10.)) kwargs.update(kwargs1) calc = GPAW(**kwargs) system.set_calculator(calc) system.get_potential_energy() return calc
def get_calculator(): calc = GPAW(gpts=(64, 64, 64), #h=0.18, gives 64x60x60 mode='lcao', basis='szp(dzp)', nbands=-5, xc='LDA', width=0.1, mixer=Mixer(beta=0.1, nmaxold=5, weight=50.0), poissonsolver=PoissonSolver(nn='M', relax='GS'), convergence={'energy': 1e-4, 'bands': -3}, stencils=(3, 3), txt='nanoparticle.txt') return calc
def relaxGPAW(structure, label, calc=None, forcemax=0.1, niter_max=1, steps=10): # Create calculator if calc is None: calc = GPAW( poissonsolver=PoissonSolver(relax='GS', eps=1.0e-7), # C mode='lcao', basis='dzp', xc='PBE', gpts=h2gpts(0.2, structure.get_cell(), idiv=8), # C occupations=FermiDirac(0.1), maxiter=99, # C #maxiter=49, # Sn3O3 mixer=Mixer(nmaxold=5, beta=0.05, weight=75), nbands=-50, #kpts=(1,1,1), # C kpts=(2, 2, 1), # Sn3O3 txt=label + '_lcao.txt') else: calc.set(txt=label + '_true.txt') # Set calculator structure.set_calculator(calc) # loop a number of times to capture if minimization stops with high force # due to the VariansBreak calls niter = 0 # If the structure is already fully relaxed just return it if (structure.get_forces()**2).sum(axis=1).max()**0.5 < forcemax: return structure traj = Trajectory(label + '_lcao.traj', 'w', structure) while (structure.get_forces()** 2).sum(axis=1).max()**0.5 > forcemax and niter < niter_max: dyn = BFGS(structure, logfile=label + '.log') vb = VariansBreak(structure, dyn, min_stdev=0.01, N=15) dyn.attach(traj) dyn.attach(vb) dyn.run(fmax=forcemax, steps=steps) niter += 1 E = structure.get_potential_energy() F = structure.get_forces() return structure, E, F
def get_calculator(): basis = 'szp(dzp)' calc = GPAW( gpts=(64, 64, 128), # ca h=0.25 width=0.1, nbands=-5, xc='LDA', mode='lcao', txt='C2_Cu100.txt', mixer=Mixer(beta=0.1, nmaxold=5, weight=50.0), poissonsolver=PoissonSolver(nn='M', relax='GS'), stencils=(3, 3), maxiter=400, basis=basis) return calc
def simulate_CO(self, energy_cutoff, n_k_points): # # # Create Al bulk and initialize calculator parameters # # # mixer = Mixer(beta=0.1, nmaxold=5, weight=50.0) # Recommended values for small systems calc = GPAW(mode=PW(energy_cutoff), # use the LCAO basis mode h=0.18, # grid spacing, recommended value in this course xc='PBE', # Exchange-correlation functional mixer=mixer, # k-point grid - LOOP OVER LATER TO CHECK "CONVERGENCE" kpts=(n_k_points, n_k_points, n_k_points), txt='simulate_CO_GPAW.txt') # name of GPAW output text file self.adsorbate.set_calculator(calc) return self.adsorbate.get_potential_energy()
def efield(efield=0.05, n=30): printit('running GS calculation for {}'.format(efield)) fname = "sb_relaxed.cif" a = read(fname) atom = read(fname) wire = make_supercell(atom, [[n, 0, 0], [0, 1, 0], [ 0, 0, 1]], wrap=True, tol=1e-05) wire.center(vacuum=15, axis=0) a = wire.copy() if not os.path.isfile('gs_{}.gpw'.format(efield)): calc = GPAW( # mode='lcao', mode='fd', basis='szp(dzp)', # eigensolver='cg', #mixer=Mixer(beta=0.2, nmaxold=3, weight=70.0), xc='PBE', # poissonsolver=DipoleCorrection(PoissonSolver(relax='GS'), 2), mixer=Mixer(beta=0.06, nmaxold=5, weight=100.0), occupations=FermiDirac(width=0.1), kpts={'density': 4.5}, txt='gs_output_{}.txt'.format(efield), h=0.20, external=ConstantElectricField(efield, [0, 0, 1])) a.set_calculator(calc) a.get_potential_energy() calc.write('gs_{}.gpw'.format(efield)) calc = GPAW('gs_{}.gpw'.format(efield), nbands=-100, fixdensity=True, symmetry='off', kpts={'path': 'XGX', 'npoints': 100}, convergence={'bands': 'CBM+1'}, txt='gs_output_{}.txt'.format(efield)) calc.get_potential_energy() bs = calc.band_structure() bs.plot(filename='bandstructure_{}.png'.format( efield), show=False, emax=calc.get_fermi_level()+1, emin=calc.get_fermi_level()-1) bs.write('bs_{}.json'.format( efield)) try: gap, p1, p2 = get_gap(calc) printit("{} {} {} {}".format(efield, gap, p1, p2), fname="gaps.dat") except: None
def check(reuse): atoms = molecule('H2') atoms.pbc = 1 atoms.center(vacuum=1.5) atoms.positions -= atoms.positions[1] dz = 1e-2 atoms.positions[:, 2] += dz calc = GPAW(mode='pw', txt='gpaw.txt', nbands=1, experimental=dict(reuse_wfs_method='paw' if reuse else None), kpts=[[-0.3, 0.4, 0.2]], symmetry='off', mixer=Mixer(0.7, 5, 50.0)) atoms.calc = calc first_iter_err = [] def monitor(): logerr = np.log10(calc.wfs.eigensolver.error) n = calc.scf.niter if n == 1: first_iter_err.append(logerr) if world.rank == 0: print('iter', n, 'err', logerr) calc.attach(monitor, 1) atoms.get_potential_energy() logerr1 = first_iter_err.pop() atoms.positions[:, 2] -= 2 * dz atoms.get_potential_energy() logerr2 = first_iter_err.pop() if world.rank == 0: print('reuse={}'.format(bool(reuse))) print('logerr1', logerr1) print('logerr2', logerr2) gain = logerr2 - logerr1 print('gain', gain) return logerr2
def simulate_surface_Al(self, miller_index, energy_cutoff, n_k_points): ''' Function that adds surfaces to the aluminum nano particle ''' mixer = Mixer(beta=0.1, nmaxold=5, weight=50.0) # Recommended values for small systems # Initialize new calculator that only considers k-space in xy-plane, # since we're only looking at the surface calc = GPAW(mode=PW(energy_cutoff), # use the LCAO basis mode h=0.18, # grid spacing xc='PBE', # XC-functional mixer=mixer, kpts=(n_k_points, n_k_points, 1), # k-point grid txt='simulate_surface_Al_' + miller_index + 'GPAW.txt') # name of GPAW output text file self.get_surface_object(miller_index).set_calculator(calc) # Calc pot. energy of FCC surface_energy = self.surfaces[miller_index].get_potential_energy() self.surfaces[miller_index]['energy'] = surface_energy return surface_energy
def singleGPAW(structure, label): # Create calculator calc = GPAW(poissonsolver=PoissonSolver(relax='GS', eps=1.0e-7), mode='lcao', basis='dzp', xc='PBE', gpts=h2gpts(0.2, structure.get_cell(), idiv=8), occupations=FermiDirac(0.1), maxiter=99, mixer=Mixer(nmaxold=5, beta=0.05, weight=75), nbands=-50, kpts=(1, 1, 1), txt=label + '_single_lcao.txt') # Set calculator structure.set_calculator(calc) return structure.get_potential_energy(), structure.get_forces()
def convergence(self, fd, setup='de'): a = 3.0 atoms = Atoms(self.symbol, cell=(a, a, a), pbc=True) if 58 <= self.Z <= 70 or 90 <= self.Z <= 102: M = 999 mixer = {'mixer': Mixer(0.01, 5)} else: M = 333 mixer = {} atoms.calc = GPAW(mode=PW(1500), xc='PBE', setups=self.setup, symmetry='off', maxiter=M, txt=fd, **mixer) e0 = atoms.get_potential_energy() energies = [e0] iters = atoms.calc.get_number_of_iterations() oldfde = None area = 0.0 def f(x): return x**0.25 for ec in range(800, 200, -100): atoms.calc.set(mode=PW(ec)) atoms.calc.set(eigensolver='rmm-diis') de = atoms.get_potential_energy() - e0 energies.append(de) # print(ec, de) fde = f(abs(de)) if fde > f(0.1): if oldfde is None: return np.inf, iters, energies ec0 = ec + (fde - f(0.1)) / (fde - oldfde) * 100 area += ((ec + 100) - ec0) * (f(0.1) + oldfde) / 2 break if oldfde is not None: area += 100 * (fde + oldfde) / 2 oldfde = fde return area, iters, energies
def simulate_bulk_Al(self, energy_cutoff, n_k_points): ''' Function that calculates volume and energy for bulk aluminium. The function uses GPAW with a plane wave basis set and the PBE exchange correlation. ''' # # # Create Al bulk and initialize calculator parameters # # # mixer = Mixer(beta=0.1, nmaxold=5, weight=50.0) # Recommended values for small systems calc = GPAW(mode=PW(energy_cutoff), # use the LCAO basis mode h=0.18, # grid spacing, recommended value in this course xc='PBE', # Exchange-correlation functional mixer=mixer, # k-point grid - LOOP OVER LATER TO CHECK "CONVERGENCE" kpts=(n_k_points, n_k_points, n_k_points), txt='simulate_bulk_Al_GPAW.txt') # name of GPAW output text file self.bulk_Al['object'].set_calculator(calc) self.bulk_Al['volume'] = self.bulk_Al['object'].get_volume() self.bulk_Al['energy'] = self.bulk_Al['object'].get_potential_energy() return self.bulk_Al['energy']
def makeGPAWcalc(p): from gpaw import GPAW, PW, Davidson, Mixer, MixerSum, FermiDirac return GPAW( mode=PW(p['pw']), xc=p['xc'], kpts=kpt, spinpol=spinpol, convergence={'energy': p['econv']} #eV/electron , mixer=((MixerSum(beta=p['mixing'], nmaxold=p['nmix'], weight=100)) if spinpol else (Mixer(beta=p['mixing'], nmaxold=p['nmix'], weight=100))), maxiter=p['maxstep'], nbands=p['nbands'], occupations=FermiDirac(p['sigma']), setups=p['psp'], eigensolver=Davidson(5), poissonsolver=None, txt='log', symmetry={'do_not_symmetrize_the_density': True})