def test_ace(): label = "test" mol = Atoms('H2', [(0, 0, 0), (0, 0, 0.7)]) basic = [dict(Cell='5.0')] ace = ACE(label=label, BasicInformation=basic) mol.calc = ace mol.get_forces()
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
def test_ace(): import os import unittest from ase import Atoms from ase.calculators.acemolecule import ACE label = "test" mol = Atoms('H2',[(0, 0, 0),(0, 0, 0.7)]) basic = [dict(Cell= '5.0')] if "ASE_ACE_COMMAND" not in os.environ: raise unittest.SkipTest('$ASE_ACE_COMMAND not defined') ace = ACE(label=label, BasicInformation=basic) mol.set_calculator(ace) mol.get_forces()
def read_images(filename, state_number=None, mode=None): f = open(filename, 'r') atoms = [] ener = [] cycle = -1 while True: elements = [] positions = [] forces = [] line = f.readline() if not line: break if cycle == -1: atom_numb = int(line.split()[0]) line = f.readline() ener.append(float(line.split()[0])) #read one particular structure assinged by state_number if state_number is not None: if cycle == state_number: for i in range(atom_numb): line = f.readline() fields = line.split() elements.append(fields[0]) positions.append([float(fields[j + 1]) for j in range(3)]) elements = np.array(elements) positions = np.array(positions) return Atoms(elements, positions=positions) else: for i in range(atom_numb): f.readline() else: for i in range(atom_numb): line = f.readline() fields = line.split() elements.append(fields[0]) positions.append([float(fields[j + 1]) for j in range(3)]) forces.append([float(fields[j + 1]) for j in range(3, 6)]) elements = np.array(elements) positions = np.array(positions) p = Atoms(elements, positions=positions) calc = force_setter() p.set_calculator(calc) print p.get_potential_energy() print p.get_forces() atoms.append(p) cycle += 1 f.close() return atoms
def test_tipnp(): """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
def run(calc, phonon, config_type, disp): supercells = phonon.get_supercells_with_displacements() # Force calculations by calculator set_of_forces = [] for (i, scell) in enumerate(supercells): ########## at = Atoms(symbols=scell.get_chemical_symbols(), scaled_positions=scell.get_scaled_positions(), cell=scell.get_cell(), pbc=True) at.set_calculator(calc) energy = at.get_potential_energy(force_consistent=True) forces = at.get_forces() stress = at.get_stress(voigt=False) drift_force = forces.sum(axis=0) print(("[Phonopy] Drift force:" + "%11.5f" * 3) % tuple(drift_force)) # Simple translational invariance for force in forces: force -= drift_force / forces.shape[0] at.arrays["force"] = forces at.info["virial"] = -1.0 * at.get_volume() * stress at.info["energy"] = energy write("./Ti_{}_{}_scell2.xyz".format(config_type, disp), at) #write("{}_scell.xyz".format(i), at) set_of_forces.append(forces) return set_of_forces
def test_relax_co_ase_interactive_bfgs(tmpdir): tmpdir.chdir() co = Atoms('CO', [[2.256 * Bohr, 0.0, 0.0], [0.0, 0.0, 0.0]]) co.set_cell(np.ones(3) * 12.0 * Bohr) calc = iEspresso(pw=24.0 * Rydberg, dw=144.0 * Rydberg, kpts='gamma', xc='PBE', calculation='relax', ion_dynamics='ase3', spinpol=False, outdir='qe_ase_interactive_bfgs') co.set_calculator(calc) minimizer = BFGS(co, logfile='minimizer.log', trajectory='relaxed.traj') minimizer.run(fmax=0.01) ref_ene = -616.9017404193379 ref_pos = np.array([[1.19233393e+00, 0.0e+00, 0.00000000e+00], [1.48996586e-03, 0.00000000e+00, 0.00000000e+00]]) ref_for = np.array([[0.00162288, 0.0, 0.0], [-0.00162288, 0.0, 0.0]]) assert np.allclose(co.get_potential_energy(), ref_ene) #assert np.allclose(co.positions, ref_pos) #assert np.allclose(co.get_forces(), ref_for) print(co.positions) print(co.get_forces())
def main(): if sys.version_info < (2, 7): raise NotAvailable('read_xml requires Python version 2.7 or greater') 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) co.set_calculator(calc) energy = co.get_potential_energy() forces = co.get_forces() # 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 array_almost_equal(conf.get_forces(), forces, tol=1e-4) # Cleanup calc.clean()
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))
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
def phonons(model, bulk, supercell, dx, mesh=None, points=None, n_points=50): import model unitcell = PhonopyAtoms(symbols=bulk.get_chemical_symbols(), cell=bulk.get_cell(), scaled_positions=bulk.get_scaled_positions()) phonon = Phonopy(unitcell, supercell) phonon.generate_displacements(distance=dx) sets_of_forces = [] for s in phonon.get_supercells_with_displacements(): at = Atoms(cell=s.get_cell(), symbols=s.get_chemical_symbols(), scaled_positions=s.get_scaled_positions(), pbc=3 * [True]) at.set_calculator(model.calculator) sets_of_forces.append(at.get_forces()) phonon.set_forces(sets_of_forces=sets_of_forces) phonon.produce_force_constants() properties = {} if mesh is not None: phonon.set_mesh(mesh, is_gamma_center=True) qpoints, weights, frequencies, eigvecs = phonon.get_mesh() properties["frequencies"] = frequencies.tolist() properties["weights"] = weights.tolist() if points is not None: bands = [] for i in range(len(points) - 1): band = [] for r in np.linspace(0, 1, n_points): band.append(points[i] + (points[i + 1] - points[i]) * r) bands.append(band) phonon.set_band_structure(bands, is_eigenvectors=True, is_band_connection=False) band_q_points, band_distances, band_frequencies, band_eigvecs = phonon.get_band_structure( ) band_distance_max = np.max(band_distances) band_distances = [(_b / band_distance_max).tolist() for _b in band_distances] band_frequencies = [_b.tolist() for _b in band_frequencies] properties["band_q_points"] = band_q_points properties["band_distances"] = band_distances properties["band_frequencies"] = band_frequencies properties["band_eigvecs"] = band_eigvecs properties["phonopy"] = phonon return properties
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
def calc_force(iscell): scell = supercells[iscell] cell = Atoms(symbols=scell.get_chemical_symbols(), scaled_positions=scell.get_scaled_positions(), cell=scell.get_cell(), pbc=True) if is_mag: cell.set_initial_magnetic_moments(sc_mag) cell.set_calculator(copy.deepcopy(calc)) dir_name = "PHON_CELL%s" % iscell cur_dir = os.getcwd() if not os.path.exists(dir_name): os.mkdir(dir_name) if prepare_initial_wavecar: os.system('ln -s %s %s' % (os.path.abspath("SUPERCELL0/WAVECAR"), os.path.join(dir_name, 'WAVECAR'))) os.chdir(dir_name) forces = cell.get_forces() print("[Phonopy] Forces: %s" % forces) # Do something other than calculating the forces with func. # func: func(atoms, calc, func_args) if func is not None: func(cell, calc, **func_args) os.chdir(cur_dir) drift_force = forces.sum(axis=0) print("[Phonopy] Drift force:", "%11.5f" * 3 % tuple(drift_force)) # Simple translational invariance for force in forces: force -= drift_force / forces.shape[0] return forces
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)
def test_relax_co_ase_bfgs(tmpdir): tmpdir.chdir() co = Atoms('CO', [[2.256 * Bohr, 0.0, 0.0], [0.0, 0.0, 0.0]]) co.set_cell(np.ones(3) * 12.0 * Bohr) calc = Espresso(pw=24.0 * Rydberg, dw=144.0 * Rydberg, kpts='gamma', xc='PBE', calculation='scf', ion_dynamics=None, spinpol=False, outdir='qe_ase_bfgs') co.set_calculator(calc) minimizer = BFGS(co, logfile='minimizer.log', trajectory='relaxed.traj') minimizer.run(fmax=0.01) print('ase(scf) bfgs:') print('energy: ', co.get_potential_energy()) print('positions: ', co.positions) print('forces: ', co.get_forces())
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)
def main(): 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.set_calculator(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()
def test_h2(): from ase import Atoms from ase.calculators.emt import EMT h2 = Atoms('H2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) f1 = h2.calc.calculate_numerical_forces(h2, 0.0001) f2 = h2.get_forces() assert abs(f1 - f2).max() < 1e-6
def test_ase(self): from ase import Atoms from deepmd.calculator import DP water0 = Atoms('OHHOHH', positions=self.coords.reshape((-1, 3)), cell=self.box.reshape((3, 3)), calculator=DP(FROZEN_MODEL)) water1 = Atoms('OHHOHH', positions=self.coords.reshape((-1, 3)), cell=self.box.reshape((3, 3)), calculator=DP(COMPRESSED_MODEL)) ee0 = water0.get_potential_energy() ff0 = water0.get_forces() ee1 = water1.get_potential_energy() ff1 = water1.get_forces() nframes = 1 np.testing.assert_almost_equal(ff0, ff1, default_places) np.testing.assert_almost_equal(ee0, ee1, default_places)
def testANIDataset(self): builtin = torchani.neurochem.Builtins() calculator = torchani.ase.Calculator(builtin.species, builtin.aev_computer, builtin.models, builtin.energy_shifter) default_neighborlist_calculator = torchani.ase.Calculator( builtin.species, builtin.aev_computer, builtin.models, builtin.energy_shifter, True) nnp = torch.nn.Sequential(builtin.aev_computer, builtin.models, builtin.energy_shifter) for i in range(N): datafile = os.path.join(path, 'test_data/ANI1_subset/{}'.format(i)) with open(datafile, 'rb') as f: coordinates, species, _, _, _, _ = pickle.load(f) coordinates = coordinates[0] species = species[0] species_str = [builtin.consts.species[i] for i in species] atoms = Atoms(species_str, positions=coordinates) atoms.set_calculator(calculator) energy1 = atoms.get_potential_energy() / units.Hartree forces1 = atoms.get_forces() / units.Hartree atoms2 = Atoms(species_str, positions=coordinates) atoms2.set_calculator(default_neighborlist_calculator) energy2 = atoms2.get_potential_energy() / units.Hartree forces2 = atoms2.get_forces() / units.Hartree coordinates = torch.tensor(coordinates, requires_grad=True).unsqueeze(0) _, energy3 = nnp( (torch.from_numpy(species).unsqueeze(0), coordinates)) forces3 = -torch.autograd.grad(energy3.squeeze(), coordinates)[0].numpy() energy3 = energy3.item() self.assertLess(abs(energy1 - energy2), tol) self.assertLess(abs(energy1 - energy3), tol) diff_f12 = torch.tensor(forces1 - forces2).abs().max().item() self.assertLess(diff_f12, tol) diff_f13 = torch.tensor(forces1 - forces3).abs().max().item() self.assertLess(diff_f13, tol)
def main(): if sys.version_info < (2, 7): raise NotAvailable('read_xml requires Python version 2.7 or greater') 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='LDA', prec='Low', algo='Fast', ismear=0, sigma=1., nbands=12, istart=0, nelm=3, lwave=False, lcharg=False, ldipol=True) co.set_calculator(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 # Check some arrays assert np.allclose(conf.get_forces(), forces) assert np.allclose(conf.get_dipole_moment(), dipole_moment, atol=1e-6) # Check k-point-dependent properties assert len(conf.calc.get_eigenvalues(spin=0)) >= 12 assert conf.calc.get_occupation_numbers()[2] == 2 assert conf.calc.get_eigenvalues(spin=1) is None kpt = conf.calc.get_kpt(0) assert kpt.weight == 1. # Perform a spin-polarised calculation co.calc.set(ispin=2, ibrion=-1) co.get_potential_energy() conf = read('vasprun.xml') assert len(conf.calc.get_eigenvalues(spin=1)) >= 12 assert conf.calc.get_occupation_numbers(spin=1)[0] == 1. # Cleanup calc.clean()
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))
def generate_images(): '''Generates five images with varying configurations''' images = [] for step in range(5): image = Atoms([ Atom('Pd', (0., 0., 0.)), Atom('O', (0., 2., 0.)), Atom('Pd', (0., 0., 3.)), Atom('Pd', (1., 0., 0.)) ]) if step > 0: image[step - 1].position = \ image[step - 1].position + np.array([0., 1., 1.]) image.set_calculator(EMT()) image.get_potential_energy(apply_constraint=False) image.get_forces(apply_constraint=False) images.append(image) return images
def _get_phono3pyobject_phono3py(self, structure, potential, kpoint_density, displacementdistancephono3py, max_distance_third_order): cell = get_phonopy_structure(structure) kpoint = Kpoints.automatic_density(structure=structure, kppa=kpoint_density, force_gamma=True) mesh = kpoint.kpts[0] phono3py = Phono3py(cell, self.smat, primitive_matrix=[[1, 0., 0.], [0., 1, 0.], [0., 0., 1]], mesh=mesh, log_level=1) phono3py.generate_displacements( distance=displacementdistancephono3py, cutoff_pair_distance=max_distance_third_order) scells_with_disps = phono3py.get_supercells_with_displacements() disp_dataset = phono3py.get_displacement_dataset() numatoms = len(scells_with_disps[0].get_scaled_positions()) dummy_force = np.zeros((numatoms, 3)) set_of_forces = [] for scell in scells_with_disps: if scell is not None: # this part is adapted from: https://web.archive.org/web/20200610084959/https://github.com/phonopy/phonopy/blob/develop/example/ase/8Si-phonon.py # Copyright by Atsushi Togo cell = Atoms(symbols=scell.get_chemical_symbols(), scaled_positions=scell.get_scaled_positions(), cell=scell.get_cell(), pbc=True) cell.set_calculator(potential) forces = cell.get_forces() drift_force = forces.sum(axis=0) print(("[Phonopy] Drift force:" + "%11.5f" * 3) % tuple(drift_force)) for force in forces: force -= drift_force / forces.shape[0] set_of_forces.append(forces) else: set_of_forces.append(dummy_force) phono3py.produce_fc3(set_of_forces, displacement_dataset=disp_dataset, symmetrize_fc3r=True) fc3 = phono3py.get_fc3() show_drift_fc3(fc3) return phono3py
def test_aic(): """Test Atomic Counter Ion calc forces.""" import numpy as np from ase import Atoms from ase.calculators.counterions import AtomicCounterIon as ACI atoms = Atoms('2Na', positions=np.array([[0, 0, 0], [0, 0, 4]])) atoms.calc = ACI(1, 1.6642, 0.0001201186, rc=4.5) f = atoms.get_forces() df = atoms.calc.calculate_numerical_forces(atoms, 1e-6) - f print(df) assert abs(df).max() < 2e-6
def prepare_slab_opt(self, slab: Atoms) -> None: ''' Prepare slab optimization with Quantum Espresso ''' balsamcalc_module = __import__('pynta.balsamcalc', fromlist=[self.socket_calculator]) sock_calc = getattr(balsamcalc_module, self.socket_calculator) # n_kpts = IO().get_kpoints(self.repeats_surface) job_kwargs = self.balsam_exe_settings.copy() extra_calc_keywords = self.calc_keywords.copy() # add kpoints and distribute it among nodes = n_kpts # extra_calc_keywords['kpts'] = self.repeats_surface # extra_calc_keywords['job_args'] = '-nk {}'.format(n_kpts) # change how k-points are distrubuted among nodes # job_kwargs.update([('num_nodes', n_kpts)]) slab.pbc = (True, True, False) if self.socket_calculator == 'EspressoBalsamSocketIO': slab.calc = sock_calc(workflow='QE_Socket', job_kwargs=job_kwargs, pseudopotentials=self.pseudopotentials, pseudo_dir=self.pseudo_dir, **extra_calc_keywords) else: slab.calc = sock_calc(workflow='QE_Socket', job_kwargs=job_kwargs, **extra_calc_keywords) fname = os.path.join(self.creation_dir, self.slab_name) opt = BFGSLineSearch(atoms=slab, trajectory=fname + '.traj') opt.run(fmax=0.01) slab.get_potential_energy() slab.get_forces() slab.calc.close() write(fname + '.xyz', slab)
def run_dimers(dbfile, DftCalc, atomic_energies, element1, element2, minfrac=0.15, maxfrac=0.7, stepfrac=0.05, minE=5.): ''' Adds a dimer curve (with DFT energies and forces) for the given element pair to a database. dbfile: name of the database DftCalc: suitable DFT calculator class (see tango.main) atomic_energies: reference DFT energies of the separate atoms element1: symbol of the first element element2: symbol of the second element minfrac, maxfrac, stepfrac: specifies the minimal and maximal dimer distances (and the spacing) in units of the sum of covalent radii minE: dimer distances where the dimer energy is less than minE above the sum of the reference energies are omitted ''' positions = np.array([[6.] * 3, [8., 6., 6.]]) atoms = Atoms(element1 + element2, cell=[12.] * 3, positions=positions, pbc=True) calc = DftCalc(atoms, kpts=(1,1,1), run_type='dimer') db = connect(dbfile) num1 = atomic_numbers[element1] num2 = atomic_numbers[element2] e_ref = [atomic_energies['%s_DFT' % e] for e in [element1, element2]] crsum = covalent_radii[num1] + covalent_radii[num2] r = minfrac * crsum while True: if r * 1. / crsum > maxfrac: break positions[1, 0] = 6. + r atoms.set_positions(positions) atoms.set_calculator(calc) E = atoms.get_potential_energy() F = atoms.get_forces() if E - sum(e_ref) > minE: atoms.info['key_value_pairs'] = {} atoms.info['key_value_pairs']['e_dft_ref'] = convert_array(e_ref) atoms.info['key_value_pairs']['f_dft_ref'] = 0. finalize(atoms, energy=E, forces=F) db.write(atoms, r=r, **atoms.info['key_value_pairs']) r += stepfrac * crsum else: break calc.exit() return
def read_images(filename, state_number=None, mode=None): f = open(filename, 'r') atoms = [] ener = [] fmins = [] fmaxs = [] fnorms = [] cycle = -1 while True: elements = [] positions = [] forces = [] line = f.readline() if not line: break if cycle == -1: atom_numb = int(line.split()[0]) line = f.readline() energy = float(line.split(":")[1]) #read one particular structure assinged by state_number for i in range(atom_numb): line = f.readline() fields = line.split() elements.append(fields[0]) positions.append([float(fields[j + 1]) for j in range(3)]) forces.append([float(fields[j + 1]) for j in range(3, 6)]) elements = np.array(elements) positions = np.array(positions) p = Atoms(symbols=elements, positions=positions) calc = forces_setter(energy=energy, forces=np.array(forces)) p.set_cell([[20., 0, 0], [0, 20., 0], [0, 0, 20.]], scale_atoms=False) p.set_pbc((True, True, True)) p.set_calculator(calc) p.center() e = p.get_potential_energy() fs = np.absolute(p.get_forces()) fmin = np.amin(fs) fmax = np.amax(fs) if fmax > 10.0: continue ener.append(energy) fnorm = np.linalg.norm(np.sum(np.array(forces), axis=0)) atoms.append([p, [energy, fnorm, fmin, fmax]]) fmins.append(fmin) fmaxs.append(fmax) fnorms.append(fnorm) cycle += 1 f.close() return atoms, np.array(ener), np.array(fnorms), np.array(fmins), np.array( fmaxs)
def twoAtomForce(): print "\nRunning LJ twoAtomForce" elements = [29] epsilon = [0.15] sigma = [2.7] atoms = Atoms(positions=[(0.0, 0.0, 0.0), (0.0, 0.0, 2.0)], symbols="Cu2") atoms.set_calculator(LennardJones(elements, epsilon, sigma, -1.0, False)) result = atoms.get_potential_energy() r = atoms.get_positions() r.flat[:] += 0.06 * np.sin(np.arange(3 * len(atoms))) atoms.set_positions(r) resA, resB = atoms.get_forces() storedForces = [-1.15732425, 13.10743025, -258.04517252] for a in range(1, 3): ReportTest((" Simple force test dimension %d" % a), resA[a], storedForces[a], 1e-8, silent=Silent) print " Running Verlet dynamics (%s)" % ("Cu", ) dyn = VelocityVerlet(atoms, 2 * units.fs) dyn.run(100) etot1 = (atoms.get_potential_energy() + atoms.get_kinetic_energy()) dyn.run(1000) etot2 = (atoms.get_potential_energy() + atoms.get_kinetic_energy()) ReportTest((" Energy conservation (%s)" % ("Cu", )), etot1, etot2, 1.0, silent=Silent) epot = atoms.get_potential_energies() stress = atoms.get_stresses() e = [] s = [] j = 0 for i in range(0, len(atoms), 100): e.append(epot[i]) s.append(stress[i, j]) j = (j + 1) % 6 print " e" + "Cu" + " =", repr(e) print " s" + "Cu" + " =", repr(s)
def test_energy(self): vac = 8 dist_min = 1.2 atoms = Atoms('CC', positions=[[0, 0, 0], [dist_min, 0, 0]]) atoms.center(vacuum=vac) for calc in [Rebo2(), Rebo2Scr()]: atoms.calc = calc energy = atoms.get_potential_energy() forces_ac = atoms.get_forces() stress = atoms.get_stress() fname = 'structure.traj' atoms.write(fname) atoms = io.read(fname) self.assertTrue( np.abs(energy - atoms.get_potential_energy()) < 1e-10) self.assertTrue( (np.abs(forces_ac - atoms.get_forces()) < 1e-10).all()) self.assertTrue( (np.abs(stress - atoms.get_stress()) < 1e-10).all())
def test_forces_dimer(self): d = 1.2 L = 10 atomic_configuration = Atoms("HH", positions=[(L/2, L/2, L/2), (L/2 + d, L/2, L/2)], cell=[L, L, L], pbc=[1, 1, 1] ) atomic_configuration.set_array("size", np.array([1.3, 2.22]), dtype=float) atomic_configuration.set_masses(masses=np.repeat(1.0, len(atomic_configuration))) calc = Polydisperse(InversePowerLawPotential(1.0, 1.4, 0.1, 3, 1, 2.22)) atomic_configuration.set_calculator(calc) f = atomic_configuration.get_forces() fn = calc.calculate_numerical_forces(atomic_configuration, d=0.0001) self.assertArrayAlmostEqual(f, fn, tol=self.tol)
def test_ase(self): from ase import Atoms from deepmd.calculator import DP water = Atoms('OHHOHH', positions=self.coords.reshape((-1, 3)), cell=self.box.reshape((3, 3)), calculator=DP("deeppot.pb")) ee = water.get_potential_energy() ff = water.get_forces() nframes = 1 np.testing.assert_almost_equal(ff.ravel(), self.expected_f.ravel(), default_places) expected_se = np.sum(self.expected_e.reshape([nframes, -1]), axis=1) np.testing.assert_almost_equal(ee.ravel(), expected_se.ravel(), default_places)
def twoAtomForce(): print "\nRunning LJ twoAtomForce" elements = [29] epsilon = [0.15] sigma = [2.7] atoms=Atoms(positions=[(0.0, 0.0, 0.0),(0.0, 0.0, 2.0)], symbols="Cu2") atoms.set_calculator(LennardJones(elements, epsilon, sigma, -1.0, False)) result = atoms.get_potential_energy() r = atoms.get_positions() r.flat[:] += 0.06 * np.sin(np.arange(3*len(atoms))) atoms.set_positions(r) resA, resB = atoms.get_forces() ; storedForces = [ -1.15732425, 13.10743025, -258.04517252 ] for a in range(1,3): ReportTest((" Simple force test dimension %d" % a), resA[a], storedForces[a], 1e-8, silent=Silent) print " Running Verlet dynamics (%s)" % ("Cu",) dyn = VelocityVerlet(atoms, 2*units.fs) dyn.run(100) etot1 = (atoms.get_potential_energy() + atoms.get_kinetic_energy()) dyn.run(1000) etot2 = (atoms.get_potential_energy() + atoms.get_kinetic_energy()) ReportTest((" Energy conservation (%s)" % ("Cu",)), etot1, etot2, 1.0, silent=Silent) epot = atoms.get_potential_energies() stress = atoms.get_stresses() e = [] s = [] j = 0 for i in range(0, len(atoms), 100): e.append(epot[i]) s.append(stress[i,j]) j = (j + 1) % 6 print " e"+"Cu"+" =", repr(e) print " s"+"Cu"+" =", repr(s)
def run_gpaw(calc, phonon): supercells = phonon.get_supercells_with_displacements() # Force calculations by calculator set_of_forces = [] for scell in supercells: cell = Atoms(symbols=scell.get_chemical_symbols(), scaled_positions=scell.get_scaled_positions(), cell=scell.get_cell(), pbc=True) cell.set_calculator(calc) forces = cell.get_forces() drift_force = forces.sum(axis=0) print(("[Phonopy] Drift force:" + "%11.5f" * 3) % tuple(drift_force)) # Simple translational invariance for force in forces: force -= drift_force / forces.shape[0] set_of_forces.append(forces) return set_of_forces
from ase import Atoms from multiasecalc.lammps.reaxff import ReaxFF from multiasecalc.utils import get_datafile d = 0.74 #d = 3.0 a = 6.0 atoms_all = Atoms("H3", positions = [(0, 0, 0), (0, 0, d), (0, 0, 2*d)], cell = (100*a, 100*a, 100*a)) atoms_all.center() calc_1 = ReaxFF(specorder = ("C", "H", "O", "N", "S"), implementation="C", ff_file_path=get_datafile("ffield.reax")) atoms_all.set_calculator(calc_1) print(atoms_all.get_forces()) print(atoms_all.get_potential_energy())
from ase import Atoms from gpaw import GPAW, restart from gpaw.xc.sic import SIC from gpaw.test import equal a = 6.0 atom = Atoms('H', magmoms=[1.0], cell=(a, a, a)) molecule = Atoms('H2', positions=[(0, 0, 0), (0, 0, 0.737)], cell=(a, a, a)) atom.center() molecule.center() calc = GPAW(xc='LDA-PZ-SIC', eigensolver='rmm-diis', txt='h2.sic.txt', setups='hgh') atom.set_calculator(calc) e1 = atom.get_potential_energy() molecule.set_calculator(calc) e2 = molecule.get_potential_energy() F_ac = molecule.get_forces() de = 2 * e1 - e2 #equal(de, 4.5, 0.1) # Test forces ... calc.write('H2.gpw', mode='all') atoms, calc = restart('H2.gpw') e2b = atoms.get_potential_energy() equal(e2, e2b, 0.0001)
#!/usr/bin/env python from ase import Atoms, Atom from jasp import * atoms = Atoms([Atom('H', [0.5960812, -0.7677068, 0.0000000]), Atom('O', [0.0000000, 0.0000000, 0.0000000]), Atom('H', [0.5960812, 0.7677068, 0.0000000])], cell=(8, 8, 8)) with jasp('molecules/h2o_relax', xc='PBE', encut=400, ismear=0, # Gaussian smearing ibrion=2, ediff=1e-8, nsw=10, atoms=atoms) as calc: print('Forces') print('===========================') print(atoms.get_forces())
npj=1, ppn=8, exe=vasp, mpirun=mpirun, parmode='mpi', xc='LDA', lreal=False, ibrion=13, nsw=1000000, algo='VeryFast', npar=8, lplane=False, lwave=False, lcharg=False, nsim=1, voskown=1, ismear=0, sigma=0.01, iwavpr=11, isym=0, nelm=150) sock_calc = SocketCalculator(vasp_client) bulk.set_calculator(sock_calc) sock_e = bulk.get_potential_energy() sock_f = bulk.get_forces() sock_s = bulk.get_stress() print 'energy', sock_e print 'forces', sock_f print 'stress', sock_s bulk.rattle(0.01) sock_e = bulk.get_potential_energy() sock_f = bulk.get_forces() sock_s = bulk.get_stress() print 'energy', sock_e print 'forces', sock_f
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() dimer.constraints = FixInternals( bonds=[(r, (0, 2)), (r, (1, 2)), (r, (3, 5)), (r, (4, 5))], angles=[(a, (0, 2, 1)), (a, (3, 5, 4))]) opt = BFGS(dimer, trajectory=calc.name + '.traj', logfile=calc.name + 'd.log')
from ase import Atoms from ase.calculators.emt import EMT from ase.calculators.test import numeric_forces h2 = Atoms('H2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) f1 = numeric_forces(h2, d=0.0001) f2 = h2.get_forces() assert abs(f1 - f2).max() < 1e-6
from gpaw import GPAW import numpy as np # spin paired H2 d = 0.75 h2 = Atoms('H2', [[0, 0, 0], [0, 0, d]]) h2.center(vacuum=2.) e = np.array([]) f = np.array([]) for xc in ['LDA', 'PPLDA']: calc = GPAW(nbands=-1, xc=xc, convergence={'eigenstates': 1.e-9}, txt=None) h2.set_calculator(calc) e = np.append(e, h2.get_potential_energy()) f = np.append(f, h2.get_forces()) del calc print(e[0], e[1], np.abs(e[0] - e[1])) print(f[0], f[1], np.sum(np.abs(f[0] - f[1]))) assert np.abs(e[0] - e[1]) < 1.e-8 assert np.sum(np.abs(f[0] - f[1])) < 1.e-8 # spin polarized O2 d = 1.2 o2 = Atoms('O2', [[0, 0, 0], [0, 0, d]], magmoms=[1., 1.]) o2.center(vacuum=2.) e = np.array([]) f = np.array([])
from ase import Atom, Atoms from ase.calculators.lj import LennardJones from ase.constraints import FixBondLength dimer = Atoms([Atom('X', (0, 0, 0)), Atom('X', (0, 0, 1))], calculator=LennardJones(), constraint=FixBondLength(0, 1)) print dimer.get_forces() print dimer.positions dimer.positions[:] += 0.1 print dimer.positions dimer.positions[:, 2] += 5.1 print dimer.positions dimer.positions[:] = [(1,2,3),(4,5,6)] print dimer.positions dimer.set_positions([(1,2,3),(4,5,6.2)]) print dimer.positions
nbands = -5, xc = xc, width = 0.05, eigensolver = eigensolver, spinpol = True, txt = None, mixer = MixerSum(beta=0.1, nmaxold=5, weight=50.0), convergence = {'energy': 100, 'density': 100, 'eigenstates': 1.0e-9, 'bands': -1}) atoms.set_calculator(calc_gs) E0.append(atoms.get_potential_energy()) if i==1: F0 = atoms.get_forces() calc_es = GPAW(h = 0.2, nbands = -5, xc = xc, width = 0.05, eigensolver = eigensolver, spinpol = True, txt = None, mixer = MixerSum(beta=0.1, nmaxold=5, weight=50.0), convergence = {'energy': 100, 'density': 100, 'eigenstates': 1.0e-9, 'bands': -1}) n = 5 # LUMO
a = 4. # Size of unit cell (Angstrom) c = a / 2 d = 0.74 # Experimental bond length molecule = Atoms('H2', [(c - d / 2, c, c), (c + d / 2, c, c)], cell=(a, a, a), pbc=False) calc = GPAW(h=0.2, nbands=1, xc='PBE', txt=None) molecule.set_calculator(calc) e1 = molecule.get_potential_energy() niter1 = calc.get_number_of_iterations() calc.write('H2.gpw') calc.write('H2a.gpw', mode='all') molecule.get_forces() calc.write('H2f.gpw') calc.write('H2fa.gpw', mode='all') from time import time def timer(func, *args, **kwargs): t0 = time() ret = func(*args, **kwargs) return ret, time()-t0 molecule = GPAW('H2.gpw', txt=None).get_atoms() f1, t1 = timer(molecule.get_forces) molecule = GPAW('H2a.gpw', txt=None).get_atoms() f2, t2 = timer(molecule.get_forces) molecule = GPAW('H2f.gpw', txt=None).get_atoms() f3, t3 = timer(molecule.get_forces)
"""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
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.set_calculator(EMT()) f = UnitCellFilter(cu, [1, 1, 1, 0, 0, 0]) opt = LBFGS(f) t = Trajectory('Cu-fcc.traj', 'w', cu) opt.attach(t) opt.run(5.0) # HCP: from ase.build import hcp0001 cu = hcp0001('Cu', (1, 1, 2), a=a / sqrt(2)) cu.cell[1, 0] += 0.05 cu *= (6, 6, 3) cu.set_calculator(EMT()) print(cu.get_forces()) print(cu.get_stress()) f = UnitCellFilter(cu) opt = MDMin(f, dt=0.01) t = Trajectory('Cu-hcp.traj', 'w', cu) opt.attach(t) opt.run(0.2)
# <<water-vib>> # adapted from http://cms.mpi.univie.ac.at/wiki/index.php/H2O_vibration from ase import Atoms, Atom from jasp import * import ase.units atoms = Atoms([Atom('H', [0.5960812, -0.7677068, 0.0000000]), Atom('O', [0.0000000, 0.0000000, 0.0000000]), Atom('H', [0.5960812, 0.7677068, 0.0000000])], cell=(8, 8, 8)) atoms.center() with jasp('molecules/h2o_vib', xc='PBE', encut=400, ismear=0, # Gaussian smearing ibrion=6, # finite differences with symmetry nfree=2, # central differences (default) potim=0.015, # default as well ediff=1e-8, # for vibrations you need precise energies nsw=1, # Set to 1 for vibrational calculation atoms=atoms) as calc: print 'Forces' print '======' print atoms.get_forces() print # vibrational energies are in eV energies, modes = calc.get_vibrational_modes() print 'energies\n========' for i, e in enumerate(energies): print '{0:02d}: {1} eV'.format(i, e)
from ase.units import fs, kB from ase.calculators.test import TestPotential from ase.md import Langevin from ase.io import Trajectory, read from ase.optimize import QuasiNewton from ase.utils import seterr with seterr(all='raise'): a = Atoms('4X', masses=[1, 2, 3, 4], positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0), (0.1, 0.2, 0.7)], calculator=TestPotential()) print(a.get_forces()) # Langevin should reproduce Verlet if friction is 0. md = Langevin(a, 0.5 * fs, 300 * kB, 0.0, logfile='-', loginterval=500) traj = Trajectory('4N.traj', 'w', a) md.attach(traj, 100) e0 = a.get_total_energy() md.run(steps=10000) del traj assert abs(read('4N.traj').get_total_energy() - e0) < 0.0001 # Try again with nonzero friction. md = Langevin(a, 0.5 * fs, 300 * kB, 0.001, logfile='-', loginterval=500) traj = Trajectory('4NA.traj', 'w', a) md.attach(traj, 100) md.run(steps=10000)
def test(): ########################################################################### # Parameters atoms = Atoms(symbols='PdOPd2', pbc=np.array([False, False, False], dtype=bool), cell=np.array( [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]), positions=np.array( [[0., 1., 0.], [1., 2., 1.], [-1., 1., 2.], [1., 3., 2.]])) ########################################################################### # Parameters Gs = {'O': [{'type': 'G2', 'element': 'Pd', 'eta': 0.8}, {'type': 'G4', 'elements': [ 'Pd', 'Pd'], 'eta':0.2, 'gamma':0.3, 'zeta':1}, {'type': 'G4', 'elements': ['O', 'Pd'], 'eta':0.3, 'gamma':0.6, 'zeta':0.5}], 'Pd': [{'type': 'G2', 'element': 'Pd', 'eta': 0.2}, {'type': 'G4', 'elements': ['Pd', 'Pd'], 'eta':0.9, 'gamma':0.75, 'zeta':1.5}, {'type': 'G4', 'elements': ['O', 'Pd'], 'eta':0.4, 'gamma':0.3, 'zeta':4}]} hiddenlayers = {'O': (2,), 'Pd': (2,)} weights = OrderedDict([('O', OrderedDict([(1, np.matrix([[-2.0, 6.0], [3.0, -3.0], [1.5, -0.9], [-2.5, -1.5]])), (2, np.matrix([[5.5], [3.6], [1.4]]))])), ('Pd', OrderedDict([(1, np.matrix([[-1.0, 3.0], [2.0, 4.2], [1.0, -0.7], [-3.0, 2.0]])), (2, np.matrix([[4.0], [0.5], [3.0]]))]))]) scalings = OrderedDict([('O', OrderedDict([('intercept', -2.3), ('slope', 4.5)])), ('Pd', OrderedDict([('intercept', 1.6), ('slope', 2.5)]))]) fingerprints_range = {"O": np.array([[0.21396177208585404, 2.258090276328769], [0.0, 2.1579067008202975], [0.0, 0.0]]), "Pd": np.array([[0.0, 1.4751761770313006], [0.0, 0.697686078889583], [0.0, 0.37848964715610417]])} ########################################################################### calc = Amp(descriptor=Gaussian(cutoff=6.5, Gs=Gs, fortran=False,), model=NeuralNetwork(hiddenlayers=hiddenlayers, weights=weights, scalings=scalings, fprange=fingerprints_range, mode='atom-centered'), cores=1) atoms.set_calculator(calc) e1 = atoms.get_potential_energy(apply_constraint=False) e2 = calc.get_potential_energy(atoms) f1 = atoms.get_forces(apply_constraint=False) atoms[0].x += 0.5 boolean = atoms.calc.calculation_required(atoms, properties=['energy']) e3 = atoms.get_potential_energy(apply_constraint=False) e4 = calc.get_potential_energy(atoms) f2 = atoms.get_forces(apply_constraint=False) assert (e1 == e2 and e3 == e4 and abs(e1 - e3) > 10. ** (-3.) and (boolean is True) and (not (f1 == f2).all())), 'Displaced-atom test broken!'
atoms = Atoms('Na3', positions=[( 0, 0, 0), ( 0, 0, d), ( 0, d*sqrt(3./4.), d/2.)], magmoms=[1.0, 1.0, 1.0], cell=(3.5, 3.5, 4.+2/3.), pbc=True) # Only a short, non-converged calcuation conv = {'eigenstates': 1.e-3, 'energy':1e-2, 'density':1e-1} calc = GPAW(h=0.30, nbands=3, setups={'Na': '1'}, convergence=conv) atoms.set_calculator(calc) e0 = atoms.get_potential_energy() niter0 = calc.get_number_of_iterations() f0 = atoms.get_forces() m0 = atoms.get_magnetic_moments() eig00 = calc.get_eigenvalues(spin=0) eig01 = calc.get_eigenvalues(spin=1) # Write the restart file(s) for mode in modes: calc.write('tmp.%s' % mode) del atoms, calc # Try restarting from all the files for mode in modes: atoms, calc = restart('tmp.%s' % mode) # Force new calculation calc.scf.converged = False e1 = atoms.get_potential_energy() f1 = atoms.get_forces()
for d in bond_lengths: # possible bond lengths co = Atoms([Atom('C', [0, 0, 0]), Atom('O', [d, 0, 0])], cell=(6, 6, 6)) with jasp('molecules/co-{0}'.format(d), # output dir xc='PBE', encut=450, ismear=1, sigma=0.01, atoms=co) as calc: try: e = co.get_potential_energy() energies.append(e) print('d = {0:1.3f} ang'.format(d)) print('energy = {0:1.5f} eV'.format(e)) print('forces = (eV/ang)\n {0}'.format(co.get_forces())) print('') # blank line except (VaspSubmitted, VaspQueued): energies.append(None) pass # fit the data pars = np.polyfit(bond_lengths, energies, 3) xfit = np.linspace(1.05, 1.25) efit = np.polyval(pars, xfit) # first derivative dpars = np.polyder(pars) # find where the minimum is. chose the second one because it is the # minimum we need. droots = np.roots(dpars) # second derivative
ref = np.array([[-1.26056746e-01, 4.10007559e-01, 2.85719551e-04], [4.28062314e-01, 2.56059142e-02, 2.17691110e-04], [-3.02019173e-01, -4.35613473e-01, -5.03410632e-04]]) error = np.sqrt(np.sum((forces_num - ref)**2)) print('forces_num') print(forces_num) print('diff from reference:') print(error) assert(error < tol) # analytical forces forces_an = atoms.get_forces() ref = np.array([[-1.26446863e-01, 4.09628186e-01, -0.00000000e+00], [4.27934442e-01, 2.50425467e-02, -5.14220671e-05], [-2.99225008e-01, -4.31533987e-01, -5.14220671e-05]]) error = np.sqrt(np.sum((forces_an - ref)**2)) print('forces_an') print(forces_an) print('diff from reference:') print(error) assert(error < tol) # optimize geometry dyn = BFGS(atoms)
write(fname2, images, format=format) if format in r: print('I') a1 = read(fname1) assert np.all(np.abs(a1.get_positions() - atoms.get_positions()) < 1e-6) if format in ['traj', 'cube', 'cfg', 'struct', 'gen', 'extxyz']: assert np.all(np.abs(a1.get_cell() - atoms.get_cell()) < 1e-6) if format in ['cfg', 'extxyz']: assert np.all(np.abs(a1.get_array('extra') - atoms.get_array('extra')) < 1e-6) if format in ['extxyz']: assert np.all(a1.get_pbc() == atoms.get_pbc()) assert np.all(a1.get_potential_energy() == atoms.get_potential_energy()) assert np.all(a1.get_stress() == atoms.get_stress()) assert np.all(abs(a1.get_forces() - atoms.get_forces()) < 1e-6) if format not in only_one_image: a2 = read(fname2) a3 = read(fname2, index=0) a4 = read(fname2, index=slice(None)) if format in ['cif'] and sys.platform in ['win32']: # Fails on Windows: # https://trac.fysik.dtu.dk/projects/ase/ticket/62 pass else: assert len(a4) == 2 else: print()
# 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')
from ase.calculators.test import numeric_force from gpaw import GPAW, Mixer from gpaw.test import equal a = 4.0 n = 16 atoms = Atoms([Atom('H', [1.234, 2.345, 3.456])], cell=(a, a, a), pbc=True) calc = GPAW(nbands=1, gpts=(n, n, n), txt=None, mixer=Mixer(0.25, 3, 1), convergence={'energy': 1e-7}) atoms.set_calculator(calc) e1 = atoms.get_potential_energy() niter1 = calc.get_number_of_iterations() f1 = atoms.get_forces()[0] for i in range(3): f2i = numeric_force(atoms, 0, i) print f1[i]-f2i equal(f1[i], f2i, 0.00025) energy_tolerance = 0.00006 force_tolerance = 0.0001 niter_tolerance = 0 equal(e1, -0.531042, energy_tolerance) f1_ref = [-0.291893, -0.305174, -0.35329] for i in range(3): equal(f1[i], f1_ref[i], force_tolerance) assert 34 <= niter1 <= 35, niter1
import numpy as np from ase import Atoms from ase.units import fs from ase.calculators.test import TestPotential from ase.calculators.emt import EMT from ase.md import VelocityVerlet from ase.io import PickleTrajectory, read from ase.optimize import QuasiNewton np.seterr(all='raise') a = Atoms('4X', masses=[1, 2, 3, 4], positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0), (0.1, 0.2, 0.7)], calculator=TestPotential()) print a.get_forces() md = VelocityVerlet(a, dt=0.5 * fs, logfile='-', loginterval=500) traj = PickleTrajectory('4N.traj', 'w', a) md.attach(traj.write, 100) e0 = a.get_total_energy() md.run(steps=10000) del traj assert abs(read('4N.traj').get_total_energy() - e0) < 0.0001 qn = QuasiNewton(a) qn.run(0.001) assert abs(a.get_potential_energy() - 1.0) < 0.000002
from ase import Atoms from ase.calculators.emt import EMT h2 = Atoms('H2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) print h2.calc.get_numeric_forces(h2) print h2.get_forces()
system = Atoms(symbols='Si2', pbc=True, cell=0.5 * a * np.array([(1, 1, 0), (1, 0, 1), (0, 1, 1)]), scaled_positions=[(0.0, 0.0, 0.0), (0.23, 0.23, 0.23)]) calc = GPAW(h=0.2, mode='lcao', basis=basis, kpts=(2,2,2), convergence={'density':1e-5, 'energy': 1e-6} ) system.set_calculator(calc) F_ac = system.get_forces() # Previous FD result, generated by disabled code below F_ac_ref = np.array([[-1.3977335 , -1.39637682, -1.39682766], [ 1.39952439, 1.39949595, 1.39882519]]) err_ac = np.abs(F_ac - F_ac_ref) err = err_ac.max() print 'Force' print F_ac print print 'Reference result' print F_ac_ref print print 'Error'
(0.25, 0.25, 0.25), (0.25, 0.75, 0.75), (0.75, 0.25, 0.75), (0.75, 0.75, 0.25)], pbc=True) bulk.set_cell((a, a, a), scale_atoms=True) n = 20 calc = GPAW(gpts=(n, n, n), nbands=8*3, occupations=FermiDirac(width=0.01), poissonsolver=PoissonSolver(nn='M', relax='J'), kpts=(2, 2, 2), convergence={'energy': 1e-7} ) bulk.set_calculator(calc) f1 = bulk.get_forces()[0, 2] e1 = bulk.get_potential_energy() niter1 = calc.get_number_of_iterations() f2 = numeric_force(bulk, 0, 2) print f1,f2,f1-f2 equal(f1, f2, 0.005) # Volume per atom: vol = a**3 / 8 de = calc.get_electrostatic_corrections() / vol print de assert abs(de[0] - -2.190) < 0.001 print e1, f1, niter1 energy_tolerance = 0.00025
from ase import Atoms, Atom from jasp import * import numpy as np np.set_printoptions(precision=3, suppress=True) co = Atoms([Atom('C', [0, 0, 0]), Atom('O', [1.2, 0, 0])], cell=(6., 6., 6.)) with jasp('molecules/simple-co', # output dir xc='PBE', # the exchange-correlation functional nbands=6, # number of bands encut=350, # planewave cutoff ismear=1, # Methfessel-Paxton smearing sigma=0.01, # very small smearing factor for a molecule atoms=co) as calc: print('energy = {0} eV'.format(co.get_potential_energy())) print(co.get_forces())