def __init__(self, symbol, filename=None, index=None, txt=None): if filename is None or filename == '-': formula, index = get_system(symbol) filename = restart_filename % formula calc = Calculator(filename, txt=txt) atoms = calc.get_atoms() symbols = atoms.get_chemical_symbols() if index is None: index = symbols.index(symbol) else: if not symbols[index] == symbol: raise ValueError( ('Atom (%s) at specified index (%d) not of ' + 'requested type (%s)') % (symbols[index], index, symbol)) self.calc = calc self.filename = filename self.atoms = atoms self.symbol = symbol self.symbols = symbols self.index = index self.cell = atoms.get_cell().diagonal() # cubic cell #self.center = atoms.positions[index] self.spos_ac = atoms.positions / self.cell self.gpts = calc.wfs.gd.N_c if calc.kpt_u[0].psit_nG is None: raise RuntimeError('No wave functions found in .gpw file')
def __init__(self, symbol, filename=None, index=None, txt=None): if filename is None or filename == '-': formula, index = get_system(symbol) filename = restart_filename % formula calc = Calculator(filename, txt=txt) atoms = calc.get_atoms() symbols = atoms.get_chemical_symbols() if index is None: index = symbols.index(symbol) else: if not symbols[index] == symbol: raise ValueError(('Atom (%s) at specified index (%d) not of '+ 'requested type (%s)') % (symbols[index], index, symbol)) self.calc = calc self.filename = filename self.atoms = atoms self.symbol = symbol self.symbols = symbols self.index = index self.cell = atoms.get_cell().diagonal() # cubic cell #self.center = atoms.positions[index] self.spos_ac = atoms.positions / self.cell self.gpts = calc.wfs.gd.N_c if calc.kpt_u[0].psit_nG is None: raise RuntimeError('No wave functions found in .gpw file')
class STM: def __init__(self, surfacecalc, tipcalc): self.scalc = surfacecalc self.tcalc = tipcalc self.surface = surfacecalc.get_atoms() self.tip = tipcalc.get_atoms() def initialize(self): tip = self.tip.copy() htip = tip.get_cell()[2, 2] #tip.translate((0, 0, htip)) self.combined = self.surface + tip self.combined.cell[2, 2] += htip self.calc = Calculator(h=0.2, eigensolver='lcao', basis='sz', txt=None) #self.combined.set_calculator(self.calc) self.calc.initialize(self.combined) self.calc.hamiltonian.initialize(self.calc) self.calc.density.initialize() self.vtip_G = self.tcalc.hamiltonian.vt_sG[0] self.vsurface_G = self.scalc.hamiltonian.vt_sG[0] self.get_basis_functions() self.tgd = self.tcalc.wfs.gd self.sgd = self.scalc.wfs.gd def get_basis_functions(self): gd = self.calc.wfs.gd self.functions = [] for nucleus in self.calc.nuclei: spos0_c = np.round(nucleus.spos_c * gd.N_c) / gd.N_c f_iG = clf(nucleus.setup.phit_j, gd, nucleus.spos_c + 0.5 - spos0_c, dtype=float, cut=False, forces=False, lfbc=None).box_b[0].get_functions() self.functions.append((spos0_c, f_iG)) def set_position(self, dG): positions = self.combined.get_positions() tippositions = self.tip.get_positions() tippositions += dG * self.calc.wfs.gd.h_c / Bohr positions[-len(self.tip):] = tippositions self.combined.set_positions(positions) self.calc.set_positions(self.combined) self.calc.hamiltonian.initialize_lcao()
def memory_bandwidth(code='gpaw', runs=7): slab = Atoms([ Atom('Al', (0, 0, 0)), Atom('Al', (a, 0, 0)), Atom('Al', (a / 2, d / 2, -d / 2)), Atom('Al', (3 * a / 2, d / 2, -d / 2)), Atom('Al', (0, 0, -d)), Atom('Al', (a, 0, -d)), Atom('Al', (a / 2, d / 2, -3 * d / 2)), Atom('Al', (3 * a / 2, d / 2, -3 * d / 2)), Atom('Al', (0, 0, -2 * d)), Atom('Al', (a, 0, -2 * d)), Atom('H', (a / 2 - b / 2, 0, z)), Atom('H', (a / 2 + b / 2, 0, z)) ], cell=(2 * a, d, 5 * d), pbc=(1, 1, 1)) h = 0.15 nbands = 28 kpts = (2, 6, 1) parameters = {} if code == 'gpaw': from gpaw import Calculator from gpaw.mpi import rank parameters['convergence'] = {'eigenstates': 1e-5} parameters['h'] = h elif code == 'dacapo': from ase.calculators.dacapo import Dacapo as Calculator parameters['planewavecutoff'] = gridspacing2cutoff(h) parameters['densitycutoff'] = parameters['planewavecutoff'] * 1.5 rank = 0 t = 0.0 t_runs = [] for n in range(runs): t0 = time.time() for i in range(1): calc = Calculator(nbands=nbands, kpts=kpts, **parameters) slab.set_calculator(calc) e = slab.get_potential_energy() del calc if exists('out.nc'): remove('out.nc') t1 = time.time() t = t + t1 - t0 t_runs.append(t1 - t0) print 'Run: ', n, ' energy ', e, ' rank: ', str( rank), ' time: ', time.time() - t0 if rank == 0: print 'Rank ' + str(rank) + ': time [sec]: avg ' + str( round(np.average(t_runs), 1)) + ', stddev ' + str( round(np.std(t_runs), 1)) + ', min ' + str( round(min(t_runs), 1)) + ', max ' + str( round(max(t_runs), 1))
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 initialize(self): tip = self.tip.copy() htip = tip.get_cell()[2, 2] #tip.translate((0, 0, htip)) self.combined = self.surface + tip self.combined.cell[2, 2] += htip self.calc = Calculator(h=0.2, eigensolver='lcao', basis='sz', txt=None) #self.combined.set_calculator(self.calc) self.calc.initialize(self.combined) self.calc.hamiltonian.initialize(self.calc) self.calc.density.initialize() self.vtip_G = self.tcalc.hamiltonian.vt_sG[0] self.vsurface_G = self.scalc.hamiltonian.vt_sG[0] self.get_basis_functions() self.tgd = self.tcalc.wfs.gd self.sgd = self.scalc.wfs.gd
def rotation_test(): molecule = 'NH3' a = 7. rcut = 5. l = 1 from gpaw.output import plot rotationvector = np.array([1.0, 1.0, 1.0]) angle_increment = 0.3 system = g2.molecule(molecule) system.set_cell([a, a, a]) system.center() calc = Calculator(h=0.27, txt=None) system.set_calculator(calc) pog = PolarizationOrbitalGenerator(rcut) r = np.linspace(0., rcut, 300) maxvalues = [] import pylab for i in range(0, int(6.28 / angle_increment)): ascii = plot(system.positions, system.get_atomic_numbers(), system.get_cell().diagonal()) print ascii print 'angle=%.03f' % (angle_increment * i) energy = system.get_potential_energy() center = (system.positions / system.get_cell().diagonal())[0] orbital = pog.generate(l, calc.wfs.gd, calc.kpt_u[0].psit_nG, center) y = orbital(r) pylab.plot(r, y, label='%.02f' % (i * angle_increment)) maxvalues.append(max(y)) print 'Quality by orbital', #pretty(pog.optimizer.lastterms) system.rotate(rotationvector, angle_increment) system.center() print max(maxvalues) - min(maxvalues) pylab.legend() pylab.show()
tests = [] for nkpt in [4]: for magmom in [3.0]: test = 'test: nkpt = %d magmom = %1.1f' % (nkpt, magmom) for nhosts in nhostswrite: print test file_prefix = 'Fe_%d_%1.1f_par%d' % (nkpt, magmom, nhosts) fcc = Atoms([Atom('Fe', (0, 0, 0.0001), magmom=magmom)], pbc=True, cell=(2.55, 2.55, 2.55)) calc = Calculator(nbands=6, gpts=(ng, ng, ng), kpts=(4, 2, 2), txt=file_prefix + '.txt', tolerance=1e-10) fcc.set_calculator(calc) #fcc[0].set_magnetic_moment(magmom) e = fcc.get_potential_energy() calc.write(file_prefix + '.gpw') del calc, fcc for nhosts in nhostsread: file_prefix = 'Fe_%d_%1.1f_par%d' % (nkpt, magmom, nhosts) print '------ restart calculation ', file_prefix, rank * 111111111 calc = Calculator(file_prefix + '.gpw', txt=file_prefix + '_restart.txt', tolerance=1e-10)
from ase import * from gpaw import Calculator h = 0.2 n = 24 a = n * h H2 = Atoms('He2', positions=[(0.123, 0.234, 0.345), (2.523, 2.634, 0.345)], pbc=True, cell=(a, a, a)) calc = Calculator( nbands=2, gpts=(n, n, n), #hosts=8, txt='tmp') H2.set_calculator(calc) e0 = H2.get_potential_energy() for i in range(51): e = H2.get_potential_energy() print i * a / 25, e - e0 calc.txt.flush() H2.positions[0] += (a / 25, 0, 0) H2.positions[1] += (0, 0, a / 25) assert abs(e - e0) < 1e-4
from ase import * from gpaw import Calculator from gpaw.utilities import equal a = 4.8 # => N = 4.8 / 0.2 = 24 loa = Atoms([Atom('C', [a / 2 + .3, a / 2 -.1, a / 2], magmom=2)], pbc=False, cell=(a, a, a)) p = [] exx = [] i = 0 calc = Calculator(convergence={'eigenstates': 1e-6}, hund=1, txt='exx_parallel.txt') loa.set_calculator(calc) p.append(loa.get_potential_energy()) exx.append(calc.get_exact_exchange()) print 'Potential energy :', p[i] print 'Exchange energy :', exx[i] print '' ## number of CPUs : 1 ## Potential energy : -1.04946572514 ## Exchange energy : -5.05252232093 ## number of CPUs : 2 ## Potential energy : -1.04946572514 ## Exchange energy : -5.05252232093
from ase import * from gpaw import Calculator from gpaw.utilities import equal a = 4.8 # => N = 4.8 / 0.2 = 24 loa = Atoms([Atom('C', [a / 2 + .3, a / 2 - .1, a / 2], magmom=2)], pbc=False, cell=(a, a, a)) p = [] exx = [] i = 0 calc = Calculator(convergence={'eigenstates': 1e-6}, hund=1, txt='exx_parallel.txt') loa.set_calculator(calc) p.append(loa.get_potential_energy()) exx.append(calc.get_exact_exchange()) print 'Potential energy :', p[i] print 'Exchange energy :', exx[i] print '' ## number of CPUs : 1 ## Potential energy : -1.04946572514 ## Exchange energy : -5.05252232093 ## number of CPUs : 2 ## Potential energy : -1.04946572514 ## Exchange energy : -5.05252232093
import numpy as np from ASE import Atom from gpaw.utilities import equal from gpaw.cluster import Cluster from gpaw import Calculator from gpaw.analyse.expandyl import ExpandYl R = 1. H2 = Cluster([Atom('H',(0,0,0)), Atom('H',(0,0,R))]) H2.minimal_box(3.) calc = Calculator(h=0.2, width=0.01, nbands=2) H2.SetCalculator(calc) H2.GetPotentialEnergy() yl = ExpandYl(H2.center_of_mass(), calc.wfs.gd, Rmax=2.5) gl = [] for n in range(calc.nbands): psit_G = calc.kpt_u[0].psit_nG[n] norm = calc.wfs.gd.integrate(psit_G**2) g = yl.expand(psit_G) gsum = np.sum(g) # allow for 10 % inaccuracy in the norm print "norm, sum=", norm, gsum equal(norm, gsum, 0.1) gl.append(g/gsum*100)
def run_slab(adsorbate, geometry, xc, code): parameters = initialize_parameters(code, 0.1, h) parameters['xc'] = xc tag = 'Ru001' if adsorbate != 'None': name = adsorbate + tag else: name = tag if geometry == 'fix': slab = read_trajectory(code + '_' + name + '.traj') else: adsorbate_heights = {'N': 1.108, 'O': 1.257} slab = hcp0001('Ru', size=(2, 2, 4), a=2.72, c=1.58 * 2.72, vacuum=5.0 + add_vacuum, orthogonal=True) slab.center(axis=2) if adsorbate != 'None': add_adsorbate(slab, adsorbate, adsorbate_heights[adsorbate], 'hcp') slab.set_constraint(FixAtoms(mask=slab.get_tags() >= 3)) if code != 'elk': parameters['nbands'] = 80 parameters['kpts'] = [4, 4, 1] # if code == 'gpaw': from gpaw import GPAW as Calculator from gpaw.mpi import rank parameters['txt'] = code + '_' + name + '.txt' from gpaw.mixer import Mixer, MixerSum parameters['mixer'] = Mixer(beta=0.2, nmaxold=5, weight=100.0) if code == 'dacapo': from ase.calculators.dacapo import Dacapo as Calculator rank = 0 parameters['txtout'] = code + '_' + name + '.txt' if code == 'abinit': from ase.calculators.abinit import Abinit as Calculator rank = 0 parameters['label'] = code + '_' + name if code == 'elk': from ase.calculators.elk import ELK as Calculator rank = 0 parameters['autokpt'] = True elk_dir = 'elk_' + str(parameters['rgkmax']) conv_param = 1.0 parameters['dir'] = elk_dir + '_' + name # calc = Calculator(**parameters) # slab.set_calculator(calc) try: if geometry == 'fix': slab.get_potential_energy() traj = PickleTrajectory(code + '_' + name + '.traj', mode='w') traj.write(slab) else: opt = QuasiNewton(slab, logfile=code + '_' + name + '.qn', trajectory=code + '_' + name + '.traj') opt.run(fmax=fmax) except: raise
def run_molecule(adsorbate, geometry, xc, code): parameters = initialize_parameters(code, 0.01, h) parameters['xc'] = xc molecules = { 'None': ('NO', 8), 'N': ('N2', 8), 'O': ('O2', 8), } for name, nbands in [molecules[adsorbate]]: if code != 'elk': parameters['nbands'] = nbands if geometry == 'fix': mol = read_trajectory(code + '_' + name + '.traj') else: mol = molecule(name) mol.center(vacuum=3.0 + add_vacuum) if name == 'NO': mol.translate((0, 0.1, 0)) # if code == 'gpaw': from gpaw import GPAW as Calculator from gpaw.mpi import rank parameters['txt'] = code + '_' + name + '.txt' from gpaw.mixer import Mixer, MixerSum #if name == 'N2': # parameters['mixer'] = Mixer(beta=0.1, nmaxold=5, metric='new', weight=100.0) #else: # #parameters['eigensolver'] = 'cg' # parameters['mixer'] = MixerSum(beta=0.2, nmaxold=5, metric='new', weight=100.0) if code == 'dacapo': from ase.calculators.dacapo import Dacapo as Calculator rank = 0 parameters['txtout'] = code + '_' + name + '.txt' if code == 'abinit': from ase.calculators.abinit import Abinit as Calculator rank = 0 parameters['label'] = code + '_' + name if code == 'elk': from ase.calculators.elk import ELK as Calculator rank = 0 elk_dir = 'elk_' + str(parameters['rgkmax']) conv_param = 1.0 parameters['dir'] = elk_dir + '_' + name # calc = Calculator(**parameters) # mol.set_calculator(calc) try: if geometry == 'fix': mol.get_potential_energy() traj = PickleTrajectory(code + '_' + name + '.traj', mode='w') traj.write(mol) else: opt = QuasiNewton(mol, logfile=code + '_' + name + '.qn', trajectory=code + '_' + name + '.traj') opt.run(fmax=fmax) except: raise
tests = [] for nkpt in [4]: for magmom in [3.0]: test = 'test: nkpt = %d magmom = %1.1f' % (nkpt, magmom) for nhosts in nhostswrite: print test file_prefix = 'Fe_%d_%1.1f_par%d'%(nkpt,magmom,nhosts) fcc = Atoms([Atom('Fe', (0, 0, 0.0001) ,magmom=magmom)], pbc=True, cell = (2.55,2.55,2.55)) calc = Calculator(nbands=6, gpts=(ng,ng,ng), kpts=(4, 2, 2), txt=file_prefix+'.txt', tolerance = 1e-10) fcc.set_calculator(calc) #fcc[0].set_magnetic_moment(magmom) e = fcc.get_potential_energy() calc.write(file_prefix+'.gpw') del calc,fcc for nhosts in nhostsread: file_prefix = 'Fe_%d_%1.1f_par%d'%(nkpt,magmom,nhosts) print '------ restart calculation ',file_prefix, rank*111111111 calc = Calculator(file_prefix+'.gpw', txt=file_prefix+'_restart.txt', tolerance = 1e-10)