def relax(input_atoms, ref_db): atoms_string = input_atoms.get_chemical_symbols() # Open connection to the database with reference data db = connect(ref_db) # Load our model structure which is just FCC atoms = FaceCenteredCubic('X', latticeconstant=1.) atoms.set_chemical_symbols(atoms_string) # Compute the average lattice constant of the metals in this individual # and the sum of energies of the constituent metals in the fcc lattice # we will need this for calculating the heat of formation a = 0 ei = 0 for m in set(atoms_string): dct = db.get(metal=m) count = atoms_string.count(m) a += count * dct.latticeconstant ei += count * dct.energy_per_atom a /= len(atoms_string) atoms.set_cell([a, a, a], scale_atoms=True) # Since calculations are extremely fast with EMT we can also do a volume # relaxation atoms.set_calculator(EMT()) eps = 0.05 volumes = (a * np.linspace(1 - eps, 1 + eps, 9))**3 energies = [] for v in volumes: atoms.set_cell([v**(1. / 3)] * 3, scale_atoms=True) energies.append(atoms.get_potential_energy()) eos = EquationOfState(volumes, energies) v1, ef, B = eos.fit() latticeconstant = v1**(1. / 3) # Calculate the heat of formation by subtracting ef with ei hof = (ef - ei) / len(atoms) # Place the calculated parameters in the info dictionary of the # input_atoms object input_atoms.info['key_value_pairs']['hof'] = hof # Raw score must always be set # Use one of the following two; they are equivalent input_atoms.info['key_value_pairs']['raw_score'] = -hof # set_raw_score(input_atoms, -hof) input_atoms.info['key_value_pairs']['latticeconstant'] = latticeconstant # Setting the atoms_string directly for easier analysis atoms_string = ''.join(input_atoms.get_chemical_symbols()) input_atoms.info['key_value_pairs']['atoms_string'] = atoms_string
def MakeCu(T=300, size=(29,29,30)): print "Preparing", T, "K Copper system." atoms = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], symbol='Cu', size=size) atoms.set_calculator(EMT()) MaxwellBoltzmannDistribution(atoms, 2*T * units.kB) #dyn = VelocityVerlet(atoms, 5*units.fs) dyn = Langevin(atoms, 5*units.fs, T*units.kB, 0.05) dyn.run(50) print "Done. Temperature =", temperature(atoms), \ "K. Number of atoms: ", len(atoms) return atoms
def test_stress(self): a = FaceCenteredCubic('Au', size=[2,2,2]) calc = EAM('Au-Grochola-JCP05.eam.alloy') a.set_calculator(calc) self.assertArrayAlmostEqual(a.get_stress(), calc.calculate_numerical_stress(a), tol=self.tol) sx, sy, sz = a.cell.diagonal() a.set_cell([sx, 0.9*sy, 1.2*sz], scale_atoms=True) self.assertArrayAlmostEqual(a.get_stress(), calc.calculate_numerical_stress(a), tol=self.tol) a.set_cell([[sx, 0.1*sx, 0], [0, 0.9*sy, 0], [0, -0.1*sy, 1.2*sz]], scale_atoms=True) self.assertArrayAlmostEqual(a.get_stress(), calc.calculate_numerical_stress(a), tol=self.tol)
def test_Grochola(self): a = FaceCenteredCubic('Au', size=[2,2,2]) calc = EAM('Au-Grochola-JCP05.eam.alloy') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) a0 = a.cell.diagonal().mean()/2 self.assertTrue(abs(a0-4.0701)<2e-5) self.assertTrue(abs(a.get_potential_energy()/len(a)+3.924)<0.0003) C, C_err = fit_elastic_constants(a, symmetry='cubic', verbose=False) C11, C12, C44 = Voigt_6x6_to_cubic(C) self.assertTrue(abs((C11-C12)/GPa-32.07)<0.7) self.assertTrue(abs(C44/GPa-45.94)<0.5)
def test_CuZr(self): # This is a test for the potential published in: # Mendelev, Sordelet, Kramer, J. Appl. Phys. 102, 043501 (2007) a = FaceCenteredCubic('Cu', size=[2,2,2]) calc = EAM('CuZr_mm.eam.fs', kind='eam/fs') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) a_Cu = a.cell.diagonal().mean()/2 #print('a_Cu (3.639) = ', a_Cu) self.assertAlmostEqual(a_Cu, 3.639, 3) a = HexagonalClosedPacked('Zr', size=[2,2,2]) a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) a, b, c = a.cell/2 #print('a_Zr (3.220) = ', norm(a), norm(b)) #print('c_Zr (5.215) = ', norm(c)) self.assertAlmostEqual(norm(a), 3.220, 3) self.assertAlmostEqual(norm(b), 3.220, 3) self.assertAlmostEqual(norm(c), 5.215, 3) # CuZr3 a = L1_2(['Cu', 'Zr'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) self.assertAlmostEqual(a.cell.diagonal().mean()/2, 4.324, 3) # Cu3Zr a = L1_2(['Zr', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) self.assertAlmostEqual(a.cell.diagonal().mean()/2, 3.936, 3) # CuZr a = B2(['Zr', 'Cu'], size=[2,2,2], latticeconstant=3.3) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) self.assertAlmostEqual(a.cell.diagonal().mean()/2, 3.237, 3)
#nsteps = 5000 nprint = 50000 nequil = 100000 nminor = 25 nequilprint = 200 tolerance = 0.01 timestep = 5 # fs frict = 0.001 temp = 100 # K repeats = 5 # Set up atoms in a regular simple-cubic lattice. initial = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], size = (1,5,5), symbol="Cu", latticeconstant=3.5, pbc=False, debug=0) initial.set_calculator(EMT()) ReportTest("Number of atoms", len(initial), 100, 0) # Make a small perturbation of the momenta initial.set_momenta(1e-6 * np.random.normal(size=[len(initial), 3])) print "Initializing (1) ..." predyn = VelocityVerlet(initial, 0.5) predyn.run(2500) initial2 = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], size = (4,4,4), symbol="Cu", debug=0) initial2.set_calculator(EMT()) # Make a small perturbation of the momenta initial2.set_momenta(1e-6 * np.random.normal(size=[len(initial2), 3])) print "Initializing (2) ..."
from ase.calculators.vasp import Vasp from ase.lattice.cubic import FaceCenteredCubic from ase.io import write calc = Vasp(xc='PBE', kpts=(3,3,3), ismear=0, sigma=0.1, ediff=1e-10, lcharg=False, lwave=False, encut=400, nelmin=4, nelmdl=6, ispin=1,lvdw=True, vdw_version=3,isif=3,ibrion=1,nsw=500) #a = 5.0 #c = 3.5 #iro2 = crystal(['Ir', 'O'], basis=[(0,0,0), (0.3,0.3,0)], cellpar=[a, a, c, 90, 90, 90], spacegroup=136) #FCC Cell = FaceCenteredCubic(symbol='Ag') Cell.set_calculator(calc) calc.initialize(Cell) calc.write_incar(Cell) calc.write_potcar() calc.write_kpoints() write('POSCAR', calc.atoms_sorted) # this will write a "sorted" POSCAR #sf = StrainFilter(Cell) #opt = LBFGS(sf, trajectory=traj('atom-cell.traj', 'w', Cell)) #opt.run(fmax=0.01) #opt = LBFGS(Cell, trajectory=traj('atom.traj', 'w', Cell)) #opt.run(fmax=0.01)
def test_direct_evaluation(self): a = FaceCenteredCubic('Au', size=[2, 2, 2]) a.rattle(0.1) calc = EAM('Au-Grochola-JCP05.eam.alloy') a.set_calculator(calc) f = a.get_forces() calc2 = EAM('Au-Grochola-JCP05.eam.alloy') i_n, j_n, dr_nc, abs_dr_n = neighbour_list('ijDd', a, cutoff=calc2.cutoff) epot, virial, f2 = calc2.energy_virial_and_forces( a.numbers, i_n, j_n, dr_nc, abs_dr_n) self.assertArrayAlmostEqual(f, f2) a = FaceCenteredCubic('Cu', size=[2, 2, 2]) calc = EAM('CuAg.eam.alloy') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e_Cu = a.get_potential_energy() / len(a) a = FaceCenteredCubic('Ag', size=[2, 2, 2]) a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e_Ag = a.get_potential_energy() / len(a) self.assertTrue(abs(e_Ag + 2.85) < 1e-6) a = L1_2(['Ag', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.096) < 0.0005) a = B1(['Ag', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.516) < 0.0005) a = B2(['Ag', 'Cu'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.177) < 0.0003) a = L1_2(['Cu', 'Ag'], size=[2, 2, 2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1, 1, 1, 0, 0, 0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue( abs((e - (syms == 'Cu').sum() * e_Cu - (syms == 'Ag').sum() * e_Ag) / len(a) - 0.083) < 0.0005)
lasttime = targettime results = {} for nthreads in threads: try: AsapThreads(nthreads) except ValueError: break maxthread = nthreads for natoms in sizes: print "Timing with %i atoms (%i threads)" % (natoms, nthreads) blocksize = int(np.ceil((natoms/4)**(1./3.))) atoms = FaceCenteredCubic(symbol='Cu', size=(blocksize,blocksize,blocksize), pbc=False) print "Creating block with %i atoms, cutting to %i atoms" % (len(atoms), natoms) atoms = atoms[:natoms] assert len(atoms) == natoms atoms.set_calculator(EMT()) MaxwellBoltzmannDistribution(atoms, 2 * T * units.kB) dyn = VelocityVerlet(atoms, 5*units.fs) ptsteps = int(laststeps * (0.1 * targettime / lasttime) * lastsize / natoms) if ptsteps < 100: ptsteps = 100 print "Running pre-timing (%i steps)..." % (ptsteps,) t1 = time.time() dyn.run(ptsteps - 50) MaxwellBoltzmannDistribution(atoms, (2 * T - atoms.get_temperature()) * units.kB) dyn.run(50) t1 = time.time() - t1 steps = int(ptsteps * targettime / t1) if steps < 200: steps = 200 print "Temperature is %.1f K" % (atoms.get_temperature(),)
import numpy as np from ase.constraints import UnitCellFilter from ase.lattice.cubic import FaceCenteredCubic from ase.optimize import FIRE from ase.utils.eos import EquationOfState from atomistica import TabulatedAlloyEAM ### n = 2 a = FaceCenteredCubic('Au', size=[n, n, n]) x0 = a.cell[0, 0]/n c = TabulatedAlloyEAM(fn='Au-Grochola-JCP05.eam.alloy') a.set_calculator(c) # Vary volume and fit minimum def en(a, x): a.set_cell([x, x, x], scale_atoms=True) return a.get_potential_energy() x = np.linspace(0.9*x0, 1.1*x0, 101) e = [ en(a, n*_x)/(n**3) for _x in x ] eos = EquationOfState(x**3, e) v0, e0, B = eos.fit() print 'lattice constant (from equation of state) =', v0**(1./3) # Keep cell rectangular during optimization FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.0001)
txt = nbltype + (" PBC=%1i%1i%1i " % pbc) # Test that EMT reimported through OpenKIM gives the right results. atoms_kim = FaceCenteredCubic(size=(10,10,10), symbol='Cu') #atoms_kim = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], # size=(30, 30, 30), # symbol="Cu") natoms = len(atoms_kim) atoms_kim.set_pbc(pbc) r = atoms_kim.get_positions() r.flat[:] += 0.1 * np.sin(np.arange(3*natoms)) atoms_kim.set_positions(r) atoms_emt = atoms_kim.copy() kim = OpenKIMcalculator(openkimmodel, allowed=nbltype) emt = EMT() emt.set_subtractE0(False) atoms_kim.set_calculator(kim) atoms_emt.set_calculator(emt) ek = atoms_kim.get_potential_energy() ee = atoms_emt.get_potential_energy() ReportTest(txt+"Total energy", ek, ee, 1e-8) ek = atoms_kim.get_potential_energies() ee = atoms_emt.get_potential_energies() for i in range(0, natoms, step): ReportTest(txt+"Energy of atom %i" % (i,), ek[i], ee[i], 1e-8) fk = atoms_kim.get_forces() fe = atoms_emt.get_forces() n = 0 for i in range(0, natoms, step): n = (n + 1) % 3 ReportTest(txt+"Force(%i) of atom %i" % (n, i), fk[i, n], fe[i, n], 1e-8) sk = atoms_kim.get_stress()
for i2, p2 in enumerate(positions[:i1]): diff = p2 - p1 d2 = np.dot(diff, diff) c6 = (self.sigma**2 / d2)**3 c12 = c6**2 if d2 < self.cutoff**2: self.energy += 4 * self.epsilon * (c12 - c6) - self.shift F = 24 * self.epsilon * (2 * c12 - c6) / d2 * diff self._forces[i1] -= F self._forces[i2] += F self.positions = positions.copy() N = 5 ar = FaceCenteredCubic('Ar', pbc=[(0,0,0)], directions=[[1,0,0],[0,1,0],[0,0,1]], size=[N,N,N]) print ar.get_cell() #view(ar) calc1 = KIMCalculator("ex_model_Ar_P_LJ") ar.set_calculator(calc1) kim_energy = ar.get_potential_energy() print "kim energy = ", kim_energy calc2 = LennardJones(epsilon=epsilon, sigma=sigma, cutoff=cutoff) ar.set_calculator(calc2) ase_energy = ar.get_potential_energy() print "ase energy = ", ase_energy print "difference = ", kim_energy - ase_energy
from ase.calculators.emt import EMT #from asap3 import EMT # Way too slow with ase.EMT ! size = 10 T = 1500 # Kelvin # Set up a crystal atoms = FaceCenteredCubic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], symbol="Cu", size=(size, size, size), pbc=False) # Describe the interatomic interactions with the Effective Medium Theory atoms.set_calculator(EMT()) # We want to run MD with constant energy using the Langevin algorithm # with a time step of 5 fs, the temperature T and the friction # coefficient to 0.02 atomic units. dyn = Langevin(atoms, 5 * units.fs, T * units.kB, 0.002) def printenergy(a=atoms): # store a reference to atoms in the definition. """Function to print the potential, kinetic and total energy.""" epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) print('Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' 'Etot = %.3feV' % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin))
"""Check that energy is correct even after wrapping through periodic boundary conditions. """ from ase.lattice.cubic import FaceCenteredCubic from asap3 import * from asap3.testtools import * import random ref_atoms = FaceCenteredCubic(size=(7,7,7), symbol="Cu", pbc=(True, False, True)) ref_atoms.set_calculator(EMT()) ref_energy = ref_atoms.get_potential_energy() ref_energies = ref_atoms.get_potential_energies() ref_forces = ref_atoms.get_forces() passes = 5 for ps in range(passes): print "Pass", ps, "of", passes atoms = ref_atoms.copy() atoms.set_calculator(EMT()) nat = random.randint(0, len(atoms)) assert nat < len(atoms) pos0 = atoms[nat].position cell = atoms.get_cell() for d in range(1,4): for dx in (-d, 0, d): #for dy in (-d, 0, d): for dy in (0,): for dz in (-d, 0 ,d): deltar = dx * cell[0] + dy * cell[1] + dz * cell[2]
from ase.io import write, read from ase import units from ase.lattice.cubic import FaceCenteredCubic from ase.md.verlet import VelocityVerlet from ase.optimize import FIRE # Parameters for the Morse potential for Cu D = 0.3429 r0 = 2.866 alpha = 1.3588 atoms = FaceCenteredCubic(latticeconstant=1.5, symbol='Cu', pbc=False, size=(3,3,3)) atoms.center(vacuum=100) atoms.set_calculator(MorsePotential(D=D, alpha=alpha, r0=r0)) dyn = FIRE(atoms, trajectory='relax.traj') dyn.run(fmax=0.01) write('relax.xyz', read('relax.traj@:')) # uncomment this line for Task 2 open('md_fire.log', 'w').close() # clean current log file dyn = VelocityVerlet(atoms, dt=1 * units.fs, trajectory='md_fire.traj', logfile='md_fire.log') dyn.run(1000) write('md_fire.xyz', read('md_fire.traj@:')) # write('langevin.xyz', read('langevin.traj@:')) # uncomment this line for Task 3
return p def MakeEMT2013(): "EMT2013 potential." return EMT2013(PtY_parameters) for pot in (EMT, MakeLJ, MakeEMT2013): print "Testing:", pot.__doc__.split("\n")[0] atoms1 = FaceCenteredCubic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], size=(6, 6, 6), symbol="Pt") emt = pot() atoms1.set_calculator(emt) f1 = atoms1.get_forces() atoms2 = FaceCenteredCubic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], size=(5, 5, 5), symbol="Pt") atoms2.set_calculator(emt) f3 = atoms1.get_forces() maxdev = abs(f3 - f1).max() print maxdev ReportTest("Max error 1:", maxdev, 0.0, 1e-6) atoms1 = FaceCenteredCubic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], size=(6, 6, 6), symbol="Pt") emt = pot()
delta=0.01, full_output=True, disp=False) #print "Minimize unit cell:", xopt, fopt, iter, calls if __name__ == '__main__': from asap3 import EMT, units, EMThcpParameters from ase.lattice.cubic import FaceCenteredCubic from ase.lattice.hexagonal import HexagonalClosedPacked print "Calculating cubic constants for Cu" atoms = FaceCenteredCubic(size=(5, 5, 5), symbol='Cu', latticeconstant=3.59495722231) atoms.set_calculator(EMT()) e = ElasticConstants(atoms, 'cubic') print np.array(e) / units.GPa print "Pretending that Cu is hexagonal" e = ElasticConstants(atoms, 'hexagonal', sanity=False) print np.array(e) / units.GPa print "Calculating elastic constants for Ru" atoms = HexagonalClosedPacked(size=(5, 5, 5), symbol='Ru', directions=[[1, -2, 1, 0], [1, 0, -1, 0], [0, 0, 0, 1]]) atoms.set_calculator(EMT(EMThcpParameters())) e = ElasticConstants(atoms, 'hexagonal', minimize=True) print np.array(e) / units.GPa
potential_path = os.environ.get('LAMMPS_POTENTIALS_PATH', '.') cmds = [ "pair_style eam/alloy", "pair_coeff * * {path}/NiAlH_jea.eam.alloy Ni H" "".format(path=potential_path) ] lammps = LAMMPSlib(lmpcmds=cmds, atom_types={ 'Ni': 1, 'H': 2 }, log_file='test.log', keep_alive=True) atoms = FaceCenteredCubic(size=(2, 2, 2), latticeconstant=3.52, symbol="Ni", pbc=True) atoms.set_calculator(lammps) energy_ppp_ref = -142.400000403 energy_ppp = atoms.get_potential_energy() print("Computed energy with boundary ppp = {}".format(energy_ppp)) diff_ppp = abs((energy_ppp - energy_ppp_ref) / energy_ppp_ref) assert diff_ppp < 1e-10, "Expected " + str(energy_ppp_ref) atoms.set_pbc((False, False, True)) energy_ssp_ref = -114.524625705 energy_ssp = atoms.get_potential_energy() print("Computed energy with boundary ssp = {}".format(energy_ssp)) diff_ssp = abs((energy_ssp - energy_ssp_ref) / energy_ssp_ref) assert diff_ssp < 1e-10, "Expected " + str(energy_ssp_ref)
def test_mix_eam_alloy(self): if False: source,parameters,F,f,rep = read_eam("CuAu_Zhou.eam.alloy",kind="eam/alloy") source1,parameters1,F1,f1,rep1 = mix_eam(["Cu_Zhou.eam.alloy","Au_Zhou.eam.alloy"],"eam/alloy","weight") write_eam(source1,parameters1,F1,f1,rep1,"CuAu_mixed.eam.alloy",kind="eam/alloy") calc0 = EAM('CuAu_Zhou.eam.alloy') calc1 = EAM('CuAu_mixed.eam.alloy') a = FaceCenteredCubic('Cu', size=[2,2,2]) a.set_calculator(calc0) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e0 = a.get_potential_energy()/len(a) a = FaceCenteredCubic('Cu', size=[2,2,2]) a.set_calculator(calc1) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e1 = a.get_potential_energy()/len(a) self.assertTrue(e0-e1 < 0.0005) a = FaceCenteredCubic('Au', size=[2,2,2]) a.set_calculator(calc0) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e0 = a.get_potential_energy()/len(a) a = FaceCenteredCubic('Au', size=[2,2,2]) a.set_calculator(calc1) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e1 = a.get_potential_energy()/len(a) self.assertTrue(e0-e1 < 0.0005) a = L1_2(['Au', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc0) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e0 = a.get_potential_energy()/len(a) a = L1_2(['Au', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc1) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e1 = a.get_potential_energy()/len(a) self.assertTrue(e0-e1 < 0.0005) a = L1_2(['Cu', 'Au'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc0) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e0 = a.get_potential_energy()/len(a) a = L1_2(['Cu', 'Au'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc1) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e1 = a.get_potential_energy()/len(a) self.assertTrue(e0-e1 < 0.0005) a = B1(['Au', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc0) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e0 = a.get_potential_energy()/len(a) a = B1(['Au', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc1) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e1 = a.get_potential_energy()/len(a) self.assertTrue(e0-e1 < 0.0005) os.remove("CuAu_mixed.eam.alloy")
nrun = 1 for ntest in range(nrun): print print "Running pass", ntest+1, "of", nrun print if pbcrnd: pbc = tuple(random.randint(0,2,3)) print "Periodic boundaries:", pbc if nrun > 1: time.sleep(1) atoms = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], size=(10,10,10), symbol=element, pbc=pbc) atoms = MonteCarloAtoms(atoms) print "Number of atoms:", len(atoms) atoms.set_calculator(MonteCarloEMT()) atoms.get_potential_energies() # Force creation of neighbor list. atoms2 = atoms.copy() atoms2.set_calculator(EMT()) print print "Testing perturbations of single atoms" pick1 = argsort(random.random((len(magnarr),))) for magn in take(magnarr, pick1): pick2 = argsort(random.random((len(numarr),))) for number in take(numarr, pick2): # Pick number random atoms. if number < 0: # Find N neighboring atoms and perturb them number = -number
elif world.size == 3: cpulayout = [1,3,1] elif world.size == 4: cpulayout = [1,2,2] print_version(1) if ismaster: atoms = FaceCenteredCubic(size=(2,10,10), symbol="Cu", pbc=False, latticeconstant = 3.5) else: atoms = None if isparallel: atoms = MakeParallelAtoms(atoms, cpulayout) atoms.set_calculator(asap3.EMT()) natoms = atoms.get_number_of_atoms() ReportTest("Number of atoms", natoms, 800, 0) # Make a small perturbation of the momenta atoms.set_momenta(1e-6 * random.random([len(atoms), 3])) print "Initializing ..." predyn = VelocityVerlet(atoms, 0.5) try: predyn.run(2500) except: print atoms.arrays['positions'] print atoms.arrays['momenta'] print atoms.arrays['momenta'].shape print atoms.get_masses()
for j in range(3): if i != j and np.abs(uc[i,j]) > 1e-15: diagonal = False if not (self.allow_mi_opbc and atoms.get_pbc().all() and diagonal): # Minimum Image Orthogonal Periodic Boundary Conditions # are not allowed remove.extend(["MI_OPBC_H", "MI_OPBC_F"]) if atoms.get_pbc().any(): # Cluster method is not allowed remove.append("CLUSTER") for rem in remove: if rem in allowed: allowed.remove(rem) if self.verbose: print "Allowed PBC:", allowed return allowed if __name__ == '__main__': from ase.lattice.cubic import FaceCenteredCubic atoms = FaceCenteredCubic(size=(10,10,10), symbol='Cu') print "Creating calculator" pot = OpenKIMcalculator('EMT_Asap_Standard_AlAgAuCuNiPdPt__MO_118428466217_000') print "Setting atoms" atoms.set_calculator(pot) print "Calculating energy" print atoms.get_potential_energy() print atoms.get_forces()[10:] print atoms.get_stress()
def main(element, T_up, T_low, T_expect, bulkmodulus, makepot): def set_temp_fric(dyn, atoms): z = atoms.get_positions()[:,2] zmax = atoms.get_cell()[2,2] zmin = 0 T = T_low + (T_up - T_low) * (z - zmin) / (zmax - zmin) dyn.set_temperature(T * units.kB) rnd = world.sum(random.randint(0,2**32)) # Insures the same number on all nodes. prefix = "melt-%s-%s" % (element, hex(rnd)[2:]) if master: print "Using output directory", prefix os.mkdir(prefix) else: while not os.path.exists(prefix): time.sleep(1) if master: atoms = FaceCenteredCubic(symbol=element, size=size, pbc=(True, True, False)) atoms.center(vacuum=10.0, axis=2) else: atoms = None atoms = MakeParallelAtoms(atoms, cpulayout1) print world.rank, '-', len(atoms), atoms.get_number_of_atoms() atoms.set_calculator(makepot()) #view(atoms) dyn = Langevin(atoms, 5*units.fs, 0.0, friction) logger = MDLogger(dyn, atoms, prefix+'/Melt-phase1.log', stress=True, peratom=True) dyn.attach(logger, interval=100) set_temp_fric(dyn, atoms) unstress = Inhomogeneous_NPTBerendsen(atoms, 50*units.fs, 0, taup=500*units.fs, compressibility=1/bulkmodulus) dyn.attach(unstress.scale_positions_and_cell, interval=10) #traj = PickleTrajectory("melting-phase1.traj", "w", atoms) fn1 = prefix + "/Melt-phase1.bundle" if master: print "Opening file", fn1 traj = BundleTrajectory(fn1, "w", atoms, split=True) dyn.attach(traj, interval=500) therm = Thermometer(atoms, prefix+"/TempProfile-phase1.dat") dyn.attach(therm.update, interval=500) for i in range(steps1 / 100): dyn.run(100) set_temp_fric(dyn, atoms) if master: print "Closing file", fn1 traj.close() del traj, atoms # Reread the bundle atoms = BundleTrajectory(fn1).get_atoms(-1, cpulayout2) atoms.set_calculator(makepot()) dyn = VelocityVerlet(atoms, 5*units.fs) logger = MDLogger(dyn, atoms, prefix+'/PtMelt-phase2.log', stress=True, peratom=True) dyn.attach(logger, interval=1000) unstress = Inhomogeneous_NPTBerendsen(atoms, 50*units.fs, 0, taup=5000*units.fs, compressibility=1/bulkmodulus) dyn.attach(unstress.scale_positions_and_cell, interval=10) fn2 = prefix + "/Melt-phase2.bundle" if master: print "Opening file", fn2 traj = BundleTrajectory(fn2, "w", atoms) dyn.attach(traj, interval=steps2/100) therm = Thermometer(atoms, prefix+"/TempProfile-phase2.dat") dyn.attach(therm.update, interval=steps2/10) dyn.run(steps2 - takedata) therm2 = AveragingThermometer(atoms) dyn.attach(therm2.update, interval=100) dyn.run(takedata) # Run the last part T = therm2.get_temp() if master: print "Melting temperature:", T ReportTest("Melting temperature", T, T_expect, 3) if cleanup: world.barrier() # Cleanup may fail due to the directory not being updated from # writes on the other nodes. Wait for NFS file system. time.sleep(60) if master: shutil.rmtree(prefix) world.barrier() ReportTest.Summary()
def pot(): #return EMT2013(PtY_parameters) return EMT() #set_verbose(1) master = world.rank == 0 if master: atoms0 = FaceCenteredCubic(symbol='Pt', size=(15, 15, 30)) else: atoms0 = None atoms0 = MakeParallelAtoms(atoms0, (1, 1, 2)) atoms0.set_calculator(pot()) print >> sys.stderr, "*********** FIRST FORCE CALCULATION ************" print >> sys.stderr, "len(atoms) =", len( atoms0), " no. atoms =", atoms0.get_number_of_atoms() f0 = atoms0.get_forces() perturbation = 0.01 * np.random.standard_normal(atoms0.get_positions().shape) r = atoms0.get_positions() + perturbation atoms0.set_positions(r) print >> sys.stderr, "*********** SECOND FORCE CALCULATION ************" f1 = atoms0.get_forces() print >> sys.stderr, "*********** COPYING ATOMS **************" atoms2 = ParallelAtoms((1, 1, 2), atoms0.comm, atoms0, distribute=False) atoms2.set_calculator(pot())
from hotbit import * from ase.lattice.cubic import FaceCenteredCubic import numpy as np import pylab from box.interpolation import interpolate_path pi = np.pi d = 4.08 atoms = FaceCenteredCubic('Au', latticeconstant=d, directions=((0, 1, 1), (1, 0, 1), (1, 1, 0)), align=False) calc = Hotbit(SCC=False, kpts=(8, 8, 8), txt='bs.cal') atoms.set_calculator(calc) atoms.get_potential_energy() # reciprocal lattice vectors V = atoms.get_volume() a, b, c = atoms.get_cell() a_ = 2 * pi / V * np.cross(b, c) b_ = 2 * pi / V * np.cross(c, a) c_ = 2 * pi / V * np.cross(a, b) gamma = np.array((0, 0, 0)) # a path which connects the L-points and gamma-point kpts, distances, label_points = interpolate_path( (-a_ / 2, a_ / 2, gamma, -b_ / 2, b_ / 2, gamma, -c_ / 2, c_ / 2, gamma, (-a_ - b_ - c_) / 2, (a_ + b_ + c_) / 2), 500)
def test_CuAg(self): a = FaceCenteredCubic('Cu', size=[2,2,2]) calc = EAM('CuAg.eam.alloy') a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e_Cu = a.get_potential_energy()/len(a) a = FaceCenteredCubic('Ag', size=[2,2,2]) a.set_calculator(calc) FIRE(StrainFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e_Ag = a.get_potential_energy()/len(a) self.assertTrue(abs(e_Ag+2.85)<1e-6) a = L1_2(['Ag', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.096)<0.0005) a = B1(['Ag', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.516)<0.0005) a = B2(['Ag', 'Cu'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.177)<0.0003) a = L1_2(['Cu', 'Ag'], size=[2,2,2], latticeconstant=4.0) a.set_calculator(calc) FIRE(UnitCellFilter(a, mask=[1,1,1,0,0,0]), logfile=None).run(fmax=0.001) e = a.get_potential_energy() syms = np.array(a.get_chemical_symbols()) self.assertTrue(abs((e-(syms=='Cu').sum()*e_Cu- (syms=='Ag').sum()*e_Ag)/len(a)-0.083)<0.0005)
a.set_cell(newcell, scale_atoms=True) #if len(v) > 1: # print "fmin: %.4f %7.4f %8.4f %8.4f" % (v[0], v[1], a.get_positions()[1792,2], a.get_potential_energy()) return a.get_potential_energy() xopt, fopt, iter, calls, flag = fmin(energy, var, delta=0.01, full_output=True, disp=False) #print "Minimize unit cell:", xopt, fopt, iter, calls if __name__ == '__main__': from asap3 import EMT, units, EMThcpParameters from ase.lattice.cubic import FaceCenteredCubic from ase.lattice.hexagonal import HexagonalClosedPacked print "Calculating cubic constants for Cu" atoms = FaceCenteredCubic(size=(5,5,5), symbol='Cu', latticeconstant=3.59495722231) atoms.set_calculator(EMT()) e = ElasticConstants(atoms, 'cubic') print np.array(e) / units.GPa print "Pretending that Cu is hexagonal" e = ElasticConstants(atoms, 'hexagonal', sanity=False) print np.array(e) / units.GPa print "Calculating elastic constants for Ru" atoms = HexagonalClosedPacked(size=(5,5,5), symbol='Ru', directions=[[1,-2,1,0], [1,0,-1,0], [0,0,0,1]]) atoms.set_calculator(EMT(EMThcpParameters())) e = ElasticConstants(atoms, 'hexagonal', minimize=True) print np.array(e) / units.GPa
j in fnb[i], silent=True) ReportTest.BoolTest("Atom %d on list %d (reverse)" % (i, j), i in fnb[j], silent=True) if ReportTest.GetNumberOfErrors() > 10: print "*** Too many errors - giving up! ***" break print_version(1) element = "Cu" latconst = ase.data.reference_states[ase.data.atomic_numbers[element]]['a'] atoms = FaceCenteredCubic(directions=[[1,0,0],[0,1,1],[0,0,1]], size=(9,7,5), symbol=element, debug=0) atoms.set_calculator(EMT(minimum_image=True)) epot = atoms.get_potential_energy() nblist = atoms.get_calculator().get_neighborlist() count = {} for lst in nblist: n = len(lst) try: count[n] += 1 except KeyError: count[n] = 1 # print "Histogram:" numbers = count.keys() numbers.sort() sum = 0 for i in numbers:
def test_mask_decomposition_lj_cut(self): a = FaceCenteredCubic('Au', size=[2,2,2]) c = LJCut(el1='Au', el2='Au', epsilon=1.0, sigma=1.0, cutoff=6.0) a.set_calculator(c) self.random_mask_test(a)
elif str == "hcp": from math import sqrt a = lp b = sqrt(3.0) * lp c = lp * sqrt(8.0 / 3.0) * catoi # this did not work # maybe wrong setting of LAMMPS volume optimization for triclinic cell # from ase.lattice.hexagonal import HexagonalClosedPacked # atoms = HexagonalClosedPacked(symbol=el1,latticeconstant=(lp,c),size=(5,5,5)) atoms = HCPO(symbol=el1, latticeconstant=(a, b, c), size=(8, 4, 4)) else: raise RuntimeError, 'unknown structure "' + str + '"' atoms.set_calculator(calc) print "el:", el1, "str:", str, "lp:", lp if str == "hcp": print "catoi:", catoi v1 = atoms.get_volume() print "v1:", v1 n1 = atoms.get_number_of_atoms() print "n1:", n1 v1pa = v1 / n1 print "v1pa:", v1pa # initial ene0 = atoms.get_potential_energy() print "ene0:", ene0
def test_mask_decomposition_tabulated_alloy_eam(self): a = FaceCenteredCubic('Au', size=[2,2,2]) c = TabulatedAlloyEAM(fn='Au-Grochola-JCP05.eam.alloy') a.set_calculator(c) self.random_mask_test(a)
if len(sys.argv) == 2: arg = sys.argv[1] else: arg = 'Wrong number of arguments.' if arg == 'EMT': filename = 'small_EMT.dat' elif arg == 'EMT2013': filename = 'small_EMT2013.dat' else: print __doc__ sys.exit(1) T = 450 atoms = FaceCenteredCubic(size=(10,10,10), symbol='Cu', pbc=False) if arg == 'EMT': atoms.set_calculator(EMT()) else: atoms.set_calculator(EMT2013(EMT2013_parameters)) print "Setting temperature:", T, "K" MaxwellBoltzmannDistribution(atoms, 2*T*units.kB) Stationary(atoms) dyn1 = Langevin(atoms, 2*units.fs, temperature=T*units.kB, friction=0.05) dyn1.run(200) dyn = VelocityVerlet(atoms, 3*units.fs, logfile=filename, loginterval=25) dyn.run(10000000) # 10^7 timesteps is 3 ns.
# Attach VASP calculation to Optimize Nuclei position ''' From the calculation, the lattice constants can be obtained, and the constants are used to creat Surface_Au in the next step. ''' from ase.calculators.vasp import Vasp calc = Vasp( xc='PBE', #Level of theory (density functional) encut= 520, #plane-wave kinetic energy cutoff (convergence test; I usually use about 520) kpts=[ 10, 10, 10 ], #number of k-points, e.g. [3,3,3] (convergence test; fewer kpoints are needed if lattice dimension is large) isif=3, #relaxation method (2 = positions, 3 = positions+volume) prec='Accurate', #accuracy (don't change this) sigma=0.01, #don't need to change (smearing width) ismear=0, #don't need to change (smearing method) isym=0, #disables symmetry ediffg= -0.03, #force tolerance, |ediffg| (eV/A) (I generally use 0.01 --> 0.03; lower is better but will take longer) nsw=1000, #maximum number of steps #ivdw=12, #enable van der Waals interactions ibrion=2 ) #geom opt algorithm (dont need change; default is conjugate gradient -- works fine) Bulk_Au.set_calculator(calc) Bulk_Au.get_potential_energy()