TB2J 0.8.1__tar.gz → 0.8.2.1__tar.gz

{TB2J-0.8.1 → TB2J-0.8.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.8.1
+Version: 0.8.2.1
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Home-page: UNKNOWN
 Author: Xu He

TB2J-0.8.2.1/TB2J/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.2.1"

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/abacus/abacus_wrapper.py

@@ -4,6 +4,7 @@
 The abacus wrapper
 """
 from pathlib import Path
+import os
 import numpy as np
 from scipy.linalg import eigh
 from TB2J.utils import symbol_number_list
@@ -123,7 +124,14 @@ class AbacusParser:
                         raise ValueError("nspin should be either 1 or 4.")
 
     def read_atoms(self):
-        self.atoms = read_abacus(str(Path(self.outpath) / "../Stru"))
+        path1=str(Path(self.outpath) / "../STRU")
+        path2=str(Path(self.outpath) / "../Stru")
+        if os.path.exists(path1):
+            self.atoms = read_abacus(path1)
+        elif os.path.exists(path2):
+            self.atoms = read_abacus(path2)
+        else:
+            raise Exception("The STRU or Stru file cannot be found.")
         return self.atoms
 
     def read_basis(self):

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/abacus/stru_api.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 """
-Created on Wed Jun 13 10:31:30 2018
-@author: shenzx
+@author: Zhen-Xiong Shen
+@email: shenzx@iai.ustc.edu.cn
+@workplace: Institute of Artificial Intelligence, Hefei Comprehensive National Science Center
 
 Modified on Wed Aug 01 11:44:51 2022
 @author: Ji Yu-yang

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/io_exchange/io_exchange.py

@@ -19,6 +19,7 @@ from datetime import datetime
 import matplotlib.pyplot as plt
 from TB2J.spinham.spin_api import SpinModel
 from TB2J.io_exchange.io_txt import write_Jq_info
+from TB2J.utils import symbol_number
 
 
 class SpinIO(object):
@@ -212,7 +213,23 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
     def get_spin_ispin(self, i):
         return self.spinat[self.iatom(i)]
 
+    def get_symbol_number_ispin(self, symnum):
+        """
+        Return the spin index for a given symbol number.
+        """
+        symdict = symbol_number(self.atoms)
+        return self.index_spin[symdict[symnum]]
+
+    def i_spin(self, i):
+        if isinstance(i, int):
+            return i
+        elif isinstance(i, str):
+            return self.get_symbol_number_ispin(i)
+        else:
+            raise ValueError("i must be either an integer or a string.")
+
     def get_charge_ispin(self, i):
+        i = self.i_spin(i)
         return self.charges[self.iatom(i)]
 
     def get_spin_iatom(self, iatom):
@@ -222,6 +239,8 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         return self.charges[iatom]
 
     def get_J(self, i, j, R, default=None):
+        i = self.i_spin(i)
+        j = self.i_spin(j)
         key = (
             tuple(R),
             i,
@@ -233,6 +252,8 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             return default
 
     def get_Jiso(self, i, j, R, default=None):
+        i = self.i_spin(i)
+        j = self.i_spin(j)
         key = (
             tuple(R),
             i,
@@ -244,6 +265,8 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             return default
 
     def get_DMI(self, i, j, R, default=None):
+        i = self.i_spin(i)
+        j = self.i_spin(j)
         key = (
             tuple(R),
             i,
@@ -261,6 +284,8 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         param j: spin index j
         param R (tuple of integers): cell index R
         """
+        i = self.i_spin(i)
+        j = self.i_spin(j)
         key = (
             tuple(R),
             i,
@@ -278,6 +303,8 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         param j: spin index j
         param R (tuple of integers): cell index R
         """
+        i = self.i_spin(i)
+        j = self.i_spin(j)
         if iso_only:
             Jtensor = np.eye(3) * self.get_J(i, j, R)
         else:
@@ -295,6 +322,8 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         returns:
             Jmat: (3*nspin,3*nspin) matrix.
         """
+        i = self.i_spin(i)
+        j = self.i_spin(j)
         n3 = self.nspin * 3
         Jmat = np.zeros((n3, n3), dtype=float)
         for i in range(self.nspin):

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/io_merge.py

@@ -215,9 +215,9 @@ class Merger2:
                 )
                 w = Jani_removed / Jani
                 Jani_sum += Jani * w  # Jani_removed
-                print(f"{Jani* w=}")
+                #print(f"{Jani* w=}")
                 weights += w
-            print(f"{weights=}")
+            #print(f"{weights=}")
             if np.any(weights == 0):
                 raise RuntimeError(
                     "The data set to be merged does not give a complete anisotropic J tensor, please add more data"

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/manager.py

@@ -284,6 +284,21 @@ def gen_exchange_siesta(
         raise ImportError(
             f"sisl version is {sisl.__version__}, but should be larger than 0.10.0."
         )
+
+    include_orbs = {}
+    if isinstance(magnetic_elements, str):
+        magnetic_elements = [magnetic_elements]
+    for element in magnetic_elements:
+        if "_" in element:
+            elem = element.split("_")[0]
+            orb = element.split("_")[1:]
+            include_orbs[elem] = orb
+        else:
+            include_orbs[element] = None
+    magnetic_elements = list(include_orbs.keys())
+    print(magnetic_elements)
+    print(include_orbs)
+
     fdf = sisl.get_sile(fdf_fname)
     geom = fdf.read_geometry()
     H = fdf.read_hamiltonian()

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/myTB.py

@@ -9,7 +9,7 @@ from collections import defaultdict
 # from tbmodels import Model
 from ase.atoms import Atoms
 from TB2J.utils import auto_assign_basis_name
-from TB2J.wannier import parse_ham, parse_xyz, parse_atoms
+from TB2J.wannier import parse_ham, parse_xyz, parse_atoms, parse_tb
 
 
 class AbstractTB:
@@ -84,6 +84,7 @@ class MyTB(AbstractTB):
         self,
         nbasis,
         data=None,
+        R_degens=None,
         positions=None,
         sparse=False,
         ndim=3,
@@ -93,6 +94,7 @@ class MyTB(AbstractTB):
         """
         :param nbasis: number of basis.
         :param data: a dictionary of {R: matrix}. R is a tuple, matrix is a nbasis*nbasis matrix.
+        :param R_degens: degeneracy of R.
         :param positions: reduced positions.
         :param sparse: Bool, whether to use a sparse matrix.
         :param ndim: number of dimensions.
@@ -107,6 +109,10 @@ class MyTB(AbstractTB):
         self._nspin = nspin
         self._norb = nbasis // nspin
         self._ndim = ndim
+        if R_degens is not None:
+            self.R_degens = R_degens
+        else:
+            self.R_degens = np.ones(len(self.data.keys()), dtype=int)
         if positions is None:
             self._positions = np.zeros((nbasis, self.ndim))
         else:
@@ -121,7 +127,6 @@ class MyTB(AbstractTB):
         self.k2Rfactor = -2.0j * np.pi
         self.is_siesta = False
         self.is_orthogonal = True
-
         self._name = "Wannier"
 
     def set_atoms(self, atoms):
@@ -178,12 +183,17 @@ class MyTB(AbstractTB):
         :param path: path
         :param prefix: prefix to the wannier files, often wannier90, or wannier90_up, or wannier90_dn for vasp.
         """
-        # tbmodel = Model.from_wannier_folder(
-        #    folder=path, prefix=prefix)
-        # m = MyTB.from_tbmodel(tbmodel)
 
-        nbasis, data = parse_ham(fname=os.path.join(path, prefix + "_hr.dat"))
-        xcart, _, _ = parse_xyz(fname=os.path.join(path, prefix + "_centres.xyz"))
+        tb_fname = os.path.join(path, prefix + "_tb.dat")
+        hr_fname = os.path.join(path, prefix + "_hr.dat")
+        if os.path.exists(tb_fname):
+            xcart, nbasis, data, R_degens = parse_tb(fname=tb_fname)
+        else:
+            nbasis, data, R_degens = parse_ham(
+                fname=os.path.join(path, prefix + "_hr.dat")
+            )
+            xcart, _, _ = parse_xyz(fname=os.path.join(path, prefix + "_centres.xyz"))
+
         if atoms is None:
             atoms = parse_atoms(os.path.join(path, prefix + ".win"))
         cell = atoms.get_cell()
@@ -200,7 +210,7 @@ class MyTB(AbstractTB):
                 data[key][1::2, ::2] = dtmp[norb:, :norb]
                 data[key][1::2, 1::2] = dtmp[norb:, norb:]
         ind, positions = auto_assign_basis_name(xred, atoms)
-        m = MyTB(nbasis=nbasis, data=data, positions=xred)
+        m = MyTB(nbasis=nbasis, data=data, positions=xred, R_degens=R_degens)
         nm = m.shift_position(positions)
         nm.set_atoms(atoms)
         return nm
@@ -243,13 +253,16 @@ class MyTB(AbstractTB):
         """
         Hk = np.zeros((self.nbasis, self.nbasis), dtype="complex")
         if convention == 2:
-            for R, mat in self.data.items():
-                phase = np.exp(self.R2kfactor * np.dot(k, R))
+            for iR, (R, mat) in enumerate(self.data.items()):
+                phase = np.exp(self.R2kfactor * np.dot(k, R))  # /self.R_degens[iR]
                 H = mat * phase
                 Hk += H + H.conjugate().T
         elif convention == 1:
-            for R, mat in self.data.items():
-                phase = np.exp(self.R2kfactor * np.dot(k, R + self.rjminusri))
+            for iR, (R, mat) in enumerate(self.data.items()):
+                phase = (
+                    np.exp(self.R2kfactor * np.dot(k, R + self.rjminusri))
+                    / self.R_degens[iR]
+                )
                 H = mat * phase
                 Hk += H + H.conjugate().T
         else:
@@ -369,7 +382,7 @@ class MyTB(AbstractTB):
         newpos = copy.deepcopy(pos)
         for i in range(self.nbasis):
             newpos[i] = pos[i] - shift[i]
-        d = MyTB(self.nbasis, ndim=self.ndim, nspin=self.nspin)
+        d = MyTB(self.nbasis, ndim=self.ndim, nspin=self.nspin, R_degens=self.R_degens)
         d._positions = newpos
 
         for R, v in self.data.items():

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/sisl_wrapper.py

@@ -258,6 +258,110 @@ class SislWrapper(AbstractTB):
         return 0.0
 
 
+class SislWFSXWrapper(SislWrapper):
+    """Wrapper for retrieving eigenvalues and eigenvectors from siesta WFSX file
+
+    Parameters
+    ----------
+    geom : sisl.Geometry
+        the geometry containing information about atomic positions and orbitals
+    wfsx_sile: sisl.io.siesta.wfsxSileSiesta
+        file reader for WFSX file
+    spin : sisl.physics.Spin
+        spin object carrying information about spin configurations and spin component.
+    ispin : None or int
+        index of spin channel to be considered. Only takes effect for collinear spin calculations (UP: 0, DOWN: 1).
+        (default: None)
+    shift_fermi: None or float
+        energy shift to be applied to all energies. If `None` no shift is applied. (default: None)
+    """
+
+    def __init__(self, geom, wfsx_sile, spin, ispin=None, shift_fermi=None):
+        # super().__init__(geom, spin=spin, ispin=ispin, shift_fermi=shift_fermi)
+        super().__init__(sisl_hamiltonian, geom=None, spin=None)
+        self.geom = geom
+        self.wfsx_sile = wfsx_sile
+        self.read_all()
+
+    def read_all(self):
+        """Read all wavefunctions, eigenvalues, and k-points from WFSX file."""
+        evals = []
+        evecs = []
+        wfsx_kpts = []
+
+        def change_gauge(k, evec):
+            """Change the eigenvector gauge"""
+            phase = np.dot(
+                self.geom.xyz[self.geom.o2a(np.arange(self.geom.no)), :],
+                np.dot(k, self.geom.rcell),
+            )
+            if self.spin.has_noncolinear:
+                # for NC/SOC we have a 2x2 spin-box per orbital
+                phase = np.repeat(phase, 2)
+            # r -> R gauge tranformation.
+            return evec * np.exp(1j * phase).reshape(1, -1)
+
+        # Read wavefunctions and eigenvalues
+        for wfc in self.wfsx_sile.yield_eigenstate(parent=self.geom):
+            wfsx_kpts.append(wfc.info["k"])
+            evals.append(wfc.c)
+            # To get the same eigvecs as eigh returns we need to transpose the
+            # array and change the gauge from 'r' to 'R'
+            evecs.append(change_gauge(wfc.info["k"], wfc.state).T)
+
+        # If any k-point occurs more than once in the WaveFuncKPoints block,
+        # we discard the duplicates
+        is_duplicate = self._is_duplicate(wfsx_kpts)
+        self.wfsx_kpts = wfsx_kpts[~is_duplicate]
+        self.evals = np.array(evals, dtype=float)[~is_duplicate]
+        if self.shift_fermi is not None:
+            self.evals += self.shift_fermi
+        self.evecs = np.array(evecs, dtype=np.complex64, order="C")[~is_duplicate]
+
+    def _is_duplicate(self, array):
+        # TODO: Move into utils
+        # Find all matches (i,j): array[i] == array[j]
+        matches = np.all(np.isclose(array[None, :], array[:, None]), axis=-1)
+        # Remove double counting of matches: (i,j) and (j,i)
+        # Also, remove matches of elements with themselves: (i,i)
+        matches = np.triu(matches, 1)
+
+        # Finally determine elements which are duplicates
+        return np.any(matches, axis=0)
+
+    def find_all(self, kpts):
+        """Find the correct eigenvectors and eigenvalues and sort them
+        to match the order in kpts.
+
+        Parameters
+        ----------
+        kpts : list of float (3,) or (nk, 3)
+            list of k points
+
+        Returns
+        -------
+        evals : list of float (nk, n)
+            list of eigenvalues for every requested k point
+        evecs :
+            list of eiegnvector for every requested k point
+        """
+        kpts = np.asarray(kpts)
+        sort_idx = np.where(
+            np.all(np.isclose(self.wfsx_kpts[None, :], kpts[:, None]), axis=-1)
+        )[1]
+        if len(sort_idx) < len(kpts):
+            # k-point not found
+            raise ValueError(
+                f"{self.__class__.__name__}._read_all unable to find at least one "
+                "required k point in '{self.wfsx_sile.file}'. Please, ensure that "
+                "all k points listed below are included:\n"
+                + "\n".join([str(k) for k in kpts])
+            )
+        if not np.all(np.isclose(self.wfsx_kpts[sort_idx], kpts)):
+            # raise ValueError(       wfsx_kpts = np.asarray(wfsx_kpts)
+            pass
+
+
 # def test():
 #    fdf = sisl.get_sile('/home/hexu/projects/learn_siesta/SMO_Wannier/siesta.fdf')
 #    H = fdf.read_hamiltonian(order='nc',dim=2)

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/wannier/__init__.py

@@ -1 +1 @@
-from TB2J.wannier.w90_parser import parse_xyz, parse_ham, parse_atoms
+from TB2J.wannier.w90_parser import parse_xyz, parse_ham, parse_atoms, parse_tb

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J/wannier/w90_parser.py

@@ -5,6 +5,7 @@ import numpy as np
 from ase.io import read
 from ase.atoms import Atoms
 from ase.units import Angstrom, Bohr
+from .w90_tb_parser import parse_tb_file
 
 unit_dict = {"ANG": Angstrom, "BOHR": Bohr}
 
@@ -49,6 +50,7 @@ def parse_ham(fname="wannier90_hr.dat", cutoff=None):
     for i in range(3, 3 + nline):
         d = map(float, lines[i].strip().split())
         dlist += d
+    R_degens = np.array(dlist, dtype=int)
     H_mnR = defaultdict(lambda: np.zeros((n_wann, n_wann), dtype=complex))
     for i in range(3 + nline, 3 + nline + n_wann**2 * n_R):
         t = lines[i].strip().split()
@@ -65,7 +67,7 @@ def parse_ham(fname="wannier90_hr.dat", cutoff=None):
                 H_mnR[R][m, n] = val / 2.0
         else:
             H_mnR[R][m, n] = val / 2.0
-    return n_wann, H_mnR
+    return n_wann, H_mnR, R_degens
 
 
 def parse_cell(fname, unit=Angstrom):
@@ -138,3 +140,11 @@ def parse_atoms(fname):
         taus = taus * factor
         atoms = Atoms(symbols=symbols, cell=cell, positions=taus)
     return atoms
+
+
+def parse_tb(fname):
+    """
+    return the wannier center, number of wannier functions and the Hamiltonian from the wannier90 _tb.dat file.
+    """
+    result = parse_tb_file(fname)
+    return result["centers"], result["n_wann"], result["H"], result["Rdegens"]

TB2J-0.8.2.1/TB2J/wannier/w90_tb_parser.py

@@ -0,0 +1,129 @@
+"""
+parse the tb files in Wannier90
+"""
+
+import os
+import re
+import numpy as np
+from typing import List, Tuple, Dict
+
+
+def ssrline(file):
+    """
+    Read a line and split it into a list of strings"""
+    line = file.readline().strip()
+    return re.split(r"\s+", line)
+
+
+def parse_vector(file, vector_type, size):
+    result = np.zeros((size,), dtype=vector_type)
+    for i in range(size):
+        result[i] = np.fromstring(file.readline().strip(), sep=" ")
+        result[i] = result[i].astype(vector_type)
+    return result
+
+
+def find_Rvectors(Rvectors, R):
+    for i, Rvec in enumerate(Rvectors):
+        if np.all(Rvec == R):
+            return i
+    return -1
+
+
+def parse_tb_file(filename):
+    with open(filename, "r") as io:
+        header = io.readline().strip()
+        a1 = np.fromstring(io.readline().strip(), sep=" ")
+        a2 = np.fromstring(io.readline().strip(), sep=" ")
+        a3 = np.fromstring(io.readline().strip(), sep=" ")
+        # a1, a2, a3 = np.array(list(map(float, [a1, a2, a3])), dtype=np.float64)
+        # lattice = np.vstack((a1.reshape(-1, 1), a2.reshape(-1, 1), a3.reshape(-1, 1))).T
+        lattice = np.vstack((a1, a2, a3))
+
+        n_wann = int(ssrline(io)[0])
+        n_Rvecs = int(ssrline(io)[0])
+
+        Rdegens = []
+        line = io.readline().strip()
+        while line != "":
+            Rdegens += [int(x) for x in line.split()]
+            line = io.readline().strip()
+        assert len(Rdegens) == n_Rvecs, "Rdegens length does not match n_Rvecs"
+
+        Rvectors = np.zeros((n_Rvecs, 3), dtype=np.int32)
+        # H = np.zeros((n_Rvecs,n_wann, n_wann), dtype=np.complex128)
+        H = {}
+        r_x = np.zeros((n_Rvecs, n_wann, n_wann), dtype=np.complex128)
+        r_y = np.zeros((n_Rvecs, n_wann, n_wann), dtype=np.complex128)
+        r_z = np.zeros((n_Rvecs, n_wann, n_wann), dtype=np.complex128)
+        pos_operator = np.zeros((n_Rvecs, n_wann, n_wann, 3), dtype=np.complex128)
+
+        for iR in range(n_Rvecs):
+            # read Rvectors
+            Rvectors[iR] = np.fromstring(io.readline().strip(), sep=" ")
+            Rvectors[iR] = Rvectors[iR].astype(np.int32)
+            R = tuple(Rvectors[iR])
+            H[R] = np.zeros((n_wann, n_wann), dtype=np.complex128)
+            # read H
+            for n in range(n_wann):
+                for m in range(n_wann):
+                    line = ssrline(io)
+                    assert (
+                        m == int(line[0]) - 1 and n == int(line[1]) - 1
+                    ), "Unexpected indices"
+                    reH, imH = float(line[2]), float(line[3])
+                    # H[iR][m, n] = reH + 1j * imH
+                    H[R][m, n] = (reH + 1j * imH) / 2.0
+            io.readline()  # empty line
+        # set the onsite term to half
+        # np.fill_diagonal(H[(0, 0, 0)], H[(0, 0, 0)].diagonal() / 2.0)
+        # print("onsite H from TB: ", H[(0, 0, 0)].diagonal())
+
+        iR0 = find_Rvectors(Rvectors, [0, 0, 0])
+        for iR in range(n_Rvecs):
+            # read Rvectors
+            line = io.readline().strip()
+            Rvectors[iR] = np.fromstring(line, sep=" ")
+            Rvectors[iR] = Rvectors[iR].astype(np.int32)
+            # read r_x, r_y, r_z
+            for n in range(n_wann):
+                for m in range(n_wann):
+                    line = ssrline(io)
+                    assert (
+                        m == int(line[0]) - 1 and n == int(line[1]) - 1
+                    ), f"Unexpected indices in line {line}"
+                    pos_operator[iR, m, n, 0] = complex(float(line[2]), float(line[3]))
+                    pos_operator[iR, m, n, 1] = complex(float(line[4]), float(line[5]))
+                    pos_operator[iR, m, n, 2] = complex(float(line[6]), float(line[7]))
+            io.readline()
+
+        # print(
+        #    f"Reading tb.dat file: {filename} | Header: {header} | n_wann: {n_wann} | n_Rvecs: {n_Rvecs}"
+        # )
+
+        centers = pos_operator[iR0, :, :, :].diagonal(offset=0, axis1=0, axis2=1).T.real
+
+        return {
+            "n_wann": n_wann,
+            "lattice": lattice,
+            "Rvectors": Rvectors,
+            "Rdegens": Rdegens,
+            "H": H,
+            "pos_operator": pos_operator,
+            "centers": centers,
+            "header": header,
+        }
+
+
+def test_parse_tb_file():
+    filename = "cri3_up_tb.dat"
+    result = parse_tb_file(filename)
+    # rvecs=result["Rvectors"]
+    # iR=find_Rvectors(rvecs, [0, 0, 0])
+    # for i in range(30):
+    #    print(np.real(result["pos_operator"][iR, i, i, :]))
+    print(result["centers"])
+
+
+if __name__ == "__main__":
+    test_parse_tb_file()

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.8.1
+Version: 0.8.2.1
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Home-page: UNKNOWN
 Author: Xu He

{TB2J-0.8.1 → TB2J-0.8.2.1}/TB2J.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ TB2J/spinham/spin_xml.py
 TB2J/spinham/supercell.py
 TB2J/wannier/__init__.py
 TB2J/wannier/w90_parser.py
+TB2J/wannier/w90_tb_parser.py
 scripts/TB2J_downfold.py
 scripts/TB2J_eigen.py
 scripts/TB2J_magnon.py

{TB2J-0.8.1 → TB2J-0.8.2.1}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
 
-__version__ = "0.8.1"
+__version__ = "0.8.2.1"
 
 long_description = """TB2J is a Python package aimed to compute automatically the magnetic interactions (superexchange  and Dzyaloshinskii-Moriya) between atoms of magnetic crystals from DFT Hamiltonian based on Wannier functions or Linear combination of atomic orbitals. It uses the Green's function method and take the local rigid spin rotation as a perturbation. The package can take the output from Wannier90, which is interfaced with many density functional theory codes or from codes based on localised orbitals. A minimal user input is needed, which allows for an easily integration into a high-throughput workflows. """
 

TB2J-0.8.1/TB2J/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.1"