Sisl

- Fixed scaling of bond-currents in case 'all' is used, makes comparison
with '+' and '-' easier.

- Updated defaults in bond_current to '+' such that only forward
going electrons are captured.

- Updated defaults in vector_current to '+' such that only forward
going electrons are captured.

- Enabled reading a tabular data-file

- Lots of updates to the spin-class. It should now be more coherent.

- Added rij and Rij to the sparse_geometry classes to extract orbital or
atomic distance matrices (returing the same sparsity pattern).

- Renamed `which` keyword in `Geometry.center` to `what`

- Added uniq keyword to o2a for better handling of orbitals -> atoms.

- Fixed a performance bottleneck issue related to the `scipy.linalg.solve`
routine which was changed since 0.19.0.

- Changed internal testing scheme to `pytest`

- Lots of bug-fixes here and there

- Geometry files used in the command-line has updated these arguments:

- tile
- repeat
- rotate

The order of the arguments are interchanged to be similar to the
scripting capabilities.

Also fixed an issue related to moving atoms into the unit-cell.

- Enabled deleting supercell elements of a sparse Geometry. This
will come in handy when calculating the self-energies and Green
functions. I.e. Hamiltonian.set_nsc(...) will truncate entries
based on the new supercell.

- Preliminary testing of reading Siesta binary output (.RHO, .VT, etc.)

- Added parsing the Siesta EIG file (easy plotting, reading in Python)

- Changed interface for BrillouinZone objects.
Now a BrillouinZone accepts any object which has cell/rcell entries.
Any function call on the BrillouinZone object will transfer the call to the
passed object and evaluate that function for all k-points in the BrillouinZone.

- sisl.io.siesta.tbtrans

* Added current calculator to TBT.nc sile to calculate the current as TBtrans
does it (this requires the latest commit in SIESTA which defines the
chemical potential and electronic structure of *all* electrodes).

* Bug-fixes for TBT.nc sile, the bond-currents for multi-orbital systems
were in some cases wrong.

* Huge performance increase for TBT.nc data processing. Now the majority
of routines are based on array-indexing, rather than sparse loops.

* Changed the DOS retrieval functions to be more flexible. The default is
now to return the summed DOS across the selected atoms.

* Added a TBTGFSileSiesta which enables one to create _external_ self-energies
to be read in by TBtrans (complete electrode control).

* Added `deltancSileSiesta` as a replacement for `dHncSileSiesta`, TBtrans 4.1b4
will have two delta terms, dH (adds to bond-currents) and dSigma (does not
add to bond-currents).

* BEWARE, lots of defaults has changed in this release.

- Hamiltonian.tile is now even faster, only utilizing
intrinsic numpy array functionality.

- Greatly speeded up Hamiltonian.remove/sub functions.
Now there are no for-loops in the remove/sub routines which
will greatly increase performance.
It will now be much faster to generate the Hamiltonian for
a small reference cell, tile/repeat it, remove atoms.

- Added the following routines:

* `SuperCell.fit` routine to determine a new supercell object
such that a given set of coordinates are all within AND
periodic in the new supercell.
* `SuperCell.parallel` to check whether two objects have parallel
latticevectors.
* `Geometry.distance` returns a list of distances from a given
set of atoms. I.e. to determine a set of distances required for
a subsequent close call. This routine can also be used to group
neighbouring atoms in a common fashion.
* `Geometry.optimize_nsc` loops all atoms and minimizes `nsc` in case
one is not sure of the interaction range.
* `Hamiltonian.shift` enables the shift of the entire electronic structure
Fermi-level.
* Added new flag to `Hamiltonian.Hk` routines
``format={'csr', 'array', 'dense', ...}``
to ensure a consistent return of the data-type.

- Bug fix for dHncSileSiesta for multiple levels.

- Performance boost for the sub and remove functions for the
Hamiltonian objects. Instead of creating the geometry first,
it may now be much faster to generate the small Hamiltonian,
tile -> repeat -> sub -> remove.

- Performance boost for the tile and repeat functions for the
Hamiltonian objects. They are now the preferred method for creating
large systems.

- Bug fixed when having extremely long atomic ranges and using tile/repeat.
The number of supercells was too large.
It did not affect anything, but it was inconsistent.

- Enabled reading the density matrix and energy density matrix from siesta.

- Addition of a PerformanceSelector class which enables a dynamic
selection of the best routine.

Currently this is enabled in the SparseOrbitalBZ class where
constructing a matrix k can be done in numerous ways.

- Bug fixed in supercell specification of the Hamiltonian:

>>> H[io, jo, (-1, 0, 0)]

now works in all cases.

- Spin-orbit H(k) has been enabled

- Fixed reading the <>.nc file from SIESTA, the non-zero elements count was
wrong.

- Now H(k) has been tested for non-colinear and spin-orbit coupling and
one can now use sisl to perform non-colinear and spin-orbit coupling
calculations.

- API change, all dR keywords has been changed to R for consistency and
reduction of ambiguity.
Also the `Atoms.dR` is now referred to as `Atoms.maxR()` to indicate
its meaning.

This may break old scripts if one use the `dR` keyword in arguments.

- Added BrillouinZone class to easily create BrillouinZone plots etc.
When calculating the eigenspectrum of a Hamiltonian one may pass
the BrillouinZone object instead of the k-point to retrieve all
eigenvalues for the k-points in the BrillouinZone object.
Say for a PathBZ one can now easily retrieve the band-structure.

- Enabled specification of Hamiltonian connections across supercells via
a tuple index (as the last index):

>>> H[io, jo, (-1, 0, 0)]

Thus connecting orbital `io` and `jo` across the -1 first lattice vector

- Enabled tbtrans files to attach a geometry (to get correct species).

- API change of:

read/write_geom => read/write_geometry
read/write_sc => read/write_supercell
read/write_es => read/write_hamiltonian

Moved `quantity` to `physics`.

- Enabled slice deletion in `SparseCSR`

Enabled eliminate_zeros() to remove unneeded values.

- Added ScaleUp compatibility. sisl now acceps ScaleUp files which is
a 2nd principles code for large scale calculations using Wannier
functions.

- Added Hamiltonian.sub/remove/tile for easy extension of Hamiltonian
without having to construct the larger geometries.
This should speed up the creation of really large structures
as one may then simply "update" the Hamiltonian elements subsequently.

- Fixed bug in __write_default (should have been _write_default)

- API change in `close` functions, now ret_coord => ret_xyz,
ret_dist => ret_rij

- Added `SparseCSR` math operations work on other `SparseCSR` matrices
Thus one may now do:

>>> a, b = SparseCSR(...), SparseCSR(...)
>>> aMb, aPb = a * b, a + b

Which makes many things much easier.
If this is used, you are encouraged to assert that the math is correct.
Currently are the routines largely untested. Assistance is greatly appreciated
in creating tests.

- Geometries now _always_ create a supercell. This was not the case when
an atom with no defined orbital radius was used. Now this returns a
supercell with 10 A of vacuum along each Cartesian direction.

- Fixed reading _hr.dat from Wannier90, now the band-structure of
SrTiO3 (Junquera's test example) is correct.

- Speeded up tbtrans.py analyzing methods enourmously by introducing
faster sparse iterators. Now one can easily perform data-analysis on
systems in excess of 10.000 atoms very fast.

- Added the TBT.AV.nc file which is meant to be created by `sisl` from
the TBT.nc files (i.e. create the k-averaged output).
This enables users to run tbtrans, create the k-averaged output, and
then delete the old file to heavily reduce disk-usage.

An example:

tbtrans RUN.fdf > TBT.out
sdata siesta.TBT.nc --tbt-av
rm siesta.TBT.nc

after this `siesta.TBT.AV.nc` exists will all k-averaged quantites.
If one is not interested in k-resolved quantities this may be very interesting.

- Updated the TBT.nc sile for improved readability.

- Easier script data-extraction from TBT.nc files due to easier conversion
between atomic indices and pivoting orbitals.

For this:

* a2p
returns the pivoting indices for the given atoms (complete set)
* o2p
returns the pivoting indices for the given orbitals

* Added `atom` keyword for retrieving DOS for a given set of atoms

* `sdata` and `TBT.nc` files now enable the creation of the TBT.AV.nc file
which is the k-averaged file of TBT.nc

- Faster bond-current algorithms (faster iterator)

- Initial template for TBT.Proj files for sdata processing

- Geometry:

* Enabled multiplying geometries with integers to emulate `repeat` or
`tile` functions:

>>> geometry * 2 == geometry.tile(2, 0).tile(2, 1).tile(2, 2)
>>> geometry * [2, 1, 2] == geometry.tile(2, 0).tile(2, 2)
>>> geometry * [2, 2] == geometry.tile(2, 2)
>>> geometry * ([2, 1, 2], 'repeat') == geometry.repeat(2, 0).repeat(2, 2)
>>> geometry * ([2, 1, 2], 'r') == geometry.repeat(2, 0).repeat(2, 2)
>>> geometry * ([2, 0], 'r') == geometry.repeat(2, 0)
>>> geometry * ([2, 2], 'r') == geometry.repeat(2, 2)

This may be considered an advanced feature but useful nonetheless.

* Enabled "adding" geometries in a similar way as multiplication
I.e. the following applies:

>>> A + B == A.add(B)
>>> A + (B, 1) == A.append(B, 1)
>>> A + (B, 2) == A.append(B, 2)
>>> (A, 1) + B == A.prepend(B, 1)

* Added `origo` and `atom` argument to rotation functions. Previously this could be
accomblished by:

rotated = geometry.move(-origo).rotate(...).move(origo)

while now it is:

rotated = geometry.rotate(..., origo=origo)

The origo argument may also be a single integer in which case the rotation
is around atom `origo`.

Lastly the `atom` argument enables only rotating a sub-set of atoms.

* Geometry[..] is now calling axyz if `..` is pure indices, if it is
a `slice` it does not work with super-cell indices

* Added `rij` functions to the Geometry for retrieving distances
between two atoms (`orij` for orbitals)

* Renamed iter_linear to iter

* Added argument to iter_species for only looping certain atomic indices

* Added iter_orbitals which returns an iterator with atomic _and_ associated
orbitals.
The orbitals are with respect to the local orbital indices on the given atom


>>> for ia, io in Geometry.iter_orbitals():
>>> Geometry.atom[ia].R[io]


works, while


>>> for ia, io in Geometry.iter_orbitals(local=False):
>>> Geometry.atom[ia].R[io]


does not work because `io` is globally defined.

* Changed argument name for `coords`, `atom` instead of the
old `idx`.

* Renamed function `axyzsc` to `axyz`

- SparseCSR:

* Added `iter_nnz(i=None)` which loops on sparse elements connecting to
row `i` (or default to loop on all rows and columns).

* `ispmatrix` to iterate through a `scipy.sparse.*_matrix` (and the `SparseCSR`
matrix).

- Hamiltonian:

* Added `iter_nnz` which is the `Hamiltonian` equivalent of `SparseCSR.iter_nnz`.
It enables explicit looping on atomic couplings, or orbital couplings.
I.e. one may specify a subset of atoms or orbitals to loop over.

* Preliminary implementation of the non-collinear spin-case. Needs testing.