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
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
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)
if ismaster:
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()
p = -(s[0] + s[1] + s[2])/3.0 / units.GPa
T = atoms.get_kinetic_energy() / (1.5 * atoms.get_number_of_atoms() * units.kB)
print "Pressure is %f GPa, desired pressure is %f GPa (T = %.2f K)" % (p, p_goal, T)
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)
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.
# 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
df = max(fabs(f.flat[:] - oldf.flat[:]))
print "Maximal deviation: Energy", de, " Force", df
ReportTest("Max force error", df, 0.0, 1e-11)
ReportTest("Max energy error", de, 0.0, 1e-11)
del olde, oldf
else:
print "WARNING: No self-check database found, creating it."
cPickle.dump((e, f), open(selfcheckfilename, "w"))
del e, f, atoms
ReportTest.Summary(exit=1)
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."
print "Temperature:", atoms.get_temperature()
#del dynamics, atoms
print ""
print ""
print "TIMING RESULTS:"
(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)
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
# 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
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()
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:
# Associate the EMT potential with the atoms
atoms.set_calculator(EMT())
# Temperature profile
temperatures = (250, 500, 750, 1000, 1250, 1500, 1750)
# How many steps at each temperature
nsteps = 5000
# Interval between plots
plotinterval = 500
# Make the Langevin dynamics module
dyn = Langevin(atoms, 5*units.fs, units.kB*temperatures[0], 0.002)
# The plotter
plotter = PrimiPlotter(atoms)
plotter.set_output(X11Window())
plotter.set_rotation((10.0, 5.0, 0))
dyn.attach(plotter.plot, interval=plotinterval)
# Some functions for calculating the actual temperature, energy, ...
def temperature(a):
return 2.0/3.0 * a.get_kinetic_energy() / (len(a) * units.kB)
def etotal(a):
return (a.get_kinetic_energy() + a.get_potential_energy()) / len(a)
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)
from asap3 import *
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=[0,]):
n = len(a)
ekin = a.get_kinetic_energy() / n
epot = a.get_potential_energy() / n
# 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
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()
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.
#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
