February 14, 2018

Installation

Quantum KITE is an open-source software suite for accurate real-space tight-binding (TB) simulations of electronic structure & quantum transport of large condensed and molecular systems scalable to multi-billions of atomic orbitals.

KITE is written in C++ with code optimisation at the design level, including automated lattice-domain decomposition to boost multithreading performance. KITE’s interface & post-processing tools are based on Pybinding, a scientific Python package for TB calculations.

KITE is also a quantum transport simulator. On-site energies, defects and generic multi-orbital disorder can be configured at the interface level and added to the system Hamiltonian with desired probability distributions. Green’s functions and related quantities are computed in an essentially numerically exact fashion using highly accurate spectral methods, which allow predictive simulations of a wide range of electronic properties.

For currently available functionalities and to-do-list please refer to the README file. Please share your feedback and bug reports. We’d love to hear your ideas for future improvements (contact email: support at quantum-kite.com).

We are currently working on pip & Conda build packages to automate the installation process (more info soon). Meanwhile, manual installation can be done in three simple steps which are detailed below: (1) downloading the source code; (2) checking dependencies, and; (3) compiling KITEx and KITE-tools from the source code.

KITE runs exclusively on UNIX-based systems, such as GNU/Linux and Mac OS X.

1. Download KITE

First download the source code. You can find the latest version of KITE at our official repository on GitHub repository. Fetch the source code from the Git Hub repository using the command

git clone https://github.com/quantum-kite/kite.git

This will create a folder “kite” with the source code inside kite/src and kite/tools/src.

2. Dependencies

Next, you must ensure that all dependencies have been met. KITE requires:

  • Pybinding
  • Eigen3 (version 3.3.7 or newer)
  • HDF5 (version 1.8.13 or newer)
  • CMake (version 3.9 or newer)
  • gcc (version 4.8.1 or newer)

These packages are available from public domain servers. The compiler must support C++11 features and OpenMP parallelization. To enable KITE’s Gaussian wavepacket propagation functionality, compile the source code with a recent gcc version (gcc 8.0.0 or newer). To check the gcc version, you can use the following command in the terminal:

g++ --version

Below, we provide some convenient instructions on how to install these libraries in Ubuntu and Mac OS X. Instructions on how to install these dependencies for other Linux distributions may be found on the respective websites of the libraries.

2.1 Dependencies in Ubuntu

The instructions below were tested with Ubuntu LTS release 16.04; for other Linux distributions please refer to Compiling libraries from Source Code.

Eigen (Eigen3) features various linear algebra tools. To install it, run:

sudo apt-get install libeigen3-dev

Ubuntu may not provide the required version of Eigen3. You can retrieve the latest stable release of Eigen3 from eigen.tuxfamily.org. Unzip the file and copy the Eigen folder to /usr/include/.

Hierarchical Data Format (HDF5) is used to store the inputs/outputs of the program. To install HDF5, run:

sudo apt-get install h5utils
sudo apt-get install libhdf5-dev

Calculations on KITE are configured using a python script which interfaces with Pybinding. To install Pybinding, you will need CMake and pip:

sudo apt-get install cmake
sudo apt-get install pip3

Pybinding also requires the SciPy packages but pip will resolve all the SciPy dependencies automatically:

pip3 install pybinding

Alternatively, you might prefer to follow the instructions on the Pybinding webpage.

IMPORTANT: the last version of matlibplot is having issues with pybinding. Until this is resolved, use:

pip3 install matplotlib==2.1.1

2.2 Dependencies in Mac OS X

You will need Xcode command-line tools from Apple Developer. You can download Xcode from the Apple Store. Alternatively, you can install the command tools directly from the terminal:

xcode-select --install

You will also need an open-source software package management system. Here, we provide detailed instructions using Homebrew. To install Homebrew run the following command on the terminal:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Follow the instructions provided. Next, install the C++ compiler. For example,

brew install gcc@6

installs gcc version 6.

Eigen (Eigen3) features various linear algebra tools. To install it, run:

brew install eigen

Hierarchical Data Format (HDF5) is used to store the inputs/outputs of the program. To install HDF5, run:

brew install hdf5 --cc=gcc-6

Calculations on KITE are configured using a python script which interfaces with Pybinding. To install the Pybinding package, we suggest using Homebrew. (Alternatively, you can proceed with the installation suggested by Pybinding, with the use of Miniconda.)

brew install cmake
brew install python

Last, install Pybinding with pip:

pip3 install pybinding

IMPORTANT: the last version of matlibplot is having issues with pybinding. Until this is resolved, use:

pip3 install matplotlib==2.1.1

3. Install KITEx and KITE-tools

The last step is to build KITE from source. The following set of commands will create a build directory for both KITE and KITE-tools, and compile the programs from their respective source codes. From within the kite directory (containing CMakeLists.txt and kite.py), run the following commands to compile the main program KITEx:

mkdir build
cd build
cmake ..
make

In order to compile the suite of post-processing utilities, KITE-tools, run the following commands from the kite/tools directory

mkdir build
cmake ..
make

If these commands have ran successfully, you will now find KITEx in the build directory and KITE-tools in the tools/build directory, which are now ready to use!

Testing the program

To generate the input file, try one of our examples. In the kite/examples folder, run

python example_initial.py

It creates a file named example_initial.h5 that is used as an input for KITE:

../build/KITEx example_initial.h5

This first example calculates the density of states of pure graphene. To obtain the data file, you need to postprocess the output:

../tools/build/KITEx-tools example_initial.h5

For more details refer to the KITE Documentation.