Update changelog, readme and version number

changelog.md

@@ -1,19 +1,58 @@
 # Changelog
 
-### v0.8.0 | in development
+### v0.8.0 | 2016-07-01
+
+##### New features
+
+* Added support for scattering models. Semi-infinite leads can be attached to a finite-sized
+  scattering region. Take a look at the documentation, specifically section 10 of the "Basic
+  Tutorial", for details on how to construct such models.
+
+* Added compatibility with [Kwant](http://kwant-project.org/) for transport calculations. A model
+  can be constructed in Pybinding and then exported using the `Model.tokwant()` method. This makes
+  it possible to use Kwant's excellent solver for transport problems. While Kwant does have its
+  own model builder, Pybinding is much faster in this regard: by two orders of magnitude, see the
+  "Benchmarks" page in the documentation for a performance comparison.
+
+* *Experimental:* Initial CUDA implementation of KPM Green's function (only for diagonal elements
+  for now). See the "Experimental Features" section of the documentation.
+
+##### Improvements
+
+* The performance of the KPM Green's function implementation has been improved significantly:
+  by a factor of 2.5x. The speedup was achieved with CPU code using portable SIMD intrinsics
+  thanks to [libsimdpp](https://github.com/p12tic/libsimdpp).
+
+* The Green's function can now be computed for multiple indices simultaneously.
+
+* The spatial origin of a lattice can be adjusted using the `Lattice.offset` attribute. See the
+  "Advanced Topics" section.
 
 ##### Breaking changes
 
-* The interfaces for the `SpatialMap` and `StructureMap` result objects have changed significantly.
-  See the "Plotting Guide" section of the documentation for details.
+* The interface for structure plotting (as used in `System.plot()` and `StructureMap`) has been
+  greatly improved. Some of the changes are not backwards compatible and may require some minor
+  code changes after upgrading. See the "Plotting Guide" section of the documentation for details.
+
+* The interfaces for the `Bands` and `StructureMap` result objects have been revised. Specifically,
+  structure maps are now more consistent with ndarrays, so the old `smap.filter(smap.x > 0)` is
+  replaced by `smap2 = smap[smap.x > 0]`. The "Plotting Guide" has a few examples and there is a
+  full method listing in the "API Reference" section.
 
 ##### Documentation
 
 * The API reference has been completely revised and now includes a summary on the main page.
 
+* A few advanced topics are now covered, including some aspects of plotting. A few more random
+  examples have also been added.
+
+* Experimental features are now documented.
+
 ##### Bug fixes
 
 * Fixed translational symmetry skipping directions for some 2D systems.
+* Fixed computation of off-diagonal Green's function elements with `opt_level > 0`
+* Fixed some issues with shapes which were not centered at `(x, y) = (0, 0)`.
 
 
 ### v0.7.2 | 2016-03-14

pybinding/__about__.py

@@ -1,6 +1,6 @@
 """Package for numerical tight-binding calculations in solid state physics"""
 __title__ = "pybinding"
-__version__ = "0.7.3.dev"
+__version__ = "0.8.0"
 __summary__ = "Package for tight-binding calculations"
 __url__ = "https://github.com/dean0x7d/pybinding"
 

readme.md

@@ -61,15 +61,34 @@ See the [documentation] for more details and a guide to get started.
 * Green's function: fast kernel polynomial method implementation
 * Eigensolvers: standard dense and sparse solvers (always available)
   and the [FEAST] solver (only available when compiled with Intel's MKL)
+* Transport: scattering systems with semi-infinite leads can be constructed in Pybinding and then
+  solved using the [Kwant compatibility] layer.
 * Model and result objects have builtin plotting functions for easy visualization
 
 #### Planned work
 
-* Support for transport calculations
 * Improvements for 3D systems (mostly related to plotting functions)
 * Multiple orbitals and spins are already supported, but could use a nicer interface
 
 
+## Benchmarks
+
+One of the main features of Pybinding is an easy-to-use and fast model builder. This can be a
+demanding task for large or complicated systems. Great care was taken to make this process fast.
+
+The following figures compare the performance of Pybinding with the [Kwant] package. They present
+the time and memory required to build a Hamiltonian matrix which describes a tight-binding system.
+Pybinding features good performance and a low memory footprint by using contiguous data structures
+and vectorized operations.
+
+<p align="center">
+  <img src="/docs/benchmarks/system_build.png?raw=true" alt="Tight-binding model build benchmark"/>
+</p>
+
+See the [benchmarks] section of the documentation for details on the testbed hardware and software,
+as well as the source code which can be used to reproduce the results.
+
+
 ## Questions?
 
 If you have any questions, feel free to join the [chat room on Gitter].
@@ -79,7 +98,10 @@ You can also open an issue at the [tracker].
 [documentation]: http://docs.pybinding.site/
 [install instructions]: http://docs.pybinding.site/page/install/index.html
 [Python]: https://www.python.org/
-[SciPy]: http://www.scipy.org/>
+[SciPy]: http://www.scipy.org/
 [FEAST]: http://www.ecs.umass.edu/~polizzi/feast/index.htm
+[Kwant compatibility]: http://docs.pybinding.site/page/advanced/kwant.html
+[Kwant]: http://kwant-project.org/
+[benchmarks]: http://docs.pybinding.site/page/benchmarks/index.html
 [chat room on Gitter]: https://gitter.im/dean0x7d/pybinding
 [tracker]: https://github.com/dean0x7d/pybinding/issues

setup.py

@@ -70,7 +70,7 @@ def changelog():
 
     with open("changelog.md") as file:
         log = file.read()
-    match = re.search(r"### ([\s\S]*?)\n###", log)
+    match = re.search(r"### ([\s\S]*?)\n###\s", log)
     return match.group(1) if match else ""