Exemplo n.º 1
0
    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 ['Na', 'Mg']: eigensolver = 'cg'
        if self.symbol in ['Sc', 'Ti', 'V', 'Mn', 'Ni',
                           'Zn']: eigensolver = 'cg'
        if self.symbol in ['Zr', 'Nb', 'Mo', 'Ru', 'Rh', 'Pd',
                           'Ag']: eigensolver = 'cg'
        if self.symbol in ['Sn', 'Sb', 'Te', 'Ba']: eigensolver = 'cg'
        if self.symbol in ['Hf', 'Ta', 'W', 'Re', 'Os',
                           'Ir', 'Pt', 'Hg', 'Pb', 'Bi']: 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]
Exemplo n.º 2
0
    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]
Exemplo n.º 3
0
    def setup_calculator(self, system, formula):
        hund = (len(system) == 1)
        cell = system.get_cell()
        h = self.h
        system.set_cell((cell / (4 * h)).round() * 4 * h)
        system.center()
        calc = GPAW(xc=self.xc,
                    h=h,
                    hund=hund,
                    fixmom=True,
                    setups=self.setups,
                    txt=self.get_filename(formula, extension='txt'),
                    mode=self.mode,
                    basis=self.basis
                    )

        # Special cases
        if formula == 'BeH':
            calc.set(idiotproof=False)
            #calc.initialize(system)
            #calc.nuclei[0].f_si = [(1, 0, 0.5, 0, 0),
            #                       (0.5, 0, 0, 0, 0)]

        if formula in self.bad_formulas:
            system.positions[:, 1] += h * 1.5
        
        return calc
Exemplo n.º 4
0
    def get_forces(self, atoms):
        """
        Altered version of the original get_forces function in the GPAW-class.
        The function obtains the DFT forces by using the original call for the
        GPAW package and adds the DFT-D contribution to the calculated forces.
        """
        #
        # Conversion factors a.u. -> eV and a.u. -> eV/Angst
        Eh__2__eV          = 27.211396132
        Eh_rb__2__eV_Angst = 51.422086162
        #
        # Calling original VASP-calculator for forces
        self.dft_forces = GPAW.get_forces(self, atoms)
        #
        # Get functional name as string
	self.functional = xc_name(str.lower(GPAW.get_xc_functional(self)))
        #
        # Call DFT-D module: Energy and gradients
        self.dispersion_correction, self.dft_d_gradient_contribution = d2_pbc(atoms,self.functional)
        #
        # Convert to proper units
        self.dispersion_correction       = self.dispersion_correction       * Eh__2__eV
        self.dft_d_gradient_contribution = self.dft_d_gradient_contribution * Eh_rb__2__eV_Angst
        #
        # Adding correction contributions to forces
        # Note the (-) sign: DFT-D module delivers gradients, not forces
        return self.dft_forces - self.dft_d_gradient_contribution
Exemplo n.º 5
0
def fulldiag(filename, bands=None, scalapack=1, dry_run=False):
    """Set up full H and S matrices and find all or some eigenvectors/values.
    
    calc: str
        Filename of gpw-file.
    bands: int
        Number of bands to calculate.  Defaults to all.
    scalapack: int
        Number of cores to use for ScaLapack.  Default is one.
    dry_run: bool
        Don't do actual calculation.
    
    """
    name, ext = filename.rsplit('.', 1)
    assert ext == 'gpw'
    calc = GPAW(filename,
                parallel={'band': scalapack},
                txt=name + '-all.txt')
    if not dry_run:
        calc.diagonalize_full_hamiltonian(bands)
        calc.write(name + '-all.gpw', 'all')
    
    ng = calc.wfs.pd.ngmax
    mem = ng**2 * 16 / 1024**2
    print('Maximum matrix size: {0}x{0} = {1:.3f} MB'.format(ng, mem))
Exemplo n.º 6
0
def GLLBSC_fail():
    calc = GPAW(xc='GLLBSC', 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()
Exemplo n.º 7
0
    def get_potential_energy(self, atoms, force_consistent=False):
        """
        Altered version of the original get_potential_energy function
        in the class GPAW. The function obtains the DFT energy by using
        the original call for the GPAW package and adds the DFT-D3 contribution
        to the converged SCF-energy.
        """
        #
        # Conversion factors a.u. -> eV
        Eh__2__eV          = 27.211396132
        #
        # Calling original GPAW-calculator for energy
        self.ks_scf_energy = GPAW.get_potential_energy(self, atoms, force_consistent)
        #
        # Get functional name as string
	self.functional = xc_name(str.lower(GPAW.get_xc_functional(self)))
        #
        # Call DFT-D module: Energy and gradients
        self.dispersion_correction, self.dft_d_gradient_contribution = d3_pbc(atoms, self.functional)
        #
        # Convert to proper units
        self.dispersion_correction       = self.dispersion_correction       * Eh__2__eV
        #
#       # Print out components (Useful?)
#       print
#       print 'DFT total energy  : ', self.ks_scf_energy
#       print 'DFT-D3 correction : ', self.dispersion_correction
#       print
#       print 'DFT-D3 final corrected energy: ', self.ks_scf_energy + self.dispersion_correction
#       print
        #
        # Adding correction contribution to energy
        return self.ks_scf_energy + self.dispersion_correction
Exemplo n.º 8
0
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='revPBE')
    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)
Exemplo n.º 9
0
def dos(filename, plot=False, output='dos.csv', width=0.1):
    """Calculate density of states.
    
    filename: str
        Name of restart-file.
    plot: bool
        Show a plot.
    output: str
        Name of CSV output file.
    width: float
        Width of Gaussians.
    """
    from gpaw import GPAW
    from ase.dft.dos import DOS
    calc = GPAW(filename, txt=None)
    dos = DOS(calc, width)
    D = [dos.get_dos(spin) for spin in range(calc.get_number_of_spins())]
    if output:
        fd = sys.stdout if output == '-' else open(output, 'w')
        for x in zip(dos.energies, *D):
            print(*x, sep=', ', file=fd)
        if output != '-':
            fd.close()
    if plot:
        import matplotlib.pyplot as plt
        for y in D:
            plt.plot(dos.energies, y)
        plt.show()
Exemplo n.º 10
0
    def get_exact_exchange(self, ecut=None, communicator=world, file='EXX.pckl'):

        try:
            self.ini
        except:
            self.initialize()

        self.printtxt('------------------------------------------------')
        self.printtxt("calculating Exact exchange and E_XC")

        calc = GPAW(self.file, communicator=communicator, parallel={'domain':1, 'band':1}, txt=None)
        v_xc = vxc(calc)

        if ecut == None:
            ecut = self.ecut.max()
        else:
            ecut /= Hartree

        if self.pwmode: # planewave mode
            from gpaw.xc.hybridg import HybridXC
            self.printtxt('Use planewave ecut from groundstate calculator: %4.1f eV' % (calc.wfs.pd.ecut*Hartree) )
            exx = HybridXC('EXX', alpha=5.0, bandstructure=True, bands=self.bands)
        else:                                     # grid mode
            from gpaw.xc.hybridk import HybridXC
            self.printtxt('Planewave ecut (eV): %4.1f' % (ecut*Hartree) )
            exx = HybridXC('EXX', alpha=5.0, ecut=ecut, bands=self.bands)
        calc.get_xc_difference(exx)

        e_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
        f_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
        vxc_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)
        exx_skn = np.zeros((self.nspins, self.gwnkpt, self.gwnband), dtype=float)

        for s in range(self.nspins):
            for i, k in enumerate(self.gwkpt_k):
                ik = self.kd.bz2ibz_k[k]
                for j, n in enumerate(self.gwbands_n):
                    e_skn[s][i][j] = self.e_skn[s][ik][n]
                    f_skn[s][i][j] = self.f_skn[s][ik][n]
                    vxc_skn[s][i][j] = v_xc[s][ik][n] / Hartree
                    exx_skn[s][i][j] = exx.exx_skn[s][ik][n]
                    if self.eshift is not None:
                        if e_skn[s][i][j] > self.eFermi:
                            vxc_skn[s][i][j] += self.eshift / Hartree

        data = {
                'e_skn':     e_skn,      # in Hartree
                'vxc_skn':   vxc_skn,    # in Hartree
                'exx_skn':   exx_skn,    # in Hartree
                'f_skn':     f_skn,
                'gwkpt_k':   self.gwkpt_k,
                'gwbands_n': self.gwbands_n
               }
        if rank == 0:
            pickle.dump(data, open(file, 'w'), -1)
            self.printtxt("------------------------------------------------")
            self.printtxt("non-selfconsistent HF eigenvalues are (eV):")
            self.printtxt((e_skn - vxc_skn + exx_skn)*Hartree)
Exemplo n.º 11
0
class UTGroundStateSetup(TestCase):
    """
    Setup a simple calculation starting from ground state."""

    # Number of bands
    nbands = 1

    # Spin-paired, single kpoint
    nspins = 1
    nibzkpts = 1

    # Mean spacing and number of grid points per axis (G x G x G)
    h = 0.25 / Bohr

    def setUp(self):
        for virtvar in []:
            assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar

        parsize_domain, parsize_bands = create_parsize_maxbands(self.nbands, world.size)
        self.parallel = {'domain': parsize_domain, 'band': parsize_bands}

        self.atoms = molecule('Na2')
        self.atoms.center(vacuum=4.0)
        self.atoms.set_pbc(False)

        cell_c = np.sum(self.atoms.get_cell()**2, axis=1)**0.5 / Bohr
        ngpts = 16 * np.round(cell_c / (self.h * 16))
        self.gsname = 'ut_tddft_gs'
        self.gscalc = GPAW(gpts=ngpts, nbands=self.nbands, basis='dzp',
                           setups={'Na': '1'},
                           spinpol=(self.nspins==2), parallel=self.parallel,
                           txt=self.gsname + '.txt')

    def tearDown(self):
        del self.atoms, self.gscalc

    # =================================

    def verify_comm_sizes(self):
        if world.size == 1:
            return
        rem = world.size // (self.parallel['band'] * self.parallel['domain'])
        comm_sizes = (world.size, self.parallel['band'],
                      self.parallel['domain'], rem)
        self._parinfo =  '%d world, %d band, %d domain, %d kpt' % comm_sizes
        self.assertEqual(self.nbands % self.parallel['band'], 0)
        self.assertEqual((self.nspins * self.nibzkpts) % rem, 0)

    def verify_ground_state(self):
        #XXX DEBUG START
        if debug and os.path.isfile(self.gsname + '.gpw'):
            return
        #XXX DEBUG END

        self.atoms.set_calculator(self.gscalc)
        self.assertAlmostEqual(self.atoms.get_potential_energy(), -1.0621, 4)
        self.gscalc.write(self.gsname + '.gpw', mode='all')
        self.assertTrue(os.path.isfile(self.gsname + '.gpw'))
Exemplo n.º 12
0
Arquivo: Al100.py Projeto: qsnake/gpaw
def energy(N, k, a=4.05):
    fcc = fcc100('Al', (1, 1, N), a=a, vacuum=7.5)
    fcc.center(axis=2)
    calc = GPAW(nbands=N * 5,
                kpts=(k, k, 1),
                h=0.25,
                txt='slab-%d.txt' % N)
    fcc.set_calculator(calc)
    e = fcc.get_potential_energy()
    calc.write('slab-%d.gpw' % N)
    return e
Exemplo n.º 13
0
def f(kpts, n, magmom, pbc, dd):
    global de1
    H = Atoms([Atom('H',(a/2, a/2, a/2), magmom=magmom)],
                    pbc=pbc,
                    cell=(a, a, a))
    
    H.set_calculator(GPAW(nbands=1, gpts=(n, n, n), kpts=kpts,
                               txt=None, tolerance=0.0001,
                               parsize=dd))
    e = H.get_potential_energy()
    H.get_calculator().write('H-par.gpw')
    c = GPAW('H-par.gpw', txt=None)
    H = c.get_atoms()
    de = abs(H.get_potential_energy() - e)
    if de > de1:
        de1 = de
    assert de < 1e-15
    return e
 def ground_state(self, filename, **kwargs):
     # GPAW calculator for the ground state
     self.gs_calc = GPAW(gpts          = self.gpts,
                         poissonsolver = self.poissonsolver,
                         **kwargs
                         )
     self.atoms.set_calculator(self.gs_calc)
     self.energy = self.atoms.get_potential_energy()
     self.write(filename, mode='all')
Exemplo n.º 15
0
def f(kpts, n, magmom, periodic, dd):
    global de1
    H = Atoms('H', positions=[(a/2, a/2, a/2)], magmoms=[magmom],
              pbc=periodic,
              cell=(a, a, a))
    
    H.set_calculator(GPAW(nbands=1, gpts=(n, n, n), kpts=kpts,
                          txt=None,
                          convergence={'eigenstates': 0.0001},
                          parsize=dd))
    e = H.get_potential_energy()
    H.get_calculator().write('/tmp/H-par.gpw')
    c = GPAW('/tmp/H-par.gpw', txt=None)
    H = c.get_atoms()
    de = abs(H.get_potential_energy() - e)
    if de > de1:
        de1 = de
    assert de < 1e-15
    return e
Exemplo n.º 16
0
    def do_calculations(self, formulas):
        """Perform calculation on molecules, write results to .gpw files."""
        atoms = {}
        for formula in formulas:
            for symbol in string2symbols(formula.split('_')[0]):
                atoms[symbol] = None
        formulas = formulas + atoms.keys()

        for formula in formulas:
            if path.isfile(formula + '.gpw'):
                continue

            barrier()
            open(formula + '.gpw', 'w')
            s = molecule(formula)
            s.center(vacuum=self.vacuum)
            cell = s.get_cell()
            h = self.h
            s.set_cell((cell / (4 * h)).round() * 4 * h)
            s.center()
            calc = GPAW(h=h,
                        xc=self.xc,
                        eigensolver=self.eigensolver,
                        setups=self.setups,
                        basis=self.basis,
                        fixmom=True,
                        txt=formula + '.txt')

            if len(s) == 1:
                calc.set(hund=True)

            s.set_calculator(calc)

            if formula == 'BeH':
                calc.initialize(s)
                calc.nuclei[0].f_si = [(1, 0, 0.5, 0, 0),
                                       (0.5, 0, 0, 0, 0)]

            if formula in ['NO', 'ClO', 'CH']:
                s.positions[:, 1] += h * 1.5

            try:
                energy = s.get_potential_energy()
            except (RuntimeError, ConvergenceError):
                if rank == 0:
                    print >> sys.stderr, 'Error in', formula
                    traceback.print_exc(file=sys.stderr)
            else:
                print >> self.txt, formula, repr(energy)
                self.txt.flush()
                calc.write(formula)

            if formula in diatomic and self.calculate_dimer_bond_lengths:
                traj = PickleTrajectory(formula + '.traj', 'w')
                d = diatomic[formula][1]
                for x in range(-2, 3):
                    s.set_distance(0, 1, d * (1.0 + x * 0.02))
                    traj.write(s)
Exemplo n.º 17
0
def aual100(site, height, calc=None):

    slab = fcc100('Al', size=(2, 2, 1))
    add_adsorbate(slab, 'Au', height, site)
    slab.center(axis=2, vacuum=3.0)
    mask = [atom.symbol == 'Al' for atom in slab]
    fixlayer = FixAtoms(mask=mask)
    slab.set_constraint(fixlayer)

    if calc is None:
        calc = GPAW(h=0.25, kpts=(2, 2, 1), xc='PBE', txt=site + '.txt')

    slab.set_calculator(calc)
    qn = QuasiNewton(slab, trajectory=site + '.traj')
    qn.run(fmax=0.05)

    if isinstance(calc, GPAW):
        calc.write(site + '.gpw')

    return slab.get_potential_energy()
Exemplo n.º 18
0
def create_calc(name, spinpol, pbc):
    # Bond lengths between H-C and C-C for ethyne (acetylene) cf.
    # CRC Handbook of Chemistry and Physics, 87th ed., p. 9-28
    dhc = 1.060
    dcc = 1.203

    atoms = Atoms([Atom('H', (0, 0, 0)),
                   Atom('C', (dhc, 0, 0)),
                   Atom('C', (dhc+dcc, 0, 0)),
                   Atom('H', (2*dhc+dcc, 0, 0))],
                  pbc=pbc)

    atoms.center(vacuum=2.0)

    # Number of occupied and unoccupied bands to converge
    nbands = int(10/2.0)
    nextra = 3

    #TODO use pbc and cell to calculate nkpts
    kwargs = {}

    if spinpol:
        kwargs['mixer'] = MixerSum(nmaxold=5, beta=0.1, weight=100)
    else:
        kwargs['mixer'] = Mixer(nmaxold=5, beta=0.1, weight=100)

    calc = GPAW(h=0.3,
                nbands=nbands+nextra,
                xc='PBE',
                spinpol=spinpol,
                eigensolver='cg',
                convergence={'energy':1e-4/len(atoms), 'density':1e-5, \
                             'eigenstates': 1e-9, 'bands':-1},
                txt=name+'.txt', **kwargs)

    atoms.set_calculator(calc)
    atoms.get_potential_energy()

    calc.write(name+'.gpw', mode='all')
Exemplo n.º 19
0
def xc(filename, xc, ecut=None):
    """Calculate non self-consitent energy.
    
    filename: str
        Name of restart-file.
    xc: str
        Functional
    ecut: float
        Plane-wave cutoff for exact exchange.
    """
    name, ext = filename.rsplit(".", 1)
    assert ext == "gpw"
    if xc in ["EXX", "PBE0", "B3LYP"]:
        from gpaw.xc.exx import EXX

        exx = EXX(filename, xc, ecut=ecut, txt=name + "-exx.txt")
        exx.calculate()
        e = exx.get_total_energy()
    else:
        from gpaw import GPAW

        calc = GPAW(filename, txt=None)
        e = calc.get_potential_energy() + calc.get_xc_difference(xc)
    print(e, "eV")
Exemplo n.º 20
0
    def setUp(self):
        for virtvar in []:
            assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar

        parsize_domain, parsize_bands = create_parsize_maxbands(self.nbands, world.size)
        self.parallel = {'domain': parsize_domain, 'band': parsize_bands}

        self.atoms = molecule('Na2')
        self.atoms.center(vacuum=4.0)
        self.atoms.set_pbc(False)

        cell_c = np.sum(self.atoms.get_cell()**2, axis=1)**0.5 / Bohr
        ngpts = 16 * np.round(cell_c / (self.h * 16))
        self.gsname = 'ut_tddft_gs'
        self.gscalc = GPAW(gpts=ngpts, nbands=self.nbands, basis='dzp',
                           setups={'Na': '1'},
                           spinpol=(self.nspins==2), parallel=self.parallel,
                           txt=self.gsname + '.txt')
Exemplo n.º 21
0
    def get_dispersion_correction(self, atoms):
        """
        Returns the DFT-D dispersion correction for the current geometry
        """
        #
        # Conversion factors a.u. -> eV
        Eh__2__eV          = 27.211396132
        #
        # Get functional name as string
	self.functional = xc_name(str.lower(GPAW.get_xc_functional(self)))
        #
        # Call DFT-D module: Energy and gradients
        self.dispersion_correction, self.dft_d_gradient_contribution = d2_pbc(atoms, self.functional)
        #
        # Convert to proper units
        self.dispersion_correction       = self.dispersion_correction       * Eh__2__eV
        #
        #
        # Return dispersion correction
        return self.dispersion_correction
Exemplo n.º 22
0
def check_degenerate_bands(filename, etol):

    from gpaw import GPAW
    calc = GPAW(filename,txt=None)
    print('Number of Electrons   :', calc.get_number_of_electrons())
    nibzkpt = calc.get_ibz_k_points().shape[0]
    nbands = calc.get_number_of_bands()
    print('Number of Bands       :', nbands)
    print('Number of ibz-kpoints :', nibzkpt)
    e_kn = np.array([calc.get_eigenvalues(k) for k in range(nibzkpt)])
    f_kn = np.array([calc.get_occupation_numbers(k) for k in range(nibzkpt)])
    for k in range(nibzkpt):
        for n in range(1,nbands):
            if (f_kn[k,n-1] - f_kn[k,n] > 1e-5) and (np.abs(e_kn[k,n] - e_kn[k,n-1]) < etol):
                print(k, n, e_kn[k,n], e_kn[k, n-1])
    return
Exemplo n.º 23
0
    def setUp(self):
        for virtvar in []:
            assert getattr(self, virtvar) is not None, 'Virtual "%s"!' % virtvar

        parsize_domain, parsize_bands = create_parsize_maxbands(self.nbands, world.size)
        self.parallel = {"domain": parsize_domain, "band": parsize_bands}

        self.atoms = molecule("Na2")
        self.atoms.center(vacuum=4.0)
        self.atoms.set_pbc(False)

        cell_c = np.sum(self.atoms.get_cell() ** 2, axis=1) ** 0.5 / Bohr
        ngpts = 16 * np.round(cell_c / (self.h * 16))
        self.gsname = "ut_tddft_gs"
        self.gscalc = GPAW(
            gpts=ngpts,
            nbands=self.nbands,
            basis="dzp",
            setups={"Na": "1"},
            spinpol=(self.nspins == 2),
            parallel=self.parallel,
            txt=self.gsname + ".txt",
        )
Exemplo n.º 24
0
def test():
   
    
     h=4.02
    
     vdw = FFTVDWFunctional(verbose=1)
        
     L=20
     a=3.52
    
     atoms = Atoms(pbc=(True, True, True), cell=(a/sqrt(2), sqrt(6)*a/2.0, L))
     atoms.append(Atom('C',[1.5*a/sqrt(2)*1.0/3,a/sqrt(2)*sqrt(3)/2*1.0/3, L/2+h]))
     atoms.append(Atom('C',[1.5*a/sqrt(2)*2.0/3,a/sqrt(2)*sqrt(3)/2*2.0/3, L/2+h]))
     atoms.append(Atom('C',[a/sqrt(2)/2.0+1.5*a/sqrt(2)*1.0/3,sqrt(6)*a/4.0+a/sqrt(2)*sqrt(3)/2*1.0/3, L/2+h]))
     atoms.append(Atom('C',[a/sqrt(2)/2.0+1.5*a/sqrt(2)*2.0/3-a/sqrt(2),sqrt(6)*a/4.0+a/sqrt(2)*sqrt(3)/2*2.0/3, L/2+h]))
 
 
     atoms.append(Atom('C',[1.5*a/sqrt(2)*1.0/3,a/sqrt(2)*sqrt(3)/2*1.0/3+2.874/2, L/2]))
     atoms.append(Atom('C',[1.5*a/sqrt(2)*2.0/3,a/sqrt(2)*sqrt(3)/2*2.0/3+2.874/2, L/2]))
     atoms.append(Atom('C',[a/sqrt(2)/2.0+1.5*a/sqrt(2)*1.0/3,sqrt(6)*a/4.0+a/sqrt(2)*sqrt(3)/2*1.0/3+2.874/2, L/2]))
     atoms.append(Atom('C',[a/sqrt(2)/2.0+1.5*a/sqrt(2)*2.0/3-a/sqrt(2),sqrt(6)*a/4.0+a/sqrt(2)*sqrt(3)/2*2.0/3+2.874/2, L/2]))
     calc = GPAW(h=0.18, xc='revPBE',kpts=(8,8,1),txt=str(h)+'.txt')
     atoms.set_calculator(calc)
     e2 = atoms.get_potential_energy()
     calc.write('gr_dilayer.gpw')
     e2vdw = calc.get_xc_difference(vdw)
     del atoms[4:]
     e = atoms.get_potential_energy()
     calc.write('gr_dilayer.gpw')
     evdw = calc.get_xc_difference(vdw)
    
     E = 2 * e - e2
     Evdw = E + 2 * evdw - e2vdw
     print E, Evdw
     assert abs(E +0.032131069056 ) < 1e-4
     assert abs(Evdw- 0.144516773316) < 1e-4
Exemplo n.º 25
0
from ase import Atoms
from gpaw import GPAW, PW
from ase.optimize import BFGS
from ase.build import fcc111, add_adsorbate, bulk
from gpaw import GPAW, PW
from ase.io import read, write
from ase.constraints import FixAtoms

adsorbate = Atoms('CO')
adsorbate[1].z = 1.43  #panjang ikatan CO
adsorbate.center(vacuum=5)

c = FixAtoms(indices=[0])
adsorbate.set_constraint(c)

calc = GPAW(mode=PW(750), xc='PBE', parallel={'band': 1}, txt='relax-co.txt')
adsorbate.calc = calc
adsorbate.get_potential_energy()

relax = BFGS(adsorbate, logfile='bfgs.log', trajectory='co.traj')
relax.run(fmax=0.05)
Exemplo n.º 26
0
filename = 'atoms_'+name+'.dat'

f = paropen(filename,'w')

elements = ['N']

for symbol in elements:
    mixer = Mixer()

    eigensolver = CG(tw_coeff=lambda_coeff)
    
    poissonsolver=PoissonSolver()
    molecule = Atoms(symbol,
                     positions=[(c,c,c)] ,
                     cell=(a,a,a))
    
    calc = GPAW(h=h,
                xc=xcname,
                maxiter=240,
                eigensolver=eigensolver,
                mixer=mixer,
                setups=name,
                poissonsolver=poissonsolver)
        
    molecule.set_calculator(calc)

    E = molecule.get_total_energy()

    f.write('{0}\t{1}\n'.format(symbol,E))
Exemplo n.º 27
0
#!/usr/bin/env python
import numpy as np

from ase import Atom, Atoms
from ase.parallel import rank

from gpaw import GPAW
from gpaw.test import equal

try:
    calc = GPAW('NaCl.gpw')
    NaCl = calc.get_atoms()
    e = NaCl.get_potential_energy()
    niter = None
except IOError:
    h = 0.21  # gridspacing
    a = [6.5, 6.5, 7.7]  # unit cell
    d = 2.3608  # experimental bond length

    NaCl = Atoms(
        [Atom('Na', [0, 0, 0]), Atom('Cl', [0, 0, d])], pbc=False, cell=a)
    NaCl.center()
    calc = GPAW(h=h,
                xc='LDA',
                nbands=5,
                lmax=0,
                convergence={'eigenstates': 1e-6},
                spinpol=1)

    NaCl.set_calculator(calc)
    e = NaCl.get_potential_energy()
Exemplo n.º 28
0
from ase import Atoms
from ase.parallel import paropen
from gpaw import GPAW
from gpaw.wavefunctions.pw import PW

resultfile = paropen('H.ralda.DFT_corr_energies.txt', 'w')
resultfile.write('DFT Correlation energies for H atom\n')

H = Atoms('H', [(0, 0, 0)])
H.set_pbc(True)
H.center(vacuum=2.0)
calc = GPAW(mode=PW(300, force_complex_dtype=True),
            parallel={'domain': 1},
            hund=True,
            txt='H.ralda_01_lda.output.txt',
            xc='LDA')

H.set_calculator(calc)
E_lda = H.get_potential_energy()
E_c_lda = -calc.get_xc_difference('LDA_X')

resultfile.write('LDA correlation: %s eV' % E_c_lda)
resultfile.write('\n')

calc.diagonalize_full_hamiltonian()
calc.write('H.ralda.lda_wfcs.gpw', mode='all')
Exemplo n.º 29
0
from ase import Atoms
from ase.build import fcc111, add_adsorbate, bulk
from ase.io import read, write
from gpaw import GPAW, PW

a = 3.597  #lattice Cu
slab = fcc111('Cu', (1, 1, 3), a=a, vacuum=10.0)

for k in range(2, 11, 1):
    calc = GPAW(mode=PW(850),
                xc='PBE',
                kpts=(k, k, 1),
                parallel={'band': 1},
                txt='scf-k_%d.txt' % k)
    slab.calc = calc
    slab.get_potential_energy()
Exemplo n.º 30
0
from ase.build import bulk
from gpaw import GPAW, PW, FermiDirac
from ase.units import Bohr, Hartree
import numpy as np

atoms = bulk("Si", "diamond", a=10.2631 * Bohr)

ecutwfc = 15.0 * Hartree

for kden in np.linspace(1.0, 5.0, 9):
    calc = GPAW(mode=PW(ecutwfc),
                occupations=FermiDirac(0.0),
                kpts={"density": kden},
                txt="LOG_kden_v2_" + str(kden))
    atoms.set_calculator(calc)

    etot = atoms.get_potential_energy()
    print("%6.3f  %18.10f  %18.10f" % (kden, etot, etot / Hartree))
Exemplo n.º 31
0
    # Set calculator
    # 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
    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
    #print('relaxgpaw over',flush=True)
    return structure


calc = GPAW(mode=PW(500), xc='PBE', basis='dzp', kpts=(3, 3, 1))

traj = Trajectory('V2O5_2H2OTiO2_101_DFTrelaxed.traj', 'w')
name = 'V2O5_2H2OTiO2_101surface_gm'
data = read('V2O5_2H2O_TiO2_I3s.traj@:')
for i in range(0, len(data)):
    name = 'V2O5_2H2OTiO2_101surface_isomer_{}'.format(i)
    a = data[i]
    a.set_calculator(calc)
    a_relaxed = relaxGPAW(a, name, forcemax=0.01, niter_max=2, steps=100)
    traj.write(a_relaxed)
Exemplo n.º 32
0
from ase.constraints import ExpCellFilter
from ase.io import write
from ase.optimize import BFGS
from ase.spacegroup import crystal
from gpaw import GPAW, PW

a = 4.6
c = 2.95

# Rutile TiO2:
atoms = crystal(['Ti', 'O'],
                basis=[(0, 0, 0), (0.3, 0.3, 0.0)],
                spacegroup=136,
                cellpar=[a, a, c, 90, 90, 90])
write('rutile.traj', atoms)

calc = GPAW(mode=PW(800), kpts=[2, 2, 3], txt='gpaw.rutile.txt')
atoms.calc = calc

opt = BFGS(ExpCellFilter(atoms), trajectory='opt.rutile.traj')
opt.run(fmax=0.05)

calc.write('groundstate.rutile.gpw')

print('Final lattice:')
print(atoms.cell.get_bravais_lattice())
Exemplo n.º 33
0
from gpaw.lrtddft import LrTDDFT, photoabsorption_spectrum
from gpaw.lrtddft.kssingle import KSSingles
from cStringIO import StringIO

L = 10.0
txt=None
txt='-'

N2 = molecule('N2')
N2.set_cell([L, L, L])
#N2.set_pbc(True)
N2.center()

try:
    calc = GPAW('N2_wfs.gpw', 
                txt=txt, 
                parallel={'domain': world.size})
    calc.converge_wave_functions()
except:
    calc = GPAW(h=0.25,
                nbands=-5,
                spinpol=True,
                xc='PBE',
                txt=txt,
                eigensolver='cg',
                parallel={'domain': world.size})
    N2.set_calculator(calc)
    E0 = N2.get_potential_energy()
    calc.write('N2_wfs.gpw', 'all')

# selections
Exemplo n.º 34
0
#!/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)
Exemplo n.º 35
0
import numpy as np
from ase.lattice import bulk
from gpaw import GPAW
from gpaw.response.df import DielectricFunction

# Part 1: Ground state calculation
atoms = bulk('Si', 'diamond', a=5.431)   # Generate diamond crystal structure for silicon
calc = GPAW(mode='pw', kpts=(4,4,4))     # GPAW calculator initialization
 
atoms.set_calculator(calc)               
atoms.get_potential_energy()             # Ground state calculation is performed
calc.write('si.gpw', 'all')              # Use 'all' option to write wavefunction

# Part 2 : Spectrum calculation          # DF: dielectric function object
df = DielectricFunction(calc='si.gpw',   # Ground state gpw file (with wavefunction) as input
                        domega0=0.05)    # Using nonlinear frequency grid
df.get_dielectric_function()             # By default, a file called 'df.csv' is generated

Exemplo n.º 36
0

    atoms = sys.argv[5]
    atoms = int(atoms)
    bulk_mat = bulk('Cu','fcc',a)*(atoms,atoms,atoms)


    is_varying = str(sys.argv[6])

    if (str(sys.argv[8]) == 'True'):

        del bulk_mat[[atom.index for atom in bulk_mat if atom.index == 0]]

    #view(bulk_mat)
    #time.sleep(3600)
    calc = GPAW(mode=PW(e_cut), nbands = nbands,
                xc='PBE', kpts=(k_pts,k_pts,k_pts),
                occupations=FermiDirac(smear), txt='Cu.out')


    bulk_mat.set_calculator(calc)

    traj = Trajectory('some_test.traj', 'w', bulk_mat)
    relaxer = PreconLBFGS(bulk_mat, variable_cell = True, logfile = 'my_log.txt')
    relaxer.attach(traj)
    relaxer.run(fmax = 0.025, smax = 0.003)

    bulk_mat.get_potential_energy()
    calc.write('Cu.gpw')
    save_atoms(bulk_mat, e_cut, nbands, k_pts, smear, a, is_varying, str(sys.argv[7]))
Exemplo n.º 37
0
## try:
##     import Scientific.IO.NetCDF
##     endings.append('nc')
## except ImportError:
##     pass

for ending in endings:
    restart_wf = 'gpaw-restart-wf.' + ending
    # H2
    H = Atoms([Atom('H', (0, 0, 0)), Atom('H', (0, 0, 1))])
    H.center(vacuum=2.0)

    if 1:
        calc = GPAW(nbands=2,
                    convergence={
                        'eigenstates': 0.001,
                        'energy': 0.1,
                        'density': 0.1
                    })
        H.set_calculator(calc)
        H.get_potential_energy()
        calc.write(restart_wf, 'all')

        # refine the result directly
        calc.set(convergence={'energy': 0.00001})
        Edirect = H.get_potential_energy()

    # refine the result after reading from a file
    H = GPAW(restart_wf, convergence={'energy': 0.00001}).get_atoms()
    Erestart = H.get_potential_energy()

    print Edirect, Erestart
Exemplo n.º 38
0
'Test ase.dft.wannier module with k-points.'
from __future__ import print_function

from ase.build import bulk
from ase.dft.wannier import Wannier

from gpaw import GPAW
from gpaw.mpi import world, serial_comm

si = bulk('Si', 'diamond', a=5.43)

k = 2
if 1:
    si.calc = GPAW(kpts=(k, k, k), mode='lcao', txt='Si-ibz.txt')
    #si.calc = GPAW(kpts=(k, k, k), mode='lcao')
    e1 = si.get_potential_energy()
    si.calc.write('Si-ibz', mode='all')
    #si.calc.set(symmetry='off', txt='Si-bz.txt')
    #si.calc.set(symmetry='off')
    #e2 = si.get_potential_energy()
    #si.calc.write('Si-bz', mode='all')
    #print e1, e2


def wan(calc):
    centers = [([0.125, 0.125, 0.125], 0, 1.5), ([0.125, 0.625,
                                                  0.125], 0, 1.5),
               ([0.125, 0.125, 0.625], 0, 1.5), ([0.625, 0.125,
                                                  0.125], 0, 1.5)]
    w = Wannier(4, calc, nbands=4, verbose=False, initialwannier=centers)
    w.localize()
Exemplo n.º 39
0
    # plot orthogonal to bond axis through H2
    ax[1][1].set_title(
        r'Plane of $ -\frac{1}{2} \nabla^2 \rho^{1/2} $ orthogonal to bond axis at H2'
    )
    ax[1][1].set_xlabel(r'cell axis x')
    ax[1][1].set_ylabel(r'cell axis y')
    ax[1][1].set_xlim(x1z, x2z)
    ax[1][1].set_ylim(y1z, y2z)
    ax[1][1].contour(func_obj.coordinates[0], func_obj.coordinates[1],
                     z_plane_kin_o_bond_h2)
    ax[1][1].scatter(pos_z[1], pos_z[0], c='red')


# load results from GPAW calculation
calc2 = GPAW('/home/misa/APDFT/prototyping/gpaw/OFDFT/result_64_gpts.gpw')

# cell width in Bohr
cell_vectors = calc2.atoms.cell
a_x = cell_vectors[0][0]
a_y = cell_vectors[1][1]
a_z = cell_vectors[2][2]

###############################################################################

# create func object for sqrt of coarse pseudo density and apply own kinetic energy operator to sqrt(density)
sqrt_pseudo_dens = np.sqrt(
    calc2.density.nt_sG[0])  # sqrt of pseudo density on coarse grid
kwargs_pseuod_dens = {
    'func_value': sqrt_pseudo_dens,
    'length_cell': [a_x, a_y, a_z]
Exemplo n.º 40
0
from ase.build import molecule
from ase import io
from gpaw import GPAW

txt = 'out.txt'
if 1:
    calculator = GPAW(h=0.3, txt=txt)
    atoms = molecule('H2', calculator=calculator)
    atoms.center(vacuum=3)
    atoms.get_potential_energy()

    atoms.set_initial_magnetic_moments([0.5, 0.5])
    calculator.set(charge=1)
    atoms.get_potential_energy()

# read again
t = io.read(txt, index=':')
assert isinstance(t, list)
M = t[1].get_magnetic_moments()
assert abs(M - 0.2).max() < 0.1
Exemplo n.º 41
0

atoms = Atoms(symbols=myGpaw.symstr,
             pbc=[ True,  True,  True],
             cell=myGpaw.gcell,
             positions=myGpaw.pos
                    )
# view(atoms)
kpts={'size': (4, 4, 4), 'gamma': True}
calc = GPAW(#h=0.16,
            mode=PW(900),
            kpts=kpts,
            xc='PBE',
            txt=myGpaw.symstr+'_900.out',
            occupations=FermiDirac(width=0.05),
          #   nbands=-2,
            convergence={'energy': 0.0005,  # eV / electron
               'density': 1.0e-4,
               'eigenstates': 4.0e-8,  # eV^2 / electron
               'bands': 'CBM+2.0',
               'forces': float('inf')} # eV / Ang Max
            )

atoms.calc = calc
e2 = atoms.get_potential_energy()
d0 = atoms.get_distance(0, 1)

fd = open('optimization.txt', 'w')
print('experimental bond length:', file=fd)
print('hydrogen molecule energy: %5.2f eV' % e2, file=fd)
print('bondlength              : %5.2f Ang' % d0, file=fd)
Exemplo n.º 42
0
struct = elem_list[1]
print("struct = ", struct)
nbnd = int(elem_list[2])
print("nbands = ", nbnd)
spath = elem_list[3]
print("path = ", spath)
nkpts = elem_list[4]
print("kpts = ", nkpts)
kpts = ast.literal_eval(nkpts)

# First perform a regular SCF run
calc = GPAW(
    mode=PW(400),
    maxiter=200,
    spinpol=False,
    kpts=kpts,
    xc=xc,
    txt='-',
    occupations=FermiDirac(0.02),
    mixer=Mixer(0.05, 8, 100),
)

atoms = bulk(element, struct)
# sc,fcc,bcc,tetragonal,bct,hcp,rhmbohedral,orthorhombic
# mlc, diamond,zincblende,rocksalt,cesiumchloride, fluorite, wurtzite
atoms.set_calculator(calc)
atoms.get_potential_energy()

# Get the valence band maximum
efermi = calc.get_fermi_level()
Nk = len(calc.get_ibz_k_points())
Ns = calc.get_number_of_spins()
Exemplo n.º 43
0
class GWBands:
    """This class defines the GW_bands properties"""

    def __init__(self,
                 calc=None,
                 comm=None,
                 gw_file=None,
                 kpoints=None,
                 bandrange=None):

        self.calc = GPAW(calc, communicator=comm, txt=None)
        if gw_file is not None:
            self.gw_file = pickle.load(open(gw_file, 'rb'),encoding='bytes')
        self.kpoints = kpoints
        if bandrange is None:
            self.bandrange = np.arange(self.calc.get_number_of_bands())
        else:
            self.bandrange = bandrange

        self.gd = self.calc.wfs.gd.new_descriptor()
        self.kd = self.calc.wfs.kd

        self.acell_cv = self.gd.cell_cv
        self.bcell_cv = 2 * np.pi * self.gd.icell_cv
        self.vol = self.gd.volume
        self.BZvol = (2 * np.pi)**3 / self.vol

    def find_k_along_path(self, plot_BZ=True):
        """Finds the k-points along the bandpath present in the
           original calculation"""
        kd = self.kd
        acell_cv = self.acell_cv
        bcell_cv = self.bcell_cv
        kpoints = self.kpoints

        if plot_BZ:
            """Plotting the points in the Brillouin Zone"""
            kp_1bz = to1bz(kd.bzk_kc, acell_cv)

            bzk_kcv = np.dot(kd.bzk_kc, bcell_cv)
            kp_1bz_v = np.dot(kp_1bz, bcell_cv)

            import matplotlib.pyplot as plt
            plt.plot(bzk_kcv[:, 0], bzk_kcv[:, 1], 'xg')
            plt.plot(kp_1bz_v[:, 0], kp_1bz_v[:, 1], 'ob')
            for ik in range(1, len(kpoints)):
                kpoint1_v = np.dot(kpoints[ik], bcell_cv)
                kpoint2_v = np.dot(kpoints[ik - 1], bcell_cv)
                plt.plot([kpoint1_v[0], kpoint2_v[0]], [kpoint1_v[1],
                                                        kpoint2_v[1]], '--vr')

        """Finding the points along given directions"""
        print('Finding the kpoints along the path')
        N_c = kd.N_c
        wpts_xc = kpoints

        x_x = []
        k_xc = []
        k_x = []
        x = 0.
        X = []
        for nwpt in range(1, len(wpts_xc)):
            X.append(x)
            to_c = wpts_xc[nwpt]
            from_c = wpts_xc[nwpt - 1]
            vec_c = to_c - from_c
            print('From ', from_c, ' to ', to_c)
            Nv_c = (vec_c * N_c).round().astype(int)
            Nv = abs(gcd(gcd(Nv_c[0], Nv_c[1]), Nv_c[2]))
            print(Nv, ' points found')
            dv_c = vec_c / Nv
            dv_v = np.dot(dv_c, bcell_cv)
            dx = np.linalg.norm(dv_v)
            if nwpt == len(wpts_xc) - 1:
                # X.append(Nv * dx)
                Nv += 1
            for n in range(Nv):
                k_c = from_c + n * dv_c
                bzk_c = to1bz(np.array([k_c]), acell_cv)[0]
                ikpt = kd.where_is_q(bzk_c, kd.bzk_kc)
                x_x.append(x)
                k_xc.append(k_c)
                k_x.append(ikpt)
                x += dx
        X.append(x_x[-1])
        if plot_BZ is True:
            for ik in range(len(k_xc)):
                ktemp_xcv = np.dot(k_xc[ik], bcell_cv)
                plt.plot(ktemp_xcv[0], ktemp_xcv[1], 'xr', markersize=10)
            plt.show()

        return x_x, k_xc, k_x, X

    def get_dft_eigenvalues(self):
        Nk = len(self.calc.get_ibz_k_points())
        bands = np.arange(self.bandrange[0], self.bandrange[-1])
        e_kn = np.array([self.calc.get_eigenvalues(kpt=k)[bands]
                         for k in range(Nk)])
        return e_kn

    def get_vacuum_level(self, plot_pot=False):
        """Finds the vacuum level through Hartree potential"""
        vHt_g = self.calc.get_electrostatic_potential()
        vHt_z = np.mean(np.mean(vHt_g, axis=0), axis=0)

        if plot_pot:
            import matplotlib.pyplot as plt
            plt.plot(vHt_z)
            plt.show()
        return vHt_z[0]

    def get_spinorbit_corrections(self, return_spin=True, return_wfs=False,
                                  bands=None, gwqeh_file=None, dft=False,
                                  eig_file=None):
        """Gets the spinorbit corrections to the eigenvalues"""
        calc = self.calc
        bandrange = self.bandrange

        if not dft:
            try:
                e_kn = self.gw_file['qp'][0]
            except:
                e_kn = self.gw_file[b'qp'][0]
        else:
            if eig_file is not None:
                e_kn = pickle.load(open(eig_file))[0]
            else:
                e_kn = self.get_dft_eigenvalues()[:,bandrange[0]:bandrange[-1]]

        eSO_nk, s_nk, v_knm = get_spinorbit_eigenvalues(
            calc,
            return_spin=return_spin, return_wfs=return_wfs,
            bands=range(bandrange[0], bandrange[-1]+1),
            gw_kn=e_kn)

        e_kn = eSO_nk.T
        return e_kn, v_knm

    def get_gw_bands(self, nk_Int=50, interpolate=False, SO=False,
                     gwqeh_file=None, dft=False, eig_file=None, vac=False):
        """Getting Eigenvalues along the path"""
        kd = self.kd
        if SO:
            e_kn, v_knm = self.get_spinorbit_corrections(return_wfs=True,
                                                         dft=dft,
                                                         eig_file=eig_file)
            if gwqeh_file is not None:
                gwqeh_file = pickle.load(open(gwqeh_file))
                eqeh_noSO_kn = gwqeh_file['qp_sin'][0] * Ha
                eqeh_kn = np.zeros_like(e_kn)
                eqeh_kn[:, ::2] = eqeh_noSO_kn
                eqeh_kn[:, 1::2] = eqeh_noSO_kn

                e_kn += eqeh_kn

        elif gwqeh_file is not None:
            gwqeh_file = pickle.load(open(gwqeh_file))
            e_kn = gwqeh_file['Qp_sin'][0] * Ha
        elif eig_file is not None:
            e_kn = pickle.load(open(eig_file))[0]
        else:
            if not dft:
                try:
                    e_kn = self.gw_file['qp'][0]
                except:
                    e_kn = self.gw_file[b'qp'][0]
            else:
                e_kn = self.get_dft_eigenvalues()
        e_kn = np.sort(e_kn, axis=1)

        bandrange = self.bandrange
        ef = self.calc.get_fermi_level()
        if vac:
            evac = self.get_vacuum_level()
        else:
            evac = 0.0
        x_x, k_xc, k_x, X = self.find_k_along_path(plot_BZ=False)

        k_ibz_x = np.zeros_like(k_x)
        eGW_kn = np.zeros((len(k_x), e_kn.shape[1]))
        for n in range(e_kn.shape[1]):
            for ik in range(len(k_x)):
                ibzkpt = kd.bz2ibz_k[k_x[ik]]
                k_ibz_x[ik] = ibzkpt
                eGW_kn[ik, n] = e_kn[ibzkpt, n]

        N_occ = (eGW_kn[0] < ef).sum()
        print(N_occ, bandrange[0])
        # N_occ = int(self.calc.get_number_of_electrons()/2)
        print(' ')
        if SO:
            print('The number of Occupied bands is:', N_occ + 2.*bandrange[0])
        else:
            print('The number of Occupied bands is:', N_occ + bandrange[0])
        gap = (eGW_kn[:, N_occ].min() - eGW_kn[:, N_occ - 1].max())
        print('The bandgap is: %f' % gap)

        vbm = eGW_kn[:, N_occ - 1].max() - evac
        cbm = eGW_kn[:, N_occ].min() - evac

        if interpolate:
            xfit_k = np.linspace(x_x[0], x_x[-1], nk_Int)
            xfit_k = np.append(xfit_k, x_x)
            xfit_k = np.sort(xfit_k)
            nk_Int = len(xfit_k)
            efit_kn = np.zeros((nk_Int, eGW_kn.shape[1]))
            for n in range(eGW_kn.shape[1]):
                fit_e = InterpolatedUnivariateSpline(x_x, eGW_kn[:, n])
                efit_kn[:, n] = fit_e(xfit_k)

            results = {'x_k': xfit_k,
                       'X': X,
                       'e_kn': efit_kn - evac,
                       'ef': ef - evac,
                       'gap': gap,
                       'vbm': vbm,
                       'cbm': cbm}

            return results
        else:
            results = {'x_k': x_x,
                       'X': X,
                       'k_ibz_x': k_ibz_x,
                       'e_kn': eGW_kn - evac,
                       'ef': ef - evac,
                       'gap': gap,
                       'vbm': vbm,
                       'cbm': cbm}
            return results
Exemplo n.º 44
0
import numpy as np
from ase import Atoms
from ase.units import Bohr
from gpaw.jellium import JelliumSlab
from gpaw import GPAW, PW

rs = 5.0 * Bohr  # Wigner-Seitz radius
h = 0.2  # grid-spacing
a = 8 * h  # lattice constant
v = 3 * a  # vacuum
L = 10 * a  # thickness
k = 12  # number of k-points (k*k*1)

ne = a**2 * L / (4 * np.pi / 3 * rs**3)

jellium = JelliumSlab(ne, z1=v, z2=v + L)

surf = Atoms(pbc=(True, True, False), cell=(a, a, v + L + v))
surf.calc = GPAW(mode=PW(400.0),
                 background_charge=jellium,
                 xc='LDA_X+LDA_C_WIGNER',
                 eigensolver='dav',
                 kpts=[k, k, 1],
                 h=h,
                 convergence={'density': 0.001},
                 nbands=int(ne / 2) + 15,
                 txt='surface.txt')
e = surf.get_potential_energy()
surf.calc.write('surface.gpw')
Exemplo n.º 45
0
atoms.center()
atoms.set_pbc(1)
r = [1, 1, 1]
atoms = atoms.repeat(r)
n = [240 * ri for ri in r]
# nbands (>=1683) is the number of bands per cluster
nbands = 3 * 6 * 6 * 16  # 1728
for ri in r:
    nbands = nbands * ri
mixer = Mixer(beta=0.1, nmaxold=5, weight=100.0)
# the next three lines decrease memory usage
es = RMMDIIS(keep_htpsit=False)
calc = GPAW(
    nbands=nbands,
    # uncomment next two lines to use lcao/sz
    # mode='lcao',
    # basis='sz',
    gpts=tuple(n),
    maxiter=5,
    width=0.1,
    xc='LDA',
    mixer=mixer,
    eigensolver=es,
    txt=prefix + '.txt')

atoms.set_calculator(calc)
try:
    pot = atoms.get_potential_energy()
except ConvergenceError:
    pass
Exemplo n.º 46
0
from gpaw.poisson import PoissonSolver
from gpaw.lcaotddft.dipolemomentwriter import DipoleMomentWriter
from gpaw.lcaotddft.wfwriter import WaveFunctionWriter
from gpaw.tddft.spectrum import photoabsorption_spectrum
from gpaw.mpi import world

from gpaw.test import equal

# Atoms
atoms = molecule('Na2')
atoms.center(vacuum=4.0)

# Ground-state calculation
calc = GPAW(nbands=2, h=0.4, setups=dict(Na='1'),
            basis='dzp', mode='lcao',
            poissonsolver=PoissonSolver(eps=1e-16),
            convergence={'density': 1e-8},
            txt='gs.out')
atoms.set_calculator(calc)
energy = atoms.get_potential_energy()
calc.write('gs.gpw', mode='all')

# Time-propagation calculation
td_calc = LCAOTDDFT('gs.gpw', txt='td.out')
DipoleMomentWriter(td_calc, 'dm.dat')
WaveFunctionWriter(td_calc, 'wf.ulm')
WaveFunctionWriter(td_calc, 'wf_split.ulm', split=True)
td_calc.absorption_kick(np.ones(3) * 1e-5)
td_calc.propagate(20, 3)
td_calc.write('td.gpw', mode='all')
td_calc.propagate(7, 3)
Exemplo n.º 47
0
a = 5.404
bulk = Atoms(symbols='Si8',
             scaled_positions=[(0, 0, 0),
                               (0, 0.5, 0.5),
                               (0.5, 0, 0.5),
                               (0.5, 0.5, 0),
                               (0.25, 0.25, 0.25),
                               (0.25, 0.75, 0.75),
                               (0.75, 0.25, 0.75),
                               (0.75, 0.75, 0.25)],
             pbc=True, cell=(a, a, a))
n = 20
calc = GPAW(gpts=(n, n, n),
            nbands=8 * 3,
            occupations=FermiDirac(width=0.01),
            verbose=1,
            kpts=(1, 1, 1))
bulk.set_calculator(calc)
e1 = bulk.get_potential_energy()
niter1 = calc.get_number_of_iterations()
eigs = calc.get_eigenvalues(kpt=0)
calc.write('temp.gpw')

bulk, calc = restart('temp.gpw', fixdensity=True)
e2 = bulk.get_potential_energy()
eigs2 = calc.get_eigenvalues(kpt=0)
print('Orginal', eigs)
print('Fixdensity', eigs2)
print('Difference', eigs2 - eigs)
Exemplo n.º 48
0
    density_number = int(sys.argv[3])
    #density_number = 5.4, 1.37
    k_pts = {'density': density_number, 'even': True}
    smear = 0.1
    system_id = int((sys.argv[1]))
    system_name = 'fesi_id' + str(system_id)
    final_db = str(sys.argv[2])

    print(time.strftime("%d/%m/%Y"))
    print(time.strftime("%H:%M:%S"))
    print('The id for this script is: ' + str(system_id))

    calc = GPAW(mode=PW(e_cut),
                nbands=nbands,
                xc='PBE',
                spinpol=True,
                kpts=k_pts,
                occupations=FermiDirac(smear),
                txt=system_name + '.out')

    if os.path.isfile('./' + system_name + '.gpw'):
        #Recover past done calculations if available
        #bulk_mat, calc = restart(system_name + '.gpw', txt = None)
        #bulk_mat.set_calculator(calc)
        traj = Trajectory(system_name + '.traj')
        bulk_mat = traj[-1]
        bulk_mat.set_calculator(calc)

    else:
        #Initialize new calculations
        db = connect(final_db)
Exemplo n.º 49
0
Arquivo: logo.py Projeto: uu1477/MyAse
d = 1.2

logo = Atoms()
for i, line in enumerate(ase.split('\n')):
    for j, c in enumerate(line):
        if c == 'H':
            logo.append(Atom('H', [d * j, d * i, 0]))
logo.set_cell((15, 15, 2))
logo.center()
#logo.center(vacuum=2.0)

#view(logo)

if 1:
    from gpaw import GPAW
    calc = GPAW()
    logo.set_calculator(calc)
    e = logo.get_potential_energy()
    calc.write('logo2.gpw')
if 0:
    from gpaw import GPAW
    calc = GPAW('logo2.gpw', idiotproof=0)


if 1:
    print(calc.density.nt_sg.shape)
    n = calc.density.nt_sg[0, :, :, 10]
    #1c4e63
    c0 = np.array([19, 63, 82.0]).reshape((3, 1, 1)) / 255
    c1 = np.array([1.0, 1, 0]).reshape((3, 1, 1))
    a = c0 + n / n.max() * (c1 - c0)
Exemplo n.º 50
0
from gpaw import GPAW, restart
from gpaw.test import gen
from gpaw import setup_paths
from gpaw.mpi import world

xc = 'GLLBSC'
gen('C', xcname=xc)
setup_paths.insert(0, '.')

# Calculate ground state
atoms = bulk('C', 'diamond', a=3.567)
# We want sufficiently many grid points that the calculator
# can use wfs.world for the finegd, to test that part of the code.
calc = GPAW(h=0.2,
            kpts=(4, 4, 4),
            xc=xc,
            nbands=8,
            parallel=dict(domain=min(world.size, 2), band=1),
            eigensolver=Davidson(niter=4))
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write('Cgs.gpw')

# Calculate accurate KS-band gap from band structure
calc = GPAW('Cgs.gpw',
            kpts={
                'path': 'GX',
                'npoints': 12
            },
            fixdensity=True,
            symmetry='off',
            nbands=8,
Exemplo n.º 51
0
from gpaw import GPAW, Mixer, FermiDirac

tag = 'Ru001'

adsorbate_heights = {'H': 1.0, 'N': 1.108, 'O': 1.257}

slab = hcp0001('Ru', size=(2, 2, 4), a=2.72, c=1.58*2.72, vacuum=7.0,
               orthogonal=True)
slab.center(axis=2)

if len(argv) > 1:
    adsorbate = argv[1]
    tag = adsorbate + tag
    add_adsorbate(slab, adsorbate, adsorbate_heights[adsorbate], 'hcp')

slab.set_constraint(FixAtoms(mask=slab.get_tags() >= 3))

calc = GPAW(xc='PBE',
            h=0.2,
            mixer=Mixer(0.1, 5, weight=100.0),
            stencils=(3, 3),
            occupations=FermiDirac(width=0.1),
            kpts=[4, 4, 1],
            eigensolver='cg',
            txt=tag + '.txt')
slab.set_calculator(calc)
  
opt = LBFGS(slab, logfile=tag + '.log', trajectory=tag + '.traj')
opt.run(fmax=0.05)
calc.write(tag)
Exemplo n.º 52
0
from __future__ import print_function
from ase import Atoms
from gpaw import GPAW
from gpaw.test import equal

s = Atoms('Cl')
s.center(vacuum=3)
c = GPAW(xc={'name': 'PBE', 'stencil': 1}, nbands=-4, charge=-1, h=0.3)
s.set_calculator(c)

e = s.get_potential_energy()
niter = c.get_number_of_iterations()

print(e, niter)
energy_tolerance = 0.0003
niter_tolerance = 0
equal(e, -2.89336, energy_tolerance)
Exemplo n.º 53
0
    from ase.build import molecule

    #s = UPFSetupData('/home/askhl/parse-upf/h_lda_v1.uspp.F.UPF')

    upfsetups = {
        'H': UPFSetupData('H.pz-hgh.UPF'),
        'O': UPFSetupData('O.pz-hgh.UPF')
    }

    system = molecule('H2O')
    system.center(vacuum=3.5)
    calc = GPAW(
        txt='-',
        nbands=6,
        setups=upfsetups,
        #setups='paw',
        #hund=True,
        #mixer=MixerSum(0.1, 5, 20.0),
        #eigensolver='cg',
        #occupations=FermiDirac(0.1),
        #charge=1-1e-12,
        #eigensolver='rmm-diis',
        gpts=h2gpts(0.12, system.get_cell(), idiv=8),
        poissonsolver=PoissonSolver(relax='GS', eps=1e-7),
        xc='oldLDA',
        #nbands=4
    )

    system.set_calculator(calc)
    system.get_potential_energy()
Exemplo n.º 54
0
from gpaw import GPAW

calc = GPAW('groundstate.rutile.gpw')
atoms = calc.get_atoms()
path = atoms.cell.bandpath(density=7)
path.write('path.rutile.json')

calc.set(kpts=path, fixdensity=True, symmetry='off')

atoms.get_potential_energy()
bs = calc.band_structure()
bs.write('bs.rutile.json')
Exemplo n.º 55
0
# Initial state:
# 2x2-Al(001) surface with 1 layer and an
# Au atom adsorbed in a hollow site:
slab = fcc100('Al', size=(2, 2, 2))
slab.center(axis=2, vacuum=3.0)
add_adsorbate(slab, 'Au', 1.6, 'hollow')

# Make sure the structure is correct:
view(slab)

# Fix the Al atoms:
mask = [atom.symbol == 'Al' for atom in slab]
print(mask)
fixlayer = FixAtoms(mask=mask)
slab.set_constraint(fixlayer)

# Use GPAW:
calc = GPAW(mode=PW(200), kpts=(2, 2, 1), xc='PBE', txt='hollow.txt')
slab.set_calculator(calc)

qn = QuasiNewton(slab, trajectory='hollow.traj')

# Find optimal height.  The stopping criterion is: the force on the
# Au atom should be less than 0.05 eV/Ang
qn.run(fmax=0.05)

calc.write('hollow.gpw')  # Write gpw output after the minimization

print('energy:', slab.get_potential_energy())
print('height:', slab.positions[-1, 2] - slab.positions[0, 2])
Exemplo n.º 56
0
Arquivo: h.py Projeto: thonmaker/gpaw
from ase.build import molecule
from gpaw import GPAW, PW
from gpaw.mpi import world

a = molecule('H', pbc=1)
a.center(vacuum=2)

comm = world.new_communicator([world.rank])
e0 = 0.0
a.calc = GPAW(mode=PW(250), communicator=comm, txt=None)
e0 = a.get_potential_energy()
e0 = world.sum(e0) / world.size

a.calc = GPAW(mode=PW(250),
              eigensolver='rmm-diis',
              basis='szp(dzp)',
              txt='%d.txt' % world.size)
e = a.get_potential_energy()
f = a.get_forces()
assert abs(e - e0) < 7e-5, abs(e - e0)
assert abs(f).max() < 1e-10, abs(f).max()
Exemplo n.º 57
0
from __future__ import print_function
import numpy as np
from ase import Atoms
from gpaw import GPAW
from gpaw.test import equal

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)):
Exemplo n.º 58
0
from __future__ import print_function
import numpy as np
import ase.units as units
from gpaw import restart, GPAW
from gpaw.poisson import PoissonSolver
from gpaw.dipole_correction import DipoleCorrection

energies = []
for name in ['zero', 'periodic', 'corrected']:
    if name == 'corrected':
        calc = GPAW(name,
                    txt=None,
                    poissonsolver=DipoleCorrection(PoissonSolver(), 2))
    else:
        calc = GPAW(name, txt=None)

    energies.append(calc.get_potential_energy())

print(energies)
assert abs(energies[1] - energies[0]) < 0.003
assert abs(energies[2] - energies[0] - 0.0409) < 0.003

efermi = calc.get_fermi_level()
calc.restore_state()
v = (calc.hamiltonian.vHt_g * units.Hartree).mean(0).mean(0)
w1 = v[0] - efermi
w2 = v[-1] - efermi
print(w1, w2)
assert abs(w1 - 4.359) < 0.01
assert abs(w2 - 2.556) < 0.01
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
Exemplo n.º 60
0
from gpaw import GPAW, restart, FD
from ase.build import molecule
from gpaw.test import equal
Eini0 = -17.8037610364
energy_eps = 0.0005
esolvers = ['cg', 'rmm-diis', 'dav']

calc = GPAW(xc='LDA',
            h=0.21,
            eigensolver='cg',
            convergence={'eigenstates': 3.5e-5, 'energy': energy_eps},
            mode=FD(force_complex_dtype=True))

mol = molecule('N2')
mol.center(vacuum=3.0)
mol.set_calculator(calc)

Eini = mol.get_potential_energy()
Iini = calc.get_number_of_iterations()
print('%10s: %12.6f eV in %3d iterations' % ('init(cg)', Eini, Iini))
equal(Eini, Eini0, energy_eps * calc.get_number_of_electrons())

calc.write('N2_complex.gpw', mode='all')

for esolver in esolvers:
    mol, calc = restart('N2_complex.gpw')

    assert calc.wfs.dtype == complex
    assert calc.wfs.kpt_u[0].psit_nG.dtype == complex
    
    calc.set(convergence={'eigenstates': 3.5e-9, 'energy': energy_eps})