def run(self):
if self.model is None:
self.model = KMC_Model(self.queue,
self.parameter_queue,
self.signal_queue,
steps_per_frame=self.steps_per_frame)
self.model.run()
class KMC_ModelProxy(multiprocessing.Process):
"""This is a proxy class handling the communication
with the Model process.
This proxy was necessary because Windows does not
support fork() and thus the model process cannot be split-off
directly. As a workaround multiprocessing tries to pickle the
memory of the current process, however it does not know how
to pickle the fortran objects.
"""
def __init__(self, *args, **kwargs):
super(KMC_ModelProxy, self).__init__()
self.model = kwargs.get('model', None)
self.kwargs = kwargs
self.signal_queue = self.kwargs.get('signal_queue')
self.parameter_queue = self.kwargs.get('parameter_queue')
self.queue = self.kwargs.get('queue')
def run(self):
if self.model is None:
self.model = KMC_Model(self.queue,
self.parameter_queue,
self.signal_queue)
self.model.run()
def join(self):
self.signal_queue.put('JOIN')
super(KMC_ModelProxy, self).join()
def terminate(self):
self.signal_queue.put('STOP')
super(KMC_ModelProxy, self).terminate()
def run(i=0, edir=''):
from sys import path
path.append(edir)
from kmos.run import KMC_Model
model = KMC_Model(banner=False, print_rates=False)
model.settings.random_seed = i
assert not model.do_steps(1000)
assert not model.deallocate()
def run(i=0, edir=''):
from sys import path
path.append(edir)
from kmos.run import KMC_Model
model = KMC_Model(banner=False, print_rates=False)
model.settings.random_seed = i
assert not model.do_steps(1000)
assert not model.deallocate()
class KMC_Viewer():
"""A graphical front-end to run, manipulate
and view a kMC model.
"""
def __init__(self, model=None):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.connect('delete-event', self.exit)
self.vbox = gtk.VBox()
self.window.add(self.vbox)
queue = multiprocessing.Queue(maxsize=3)
self.parameter_queue = multiprocessing.Queue(maxsize=50)
self.signal_queue = multiprocessing.Queue(maxsize=10)
if model is None:
self.model = KMC_Model(queue, self.parameter_queue, self.signal_queue)
else:
self.model = model
self.model.image_queue = queue
self.model.parameter_queue = self.parameter_queue
self.model.signal_queue = self.signal_queue
self.viewbox = KMC_ViewBox(queue, self.signal_queue,
self.vbox, self.window)
for param_name in filter(lambda p: \
settings.parameters[p]['adjustable'], settings.parameters):
param = settings.parameters[param_name]
slider = ParamSlider(param_name, param['value'],
param['min'], param['max'],
param['scale'], self.parameter_callback)
self.vbox.add(slider)
self.vbox.set_child_packing(slider, expand=False,
fill=False, padding=0,
pack_type=gtk.PACK_START)
#print('initialized kmc_viewer')
#print(self.window.get_title())
self.window.set_title('kmos GUI')
#print(self.window.get_title())
self.window.show_all()
def parameter_callback(self, name, value):
settings.parameters[name]['value'] = value
self.parameter_queue.put(settings.parameters)
def exit(self, widget, event):
#print('Starting shutdown procedure')
self.viewbox.kill()
#print(' ... sent kill to viewbox')
self.viewbox.join()
#print(' ... viewbox thread joined')
self.signal_queue.put('STOP')
#print(' ... sent stop to model')
self.model.terminate()
self.model.join()
#print(' ... model thread joined')
base.deallocate_system()
gtk.main_quit()
return True
def __init__(self, model=None):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.connect('delete-event', self.exit)
self.vbox = gtk.VBox()
self.window.add(self.vbox)
queue = multiprocessing.Queue(maxsize=3)
self.parameter_queue = multiprocessing.Queue(maxsize=50)
self.signal_queue = multiprocessing.Queue(maxsize=10)
if model is None:
self.model = KMC_Model(queue, self.parameter_queue, self.signal_queue)
else:
self.model = model
self.model.image_queue = queue
self.model.parameter_queue = self.parameter_queue
self.model.signal_queue = self.signal_queue
self.viewbox = KMC_ViewBox(queue, self.signal_queue,
self.vbox, self.window)
for param_name in filter(lambda p: \
settings.parameters[p]['adjustable'], settings.parameters):
param = settings.parameters[param_name]
slider = ParamSlider(param_name, param['value'],
param['min'], param['max'],
param['scale'], self.parameter_callback)
self.vbox.add(slider)
self.vbox.set_child_packing(slider, expand=False,
fill=False, padding=0,
pack_type=gtk.PACK_START)
#print('initialized kmc_viewer')
#print(self.window.get_title())
self.window.set_title('kmos GUI')
#print(self.window.get_title())
self.window.show_all()
def run(self):
if self.model is None:
self.model = KMC_Model(self.queue,
self.parameter_queue,
self.signal_queue,
steps_per_frame=self.steps_per_frame)
self.model.run()
def __init__(self, model=None):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.connect('delete-event', self.exit)
self.vbox = gtk.VBox()
self.window.add(self.vbox)
queue = multiprocessing.Queue(maxsize=3)
self.parameter_queue = multiprocessing.Queue(maxsize=50)
self.signal_queue = multiprocessing.Queue(maxsize=10)
if model is None:
self.model = KMC_Model(queue, self.parameter_queue,
self.signal_queue)
else:
self.model = model
self.model.image_queue = queue
self.model.parameter_queue = self.parameter_queue
self.model.signal_queue = self.signal_queue
self.viewbox = KMC_ViewBox(queue, self.signal_queue, self.vbox,
self.window)
for param_name in filter(lambda p: \
settings.parameters[p]['adjustable'], settings.parameters):
param = settings.parameters[param_name]
slider = ParamSlider(param_name, param['value'], param['min'],
param['max'], param['scale'],
self.parameter_callback)
self.vbox.add(slider)
self.vbox.set_child_packing(slider,
expand=False,
fill=False,
padding=0,
pack_type=gtk.PACK_START)
#print('initialized kmc_viewer')
#print(self.window.get_title())
self.window.set_title('kmos GUI')
#print(self.window.get_title())
self.window.show_all()
def run(point):
"""Run function"""
T, p_COgas, p_O2gas = point
kmc_settings.simulation_size = 1
with KMC_Model(print_rates=False, banner=False) as model:
# Write header to data file
if not os.path.isfile(DATA_FILENAME):
with file(DATA_FILENAME, 'w') as datafile:
datafile.write(
"#T p_CO p_O2 kmc_time %s %s\n" %
(model.get_tof_header(), model.get_occupation_header()))
datafile.write(str(model))
# Set experimental parameters
model.parameters.p_COgas = p_COgas
model.parameters.p_O2gas = p_O2gas
model.parameters.T = T
# Run simulation
last_time = 0.
for double_step in xrange(3):
last_time = model.base.get_kmc_time()
model.double()
model.base.set_kmc_time(last_time)
print(model.size)
while not model.base.get_kmc_time() > INITIAL_TIME + last_time:
model.do_steps(INITIAL_STEPS)
atoms = model.get_atoms(geometry=False)
occupation = []
tof = []
delta_ts = []
for i in xrange(SAMPLES):
model.do_steps()
atoms = model.get_atoms(geometry=False)
occupation.append(atoms.occupation.flatten())
tof.append(atoms.tof_data)
delta_ts.append(atoms.delta_t)
occupation = np.average(occupation, axis=0, weights=delta_ts)
tof = np.average(tof, axis=0, weights=delta_ts)
kmc_time = sum(delta_ts)
with file(DATA_FILENAME, 'a') as datafile:
outdata = tuple([T, p_COgas, p_O2gas, kmc_time] + list(tof) +
list(occupation))
datafile.write(
(' '.join(['%.3e'] * len(outdata)) + '\n') % outdata)
import numpy as np
import matplotlib.pyplot as plt
# Parameters
L = 50
H = 20
NREL = 1e7
NSAMPLE = 5e7
# current vs field
theta = 0.5
currents = []
fields = np.linspace(0.005, 0.04, 10)
for eps_f in fields:
model = KMC_Model(banner = False, size = [L, H])
model.parameters.thetaS = theta
model.parameters.thetaD = theta
model.parameters.eps_f = eps_f
model.do_steps(NREL)
exit0 = (model.base.get_procstat(model.proclist.drain_exit)
- model.base.get_procstat(model.proclist.drain_entry))
t0 = model.base.get_kmc_time()
model.do_steps(NSAMPLE)
currents.append( ( model.base.get_procstat(model.proclist.drain_exit)
- model.base.get_procstat(model.proclist.drain_entry)
- exit0) / (model.base.get_kmc_time() - t0) / float(L))
model.deallocate()
"""
Generate and Arrhenius plot
using kmos
Juan M. Lorenzi
TU Munich
June 2016
"""
import math
from kmos.run import KMC_Model
model = KMC_Model(banner = False)
model.parameters.p_COgas = 2.e-1
model.parameters.p_O2gas = 1.e-1
nrel = 1e7; nsample = 1e7 # numerical parameters
Ts = range(450,650,20) # 20 values between 450 and 650 K
fout = open('arrhenius.dat', 'w') # open an output file
fout.write(model.get_std_header()) # print the header
# Loop over the temperature
for T in Ts:
model.parameters.T = T # Set the desired temperature
model.do_steps(nrel) # Relax the system
# Sample the reactivity and print data to file
output = model.get_std_sampled_data(1, nsample)
fout.write(output)
fout.close() # Close output file
# We can read the file with numpy...
import numpy as np
class KMC_Viewer():
"""A graphical front-end to run, manipulate
and view a kMC model.
"""
def __init__(self, model=None):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.connect('delete-event', self.exit)
self.vbox = gtk.VBox()
self.window.add(self.vbox)
queue = multiprocessing.Queue(maxsize=3)
self.parameter_queue = multiprocessing.Queue(maxsize=50)
self.signal_queue = multiprocessing.Queue(maxsize=10)
if model is None:
self.model = KMC_Model(queue, self.parameter_queue,
self.signal_queue)
else:
self.model = model
self.model.image_queue = queue
self.model.parameter_queue = self.parameter_queue
self.model.signal_queue = self.signal_queue
self.viewbox = KMC_ViewBox(queue, self.signal_queue, self.vbox,
self.window)
for param_name in filter(lambda p: \
settings.parameters[p]['adjustable'], settings.parameters):
param = settings.parameters[param_name]
slider = ParamSlider(param_name, param['value'], param['min'],
param['max'], param['scale'],
self.parameter_callback)
self.vbox.add(slider)
self.vbox.set_child_packing(slider,
expand=False,
fill=False,
padding=0,
pack_type=gtk.PACK_START)
#print('initialized kmc_viewer')
#print(self.window.get_title())
self.window.set_title('kmos GUI')
#print(self.window.get_title())
self.window.show_all()
def parameter_callback(self, name, value):
settings.parameters[name]['value'] = value
self.parameter_queue.put(settings.parameters)
def exit(self, widget, event):
#print('Starting shutdown procedure')
self.viewbox.kill()
#print(' ... sent kill to viewbox')
self.viewbox.join()
#print(' ... viewbox thread joined')
self.signal_queue.put('STOP')
#print(' ... sent stop to model')
self.model.terminate()
self.model.join()
#print(' ... model thread joined')
base.deallocate_system()
gtk.main_quit()
return True
#!/usr/bin/env python
from kmos.run import KMC_Model
import pylab
import numpy as np
import random
from ase.all import view
#load model
model = KMC_Model(print_rates=False, banner=False)
#set pressures and temperature
model.parameters.T = 450
model.parameters.p_COgas = 1
model.parameters.p_O2gas = 1
#prepare random initial state of system based on initial guess of species coverages.
#the initial guess could be the coverages obtained in a mean-field (rate equations) model.
#get coverage labels, disregarding the empty species
Nsite_types = model.lattice.spuck
cov_labels = model.get_occupation_header().split(' ')[:-Nsite_types]
#define guess coverages
guess_coverages = [0.25, 0.15, 0.35, 0.55] #CO_br, CO_cus, O_br, O_cus
#dictionaries for converting to kmos variables
kmos_species = {'CO': model.proclist.co, 'O': model.proclist.o}
kmos_sites = {
'bridge': model.lattice.ruo2_bridge,
'cus': model.lattice.ruo2_cus
from kmos.run import KMC_Model
import random
Ts = [350, 450]
kads = 3e-3
size = (30, 30, 30)
targetML = 4.
nsteps = 100
for i, T in enumerate(Ts):
random_seed = random.random() * 1e12
model = KMC_Model(banner=False, size=size, random_seed=random_seed)
model.parameters.T = T
model.parameters.kads = kads
tsim = 0.0
ML = 0.0
while ML < targetML:
model.do_steps(nsteps)
at = model.get_atoms(geometry=False)
# Convert TOF into ML growth
ML += at.tof_data[model.tofs.index('Growth')] * at.delta_t * size[2]
outname = '_'.join(['config', 'T{}'.format(T)] +
['{}'.format(d) for d in model.size])
model.dump_config(outname)
print('Finished with T={}K'.format(T))
print('Deposited {}ML in {} s'.format(ML, model.base.get_kmc_time()))
model.deallocate()
#!/usr/bin/env python
from kmos.run import KMC_Model
import pylab
import numpy as np
import random
from ase.all import view
#load model
model = KMC_Model(print_rates=False, banner=False)
#set pressures and temperature
model.parameters.T = 600
model.parameters.p_COgas = 1
model.parameters.p_O2gas = 1
#prepare random initial state of O-poisoned lattice (known steady-state solution)
#this ensures faster relaxation.
#get coverage labels, disregarding the empty species
Nsite_types = model.lattice.spuck
cov_labels = model.get_occupation_header().split(' ')[:-Nsite_types]
#define guess coverages
guess_coverages = [0.05, 0.05, 0.95, 0.95] #CO_br, CO_cus, O_br, O_cus
#dictionaries for converting to kmos variables
kmos_species = {'CO':model.proclist.co, 'O':model.proclist.o}
kmos_sites = {'bridge':model.lattice.ruo2_bridge, 'cus':model.lattice.ruo2_cus}
#available sites
"""
Generate and Arrhenius plot
using kmos
Juan M. Lorenzi
TU Munich
June 2016
"""
import math
from kmos.run import KMC_Model
model = KMC_Model(banner=False)
model.parameters.p_COgas = 2.e-1
model.parameters.p_O2gas = 1.e-1
nrel = 1e7
nsample = 1e7 # numerical parameters
Ts = range(450, 650, 20) # 20 values between 450 and 650 K
TOFs = [] # empty list for output
# Loop over the temperature
for T in Ts:
model.parameters.T = T # Set the temperature
model.do_steps(nrel) # Relax the system
# Sample the reactivity
output = model.get_std_sampled_data(1, nsample, output='dict')
# Collect output
TOFs.append(output['CO_oxidation'])
# Transform the variables
invTs = [1 / float(T) for T in Ts]
#!/usr/bin/env python
from kmos.run import KMC_Model
import pylab
import numpy as np
#load model
model = KMC_Model(print_rates=False, banner=False)
#set pressures and temperature
model.parameters.T = 450
model.parameters.p_COgas = 1
model.parameters.p_O2gas = 1
#prepare initial state of system with all bridge sites covered by O
#for i in range(model.size[0]):
# for j in range(model.size[1]):
# model._put([i,j,0,model.lattice.ruo2_bridge], model.proclist.o)
#model._adjust_database()
#get TOF labels
tof_labels = model.get_tof_header().split(' ')
#get coverage labels
cov_labels = model.get_occupation_header().split(' ')
#Number of kmc steps taken in each sample
sample_step = 1e5
#Number of samples
N = 100
from kmos.run import KMC_Model
import numpy as np
import matplotlib.pyplot as plt
n_relax = 1e7
n_sample = 1e7
eps_f = 0.02
e_int = 0.002
thetas = np.linspace(0.1, 0.9, 9)
# current vs. concentration
currents = []
for theta in thetas:
model = KMC_Model(banner=False)
model.parameters.thetaS = theta
model.parameters.thetaD = theta
model.parameters.eps_f = eps_f
model.parameters.e_int = e_int
model.do_steps(n_relax)
exit0 = (model.base.get_procstat(model.proclist.drain_exit) -
model.base.get_procstat(model.proclist.drain_entry))
t0 = model.base.get_kmc_time()
model.do_steps(n_sample)
currents.append(
(model.base.get_procstat(model.proclist.drain_exit) -
model.base.get_procstat(model.proclist.drain_entry) - exit0) /
(model.base.get_kmc_time() - t0) / float(model.size[1]))
model.deallocate()
def main(args=None):
"""The CLI main entry point function.
The optional arguemnts args, can be used to
directly supply command line argument like
$ kmos <args>
otherwise args will be taken from STDIN.
"""
import optparse
import os
from glob import glob
import kmos
parser = optparse.OptionParser('Usage: %prog [help] (' +
'|'.join(sorted(usage.keys())) +
') [options]',
version=kmos.__version__)
parser.add_option('-s',
'--source-only',
dest='source_only',
action='store_true',
default=False)
parser.add_option('-p',
'--path-to-f2py',
dest='path_to_f2py',
default='f2py')
try:
from numpy.distutils.fcompiler import get_default_fcompiler
from numpy.distutils import log
log.set_verbosity(-1, True)
fcompiler = get_default_fcompiler()
except:
fcompiler = 'gfortran'
parser.add_option('-f',
'--fcompiler',
dest='fcompiler',
default=os.environ.get('F2PY_FCOMPILER', fcompiler))
if args is not None:
options, args = parser.parse_args(args.split())
else:
options, args = parser.parse_args()
if len(args) < 1:
parser.error('Command expected')
if args[0] == 'benchmark':
from sys import path
path.append(os.path.abspath(os.curdir))
nsteps = 1000000
from time import time
from kmos.run import KMC_Model
with KMC_Model(print_rates=False, banner=False) as model:
time0 = time()
model.do_steps(nsteps)
needed_time = time() - time0
print('%s steps took %.2f seconds' % (nsteps, needed_time))
print('Or %.2e steps/s' % (1e6 / needed_time))
elif args[0] == 'build':
from kmos.utils import build
build(options)
elif args[0] == 'edit':
from kmos import gui
gui.main()
elif args[0] == 'export-settings':
import kmos.types
import kmos.io
from kmos.utils import build
import shutil
from kmos.io import ProcListWriter
if len(args) < 2:
parser.error('XML file and export path expected.')
if len(args) < 3:
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
xml_file = args[1]
export_dir = args[2]
project = kmos.types.Project()
project.import_xml_file(xml_file)
writer = ProcListWriter(project, export_dir)
writer.write_settings()
elif args[0] == 'export':
import kmos.types
import kmos.io
from kmos.utils import build
import shutil
if len(args) < 2:
parser.error('XML file and export path expected.')
if len(args) < 3:
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
xml_file = args[1]
export_dir = os.path.join(args[2], 'src')
project = kmos.types.Project()
project.import_xml_file(xml_file)
kmos.io.export_source(project, export_dir)
if ((os.name == 'posix'
and os.uname()[0] == 'Linux')
or os.name == 'nt') \
and not options.source_only:
os.chdir(export_dir)
build(options)
for out in glob('kmc_*'):
if os.path.exists('../%s' % out):
overwrite = raw_input(('Should I overwrite existing %s ?'
'[y/N] ') % out).lower()
if overwrite.startswith('y'):
os.remove('../%s' % out)
shutil.move(out, '..')
else:
shutil.move(out, '..')
elif args[0] == 'export-settings':
import kmos.io
pt = kmos.io.import_xml_file(args[1])
if len(args) < 3:
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting kmc_settings.py to %s' %
out_dir)
args.append(out_dir)
if not os.path.exists(args[2]):
os.mkdir(args[2])
elif not os.path.isdir(args[2]):
raise UserWarning("Cannot overwrite %s; Exiting;" % args[2])
writer = kmos.io.ProcListWriter(pt, args[2])
writer.write_settings()
elif args[0] == 'export-view':
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
os.system('kmos-export-program %s %s' % (args[1], args[2]))
os.chdir(out_dir)
main('view')
elif args[0] == 'all':
print('Interpreting: all -> help all\n\n')
main('help all')
elif args[0] == 'help':
if len(args) < 2:
parser.error('Which help do you want?')
if args[1] == 'all':
for command in sorted(usage):
print(usage[command])
elif args[1] in usage:
print('Usage: %s\n' % usage[args[1]])
else:
raise Exception('Command "%s" not known or not documented.' %
args[1])
elif args[0] == 'import':
import kmos.io
if not len(args) >= 2:
raise UserWarning('XML file name expected.')
global pt
pt = kmos.io.import_xml_file(args[1])
sh(banner='Note: pt = kmos.io.import_xml(\'%s\')' % args[1])
elif args[0] == 'rebuild':
from sys import path
path.append(os.path.abspath(os.curdir))
from tempfile import mktemp
if not os.path.exists('kmc_model.so') \
and not os.path.exists('kmc_model.pyd'):
raise Exception('No kmc_model.so found.')
if not os.path.exists('kmc_settings.py'):
raise Exception('No kmc_settings.py found.')
from kmos.run import KMC_Model
with KMC_Model(print_rates=False, banner=False) as model:
tempfile = mktemp()
f = file(tempfile, 'w')
f.write(model.xml())
f.close()
for kmc_model in glob('kmc_model.*'):
os.remove(kmc_model)
os.remove('kmc_settings.py')
main('export %s .' % tempfile)
os.remove(tempfile)
elif args[0] == 'run':
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos.run import KMC_Model
with KMC_Model(print_rates=False) as model:
global model
sh(banner='Note: model = KMC_Model(print_rates=False)')
elif args[0] == 'view':
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos import view
view.main()
else:
parser.error('Command "%s" not understood.' % args[0])
from kmos.run import KMC_Model
import numpy as np
import matplotlib.pyplot as plt
n_relax = 1e7
n_sample = 1e7
eps_f = 0.02
e_int = 0.002
thetas = np.linspace(0.1, 0.9, 9)
# current vs. concentration
currents = []
for theta in thetas:
model = KMC_Model(banner=False)
model.parameters.thetaS = theta
model.parameters.thetaD = theta
model.parameters.eps_f = eps_f
model.parameters.e_int = e_int
model.do_steps(n_relax)
exit0 = (model.base.get_procstat(model.proclist.drain_exit)
- model.base.get_procstat(model.proclist.drain_entry))
t0 = model.base.get_kmc_time()
model.do_steps(n_sample)
currents.append((model.base.get_procstat(model.proclist.drain_exit)
- model.base.get_procstat(model.proclist.drain_entry)
- exit0) / (model.base.get_kmc_time() - t0) / float(model.size[1]))
model.deallocate()
from kmos.run import KMC_Model
import random
Ts = [350, 450]
kads = 3e-3
size = (30, 30, 30)
targetML = 4.
nsteps = 100
for i,T in enumerate(Ts):
random_seed = random.random()*1e12
model = KMC_Model(banner=False,
size = size,
random_seed = random_seed)
model.parameters.T = T
model.parameters.kads = kads
tsim = 0.0
ML = 0.0
while ML < targetML:
model.do_steps(nsteps)
at = model.get_atoms(geometry=False)
# Convert TOF into ML growth
ML += at.tof_data[model.tofs.index('Growth')]*at.delta_t*size[2]
outname = '_'.join(['config', 'T{}'.format(T)] +
['{}'.format(d) for d in model.size])
model.dump_config(outname)
print('Finished with T={}K'.format(T))
print('Deposited {}ML in {} s'.format(
ML,
model.base.get_kmc_time()))
"""
Generate and Arrhenius plot
using kmos
Juan M. Lorenzi
TU Munich
June 2016
"""
import math
from kmos.run import KMC_Model
model = KMC_Model(banner = False)
model.parameters.p_COgas = 2.e-1
model.parameters.p_O2gas = 1.e-1
nrel = 1e7; nsample = 1e7 # numerical parameters
Ts = range(450,650,20) # 20 values between 450 and 650 K
TOFs = [] # empty list for output
# Loop over the temperature
for T in Ts:
model.parameters.T = T # Set the temperature
model.do_steps(nrel) # Relax the system
# Sample the reactivity
output = model.get_std_sampled_data(1, nsample, output='dict')
# Collect output
TOFs.append(output['CO_oxidation'])
# Transform the variables
invTs = [1/float(T) for T in Ts]
logTOFs = [math.log(TOF,10.) for TOF in TOFs]
"""Visualize the growth of a run of the SOS model""" import sys, os from kmos.run import KMC_Model from ase.visualize import view config = os.path.splitext(sys.argv[1])[0] size = (30, 30, 30) model = KMC_Model(banner = False, size = size) model.load_config(config) at = model.get_atoms() view(at)
#!/usr/bin/env python
from kmos.run import KMC_Model
import pylab
import numpy as np
#load model
model = KMC_Model(print_rates=False, banner=False)
#set pressures and temperature
model.parameters.T = 450
model.parameters.p_COgas = 1
model.parameters.p_O2gas = 1
#prepare initial state of system with all bridge sites covered by O
#for i in range(model.size[0]):
# for j in range(model.size[1]):
# model._put([i,j,0,model.lattice.ruo2_bridge], model.proclist.o)
#model._adjust_database()
#get TOF labels
tof_labels = model.get_tof_header().split(' ')
#get coverage labels
cov_labels = model.get_occupation_header().split(' ')
#Number of kmc steps taken in each sample
sample_step = 1e5
#Number of samples
N = 100
"""Visualize the growth of a run of the SOS model""" import sys, os from kmos.run import KMC_Model from ase.visualize import view config = os.path.splitext(sys.argv[1])[0] size = (30, 30, 30) model = KMC_Model(banner=False, size=size) model.load_config(config) at = model.get_atoms() view(at)
"""
Generate and Arrhenius plot
using kmos
Juan M. Lorenzi
TU Munich
June 2016
"""
import math
from kmos.run import KMC_Model
model = KMC_Model(banner=False)
model.parameters.p_COgas = 2.e-1
model.parameters.p_O2gas = 1.e-1
nrel = 1e7
nsample = 1e7 # numerical parameters
Ts = range(450, 650, 20) # 20 values between 450 and 650 K
fout = open('arrhenius.dat', 'w') # open an output file
fout.write(model.get_std_header()) # print the header
# Loop over the temperature
for T in Ts:
model.parameters.T = T # Set the desired temperature
model.do_steps(nrel) # Relax the system
# Sample the reactivity and print data to file
output = model.get_std_sampled_data(1, nsample)
fout.write(output)
fout.close() # Close output file
# We can read the file with numpy...
def main(args=None):
"""The CLI main entry point function.
The optional argument args, can be used to
directly supply command line argument like
$ kmos <args>
otherwise args will be taken from STDIN.
"""
from glob import glob
options, args, parser = get_options(args, get_parser=True)
if not args[0] in usage.keys():
args[0] = match_keys(args[0], usage, parser)
if args[0] == 'benchmark':
from sys import path
path.append(os.path.abspath(os.curdir))
nsteps = 1000000
from time import time
from kmos.run import KMC_Model
model = KMC_Model(print_rates=False, banner=False)
time0 = time()
try:
model.proclist.do_kmc_steps(nsteps)
except: # kmos < 0.3 had no model.proclist.do_kmc_steps
model.do_steps(nsteps)
needed_time = time() - time0
print('Using the [%s] backend.' % model.get_backend())
print('%s steps took %.2f seconds' % (nsteps, needed_time))
print('Or %.2e steps/s' % (1e6 / needed_time))
model.deallocate()
elif args[0] == 'build':
from kmos.utils import build
build(options)
elif args[0] == 'edit':
from kmos import gui
gui.main()
elif args[0] == 'settings-export':
import kmos.types
import kmos.io
from kmos.io import ProcListWriter
if len(args) < 2:
parser.error('XML file and export path expected.')
if len(args) < 3:
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
xml_file = args[1]
export_dir = args[2]
project = kmos.types.Project()
project.import_xml_file(xml_file)
writer = ProcListWriter(project, export_dir)
writer.write_settings()
elif args[0] == 'export':
import kmos.types
import kmos.io
from kmos.utils import build
if len(args) < 2:
parser.error('XML file and export path expected.')
if len(args) < 3:
out_dir = '%s_%s' % (os.path.splitext(args[1])[0], options.backend)
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
xml_file = args[1]
export_dir = os.path.join(args[2], 'src')
project = kmos.types.Project()
project.import_xml_file(xml_file)
kmos.io.export_source(project,
export_dir,
code_generator=options.backend)
if ((os.name == 'posix'
and os.uname()[0] == 'Linux')
or os.name == 'nt') \
and not options.source_only:
os.chdir(export_dir)
build(options)
for out in glob('kmc_*'):
if os.path.exists('../%s' % out):
overwrite = raw_input(('Should I overwrite existing %s ?'
'[y/N] ') % out).lower()
if overwrite.startswith('y'):
os.remove('../%s' % out)
shutil.move(out, '..')
else:
shutil.move(out, '..')
elif args[0] == 'settings-export':
import kmos.io
pt = kmos.io.import_xml_file(args[1])
if len(args) < 3:
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting kmc_settings.py to %s'
% out_dir)
args.append(out_dir)
if not os.path.exists(args[2]):
os.mkdir(args[2])
elif not os.path.isdir(args[2]):
raise UserWarning("Cannot overwrite %s; Exiting;" % args[2])
writer = kmos.io.ProcListWriter(pt, args[2])
writer.write_settings()
elif args[0] == 'help':
if len(args) < 2:
parser.error('Which help do you want?')
if args[1] == 'all':
for command in sorted(usage):
print(usage[command])
elif args[1] in usage:
print('Usage: %s\n' % usage[args[1]])
else:
arg = match_keys(args[1], usage, parser)
print('Usage: %s\n' % usage[arg])
elif args[0] == 'import':
import kmos.io
if not len(args) >= 2:
raise UserWarning('XML file name expected.')
global pt
pt = kmos.io.import_xml_file(args[1])
sh(banner='Note: pt = kmos.io.import_xml(\'%s\')' % args[1])
elif args[0] == 'rebuild':
from time import sleep
print('Will rebuild model from kmc_settings.py in current directory')
print('Please do not interrupt,'
' build process, as you will most likely')
print('loose the current model files.')
sleep(2.)
from sys import path
path.append(os.path.abspath(os.curdir))
from tempfile import mktemp
if not os.path.exists('kmc_model.so') \
and not os.path.exists('kmc_model.pyd'):
raise Exception('No kmc_model.so found.')
if not os.path.exists('kmc_settings.py'):
raise Exception('No kmc_settings.py found.')
from kmos.run import KMC_Model
model = KMC_Model(print_rates=False, banner=False)
tempfile = mktemp()
f = file(tempfile, 'w')
f.write(model.xml())
f.close()
for kmc_model in glob('kmc_model.*'):
os.remove(kmc_model)
os.remove('kmc_settings.py')
main('export %s -b %s .' % (tempfile, options.backend))
os.remove(tempfile)
model.deallocate()
elif args[0] in ['run', 'shell']:
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos.run import KMC_Model
# useful to have in interactive mode
import numpy as np
try:
from matplotlib import pyplot as plt
except:
plt = None
try:
model = KMC_Model(print_rates=False)
except:
print("Warning: could not import kmc_model!"
" Please make sure you are in the right directory")
global model, np
sh(banner='Note: model = KMC_Model(print_rates=False)')
try:
model.deallocate()
except:
print("Warning: could not deallocate model. Was is allocated?")
elif args[0] == 'version':
from kmos import VERSION
print(VERSION)
elif args[0] == 'view':
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos import view
view.main(steps_per_frame=options.steps_per_frame)
elif args[0] == 'xml':
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos.run import KMC_Model
model = KMC_Model(banner=False, print_rates=False)
print(model.xml())
else:
parser.error('Command "%s" not understood.' % args[0])
#!/usr/bin/env python
from kmos.run import KMC_Model
import pylab
import numpy as np
import random
from ase.all import view
#load model
model = KMC_Model(print_rates=False, banner=False)
#set pressures and temperature
model.parameters.T = 600
model.parameters.p_COgas = 1
model.parameters.p_O2gas = 1
#prepare random initial state of O-poisoned lattice (known steady-state solution)
#this ensures faster relaxation.
#get coverage labels, disregarding the empty species
Nsite_types = model.lattice.spuck
cov_labels = model.get_occupation_header().split(' ')[:-Nsite_types]
#define guess coverages
guess_coverages = [0.05, 0.05, 0.95, 0.95] #CO_br, CO_cus, O_br, O_cus
#dictionaries for converting to kmos variables
kmos_species = {'CO': model.proclist.co, 'O': model.proclist.o}
kmos_sites = {
'bridge': model.lattice.ruo2_bridge,
'cus': model.lattice.ruo2_cus
def main(args=None):
"""The CLI main entry point function.
The optional argument args, can be used to
directly supply command line argument like
$ kmos <args>
otherwise args will be taken from STDIN.
"""
from glob import glob
options, args, parser = get_options(args, get_parser=True)
global model, pt, np, cm_model
if not args[0] in usage.keys():
args[0] = match_keys(args[0], usage, parser)
if args[0] == 'benchmark':
from sys import path
path.append(os.path.abspath(os.curdir))
nsteps = 1000000
from time import time
from kmos.run import KMC_Model
model = KMC_Model(print_rates=False, banner=False)
time0 = time()
try:
model.proclist.do_kmc_steps(nsteps)
except: # kmos < 0.3 had no model.proclist.do_kmc_steps
model.do_steps(nsteps)
needed_time = time() - time0
print('Using the [%s] backend.' % model.get_backend())
print('%s steps took %.2f seconds' % (nsteps, needed_time))
print('Or %.2e steps/s' % (1e6 / needed_time))
model.deallocate()
elif args[0] == 'build':
from kmos.utils import build
build(options)
elif args[0] == 'edit':
from kmos import gui
gui.main()
elif args[0] == 'settings-export':
import kmos.types
import kmos.io
from kmos.io import ProcListWriter
if len(args) < 2:
parser.error('XML file and export path expected.')
if len(args) < 3:
out_dir = '%s_%s' % (os.path.splitext(args[1])[0], options.backend)
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
xml_file = args[1]
export_dir = args[2]
project = kmos.types.Project()
project.import_file(xml_file)
writer = ProcListWriter(project, export_dir)
writer.write_settings()
elif args[0] == 'export':
import kmos.types
import kmos.io
from kmos.utils import build
if len(args) < 2:
parser.error('XML file and export path expected.')
if len(args) < 3:
out_dir = '%s_%s' % (os.path.splitext(args[1])[0], options.backend)
print('No export path provided. Exporting to %s' % out_dir)
args.append(out_dir)
xml_file = args[1]
export_dir = os.path.join(args[2], 'src')
project = kmos.types.Project()
project.import_file(xml_file)
project.shorten_names(max_length=options.variable_length)
kmos.io.export_source(project, export_dir, options=options)
if ((os.name == 'posix'
and os.uname()[0] in ['Linux', 'Darwin'])
or os.name == 'nt') \
and not options.source_only:
os.chdir(export_dir)
build(options)
for out in glob('kmc_*'):
if os.path.exists('../%s' % out):
if options.overwrite:
overwrite = 'y'
else:
overwrite = raw_input(
('Should I overwrite existing %s ?'
'[y/N] ') % out).lower()
if overwrite.startswith('y'):
print('Overwriting {out}'.format(**locals()))
os.remove('../%s' % out)
shutil.move(out, '..')
else:
print('Skipping {out}'.format(**locals()))
else:
shutil.move(out, '..')
elif args[0] == 'settings-export':
import kmos.io
pt = kmos.io.import_file(args[1])
if len(args) < 3:
out_dir = os.path.splitext(args[1])[0]
print('No export path provided. Exporting kmc_settings.py to %s' %
out_dir)
args.append(out_dir)
if not os.path.exists(args[2]):
os.mkdir(args[2])
elif not os.path.isdir(args[2]):
raise UserWarning("Cannot overwrite %s; Exiting;" % args[2])
writer = kmos.io.ProcListWriter(pt, args[2])
writer.write_settings()
elif args[0] == 'help':
if len(args) < 2:
parser.error('Which help do you want?')
if args[1] == 'all':
for command in sorted(usage):
print(usage[command])
elif args[1] in usage:
print('Usage: %s\n' % usage[args[1]])
else:
arg = match_keys(args[1], usage, parser)
print('Usage: %s\n' % usage[arg])
elif args[0] == 'import':
import kmos.io
if not len(args) >= 2:
raise UserWarning('XML file name expected.')
pt = kmos.io.import_xml_file(args[1])
if len(args) == 2:
sh(banner='Note: pt = kmos.io.import_xml(\'%s\')' % args[1])
elif len(
args
) == 3: # if optional 3rd argument is given, store model there and exit
pt.save(args[2])
elif args[0] == 'rebuild':
from time import sleep
print('Will rebuild model from kmc_settings.py in current directory')
print('Please do not interrupt,'
' build process, as you will most likely')
print('loose the current model files.')
sleep(2.)
from sys import path
path.append(os.path.abspath(os.curdir))
from tempfile import mktemp
if not os.path.exists('kmc_model.so') \
and not os.path.exists('kmc_model.pyd'):
raise Exception('No kmc_model.so found.')
if not os.path.exists('kmc_settings.py'):
raise Exception('No kmc_settings.py found.')
from kmos.run import KMC_Model
model = KMC_Model(print_rates=False, banner=False)
tempfile = mktemp()
f = file(tempfile, 'w')
f.write(model.xml())
f.close()
for kmc_model in glob('kmc_model.*'):
os.remove(kmc_model)
os.remove('kmc_settings.py')
main('export %s -b %s .' % (tempfile, options.backend))
os.remove(tempfile)
model.deallocate()
elif args[0] in ['run', 'shell']:
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos.run import KMC_Model
# useful to have in interactive mode
import numpy as np
try:
from matplotlib import pyplot as plt
except:
plt = None
if options.catmap:
import catmap
import catmap.cli.kmc_runner
seed = catmap.cli.kmc_runner.get_seed_from_path('.')
cm_model = catmap.ReactionModel(setup_file='{seed}.mkm'.format(
**locals()))
catmap_message = '\nSide-loaded catmap_model {seed}.mkm into cm_model = ReactionModel(setup_file="{seed}.mkm")'.format(
**locals())
else:
catmap_message = ''
try:
model = KMC_Model(print_rates=False)
except:
print("Warning: could not import kmc_model!"
" Please make sure you are in the right directory")
sh(banner='Note: model = KMC_Model(print_rates=False){catmap_message}'.
format(**locals()))
try:
model.deallocate()
except:
print("Warning: could not deallocate model. Was is allocated?")
elif args[0] == 'version':
from kmos import VERSION
print(VERSION)
elif args[0] == 'view':
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos import view
view.main(steps_per_frame=options.steps_per_frame)
elif args[0] == 'xml':
from sys import path
path.append(os.path.abspath(os.curdir))
from kmos.run import KMC_Model
model = KMC_Model(banner=False, print_rates=False)
print(model.xml())
else:
parser.error('Command "%s" not understood.' % args[0])
#!/usr/bin/env python
from kmos.run import KMC_Model
import pylab
import numpy as np
import random
from ase.all import view
#load model
model = KMC_Model(print_rates=False, banner=False)
#set pressures and temperature
model.parameters.T = 450
model.parameters.p_COgas = 1
model.parameters.p_O2gas = 1
#prepare random initial state of system based on initial guess of species coverages.
#the initial guess could be the coverages obtained in a mean-field (rate equations) model.
#get coverage labels, disregarding the empty species
Nsite_types = model.lattice.spuck
cov_labels = model.get_occupation_header().split(' ')[:-Nsite_types]
#define guess coverages
guess_coverages = [0.25, 0.15, 0.35, 0.55] #CO_br, CO_cus, O_br, O_cus
#dictionaries for converting to kmos variables
kmos_species = {'CO':model.proclist.co, 'O':model.proclist.o}
kmos_sites = {'bridge':model.lattice.ruo2_bridge, 'cus':model.lattice.ruo2_cus}
#available sites
