Merge branch 'api-design'

See !16

Merge branch 'api-design'
See !16
8e0a0a1c · Joseph Weston · 489b0e4b · 1d0cdd39 · 8e0a0a1c · 8e0a0a1c
Commit 8e0a0a1c authored Dec 14, 2018 by Joseph Weston
32 changed files
--- a/.gitattributes
+++ b/.gitattributes
+semicon/_static_version.py export-subst
\ No newline at end of file
--- a/.gitignore
+++ b/.gitignore
@@ -105,3 +105,4 @@ ENV/
 # this project
 kp_models/cache.json
 .pytest_cache
+semicon/model_cache.json
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
 image: kwant/testing

 stages:
-  - build
  - test

-build package:
-  stage: build
+test package:
+  stage: test
  script:
-    - python3 setup.py build
+    - pip3 install sympy==1.1.1
+    - pip3 install -e .
+    - py.test -r w --cov semicon --cov-report term --flakes semicon


-test package:
+test package with latest scipy:
+  stage: test
+  script:
+    - pip3 install sympy==1.1.1 scipy==1.2.0rc2
+    - pip3 install -e .
+    - py.test -r w --cov semicon --cov-report term --flakes semicon
+
+
+test package with latest SymPy and Kwant stable:
  stage: test
  script:
+    - pip3 install sympy
+    - pip3 install git+https://gitlab.kwant-project.org/kwant/kwant.git@stable
    - pip3 install -e .
    - py.test -r w --cov semicon --cov-report term --flakes semicon
+
+test packaging:
+  stage: test
+  script:
+    - pip3 install sympy==1.1.1
+    - pip3 install .
+    - cd /  # make sure we don't import the cloned version
+    - python3 -c 'import semicon; semicon.test()'
--- a/MANIFEST.in
+++ b/MANIFEST.in
+include LICENSE README.md
+include semicon/databank/*.yml
--- a/notebooks/hamiltonian_and_bulk_bands.ipynb
+++ b/notebooks/hamiltonian_and_bulk_bands.ipynb
--- a/notebooks/interface sketch.ipynb
+++ b/notebooks/interface sketch.ipynb
@@ -4,64 +4,229 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "# basic interface idea (prototype)"
+    "# Idea of API\n",
+    "\n",
+    "See corresponding [issue](https://gitlab.kwant-project.org/semicon/semicon/issues/16)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Basic idea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
   "outputs": [],
   "source": [
-    "import semicon\n",
+    "from semicon.models import ZincBlende\n",
+    "from semicon.helpers import interpolate_parameters\n",
    "\n",
-    "bands = ['gamma_6c', 'gamma_8v', 'gamma_7v']\n",
    "\n",
-    "# this will be probably a sympy model, that\n",
-    "# can directly be used by ``kwant.continuum.discretizer``.\n",
+    "# coords describe space dependence of parameters\n",
+    "# bands and components are sequence of strings\n",
+    "model = ZincBlende(coords='z', bands=..., components=...)\n",
    "\n",
-    "hamiltonian = semicon.models.kane(\n",
-    "    components=['base', 'zeeman', 'dresselhaus'], \n",
-    "    bands=bands,\n",
-    "    coords='z',\n",
-    ")\n",
+    "\n",
+    "# hamiltonian property returned as sympy object\n",
+    "smp_ham = model.hamiltonian\n",
+    "\n",
+    "\n",
+    "# parameters returned via method of model\n",
+    "# this method has access to \"bands\" and \"components\" and return\n",
+    "# a parameter class object: subclass of dict with extra method\n",
+    "# for removing spurious solutions\n",
+    "pInAs = model.parameters(material='InAs', databank=lawaetz)\n",
+    "pInAs = pInAs.renormalize(gamma_0=1)\n",
    "\n",
    "\n",
-    "# this will be a dictionary that can be passed into ``params`` of kwant system.\n",
-    "# possible it will also have attributes with extra information about material\n",
-    "# sources, etc.\n",
    "\n",
-    "parameters = semicon.parameters.two_deg(\n",
-    "    bank='lawaetz',\n",
-    "    materials=['AlSb', 'InAs', 'GaSb', 'InAs'],\n",
-    "    widths=[5, 12.5, 5, 5],\n",
-    "    valence_band_offsets=[.18, .0, .56, .18]\n",
-    "    extra_constants={'hbar': 1, 'e': 1},\n",
-    "    bands=bands,\n",
+    "# these could be for example combined with helper function\n",
+    "# to provide interpolated smooth functions for a \"sandwich\"\n",
+    "# two-deg system\n",
+    "parameters = {k: model.parameters(material=k).renormalize(gamma_0=1) \n",
+    "              for k in ['InAs', 'GaSb', 'AlSb']}\n",
+    "\n",
+    "syst = ... # user defines his system of appropriate shape and fill \n",
+    "           # with smp_ham through discretizer on his own\n",
+    "\n",
+    "# assingment is mapping from coords to material name\n",
+    "parameters = interpolate_parameters(syst, parameters, assingment)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## basic bulk example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from semicon.models import ZincBlende\n",
+    "\n",
+    "model = ZincBlende(\n",
+    "    bands=('gamma_6c', 'gamma_8v', 'gamma_7v'),\n",
+    "    components=('base', 'zeeman', 'strain'),\n",
    ")\n",
    "\n",
+    "params = model.parameters(material='InAs').renormalize(gamma_0=1)\n",
+    "\n",
+    "\n",
+    "# and standard kwant code (for continuum disp)\n",
    "\n",
-    "shape = semicon.shapes.two_deg(L=sum(parameters.widths))"
+    "disp = kwant.continuum.lambdify(model.hamiltonian)\n",
+    "e_k = lambda kx, ky, kz: disp(k_x=kx, k_y=ky, k_z=kz, **params)\n",
+    "...\n",
+    "\n",
+    "\n",
+    "# and standard kwant code (for tb dispersion)\n",
+    "\n",
+    "template = kwant.continuum.discretize(model.hamiltonian, grid_spacing=0.5)\n",
+    "syst = kwant.wraparound.wraparound(template).finalized()\n",
+    "e_k = lambda kx, ky, kz: syst.hamiltonian_submpatrix(params=dict('k_x': k_x, ..., **params))\n",
+    "..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## basic two-deg example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from semicon.models import ZincBlende\n",
+    "import semicon\n",
+    "\n",
+    "\n",
+    "model = ZincBlende(\n",
+    "    coords='z',\n",
+    "    bands=('gamma_6c', 'gamma_8v', 'gamma_7v'),\n",
+    "    components=('base', 'zeeman', 'strain'),\n",
+    ")\n",
+    "\n",
+    "parameters = {k: model.parameters(material=k).renormalize(gamma_0=1) \n",
+    "              for k in ['InAs', 'GaSb', 'AlSb']}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### get system"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
   "outputs": [],
   "source": [
-    "import kwant\n",
-    "template = kwant.continuum.discretize(hamiltonian, coords='z', grid_spacing=0.5)\n",
+    "grid = 0.5\n",
+    "L = 20\n",
+    "\n",
+    "template = kwant.continuum.discretize(model.hamiltonian, coords='z', grid_spacing=a)\n",
    "syst = kwant.Builder()\n",
    "\n",
+    "shape = semicon.shapes.twodeg(start=0 - a/2, end=L + a/2)\n",
    "syst.fill(template, shape, (0,))\n",
-    "syst = syst.finalized()\n",
+    "syst = syst.finalized()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## get 2deg parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def twodeg_mapping(z):\n",
+    "    \"\"\"User specified mapping from coord to material.\"\"\"\n",
+    "    return 'AlSb' if z < 5 or z > 5 else 'InAs'\n",
+    " \n",
+    "    \n",
+    "pars_2deg = semicon.helpers.interpolate(\n",
+    "    syst=syst,\n",
+    "    parameters=parameters,\n",
+    "    mapping=twodeg_mapping \n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## and finally obtain hamiltonian and do simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ham = syst.hamiltonian_submatrix(params=pars_2deg)\n",
+    "..."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# further nice helpers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## different growth direction\n",
+    "\n",
+    "Basic idea about the rotation of coordinates is explained in this [notebook](./rotations.ipynb) and discussed in this [issue](https://gitlab.kwant-project.org/semicon/semicon/issues/12).\n",
+    "\n",
+    "From the notebook it is clear that applying rotation produce ugly numerical coefficients in the Hamiltonian. Therefore it may be good idea to chain this method with ``prettify`` functionality."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from semicon.models import ZincBlende\n",
+    "\n",
+    "model = ZincBlende(\n",
+    "    bands=('gamma_6c', 'gamma_8v', 'gamma_7v'),\n",
+    "    components=('base', 'zeeman', 'strain'),\n",
+    ")\n",
+    "\n",
+    "R = ... # 3x3 rotation matrix\n",
+    "model = model.rotate(R, act_on=semicon.symbols.momenta) \\ \n",
+    "             .prettify(zero_atol=1e-8, nsimplify=True)\n",
+    "\n",
    "\n",
-    "ham = syst.hamiltonian_submatrix(params=parameters)"
+    "# note: Using \"act_on\" to specify rotation of only momenta\n",
+    "# allows to leave coords unchanged (treat them as they \n",
+    "# would be already defined in simulation coordinate system)"
   ]
  }
 ],
@@ -81,7 +246,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.6"
  }
 },
 "nbformat": 4,

--- a/notebooks/interpolation.ipynb
+++ b/notebooks/interpolation.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def interpolate(point, values, coords):\n",
+    "    diffs = np.abs(coords - point)\n",
+    "    weights = np.prod(1 - diffs, axis = 1)\n",
+    "    return weights @ values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f8fdc189588>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "values = np.array([0, 0, 0, 1])\n",
+    "points = np.array([[0, 0], [1, 0], [0, 1], [1, 1]])\n",
+    "xs = np.linspace(0, 1, 100)\n",
+    "plt.imshow([[interpolate(np.array([x, y]), values, points) \n",
+    "             for x in xs]\n",
+    "            for y in xs])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
--- a/notebooks/parameters.ipynb
+++ b/notebooks/parameters.ipynb
--- a/notebooks/rotations.ipynb
+++ b/notebooks/rotations.ipynb
--- a/notebooks/simple_2deg.ipynb
+++ b/notebooks/simple_2deg.ipynb
--- a/notebooks/spurious-solutions.ipynb
+++ b/notebooks/spurious-solutions.ipynb
--- a/notebooks/test_new_models.ipynb
+++ b/notebooks/test_new_models.ipynb
--- a/pytest.ini
+++ b/pytest.ini
@@ -2,3 +2,5 @@
 testpaths = semicon
 flakes-ignore =
    __init__.py UnusedImport
+    semicon/kp_models/*.py ImportStarUsage
+    semicon/kp_models/*.py ImportStarUsed
--- a/semicon/__init__.py
+++ b/semicon/__init__.py
 __all__ = []

+from ._version import __version__
+__all__.append('__version__')

 for module in ['parameters', 'models', 'peierls']:
    exec('from . import {0}'.format(module))
    __all__.append(module)
+
+
+def test(verbose=True):
+    from pytest import main
+    import os.path
+
+    return main([os.path.dirname(os.path.abspath(__file__)),
+                 "-s"] + (['-v'] if verbose else []))
+
+test.__test__ = False
--- a/semicon/_static_version.py
+++ b/semicon/_static_version.py
+# -*- coding: utf-8 -*-
+# This file is part of 'miniver': https://github.com/jbweston/miniver
+#
+# This file will be overwritten by setup.py when a source or binary
+# distribution is made.  The magic value "__use_git__" is interpreted by
+# version.py.
+
+version = "__use_git__"
+
+# These values are only set if the distribution was created with 'git archive'
+refnames = "$Format:%D$"
+git_hash = "$Format:%h$"
--- a/semicon/_version.py
+++ b/semicon/_version.py
+# -*- coding: utf-8 -*-
+# This file is part of 'miniver': https://github.com/jbweston/miniver
+#
+from collections import namedtuple
+import os
+import subprocess
+
+from distutils.command.build_py import build_py as build_py_orig
+from setuptools.command.sdist import sdist as sdist_orig
+
+Version = namedtuple('Version', ('release', 'dev', 'labels'))
+
+# No public API
+__all__ = []
+
+package_root = os.path.dirname(os.path.realpath(__file__))
+package_name = os.path.basename(package_root)
+distr_root = os.path.dirname(package_root)
+
+STATIC_VERSION_FILE = '_static_version.py'
+
+
+def get_version(version_file=STATIC_VERSION_FILE):
+    version_info = get_static_version_info(version_file)
+    version = version_info['version']
+    if version == "__use_git__":
+        version = get_version_from_git()
+        if not version:
+            version = get_version_from_git_archive(version_info)
+        if not version:
+            version = Version("unknown", None, None)
+        return pep440_format(version)
+    else:
+        return version
+
+
+def get_static_version_info(version_file=STATIC_VERSION_FILE):
+    version_info = {}
+    with open(os.path.join(package_root, version_file), 'rb') as f:
+        exec(f.read(), {}, version_info)
+    return version_info
+
+
+def version_is_from_git(version_file=STATIC_VERSION_FILE):
+    return get_static_version_info(version_file)['version'] == '__use_git__'
+
+
+def pep440_format(version_info):
+    release, dev, labels = version_info
+
+    version_parts = [release]
+    if dev:
+        if release.endswith('-dev') or release.endswith('.dev'):
+            version_parts.append(dev)
+        else:  # prefer PEP440 over strict adhesion to semver
+            version_parts.append('.dev{}'.format(dev))
+
+    if labels:
+        version_parts.append('+')
+        version_parts.append(".".join(labels))
+
+    return "".join(version_parts)
+
+
+def get_version_from_git():
+    try:
+        p = subprocess.Popen(['git', 'rev-parse', '--show-toplevel'],
+                             cwd=distr_root,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except OSError:
+        return
+    if p.wait() != 0:
+        return
+    if not os.path.samefile(p.communicate()[0].decode().rstrip('\n'),
+                            distr_root):
+        # The top-level directory of the current Git repository is not the same
+        # as the root directory of the distribution: do not extract the
+        # version from Git.
+        return
+
+    # git describe --first-parent does not take into account tags from branches
+    # that were merged-in. The '--long' flag gets us the 'dev' version and
+    # git hash, '--always' returns the git hash even if there are no tags.
+    for opts in [['--first-parent'], []]:
+        try:
+            p = subprocess.Popen(
+                ['git', 'describe', '--long', '--always'] + opts,
+                cwd=distr_root,
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        except OSError:
+            return
+        if p.wait() == 0:
+            break
+    else:
+        return
+
+    description = (
+        p.communicate()[0]
+        .decode()
+        .strip('v')  # Tags can have a leading 'v', but the version should not
+        .rstrip('\n')
+        .rsplit('-', 2)  # Split the latest tag, commits since tag, and hash
+    )
+
+    try:
+        release, dev, git = description
+    except ValueError:  # No tags, only the git hash
+        # prepend 'g' to match with format returned by 'git describe'
+        git = 'g{}'.format(*description)
+        release = 'unknown'
+        dev = None
+
+    labels = []
+    if dev == "0":
+        dev = None
+    else:
+        labels.append(git)
+
+    try:
+        p = subprocess.Popen(['git', 'diff', '--quiet'], cwd=distr_root)
+    except OSError:
+        labels.append('confused')  # This should never happen.
+    else:
+        if p.wait() == 1:
+            labels.append('dirty')
+
+    return Version(release, dev, labels)
+
+
+# TODO: change this logic when there is a git pretty-format
+#       that gives the same output as 'git describe'.
+#       Currently we can only tell the tag the current commit is
+#       pointing to, or its hash (with no version info)
+#       if it is not tagged.
+def get_version_from_git_archive(version_info):
+    try:
+        refnames = version_info['refnames']
+        git_hash = version_info['git_hash']
+    except KeyError:
+        # These fields are not present if we are running from an sdist.
+        # Execution should never reach here, though
+        return None
+
+    if git_hash.startswith('$Format') or refnames.startswith('$Format'):
+        # variables not expanded during 'git archive'
+        return None
+
+    VTAG = 'tag: v'
+    refs = set(r.strip() for r in refnames.split(","))
+    version_tags = set(r[len(VTAG):] for r in refs if r.startswith(VTAG))
+    if version_tags:
+        release, *_ = sorted(version_tags)  # prefer e.g. "2.0" over "2.0rc1"
+        return Version(release, dev=None, labels=None)
+    else:
+        return Version('unknown', dev=None, labels=['g{}'.format(git_hash)])
+
+
+__version__ = get_version()
+
+
+# The following section defines a module global 'cmdclass',
+# which can be used from setup.py. The 'package_name' and
+# '__version__' module globals are used (but not modified).
+
+def _write_version(fname):
+    # This could be a hard link, so try to delete it first.  Is there any way
+    # to do this atomically together with opening?
+    try:
+        os.remove(fname)
+    except OSError:
+        pass
+    with open(fname, 'w') as f:
+        f.write("# This file has been created by setup.py.\n"
+                "version = '{}'\n".format(__version__))
+
+
+class _build_py(build_py_orig):
+    def run(self):
+        super().run()
+        _write_version(os.path.join(self.build_lib, package_name,
+                                    STATIC_VERSION_FILE))
+
+
+class _sdist(sdist_orig):
+    def make_release_tree(self, base_dir, files):
+        super().make_release_tree(base_dir, files)
+        _write_version(os.path.join(base_dir, package_name,
+                                    STATIC_VERSION_FILE))