TB2J 0.9.9rc18__tar.gz → 0.9.9rc20__tar.gz

tb2j-0.9.9rc20/.github/workflows/pylint.yml.bak

@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint
+    - name: Analysing the code with pylint
+      run: |
+        pylint $(git ls-files '*.py')

tb2j-0.9.9rc20/.github/workflows/python-app.yml

@@ -0,0 +1,44 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python application
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        #pytest
+        #  - pwd
+        python -m pip install . 
+        cd examples/abinit-w90/SrMnO3
+        ls -lah
+        sh get_J.sh
+        cd TB2J_results/Multibinit
+        TB2J_magnon.py --figfname magnon.png

tb2j-0.9.9rc20/.gitignore

@@ -0,0 +1,131 @@
+doc/refs/*.pdf
+
+
+*.swp
+
+# Latex 
+*.aux
+
+# xyz files
+
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# numpy results
+*.npy
+
+# png files
+
+# C extensions
+*.so
+*.a
+
+# Fortran extensions
+*.fpp
+*.mod
+*.o
+
+# F90wrap files
+*.plist
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+*.egg-info/*
+.installed.cfg
+*.egg
+
+# temporary files
+temp/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/

tb2j-0.9.9rc20/.pre-commit-config.yaml

@@ -0,0 +1,11 @@
+repos:
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.3.5
+    hooks:
+      # Run the linter.
+      - id: ruff
+        # --select I sorts imports
+        args: [ --fix, --extend-select, I  ]
+      # Run the formatter.
+      - id: ruff-format

tb2j-0.9.9rc20/.readthedocs.yml

@@ -0,0 +1,28 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+build:
+  os: "ubuntu-22.04"
+  tools:
+    python: "3.11"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+
+# Build documentation with MkDocs
+#mkdocs:
+#  configuration: mkdocs.yml
+
+# Optionally build your docs in additional formats such as PDF
+formats:
+  - pdf
+
+# Optionally set the version of Python and requirements required to build your docs
+python:
+  install:
+    - requirements: requirements.txt
+    - requirements: docs/requirements.txt

tb2j-0.9.9rc20/.ruff.toml

@@ -0,0 +1,78 @@
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 88
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py38"
+
+[lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F"]
+ignore = ["E741"]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
+

tb2j-0.9.9rc20/.travis.yml

@@ -0,0 +1,33 @@
+language: python
+python:
+  - "3.7"
+  - "3.8"
+  - "3.9"
+  - "3.10"
+  - "3.11"
+cache: pip
+
+addons:
+  apt:
+    packages: &common_packages
+      - gfortran
+      - libatlas-base-dev
+      - liblapack-dev
+      - libnetcdf-dev
+      - libnetcdff-dev
+      - eatmydata
+      - ccache
+before_install:
+ - if [[ $TRAVIS_PYTHON_VERSION == 3.7 ]]; then pip install -U importlib_metadata; fi
+
+install:
+  - pip install -r requirements.txt
+  - pip install sisl
+  - pip install -e .
+script:
+  - pwd
+  - cd examples/abinit-w90/SrMnO3
+  - ls -lah
+  - sh get_J.sh
+  - cd TB2J_results/Multibinit
+  - TB2J_magnon.py --figfname magnon.png

{tb2j-0.9.9rc18 → tb2j-0.9.9rc20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc18
+Version: 0.9.9rc20
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com

tb2j-0.9.9rc20/TB2J/.gitignore

@@ -0,0 +1,5 @@
+*.o
+*.x
+*.mod
+exchanges.sublime-project
+exchanges.sublime-workspace

{tb2j-0.9.9rc18 → tb2j-0.9.9rc20}/TB2J/Jdownfolder.py

@@ -136,7 +136,7 @@ class JDownfolder_pickle:
         outpath,
         qmesh=[7, 7, 7],
         iso_only=False,
-        method="pwf",
+        method="lowdin",
         **kwargs,
     ):
         self.exc = SpinIO.load_pickle(path=inpath, fname="TB2J.pickle")
@@ -146,6 +146,7 @@ class JDownfolder_pickle:
         self.ligands = ligands
         self.outpath = outpath
         self.method = method
+        print("Using method:", self.method)
 
         # read atomic structure
         self.atoms = self.exc.atoms
@@ -176,7 +177,7 @@ class JDownfolder_pickle:
 
     def _downfold(self, **kwargs):
         JR2 = self.exc.get_full_Jtensor_for_Rlist(asr=True)
-        if self.method == "lowdin":
+        if self.method.lower() == "lowdin":
             d = JDownfolder(
                 JR2,
                 self.exc.Rlist,

{tb2j-0.9.9rc18 → tb2j-0.9.9rc20}/TB2J/MAEGreen.py

@@ -1,7 +1,6 @@
 import gc
 from pathlib import Path
 
-import matplotlib.pyplot as plt
 import numpy as np
 import tqdm
 from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
@@ -55,9 +54,8 @@ class MAEGreen(ExchangeNCL):
 
     def set_angles_xyz(self):
         """theta and phi are defined as the x, y, z, xy, yz, xz, xyz, x-yz, -xyz, -x-yz axis."""
-        self.thetas = [ np.pi / 2, np.pi / 2, 0.0]
-        self.phis = [ np.pi / 2,  0, 0.0]
-
+        self.thetas = [np.pi / 2, np.pi / 2, 0.0]
+        self.phis = [np.pi / 2, 0, 0.0]
 
     def set_angles_axis(self):
         """theta and phi are defined as the x, y, z, xy, yz, xz, xyz, x-yz, -xyz, -x-yz axis."""
@@ -255,11 +253,11 @@ class MAEGreen(ExchangeNCL):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
-        fname_tensor = f"{output_path}/MAE_tensor.dat"
-        if figure3d is not None:
-            fname_fig3d = f"{output_path}/{figure3d}"
-        if figure_contourf is not None:
-            fname_figcontourf = f"{output_path}/{figure_contourf}"
+        # fname_tensor = f"{output_path}/MAE_tensor.dat"
+        # if figure3d is not None:
+        #    fname_fig3d = f"{output_path}/{figure3d}"
+        # if figure_contourf is not None:
+        #    fname_figcontourf = f"{output_path}/{figure_contourf}"
 
         # ouput with eigenvalues.
         if with_eigen:
@@ -284,18 +282,18 @@ class MAEGreen(ExchangeNCL):
                     f.write(f"{ea*1e3:.8f} ")
                 f.write("\n")
 
-        #self.ani = self.fit_anisotropy_tensor()
-        #with open(fname_tensor, "w") as f:
+        # self.ani = self.fit_anisotropy_tensor()
+        # with open(fname_tensor, "w") as f:
         #    f.write("# Anisotropy tensor in meV\n")
         #    f.write(f"{self.ani.tensor_strings(include_isotropic=False)}\n")
 
-        #if figure3d is not None:
+        # if figure3d is not None:
         #    self.ani.plot_3d(figname=fname_fig3d, show=False)
 
-        #if figure_contourf is not None:
+        # if figure_contourf is not None:
         #    self.ani.plot_contourf(figname=fname_figcontourf, show=False)
 
-        #plt.close()
+        # plt.close()
         gc.collect()
 
         with open(fname_orb, "w") as f:

tb2j-0.9.9rc20/TB2J/downfold/Hdownfolder.py

@@ -0,0 +1,233 @@
+import numpy as np
+
+from .io_exchange import ExchangeIO
+from .io_exchange.structure import get_attribute_array
+from .kpoints import monkhorst_pack
+from .mathutils import get_rotation_arrays
+
+
+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
+    )
+
+
+class ExchangeDownfolder(ExchangeIO):
+    def __init__(self, **kwargs):
+        reference_axes = kwargs.pop("reference_axes", None)
+        kwargs["kmesh"] = kwargs.pop("kmesh", [7, 7, 7])
+        super().__init__(**kwargs)
+        self._old_values = None
+
+        if reference_axes is None:
+            reference_axes = np.zeros((6, 3))
+            reference_axes[:3] = np.eye(3)
+            reference_axes[3:] = np.array(
+                [[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 0.0]]
+            ) / np.sqrt(2)
+        self.reference_axes = reference_axes
+
+    @property
+    def reference_axes(self):
+        return self._axes
+
+    @reference_axes.setter
+    def reference_axes(self, values):
+        axes = get_attribute_array(values, "reference_axes")
+        if axes.ndim != 2 or axes.shape[-1] != 3:
+            raise ValueError("The reference axes must be an array of shape (n, 3)")
+        self._axes = axes
+
+    @property
+    def kpoints(self):
+        return self._kpoints
+
+    @ExchangeIO.kmesh.setter
+    def kmesh(self, value):
+        ExchangeIO.kmesh.fset(self, value)
+        self._kpoints = monkhorst_pack(self._kmesh)
+
+    def set_downfolded_magnetic_sites(self, metals):
+        # vectors = self.vectors
+        old_pairs = self.interacting_pairs
+        self._old_magnetic_elements = self.magnetic_elements
+
+        self.magnetic_elements = metals
+        indices = [old_pairs.index(pair) for pair in self.interacting_pairs]
+        self._old_values = self._exchange_values.copy()
+        self.set_vectors(values=self.vectors[indices])
+
+    def _generate_u_matrix(self):
+        """
+        Constructs the matrix with the coefficients that relate the exchange tensor J_{ij} to the matrix A_{ij}.
+        These coefficients only depend on the vectors u_i which depend on the orientations of the magnetic moments.
+
+        """
+        i, j = self.i, self.j
+        if self.collinear:
+            flat_magmoms = self.magmoms[self._index_spin]
+            magmoms = np.zeros((flat_magmoms.shape[0], 3))
+            magmoms[:, 2] = flat_magmoms
+        else:
+            magmoms = self.magmoms[self._index_spin]
+        magmoms /= np.linalg.norm(magmoms, axis=-1)[:, None]
+
+        U, _ = zip(
+            *[get_rotation_arrays(magmoms, u=u[None, :]) for u in self.reference_axes]
+        )
+        U = np.stack(U).swapaxes(0, 1)
+
+        u1 = combine_arrays(U[i], U[j].conj())
+        ur = combine_arrays(U[i], U[j])
+        ui = combine_arrays(U[i].conj(), U[j].conj())
+        u2 = combine_arrays(U[i].conj(), U[j])
+        u = np.concatenate([u1, ur, ui, u2], axis=1)
+
+        self.u_matrix = u
+
+    def _compute_AB_coefficients(self, Hk):
+        """
+        Computes the coefficients corresponding to A_{ij}(d), B_{ij}(d) from the dynamical matrix h(k). They are
+        required to reconstruct the exchange tensor J_{ij}(d).
+        These 18 coefficients are stored in an array with the shape (npairs, 18, nvectors)
+
+        """
+        i, j = self.i, self.j
+        n = i.max() + 1
+
+        ABk = Hk[:, :, [i, i, i + n, i + n], [j, j + n, j, j + n]]
+        ABk = np.moveaxis(ABk, [2, 3], [1, 0]).reshape(len(i), 24, -1)
+
+        exp_summand = np.exp(2j * np.pi * self.vectors @ self.kpoints.T)
+        AB = np.einsum("nik,ndk->nid", ABk[..., ::-1], exp_summand) / len(self.kpoints)
+
+        self.AB_coefficients = AB
+
+    def compute_exchange_tensor(self, Hk):
+        """
+        Computes the exchange tensor that best fits the dynamical matrix Hk
+
+        Parameters
+        ----------
+        Hk : ndarray
+            Dynamical matrix corresponding to the points on a k-grid, constructed for different reference axes.
+            It has the shape (naxes, nkpoints, 2*natoms, 2*natoms)
+
+        Returns
+        -------
+        output : ndarray
+            An exchange tensor with shape (npairs, ninteractions, 3, 3)
+        """
+        n = Hk.shape[-1] // 2
+        # diag = np.diag_indices(n)
+        self.i, self.j = np.triu_indices(n)
+
+        self._generate_u_matrix()
+        self._compute_AB_coefficients(Hk)
+
+        ii = np.where(self.i == self.j)
+        i0 = np.where((self.vectors == 0).all(axis=-1))
+        J = np.stack(
+            [
+                np.linalg.lstsq(mat, coeffs, rcond=None)[0]
+                for mat, coeffs in zip(self.u_matrix, self.AB_coefficients)
+            ]
+        ).swapaxes(1, 2)
+        J = J[:, :, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(len(self.i), -1, 3, 3)
+        J *= -1
+        J[ii] *= 2
+        J[i0] *= 0
+
+        del self.i, self.j, self.u_matrix, self.AB_coefficients
+
+        return J
+
+    def set_exchange_tensor(self, J):
+        idig = np.diag_indices(3)
+        Jiso = J[:, :, *idig].mean(axis=-1)
+
+        idmi = ([1, 2, 0], [2, 0, 1])
+        DMI = (J - J.swapaxes(-1, -2)) / 2
+
+        Jani = (J + J.swapaxes(-1, -2)) / 2
+        Jani[:, :, *idig] -= Jiso[:, :, None]
+
+        self._exchange_values[:, :, 3] = Jiso
+        if not self.collinear:
+            self._exchange_values[:, :, 6:9] = DMI[:, :, *idmi]
+            self._exchange_values[:, :, 9:] = Jani.reshape(Jani.shape[:2] + (9,))
+
+    @staticmethod
+    def downfold_matrix(matrix, basis):
+        eigvals, eigvecs = np.linalg.eigh(matrix)
+        A = np.einsum("...ki,...kj->...ij", eigvecs.conj(), basis)
+        W, _, Vh = np.linalg.svd(A, full_matrices=False)
+        U = np.einsum("...ik,...kj->...ij", W, Vh)
+        downfolded_matrix = np.einsum(
+            "...ki,...kj->...ij", U.conj(), eigvals[..., None] * U
+        )
+
+        return downfolded_matrix
+
+    @staticmethod
+    def lowdin_partition(matrix, indices):
+        N = matrix.shape[-1] // 2
+        null_indices = np.array([i for i in range(N) if i not in indices])
+        diag_indices = np.diag_indices(2 * null_indices.size)
+
+        idx = np.concatenate([indices, indices + N])[None, :]
+        jdx = np.concatenate([null_indices, null_indices + N])[None, :]
+
+        Hii = matrix[..., idx.T, idx]
+        Hij = matrix[..., idx.T, jdx]
+        Hji = matrix[..., jdx.T, idx]
+        Hjj = matrix[..., jdx.T, jdx]
+
+        eigvals = np.linalg.eigvalsh(matrix)
+        Hjj[..., *diag_indices] -= eigvals.min()
+        correction = np.einsum("...ij,...jk,...kl->...il", Hij, np.linalg.inv(Hjj), Hji)
+
+        return Hii - correction
+
+    def downfold(self, metals, **params):
+        try:
+            metals = metals.split()
+        except AttributeError:
+            try:
+                metals = list(metals)
+            except (ValueError, TypeError):
+                raise TypeError("argument must be a list of element symbols.")
+
+        if any(metal not in self.magnetic_elements for metal in metals):
+            wrong_symbols = [
+                metal for metal in metals if metal not in self.magnetic_elements
+            ]
+            raise ValueError(
+                f"The metal symbols '{wrong_symbols}' are not magnetic elements."
+            )
+        else:
+            magnetic_sites = [
+                symbol for symbol in self.elements if symbol in self.magnetic_elements
+            ]
+            # nsites = len(magnetic_sites)
+            metal_indices = np.array(
+                [i for i, element in enumerate(magnetic_sites) if element in metals]
+            )
+
+        Hq = np.stack(
+            [self.Hq(self.kpoints, u=u[None, :]) for u in self.reference_axes]
+        )
+        downfolded_Hq = self.lowdin_partition(Hq, metal_indices)
+
+        self.set_downfolded_magnetic_sites(metals)
+        J = self.compute_exchange_tensor(downfolded_Hq)
+        self.set_exchange_tensor(J.real)
+
+        return J
+
+    def reset(self):
+        if self.old_values is not None:
+            self.magnetic_elements = self._old_magnetic_elements
+            self._exchange_values = self._old_values
+            self.old_values = None
+            self.old_magnetic_elements = None

{tb2j-0.9.9rc18 → tb2j-0.9.9rc20}/TB2J/exchange_params.py

@@ -177,8 +177,7 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
     )
 
     parser.add_argument(
-        "--np",
-        "--nproc",
+        "-np",
         help="number of cpu cores to use in parallel, default: 1",
         default=1,
         type=int,

tb2j-0.9.9rc20/TB2J/interfaces/abacus/.gitignore

@@ -0,0 +1,2 @@
+TB2J_results/
+*.png