def run_md(atoms): from ase import units from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.md import VelocityVerlet traj = ase.io.Trajectory("traj.traj", 'w') calc = Amp.load("amp.amp") atoms.set_calculator(calc) atoms.get_potential_energy() MaxwellBoltzmannDistribution(atoms, 10. * units.kB) traj.write(atoms) dyn = VelocityVerlet(atoms, dt=1. * units.fs) f = open("md.ene", "w") f.write("{:^5s}{:^10s}{:^10s}{:^10s}\n".format("time", "Etot", "Epot", "Ekin")) for step in range(100): pot = atoms.get_potential_energy() # kin = atoms.get_kinetic_energy() tot = pot + kin f.write("{:5d}{:10.5f}{:10.5f}{:10.5f}\n".format(step, tot, pot, kin)) print("{}: Total Energy={}, POT={}, KIN={}".format( step, tot, pot, kin)) dyn.run(10) traj.write(atoms) f.close()
def TestEnergyConservation(): print "Running TestEnergyConservation..." calc = Morse(elements, epsilon, alpha, rmin) atoms = SimpleCubic('Ar', size=(10,10,10), latticeconstant=5.0) n = 0 while n < 100: i = np.random.randint(len(atoms)-1) if atoms[i].number != atomic_numbers['Ru']: atoms[i].number = atomic_numbers['Ru'] n += 1 atoms.set_calculator(calc) # Set initial momentum MaxwellBoltzmannDistribution(atoms, 300*units.kB) # Run dynamics dyn = VelocityVerlet(atoms, 1.0 * units.fs, logfile='test-energy.dat', loginterval=10) dyn.run(10) etot = (atoms.get_potential_energy() + atoms.get_kinetic_energy())/len(atoms) print "%-9s %-9s %-9s" % ("Epot", "Ekin", "Sum") for i in range(25): if i: dyn.run(100) epot = atoms.get_potential_energy()/len(atoms) ekin = atoms.get_kinetic_energy()/len(atoms) print "%9.5f %9.5f %9.5f" % (epot, ekin, epot+ekin) ReportTest("Step %i." % (i,), epot+ekin, etot, 1e-3, silent=True)
def test_idealgas(): from ase.md import VelocityVerlet from ase.build import bulk from ase.units import kB from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.calculators.idealgas import IdealGas import numpy as np atoms = bulk('Kr').repeat((10, 10, 10)) assert len(atoms) == 1000 atoms.center(vacuum=100) atoms.set_calculator(IdealGas()) T = 1000 MaxwellBoltzmannDistribution(atoms, T * kB) print("Temperature: {} K".format(atoms.get_temperature())) md = VelocityVerlet(atoms, timestep=0.1) for i in range(5): md.run(5) s = atoms.get_stress(include_ideal_gas=True) p = -s[:3].sum() / 3 v = atoms.get_volume() N = len(atoms) T = atoms.get_temperature() print("pV = {} NkT = {}".format(p * v, N * kB * T)) assert np.fabs(p * v - N * kB * T) < 1e-6
def run_md(fdata, atoms): from ase import units from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.md import VelocityVerlet fdata = fdata[:-7] traj = ase.io.Trajectory(fdata + ".traj", 'w') calc = Amp.load("amp.amp") atoms.set_calculator(calc) atoms.get_potential_energy() MaxwellBoltzmannDistribution(atoms, 100. * units.kB) #Boltzmann constant eV/K traj.write(atoms) dyn = VelocityVerlet(atoms, dt=1. * units.fs) for step in range(200): pot = atoms.get_potential_energy() # kin = atoms.get_kinetic_energy() with open(fdata + '.txt', 'a') as f: f.write("{}: Total Energy={}, POT={}, KIN={}\n".format( step, pot + kin, pot, kin)) dyn.run(5) ase.io.write(fdata + '.xyz', ase.io.read(fdata + '.traj'), append=True) traj.write(atoms)
def run(self, calc, filename): slab = self.starting_geometry.copy() slab.set_calculator(calc) np.random.seed(1) MaxwellBoltzmannDistribution(slab, self.temp * units.kB) if self.ensemble == "NVE": dyn = VelocityVerlet(slab, self.dt * units.fs) elif self.ensemble == "nvtberendsen": dyn = nvtberendsen.NVTBerendsen(slab, self.dt * units.fs, self.temp, taut=300 * units.fs) elif self.ensemble == "langevin": dyn = Langevin(slab, self.dt * units.fs, self.temp * units.kB, 0.002) traj = ase.io.Trajectory(filename + ".traj", "w", slab) dyn.attach(traj.write, interval=1) try: fixed_atoms = len(slab.constraints[0].get_indices()) except: fixed_atoms = 0 pass def printenergy(a=slab): """Function to print( the potential, kinetic, and total energy)""" epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / (len(a) - fixed_atoms) print("Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) " "Etot = %.3feV" % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin)) if printenergy: dyn.attach(printenergy, interval=10) dyn.run(self.count)
def test_idealgas(): rng = np.random.RandomState(17) atoms = bulk('Kr').repeat((10, 10, 10)) assert len(atoms) == 1000 atoms.center(vacuum=100) atoms.calc = IdealGas() natoms = len(atoms) md_temp = 1000 MaxwellBoltzmannDistribution(atoms, md_temp * kB, rng=rng) print("Temperature: {} K".format(atoms.get_temperature())) md = VelocityVerlet(atoms, timestep=0.1) for i in range(5): md.run(5) stress = atoms.get_stress(include_ideal_gas=True) stresses = atoms.get_stresses(include_ideal_gas=True) assert stresses.mean(0) == pytest.approx(stress) pressure = -stress[:3].sum() / 3 pV = pressure * atoms.cell.volume NkT = natoms * kB * atoms.get_temperature() print(f"pV = {pV} NkT = {NkT}") assert pV == pytest.approx(NkT, abs=1e-6)
def canonical(atoms,dt=1.0,steps=1000,output=10,name=None,verbose=False): """ Perform little canonical simulation. parameters: ----------- atoms: atoms with calculator attached dt: time step in fs steps: how many md steps output: output frequency name: TrajectoryRecording name verbose: increase verbosity """ if name==None: try: name=atoms.get_chemical_formula(mode="hill") except: name='microcanonical' name+='.trj' traj=PickleTrajectory(name,'w',atoms) rec=TrajectoryRecording(atoms,verbose) md=VelocityVerlet(atoms,dt*fs) md.attach(rec,interval=output) md.attach(traj.write,interval=output) md.run(steps) return rec
def microcanonical(atoms, dt=1.0, steps=100, output=1, name=None, verbose=False): """ Perform little microcanonical simulation. parameters: ----------- atoms: dt: time step in fs steps: how many md steps output: output frequency name: TrajectoryRecording name verbose: increase verbosity Return TrajectoryRecording object for further analysis. """ if name == None: try: name = atoms.get_chemical_formula(mode="hill") except: name = 'microcanonical' name += '.trj' traj = Trajectory(name, 'w', atoms) rec = TrajectoryRecording(atoms, verbose) md = VelocityVerlet(atoms, dt * fs) md.attach(rec, interval=output) md.attach(traj.write, interval=output) md.run(steps) return rec
def amp_md(atoms, nstep, dt): from ase import units from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.md import VelocityVerlet traj = ase.io.Trajectory("traj.traj", 'w') try: calc = Amp.load("amp.amp") except FileNotFoundError: try: calc = Amp.load("amp-untrained-parameters.amp") except FileNotFoundError: print("Error: amp-pes.amp file does not exist, input amp-pot file by -p") sys.exit(1) atoms.set_calculator(calc) atoms.get_potential_energy() MaxwellBoltzmannDistribution(atoms, 300 * units.kB) traj.write(atoms) dyn = VelocityVerlet(atoms, dt=dt * units.fs) f = open("md.ene", "w") f.write("{:^5s} {:^10s} {:^10s} {:^10s}\n".format("time","Etot","Epot","Ekin")) for step in range(nstep): pot = atoms.get_potential_energy() # kin = atoms.get_kinetic_energy() tot = pot + kin f.write("{:5d}{:10.5f}{:10.5f}{:10.5f}\n".format(step, tot, pot, kin)) print("{}: Total Energy={}, POT={}, KIN={}".format(step, tot, pot, kin)) dyn.run(2) traj.write(atoms) # write kinetic energy, but pot is not seen in ase f.close()
def TestEnergyConservation(): print "Running TestEnergyConservation..." calc = Morse(elements, epsilon, alpha, rmin) atoms = SimpleCubic('Ar', size=(10, 10, 10), latticeconstant=5.0) n = 0 while n < 100: i = np.random.randint(len(atoms) - 1) if atoms[i].number != atomic_numbers['Ru']: atoms[i].number = atomic_numbers['Ru'] n += 1 atoms.set_calculator(calc) # Set initial momentum MaxwellBoltzmannDistribution(atoms, 300 * units.kB) # Run dynamics dyn = VelocityVerlet(atoms, 1.0 * units.fs, logfile='test-energy.dat', loginterval=10) dyn.run(10) etot = (atoms.get_potential_energy() + atoms.get_kinetic_energy()) / len(atoms) print "%-9s %-9s %-9s" % ("Epot", "Ekin", "Sum") for i in range(25): if i: dyn.run(100) epot = atoms.get_potential_energy() / len(atoms) ekin = atoms.get_kinetic_energy() / len(atoms) print "%9.5f %9.5f %9.5f" % (epot, ekin, epot + ekin) ReportTest("Step %i." % (i, ), epot + ekin, etot, 1e-3, silent=True)
def _molecular_dynamics(self, step, N): """Performs a molecular dynamics simulation, until mdmin is exceeded. If resuming, the file number (md%05i) is expected.""" mincount = 0 energies, oldpositions = [], [] thermalized = False if not thermalized: self.MaxwellBoltzmannDistribution(N, temp=self.temperature * kB, force_temp=True) traj = io.Trajectory('md.traj', 'a', self.atoms) dyn = VelocityVerlet(self.atoms, dt=self.timestep * units.fs) log = MDLogger(dyn, self.atoms, 'md.log', header=True, stress=False, peratom=False) dyn.attach(log, interval=1) dyn.attach(traj, interval=1) os.remove('md.log') os.remove('md.traj') while mincount < self.mdmin: dyn.run(1) energies.append(self.atoms.get_potential_energy()) passedmin = self.passedminimum(energies) if passedmin: mincount += 1 oldpositions.append(self.atoms.positions.copy()) # Reset atoms to minimum point. self.atoms.positions = oldpositions[passedmin[0]]
def test_nve_against_ase(self): from ase.build import bulk ase_atoms = bulk("Ar", cubic=True) * [8, 8, 8] ase_atoms.calc = aLJ( epsilon=self.epsilon, sigma=self.sigma, rc=self.rc, ro=self.ro, smooth=True ) ase_dyn = VelocityVerlet(ase_atoms, timestep=self.dt) asax_atoms = bulk("Ar", cubic=True) * [8, 8, 8] asax_atoms.calc = jLJ( epsilon=self.epsilon, sigma=self.sigma, rc=self.rc, ro=self.ro, x64=True ) asax_dyn = VelocityVerlet(asax_atoms, timestep=self.dt) for i in range(10): ase_dyn.run(steps=1) asax_dyn.run(steps=1) self.assertAllClose( ase_atoms.get_positions(wrap=True), asax_atoms.get_positions(wrap=True), atol=1e-8, equal_nan=False, )
def _molecular_dynamics(self, resume=None): """Performs a molecular dynamics simulation, until mdmin is exceeded. If resuming, the file number (md%05i) is expected.""" self._log('msg', 'Molecular dynamics: md%05i' % self._counter) mincount = 0 energies, oldpositions = [], [] thermalized = False if resume: self._log('msg', 'Resuming MD from md%05i.traj' % resume) if os.path.getsize('md%05i.traj' % resume) == 0: self._log( 'msg', 'md%05i.traj is empty. Resuming from ' 'qn%05i.traj.' % (resume, resume - 1)) atoms = io.read('qn%05i.traj' % (resume - 1), index=-1) else: with io.Trajectory('md%05i.traj' % resume, 'r') as images: for atoms in images: energies.append(atoms.get_potential_energy()) oldpositions.append(atoms.positions.copy()) passedmin = self._passedminimum(energies) if passedmin: mincount += 1 self._atoms.set_momenta(atoms.get_momenta()) thermalized = True self._atoms.positions = atoms.get_positions() self._log('msg', 'Starting MD with %i existing energies.' % len(energies)) if not thermalized: MaxwellBoltzmannDistribution(self._atoms, temperature_K=self._temperature, force_temp=True) traj = io.Trajectory('md%05i.traj' % self._counter, 'a', self._atoms) dyn = VelocityVerlet(self._atoms, timestep=self._timestep * units.fs) log = MDLogger(dyn, self._atoms, 'md%05i.log' % self._counter, header=True, stress=False, peratom=False) with traj, dyn, log: dyn.attach(log, interval=1) dyn.attach(traj, interval=1) while mincount < self._mdmin: dyn.run(1) energies.append(self._atoms.get_potential_energy()) passedmin = self._passedminimum(energies) if passedmin: mincount += 1 oldpositions.append(self._atoms.positions.copy()) # Reset atoms to minimum point. self._atoms.positions = oldpositions[passedmin[0]]
def test(): # Generate atomic system to create test data. atoms = fcc110('Cu', (2, 2, 2), vacuum=7.) adsorbate = Atoms([ Atom('H', atoms[7].position + (0., 0., 2.)), Atom('H', atoms[7].position + (0., 0., 5.)) ]) atoms.extend(adsorbate) atoms.set_constraint(FixAtoms(indices=[0, 2])) calc = EMT() # cheap calculator atoms.set_calculator(calc) # Run some molecular dynamics to generate data. trajectory = io.Trajectory('data.traj', 'w', atoms=atoms) MaxwellBoltzmannDistribution(atoms, temp=300. * units.kB) dynamics = VelocityVerlet(atoms, dt=1. * units.fs) dynamics.attach(trajectory) for step in range(50): dynamics.run(5) trajectory.close() # Train the calculator. train_images, test_images = randomize_images('data.traj') calc = Amp(descriptor=Behler(), regression=NeuralNetwork()) calc.train(train_images, energy_goal=0.001, force_goal=None) # Plot and test the predictions. import matplotlib matplotlib.use('Agg') from matplotlib import pyplot fig, ax = pyplot.subplots() for image in train_images: actual_energy = image.get_potential_energy() predicted_energy = calc.get_potential_energy(image) ax.plot(actual_energy, predicted_energy, 'b.') for image in test_images: actual_energy = image.get_potential_energy() predicted_energy = calc.get_potential_energy(image) ax.plot(actual_energy, predicted_energy, 'r.') ax.set_xlabel('Actual energy, eV') ax.set_ylabel('Amp energy, eV') fig.savefig('parityplot.png')
def test(): # Generate atomic system to create test data. atoms = fcc110('Cu', (2, 2, 2), vacuum=7.) adsorbate = Atoms([Atom('H', atoms[7].position + (0., 0., 2.)), Atom('H', atoms[7].position + (0., 0., 5.))]) atoms.extend(adsorbate) atoms.set_constraint(FixAtoms(indices=[0, 2])) calc = EMT() # cheap calculator atoms.set_calculator(calc) # Run some molecular dynamics to generate data. trajectory = io.Trajectory('data.traj', 'w', atoms=atoms) MaxwellBoltzmannDistribution(atoms, temp=300. * units.kB) dynamics = VelocityVerlet(atoms, dt=1. * units.fs) dynamics.attach(trajectory) for step in range(50): dynamics.run(5) trajectory.close() # Train the calculator. train_images, test_images = randomize_images('data.traj') calc = Amp(descriptor=Behler(), regression=NeuralNetwork()) calc.train(train_images, energy_goal=0.001, force_goal=None) # Plot and test the predictions. import matplotlib matplotlib.use('Agg') from matplotlib import pyplot fig, ax = pyplot.subplots() for image in train_images: actual_energy = image.get_potential_energy() predicted_energy = calc.get_potential_energy(image) ax.plot(actual_energy, predicted_energy, 'b.') for image in test_images: actual_energy = image.get_potential_energy() predicted_energy = calc.get_potential_energy(image) ax.plot(actual_energy, predicted_energy, 'r.') ax.set_xlabel('Actual energy, eV') ax.set_ylabel('Amp energy, eV') fig.savefig('parityplot.png')
def test_forcecurve(plt): from ase.build import bulk from ase.calculators.emt import EMT from ase.utils.forcecurve import force_curve from ase.md import VelocityVerlet from ase.units import fs from ase.io import read atoms = bulk('Au', cubic=True) * (2, 1, 1) atoms.calc = EMT() atoms.rattle(stdev=0.05) md = VelocityVerlet(atoms, timestep=12.0 * fs, trajectory='tmp.traj') md.run(steps=10) images = read('tmp.traj', ':') force_curve(images)
def _molecular_dynamics(self, resume=None): """Performs a molecular dynamics simulation, until mdmin is exceeded. If resuming, the file number (md%05i) is expected.""" self._log('msg', 'Molecular dynamics: md%05i' % self._counter) mincount = 0 energies, oldpositions = [], [] thermalized = False if resume: self._log('msg', 'Resuming MD from md%05i.traj' % resume) if os.path.getsize('md%05i.traj' % resume) == 0: self._log('msg', 'md%05i.traj is empty. Resuming from ' 'qn%05i.traj.' % (resume, resume - 1)) atoms = io.read('qn%05i.traj' % (resume - 1), index=-1) else: images = io.PickleTrajectory('md%05i.traj' % resume, 'r') for atoms in images: energies.append(atoms.get_potential_energy()) oldpositions.append(atoms.positions.copy()) passedmin = self._passedminimum(energies) if passedmin: mincount += 1 self._atoms.set_momenta(atoms.get_momenta()) thermalized = True self._atoms.positions = atoms.get_positions() self._log('msg', 'Starting MD with %i existing energies.' % len(energies)) if not thermalized: MaxwellBoltzmannDistribution(self._atoms, temp=self._temperature * units.kB, force_temp=True) traj = io.PickleTrajectory('md%05i.traj' % self._counter, 'a', self._atoms) dyn = VelocityVerlet(self._atoms, dt=self._timestep * units.fs) log = MDLogger(dyn, self._atoms, 'md%05i.log' % self._counter, header=True, stress=False, peratom=False) dyn.attach(log, interval=1) dyn.attach(traj, interval=1) while mincount < self._mdmin: dyn.run(1) energies.append(self._atoms.get_potential_energy()) passedmin = self._passedminimum(energies) if passedmin: mincount += 1 oldpositions.append(self._atoms.positions.copy()) # Reset atoms to minimum point. self._atoms.positions = oldpositions[passedmin[0]]
def generate_data(count, filename='training.traj'): """Generates test or training data with a simple MD simulation.""" if os.path.exists(filename): return traj = ase.io.Trajectory(filename, 'w') atoms = fcc110('Pt', (2, 2, 2), vacuum=7.) atoms.extend(Atoms([Atom('Cu', atoms[7].position + (0., 0., 2.5)), Atom('Cu', atoms[7].position + (0., 0., 5.))])) atoms.set_constraint(FixAtoms(indices=[0, 2])) atoms.set_calculator(EMT()) atoms.get_potential_energy() traj.write(atoms) MaxwellBoltzmannDistribution(atoms, 300. * units.kB) dyn = VelocityVerlet(atoms, dt=1. * units.fs) for step in range(count - 1): dyn.run(50) traj.write(atoms)
def test_verlet(): 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=TstPotential()) print(a.get_forces()) md = VelocityVerlet(a, timestep=0.5 * fs, logfile='-', loginterval=500) traj = Trajectory('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
def test_verlet_asap(asap3): with seterr(all='raise'): a = bulk('Au').repeat((2, 2, 2)) a[5].symbol = 'Ag' a.pbc = (True, True, False) print(a) a.calc = asap3.EMT() MaxwellBoltzmannDistribution(a, 300 * kB, force_temp=True) Stationary(a) assert abs(a.get_temperature() - 300) < 0.0001 print(a.get_forces()) md = VelocityVerlet(a, timestep=2 * fs, logfile='-', loginterval=500) traj = Trajectory('Au7Ag.traj', 'w', a) md.attach(traj.write, 100) e0 = a.get_total_energy() md.run(steps=10000) del traj assert abs(a.get_total_energy() - e0) < 0.0001 assert abs(read('Au7Ag.traj').get_total_energy() - e0) < 0.0001
def run_md(atoms): from ase import units from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.md import VelocityVerlet traj = ase.io.Trajectory("traj.traj", 'w') calc = Amp.load("amp.amp") atoms.set_calculator(calc) atoms.get_potential_energy() MaxwellBoltzmannDistribution(atoms, 300. * units.kB) traj.write(atoms) dyn = VelocityVerlet(atoms, dt=1. * units.fs) for step in range(100): pot = atoms.get_potential_energy() # kin = atoms.get_kinetic_energy() print("{}: Total Energy={}, POT={}, KIN={}".format( step, pot + kin, pot, kin)) dyn.run(10) traj.write(atoms)
def generate_data(count): """Generates test or training data with a simple MD simulation.""" atoms = fcc110('Pt', (2, 2, 2), vacuum=7.) adsorbate = Atoms([Atom('Cu', atoms[7].position + (0., 0., 2.5)), Atom('Cu', atoms[7].position + (0., 0., 5.))]) atoms.extend(adsorbate) atoms.set_constraint(FixAtoms(indices=[0, 2])) atoms.set_calculator(EMT()) MaxwellBoltzmannDistribution(atoms, 300. * units.kB) dyn = VelocityVerlet(atoms, dt=1. * units.fs) newatoms = atoms.copy() newatoms.set_calculator(EMT()) newatoms.get_potential_energy() images = [newatoms] for step in range(count - 1): dyn.run(50) newatoms = atoms.copy() newatoms.set_calculator(EMT()) newatoms.get_potential_energy() images.append(newatoms) return images
def generate_data(count): """Generates test or training data with a simple MD simulation.""" atoms = fcc110('Pt', (2, 2, 1), vacuum=7.) adsorbate = Atoms([Atom('Cu', atoms[3].position + (0., 0., 2.5)), Atom('Cu', atoms[3].position + (0., 0., 5.))]) atoms.extend(adsorbate) atoms.set_constraint(FixAtoms(indices=[0, 2])) atoms.set_calculator(EMT()) MaxwellBoltzmannDistribution(atoms, 300. * units.kB) dyn = VelocityVerlet(atoms, dt=1. * units.fs) newatoms = atoms.copy() newatoms.set_calculator(EMT()) newatoms.get_potential_energy() images = [newatoms] for step in range(count - 1): dyn.run(50) newatoms = atoms.copy() newatoms.set_calculator(EMT()) newatoms.get_potential_energy() images.append(newatoms) return images
def check_energy_conservation(atoms, dt=1.0 * fs, steps=200, tol=0.01, plot=False): """ For given initial atoms, check the energy conservation with NVE simulation. @param atoms: ase atoms instance @param dt: time step @param steps: number of time steps used in the check @param plot: use maplotlib to plot the etot,epot -graph Energy is conserved if fluctuation of total energy is tolerance times the fluctuation of potential energy. """ dyn = VelocityVerlet(atoms, dt=dt) epot = [] ekin = [] for i in range(steps): dyn.run(1) epot.append(atoms.get_potential_energy()) ekin.append(atoms.get_kinetic_energy()) epot = np.array(epot) ekin = np.array(ekin) etot = epot + ekin depot = np.sqrt(np.var(epot)) detot = np.sqrt(np.var(etot)) if plot: import pylab as pl pl.plot(epot, label='epot') pl.plot(etot, label='etot') pl.legend() pl.xlabel('time step') pl.ylabel('energy (eV)') pl.show() if detot < tol * depot: return True else: return False
def test_md(): from ase import Atoms from ase.calculators.emt import EMT from ase.md import VelocityVerlet from ase.io import Trajectory a = 3.6 b = a / 2 fcc = Atoms('Cu', positions=[(0, 0, 0)], cell=[(0, b, b), (b, 0, b), (b, b, 0)], pbc=1) fcc *= (2, 1, 1) fcc.set_calculator(EMT()) fcc.set_momenta([(0.9, 0.0, 0.0), (-0.9, 0, 0)]) md = VelocityVerlet(fcc, timestep=0.1) def f(): print(fcc.get_potential_energy(), fcc.get_total_energy()) md.attach(f) md.attach(Trajectory('Cu2.traj', 'w', fcc).write, interval=3) md.run(steps=20) Trajectory('Cu2.traj', 'r')[-1]
def generate_training_set(individual, db_name): """ Do MD using EMT calculator with each slab for 10 steps and add it to train.db """ db = connect(db_name) for miller_indices in individual: # Do MD slab = generate_slab(miller_indices, 5) slab = make_supercell(slab, P=[[3, 1, 1], [1, 3, 1], [1, 1, 1]]) slab.set_calculator(EMT()) slab.get_potential_energy() db.write(slab) MaxwellBoltzmannDistribution(slab, 300. * units.kB) dyn = VelocityVerlet(slab, dt=1. * units.fs) for i in range(1, 10): dyn.run(10) db.write(slab)
def check_energy_conservation(atoms,dt=1.0*fs,steps=200,tol=0.01,plot=False): """ For given initial atoms, check the energy conservation with NVE simulation. @param atoms: ase atoms instance @param dt: time step @param steps: number of time steps used in the check @param plot: use maplotlib to plot the etot,epot -graph Energy is conserved if fluctuation of total energy is tolerance times the fluctuation of potential energy. """ dyn = VelocityVerlet(atoms,dt=dt) epot = [] ekin = [] for i in range(steps): dyn.run(1) epot.append( atoms.get_potential_energy() ) ekin.append( atoms.get_kinetic_energy() ) epot = np.array(epot) ekin = np.array(ekin) etot = epot + ekin depot = np.sqrt( np.var(epot) ) detot = np.sqrt( np.var(etot) ) if plot: import pylab as pl pl.plot(epot,label='epot') pl.plot(etot,label='etot') pl.legend() pl.xlabel('time step') pl.ylabel('energy (eV)') pl.show() if detot < tol*depot: return True else: return False
from ase.build import bulk from ase.calculators.emt import EMT from ase.utils.forcecurve import force_curve from ase.md import VelocityVerlet from ase.units import fs from ase.io import read atoms = bulk('Au', cubic=True) * (2, 1, 1) atoms.calc = EMT() atoms.rattle(stdev=0.05) md = VelocityVerlet(atoms, timestep=12.0 * fs, trajectory='tmp.traj') md.run(steps=10) images = read('tmp.traj', ':') force_curve(images) # import pylab as plt # plt.show()
from ase import Atoms from ase.calculators.emt import EMT from ase.md import VelocityVerlet from ase.io import Trajectory a = 3.6 b = a / 2 fcc = Atoms('Cu', positions=[(0, 0, 0)], cell=[(0, b, b), (b, 0, b), (b, b, 0)], pbc=1) fcc *= (2, 1, 1) fcc.set_calculator(EMT()) fcc.set_momenta([(0.9, 0.0, 0.0), (-0.9, 0, 0)]) md = VelocityVerlet(fcc, dt=0.1) def f(): print(fcc.get_potential_energy(), fcc.get_total_energy()) md.attach(f) md.attach(Trajectory('Cu2.traj', 'w', fcc).write, interval=3) md.run(steps=20) fcc2 = Trajectory('Cu2.traj', 'r')[-1]
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.constraints import FixAtoms from ase.calculators.siesta import Siesta from ase.md import VelocityVerlet from ase import units # Read in the geometry from a xyz file, set the cell, boundary conditions and center atoms = read('geom.xyz') atoms.set_cell([7.66348,7.66348,7.66348*2]) atoms.set_pbc((1,1,1)) atoms.center() # Set initial velocities for hydrogen atoms along the z-direction p = atoms.get_momenta() p[0,2]= -1.5 p[1,2]= -1.5 atoms.set_momenta(p) # Keep some atoms fixed during the simulation atoms.set_constraint(FixAtoms(indices=range(18,38))) # Set the calculator and attach it to the system calc = Siesta('si001+h2',basis='SZ',xc='PBE',meshcutoff=50*units.Ry) calc.set_fdf('PAO.EnergyShift', 0.25 * units.eV) calc.set_fdf('PAO.SplitNorm', 0.15) atoms.set_calculator(calc) # Set the VelocityVerlet algorithm and run it dyn = VelocityVerlet(atoms,dt=1.0 * units.fs,trajectory='si001+h2.traj') dyn.run(steps=100)
def test_hookean(): """ Test of Hookean constraint. Checks for activity in keeping a bond, preventing vaporization, and that energy is conserved in NVE dynamics. """ import numpy as np from ase import Atoms, Atom from ase.build import fcc110 from ase.calculators.emt import EMT from ase.constraints import FixAtoms, Hookean from ase.md import VelocityVerlet from ase import units class SaveEnergy: """Class to save energy.""" def __init__(self, atoms): self.atoms = atoms self.energies = [] def __call__(self): self.energies.append(atoms.get_total_energy()) # Make Pt 110 slab with Cu2 adsorbate. atoms = fcc110('Pt', (2, 2, 2), vacuum=7.) adsorbate = Atoms([ Atom('Cu', atoms[7].position + (0., 0., 2.5)), Atom('Cu', atoms[7].position + (0., 0., 5.0)) ]) atoms.extend(adsorbate) calc = EMT() atoms.calc = calc # Constrain the surface to be fixed and a Hookean constraint between # the adsorbate atoms. constraints = [ FixAtoms(indices=[atom.index for atom in atoms if atom.symbol == 'Pt']), Hookean(a1=8, a2=9, rt=2.6, k=15.), Hookean(a1=8, a2=(0., 0., 1., -15.), k=15.) ] atoms.set_constraint(constraints) # Give it some kinetic energy. momenta = atoms.get_momenta() momenta[9, 2] += 20. momenta[9, 1] += 2. atoms.set_momenta(momenta) # Propagate in Velocity Verlet (NVE). dyn = VelocityVerlet(atoms, timestep=1.0 * units.fs) energies = SaveEnergy(atoms) dyn.attach(energies) dyn.run(steps=100) # Test the max bond length and position. bondlength = np.linalg.norm(atoms[8].position - atoms[9].position) assert bondlength < 3.0 assert atoms[9].z < 15.0 # Test that energy was conserved. assert max(energies.energies) - min(energies.energies) < 0.01 # Make sure that index shuffle works. neworder = list(range(len(atoms))) neworder[8] = 9 # Swap two atoms. neworder[9] = 8 atoms = atoms[neworder] assert atoms.constraints[1].indices[0] == 9 assert atoms.constraints[1].indices[1] == 8 assert atoms.constraints[2].index == 9
from ase import Atoms from ase.units import fs from ase.calculators.test import TestPotential from ase.md import VelocityVerlet 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()) md = VelocityVerlet(a, timestep=0.5 * fs, logfile='-', loginterval=500) traj = Trajectory('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.io import read from ase.constraints import FixAtoms from ase.calculators.siesta import Siesta from ase.md import VelocityVerlet from ase import units # Read in the geometry from a xyz file, set the cell, boundary conditions and center atoms = read('geom.xyz') atoms.set_cell([7.66348, 7.66348, 7.66348 * 2]) atoms.set_pbc((1, 1, 1)) atoms.center() # Set initial velocities for hydrogen atoms along the z-direction p = atoms.get_momenta() p[0, 2] = -1.5 p[1, 2] = -1.5 atoms.set_momenta(p) # Keep some atoms fixed during the simulation atoms.set_constraint(FixAtoms(indices=range(18, 38))) # Set the calculator and attach it to the system calc = Siesta('si001+h2', basis='SZ', xc='PBE', meshcutoff=50 * units.Ry) calc.set_fdf('PAO.EnergyShift', 0.25 * units.eV) calc.set_fdf('PAO.SplitNorm', 0.15) atoms.set_calculator(calc) # Set the VelocityVerlet algorithm and run it dyn = VelocityVerlet(atoms, dt=1.0 * units.fs, trajectory='si001+h2.traj') dyn.run(steps=100)
#opt.run(fmax=1e-3) ase.io.write('crack_3.xyz', c, format='extxyz') dyn = VelocityVerlet(c, params.dt, logfile=None) set_initial_velocities(dyn.atoms) crack_pos = [] traj = NetCDFTrajectory('traj.nc', 'w', c) dyn.attach(traj.write, 10, dyn.atoms, arrays=['stokes', 'momenta']) dyn.attach(find_crack_tip, 10, dyn.atoms, dt=params.dt*10, store=True, results=crack_pos) # run for 2000 time steps to reach steady state at initial load for i in range(20): dyn.run(100) if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): set_constraints(dyn.atoms, params.a, delta_strain=None) # start decreasing strain set_constraints(dyn.atoms, params.a, delta_strain=delta_strain) for i in range(1000): dyn.run(100) if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): set_constraints(dyn.atoms, params.a, delta_strain) traj.close() time = 10.0*dyn.dt*np.arange(dyn.get_number_of_steps()/10) np.savetxt('crackpos.dat', np.c_[time, crack_pos])
def test_verlet_thermostats_asap(asap3): rng = np.random.RandomState(0) calculator = asap3.EMT() T_low = 10 T_high = 300 md_kwargs = {'timestep': 0.5 * fs, 'logfile': '-', 'loginterval': 500} with seterr(all='raise'): a = bulk('Au').repeat((4, 4, 4)) a[5].symbol = 'Ag' # test thermalization by MaxwellBoltzmannDistribution thermalize(T_high, a, rng) assert abs(a.get_temperature() - T_high) < 0.0001 # test conservation of total energy e0 using Verlet a_verlet, traj = prepare_md(a, calculator) e0 = a_verlet.get_total_energy() md = VelocityVerlet(a_verlet, **md_kwargs) md.attach(traj.write, 100) md.run(steps=10000) traj_verlet = read('Au7Ag.traj', index=':') assert abs(traj_verlet[-1].get_total_energy() - e0) < 0.0001 # test reproduction of Verlet by Langevin and Andersen for thermostats # switched off pos_verlet = [t.get_positions() for t in traj_verlet[:3]] md_kwargs.update({'temperature_K': T_high}) for MDalgo in [Langevin, Andersen]: a_md, traj = prepare_md(a, calculator) if MDalgo is Langevin: md = MDalgo(a_md, friction=0.0, rng=rng, **md_kwargs) elif MDalgo is Andersen: md = MDalgo(a_md, andersen_prob=0.0, rng=rng, **md_kwargs) md.attach(traj, 100) md.run(steps=200) traj_md = read('Au7Ag.traj', index=':') pos_md = [t.get_positions() for t in traj_md[:3]] assert np.allclose(pos_verlet, pos_md) # Verlet reproduced? # test thermalization to target temperature by thermostats and # conservation of average temperature by thermostats md.set_timestep(4 * fs) if MDalgo is Langevin: md.set_friction(0.01) elif MDalgo is Andersen: md.set_andersen_prob(0.01) thermalize(T_low, a_md, rng) # thermalize with low temperature (T) assert abs(a_md.get_temperature() - T_low) < 0.0001 md.run(steps=500) # equilibration, i.e. thermalization to high T temp = [] def recorder(): temp.append(a_md.get_temperature()) md.attach(recorder, interval=1) md.run(7000) temp = np.array(temp) avgtemp = np.mean(temp) fluct = np.std(temp) print("Temperature is {:.2f} K +/- {:.2f} K".format( avgtemp, fluct)) assert abs(avgtemp - T_high) < 10.0
if atoms[i].number != atomic_numbers['Ru']: atoms[i].number = atomic_numbers['Ru'] n += 1 atoms.set_calculator(calc) # Set initial momentum MaxwellBoltzmannDistribution(atoms, 1000 * units.kB) # Run dynamics startcpu, startwall = time.clock(), time.time() dyn = VelocityVerlet(atoms, 1.0 * units.fs, logfile='test-energy.dat', loginterval=10) dyn.run(10) etot = (atoms.get_potential_energy() + atoms.get_kinetic_energy()) / len(atoms) #obs.close() for i in range(25): if i: dyn.run(1000) epot = atoms.get_potential_energy() / len(atoms) ekin = atoms.get_kinetic_energy() / len(atoms) print "%9.5f %9.5f %9.5f" % (epot, ekin, epot + ekin) ReportTest("Step %i." % (i, ), epot + ekin, etot, 1e-3, silent=True) cpu, wall = time.clock() - startcpu, time.time() - startwall fraction = cpu / wall print "" print ""
def ribs(params, voidcount, voidrad, frame_count=1000): calc = IdealBrittleSolid(rc=params.rc, k=params.k, a=params.a, beta=params.beta) x_dimer = np.linspace(params.a - (params.rc - params.a), params.a + 1.1 * (params.rc - params.a), 51) dimers = [ Atoms('Si2', [(0, 0, 0), (x, 0, 0)], cell=[10., 10., 10.], pbc=True) for x in x_dimer ] calc.set_reference_crystal(dimers[0]) e_dimer = [] f_dimer = [] f_num = [] for d in dimers: d.set_calculator(calc) e_dimer.append(d.get_potential_energy()) f_dimer.append(d.get_forces()) f_num.append(calc.calculate_numerical_forces(d)) e_dimer = np.array(e_dimer) f_dimer = np.array(f_dimer) f_num = np.array(f_num) assert abs(f_dimer - f_num).max() < 0.1 #! crystal is created here, the length and height can be modified here as well #! edit 3N changed to different values to test crystal = triangular_lattice_slab(params.a, params.lm * params.N, params.N) calc.set_reference_crystal(crystal) crystal.set_calculator(calc) e0 = crystal.get_potential_energy() l = crystal.cell[0, 0] h = crystal.cell[1, 1] print('l=', l, 'h=', h) # compute surface (Griffith) energy b = crystal.copy() b.set_calculator(calc) shift = calc.parameters['rc'] * 2 y = crystal.positions[:, 1] b.positions[y > h / 2, 1] += shift b.cell[1, 1] += shift e1 = b.get_potential_energy() E_G = (e1 - e0) / l print('Griffith energy', E_G) # compute Griffith strain eps = 0.0 # initial strain is zero eps_max = 2 / np.sqrt(3) * (params.rc - params.a) * np.sqrt( params.N - 1) / h # Griffith strain assuming harmonic energy deps = eps_max / 100. # strain increment e_over_l = 0.0 # initial energy per unit length is zero energy = [] strain = [] while e_over_l < E_G: c = crystal.copy() c.set_calculator(calc) c.positions[:, 1] *= (1.0 + eps) c.cell[1, 1] *= (1.0 + eps) e_over_l = c.get_potential_energy() / l energy.append(e_over_l) strain.append(eps) eps += deps energy = np.array(energy) eps_of_e = interp1d(energy, strain, kind='linear') eps_G = eps_of_e(E_G) print('Griffith strain', eps_G) c = crystal.copy() c.info['E_G'] = E_G c.info['eps_G'] = eps_G # open up the cell along x and y by introducing some vaccum orig_cell_width = c.cell[0, 0] orig_cell_height = c.cell[1, 1] c.center(params.vacuum, axis=0) c.center(params.vacuum, axis=1) # centre the slab on the origin c.positions[:, 0] -= c.positions[:, 0].mean() c.positions[:, 1] -= c.positions[:, 1].mean() c.info['cell_origin'] = [-c.cell[0, 0] / 2, -c.cell[1, 1] / 2, 0.0] ase.io.write('crack_1.xyz', c, format='extxyz') width = (c.positions[:, 0].max() - c.positions[:, 0].min()) height = (c.positions[:, 1].max() - c.positions[:, 1].min()) c.info['OrigHeight'] = height print(( 'Made slab with %d atoms, original width and height: %.1f x %.1f A^2' % (len(c), width, height))) top = c.positions[:, 1].max() bottom = c.positions[:, 1].min() left = c.positions[:, 0].min() right = c.positions[:, 0].max() crack_seed_length = 0.2 * width strain_ramp_length = 8.0 * params.a # make this bigger until crack looks nicer delta_strain = params.strain_rate * params.dt # fix top and bottom rows, and setup Stokes damping mask # initial use constant strain set_constraints(c, params.a) # apply initial displacment field c.positions[:, 1] += thin_strip_displacement_y( c.positions[:, 0], c.positions[:, 1], params.delta * eps_G, left + crack_seed_length, left + crack_seed_length + strain_ramp_length) print('Applied initial load: delta=%.2f strain=%.4f' % (params.delta, params.delta * eps_G)) ase.io.write('crack_2.xyz', c, format='extxyz') c.set_calculator(calc) cl, cs, cr = calc.get_wave_speeds(c) print("rayleigh speed = %f" % cr) # relax initial structure # opt = FIRE(c) # opt.run(fmax=1e-3) ase.io.write('crack_3.xyz', c, format='extxyz') #length and height of the slab is defined here L = params.N * params.lm H = params.N * 2 #Atomic Void Simulations #😵------------------------------------------------------------------------------ #the following lines of code were written to convert 1D positions into a 2D array #so as to make manipulation of slab easier if True: #void parameters are defined here. #around a max of [0.3--1.7] recommended y_offset = 0.1 #y offset is a fraction of distance from the end of the slab x_offset = 0.4 rad = voidrad #this reference code is for 160x40 slab #in steps of 40 i.e. the height, create a list upto the length of slab #row0 = range(0,6400,40) row0 = range(0, len(c), H) #the 2D array will be held in slab slab = [] for col in range(H): row = [] for r in row0: i = col + r row.append(c.positions[i]) slab.append(row) slab = np.array(slab) #all items in the array reversed, needed because the salb is built from bottom left up #in other words, reflected in x axis slab = slab[::-1] # print(slab[0]) # slab[modifiers.mask(h=H,w=L, center=[int(L*x_offset),int((H - 1)*y_offset)], radius=rad)] = 0 #multiple voids if need be if True: for i in range(voidcount): y_offset = rand.uniform(0.1, 0.9) x_offset = rand.uniform(0.3, 0.95) slab[modifiers.mask( h=H, w=L, center=[int(L * x_offset), int((H - 1) * y_offset)], radius=rad)] = 0 #reversed the slab back again here slab = slab[::-1] # # this is a useful text-array representation of the slab, for debugging purposes # mtext = open('masktest.txt','w') # for row in slab: # mtext.write(str(row).replace("\n",",")+"\n") # mtext.close slab_1d = [] for col in range(L): for row in range(H): slab_1d.append(slab[row, col]) slab_1d = np.array(slab_1d) todel = [] for i in range(len(c)): if slab_1d[i][2] == 0: todel.append(i) print(todel) del c[todel] # return #End of Void Simulation #------------------------------------------------------------------------------- #Grain Boundary Simulations #------------------------------------------------------------------------------- if False: hi = 2 #------------------------------------------------------------------------------- #! replaced velcityVerlet with Lagevin to add temperature parameter if params.v_verlet: dyn = VelocityVerlet(c, params.dt * units.fs, logfile=None) # set_initial_velocities(dyn.atoms) else: print("Using NVT!") # mbd(c, 20 * units.kB, force_temp = True) # dyn = Langevin(c,params.dt*units.fs,params.T*units.kB, 5) dyn = NVTBerendsen(c, params.dt * units.fs, params.T, taut=0.5 * 1000 * units.fs) #dyn.atoms.rattle(1e-3) # non-deterministic simulations - adjust to suit #!simulation outputs numbered, avoids deleting exisiting results iterFile = open("simIteration.txt", 'r+') iteration = int(iterFile.readlines()[0]) + 1 if params.overwrite_output: iteration -= 1 iterFile.seek(0, 0) iterFile.write(str(iteration)) iterFile.close() dir = "./.simout/void/sim_" + str(iteration) + "_" + str( params.keep_test).lower() + "_" + params.desc + "/" cf.createFolder(dir) #!Saving parameter values for each iteration of the simulation logFile = open(dir + "params_log.txt", 'w') for p, value in params.compose_params().iteritems(): logFile.write(p + " ==> " + str(value) + "\n") logFile.close crack_pos = [] if params.keep_test: traj = NetCDFTrajectory(dir + 'traj' + str(iteration) + '.nc', 'w', c) dyn.attach(traj.write, 10, dyn.atoms, arrays=['stokes', 'momenta']) # #! isolating crack tip_x for saving # crack_tip_file2 = open(dir+'tip_x.txt','w') # crack_tip_file2.close() tip_x_file = open(dir + 'tip_x.txt', 'a') console_output = open(dir + 'console_output.txt', 'a') coord_file = open(dir + 'coordinates.csv', 'a') coordinates = [] distances = [] dyn.attach(find_crack_tip, 10, dyn.atoms, tipxfile=tip_x_file, cout=console_output, coord=coordinates, d=distances, dt=params.dt * 10, store=True, results=crack_pos) # run for 2000 time steps to reach steady state at initial load # for i in range(10): # dyn.run(250) # if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): # set_constraints(dyn.atoms, params.a) # start decreasing strain #set_constraints(dyn.atoms, params.a, delta_strain=delta_strain) # strain_atoms = ConstantStrainRate(dyn.atoms.info['OrigHeight'], # delta_strain) # dyn.attach(strain_atoms.apply_strain, 1, dyn. atoms ) # for i in range(50): # dyn.run(100) # if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): # set_constraints(dyn.atoms, params.a) # #cleardel dyn.observers[-1] # stop increasing the strain # for i in range(1000): # dyn.run(100) # if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): # set_constraints(dyn.atoms, params.a) dyn.run(int(1 * frame_count) * 10 + 10) # print("\n\n\n\n\n -----Adding Temperature------\n\n\n\n\n") # # mbd(c, 2*params.T * units.kB, force_temp = True) # dyn.set_temperature(params.T*units.kB) # dyn.run(int(0.5*frame_count)*10+10) for c in coordinates: coord_file.write(str(c[0]) + ',' + str(c[1]) + '\n') coord_file.close() if params.keep_test: traj.close() tip_x_file.close() console_output.close()
from ase.md import VelocityVerlet from ase.build import bulk from ase.units import kB from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.calculators.idealgas import IdealGas import numpy as np atoms = bulk('Kr').repeat((10, 10, 10)) assert len(atoms) == 1000 atoms.center(vacuum=100) atoms.set_calculator(IdealGas()) T = 1000 MaxwellBoltzmannDistribution(atoms, T * kB) print("Temperature: {} K".format(atoms.get_temperature())) md = VelocityVerlet(atoms, timestep=0.1) for i in range(5): md.run(5) s = atoms.get_stress(include_ideal_gas=True) p = -s[:3].sum() / 3 v = atoms.get_volume() N = len(atoms) T = atoms.get_temperature() print("pV = {} NkT = {}".format(p * v, N * kB * T)) assert np.fabs(p * v - N * kB * T) < 1e-6
from ase import Atoms from ase.calculators.emt import EMT from ase.md import VelocityVerlet from ase.io import Trajectory a = 3.6 b = a / 2 fcc = Atoms('Cu', positions=[(0, 0, 0)], cell=[(0, b, b), (b, 0, b), (b, b, 0)], pbc=1) fcc *= (2, 1, 1) fcc.set_calculator(EMT()) fcc.set_momenta([(0.9, 0.0, 0.0), (-0.9, 0, 0)]) md = VelocityVerlet(fcc, dt=0.1) def f(): print(fcc.get_potential_energy(), fcc.get_total_energy()) md.attach(f) md.attach(Trajectory('Cu2.traj', 'w', fcc).write, interval=3) md.run(steps=20) fcc2 = Trajectory('Cu2.traj', 'r')[-1]