File: basin.py

package info (click to toggle)
python-ase 3.17.0-2
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 16,340 kB
  • sloc: python: 117,348; makefile: 91
file content (59 lines) | stat: -rw-r--r-- 1,714 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import numpy as np
from ase import Atoms, io
from ase.calculators.lj import LennardJones
from ase.optimize.basin import BasinHopping
from ase.io import read
from ase.units import kB

# Global minima from
# Wales and Doye, J. Phys. Chem. A, vol 101 (1997) 5111-5116
E_global = {
    4: -6.000000,
    5: -9.103852,
    6: -12.712062,
    7: -16.505384}
N = 7
R = N**(1. / 3.)
np.random.seed(42)
pos = np.random.uniform(-R, R, (N, 3))
s = Atoms('He' + str(N),
          positions=pos)
s.set_calculator(LennardJones())
original_positions = 1. * s.get_positions()

ftraj = 'lowest.traj'

for GlobalOptimizer in [BasinHopping(s,
                                     temperature=100 * kB,
                                     dr=0.5,
                                     trajectory=ftraj,
                                     optimizer_logfile=None)]:

    if isinstance(GlobalOptimizer, BasinHopping):
        GlobalOptimizer.run(10)
        Emin, smin = GlobalOptimizer.get_minimum()
    else:
        GlobalOptimizer(totalsteps=10)
        Emin = s.get_potential_energy()
        smin = s
    print("N=", N, 'minimal energy found', Emin,
          ' global minimum:', E_global[N])

    # recalc energy
    smin.set_calculator(LennardJones())
    E = smin.get_potential_energy()
    assert abs(E - Emin) < 1e-15
    smim = read(ftraj)
    E = smin.get_potential_energy()
    assert abs(E - Emin) < 1e-15

    # check that only minima were written
    last_energy = None
    for im in io.read(ftraj + '@:'):
        energy = im.get_potential_energy()
        if last_energy is not None:
            assert energy < last_energy
        last_energy = energy

    # reset positions
    s.set_positions(original_positions)