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 MakeCu3Ni(T=300): print "Preparing", T, "K NiCu3 system." atoms = L1_2(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], symbol=('Ni', 'Cu'), latticeconstant=3.61, size=(29, 29, 30)) 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
import sys 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.
# Open info file with line buffering. Only the master core writes to it. info = paropen(infofile, "w", 1) info.write("Simulation started: {0}\n".format(time.ctime())) # Read the last frame of the input file. The atoms are distributed among # processors. atoms = Trajectory(infile).get_atoms(-1, cpulayout) nAtoms = atoms.get_number_of_atoms() info.write("Distribution on CPU cores: {0}\n".format(str(atoms.nCells))) atoms.set_calculator(EMT()) # Rapidly move the temperature to the desired range by running a # langevin simulation with increased friction at twice the temperature # until the desired temperature is crossed. dyn = Langevin(atoms, timestep * units.fs, temperature * 2 * units.kB, 20 * lgvfrict) i = 0 while atoms.get_temperature() < temperature: i = i + 1 dyn.run(10) info.write("Energy per atom (step %d): Epot = %.3f eV Ekin = %.3f eV\n" % (i, atoms.get_potential_energy() / nAtoms, atoms.get_kinetic_energy() / nAtoms)) info.write("Temperature has reached %d K: %s\n" % (atoms.get_temperature(), time.ctime())) # Run the real dynamics dyn = Langevin(atoms, timestep * units.fs, temperature * units.kB, lgvfrict) # PTM analysis
# Temperature profile - brief run at 1750, then lower temperature gradually t = linspace(1500, 250, 81) temperatures = 1500 * ones(100) temperatures[-len(t):] = t print temperatures # How many steps at each temperature nsteps_total = 100000 nsteps = nsteps_total // len(temperatures) # Interval between plots plotinterval = 2000 # Make the Langevin dynamics module dyn = Langevin(atoms, 5*units.fs, units.kB*temperatures[0], 0.002) # The PTM analyser is called every plotinterval timesteps. ptm = PTMobserver(atoms, rmsd_max=0.16) dyn.attach(ptm.analyze, interval=plotinterval) # The plotter def invisible_atoms(a): """Return True for atoms that should be invisible.""" r = atoms.get_positions() centerofmass = r.sum(axis=0) / len(atoms) return (r[:,2] < centerofmass[2]) plotter = PrimiPlotter(atoms) plotter.set_invisibility_function(invisible_atoms) plotter.set_colors(mycolors) # Map tags to colors
epot = atoms.get_potential_energy() / len(atoms) ekin = atoms.get_kinetic_energy() / len(atoms) r.append([epot, ekin, epot+ekin]) r = array(r) diff = r - ref maxdiff = diff.max() print "Maximal difference is", maxdiff ReportTest(name, maxdiff, 0.0, 1e-6) print_version(1) print "Making initial system" iniatoms = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], size=(10,5,5), symbol="Cu", pbc=(1,1,0)) iniatoms.set_calculator(EMT()) inidyn = Langevin(iniatoms, 5*units.fs, 450*units.kB, 0.05) inidyn.run(100) print "Temperature is now", iniatoms.get_kinetic_energy() / (1.5*units.kB*len(iniatoms)), "K" print "Making reference simulation" refatoms = Atoms(iniatoms) refatoms.set_calculator(EMT()) dyn = VelocityVerlet(refatoms, 5*units.fs) ref = [] for i in range(50): dyn.run(5) epot = refatoms.get_potential_energy() / len(refatoms) ekin = refatoms.get_kinetic_energy() / len(refatoms) ref.append([epot, ekin, epot+ekin]) ref = array(ref)
print atoms.get_masses() print atoms.get_masses().shape raise initr = atoms.get_positions() initp = atoms.get_momenta() def targetfunc(params, x): return params[0] * exp(-params[1] * x) + params[2] output = file("Langevin.dat", "w") for temp, frict in ((0.01, 0.001),): dyn = Langevin(atoms, timestep, temp, frict) print "" print "Testing Langevin dynamics with T = %f eV and lambda = %f" % (temp, frict) ekin = atoms.get_kinetic_energy()/natoms print ekin output.write("%.8f\n" % ekin) temperatures = [(0, 2.0 / 3.0 * ekin)] a = 0.1 b = frict c = temp print "Equilibrating ..." tstart = time.time() for i in xrange(1,nequil+1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / natoms if i % nequilprint == 0:
initr = atoms.get_positions() initp = atoms.get_momenta() def targetfunc(params, x): return params[0] * exp(-params[1] * x) + params[2] output = file("Langevin.dat", "w") for temp, frict, fixcm in ( (0.01, 0.001, True), (0.0025, 0.001, False), ): dyn = Langevin(atoms, timestep, temp, frict, fixcm=fixcm) print "" print "Testing Langevin dynamics with T = %f eV and lambda = %f" % (temp, frict) ekin = atoms.get_kinetic_energy() / len(atoms) print ekin output.write("%.8f\n" % ekin) temperatures = [(0, 2.0 / 3.0 * ekin)] a = 0.1 b = frict c = temp print "Equilibrating ..." tstart = time.time() for i in xrange(1, nequil + 1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / len(atoms)
from asap3.md.langevin import Langevin from ase.lattice.cubic import FaceCenteredCubic from asap3.md.velocitydistribution import * # Import other essential modules from numpy import * # Set up an fcc crystal of copper, 1372 atoms. atoms = FaceCenteredCubic(size=(7, 7, 7), symbol="Cu", pbc=False) # Now the standard EMT Calculator is attached atoms.set_calculator(EMT()) # Make an object doing Langevin dynamics at a temperature of 800 K dyn = Langevin(atoms, timestep=5 * units.fs, temperature=800 * units.kB, friction=0.005) # Set the momenta corresponding to T=1600K. The temperature will # quickly drop to half of that as the energy is distributed evenly # among the kinetic and potential energy. MaxwellBoltzmannDistribution(atoms, 1600 * units.kB) # Make a trajectory traj = PickleTrajectory('MD_Cluster.traj', "w", atoms) dyn.attach(traj, interval=500) # Automatically writes the initial configuration # Print the energies def printenergy(a, step=[
dynamics = VelocityVerlet(atoms, 5*units.fs) print "Running Verlet dynamics." startcpu, startwall = time.clock(), time.time() dynamics.run(timesteps) vcpu, vwall = time.clock() - startcpu, time.time() - startwall vfraction = vcpu/vwall sys.stderr.write("\n") print "Verlet dynamics done." del dynamics, atoms print "Preparing to run Langevin dynamics." atoms = Atoms(initial) atoms.set_calculator(EMT()) dynamics = Langevin(atoms, 5*units.fs, 400*units.kB, 0.001) print "Running Langevin dynamics." startcpu, startwall = time.clock(), time.time() dynamics.run(timesteps) lcpu, lwall = time.clock() - startcpu, time.time() - startwall lfraction = lcpu/lwall sys.stderr.write("\n") print "Langevin dynamics done." del dynamics, atoms print "" print "" print "TIMING RESULTS:" print "Verlet: CPU time %.2fs Wall clock time %.2fs (%.0f%%)" % (vcpu, vwall, vfraction * 100)
print_version(1) if not hasattr(NPT, '_npt_version'): print "Skipping test: NP dynamics does not work in parallel with this old version of ASE." else: if ismaster: atoms = FaceCenteredCubic(size=(30, 15, 15), symbol="Cu", pbc=True) else: atoms = None atoms = MakeParallelAtoms(atoms, cpulayout) atoms.set_calculator(EMT()) print "Number of atoms:", atoms.get_number_of_atoms() print "Heating to %d K using Langevin" % T_goal lgv = Langevin(atoms, 5 * units.fs, temperature=2 * T_goal * units.kB, friction=0.05) while atoms.get_kinetic_energy( ) < 1.5 * atoms.get_number_of_atoms() * T_goal * units.kB: lgv.run(5) T = atoms.get_kinetic_energy() / (1.5 * atoms.get_number_of_atoms() * units.kB) print "Temperature is now %.2f K" % (T, ) print "Desired temperature reached!" lgv.set_temperature(T_goal * units.kB) for i in range(2): lgv.run(20) s = atoms.get_stress()
(a, b, c) = leastSquaresFit(targetfunc, (0.1, 2*frict, temp), temperatures)[0] except OverflowError: print "leastSquaresFit failed (this is OK)." a = b = c = 0.0 print "%.6f T_inf = %.6f (goal: %f) k = %.6f" % \ (ekin, c, temp, b) tequil = time.time() - tstart print "This took %.1f minutes." % (tequil / 60) print "Taking data - this takes", repeats*nsteps/nequil, "times longer!" monitor = TemperatureMonitor(nprint) atoms = Atoms(initial) atoms.set_calculator(EMT()) dyn = Langevin(atoms, timestep*femtosecond, temp*kB, 0.001) equilibrate(atoms, dyn, kB*temp) dyn.attach(monitor.Update, 5) for i in range(repeats): monitor.New("Free boundaries, fixcm=True", atoms, temp, i) dyn.run(nsteps) monitor.Check() atoms = Atoms(initial) atoms.set_calculator(EMT()) dyn = Langevin(atoms, timestep*femtosecond, temp*kB, 0.001, fixcm=False) equilibrate(atoms, dyn, kB*temp) dyn.attach(monitor.Update, 5) for i in range(repeats): monitor.New("Free boundaries, fixcm=False", atoms, temp, i) dyn.run(nsteps)
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()
#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 # Make sure that CPU speed is revved up. dummy = L1_2(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], symbol=('Au', 'Cu'), latticeconstant=4.08, size=(10, 10, 10), debug=0) dummy.set_calculator(EMT()) dyn = Langevin(dummy, 5 * units.fs, 300 * units.kB, 0.05) dyn.run(10) del dummy logger.write("\n\nRunning on %s %s\n" % (host, when)) modelname = "Unknown CPU model name" cpumhz = "Unknown CPU speed" try: lines = open("/proc/cpuinfo").readlines() for line in lines: if line[:10] == "model name": modelname = line break for line in lines: if line[:7] == "cpu MHz": cpumhz = line