TB2J 0.8.2.7__tar.gz → 0.8.2.8__tar.gz

{TB2J-0.8.2.7 → TB2J-0.8.2.8}/PKG-INFO

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

TB2J-0.8.2.8/TB2J/__init__.py

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

{TB2J-0.8.2.7 → TB2J-0.8.2.8}/TB2J/green.py

@@ -225,12 +225,22 @@ class TBGreen:
 
     def get_density_matrix(self):
         rho = np.zeros((self.nbasis, self.nbasis), dtype=complex)
-        for ik, _ in enumerate(self.kpts):
-            rho += (
-                (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
-                @ self.get_evecs(ik).T.conj()
-                * self.kweights[ik]
-            )
+        if self.is_orthogonal:
+            for ik, _ in enumerate(self.kpts):
+                rho += (
+                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
+                    @ self.get_evecs(ik).T.conj()
+                    * self.kweights[ik]
+                )
+        else:
+            for ik, _ in enumerate(self.kpts):
+                rho += (
+                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
+                    @ self.get_evecs(ik).T.conj()
+                    @ self.get_Sk(ik)
+                    * self.kweights[ik]
+                )
+
         return rho
 
     def get_rho_R(self, Rlist):

TB2J-0.8.2.8/TB2J/spinham/h_matrix.py

@@ -0,0 +1,68 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import aiida
+from aiida_tb2j.data import ExchangeData
+
+def plot_dispersion(bands, kpoint_labels, color='blue', title=None):
+
+    fig, axs = plt.subplots(1, 1, constrained_layout=True)
+    fig.set_size_inches(6, 6/1.618)
+
+    '''
+    Plot the bands
+    '''
+    kpoints = np.arange(len(bands))
+    axs.plot(kpoints, bands, color=color, linewidth=1.5)
+
+    '''
+    Plot the symmetry points
+    '''
+    bmin = bands.min(); bmax = bands.max()
+    ymin = bmin - 0.05*np.abs(bmin-bmax); ymax = bmax + 0.05*np.abs(bmax-bmin);
+    axs.set_xticks(kpoint_labels[0], kpoint_labels[1], fontsize=10)
+    axs.vlines(x=kpoint_labels[0], ymin=ymin, ymax=ymax, color='black', linewidth=0.5)
+    axs.set_xlim([0, len(kpoints)])
+    axs.set_ylim([ymin, ymax])
+
+    if title is not None:
+        plt.title(title, fontsize=10)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument('-f', '--pickle_filename', type=str, help="Path of the 'TB2J.pickle' file.", required=True)
+    args = parser.parse_args()
+    
+    '''
+    Right now the implementation depends on AiiDA and so we must create and load an AiiDA profile,
+    even if we do not store any information on a data base.
+    '''
+    aiida.load_profile()
+    '''
+    Create an ExchangeData object with the informations from the TB2J.pickle file
+    '''
+    exchange = ExchangeData.load_tb2j(pickle_file=args.pickle_filename, isotropic=False, pbc=(True, True, True))
+    '''
+    Compute the magnon band structure along a high symmetry path generated with
+    the ASE package. The informations is stored in an AiiDA BandsData object.
+    Here tol is the symmetry tolerance to determine the space group of the system.
+    They are in units of eV
+    '''
+    magnon_data = exchange.get_magnon_bands(npoints=300, tol=1e-1, with_DMI=True, with_Jani=True)
+    magnon_bands = 1000*magnon_data.get_bands() # Convert to meV
+    raw_labels = [(k, '$\Gamma$') if s == 'GAMMA' else (k, s) for k, s in magnon_data.labels]
+    kpoint_labels = list( zip( *raw_labels ) )
+    plot_dispersion(magnon_bands, kpoint_labels, color='blue', title='Magnon Bands')
+    '''
+    We can also obtain the dynamical matrix h instead of the actual magnon bands. The result
+    is stored in a numpy array with shape (number of kpoints, 2*natoms, 2*natoms)
+    '''
+    kpoints = magnon_data.get_kpoints() # The shape of the kpoints must be (nkpoints, 3)
+    h_matrix = 1000*exchange._H_matrix(kpoints, with_DMI=True, with_Jani=True) # Convert to meV
+    h_dispersion = np.linalg.eigvalsh(h_matrix) # We can also get the eigenvectors with np.linalg.eigh
+    plot_dispersion(h_dispersion, kpoint_labels, color='red', title='h matrix dispersion')

TB2J-0.8.2.8/TB2J/spinham/obtain_J.py

@@ -0,0 +1,79 @@
+import numpy as np
+from aiida_tb2j.data import ExchangeData
+from aiida_tb2j.data.exchange import get_rotation_arrays
+from itertools import combinations_with_replacement
+
+ux, uy, uz = np.eye(3).reshape((3, 1, 3))
+
+def combine_arrays(u, v):
+
+    return np.concatenate([u*v, np.roll(u, -1, axis=-1)*v, np.roll(v, -1, axis=-1)*u], axis=-1)
+
+def get_coefficients(magmoms, indices):
+
+    i, j = indices
+
+    U, V = zip(*[get_rotation_arrays(magmoms, u=u) for u in [ux, uy, uz]])
+    U = np.stack(U).swapaxes(0, 1)
+    V = np.stack(V).swapaxes(0, 1)
+
+    uc = combine_arrays(U[i], U[j].conj())
+    ur = combine_arrays(U[i], U[j])
+    uc2 = combine_arrays(U[i].conj(), U[j])
+    u = np.concatenate([uc, ur, uc2], axis=1)
+
+    return u, V
+
+def get_C(H0, u, V):
+
+    n = int(H0.shape[-1]/2)
+    upi = np.triu_indices(n)
+    dig = np.diag_indices(n)
+    
+    i, j = upi
+    AB0 = H0[:, [i, i, i+n], [j, j+n, j+n]]
+    AB0 = np.swapaxes(AB0, 0, 2).reshape(len(i), 9)
+    J0_flat = np.linalg.solve(u, AB0)
+
+    J0 = np.empty((n, n, 3, 3), dtype=complex)
+    J0[*upi] = J0_flat[:, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(-1, 3, 3)
+    J0 += J0.swapaxes(0, 1)
+    J0[*dig] = 0.0
+
+    C = np.array([np.diag(a) for a in np.einsum('imx,ijxy,jmy->mi', V, 2*J0, V)]) 
+
+    return C
+
+def get_J(H, kpoints, exchange):
+
+    n = int(H.shape[-1]/2)
+    upi = np.triu_indices(n)
+    dig = np.diag_indices(n)
+    i, j = upi
+
+    magmoms = exchange.magmoms()[np.unique(exchange.pairs)]
+    magmoms /= np.linalg.norm(magmoms, axis=-1).reshape(-1, 1)
+    u, V = get_coefficients(magmoms, indices=upi)
+
+    H0 = np.stack([1000*exchange._H_matrix(kpoints=np.zeros((1, 3)), with_DMI=True, with_Jani=True, u=u) for u in [ux, uy, uz]])[:, 0, :, :]
+    C = get_C(H0, u, V)
+    H[:, :, :n, :n] += C.reshape(3, 1, n, n)
+    H[:, :, n:, n:] += C.reshape(3, 1, n, n)
+
+    AB = H[:, :, [i, i, i+n], [j, j+n, j+n]]
+    AB[:, :, 2, :] = AB[:, ::-1, 2, :]
+    AB = np.moveaxis(AB, [2, 3], [1, 0]).reshape(len(i), 9, -1)
+
+    vectors = exchange.get_vectors()
+    exp_summand = np.exp( -2j*np.pi*vectors @ kpoints.T )
+    nAB = np.einsum('nik,ndk->nid', AB, exp_summand) / len(kpoints)
+    
+    ii = np.where(i == j)
+    i0 = np.where(np.linalg.norm(vectors, axis=-1) == 0.0)
+    J = np.linalg.solve(u, nAB).swapaxes(1, 2)
+    J = J[:, :, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(len(i), -1, 3, 3)
+    J *= -1
+    J[ii] *= 2
+    J[i0] *= 0
+
+    return J

{TB2J-0.8.2.7 → TB2J-0.8.2.8}/TB2J.egg-info/PKG-INFO

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

{TB2J-0.8.2.7 → TB2J-0.8.2.8}/TB2J.egg-info/SOURCES.txt

@@ -58,8 +58,10 @@ TB2J/io_exchange/io_vampire.py
 TB2J/spinham/__init__.py
 TB2J/spinham/base_parser.py
 TB2J/spinham/constants.py
+TB2J/spinham/h_matrix.py
 TB2J/spinham/hamiltonian.py
 TB2J/spinham/hamiltonian_terms.py
+TB2J/spinham/obtain_J.py
 TB2J/spinham/plot.py
 TB2J/spinham/qsolver.py
 TB2J/spinham/spin_api.py

{TB2J-0.8.2.7 → TB2J-0.8.2.8}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
 
-__version__ = "0.8.2.7"
+__version__ = "0.8.2.8"
 
 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.2.7/TB2J/__init__.py

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