Commit 8e0a0a1c authored by Joseph Weston's avatar Joseph Weston

Merge branch 'api-design'

See !16
parents 489b0e4b 1d0cdd39
Pipeline #14109 passed with stage
in 2 minutes
semicon/_static_version.py export-subst
\ No newline at end of file
......@@ -105,3 +105,4 @@ ENV/
# this project
kp_models/cache.json
.pytest_cache
semicon/model_cache.json
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()'
include LICENSE README.md
include semicon/databank/*.yml
This source diff could not be displayed because it is too large. You can view the blob instead.
......@@ -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,
......
{
"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
}
This diff is collapsed.
This source diff could not be displayed because it is too large. You can view the blob instead.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
......@@ -2,3 +2,5 @@
testpaths = semicon
flakes-ignore =
__init__.py UnusedImport
semicon/kp_models/*.py ImportStarUsage
semicon/kp_models/*.py ImportStarUsed
__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
# -*- 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$"
# -*- 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))