Ejemplo n.º 1
0
def test_water():
    from ase.calculators.gaussian import Gaussian
    from ase.atoms import Atoms
    from ase.optimize.lbfgs import LBFGS
    from ase.io import read

    # First test to make sure Gaussian works
    calc = Gaussian(xc='pbe', chk='water.chk', label='water')
    calc.clean()

    water = Atoms('OHH',
                  positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)],
                  calculator=calc)

    opt = LBFGS(water)
    opt.run(fmax=0.05)

    forces = water.get_forces()
    energy = water.get_potential_energy()
    positions = water.get_positions()

    # Then test the IO routines
    water2 = read('water.log')
    forces2 = water2.get_forces()
    energy2 = water2.get_potential_energy()
    positions2 = water2.get_positions()
    # Compare distances since positions are different in standard orientation.
    dist = water.get_all_distances()
    dist2 = read('water.log', index=-1).get_all_distances()

    assert abs(energy - energy2) < 1e-7
    assert abs(forces - forces2).max() < 1e-9
    assert abs(positions - positions2).max() < 1e-6
    assert abs(dist - dist2).max() < 1e-6
Ejemplo n.º 2
0
    def __init__(self, atoms: Atoms, oszicar: Oszicar, name: str=None, time: float=None):

        if name is None:
            self.name = str(self.atoms)
        else:
            self.name = name

        self.time = time

        self.atoms = atoms
        self.potential_energy = atoms.get_potential_energy()
        self.kinetic_energy = atoms.get_kinetic_energy()
        self.total_energy = atoms.get_total_energy()
        self.temperature = atoms.get_temperature()
        # self.magmom = atoms.get_magnetic_moment()

        self.elements = Counter(atoms.get_chemical_symbols())

        self.set_area()

        self.set_oszicar(oszicar)
        n = len(atoms)
        if self.get('F'):
            self.F_n = self.F / n
        else:
            self.F_n = self.potential_energy / n
Ejemplo n.º 3
0
    def test_build_diag(self):
        direction = np.array([1., 2., 3.])
        direction /= np.linalg.norm(direction)
        r_train = np.linspace(0.5, 7, 11)
        energies_train = []
        images_train = []
        for ri in r_train:
            image = Atoms(['C', 'O'],
                          positions=np.array(
                              [-0.5 * ri * direction, 0.5 * ri * direction]))
            image.set_calculator(EMT())
            energies_train.append(image.get_potential_energy())
            images_train.append(image)
        cut = 6.5

        with SymmetryFunctionSet(["C", "O"], cutoff=cut) as sfs:
            sfs.add_Artrith_Kolpak_set()

            kernel = RBFKernel(constant=100.0, length_scale=1e-2)
            calc = GAPCalculator(descriptor_set=sfs,
                                 kernel=kernel,
                                 C1=1e8,
                                 C2=1e8,
                                 opt_restarts=0)

            [calc.add_data(im) for im in images_train]
            calc.fit()
            np.testing.assert_allclose(
                calc.build_kernel_diagonal((calc.Gs_norm, calc.dGs_norm)),
                np.diag(calc.build_kernel_matrix()))
Ejemplo n.º 4
0
def test_gfn2xtb_velocityverlet():
    """Perform molecular dynamics with GFN2-xTB and Velocity Verlet Integrator"""

    thr = 1.0e-5

    atoms = Atoms(
        symbols="NHCHC2H3OC2H3ONHCH3",
        positions=np.array([
            [1.40704587284727, -1.26605342016611, -1.93713466561923],
            [1.85007200612454, -0.46824072777417, -1.50918242392545],
            [-0.03362432532150, -1.39269245193812, -1.74003582081606],
            [-0.56857009928108, -1.01764444489068, -2.61263467107342],
            [-0.44096297340282, -2.84337808903410, -1.48899734014499],
            [-0.47991761226058, -0.55230954385212, -0.55520222968656],
            [-1.51566045903090, -2.89187354810876, -1.32273881320610],
            [-0.18116520746778, -3.45187805987944, -2.34920431470368],
            [0.06989722340461, -3.23298998903001, -0.60872832703814],
            [-1.56668253918793, 0.00552120970194, -0.52884675001441],
            [1.99245341064342, -1.73097165236442, -3.08869239114486],
            [3.42884244212567, -1.30660069291348, -3.28712665743189],
            [3.87721962540768, -0.88843123009431, -2.38921453037869],
            [3.46548545761151, -0.56495308290988, -4.08311788302584],
            [4.00253374168514, -2.16970938132208, -3.61210068365649],
            [1.40187968630565, -2.43826111827818, -3.89034127398078],
            [0.40869198386066, -0.49101709352090, 0.47992424955574],
            [1.15591901335007, -1.16524842262351, 0.48740266650199],
            [0.00723492494701, 0.11692276177442, 1.73426297572793],
            [0.88822128447468, 0.28499001838229, 2.34645658013686],
            [-0.47231557768357, 1.06737634000561, 1.52286682546986],
            [-0.70199987915174, -0.50485938116399, 2.28058247845421],
        ]),
    )

    calc = XTB(method="GFN2-xTB", cache_api=False)
    atoms.set_calculator(calc)

    dyn = VelocityVerlet(atoms, timestep=1.0 * fs)
    dyn.run(20)

    assert approx(atoms.get_potential_energy(), thr) == -896.9772346260584
    assert approx(atoms.get_kinetic_energy(), thr) == 0.022411127028842362

    atoms.calc.set(cache_api=True)
    dyn.run(20)

    assert approx(atoms.get_potential_energy(), thr) == -896.9913862530841
    assert approx(atoms.get_kinetic_energy(), thr) == 0.036580471363852810
Ejemplo n.º 5
0
def test_gfn1_xtb_3d():
    """Test ASE interface to GFN1-xTB"""
    thr = 5.0e-6

    atoms = Atoms(
        symbols='C4O8',
        positions=np.array([
            [0.9441259872, 0.9437851680, 0.9543505632],
            [3.7179966528, 0.9556570368, 3.7316862240],
            [3.7159517376, 3.7149292800, 0.9692330016],
            [0.9529872864, 3.7220864832, 3.7296981120],
            [1.6213905408, 1.6190616096, 1.6313879040],
            [0.2656685664, 0.2694175776, 0.2776540416],
            [4.3914553920, 1.6346256864, 3.0545920000],
            [3.0440834880, 0.2764611744, 4.4080419264],
            [4.3910577696, 3.0416409504, 0.2881058304],
            [3.0399936576, 4.3879335936, 1.6497353376],
            [0.2741322432, 4.4003734944, 3.0573754368],
            [1.6312174944, 3.0434586528, 4.4023048032],
        ]),
        cell=np.array([5.68032, 5.68032, 5.68032]),
        pbc=np.array([True, True, True]),
    )
    forces = np.array([
        [0.05008078, 0.06731033, 0.06324782],
        [-0.03885473, 0.07550136, -0.06667888],
        [-0.06455676, -0.04199831, 0.06908718],
        [0.04672903, -0.06303119, -0.06002863],
        [-1.9460667, -1.94514641, -1.94923488],
        [1.92953942, 1.91109506, 1.92038457],
        [-1.91269913, -1.95500822, 1.94675148],
        [1.94009239, 1.91238163, -1.93489981],
        [-1.90757165, 1.94211445, 1.94655816],
        [1.94283273, -1.90965163, -1.95863335],
        [1.91207771, -1.94256232, 1.9337591],
        [-1.95160309, 1.94899525, -1.91031277],
    ])
    charges = np.array([
        0.74256902,
        0.74308482,
        0.74305612,
        0.74300613,
        -0.37010244,
        -0.37234708,
        -0.37134504,
        -0.37177066,
        -0.37176288,
        -0.37133667,
        -0.37178059,
        -0.37127074,
    ])

    calc = XTB(method="GFN1-xTB")
    atoms.set_calculator(calc)
    assert atoms.pbc.all()

    assert approx(atoms.get_potential_energy(), abs=thr) == -1256.768167202048
    assert approx(atoms.get_forces(), abs=thr) == forces
    assert approx(atoms.get_charges(), abs=thr) == charges
Ejemplo n.º 6
0
    def test_co_potential_curve(self):
        direction = np.array([1., 2., 3.])
        direction /= np.linalg.norm(direction)
        r_train = np.linspace(0.5, 7, 11)
        energies_train = []
        images_train = []
        for ri in r_train:
            image = Atoms(['C', 'O'],
                          positions=np.array(
                              [-0.5 * ri * direction, 0.5 * ri * direction]))
            image.set_calculator(EMT())
            energies_train.append(image.get_potential_energy())
            images_train.append(image)
        cut = 6.5

        with SymmetryFunctionSet(["C", "O"], cutoff=cut) as sfs:
            # Parameters from Artrith and Kolpak Nano Lett. 2014, 14, 2670
            etas = [0.0009, 0.01, 0.02, 0.035, 0.06, 0.1, 0.2]
            rss = np.linspace(0, 6.5, 7)
            for t1 in sfs.atomtypes:
                for t2 in sfs.atomtypes:
                    for eta, rs in zip(etas, rss):
                        sfs.add_TwoBodySymmetryFunction(t1,
                                                        t2,
                                                        'BehlerG2', [eta, rs],
                                                        cuttype='cos')

            ang_etas = [0.0001, 0.003, 0.008]
            zetas = [1.0, 4.0]
            for ti in sfs.atomtypes:
                for (tj,
                     tk) in combinations_with_replacement(sfs.atomtypes, 2):
                    for eta in ang_etas:
                        for lamb in [-1.0, 1.0]:
                            for zeta in zetas:
                                sfs.add_ThreeBodySymmetryFunction(
                                    ti,
                                    tj,
                                    tk,
                                    "BehlerG3", [lamb, zeta, eta],
                                    cuttype='cos')

            # TODO: Find solution for setting the random seed. Since
            # NNCalculator builds a custom graph this does not work:
            tf.set_random_seed(1234)
            calc = NNCalculator(descriptor_set=sfs,
                                C1=1e8,
                                C2=1e8,
                                layers=[[5], [5]],
                                model_dir='./.tmp/')

            [calc.add_data(im) for im in images_train]
            calc.fit()
            np.testing.assert_allclose(
                energies_train, [calc.predict(im)[0] for im in images_train],
                rtol=1e-3,
                atol=5e-3)
Ejemplo n.º 7
0
def test_md(cp2k_factory):
    calc = cp2k_factory.calc(label='test_H2_MD')
    positions = [(0, 0, 0), (0, 0, 0.7245595)]
    atoms = Atoms('HH', positions=positions, calculator=calc)
    atoms.center(vacuum=2.0)

    # Run MD
    MaxwellBoltzmannDistribution(atoms, 0.5 * 300 * units.kB, force_temp=True)
    energy_start = atoms.get_potential_energy() + atoms.get_kinetic_energy()
    dyn = VelocityVerlet(atoms, 0.5 * units.fs)
    #def print_md():
    #    energy = atoms.get_potential_energy() + atoms.get_kinetic_energy()
    #    print("MD total-energy: %.10feV" %  energy)
    #dyn.attach(print_md, interval=1)
    dyn.run(20)

    energy_end = atoms.get_potential_energy() + atoms.get_kinetic_energy()

    assert energy_start - energy_end < 1e-4
    print('passed test "H2_MD"')
Ejemplo n.º 8
0
def test_gfn1_xtb_3d():
    """Test ASE interface to GFN1-xTB"""
    thr = 5.0e-6

    atoms = Atoms(
        symbols="C4O8",
        positions=np.array([
            [0.9441259872, 0.9437851680, 0.9543505632],
            [3.7179966528, 0.9556570368, 3.7316862240],
            [3.7159517376, 3.7149292800, 0.9692330016],
            [0.9529872864, 3.7220864832, 3.7296981120],
            [1.6213905408, 1.6190616096, 1.6313879040],
            [0.2656685664, 0.2694175776, 0.2776540416],
            [4.3914553920, 1.6346256864, 3.0545920000],
            [3.0440834880, 0.2764611744, 4.4080419264],
            [4.3910577696, 3.0416409504, 0.2881058304],
            [3.0399936576, 4.3879335936, 1.6497353376],
            [0.2741322432, 4.4003734944, 3.0573754368],
            [1.6312174944, 3.0434586528, 4.4023048032],
        ]),
        cell=np.array([5.68032, 5.68032, 5.68032]),
        pbc=np.array([True, True, True]),
    )
    forces = np.array([
        [-0.08831700, -0.07001294, -0.07468651],
        [-0.03556765, -0.02242341, +0.03047788],
        [+0.03228896, -0.03948204, -0.02892694],
        [-0.02569098, +0.03373080, -0.03161988],
        [-1.90306812, -1.90236730, -1.90612450],
        [+1.98861177, +1.96958105, +1.97849378],
        [-1.88898997, -1.93509024, +1.91692369],
        [+1.92988257, +1.95061533, -1.94116843],
        [-1.93844982, +1.93069254, +1.96026641],
        [+1.91146115, -1.88620597, -1.93901862],
        [+1.94936349, -1.94760369, +1.92150003],
        [-1.93152440, +1.91856587, -1.88611692],
    ])
    stress = np.array([
        +4.49045792e-02,
        +4.49168887e-02,
        +4.49566951e-02,
        +3.38245641e-05,
        +1.52117499e-05,
        +1.13328271e-04,
    ])

    atoms.calc = TBLite(method="GFN1-xTB")
    assert atoms.pbc.all()

    assert approx(atoms.get_potential_energy(), abs=thr) == -1257.0801067985549
    assert approx(atoms.get_forces(), abs=thr) == forces
    assert approx(atoms.get_stress(), abs=thr) == stress
Ejemplo n.º 9
0
def main():
    if "ASE_CP2K_COMMAND" not in os.environ:
        raise NotAvailable('$ASE_CP2K_COMMAND not defined')

    calc = CP2K(label='test_H2_MD')
    positions = [(0, 0, 0), (0, 0, 0.7245595)]
    atoms = Atoms('HH', positions=positions, calculator=calc)
    atoms.center(vacuum=2.0)

    # Run MD
    MaxwellBoltzmannDistribution(atoms, 0.5 * 300 * units.kB, force_temp=True)
    energy_start = atoms.get_potential_energy() + atoms.get_kinetic_energy()
    dyn = VelocityVerlet(atoms, 0.5 * units.fs)
    #def print_md():
    #    energy = atoms.get_potential_energy() + atoms.get_kinetic_energy()
    #    print("MD total-energy: %.10feV" %  energy)
    #dyn.attach(print_md, interval=1)
    dyn.run(20)

    energy_end = atoms.get_potential_energy() + atoms.get_kinetic_energy()

    assert energy_start - energy_end < 1e-4
    print('passed test "H2_MD"')
Ejemplo n.º 10
0
def main():
    if "ASE_CP2K_COMMAND" not in os.environ:
        raise NotAvailable('$ASE_CP2K_COMMAND not defined')

    calc = CP2K(label='test_H2_MD')
    positions = [(0, 0, 0), (0, 0, 0.7245595)]
    atoms = Atoms('HH', positions=positions, calculator=calc)
    atoms.center(vacuum=2.0)

    # Run MD
    MaxwellBoltzmannDistribution(atoms, 0.5 * 300 * units.kB, force_temp=True)
    energy_start = atoms.get_potential_energy() + atoms.get_kinetic_energy()
    dyn = VelocityVerlet(atoms, 0.5 * units.fs)
    #def print_md():
    #    energy = atoms.get_potential_energy() + atoms.get_kinetic_energy()
    #    print("MD total-energy: %.10feV" %  energy)
    #dyn.attach(print_md, interval=1)
    dyn.run(20)

    energy_end = atoms.get_potential_energy() + atoms.get_kinetic_energy()

    assert energy_start - energy_end < 1e-4
    print('passed test "H2_MD"')
Ejemplo n.º 11
0
def test_gfn2_xtb_3d():
    """Test ASE interface to GFN2-xTB, should fail"""
    thr = 5.0e-6

    atoms = Atoms(
        symbols='C4O8',
        positions=np.array([
            [0.9441259872, 0.9437851680, 0.9543505632],
            [3.7179966528, 0.9556570368, 3.7316862240],
            [3.7159517376, 3.7149292800, 0.9692330016],
            [0.9529872864, 3.7220864832, 3.7296981120],
            [1.6213905408, 1.6190616096, 1.6313879040],
            [0.2656685664, 0.2694175776, 0.2776540416],
            [4.3914553920, 1.6346256864, 3.0545920000],
            [3.0440834880, 0.2764611744, 4.4080419264],
            [4.3910577696, 3.0416409504, 0.2881058304],
            [3.0399936576, 4.3879335936, 1.6497353376],
            [0.2741322432, 4.4003734944, 3.0573754368],
            [1.6312174944, 3.0434586528, 4.4023048032],
        ]),
        cell=np.array([5.68032, 5.68032, 5.68032]),
        pbc=np.array([True, True, True]),
    )

    calc = XTB(method="GFN2-xTB")
    atoms.set_calculator(calc)

    with raises(CalculationFailed):
        atoms.get_potential_energy()

    # make structure molecular
    atoms.set_pbc(False)
    assert approx(atoms.get_potential_energy(), abs=thr) == -1121.9196707084955

    with raises(InputError):
        atoms.positions = np.zeros((len(atoms), 3))
        calc.calculate(atoms=atoms, system_changes=["positions"])
Ejemplo n.º 12
0
def test_no_data_file_wrap():
    """
    If 'create_atoms' hasn't been given the appropriate 'remap yes' option,
    atoms falling outside of a periodic cell are not actually created.  The
    lammpsrun calculator will then look at the thermo output and determine a
    discrepancy the number of atoms reported compared to the length of the
    ASE Atoms object and raise a RuntimeError.  This problem can only
    possibly arise when the 'no_data_file' option for the calculator is set
    to True.  Furthermore, note that if atoms fall outside of the box along
    non-periodic dimensions, create_atoms is going to refuse to create them
    no matter what, so you simply can't use the 'no_data_file' option if you
    want to allow for that scenario.
    """
    from ase.atoms import Atoms
    from ase.calculators.lammpsrun import LAMMPS

    # Make a periodic box and put one atom outside of it
    pos = [[0.0, 0.0, 0.0], [-2.0, 0.0, 0.0]]
    atoms = Atoms(symbols=["Ar"] * 2,
                  positions=pos,
                  cell=[10.0, 10.0, 10.0],
                  pbc=True)

    # Set parameters for calculator
    params = {}
    params["pair_style"] = "lj/cut 8.0"
    params["pair_coeff"] = ["1 1 0.0108102 3.345"]

    # Don't write a data file string. This will force
    # ase.calculators.lammps.inputwriter.write_lammps_in to write a bunch of
    # 'create_atoms' commands into the LAMMPS input file
    params["no_data_file"] = True

    with LAMMPS(specorder=["Ar"], **params) as calc:
        atoms.calc = calc
        atoms.get_potential_energy()
Ejemplo n.º 13
0
def test_gfn1_xtb_0d():
    """Test ASE interface to GFN1-xTB"""
    thr = 1.0e-5

    atoms = Atoms(
        symbols="CHOCH2CH4CH2OH",
        positions=np.array([
            [+1.578385, +0.147690, +0.343809],
            [+1.394750, +0.012968, +1.413545],
            [+1.359929, -1.086203, -0.359782],
            [+0.653845, +1.215099, -0.221322],
            [+1.057827, +2.180283, +0.093924],
            [+0.729693, +1.184864, -1.311438],
            [-0.817334, +1.152127, +0.208156],
            [-1.303525, +2.065738, -0.145828],
            [-0.883765, +1.159762, +1.299260],
            [+1.984120, -1.734446, -0.021385],
            [+2.616286, +0.458948, +0.206544],
            [-1.627725, -0.034052, -0.311301],
            [-2.684229, +0.151015, -0.118566],
            [-1.501868, -0.118146, -1.397506],
            [-1.324262, -1.260154, +0.333377],
            [-0.417651, -1.475314, +0.076637],
        ]),
    )
    forces = np.array([
        [-0.37070590, -0.51067739, -0.27981764],
        [-0.04339461, -0.09290876, +0.22940156],
        [+0.11141234, +0.46678720, +0.24552625],
        [+0.04255709, +0.19019316, -0.23531997],
        [-0.01897377, +0.10810803, +0.05314982],
        [-0.07150720, -0.05182148, -0.08413638],
        [+0.06631826, +0.10587709, +0.29833479],
        [-0.01062355, +0.02301460, -0.04964730],
        [+0.06610108, -0.02724994, +0.09234280],
        [+0.06519070, -0.19311773, -0.01152205],
        [+0.23879786, +0.09871398, -0.04009526],
        [-0.04381577, -0.49997745, +0.08672818],
        [-0.23259608, +0.13735636, +0.06783414],
        [+0.08297636, -0.09566973, -0.20602954],
        [-0.23686052, +0.57454371, -0.17194215],
        [+0.35512370, -0.23317164, +0.00519275],
    ])

    atoms.calc = TBLite(method="GFN1-xTB")

    assert approx(atoms.get_potential_energy(), abs=thr) == -632.7363734598027
    assert approx(atoms.get_forces(), abs=thr) == forces
Ejemplo n.º 14
0
def test_gfn2_xtb_0d():
    """Test ASE interface to GFN2-xTB"""
    thr = 1.0e-5

    atoms = Atoms(
        symbols="CHOCH2CH4CH2OH",
        positions=np.array([
            [+1.578385, +0.147690, +0.343809],
            [+1.394750, +0.012968, +1.413545],
            [+1.359929, -1.086203, -0.359782],
            [+0.653845, +1.215099, -0.221322],
            [+1.057827, +2.180283, +0.093924],
            [+0.729693, +1.184864, -1.311438],
            [-0.817334, +1.152127, +0.208156],
            [-1.303525, +2.065738, -0.145828],
            [-0.883765, +1.159762, +1.299260],
            [+1.984120, -1.734446, -0.021385],
            [+2.616286, +0.458948, +0.206544],
            [-1.627725, -0.034052, -0.311301],
            [-2.684229, +0.151015, -0.118566],
            [-1.501868, -0.118146, -1.397506],
            [-1.324262, -1.260154, +0.333377],
            [-0.417651, -1.475314, +0.076637],
        ]),
    )
    forces = np.array([
        [-0.28561308, -0.48587499, -0.28392027],
        [-0.05526371, -0.07403870, +0.09666022],
        [+0.18830054, +0.39163807, +0.33884887],
        [-0.01165266, +0.24651648, -0.16778052],
        [-0.05367208, +0.03368724, +0.05115729],
        [-0.09605395, -0.10000312, +0.01096077],
        [+0.09422811, +0.18571407, +0.17796656],
        [+0.02651446, -0.04073478, -0.03656254],
        [+0.07886459, -0.05806164, +0.00649897],
        [-0.00786081, -0.07975814, -0.03179608],
        [+0.13328259, +0.03208869, -0.04638662],
        [+0.08197190, -0.39156437, +0.12108031],
        [-0.11454175, -0.01484728, +0.09974090],
        [+0.09786247, -0.09131053, -0.05738535],
        [-0.26638845, +0.47604034, -0.27858358],
        [+0.19002181, -0.02949135, -0.00049892],
    ])

    calc = TBLite(method="GFN2-xTB", atoms=atoms)

    assert approx(atoms.get_potential_energy(), abs=thr) == -592.6794366990786
    assert approx(atoms.get_forces(), abs=thr) == forces
Ejemplo n.º 15
0
def test_orca():
    from ase.optimize import BFGS
    from ase.atoms import Atoms
    from ase.calculators.orca import ORCA

    atoms = Atoms('OHH', positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)])

    atoms.calc = ORCA(label='water', orcasimpleinput='BLYP def2-SVP')

    opt = BFGS(atoms)
    opt.run(fmax=0.05)

    final_energy = atoms.get_potential_energy()
    print(final_energy)

    assert abs(final_energy + 2077.24420) < 1.0
Ejemplo n.º 16
0
def test_molecule():
    from ase.optimize import BFGS
    from ase.atoms import Atoms
    from ase.calculators.crystal import CRYSTAL

    with open('basis', 'w') as fd:
        fd.write("""6 4
    0 0 6 2.0 1.0
     3048.0 0.001826
     456.4 0.01406
     103.7 0.06876
     29.23 0.2304
     9.349 0.4685
     3.189 0.3628
    0 1 2 4.0 1.0
     3.665 -0.3959 0.2365
     0.7705 1.216 0.8606
    0 1 1 0.0 1.0
     0.26 1.0 1.0 
    0 3 1 0.0 1.0
     0.8 1.0
    """)

    geom = Atoms('OHH',
                 positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)])

    geom.calc = CRYSTAL(
        label='water',
        guess=True,
        basis='sto-3g',
        xc='PBE',
        otherkeys=['scfdir', 'anderson',
                   ['maxcycles', '500'],
                   ['toldee', '6'],
                   ['tolinteg', '7 7 7 7 14'],
                   ['fmixing', '90']])

    opt = BFGS(geom)
    opt.run(fmax=0.05)

    final_energy = geom.get_potential_energy()
    assert abs(final_energy + 2047.34531091) < 1.0
Ejemplo n.º 17
0
async def ase_fio_task(cid, calc, atcor, ian, cell=None, pbc=None):
    """Base task for calculators implementing the
    `FileIOCalculator`_ interface (e.g. Gaussian,
    Orca, QE).

    .. _FileIOCalculator: https://gitlab.com/ase/ase/-/blob/master/ase/calculators/calculator.py

    Class ``FileIOCalculator`` is patched to enable
    async calculation through async subprocess. See
    ``monkey_patch.py`` for details.

    Args:
      cid (str): Calculation ID, for time record only
      calc: The calculator instance
      atcor (ndarray[(N,3), float]): Atom coordinate
      ian (ndarray[(N,), int]): Atomic numbers 
      pbc (bool or (bool, bool, bool)): Periodic
        boundary conditions along each axis. Arg for
        ``ase.atoms.Atoms``
      cell (ndarray[(3,3), float] or see ASE doc):
        Unit cell size. Arg for ``ase.atoms.Atoms``

    Returns:
      Energy (in hartree) and forces (in hartree/angstrom)

    .. note:: Any task calling this should make
       sure that the calculator itself's ``calculate``
       method get handled, as this only takes care
       of ``FileIOCalculator.calculate``.
    """
    from ase.atoms import Atoms
    from ase.units import Hartree as hart2ev, Bohr as b2a
    from .util import timeblock
    mol = Atoms(numbers=ian, positions=atcor, cell=cell, pbc=pbc)
    mol.calc = calc
    with timeblock(cid):
        await mol._calc.acalculate(mol, ['energy', 'forces'], [])
    return (
        mol.get_potential_energy() / hart2ev,
        mol.get_forces() * b2a / hart2ev,
    )
Ejemplo n.º 18
0
def test_gfn2xtb_lbfgs():
    """Perform geometry optimization with GFN2-xTB and L-BFGS"""

    thr = 1.0e-5

    atoms = Atoms(
        symbols="NHCHC2H3OC2H3ONHCH3",
        positions=np.array([
            [1.40704587284727, -1.26605342016611, -1.93713466561923],
            [1.85007200612454, -0.46824072777417, -1.50918242392545],
            [-0.03362432532150, -1.39269245193812, -1.74003582081606],
            [-0.56857009928108, -1.01764444489068, -2.61263467107342],
            [-0.44096297340282, -2.84337808903410, -1.48899734014499],
            [-0.47991761226058, -0.55230954385212, -0.55520222968656],
            [-1.51566045903090, -2.89187354810876, -1.32273881320610],
            [-0.18116520746778, -3.45187805987944, -2.34920431470368],
            [0.06989722340461, -3.23298998903001, -0.60872832703814],
            [-1.56668253918793, 0.00552120970194, -0.52884675001441],
            [1.99245341064342, -1.73097165236442, -3.08869239114486],
            [3.42884244212567, -1.30660069291348, -3.28712665743189],
            [3.87721962540768, -0.88843123009431, -2.38921453037869],
            [3.46548545761151, -0.56495308290988, -4.08311788302584],
            [4.00253374168514, -2.16970938132208, -3.61210068365649],
            [1.40187968630565, -2.43826111827818, -3.89034127398078],
            [0.40869198386066, -0.49101709352090, 0.47992424955574],
            [1.15591901335007, -1.16524842262351, 0.48740266650199],
            [0.00723492494701, 0.11692276177442, 1.73426297572793],
            [0.88822128447468, 0.28499001838229, 2.34645658013686],
            [-0.47231557768357, 1.06737634000561, 1.52286682546986],
            [-0.70199987915174, -0.50485938116399, 2.28058247845421],
        ]),
    )

    calc = XTB(method="GFN2-xTB", solvent="water", accuracy=0.1)
    atoms.set_calculator(calc)
    opt = LBFGS(atoms)
    opt.run(fmax=0.1)

    assert approx(atoms.get_potential_energy(), thr) == -897.4533662470938
    assert approx(np.linalg.norm(atoms.get_forces(), ord=2),
                  thr) == 0.19359647527783497
Ejemplo n.º 19
0
    def test_co_potential_curve(self):
        direction = np.array([1., 2., 3.])
        direction /= np.linalg.norm(direction)
        r_train = np.linspace(0.5, 7, 11)
        energies_train = []
        images_train = []
        for ri in r_train:
            image = Atoms(
                ['C', 'O'],
                positions=np.array([-0.5*ri*direction, 0.5*ri*direction]))
            image.set_calculator(EMT())
            energies_train.append(image.get_potential_energy())
            images_train.append(image)

        kernel = RBFKernel(constant=100.0, length_scale=1e-1)
        calc = GPRCalculator(kernel=kernel, C1=1e8, C2=1e8, opt_restarts=0)

        [calc.add_data(im) for im in images_train]
        calc.fit()
        np.testing.assert_allclose(
            energies_train,
            [calc.predict(im)[0] for im in images_train])
Ejemplo n.º 20
0
    def test_build_diag(self):
        direction = np.array([1., 2., 3.])
        direction /= np.linalg.norm(direction)
        r_train = np.linspace(0.5, 7, 11)
        energies_train = []
        images_train = []
        for ri in r_train:
            image = Atoms(['C', 'O'],
                          positions=np.array(
                              [-0.5 * ri * direction, 0.5 * ri * direction]))
            image.set_calculator(EMT())
            energies_train.append(image.get_potential_energy())
            images_train.append(image)

        def to_radius(x):
            xyzs = x.get_positions()
            r = np.sqrt(np.sum((xyzs[1, :] - xyzs[0, :])**2))
            dr = np.zeros((1, 6))
            dr[0, 0] = (xyzs[0, 0] - xyzs[1, 0]) / r
            dr[0, 1] = (xyzs[0, 1] - xyzs[1, 1]) / r
            dr[0, 2] = (xyzs[0, 2] - xyzs[1, 2]) / r
            dr[0, 3] = (xyzs[1, 0] - xyzs[0, 0]) / r
            dr[0, 4] = (xyzs[1, 1] - xyzs[0, 1]) / r
            dr[0, 5] = (xyzs[1, 2] - xyzs[0, 2]) / r
            return [r], dr

        kernel = RBFKernel(constant=100.0, length_scale=1e-1)
        calc = NCGPRCalculator(input_transform=to_radius,
                               kernel=kernel,
                               C1=1e8,
                               C2=1e8,
                               opt_restarts=0)

        [calc.add_data(im) for im in images_train]
        calc.fit()
        np.testing.assert_allclose(
            calc.build_kernel_diagonal((calc.q_train, calc.dq_train)),
            np.diag(calc.build_kernel_matrix()))
Ejemplo n.º 21
0
    number_of_atoms = []
    scat.set_processor(proc, alg)
    type_list.append((proc, alg))
    nrg_l = []
    f_l = []
    try:
        for i in sizes:
            atoms = build_sphere_np('/mnt/work-data/dev/pyIID/benchmarks/1100138.cif', float(i) / 2)
            atoms.rattle()
            print len(atoms), i/10.
            number_of_atoms.append(len(atoms))
            calc = PDFCalc(obs_data=pdf, scatter=scat, conv=1, potential='rw')
            atoms.set_calculator(calc)

            s = time.time()
            nrg = atoms.get_potential_energy()
            # scat.get_fq(atoms)
            f = time.time()

            nrg_l.append(f-s)

            s = time.time()
            # force = atoms.get_forces()
            # scat.get_grad_fq(atoms)
            f = time.time()
            f_l.append(f-s)
    except:
        print traceback.format_exc()
        break
    time_list.append((nrg_l, f_l))
Ejemplo n.º 22
0
                basis='sto-3g',
                force='force',
                nproc=1,
                chk='water.chk',
                label='water')
calc.clean()

water = Atoms('OHH',
              positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)],
              calculator=calc)

opt = LBFGS(water)
opt.run(fmax=0.05)

forces = water.get_forces()
energy = water.get_potential_energy()
positions = water.get_positions()

# Then test the IO routines
from ase.io import read
water2 = read('water.log')
forces2 = water2.get_forces()
energy2 = water2.get_potential_energy()
positions2 = water2.get_positions()
#compare distances since positions are different in standard orientation
dist = water.get_all_distances()
dist2 = read('water.log', quantity='structures')[-1].get_all_distances()

assert abs(energy - energy2) < 1e-7
assert abs(forces - forces2).max() < 1e-9
assert abs(positions - positions2).max() < 1e-6
Ejemplo n.º 23
0
class TestCalculator_SW_Potential(quippytest.QuippyTestCase):
    def setUp(self):
        self.xml = """
      <SW_params n_types="2" label="PRB_31_plus_H">
      <comment> Stillinger and Weber, Phys. Rev. B  31 p 5262 (1984), extended for other elements </comment>
      <per_type_data type="1" atomic_num="1" />
      <per_type_data type="2" atomic_num="14" />
      <per_pair_data atnum_i="1" atnum_j="1" AA="0.0" BB="0.0"
      p="0" q="0" a="1.0" sigma="1.0" eps="0.0" />
      <per_pair_data atnum_i="1" atnum_j="14" AA="8.581214" BB="0.0327827"
      p="4" q="0" a="1.25" sigma="2.537884" eps="2.1672" />
      <per_pair_data atnum_i="14" atnum_j="14" AA="7.049556277" BB="0.6022245584"
      p="4" q="0" a="1.80" sigma="2.0951" eps="2.1675" />

      <!-- triplet terms: atnum_c is the center atom, neighbours j and k -->
      <per_triplet_data atnum_c="1"  atnum_j="1"  atnum_k="1"
      lambda="21.0" gamma="1.20" eps="2.1675" />
      <per_triplet_data atnum_c="1"  atnum_j="1"  atnum_k="14"
      lambda="21.0" gamma="1.20" eps="2.1675" />
      <per_triplet_data atnum_c="1"  atnum_j="14" atnum_k="14"
      lambda="21.0" gamma="1.20" eps="2.1675" />

      <per_triplet_data atnum_c="14" atnum_j="1"  atnum_k="1"
      lambda="21.0" gamma="1.20" eps="2.1675" />
      <per_triplet_data atnum_c="14" atnum_j="1"  atnum_k="14"
      lambda="21.0" gamma="1.20" eps="2.1675" />
      <per_triplet_data atnum_c="14" atnum_j="14" atnum_k="14"
      lambda="21.0" gamma="1.20" eps="2.1675" />
      </SW_params>
      """

        quippy.system_module.system_reseed_rng(2065775975)
        self.pot_calculator = Potential('IP SW', param_str=self.xml)

        self.at = Atoms('Si8',
                        positions=diamond_pos,
                        pbc=True,
                        cell=[5.44, 5.44, 5.44])

        self.f = np.zeros((3, len(self.at)), order='F')
        self.df = np.zeros((3, len(self.at)), order='F')
        self.v = np.zeros((3, 3), order='F')

        self.energy_ref = -34.5038375509

        self.forces_ref = np.array([[0.89920374, -0.38025157, -0.38727027],
                                    [0.36623356, -0.52403757, 0.7200206],
                                    [-0.36952654, 0.12899529, 0.00458111],
                                    [-0.19912365, -0.1632057, 1.08509495],
                                    [-0.67565314, -0.59410498, -0.47921521],
                                    [0.17097454, 0.5847822, -0.31088749],
                                    [0.43613712, 0.90811269, 0.1600328],
                                    [-0.62824563, 0.03970963, -0.79235649]])

        self.virial_ref = np.array([[-0.34103601, 0.60925144, -0.02138795],
                                    [0.60925144, -0.36145702, -0.19375487],
                                    [-0.02138795, -0.19375487, -0.34640615]]).T

        # Voigt notation by hand from virial
        self.stress_ref = -np.array([
            -0.34103601, -0.36145702, -0.34640615, -0.19375487, -0.02138795,
            0.60925144
        ]) / self.at.get_volume()

        self.at.set_calculator(self.pot_calculator)

    def test_energy(self):
        self.assertAlmostEqual(self.at.get_potential_energy(), self.energy_ref)

    def test_forces(self):
        self.assertArrayAlmostEqual(self.at.get_forces(),
                                    self.forces_ref,
                                    tol=1E-06)

    def test_stress(self):
        self.assertArrayAlmostEqual(self.at.get_stress(), self.stress_ref)

    def test_virial(self):
        self.assertArrayAlmostEqual(self.pot_calculator.get_virial(self.at),
                                    self.virial_ref,
                                    tol=1E-06)

    def test_calc_args_1(self):
        self.pot_calculator.calculate(self.at,
                                      propertes=["forces"],
                                      calc_args="do_rescale_E E_scale=1.01")
        f = self.pot_calculator.results['forces']
        self.assertArrayAlmostEqual(f, self.forces_ref * 1.01, tol=1E-06)

    def test_calc_args_2(self):
        self.pot_calculator.calculate(self.at,
                                      properties=["forces"],
                                      do_rescale_E=True,
                                      E_scale=1.01)
        f = self.pot_calculator.results['forces']
        self.assertArrayAlmostEqual(f, self.forces_ref * 1.01, tol=1E-06)

    def test_calc_args_3(self):
        pot2 = Potential('IP SW',
                         param_str=self.xml,
                         calc_args="do_rescale_E E_scale=1.01")
        f = pot2.get_forces(self.at)
        self.assertArrayAlmostEqual(f, self.forces_ref * 1.01, tol=1E-06)

    def test_calc_args_4(self):
        pot2 = Potential('IP SW',
                         param_str=self.xml,
                         calc_args={
                             'do_rescale_E': True,
                             'E_scale': 1.01
                         })
        f = pot2.get_forces(self.at)
        self.assertArrayAlmostEqual(f, self.forces_ref * 1.01, tol=1E-06)
Ejemplo n.º 24
0
class execution(object):
    def __init__(self, executionInput, xyz=None, stateFile='state.json'):
        '''
  Setup a new execution

  Name:  input file
  xyz:   xyz coordinates (for future automated execution)
  stateFile: state file to use for tracking of executions

  TODO: 

  - only ground state in non-periodic cell supported NOW, more to add!
  - inputs from a dict to better handle automated executions
  '''
        if isinstance(executionInput, str):
            self.inp = self.json(executionInput)
            self.inputFileName = executionInput

        if isinstance(executionInput, dict):
            self.inp = executionInput
            self.inputFileName = 'dict'  # TODO: generate meaningful name here (how?)

        self.setup()

    def setup(self):
        '''setup'''

        self.functional = self.inp.get('functional') or 'LDA'
        self.runtype = self.inp.get('runtype') or 'calc'

        # this actually can't be none!
        _xyz = self.inp.get('xyz')

        if isinstance(_xyz, str):
            self.inputXYZ = _xyz
            self.atoms = read(self.inputXYZ)
        else:
            # support reading frm a dict (TODO: other type of objects - ?)
            from ase.atoms import Atoms
            from ase.atom import Atom

            self.atoms = \
             Atoms([Atom(a[0],(a[1],a[2],a[3])) for a in _xyz])

        # TODO: support multiple cell types
        self.atoms.cell = (self.inp['cell']['x'], self.inp['cell']['y'],
                           self.inp['cell']['z'])

        # Mixer setup - only "broyden" supported
        self.mixer = self.inp.get('mixer')

        if self.mixer is None:
            self.mixer = Mixer
        else:
            self.mixer = BroydenMixer

        # Custom ID: allow to trace parameter set using a custom id
        self.custom_id = self.inp.get('custom_id')

        # Periodic Boundary Conditions
        self.atoms.pbc = False

        # This should not be done always
        self.atoms.center()

        self.nbands = self.inp.get('nbands')

        self.gpts = None
        self.setup_gpts()

        self.max_iterations = self.inp.get('maxiter') or 333

        # Name: to be set by __str__ first time it is run
        self.name = None

        #
        self.logExtension = 'txt'
        self.dataExtension = 'gpw'

        # Timing / statistics
        self.lastElapsed = None

    #
    def get_optimizer(self, name='QuasiNewton'):

        from importlib import import_module

        name = name.lower()
        _optimMap = \
         {
          'mdmin':       'MDMin',
          'hesslbfgs':   'HessLBFGS',
          'linelbfgs':   'LineLBFGS',
          'fire':        'FIRE',
          'lbfgs':       'LBFGS',
          'lbfgsls':     'LBFGSLineSearch',
          'bfgsls':      'BFGSLineSearch',
          'bfgs':        'BFGS',
          'quasinewton': 'QuasiNewton'
         }
        _class = _optimMap[name]
        _m = import_module('ase.optimize')
        return getattr(_m, _class)

    #
    def setup_gpts(self):
        self.gpts = h2gpts(self.inp.get('spacing') or 0.20,
                           self.atoms.get_cell(),
                           idiv=self.inp.get('idiv') or 8)

    def filename(self, force_id=None, extension='txt'):
        '''to correctly support this:
     stateFile support must be completed
     as it isn't just add "_0" to __str__() for now
  '''
        base = self.__str__()

        if self.custom_id is not None:
            base = base + '_' + self.custom_id

        if force_id is None:
            _fn = base + '_0.' + extension
        else:
            _fn = '{}_{}.{}'.format(base, force_id, extension)

        return _fn

    #
    @property
    def xyz(self):
        return self.inp['xyz']

    #
    @property
    def spacegroup(self):
        '''international ID of determined spacegroup'''
        sg = spglib.get_symmetry_dataset(spglib.refine_cell(
            self.atoms))['international']

        return sg.replace('/', ':')

    #
    def __str__(self):
        '''get execution name - to be used for log filename

  Components:

  - Number atoms
  - Volume
  - Spacegroup number
  - Functional name

  '''

        if self.name is None:
            self.name = '{}_{}_{}_{}'.format(
                len(self.atoms), int(self.atoms.get_volume() * 100),
                self.spacegroup, self.functional)

        _gpaw = os.environ['GPAW']
        _pwd = os.environ['PWD']

        self.procname = '{} ({})'.format(self.name,
                                         _pwd.replace(_gpaw + '/', ''))
        setproctitle(self.procname)

        return self.name

    ##
    def print(self, *args, **kwargs):
        '''print wrapper - initial step before logger'''
        r = print(*args, *kwargs)
        return r

    #
    def pretty(self):
        '''pretty print original parameters'''
        _p = pformat(self.inp)
        self.print(_p)

    #
    def json(self, filename):
        '''load parameters from json'''

        with open(filename, 'rb') as f:
            s = f.read()
            j = json.loads(s)

        return j

    #
    def run(self, force_id=None, runtype=None):
        '''
    perform execution - only calc or optim supported now
  '''

        _lastStart = time.time()

        if runtype is None and self.runtype is 'calc':
            _f = self.calc
        else:
            _f = self.optim

        # calculate
        try:
            result = _f(force_id)
        finally:
            _lastEnd = time.time()
            self.lastElapsed = _lastEnd - _lastStart

        return result

    #
    def calc(self, force_id=None, functional=None):
        '''prepare and launch execution
     force_id: use this id for filename generation
  '''

        # Allow to override the funtional
        _fnl = functional or self.functional

        # generate filenames
        _fn = self.filename(force_id)
        _dn = self.filename(force_id, extension=self.dataExtension)

        self.print('Calculation with {} log and Input: {}.'.format(
            _fn, self.inputFileName))

        if self.nbands is None:
            _calc = GPAW(xc=_fnl,
                         txt=self.filename(force_id),
                         mixer=self.mixer(),
                         maxiter=self.max_iterations,
                         gpts=self.gpts)
        else:
            _calc = GPAW(xc=_fnl,
                         txt=self.filename(force_id),
                         nbands=self.nbands,
                         mixer=self.mixer(),
                         maxiter=self.max_iterations,
                         gpts=self.gpts)

        self.atoms.set_calculator(_calc)
        self.atoms.get_potential_energy()

        # write out wavefunctions
        _calc.write(_dn, 'all')
        return _calc

    #####
    def optim(self, force_id=None, functional=None):
        '''prepare and launch execution
     force_id: use this id for filename generation
  '''

        _optim_name = self.inp.get('optimizer') or 'QuasiNewton'
        optimizer = self.get_optimizer(_optim_name)

        # Allow to override the funtional
        _fnl = functional or self.functional

        # generate filenames
        _fn = self.filename(force_id)
        _dn = self.filename(force_id, extension=self.dataExtension)

        self.print('Optimization with {} log and Input: {}.'.format(
            _fn, self.inputFileName))

        if self.nbands is None:
            _calc = GPAW(xc=_fnl,
                         txt=self.filename(force_id),
                         mixer=self.mixer(),
                         maxiter=self.max_iterations,
                         gpts=self.gpts)
        else:
            _calc = GPAW(xc=_fnl,
                         txt=self.filename(force_id),
                         nbands=self.nbands,
                         mixer=self.mixer(),
                         maxiter=self.max_iterations,
                         gpts=self.gpts)

        self.atoms.set_calculator(_calc)

        self.opt = optimizer(self.atoms,
                             trajectory=self.__str__() + '_emt.traj')
        self.opt.run(fmax=0.05)

        # write out wavefunctions
        _calc.write(_dn, 'all')
        return _calc
Ejemplo n.º 25
0
from ase.optimize import BFGS
from ase.atoms import Atoms
from ase.calculators.crystal import CRYSTAL

geom = Atoms('OHH', positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)])

geom.set_calculator(
    CRYSTAL(label='water',
            guess=True,
            basis='sto-3g',
            xc='PBE',
            otherkeys=[
                'scfdir', 'anderson', ['maxcycles', '500'], ['toldee', '6'],
                ['tolinteg', '7 7 7 7 14'], ['fmixing', '90']
            ]))

opt = BFGS(geom)
opt.run(fmax=0.05)

final_energy = geom.get_potential_energy()
assert abs(final_energy + 2047.34531091) < 1.0
Ejemplo n.º 26
0
from gpaw import GPAW
from ase.atoms import Atoms

atoms = Atoms("C", positions=[[0.0, 0.0, 0.0]])
atoms.center(vacuum=4.0)
print(atoms)

calc = GPAW(txt="-", hund=True)

from ase.units import Hartree
atoms.set_calculator(calc)

Etot = atoms.get_potential_energy()

# convert from eV to Ha
print("Etot = %18.10f Ha\n" % (Etot / Hartree))
Ejemplo n.º 27
0
def test_gfn1_xtb_0d():
    """Test ASE interface to GFN1-xTB"""
    thr = 1.0e-5

    atoms = Atoms(
        symbols='CHOCH2CH4CH2OH',
        positions=np.array([
            [1.578385, 0.147690, 0.343809],
            [1.394750, 0.012968, 1.413545],
            [1.359929, -1.086203, -0.359782],
            [0.653845, 1.215099, -0.221322],
            [1.057827, 2.180283, 0.093924],
            [0.729693, 1.184864, -1.311438],
            [-0.817334, 1.152127, 0.208156],
            [-1.303525, 2.065738, -0.145828],
            [-0.883765, 1.159762, 1.299260],
            [1.984120, -1.734446, -0.021385],
            [2.616286, 0.458948, 0.206544],
            [-1.627725, -0.034052, -0.311301],
            [-2.684229, 0.151015, -0.118566],
            [-1.501868, -0.118146, -1.397506],
            [-1.324262, -1.260154, 0.333377],
            [-0.417651, -1.475314, 0.076637],
        ]),
    )
    forces = np.array([[-0.37070590, -0.51067739, -0.27981764],
                       [-0.04339461, -0.09290876, 0.22940156],
                       [0.11141234, 0.46678720, 0.24552625],
                       [0.04255709, 0.19019316, -0.23531997],
                       [-0.01897377, 0.10810803, 0.05314982],
                       [-0.07150720, -0.05182148, -0.08413638],
                       [0.06631826, 0.10587709, 0.29833479],
                       [-0.01062355, 0.02301460, -0.04964730],
                       [0.06610108, -0.02724994, 0.09234280],
                       [0.06519070, -0.19311773, -0.01152205],
                       [0.23879786, 0.09871398, -0.04009526],
                       [-0.04381577, -0.49997745, 0.08672818],
                       [-0.23259608, 0.13735636, 0.06783414],
                       [0.08297636, -0.09566973, -0.20602954],
                       [-0.23686052, 0.57454371, -0.17194215],
                       [0.35512370, -0.23317164, 0.00519275]])
    charges = np.array([
        0.19494678,
        0.01759972,
        -0.57108503,
        -0.05371086,
        0.02458495,
        0.03915074,
        -0.06889977,
        0.02521441,
        0.03350058,
        0.34380081,
        0.01442221,
        0.20053193,
        0.02454679,
        0.01011690,
        -0.58349877,
        0.34877861,
    ])
    dipole_moment = np.array([0.76943477, 0.33021928, 0.05670150])

    atoms.calc = XTB(method="GFN1-xTB")

    assert approx(atoms.get_potential_energy(), thr) == -632.7363734598027
    assert approx(atoms.get_forces(), thr) == forces
    assert approx(atoms.get_charges(), thr) == charges
    assert approx(atoms.get_dipole_moment(), thr) == dipole_moment
Ejemplo n.º 28
0
from ase.atoms import Atoms
from ase.optimize.lbfgs import LBFGS

# First test to make sure Gaussian works
calc = Gaussian(method='pbepbe', basis='sto-3g', force='force',
                nproc=1, chk='water.chk', label='water')
calc.clean()

water = Atoms('OHH',
              positions=[(0., 0. ,0. ), (1. ,0. ,0. ), (0. ,1. ,0. )],
              calculator=calc)

opt = LBFGS(water)
opt.run(fmax=0.05)

forces = water.get_forces()
energy = water.get_potential_energy()
positions = water.get_positions()

# Then test the IO routines
from ase.io import read
water2 = read('water/water.log')
forces2 = water2.get_forces()
energy2 = water2.get_potential_energy()
positions2 = water2.get_positions()

assert (energy - energy2) < 1e-14
assert (forces.all() - forces2.all()) < 1e-14
assert (positions.all() - positions2.all()) < 1e-14
Ejemplo n.º 29
0
def test_gfn2_xtb_0d():
    """Test ASE interface to GFN2-xTB"""
    thr = 1.0e-5

    atoms = Atoms(
        symbols='CHOCH2CH4CH2OH',
        positions=np.array([
            [1.578385, 0.147690, 0.343809],
            [1.394750, 0.012968, 1.413545],
            [1.359929, -1.086203, -0.359782],
            [0.653845, 1.215099, -0.221322],
            [1.057827, 2.180283, 0.093924],
            [0.729693, 1.184864, -1.311438],
            [-0.817334, 1.152127, 0.208156],
            [-1.303525, 2.065738, -0.145828],
            [-0.883765, 1.159762, 1.299260],
            [1.984120, -1.734446, -0.021385],
            [2.616286, 0.458948, 0.206544],
            [-1.627725, -0.034052, -0.311301],
            [-2.684229, 0.151015, -0.118566],
            [-1.501868, -0.118146, -1.397506],
            [-1.324262, -1.260154, 0.333377],
            [-0.417651, -1.475314, 0.076637],
        ]),
    )
    forces = np.array([
        [-0.28561158, -0.48592026, -0.28392327],
        [-0.05526158, -0.07403455, 0.09665539],
        [0.18824950, 0.39170140, 0.33881928],
        [-0.01166074, 0.24653252, -0.16779606],
        [-0.05367503, 0.03368063, 0.05115422],
        [-0.09605262, -0.10000389, 0.01097286],
        [0.09423300, 0.18573616, 0.17797438],
        [0.02651896, -0.04073849, -0.03655980],
        [0.07886359, -0.05806479, 0.00649360],
        [-0.00780520, -0.07979390, -0.03175697],
        [0.13328595, 0.03209283, -0.04638514],
        [0.08197778, -0.39157299, 0.12107401],
        [-0.11453823, -0.01485088, 0.09974068],
        [0.09786017, -0.09130861, -0.05738675],
        [-0.26643400, 0.47603727, -0.27856705],
        [0.19005003, -0.02949244, -0.00050938],
    ])
    charges = np.array([
        0.08239823,
        0.03066406,
        -0.44606929,
        -0.06139043,
        0.03610596,
        0.05389499,
        -0.06991855,
        0.03384415,
        0.04665524,
        0.28688538,
        0.02246569,
        0.08251610,
        0.03810481,
        0.01883776,
        -0.46691965,
        0.31192554,
    ])
    dipole_moment = np.array([0.62120710, 0.28006659, 0.04465985])

    calc = XTB(method="GFN2-xTB", atoms=atoms)

    assert approx(atoms.get_potential_energy(), abs=thr) == -592.6794366990786
    assert approx(atoms.get_forces(), abs=thr) == forces
    assert approx(atoms.get_charges(), abs=thr) == charges
    assert approx(atoms.get_dipole_moment(), abs=thr) == dipole_moment

    atoms.calc.set(
        accuracy=0.1,
        electronic_temperature=500.0,
        max_iterations=20,
        solvent="ch2cl2",
    )

    assert approx(atoms.get_potential_energy(), abs=thr) == -592.9940608761889