TB2J 0.9.9rc7__tar.gz → 0.9.9rc8__tar.gz

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc7
+Version: 0.9.9rc8
 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.9rc7 → tb2j-0.9.9rc8}/TB2J/exchange.py

@@ -566,12 +566,23 @@ class ExchangeNCL(Exchange):
         AijRs: a list of AijR,
         wherer AijR: array of ((nR, n, n, 4,4), dtype=complex)
         """
+        # if method == "trapezoidal":
+        #    integrate = trapezoidal_nonuniform
+        # elif method == "simpson":
+        #    integrate = simpson_nonuniform
+        #
+
+        # self.rho = integrate(self.contour.path, rhoRs)
         for iR, R in enumerate(self.R_ijatom_dict):
             for iatom, jatom in self.R_ijatom_dict[R]:
                 f = AijRs[(R, iatom, jatom)]
+                # self.A_ijR[(R, iatom, jatom)] = integrate(self.contour.path, f)
                 self.A_ijR[(R, iatom, jatom)] = self.contour.integrate_values(f)
 
                 if self.orb_decomposition:
+                    # self.A_ijR_orb[(R, iatom, jatom)] = integrate(
+                    #    self.contour.path, AijRs_orb[(R, iatom, jatom)]
+                    # )
                     self.contour.integrate_values(AijRs_orb[(R, iatom, jatom)])
 
     def get_quantities_per_e(self, e):

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/TB2J/io_exchange/io_exchange.py

@@ -338,12 +338,6 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             )
         return Jtensor
 
-    def get_J_tensor_dict(self):
-        Jdict = {}
-        for i, j, R in self.ijR_list():
-            Jdict[(i, j, R)] = self.get_J_tensor(i, j, R)
-        return Jdict
-
     def get_full_Jtensor_for_one_R(self, R, iso_only=False):
         """
         Return the full exchange tensor of all i and j for cell R.
@@ -411,7 +405,6 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         self.write_multibinit(path=os.path.join(path, "Multibinit"))
         self.write_tom_format(path=os.path.join(path, "TomASD"))
         self.write_vampire(path=os.path.join(path, "Vampire"))
-        self.write_matjes(path=os.path.join(path, "Matjes"))
 
         self.plot_all(savefile=os.path.join(path, "JvsR.pdf"))
         # self.write_Jq(kmesh=[9, 9, 9], path=path)
@@ -580,11 +573,6 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
 
         write_uppasd(self, path=path)
 
-    def write_matjes(self, path):
-        from TB2J.io_exchange.io_matjes import write_matjes
-
-        write_matjes(self, path=path)
-
 
 def gen_distance_dict(ind_mag_atoms, atoms, Rlist):
     distance_dict = {}
@@ -600,21 +588,6 @@ def gen_distance_dict(ind_mag_atoms, atoms, Rlist):
     return distance_dict
 
 
-def get_ind_shell(distance_dict, symprec=1e-5):
-    """
-    return a dictionary of shell index for each pair of atoms.
-    The index of shell is the ith shortest distances between all magnetic atom pairs.
-    """
-    shell_dict = {}
-    distances = np.array([x[1] for x in distance_dict.values()])
-    distances_int = np.round(distances / symprec).astype(int)
-    dint = sorted(np.unique(distances_int))
-    dintdict = dict(zip(dint, range(len(dint))))
-    for key, val in enumerate(distances_int):
-        shell_dict[key] = dintdict[val]
-    return shell_dict
-
-
 def test_spin_io():
     import numpy as np
     from ase import Atoms

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/TB2J/mycfr.py

@@ -64,6 +64,10 @@ class CFR:
         # zp = 1j / eigp * kb * self.T
         # Rp = 0.25 * np.diag(eigv)**2 * zp **2
 
+        # print the poles and the weights
+        for i in range(len(self.poles)):
+            print("Pole: ", self.poles[i], "Weight: ", self.weights[i])
+
         # add a point to the poles: 1e10j
         self.path = np.concatenate((self.path, [self.Rinf * 1j]))
         # self.path = np.concatenate((self.path, [0.0]))

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/TB2J/symmetrize_J.py

@@ -9,7 +9,7 @@ from TB2J.versioninfo import print_license
 
 
 class TB2JSymmetrizer:
-    def __init__(self, exc, symprec=1e-8, verbose=True, Jonly=True):
+    def __init__(self, exc, symprec=1e-8, verbose=True, Jonly=False):
         # list of pairs with the index of atoms
         ijRs = exc.ijR_list_index_atom()
         finder = SymmetryPairFinder(atoms=exc.atoms, pairs=ijRs, symprec=symprec)
@@ -25,12 +25,6 @@ class TB2JSymmetrizer:
             )
             print("-" * 30)
             if exc.has_dmi:
-                # raise NotImplementedError(
-                #    "Symmetrization of DMI is not yet implemented."
-                #    )
-                # raise Warning(
-                #        "WARNING: Symmetrization of DMI is not yet implemented."
-                #        )
                 print(
                     "WARNING: Currently only the isotropic exchange is symmetrized. Symmetrization of DMI and anisotropic exchange are not yet implemented."
                 )
@@ -39,7 +33,7 @@ class TB2JSymmetrizer:
             print("Symmetry found:")
             print(finder.spacegroup)
             print("-" * 30)
-        self.pldict = finder.get_symmetry_pair_list_dict()
+        self.pgdict = finder.get_symmetry_pair_group_dict()
         self.exc = exc
         self.new_exc = copy.deepcopy(exc)
         self.Jonly = Jonly
@@ -52,25 +46,21 @@ class TB2JSymmetrizer:
         Symmetrize the exchange parameters J.
         """
         symJdict = {}
-        reduced_symJdict = {}
         # Jdict = self.exc.exchange_Jdict
-        for ishell, pairlist in enumerate(self.pldict.pairlists):
-            ijRs = pairlist.get_all_ijR()
+        # ngroup = self.pgdict
+        for pairgroup in self.pgdict.groups:
+            ijRs = pairgroup.get_all_ijR()
             ijRs_spin = [self.exc.ijR_index_atom_to_spin(*ijR) for ijR in ijRs]
             Js = [self.exc.get_J(*ijR_spin) for ijR_spin in ijRs_spin]
             Javg = np.average(Js)
             for i, j, R in ijRs_spin:
                 symJdict[(R, i, j)] = Javg
-            ijRs_ref = ijRs_spin[0]
-            i, j, R = ijRs_ref
-            reduced_symJdict[(R, i, j)] = Javg
         self.new_exc.exchange_Jdict = symJdict
         if self.Jonly:
             self.new_exc.has_dmi = False
             self.new_exc.dmi_ddict = None
             self.new_exc.has_bilinear = False
             self.new_exc.Jani_dict = None
-            self.new_exc.reduced_exchange_Jdict = reduced_symJdict
             self.has_uniaxial_anisotropy = False
             self.k1 = None
             self.k1dir = None
@@ -134,12 +124,12 @@ def symmetrize_J_cli():
         help="precision for symmetry detection. default is 1e-5 Angstrom",
     )
 
-    # parser.add_argument(
-    #    "--Jonly",
-    #    action="store_true",
-    #    help="symmetrize only the exchange parameters and discard the DMI and anisotropic exchange",
-    #    default=True,
-    # )
+    parser.add_argument(
+        "--Jonly",
+        action="store_true",
+        help="symmetrize only the exchange parameters and discard the DMI and anisotropic exchange",
+        default=False,
+    )
 
     args = parser.parse_args()
     if args.inpath is None:
@@ -149,8 +139,7 @@ def symmetrize_J_cli():
         path=args.inpath,
         output_path=args.outpath,
         symprec=args.symprec,
-        # Jonly=args.Jonly,
-        Jonly=True,
+        Jonly=args.Jonly,
     )
 
 

tb2j-0.9.9rc8/TB2J/thetaphi.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+def theta_phi_even_spaced(n):
+    """
+    Return n evenly spaced theta and phi values in the ranges [0, pi] and [0, 2*pi] respectively.
+    """
+    phis = []
+    thetas = []
+    for i in range(n):
+        phi = 2 * np.pi * i / n
+        phis.append(phi)
+        r = np.sin(np.pi * i / n)
+        theta = np.arccos(1 - 2 * r)
+        thetas.append(theta)
+    return thetas, phis

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc7
+Version: 0.9.9rc8
 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.9rc7 → tb2j-0.9.9rc8}/TB2J.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ TB2J/rotate_siestaDM.py
 TB2J/sisl_wrapper.py
 TB2J/symmetrize_J.py
 TB2J/tensor_rotate.py
+TB2J/thetaphi.py
 TB2J/utest.py
 TB2J/utils.py
 TB2J/versioninfo.py
@@ -76,7 +77,6 @@ TB2J/interfaces/abacus/test_read_HRSR.py
 TB2J/interfaces/abacus/test_read_stru.py
 TB2J/io_exchange/__init__.py
 TB2J/io_exchange/io_exchange.py
-TB2J/io_exchange/io_matjes.py
 TB2J/io_exchange/io_multibinit.py
 TB2J/io_exchange/io_tomsasd.py
 TB2J/io_exchange/io_txt.py

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/docs/src/ReleaseNotes.md

@@ -1,7 +1,23 @@
 ## Release Notes
 ------------------------------------------------------------------------
-#### v0.10.0 September 1, 2024
+
+#### Current development version (v1.0.0-alpha) 
+These are the new features and changes  not yet included in the official release.
+
 - Computing MAE and single-ion anisotropy is now possible with the ABACUS and SIESTA interfaces. 
+This currently requires an non-official SIESTA branch which can seperate the spin-orbit coupling and the exchange-correlation Hamiltonian. (see this MR: https://gitlab.com/siesta-project/siesta/-/merge\_requests/309)
+
+- The full implementation of the magnon band structure from the linear spin wave theory. (Thanks to Andres Tellez Mora and Aldo Romero!) 
+
+- An improved method of the downfolding method which implements the ligand correction to the exchange based on the Wannier function method. This requires the updated version of LaWaF (https://github.com/mailhexu/lawaf) and the updated version of the TB2J\_downfold.py script.
+
+- There is a major refractoring of the interface to the DFT codes. The parsing of the electron Hamiltonian from the DFT codes are now in a separate python package called HamiltonIO (github.com/mailhexu/HamiltonIO). This package is used by TB2J but is made general to be used with other packages too.
+
+
+#### v0.11.0 October 10, 2024
+- Allowing to symmetrize the exchange according to the crystal symmetry with the TB2J\_symmetrize.py script. Note that the spin order is not considered in this symmetrization process. 
+
+#### v0.10.0 September 1, 2024
 - Improved orbital-decomposition to the ABACUS interface. 
 - Allow computing anisotropic J and DMI without three or more calculations within ABACUS and SIESTA interfaces. 
 

{tb2j-0.9.9rc7 → tb2j-0.9.9rc8}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import find_packages, setup
 
-__version__ = "0.9.9_rc7"
+__version__ = "0.9.9_rc8"
 
 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.9.9rc7/TB2J/io_exchange/io_matjes.py

@@ -1,225 +0,0 @@
-import os
-
-import numpy as np
-
-from TB2J.utils import symbol_number
-from ase.units import Bohr, nm
-
-
-def get_ind_shell(distance_dict, symprec=1e-5):
-    """
-    return a dictionary of shell index for each pair of atoms.
-    The index of shell is the ith shortest distances between all magnetic atom pairs.
-    """
-    shell_dict = {}
-    distances = np.array([x[1] for x in distance_dict.values()])
-    distances_int = np.round(distances / symprec).astype(int)
-    dint = sorted(np.unique(distances_int))
-    dintdict = dict(zip(dint, range(len(dint))))
-    for key, val in distance_dict.items():
-        di = np.round(val[1] / symprec).astype(int)
-        shell_dict[key] = dintdict[di]
-    return shell_dict
-
-
-def _write_symmetry(cls, path, fname="symmetry.in", symmetry=True):
-    fname = os.path.join(path, fname)
-    if not symmetry:
-        with open(fname, "w") as myfile:
-            myfile.write("1 \n")
-            myfile.write("\n")
-            myfile.write("! identity operation\n")
-            myfile.write("1.0000000000 0.0000000000 0.0000000000\n")
-            myfile.write("0.0000000000 1.0000000000 0.0000000000\n")
-            myfile.write("0.0000000000 0.0000000000 1.0000000000\n")
-            myfile.write("0.0000000000 0.0000000000 0.0000000000\n")
-    else:
-        raise NotImplementedError("Symmetry not implemented yet")
-
-
-def write_matjes(cls, path="TB2J_results/Matjes", symmetry=False):
-    if not os.path.exists(path):
-        os.makedirs(path)
-    inputfname = os.path.join(path, "input")
-    with open(inputfname, "w") as myfile:
-        _write_lattice_supercell(cls, myfile)
-        _write_atoms(cls, myfile)
-        _write_magnetic_interactions(cls, myfile)
-        #_write_isotropic_exchange(cls, myfile, symmetry=symmetry)
-        _write_magnetic_anisotropy(cls, myfile)
-        # _write_dmi(cls, myfile)
-        _write_exchange_tensor(cls, myfile, symmetry=symmetry)
-        _write_parameters(cls, myfile, symmetry=symmetry)
-    print(f"writting symmetries ")
-    _write_symmetry(cls, path,  fname="symmetries.in", symmetry=False)
-
-def _write_parameters(cls, myfile, symmetry=False):
-    if symmetry:
-        myfile.write("cal_sym T\n")
-        myfile.write("sym_mode 2\n")
-    else:
-        myfile.write("cal_sym F \n")
-        myfile.write("sym_mode 0\n")
-
-def _write_lattice_supercell(cls, myfile):
-    myfile.write("# Lattice and supercell\n")
-    myfile.write(
-        "Periodic_log .T. .T. .T.      # periodic boundary conditions along vector 1, 2 and 3\n"
-    )
-    myfile.write("Nsize 8 8 8                 # size of the supercell\n")
-    try:
-        unitcell = cls.atoms.get_cell().reshape((3, 3))
-    except Exception:
-        unitcell = cls.atoms.get_cell().array.reshape((3, 3))
-    uc_lengths = np.linalg.norm(unitcell, axis=1) 
-    unitcell /= uc_lengths[:, None]
-    myfile.write(f"alat {uc_lengths[0]/nm}  {uc_lengths[1]/nm} {uc_lengths[2]/nm}              #lattice constant lengths\n")
-    myfile.write(
-        "lattice                         #lattice vector should be orthogonal or expressed in cartesian\n")
-    myfile.write(
-        f"{unitcell[0][0]} {unitcell[0][1]} {unitcell[0][2]}     # a_11 a_12 a_1      first lattice vector in line (does not need to be normalize)\n"
-    )
-    myfile.write(
-        f"{unitcell[1][0]} {unitcell[1][1]} {unitcell[1][2]}      # a_21 a_22 a_23    second lattice vector in line (does not need to be normalize)\n"
-    )
-    myfile.write(
-        f"{unitcell[2][0]} {unitcell[2][1]} {unitcell[2][2]}     # a_31 a_32 a_33                     third lattice vector in line\n"
-    )
-
-
-def get_atoms_info(atoms, spinat, symmetry=False):
-    if symmetry:
-        raise NotImplementedError("Symmetry not implemented yet")
-    else:
-        symnum = symbol_number(atoms)
-        atom_types = list(symnum.keys())
-        magmoms = np.linalg.norm(spinat, axis=1)
-        masses = atoms.get_masses()
-        tags = [i for i in range(len(atom_types))]
-    return atom_types, magmoms, masses, tags
-
-
-def _write_atoms(cls, myfile, symmetry=False):
-    myfile.write("\n")
-    myfile.write("# Atoms\n")
-    atom_types, magmoms, masses, tags = get_atoms_info(
-        cls.atoms, cls.spinat, symmetry=symmetry
-    )
-
-    myfile.write(f"atomtypes  {len(atom_types)}       #Number of types atom\n")
-    for i, atom_type in enumerate(atom_types):
-        m = magmoms[i]
-        mass = masses[i]
-        charge = 0
-        myfile.write(
-            f"{atom_type} {m} {mass} 0.0  F 0 # atom type: (name, mag. moment, mass, charge, displacement, number TB-orb.)\n"
-        )
-
-    myfile.write(
-        f"\natoms {len(cls.atoms)}          positions of the atom in the unit cell\n"
-    )
-    for i, atom in enumerate(cls.atoms):
-        spos = cls.atoms.get_scaled_positions()[i]
-        myfile.write(f"{atom_types[tags[i]]} {spos[0]}, {spos[1]}, {spos[2]}  \n")
-
-
-def _write_magnetic_interactions(cls, myfile, symmetry=False):
-    myfile.write("\nThe Hamiltonian\n")
-    myfile.write("# Magnetic interactions\n")
-
-
-def _write_isotropic_exchange(cls, myfile, symmetry=False):
-    myfile.write("\nmagnetic_J\n")
-    shell_dict = get_ind_shell(cls.distance_dict)
-    if symmetry:
-        Jdict = cls.reduced_exchange_Jdict
-    else:
-        Jdict = cls.exchange_Jdict
-    for key, val in Jdict.items():
-        R, i, j = key
-        ishell = shell_dict[(R, i, j)]
-        myfile.write(
-            f"{i+1} {j+1} {ishell} {val}     # between atoms type {i+1} and {j+1}, shell {R}, amplitude in eV  \n"
-        )
-    myfile.write(
-        "\nc_H_J -1        apply 1/2 in front of the sum of the exchange energy - default is -1\n"
-    )
-
-
-def _write_magnetic_anisotropy(cls, myfile):
-    if cls.k1 is None:
-        return
-    else:
-        myfile.write("\nmagnetic_anisotropy \n")
-        for i, k1 in enumerate(cls.k1):
-            myfile.write(
-                f"{i+1} {cls.k1dir[i][0]} {cls.k1dir[i][1]} {cls.k1dir[i][2]} {k1}     anisotropy of atoms type {i+1}, direction {cls.k1dir[i][0]} {cls.k1dir[i][1]} {cls.k1dir[i][2]} and amplitude in eV\n"
-            )
-        myfile.write("\nc_H_ani 1.0\n")
-
-
-def _write_dmi(cls, myfile):
-    if cls.has_dmi:
-        myfile.write("\nmagnetic_D\n")
-        for key, val in cls.dmi_ddict.items():
-            R, i, j = key
-            myfile.write(
-                f"{i+1} {j+1} {R[0]} {R[1]} {R[2]} {val}         #between atoms type {i+1} and {j+1}, mediated by atom type {R}, shell {R}, amplitude in eV\n"
-            )
-        myfile.write(
-            "\nc_H_D   -1.0             # coefficients to put in from of the sum - default is -1\n"
-        )
-
-
-def _write_exchange_tensor(cls, myfile, symmetry=False):
-    myfile.write(
-        "\nmagnetic_r2_tensor #Exchange tensor elements, middle 9 entries: xx, xy, xz, yx, etc. (in units of eV) and direction in which it should be applied\n"
-    )
-
-    Jtensor = cls.get_J_tensor_dict()
-    shelldict = get_ind_shell(cls.distance_dict)
-    unitcell = cls.atoms.get_cell().array.reshape((3, 3))
-    uc_lengths = np.linalg.norm(unitcell, axis=1) 
-    if Jtensor is not None:
-        for key, val in Jtensor.items():
-            i, j, R = key
-            # distance vector
-            dvec = cls.distance_dict[(R, i, j)][0]/nm/uc_lengths
-            dscalar = np.linalg.norm(dvec)
-            val = np.real(val)
-            ishell = shelldict[(R, i, j)]
-            myfile.write(
-                f"{i+1} {j+1} {ishell} {' '.join([str(x) for x in val.flatten()])}  {dvec[0]} {dvec[1]} {dvec[2]} \n"
-                #f"{i+1} {j+1} {dscalar} {' '.join([str(x) for x in val.flatten()])}  {dvec[0]} {dvec[1]} {dvec[2]} \n"
-            )
-        myfile.write(
-            "\nc_H_Exchten -1         apply 1/2 in front of the sum of the exchange tensor energy - default is -1\n"
-        )
-
-def rattle_atoms_and_cell(atoms, stdev=0.001, cell_stdev=0.001):
-    """
-    Rattle both atomic positions and cell parameters.
-    
-    Parameters:
-    -----------
-    atoms: ASE atoms object
-        The atoms to be rattled
-    stdev: float
-        Standard deviation for atomic displacement in Angstrom
-    cell_stdev: float
-        Standard deviation for cell parameter variation (fractional)
-    
-    Returns:
-    --------
-    None
-        The atoms object is modified in-place
-    """
-    # Rattle atomic positions
-    positions = atoms.get_positions()
-    displacement = np.random.normal(0, stdev, positions.shape)
-    atoms.set_positions(positions + displacement)
-    
-    # Rattle cell parameters
-    cell = atoms.get_cell()
-    cell_noise = np.random.normal(0, cell_stdev, cell.shape)
-    atoms.set_cell(cell * (1 + cell_noise), scale_atoms=True)