kmcos / kmcos-roadmap

This is the roadmap repository for kmcos

kmcos: Kinetic Monte Carlo of Systems

kmcos is designed for lattice based Kinetic Monte Carlo simulations to understand chemical kinetics and mechanisms. It has been used to produce more than 10 scientific publications. Links to tutorials and other documentation are below.

DOCUMENTATION

Please refer to

• Documentation (including installation): http://kmcos.readthedocs.org/
• Examples https://github.com/kmcos/kmcos/tree/master/examples
• Workshop files: https://github.com/kmcos/intro2kmcos [the later part of the document are for advanced users and may require an instructor]

HELP, BUGS, ISSUES, TROUBLE

This code is research code for scientists by scientists. If you believe you have hit a bug, have a feature request get in touch with us either via the mailing list, or open an issue .

CONTRIBUTORS

Current Project Leaders:

• Karsten Reuter
• Aditya (Ashi) Savara

Creator:

• Max J. Hoffmann

Developers:

• Sebastian Matera
• Juan M. Lorenzi
• Mie Andersen
• Michal Bajdich
• Andreas Garhammer

Other: * Martin Deimel * Thomas Danielson * Jonathan Sutton * Joseba Alberdi * Steve Erwin & NB * Meelod Waheed

THANKS

This project draws on several other great Python modules, which are in turn each free software and we would like to thank each of these projects for making their code freely avalaible, namely:

• Python
• ASE
• Numpy
• f2py
• kiwi, gazpacho
• lxml and in particular ElementTree

FILES

├── COPYING # Copy of GPLv3
├── INSTALL.rst # installation instructions
├── README.rst # This document
├── TODO.rst # Ideas for improvement and new features
├── requirements.txt # Dependencies which can be installed via pip
├── setup.py # setuptools using setup script
├── index.html # landing website
├── kmcos/ # the core kmcos python modules
│   ├── cli.py # the command line interface
│   ├── config.py # configuration of some project wide paths
│   ├── fortran_src/ # static Fortran 90 source files
│   │   ├── assert.ppc # assertion macro
│   │   ├── base.f90 # the default kMC solver
│   │   ├── base_lat_int.f90 # slightly modified kMC solver for lat_int backend
│   │   ├── kind_values.f90 # definition of project wide kind values
│   │   └── main.f90 # source template for standalone Fortran 90 clients
│   ├── gui/ # kmcos.gui module
│   │   ├── forms.py # view definitions (MVC) of editor GUI
│   │   └── __init__.py # controller definitions (MVC) of editor GUI
│   ├── __init__.py # root import module
│   ├── io.py # conversion between format: contains main Code Generator
│   ├── kmc_editor.glade # Glade XML definiton for form interfaces
│   ├── kmc_project_v0.1.dtd # Document Type Definition file of kMC project v0.1
│   ├── kmc_project_v0.2.dtd # Document Type Definition file of kMC project v0.2
│   ├── run.py # High-level API for compiled models
│   ├── species.py # Convenient interface for some reaction intermediates
│   ├── types.py # The basic classes for building kMC models
│   ├── units.py # Definition of conversion factor (CODATA 2010)
│   ├── utils/ # Utility function that didn't fit elsewhere
│   │   ├── __init__.py
│   │   ├── ordered_dict.py
│   │   ├── progressbar.py
│   │   └── terminal.py
│   └── view.py # The runtime GUI for compiled models
├── doc/ # user guide, documentation, and reference
│   └── source/ # documentation source file for compilation with Sphinx
├── examples/ # demoing non-standard features and useful idioms
│   ├── AB_model.py # small demo file
│   ├── benchmark_compilers_and_backends.sh # demo file
│   ├── crowded.xml # demo file
│   ├── dreiD.xml # demo file for 3d model
│   ├── dummy.xml # mininal model
│   ├── model_Pt111_surface.py # demo file for non-rectangular lattice
│   ├── multidentate.py # basic example for multidentate adsorption
│   ├── render_bigcell.py # demo containing many sites
│   ├── render_co_oxidation_ruo2.py # demoing th CO Oxidation at RuO2(110) model
│   ├── render_diffusion_model.py # idioms for describing lateral interaction
│   ├── render_einsD.py # simple 1-dimensional model
│   ├── render_multispecies.py # render many species
│   ├── render_pairwise_interaction.py # idioms for describing lateral interaction
│   ├── render_Pt_111.py # another non-rectangular lattice
│   ├── render_sand_model.py # a neat diffusion model for non-trivial boundary conditions
│   ├── run_in_multi_process.py # an example for parallelization over processes
│   ├── run.py # a high-level run script using the ModelRunner metaclass
│   ├── ruptured_Pd.xml # a fcc(100) like surface with some sites missing
│   └── small.xml # demo file
├── tests/ # Unit tests and test data
├── tools # Entry points for command line interface
│   ├── kmcos
│   ├── kmcos.bat
│   ├── kmcos-build-standalone
│   └── kmcos-install-dependencies-ubuntu

COPYRIGHT AND LICENSE

Copyright (C) 2009-13 Max J. Hoffmann

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, see http://www.gnu.org/licenses/.

kmcos-roadmap's Issues

move snapshots module into Model Class

Currently, in kmcos, one uses the following syntax:
model.do_steps(400)

The snapshots module intentionally avoids the user having to type model, with the user simply typing:
do_snapshots(500)

However, if somebody wanted to run two different model objects in the same run file, which could be needed if somebody was trying to do multiple surfaces, then it would be desirable to have separate snapshots_globals so that the settings could be different [this matters more once rate constant re-throttling is included].

The solution is going to be the following:
a) do_snapshots will be moved inside the model class (like do_steps is)
b) snapshots_globals will become a class of its own to keep its namespace. When a model object is created, a snapshots_globals object will be created with it (along with model.sg = model.snaphots_globals)
c) a global variable in kmos called do_snapshots will already exist, as a None object or possibly a function that simply passes (in which case we'd need a flag to know when it's been changed). None object makes more sense. It will then have its pointer pointer moved to the do_snapshots function of the first model object created. That way this is backwards compatible and people who don't want to type the model object each time won't have to. It will only matter if somebody wants to make specific objects.
d) the None object to pointer trick will be used for the snapshots_globals variable also.

Checklist for the above:
[ ] a
[ ] b
[ ] c
[ ] d

Roadmap

Usability

• get kmcos view working with python3 (gtk and pyGobject
• update installation instructions (done for Ubuntu)
• add snapshots module
• made export & view easily accessible without the terminal command line.
• add the import export module to save and reload state (Savara module) - partly done
• Add random seed restart capability by Sutton. The function was named seed_PRNG and used sg.model.proclist.put_seed(prng_state) - partly done
• rename TOF to EF for event frequency. we might need totEF and siteEF to or similar to distinguish.
• rename "rate_constant" to transition frequency or similar during build files.
• Easy & Pretty Images and movies export. Both 2D and 3D. See examples of ASE 3D here: https://wiki.fysik.dtu.dk/ase/gallery/gallery.html
• Make user guide more strongly tied to examples. (merge in the workshop & other examples)
• Add CiteSoft functionality and add it to the banner https://github.com/kmcos/kmcos/pull/43/files
• Add Thermodynamic (and KMC) phase diagram creator
• Add Electrochemical Module
• Simple examples with different surface structures
• Import structures from DFT outputs (perhaps via catalysis-hub.org)
• Import structures from materials genome project
• Simpler integration to multiscale modeling https://simpeg.xyz/
• After a 'kmcos export' is executed, the last line to the terminal should be printing the name of the directory the compiled model was exported to.
• create a command that would print save lots of parameters, rate constants, etc to file along with configuration dumps. Maybe modify print_state_summary which exists in init.py, along with print_procstat. While parameters of interest are in the TOFS and coverages file, it’s not unusual to need to inspect various things during the simulation to make sure things are behaving as expected.

Development &, Performance

• Simplify Developer Guidelines
• More info for developers about backend
• Convert to Python 3
• Unit Testing of Feature Outputs - partially done
• Evaluate existing forks for integration
• BEP at frontend (Savara coordinate module)
• Cluster Expansions in otf back-end.
• BEP at backend
• SQERTSS algorithm
• temporal acceleration algorithm (Mie Andersen's implementation of Neurock scaling algorithm)
• FTPj steady state detection
• ppSSD (related to steady state detection)
• Build tools for tight integration into multiscale modeling. E.g., https://pubs.acs.org/doi/abs/10.1021/acscatal.8b00713 http://web.mit.edu/braatzgroup/Roder_JElectrochemSoc_2017.pdf
• spatial parallelization
• consider using property wrappers
• consider using memcaching https://realpython.com/python-memcache-efficient-caching/

Integration With Other Codes

• Import structures from DFT outputs
• Import BEP parameters from catapp datastructures.
• Simpler integration to multiscale modeling. Open Foam, https://simpeg.xyz/, etc.
• With other KMC codes? https://www.unamur.be/sciences/physique/ur/larn/logiciels/nascam/NASCAM-Homepage and https://gitlab.osti.gov/giridharnandipati/ksome

Repository Migration

• Code
• Read the docs
• Travis CI etc.
• Github Issues Cards