Ejemplo n.º 1
0
def test_replay(testdir):
    # Distance between Cu atoms on a (100) surface:
    d = 3.6 / sqrt(2)
    a = Atoms('Cu',
              positions=[(0, 0, 0)],
              cell=(d, d, 1.0),
              pbc=(True, True, False))
    a *= (2, 2, 1)  # 2x2 (100) surface-cell

    # Approximate height of Ag atom on Cu(100) surfece:
    h0 = 2.0
    a += Atom('Ag', (d / 2, d / 2, h0))

    if 0:
        view(a)

    constraint = FixAtoms(range(len(a) - 1))
    a.calc = EMT()
    a.set_constraint(constraint)

    with QuasiNewton(a, trajectory='AgCu1.traj', logfile='AgCu1.log') as dyn1:
        dyn1.run(fmax=0.1)

    a = read('AgCu1.traj')
    a.calc = EMT()
    print(a.constraints)

    with QuasiNewton(a, trajectory='AgCu2.traj', logfile='AgCu2.log') as dyn2:
        dyn2.replay_trajectory('AgCu1.traj')
        dyn2.run(fmax=0.01)
Ejemplo n.º 2
0
def compare_forces(atoms: Atoms, calc1, calc2):
    print(f"atoms # {len(atoms.numbers)}")
    calc1.reset()
    atoms.calc = calc1
    start = perf_counter()
    try:
        F1 = atoms.get_forces()
        t1 = perf_counter() - start
    except:
        print("Calculation failed")
        F1 = np.array([np.nan])
        t1 = np.nan

    print(f"F1 {F1.shape} took {t1} sec")

    calc2.reset()
    atoms.calc = calc2
    start = perf_counter()
    F2 = atoms.get_forces()
    t2 = perf_counter() - start
    print(f"F2 {F2.shape} took {t2} sec")
    # print(F2)
    print(
        f"diff {np.max(np.abs(F1 - F2))}, calc1/calc2 -> {t1 / t2} times faster"
    )
    return t1, t2, F1, F2
Ejemplo n.º 3
0
def test_strain():
    from math import sqrt
    from ase import Atoms
    from ase.constraints import StrainFilter
    from ase.optimize.mdmin import MDMin
    from ase.io import Trajectory
    try:
        from asap3 import EMT
    except ImportError:
        pass
    else:
        a = 3.6
        b = a / 2
        cu = Atoms('Cu', cell=[(0, b, b), (b, 0, b),
                               (b, b, 0)], pbc=1) * (6, 6, 6)

        cu.calc = EMT()
        f = StrainFilter(cu, [1, 1, 1, 0, 0, 0])
        opt = MDMin(f, dt=0.01)
        t = Trajectory('Cu.traj', 'w', cu)
        opt.attach(t)
        opt.run(0.001)

        # HCP:
        from ase.build import bulk
        cu = bulk('Cu', 'hcp', a=a / sqrt(2))
        cu.cell[1, 0] -= 0.05
        cu *= (6, 6, 3)

        cu.calc = EMT()
        f = StrainFilter(cu)
        opt = MDMin(f, dt=0.01)
        t = Trajectory('Cu.traj', 'w', cu)
        opt.attach(t)
        opt.run(0.01)
Ejemplo n.º 4
0
def toatoms(self, attach_calculator=False, add_additional_information=False):
    """Create Atoms object."""
    atoms = Atoms(self.numbers,
                  self.positions,
                  cell=self.cell,
                  pbc=self.pbc,
                  magmoms=self.get('initial_magmoms'),
                  charges=self.get('initial_charges'),
                  tags=self.get('tags'),
                  masses=self.get('masses'),
                  momenta=self.get('momenta'),
                  constraint=self.constraints)

    if attach_calculator:
        params = self.get('calculator_parameters', {})
        atoms.calc = get_calculator_class(self.calculator)(**params)
    else:
        results = {}
        for prop in all_properties:
            if prop in self:
                results[prop] = self[prop]
        if results:
            atoms.calc = SinglePointCalculator(atoms, **results)
            atoms.calc.name = self.get('calculator', 'unknown')

    if add_additional_information:
        atoms.info = {}
        atoms.info['unique_id'] = self.unique_id
        if self._keys:
            atoms.info['key_value_pairs'] = self.key_value_pairs
        data = self.get('data')
        if data:
            atoms.info['data'] = data
Ejemplo n.º 5
0
def _assert_energy_equal(calc1, calc2, atoms: Atoms):
    calc1.reset()
    atoms.calc = calc1
    e1 = atoms.get_potential_energy()

    calc2.reset()
    atoms.calc = calc2
    e2 = atoms.get_potential_energy()
    assert np.allclose(e1, e2, atol=1e-4, rtol=1e-4)
def test_change_cell_dimensions_and_pbc(factory, dimer_params, lj_epsilons):
    """Ensure that post_change_box commands are actually executed after
    changing the dimensions of the cell or its periodicity.  This is done by
    setting up an isolated dimer with a Lennard-Jones potential and a set of
    post_changebox_cmds that specify the same potential but with a rescaled
    energy (epsilon) parameter.  The energy is then computed twice, once before
    changing the cell dimensions and once after, and the values are compared to
    the expected values based on the two different epsilons to ensure that the
    modified LJ potential is used for the second calculation.  The procedure is
    repeated but where the periodicity of the cell boundaries is changed rather
    than the cell dimensions.
    """
    # Make a dimer in a large nonperiodic box
    dimer = Atoms(**dimer_params)
    spec, a = extract_dimer_species_and_separation(dimer)

    # Ensure LJ cutoff is large enough to encompass the dimer
    lj_cutoff = 3 * a

    calc_params = calc_params_lj_changebox(spec, lj_cutoff, **lj_epsilons)

    dimer.calc = factory.calc(**calc_params)

    energy_orig = dimer.get_potential_energy()

    # Shrink the box slightly to invalidate cached energy and force change_box
    # to be issued.  This shouldn't actually affect the energy in and of itself
    # since our dimer has non-periodic boundaries.
    cell_orig = dimer.get_cell()
    dimer.set_cell(cell_orig * 1.01, scale_atoms=False)

    energy_modified = dimer.get_potential_energy()

    eps_scaling_factor = lj_epsilons["eps_modified"] / lj_epsilons["eps_orig"]
    assert energy_modified == pytest.approx(eps_scaling_factor * energy_orig,
                                            rel=1e-4)

    # Reset dimer cell.  Also, create and attach new calculator so that
    # previous post_changebox_cmds won't be in effect.
    dimer.set_cell(cell_orig, scale_atoms=False)
    dimer.calc = factory.calc(**calc_params)

    # Compute energy of original configuration again so that a change_box will
    # be triggered on the next calculation after we change the pbcs
    energy_orig = dimer.get_potential_energy()

    # Change the periodicity of the cell along one direction.  This shouldn't
    # actually affect the energy in and of itself since the cell is large
    # relative to the dimer
    dimer.set_pbc([False, True, False])

    energy_modified = dimer.get_potential_energy()

    assert energy_modified == pytest.approx(eps_scaling_factor * energy_orig,
                                            rel=1e-4)
Ejemplo n.º 7
0
def systems_minimum():
    """two atoms at potential minimum"""

    atoms = Atoms('H2', positions=[[0, 0, 0], [0, 0, 2**(1.0 / 6.0)]])
    calc = LennardJones(rc=1.0e5)
    atoms.calc = calc
    yield atoms

    calc = LennardJones(rc=1.0e5, smooth=True)
    atoms.calc = calc
    yield atoms
Ejemplo n.º 8
0
def test_standardcomparator():
    from ase.ga.standard_comparators import (InteratomicDistanceComparator,
                                             EnergyComparator,
                                             RawScoreComparator,
                                             SequentialComparator)
    from ase import Atoms
    from ase.calculators.singlepoint import SinglePointCalculator
    from ase.ga import set_raw_score

    a1 = Atoms('AgAgAg', positions=[[0, 0, 0], [1.5, 0, 0], [1.5, 1.5, 0]])
    a2 = Atoms('AgAgAg', positions=[[0, 0, 0], [1.4, 0, 0], [1.5, 1.5, 0]])

    e1 = 1.0
    e2 = 0.8

    a1.calc = SinglePointCalculator(a1, energy=e1)
    a2.calc = SinglePointCalculator(a2, energy=e2)

    comp1 = InteratomicDistanceComparator(n_top=3,
                                          pair_cor_cum_diff=0.03,
                                          pair_cor_max=0.7,
                                          dE=0.3)
    assert comp1.looks_like(a1, a2)

    comp2 = InteratomicDistanceComparator(n_top=3,
                                          pair_cor_cum_diff=0.03,
                                          pair_cor_max=0.7,
                                          dE=0.15)
    assert not comp2.looks_like(a1, a2)

    comp3 = InteratomicDistanceComparator(n_top=3,
                                          pair_cor_cum_diff=0.02,
                                          pair_cor_max=0.7,
                                          dE=0.3)
    assert not comp3.looks_like(a1, a2)

    hard_E_comp = EnergyComparator(dE=1.0)
    assert hard_E_comp.looks_like(a1, a2)

    soft_E_comp = EnergyComparator(dE=.01)
    assert not soft_E_comp.looks_like(a1, a2)

    set_raw_score(a1, .1)
    set_raw_score(a2, .27)

    rs_comp = RawScoreComparator(0.15)
    assert not rs_comp.looks_like(a1, a2)

    comp1 = SequentialComparator([hard_E_comp, rs_comp], [0, 0])
    assert not comp1.looks_like(a1, a2)

    comp2 = SequentialComparator([hard_E_comp, rs_comp], [0, 1])
    assert comp2.looks_like(a1, a2)
Ejemplo n.º 9
0
def main():
    atom = Atoms('N')
    atom.calc = EMT()
    e_atom = atom.get_potential_energy()
    d = 1.1
    molecule = Atoms('2N', [(0, 0, 0), (0, 0, d)])
    molecule.calc = EMT()
    e_molecule = molecule.get_potential_energy()
    e_atomization = e_molecule - 2 * e_atom

    print('Nitrogen atom energy: %5.2f eV' % e_atom)
    print('Nitrogen molecule energy: %5.2f eV' % e_molecule)
    print('Atomization energy: %5.2f eV' % -e_atomization)
Ejemplo n.º 10
0
def test_finite_difference():
    # ensure that we got the modified forces right
    h = 1e-10
    r = 8.0
    calc = LennardJones(smooth=True, ro=6, rc=10, sigma=3)
    atoms = Atoms('H2', positions=[[0, 0, 0], [r, 0, 0]])
    atoms2 = Atoms('H2', positions=[[0, 0, 0], [r + h, 0, 0]])
    atoms.calc = calc
    atoms2.calc = calc

    fd_force = (atoms2.get_potential_energy() -
                atoms.get_potential_energy()) / h
    force = atoms.get_forces()[0, 0]

    np.testing.assert_allclose(fd_force, force)
Ejemplo n.º 11
0
def lithiumBulk(comm):
    d = 3.5
    li = Atoms("Li2", positions=[(0, 0, 0), (0.5 * d, 0.5 * d, 0.5 * d)], cell=np.eye(3) * d)
    from ase.dft import kpoints

    kpointList = kpoints.monkhorst_pack((4, 4, 4))
    kpointList += np.asarray([0.125, 0.125, 0.125])
    w = 1.0 / len(kpointList)
    if "--gpu" in sys.argv:
        li.calc = ElectronicMinimizeGPU(atoms=li, log=True, kpts=[(k, w) for k in kpointList], comm=comm)
    else:
        li.calc = ElectronicMinimize(atoms=li, log=True, kpts=[(k, w) for k in kpointList], comm=comm)
    li.calc.dragWavefunctions = False

    print(li.get_potential_energy() / Hartree)
Ejemplo n.º 12
0
def test_monoclinic():
    """Test band structure from different variations of hexagonal cells."""
    mc1 = Cell([[1, 0, 0], [0, 1, 0], [0, 0.2, 1]])
    par = mc1.cellpar()
    mc2 = Cell.new(par)
    mc3 = Cell([[1, 0, 0], [0, 1, 0], [-0.2, 0, 1]])
    mc4 = Cell([[1, 0, 0], [-0.2, 1, 0], [0, 0, 1]])
    path = 'GYHCEM1AXH1'

    firsttime = True
    for cell in [mc1, mc2, mc3, mc4]:
        a = Atoms(cell=cell, pbc=True)
        a.cell *= 3
        a.calc = FreeElectrons(nvalence=1, kpts={'path': path})

        lat = a.cell.get_bravais_lattice()
        assert lat.name == 'MCL'
        a.get_potential_energy()
        bs = a.calc.band_structure()
        coords, labelcoords, labels = bs.get_labels()
        assert ''.join(labels) == path
        e_skn = bs.energies

        if firsttime:
            coords1 = coords
            labelcoords1 = labelcoords
            e_skn1 = e_skn
            firsttime = False
        else:
            for d in [coords - coords1,
                      labelcoords - labelcoords1,
                      e_skn - e_skn1]:
                print(abs(d).max())
                assert abs(d).max() < 1e-13, d
Ejemplo n.º 13
0
 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
Ejemplo n.º 14
0
def test_struc_from_ase():
    from ase import Atoms
    from ase.calculators.singlepoint import SinglePointCalculator

    results = {
        "forces": np.random.randn(20, 3),
        "energy": np.random.rand(),
        "stress": np.random.randn(6),
    }

    uc = Atoms(
        ["Pd" for i in range(10)] + ["Ag" for i in range(10)],
        positions=np.random.rand(20, 3),
        cell=np.random.rand(3, 3),
    )

    calculator = SinglePointCalculator(uc, **results)
    uc.calc = calculator

    new_struc = Structure.from_ase_atoms(uc)

    assert np.all(new_struc.species_labels == uc.get_chemical_symbols())
    assert np.all(new_struc.positions == uc.get_positions())
    assert np.all(new_struc.cell == uc.get_cell())
    assert np.all(new_struc.forces == results["forces"])
    assert np.all(new_struc.energy == results["energy"])
    assert np.all(new_struc.stress == results["stress"])
Ejemplo n.º 15
0
    def to_ase(self):
        arrays_keys = set(self.arrays_keys)
        info_keys = set(self.info_keys)

        cell = self.pop('cell', None)
        pbc = self.pop('pbc', None)
        numbers = self.pop('numbers', None)
        positions = self.pop('positions', None)
        results_keys = self.derived['results_keys']

        info_keys -= {'cell', 'pbc'}
        arrays_keys -= {'numbers', 'positions'}

        atoms = Atoms(cell=cell, pbc=pbc, numbers=numbers, positions=positions)

        if 'calculator_name' in self:
            # calculator_name = self['info'].pop('calculator_name')
            # atoms.calc = get_calculator(data['results']['calculator_name'])(**params)

            params = self.pop('calculator_parameters', {})

            atoms.calc = SinglePointCalculator(atoms, **params)
            atoms.calc.results.update((key, self[key]) for key in results_keys)

        atoms.arrays.update((key, np.array(self[key])) for key in arrays_keys)
        atoms.info.update((key, self[key]) for key in info_keys)

        return atoms
Ejemplo n.º 16
0
def test_hex():
    """Test band structure from different variations of hexagonal cells."""
    firsttime = True
    for cell in [[[1, 0, 0], [0.5, 3**0.5 / 2, 0], [0, 0, 1]],
                 [[1, 0, 0], [-0.5, 3**0.5 / 2, 0], [0, 0, 1]],
                 [[0.5, -3**0.5 / 2, 0], [0.5, 3**0.5 / 2, 0], [0, 0, 1]]]:
        a = Atoms(cell=cell, pbc=True)
        a.cell *= 3
        a.calc = FreeElectrons(nvalence=1, kpts={'path': 'GMKG'})
        lat = a.cell.get_bravais_lattice()
        assert lat.name == 'HEX'
        print(repr(a.cell.get_bravais_lattice()))
        r = a.cell.reciprocal()
        k = get_special_points(a.cell)['K']
        print(np.dot(k, r))
        a.get_potential_energy()
        bs = a.calc.band_structure()
        coords, labelcoords, labels = bs.get_labels()
        assert ''.join(labels) == 'GMKG'
        e_skn = bs.energies
        if firsttime:
            coords1 = coords
            labelcoords1 = labelcoords
            e_skn1 = e_skn
            firsttime = False
        else:
            for d in [
                    coords - coords1, labelcoords - labelcoords1,
                    e_skn - e_skn1
            ]:
                assert abs(d).max() < 1e-13
Ejemplo n.º 17
0
def test_main(require_vasp):
    assert installed()

    # simple test calculation of CO molecule
    d = 1.14
    co = Atoms('CO', positions=[(0, 0, 0), (0, 0, d)],
               pbc=True)
    co.center(vacuum=5.)

    calc = Vasp(xc='PBE',
                prec='Low',
                algo='Fast',
                ismear=0,
                sigma=1.,
                istart=0,
                lwave=False,
                lcharg=False,
                ldipol=True)

    co.calc = calc
    energy = co.get_potential_energy()
    forces = co.get_forces()
    dipole_moment = co.get_dipole_moment()

    # check that parsing of vasprun.xml file works
    conf = read('vasprun.xml')
    assert conf.calc.parameters['kpoints_generation']
    assert conf.calc.parameters['sigma'] == 1.0
    assert conf.calc.parameters['ialgo'] == 68
    assert energy - conf.get_potential_energy() == 0.0
    assert np.allclose(conf.get_forces(), forces)
    assert np.allclose(conf.get_dipole_moment(), dipole_moment, atol=1e-6)

    # Cleanup
    calc.clean()
Ejemplo n.º 18
0
def test_h2of():
    with open('def2-svp.gbs', 'w') as bfile:
        bfile.write(basis)

    atoms = Atoms('OH2F', positions=[(-1.853788, -0.071113, 0.000000),
                                     (-1.892204, 0.888768, 0.000000),
                                     (-0.888854, -0.232973, 0.000000),
                                     (1.765870, 0.148285, 0.000000)])

    label = 'h2of-anion'
    calc = Gaussian(charge=-1.0,
                    basis='gen',
                    method='B3LYP',
                    basisfile='@def2-svp.gbs/N',
                    label=label,
                    ioplist=['6/80=1', '6/35=4000000'],
                    density='current',
                    addsec=['%s.wfx' % label]
                   )
    # FIXME: the "addsec" argument above is correctly incorporated into the
    # input file, but it doesn't appear to do anything to the calculation.
    # What is it for? What is it suppsoed to do?

    atoms.calc = calc
    atoms.get_potential_energy()
Ejemplo n.º 19
0
def test_counterions():
    """ Test AtomicCounterIon is force/energy consistent over 
        PBCs and with cutoff """

    import numpy as np
    from ase import Atoms
    from ase import units
    from ase.calculators.counterions import AtomicCounterIon as ACI

    sigma = 1.868 * (1.0 / 2.0)**(1.0 / 6.0)
    epsilon = 0.00277 * units.kcal / units.mol

    atoms = Atoms('3Na',
                  positions=np.array([[0, 0, -2], [0, 0, 0], [0, 0, 2]]))
    atoms.cell = [10, 10, 10]
    atoms.pbc = True

    atoms.calc = ACI(1, epsilon, sigma, rc=4.5)
    points = np.arange(-15., 15., 0.2)

    for p in points:
        f = atoms.get_forces()
        fn = atoms.calc.calculate_numerical_forces(atoms, 1e-5)
        df = (f - fn)
        assert abs(df).max() < 1e-8
Ejemplo n.º 20
0
def test_md(factory):
    # XXX ugly hack
    ver = factory.factory.version()
    if LooseVersion(ver) < '3.8':
        pytest.skip('No stress tensor until openmx 3.8+')

    bud = Atoms('CH4',
                np.array([[0.000000, 0.000000, 0.100000],
                          [0.682793, 0.682793, 0.682793],
                          [-0.682793, -0.682793, 0.68279],
                          [-0.682793, 0.682793, -0.682793],
                          [0.682793, -0.682793, -0.682793]]),
                cell=[10, 10, 10])

    calc = factory.calc(
        label='ch4',
        xc='GGA',
        energy_cutoff=300 * Ry,
        convergence=1e-4 * Ha,
        # Use 'C_PBE19' and 'H_PBE19' for version 3.9
        definition_of_atomic_species=[['C', 'C5.0-s1p1', 'C_PBE13'],
                                      ['H', 'H5.0-s1', 'H_PBE13']],
        kpts=(1, 1, 1),
        eigensolver='Band')

    bud.calc = calc
    with Trajectory('example.traj', 'w', bud) as traj:
        ucf = UnitCellFilter(bud,
                             mask=[True, True, False, False, False, False])
        dyn = QuasiNewton(ucf)
        dyn.attach(traj.write)
        dyn.run(fmax=0.1)
        bud.get_potential_energy()
Ejemplo n.º 21
0
def _assert_energy_force_stress_equal(calc1, calc2, atoms: Atoms):
    calc1.reset()
    atoms.calc = calc1
    f1 = atoms.get_forces()
    e1 = atoms.get_potential_energy()

    calc2.reset()
    atoms.calc = calc2
    f2 = atoms.get_forces()
    e2 = atoms.get_potential_energy()
    assert np.allclose(e1, e2, atol=1e-4, rtol=1e-4)
    assert np.allclose(f1, f2, atol=1e-5, rtol=1e-5)
    if np.all(atoms.pbc == np.array([True, True, True])):
        s1 = atoms.get_stress()
        s2 = atoms.get_stress()
        assert np.allclose(s1, s2, atol=1e-5, rtol=1e-5)
Ejemplo n.º 22
0
def ase_vib(embedder, coords, atomnos, logfunction=None, title='temp'):
    '''
    '''
    atoms = Atoms(atomnos, positions=coords)
    atoms.calc = get_ase_calc(embedder)
    vib = Vibrations(atoms, name=title)

    if os.path.isdir(title):
        os.chdir(title)
        for f in os.listdir():
            os.remove(f)
        os.chdir(os.path.dirname(os.getcwd()))
    else:
        os.mkdir(title)

    os.chdir(title)

    t_start = time.perf_counter()

    with HiddenPrints():
        vib.run()

    # freqs = vib.get_frequencies()
    freqs = vib.get_energies() * 8065.544  # from eV to cm-1

    if logfunction is not None:
        elapsed = time.perf_counter() - t_start
        logfunction(
            f'{title} - frequency calculation completed ({time_to_string(elapsed)})'
        )

    os.chdir(os.path.dirname(os.getcwd()))

    return freqs, np.count_nonzero(freqs.imag > 1e-3)
Ejemplo n.º 23
0
def die():
    d = 0.9575
    t = np.pi / 180 * 104.51
    water = Atoms("H2O", positions=[(d, 0, 0), (d * np.cos(t), d * np.sin(t), 0), (0, 0, 0)])
    water.calc = ElectronicMinimize(atoms=water, log=True)
    dyn = LBFGS(water)
    dyn.run(fmax=0.05)
Ejemplo n.º 24
0
def test_morse_cluster(internal, order, trajectory=None):
    rng = np.random.RandomState(4)

    nat = 4
    atoms = Atoms(['Xe'] * nat, rng.normal(size=(nat, 3), scale=3.0))
    # parameters from DOI: 10.1515/zna-1987-0505
    atoms.calc = MorsePotential(alpha=226.9 * kB, r0=4.73, rho0=4.73 * 1.099)

    cons = Constraints(atoms)
    cons.fix_translation()
    cons.fix_rotation()

    opt = Sella(
        atoms,
        order=order,
        internal=internal,
        trajectory=trajectory,
        gamma=1e-3,
        constraints=cons,
    )
    opt.run(fmax=1e-3)

    Ufree = opt.pes.get_Ufree()
    np.testing.assert_allclose(opt.pes.get_g() @ Ufree, 0, atol=5e-3)
    opt.pes.diag(gamma=1e-16)
    H = opt.pes.get_HL().project(Ufree)
    assert np.sum(H.evals < 0) == order, H.evals
Ejemplo n.º 25
0
def compareForces():
    d = 0.9575
    t = np.pi / 180 * 104.51
    water = Atoms("H2O", positions=[(d, 0, 0), (d * np.cos(t), d * np.sin(t), 0), (0, 0, 0)], cell=np.eye(3) * 5.0)
    water.calc = ElectronicMinimize(atoms=water, log=False)
    print(water.get_forces())
    print(water.calc.calculate_numerical_forces(water))
Ejemplo n.º 26
0
def get_example_adsorbate(type="CO2"):
    '''
    Small function to return CO2 or Cu atoms
    Parameters:

    type: str
        Two adsorbate types - "CO2" and "2Cu". CO2 behaviour during optimisation
        is unrealistic in EMT.
    '''

    from ase.build import molecule
    from ase import Atoms
    if type == "CO2":
        atoms = molecule("CO2")
        atoms.rotate(90, 'x')
        atoms.rotate(50, 'z')
    elif type == "2Cu":
        atoms = Atoms("2Cu",
                      positions=[(0, 0, 0), (-4.08 / (2**(1 / 2)), 0, 0)])

    # Make the model a bit more technically complete - include a calculator.
    from ase.calculators.emt import EMT
    atoms.calc = EMT()

    return atoms
Ejemplo n.º 27
0
 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
Ejemplo n.º 28
0
    def to_labeled_system(self, data, *args, **kwargs):
        '''Convert System to ASE Atoms object.'''
        from ase import Atoms
        from ase.calculators.singlepoint import SinglePointCalculator

        structures = []
        species = [data['atom_names'][tt] for tt in data['atom_types']]

        for ii in range(data['coords'].shape[0]):
            structure = Atoms(symbols=species,
                              positions=data['coords'][ii],
                              pbc=not data.get('nopbc', False),
                              cell=data['cells'][ii])

            results = {
                'energy': data["energies"][ii],
                'forces': data["forces"][ii]
            }
            if "virials" in data:
                # convert to GPa as this is ase convention
                v_pref = 1 * 1e4 / 1.602176621e6
                vol = structure.get_volume()
                results['stress'] = data["virials"][ii] / (v_pref * vol)

            structure.calc = SinglePointCalculator(structure, **results)
            structures.append(structure)

        return structures
Ejemplo n.º 29
0
def H2Morse(state=0):
    """Return H2 as a Morse-Potential with calculator attached."""
    atoms = Atoms('H2', positions=np.zeros((2, 3)))
    atoms[1].position[2] = Re[state]
    atoms.calc = H2MorseCalculator(state=state)
    atoms.get_potential_energy()
    return atoms
Ejemplo n.º 30
0
def test_tip4p():
    """Test TIP4P forces."""
    from math import cos, sin

    from ase import Atoms
    from ase.calculators.tip4p import TIP4P, rOH, angleHOH

    r = rOH
    a = angleHOH

    dimer = Atoms('H2OH2O', [(r * cos(a), 0, r * sin(a)), (r, 0, 0), (0, 0, 0),
                             (r * cos(a / 2), r * sin(a / 2), 0),
                             (r * cos(a / 2), -r * sin(a / 2), 0), (0, 0, 0)])

    # tip4p sequence OHH, OHH, ..
    dimer = dimer[[2]] + dimer[:2] + dimer[[-1]] + dimer[3:5]
    dimer.positions[3:, 0] += 2.8

    dimer.calc = TIP4P(rc=4.0,
                       width=2.0)  # put O-O distance in the cutoff range
    F = dimer.get_forces()
    print(F)
    dF = dimer.calc.calculate_numerical_forces(dimer) - F
    print(dF)
    assert abs(dF).max() < 2e-6
Ejemplo n.º 31
0
    def build(self, lines: _CHUNK) -> Atoms:
        """Apply outcar chunk parsers, and build an atoms object"""
        self.update_parser_headers()  # Ensure header is in sync

        results = self.parse(lines)
        symbols = self.header['symbols']
        constraint = self.header.get('constraint', None)

        atoms_kwargs = dict(symbols=symbols, constraint=constraint)

        # Find some required properties in the parsed results.
        # Raise ParseError if they are not present
        for prop in ('positions', 'cell'):
            try:
                atoms_kwargs[prop] = results.pop(prop)
            except KeyError:
                raise ParseError(
                    'Did not find required property {} during parse.'.format(
                        prop))
        atoms = Atoms(**atoms_kwargs)

        kpts = results.pop('kpts', None)
        calc = SinglePointDFTCalculator(atoms, **results)
        if kpts is not None:
            calc.kpts = kpts
        calc.name = 'vasp'
        atoms.calc = calc
        return atoms
Ejemplo n.º 32
0
def Al_atom_pair(pair_distance=pair_distance):
    atoms = Atoms('AlAl',
                  positions=[[-pair_distance / 2, 0, 0],
                             [pair_distance / 2, 0, 0]])
    atoms.center(vacuum=10)
    atoms.calc = EMT()
    return atoms
def test_lammpslib_small_nonperiodic():
    # test that lammpslib handle nonperiodic cases where the cell size
    # in some directions is small (for example for a dimer).
    import numpy as np
    from ase.calculators.lammpslib import LAMMPSlib
    from ase import Atoms

    cmds = ["pair_style eam/alloy", "pair_coeff * * NiAlH_jea.eam.alloy Ni H"]
    lammps = LAMMPSlib(lmpcmds=cmds,
                       atom_types={
                           'Ni': 1,
                           'H': 2
                       },
                       log_file='test.log',
                       keep_alive=True)
    a = 2.0
    dimer = Atoms("NiNi",
                  positions=[(0, 0, 0), (a, 0, 0)],
                  cell=(1000 * a, 1000 * a, 1000 * a),
                  pbc=(0, 0, 0))
    dimer.calc = lammps

    energy_ref = -1.10756669119
    energy = dimer.get_potential_energy()
    print("Computed energy: {}".format(energy))
    np.testing.assert_allclose(energy, energy_ref, atol=1e-4, rtol=1e-4)

    forces_ref = np.array([[-0.9420162329811532, 0., 0.],
                           [+0.9420162329811532, 0., 0.]])
    forces = dimer.get_forces()
    print(np.array2string(forces))
    np.testing.assert_allclose(forces, forces_ref, atol=1e-4, rtol=1e-4)
Ejemplo n.º 34
0
def color(gui):
    a = Atoms('C10', magmoms=np.linspace(1, -1, 10))
    a.positions[:] = np.linspace(0, 9, 10)[:, None]
    a.calc = SinglePointCalculator(a, forces=a.positions)
    gui.new_atoms(a)
    c = gui.colors_window()
    c.toggle('force')
    text = c.toggle('magmom')
    assert [button.active for button in c.radio.buttons] == [1, 0, 1, 0, 0, 1]
    assert text.rsplit('[', 1)[1].startswith('-1.000000,1.000000]')
Ejemplo n.º 35
0
def optimizeWater():
    d = 0.9575
    t = np.pi / 180 * 104.51
    water = Atoms("H2O", positions=[(d, 0, 0), (d * np.cos(t), d * np.sin(t), 0), (0, 0, 0)], cell=np.eye(3) * 7.0)
    water.calc = ElectronicMinimize(atoms=water, log=True)
    water.calc.dragWavefunctions = False
    # dyn = SciPyFminBFGS(water, callback_always=True)
    # dyn = BFGSLineSearch(water)
    # dyn = BFGS(water)
    # dyn.run(fmax=0.000005, steps = 10)
    print(water.get_potential_energy() / Hartree)
Ejemplo n.º 36
0
def get_hydrogen_chain_dielectric_function(NH, NK):
    a = Atoms('H', cell=[1, 1, 1], pbc=True)
    a.center()
    a = a.repeat((1, 1, NH))
    a.calc = GPAW(mode=PW(200), kpts={'size': (1, 1, NK), 'gamma': True},
                  parallel={'band': 1}, dtype=complex, gpts=(10, 10, 10 * NH))
    a.get_potential_energy()
    a.calc.diagonalize_full_hamiltonian(nbands=2 * NH)
    a.calc.write('H_chain.gpw', 'all')

    DF = DielectricFunction('H_chain.gpw', ecut=1e-3, hilbert=False,
                            omega2=np.inf, intraband=False)
    eps_NLF, eps_LF = DF.get_dielectric_function(direction='z')
    omega_w = DF.get_frequencies()
    return omega_w, eps_LF
Ejemplo n.º 37
0
    def toatoms(self, attach_calculator=False,
                add_additional_information=False):
        """Create Atoms object."""
        atoms = Atoms(self.numbers,
                      self.positions,
                      cell=self.cell,
                      pbc=self.pbc,
                      magmoms=self.get('initial_magmoms'),
                      charges=self.get('initial_charges'),
                      tags=self.get('tags'),
                      masses=self.get('masses'),
                      momenta=self.get('momenta'),
                      constraint=self.constraints)
    
        if attach_calculator:
            params = decode(self.get('calculator_parameters', '{}'))
            atoms.calc = get_calculator(self.calculator)(**params)
        else:
            results = {}
            for prop in all_properties:
                if prop in self:
                    results[prop] = self[prop]
            if results:
                atoms.calc = SinglePointCalculator(atoms, **results)
                atoms.calc.name = self.calculator

        if add_additional_information:
            atoms.info = {}
            atoms.info['unique_id'] = self.unique_id
            if self._keys:
                atoms.info['key_value_pairs'] = self.key_value_pairs
            data = self.get('data')
            if data:
                atoms.info['data'] = data
                    
        return atoms
Ejemplo n.º 38
0
def read_old_gpw(filename):
    from gpaw.io.tar import Reader
    r = Reader(filename)
    positions = r.get('CartesianPositions') * Bohr
    numbers = r.get('AtomicNumbers')
    cell = r.get('UnitCell') * Bohr
    pbc = r.get('BoundaryConditions')
    tags = r.get('Tags')
    magmoms = r.get('MagneticMoments')
    energy = r.get('PotentialEnergy') * Hartree

    if r.has_array('CartesianForces'):
        forces = r.get('CartesianForces') * Hartree / Bohr
    else:
        forces = None

    atoms = Atoms(positions=positions,
                  numbers=numbers,
                  cell=cell,
                  pbc=pbc)
    if tags.any():
        atoms.set_tags(tags)

    if magmoms.any():
        atoms.set_initial_magnetic_moments(magmoms)
        magmom = magmoms.sum()
    else:
        magmoms = None
        magmom = None

    atoms.calc = SinglePointDFTCalculator(atoms, energy=energy,
                                          forces=forces,
                                          magmoms=magmoms,
                                          magmom=magmom)
    kpts = []
    if r.has_array('IBZKPoints'):
        for w, kpt, eps_n, f_n in zip(r.get('IBZKPointWeights'),
                                      r.get('IBZKPoints'),
                                      r.get('Eigenvalues'),
                                      r.get('OccupationNumbers')):
            kpts.append(SinglePointKPoint(w, kpt[0], kpt[1],
                                          eps_n[0], f_n[0]))
    atoms.calc.kpts = kpts

    return atoms
Ejemplo n.º 39
0
i = LJInteractions({('O', 'O'): (epsilon0, sigma0)})

for calc in [TIP3P(),
             SimpleQMMM([0, 1, 2], TIP3P(), TIP3P(), TIP3P()),
             SimpleQMMM([0, 1, 2], TIP3P(), TIP3P(), TIP3P(), vacuum=3.0),
             EIQMMM([0, 1, 2], TIP3P(), TIP3P(), i),
             EIQMMM([3, 4, 5], TIP3P(), TIP3P(), i, vacuum=3.0),
             EIQMMM([0, 1, 2], TIP3P(), TIP3P(), i, vacuum=3.0)]:
    dimer = Atoms('H2OH2O',
                  [(r * cos(a), 0, r * sin(a)),
                   (r, 0, 0),
                   (0, 0, 0),
                   (r * cos(a / 2), r * sin(a / 2), 0),
                   (r * cos(a / 2), -r * sin(a / 2), 0),
                   (0, 0, 0)])
    dimer.calc = calc

    E = []
    F = []
    for d in D:
        dimer.positions[3:, 0] += d - dimer.positions[5, 0]
        E.append(dimer.get_potential_energy())
        F.append(dimer.get_forces())

    F = np.array(F)

    # plt.plot(D, E)

    F1 = np.polyval(np.polyder(np.polyfit(D, E, 7)), D)
    F2 = F[:, :3, 0].sum(1)
    error = abs(F1 - F2).max()
Ejemplo n.º 40
0
from ase import Atoms
from gpaw import GPAW
from gpaw.test import equal


# Self-consistent calculation:
a = 2.5
slab = Atoms('Li', cell=(a, a, 2 * a), pbc=1)
slab.calc = GPAW(kpts=(3,3,1), txt='li.txt',
                 parallel=dict(kpt=1))
slab.get_potential_energy()
slab.calc.write('Li.gpw')

# Gamma point:
e1 = slab.calc.get_eigenvalues(kpt=0)[0]

# Fix density and continue:
kpts = [(0,0,0)]
slab.calc.set(fixdensity=True,
              nbands=5,
              kpts=kpts,
              usesymm=None,
              eigensolver='cg')
slab.get_potential_energy()
e2 = slab.calc.get_eigenvalues(kpt=0)[0]

# Start from gpw-file:
calc = GPAW('Li.gpw', 
            fixdensity=True,
            nbands=5,
            kpts=kpts,
Ejemplo n.º 41
0
from ase import Atoms
from gpaw import GPAW
from gpaw.xc.noncollinear import NonCollinearFunctional, \
     NonCollinearLCAOEigensolver, NonCollinearMixer
from gpaw.xc import XC

a = 2.84
fe = Atoms('Fe2',
           scaled_positions=[(0, 0, 0), (0.5, 0.5, 0.5)],
           magmoms=[2.3, 2.3],
           cell=(a, a, a),
           pbc=True)

k = 4
fe.calc = GPAW(txt='fec.txt', mode='lcao', basis='dz(dzp)', kpts=(k, k, k),
               convergence=dict(energy=1e-6))
e0 = fe.get_potential_energy()

fe.set_initial_magnetic_moments()
fe.set_initial_magnetic_moments([(2.3, 0, 0), (2.3, 0, 0)])
fe.calc = GPAW(txt='fenc.txt', mode='lcao', basis='dz(dzp)', kpts=(k, k, k),
               convergence=dict(energy=1e-6),
               usesymm=False,
               xc=NonCollinearFunctional(XC('LDA')),
               mixer=NonCollinearMixer(),
               eigensolver=NonCollinearLCAOEigensolver())
e = fe.get_potential_energy()

assert abs(e - e0) < 7e-5
Ejemplo n.º 42
0
from gpaw.xc.hybridg import HybridXC

a = 2.0
li = Atoms("Li", cell=(a, a, a), pbc=1)
for spinpol in [False, True]:
    for usesymm in [True, False, None]:
        if size == 8 and not spinpol and usesymm:
            continue
        for qparallel in [False, True]:
            if rank == 0:
                print (spinpol, usesymm, qparallel)
            li.calc = GPAW(
                mode=PW(300),
                kpts=(2, 3, 4),
                spinpol=spinpol,
                usesymm=usesymm,
                parallel={"band": 1},
                txt=None,
                idiotproof=False,
            )
            e = li.get_potential_energy()
            if qparallel:
                li.calc.write("li", mode="all")
                calc = GPAW("li", txt=None, communicator=serial_comm)
            else:
                calc = li.calc
            exx = HybridXC("EXX", logfilename=None, method="acdf")
            de = calc.get_xc_difference(exx)
            exx = HybridXC("EXX", logfilename=None, method="acdf", bandstructure=True, bands=[0, 1])
            de2 = calc.get_xc_difference(exx)
            kd = calc.wfs.kd
Ejemplo n.º 43
0
# creates: ase-db.out, ase-db-long.out
import ase.db
c = ase.db.connect('abc.db')

from ase import Atoms
from ase.calculators.emt import EMT
h2 = Atoms('H2', [(0, 0, 0), (0, 0, 0.7)])
h2.calc = EMT()
h2.get_forces()

c.write(h2, relaxed=False)

from ase.optimize import BFGS
BFGS(h2).run(fmax=0.01)
c.write(h2, relaxed=True, data={'abc': [1, 2, 3]})

for d in c.select('molecule'):
    print(d.forces[0, 2], d.relaxed)

h = Atoms('H')
h.calc = EMT()
h.get_potential_energy()
c.write(h)

import subprocess
with open('ase-db.out', 'w') as fd:
    fd.write('$ ase-db abc.out\n')
    output = subprocess.check_output(['ase-db', 'abc.db'])
    fd.write(output)
with open('ase-db-long.out', 'w') as fd:
    fd.write('$ ase-db abc.out relaxed=1 -l\n')
Ejemplo n.º 44
0
c = {"energy": 0.001, "eigenstates": 1, "density": 1}
d = 0.75

gen("H", xcname="PBEsol")

for xc, E0, dE0 in [("mBEEF", 4.86, 0.16), ("BEEF-vdW", 5.13, 0.20), ("mBEEF-vdW", 4.74, 0.36)]:
    print(xc)
    if not newlibxc and xc[0] == "m":
        print("Skipped")
        continue

    # H2 molecule:
    h2 = Atoms("H2", [[0, 0, 0], [0, 0, d]])
    h2.center(vacuum=2)
    h2.calc = GPAW(txt="H2-" + xc + ".txt", convergence=c)
    h2.get_potential_energy()
    h2.calc.set(xc=xc)
    h2.get_potential_energy()
    h2.get_forces()
    ens = BEEFEnsemble(h2.calc)
    e_h2 = ens.get_ensemble_energies()

    # H atom:
    h = Atoms("H", cell=h2.cell, magmoms=[1])
    h.center()
    h.calc = GPAW(txt="H-" + xc + ".txt", convergence=c)
    h.get_potential_energy()
    h.calc.set(xc=xc)
    h.get_potential_energy()
    ens = BEEFEnsemble(h.calc)
Ejemplo n.º 45
0
                   (0.0000, 0.0000, -1.1560)]),
   'Be2': ('Be2', [(0.0000, 0.0000, 0.0000),
                   (0.0000, 0.0000, 2.460)])}


c = ase.db.connect('results.db')

for name in ex_atomization.keys() + 'H Li Be B C N O F Cl P'.split():
    id = c.reserve(name=name)
    if id is None:
        continue
        
    if name in extra:
        a = Atoms(*extra[name])
    else:
        a = molecule(name)
        if name in bondlengths:
            a.set_distance(0, 1, bondlengths[name])
    a.cell = [11, 12, 13]
    a.center()
   
    a.calc = GPAW(xc='PBE', mode=PW(500), txt=name + '.txt', dtype=complex)
    a.get_potential_energy()
    
    exx = EXX(a.calc)
    exx.calculate()
    eexx = exx.get_total_energy()

    c.write(a, name=name, exx=eexx)
    del c[id]
    
Ejemplo n.º 46
0
from ase import Atoms
from gpaw import GPAW, PW
h = Atoms('H', cell=(5, 5, 5))
h.center()
h.calc = GPAW(setups='ae', txt='H.ae.txt')
for ecut in range(200, 1001, 100):
    h.calc.set(mode=PW(ecut))
    e = h.get_potential_energy()
Ejemplo n.º 47
0
a = 4.23 / 2.0
a1 = Atoms('Na',
           scaled_positions=[[0, 0, 0]],
           cell=(a, a, a),
           pbc=True)

# Expanding along x-direction
a2 = Atoms('Na2',
           scaled_positions=[[0, 0, 0], [0.5, 0, 0]],
           cell=(2 * a, a, a),
           pbc=True)

a1.calc = GPAW(gpts=(10, 10, 10),
               mode=PW(300),
               kpts={'size': (8, 8, 8), 'gamma': True},
               parallel={'band': 1},
               txt='small.txt')

# Kpoint sampling should be halved in the expanded direction.
a2.calc = GPAW(gpts=(20, 10, 10),
               mode=PW(300),
               kpts={'size': (4, 8, 8), 'gamma': True},
               parallel={'band': 1},
               txt='large.txt')

a1.get_potential_energy()
a2.get_potential_energy()

# Use twice as many bands for expanded structure
a1.calc.diagonalize_full_hamiltonian(nbands=20)
Ejemplo n.º 48
0
from gpaw.mpi import rank, size, serial_comm
from gpaw.xc.hybridg import HybridXC

a = 2.0
li = Atoms('Li', cell=(a, a, a), pbc=1)
for spinpol in [False, True]:
    for symm in [{}, 'off', {'time_reversal': False, 'point_group': False}]:
        if size == 8 and not spinpol and symm == {}:
            continue
        for qparallel in [False, True]:
            if rank == 0:
                print((spinpol, symm, qparallel))
            li.calc = GPAW(mode=PW(300),
                           kpts=(2, 3, 4),
                           spinpol=spinpol,
                           symmetry=symm,
                           parallel={'band': 1},
                           txt=None,
                           idiotproof=False)
            e = li.get_potential_energy()
            if qparallel:
                li.calc.write('li', mode='all')
                calc = GPAW('li', txt=None, communicator=serial_comm)
            else:
                calc = li.calc
            exx = HybridXC('EXX',
                           logfilename=None,
                           method='acdf')
            de = calc.get_xc_difference(exx)
            exx = HybridXC('EXX',
                           logfilename=None,
Ejemplo n.º 49
0
"""Test TIP3P forces."""
from math import cos, sin, pi

from ase import Atoms
from ase.calculators.tip3p import TIP3P, rOH, angleHOH
from ase.calculators.tip4p import TIP4P

r = rOH
a = angleHOH * pi / 180

dimer = Atoms('H2OH2O',
              [(r * cos(a), 0, r * sin(a)),
               (r, 0, 0),
               (0, 0, 0),
               (r * cos(a / 2), r * sin(a / 2), 0),
               (r * cos(a / 2), -r * sin(a / 2), 0),
               (0, 0, 0)])
dimer = dimer[[2, 0, 1, 5, 3, 4]]
dimer.positions[3:, 0] += 2.8

for TIPnP in [TIP3P, TIP4P]:
    # put O-O distance in the cutoff range
    dimer.calc = TIPnP(rc=4.0, width=2.0)
    F = dimer.get_forces()
    print(F)
    dF = dimer.calc.calculate_numerical_forces(dimer) - F
    print(dF)
    assert abs(dF).max() < 2e-6
Ejemplo n.º 50
0
from ase import Atoms
from gpaw import GPAW
from gpaw.xc.noncollinear import NonCollinearFunctional, \
     NonCollinearLCAOEigensolver, NonCollinearMixer
from gpaw.xc import XC

h = Atoms('H', magmoms=[1])
h.center(vacuum=2)
h.calc = GPAW(txt='c.txt', mode='lcao', basis='dz(dzp)', h=0.25)
e0 = h.get_potential_energy()

h.set_initial_magnetic_moments()
h.set_initial_magnetic_moments([(0.1, 0.2, 0.3)])
h.calc = GPAW(txt='nc.txt', mode='lcao', basis='dz(dzp)', h=0.25,
              xc=NonCollinearFunctional(XC('LDA')),
              mixer=NonCollinearMixer(),
              eigensolver=NonCollinearLCAOEigensolver())
e = h.get_potential_energy()

assert abs(e - e0) < 2e-5, (e, e0)
from ase.io import write
write('h.traj', h)

Ejemplo n.º 51
0
from ase import Atoms
from gpaw import GPAW, PW, FermiDirac

# Setup up bulk NiO in an antiferromagnetic configuration:
a = 4.19  # lattice constants
b = a / 2**0.5
m = 2.0
atoms = Atoms('Ni2O2',
              pbc=True,
              cell=(b, b, a),
              positions=[(0, 0, 0),
                         (b / 2, b / 2, a / 2),
                         (0, 0, a / 2),
                         (b / 2, b / 2, 0)],
              magmoms=[m, -m, 0, 0])

k = 2  # number of k-points
atoms.calc = GPAW(mode=PW(400),
                  occupations=FermiDirac(width=0.05),
                  setups={'Ni': ':d,6.0'},  # U=6 eV for Ni d orbitals
                  txt='nio.txt',
                  kpts=(k, k, k),
                  xc='PBE')
e = atoms.get_potential_energy()
Ejemplo n.º 52
0
from ase import Atoms
from gpaw import GPAW
from gpaw.mpi import world, serial_comm

a = Atoms('H',
          cell=(1, 3, 3),
          pbc=1)

a.calc = GPAW(mode='pw',
              h=0.15,
              kpts=(4, 1, 1),
              basis='dzp',
              nbands=4,
              eigensolver='rmm-diis',
              txt=None)

a.get_potential_energy()
w1 = a.calc.get_pseudo_wave_function(0, 1)
e1 = a.calc.get_eigenvalues(1)

a.calc.write('H')

if world.size <= 2:
    scalapack = None
else:
    mb = world.size // 4
    scalapack = (2, world.size // 4, 32)

a.calc.diagonalize_full_hamiltonian(nbands=100, scalapack=scalapack)
w2 = a.calc.get_pseudo_wave_function(0, 1)
e2 = a.calc.get_eigenvalues(1)
Ejemplo n.º 53
0
from ase import Atoms
from gpaw import GPAW
from gpaw.mpi import world, serial_comm

a = Atoms('H2',
          [(0, 0, 0), (0, 0, 0.74)],
          cell=(3, 3, 3),
          pbc=1)

a.calc = GPAW(mode='pw',
              eigensolver='rmm-diis',
              nbands=8,
              dtype=complex,
              basis='dzp', txt=None)

a.get_potential_energy()
w1 = a.calc.get_pseudo_wave_function(0)
e1 = a.calc.get_eigenvalues()

a.calc.write('H2')

if world.size == 1:
    scalapack = None
else:
    scalapack = (2, world.size // 2, 32)

a.calc.diagonalize_full_hamiltonian(nbands=120, scalapack=scalapack)
w2 = a.calc.get_pseudo_wave_function(0)
e2 = a.calc.get_eigenvalues()

calc = GPAW('H2', txt=None)
Ejemplo n.º 54
0
from ase import Atoms
from gpaw import GPAW, FermiDirac, Mixer
#from gpaw.xc.noncolinear import NonColinearLDA, NonColinearLCAOEigensolver, \
#     NonColinearMixer

h = Atoms('H', magmoms=[1])
h.center(vacuum=2)
xc = 'LDA'
c = GPAW(txt='c.txt',
         mode='lcao',
         basis='dz(dzp)',
         #setups='ncpp',
         h=0.25,
         xc=xc,
         #occupations=FermiDirac(0.01),
         mixer=Mixer(),
         #noncolinear=[(2,0,0)],
         )#eigensolver=NonColinearLCAOEigensolver())
c.set(nbands=1)
h.calc = c
h.get_potential_energy()
Ejemplo n.º 55
0
from math import log
from ase import Atoms
from ase.units import Bohr
from gpaw import GPAW, FermiDirac
from gpaw.test import equal

a = 4.0
h = 0.2
hydrogen = Atoms('H',
                 [(a / 2, a / 2, a / 2)],
                 cell=(a, a, a))

hydrogen.calc = GPAW(h=h, nbands=1, convergence={'energy': 1e-7})
e1 = hydrogen.get_potential_energy()
equal(e1, 0.526939, 0.001)

dens = hydrogen.calc.density
c = dens.gd.find_center(dens.nt_sG[0]) * Bohr
equal(abs(c - a / 2).max(), 0, 1e-13)

kT = 0.001
hydrogen.calc.set(occupations=FermiDirac(width=kT))
e2 = hydrogen.get_potential_energy()
equal(e1, e2 + log(2) * kT, 3.0e-7)
Ejemplo n.º 56
0
from ase import Atoms
from ase.units import Bohr
from gpaw.jellium import JelliumSurfacePoissonSolver
from gpaw import GPAW, Mixer

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)

ps = JelliumSurfacePoissonSolver(z1=v, z2=v + L)
surf = Atoms(pbc=(True, True, False),
             cell=(a, a, v + L + v))
surf.calc = GPAW(poissonsolver=ps,
                 xc='LDA_X+LDA_C_WIGNER',
                 eigensolver='dav',
                 charge=-ne,
                 kpts=[k, k, 1],
                 h=h,
                 maxiter=300,
                 convergence={'density': 0.001},
                 mixer=Mixer(0.03, 7, 100),
                 nbands=int(ne / 2) + 15,
                 txt='surface.txt')
e = surf.get_potential_energy()
surf.calc.write('surface.gpw')
Ejemplo n.º 57
0
from gpaw.test import equal

a = 5.0
d = 1.0
x = d / 3**0.5
atoms = Atoms([Atom('C', (0.0, 0.0, 0.0)),
                     Atom('H', (x, x, x)),
                     Atom('H', (-x, -x, x)),
                     Atom('H', (x, -x, -x)),
                     Atom('H', (-x, x, -x))],
                    cell=(a, a, a),
                    pbc=False)

atoms.positions[:] += a / 2
calc = GPAW(h=0.25, nbands=4, convergence={'eigenstates': 7.8e-10})
atoms.calc = calc
energy = atoms.get_potential_energy()
niter = calc.get_number_of_iterations()

# The three eigenvalues e[1], e[2], and e[3] must be degenerate:
e = calc.get_eigenvalues()
print(e[1] - e[3])
equal(e[1], e[3], 9.3e-8)

energy_tolerance = 0.0003
niter_tolerance = 0
equal(energy, -23.6277, energy_tolerance)

# Calculate non-selfconsistent PBE eigenvalues:
from gpaw.xc.tools import vxc
epbe0 = e - vxc(calc)[0, 0] + vxc(calc, 'PBE')[0, 0]
Ejemplo n.º 58
0
import numpy as np
from ase import Atoms
from ase.units import Bohr
from gpaw.jellium import JelliumPoissonSolver
from gpaw import GPAW

rs = 5.0 * Bohr  # Wigner-Seitz radius
h = 0.2          # grid-spacing
a = 8 * h        # lattice constant
k = 12           # number of k-points (k*k*k)

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

bulk = Atoms(pbc=True, cell=(a, a, a))
bulk.calc = GPAW(poissonsolver=JelliumPoissonSolver(),
                 xc='LDA_X+LDA_C_WIGNER',
                 charge=-ne,
                 nbands=5,
                 kpts=[k, k, k],
                 h=h,
                 txt='bulk.txt')
e0 = bulk.get_potential_energy()
Ejemplo n.º 59
0
    S. Suhai: *Electron correlation in extended systems: Fourth-order
    many-body perturbation theory and density-functional methods
    applied to an infinite chain of hydrogen atoms*, Phys. Rev. B 50,
    14791-14801 (1994)
    
"""

import numpy as np
from ase import Atoms

from gpaw import GPAW, FermiDirac

k = 8
a = 6.0
d0 = 1.0

h2 = Atoms('H2', cell=(2 * d0, a, a), pbc=True,
           positions=[(0, 0, 0), (d0 + 0.1, 0, 0)])
h2.center(axis=1)
h2.center(axis=2)

h2.calc = GPAW(kpts=(k, 1, 1),
               usesymm=False,
               occupations=FermiDirac(0.01),
               txt='h2c.txt')

for d in np.linspace(0.0, 0.4, 21):
    h2[1].x = d0 + d
    e = h2.get_potential_energy()
    h2.calc.write('h2c-%.2f.gpw' % d)
Ejemplo n.º 60
0
from ase import Atoms
from gpaw import GPAW

n = Atoms('N', magmoms=[3])
n.center(vacuum=3.5)

# Calculation with no +U correction:
n.calc = GPAW(mode='lcao',
              basis='dzp',
              txt='no_u.txt',
              xc='PBE')
e1 = n.get_potential_energy()

# Calculation with a correction U=6 eV normalized:
n.calc.set(setups={'N': ':p,6.0'}, txt='normalized_u.txt')
e2 = n.get_potential_energy()

# Calculation with a correction U=6 eV not normalized:
n.calc.set(setups={'N': ':p,6.0,0'}, txt='not_normalized_u.txt')
e3 = n.get_potential_energy()