TB2Jflows 0.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

TB2Jflows/__init__.py

@@ -1,2 +1,5 @@
-from TB2Jflows.ase_siesta import SiestaFlow
-from TB2Jflows.auto_siesta_TB2J import auto_siesta_TB2J
+from TB2Jflows.ase_siesta import SiestaFlow as SiestaFlow
+from TB2Jflows.auto_siesta_TB2J import auto_siesta_TB2J as auto_siesta_TB2J
+from TB2Jflows.siesta_spinphonon import (
+    compute_spinphonon_coupling as compute_spinphonon_coupling,
+)

TB2Jflows/ase_siesta.py

@@ -5,11 +5,12 @@ from pathlib import Path
 
 import ase
 from ase.io.jsonio import decode, encode
-from pyDFTutils.siesta import MySiesta
 from TB2J.interfaces import gen_exchange_siesta
 from TB2J.io_merge import merge
 from TB2J.rotate_atoms import rotate_atom_spin, rotate_atom_xyz
 
+from .mysiesta import MySiesta
+
 
 class SiestaFlow:
     def __init__(
@@ -24,7 +25,6 @@ class SiestaFlow:
         restart=True,
         metadata={},
         fdf_arguments={},
-        relax_arguments={},
         split_soc=False,
         **kwargs,
     ):
@@ -33,6 +33,7 @@ class SiestaFlow:
         self.xc = xc
         self.kpts = kpts
         self.Udict = Udict
+
         # default fdf arguments
         self.fdf_arguments = {
             "MaxSCFIterations": 350,
@@ -51,7 +52,6 @@ class SiestaFlow:
         self.root_path = root_path
         self.restart = restart
         self.kwargs = kwargs
-        self.relax_args = relax_arguments
 
         # paths
         self.metadata_path = os.path.join(self.root_path, "metadata.json")
@@ -160,7 +160,6 @@ class SiestaFlow:
         MaxStressTol=0.1,
         NumCGSteps=200,
     ):
-        print(f"Relaxation in {path}")
         if (
             self.restart
             and self.metadata["already_relaxed"]
@@ -172,20 +171,20 @@ class SiestaFlow:
             old_spin = self.spin
             if use_collinear:
                 self.spin = "collinear"
-            calc = self.get_calculator(atoms, path=self.relax_path, label=label)
-            calc.atoms = atoms
-            atoms = calc.relax(
-                atoms,
-                TypeOfRun=TypeOfRun,
-                VariableCell=VariableCell,
-                ConstantVolume=ConstantVolume,
-                RelaxCellOnly=RelaxCellOnly,
-                MaxForceTol=MaxForceTol,
-                MaxStressTol=MaxStressTol,
-                NumCGSteps=NumCGSteps,
-            )
-            self.spin = old_spin
-            self.relaxed_atoms = atoms
+                calc = self.get_calculator(atoms, path=self.relax_path, label=label)
+                calc.atoms = atoms
+                atoms = calc.relax(
+                    atoms,
+                    TypeOfRun=TypeOfRun,
+                    VariableCell=VariableCell,
+                    ConstantVolume=ConstantVolume,
+                    RelaxCellOnly=RelaxCellOnly,
+                    MaxForceTol=MaxForceTol,
+                    MaxStressTol=MaxStressTol,
+                    NumCGSteps=NumCGSteps,
+                )
+                self.spin = old_spin
+                self.relaxed_atoms = atoms
             self.update_metadata(
                 {
                     "already_relaxed": True,
@@ -359,9 +358,9 @@ class SiestaFlow:
             write_path=os.path.join(self.root_path, "TB2J_results_merged"),
         )
 
-    def runall_collinear(self, atoms, relax=True, scf=True, TB2J=True,  **kwargs):
+    def runall_collinear(self, atoms, relax=True, scf=True, TB2J=True, **kwargs):
         if relax:
-            atoms = self.relax(atoms, **self.relax_args)
+            atoms = self.relax(atoms)
         if scf:
             self.scf_calculation_collinear(atoms, label="siesta")
         if TB2J:
@@ -371,7 +370,7 @@ class SiestaFlow:
         self, atoms, relax=True, scf=True, TB2J=True, rotate_type="structure", **kwargs
     ):
         if relax:
-            atoms = self.relax(atoms, **self.relax_args)
+            atoms = self.relax(atoms)
         if scf:
             self.scf_calculation_with_rotations(
                 atoms, rotate_type=rotate_type, label="siesta"
@@ -382,7 +381,7 @@ class SiestaFlow:
 
     def runall_split_soc(self, atoms, relax=True, scf=True, TB2J=True, **kwargs):
         if relax:
-            atoms = self.relax(atoms, **self.relax_args)
+            atoms = self.relax(atoms)
         if scf:
             self.scf_calculatoin_split_soc(atoms, label="siesta")
         if TB2J:

TB2Jflows/auto_siesta_TB2J.py

@@ -52,7 +52,6 @@ def auto_siesta_TB2J(
     TB2J=True,
     rotate_type="structure",
     fincore=True,
-    relax_kwargs={},
     siesta_kwargs={},
     TB2J_kwargs={},
     fdf_kwargs={},
@@ -100,7 +99,6 @@ def auto_siesta_TB2J(
         fincore=fincore,
         Udict=Udict,
         split_soc=split_soc,
-        relax_arguments = relax_kwargs,
         **siesta_kwargs,
     )
     flow.write_metadata()

TB2Jflows/find_pp.py

@@ -0,0 +1,91 @@
+import os
+
+from ase.data import atomic_numbers
+
+
+class PPFinder:
+    def __init__(self):
+        pass
+
+    def get_pp_path(self, element, xc, label, rel):
+        pass
+
+
+class DojoFinder:
+    def __init__(self, path=None):
+        if path is None:
+            self.path = os.environ["DOJO_PATH"]
+        else:
+            self.path = path
+
+    def get_pp_path(
+        self, xc: str, typ="NC", rel="sr", version="04", accuracy="standard", fmt="psml"
+    ):
+        typ = typ.lower()
+        xc = xc.lower()
+        if xc == "lda":
+            xc = "pbe"
+        dirname = os.path.join(
+            self.path, f"{typ}-{rel}-{version}_{xc}_{accuracy}_{fmt}"
+        )
+        if not os.path.exists(dirname):
+            raise FileNotFoundError(f"File Not found: {dirname}")
+        return dirname
+
+    def get_pp_fname(
+        self,
+        element,
+        xc: str,
+        typ="NC",
+        rel="sr",
+        version="04",
+        accuracy="standard",
+        fincore=False,
+        fmt="psml",
+    ):
+        if 57 < atomic_numbers[element] <= 70:
+            if fincore:
+                fname = os.path.join(
+                    self.get_pp_path(
+                        xc=xc,
+                        typ=typ,
+                        rel=rel,
+                        version=version,
+                        accuracy=accuracy,
+                        fmt=fmt,
+                    ),
+                    f"fincore/{element}.{fmt}",
+                )
+            else:
+                fname = os.path.join(
+                    self.get_pp_path(
+                        xc=xc,
+                        typ=typ,
+                        rel=rel,
+                        version=version,
+                        accuracy=accuracy,
+                        fmt=fmt,
+                    ),
+                    f"withf/{element}.{fmt}",
+                )
+
+        else:
+            fname = os.path.join(
+                self.get_pp_path(
+                    xc=xc, typ=typ, rel=rel, version=version, accuracy=accuracy, fmt=fmt
+                ),
+                f"{element}.{fmt}",
+            )
+        if not os.path.exists(fname):
+            raise FileNotFoundError(f"File Not found: {fname}")
+        return fname
+
+
+def test():
+    finder = DojoFinder(path=os.path.expanduser("~/projects/pp/dojo"))
+    finder.get_pp_path(element="Sr", xc="pbesol")
+    finder.get_pp_path(element="Srg", xc="pbe")
+
+
+if __name__ == "__main__":
+    test()

TB2Jflows/mysiesta.py

@@ -0,0 +1,570 @@
+import math
+import os
+import shutil
+from os.path import isfile, islink, join
+
+import numpy as np
+from ase import Atoms
+from ase.calculators.siesta import Siesta
+from ase.calculators.siesta.parameters import PAOBasisBlock, Species, format_fdf
+from ase.data import atomic_numbers
+from ase.io import write
+from ase.units import Bohr
+
+from .find_pp import DojoFinder
+
+# from pyDFTutils.siesta.pdos import gen_pdos_figure, plot_layer_pdos
+from .siesta_basis import fincore_basis, withf_basis
+
+
+def get_valence_charge(pseudopotential):
+    raise NotImplementedError(
+        "get_valence_charge is not available in the current environment."
+    )
+
+
+def read_vca_synth_block(synth_block_filename, species_number):
+    raise NotImplementedError(
+        "read_vca_synth_block is not available in the current environment."
+    )
+
+
+synthetic_atoms_dict_fincore = {
+    # Ce-Lu
+    "Ce": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Pr": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Nd": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Pm": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Sm": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Eu": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Gd": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Tb": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Dy": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Ho": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Er": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Tm": ((5, 5, 5, 4), (2, 6, 3, 0)),
+    "Yb": ((6, 5, 5, 5), (2, 6, 1, 0)),
+    "Lu": ((5, 5, 5, 4), (2, 6, 3, 0)),
+}
+
+
+def read_siesta_xv(fd):
+    vectors = []
+    for i in range(3):
+        data = next(fd).split()
+        vectors.append([float(data[j]) * Bohr for j in range(3)])
+
+    # Read number of atoms (line 4)
+    natoms = int(next(fd).split()[0])
+
+    # Read remaining lines
+    speciesnumber, atomnumbers, xyz, V = [], [], [], []
+    for line in fd:
+        if len(line) > 5:  # Ignore blank lines
+            data = line.split()
+            speciesnumber.append(int(data[0]))
+            atomnumbers.append(int(data[1]) % 200)
+            xyz.append([float(data[2 + j]) * Bohr for j in range(3)])
+            V.append([float(data[5 + j]) * Bohr for j in range(3)])
+
+    vectors = np.array(vectors)
+    atomnumbers = np.array(atomnumbers)
+    xyz = np.array(xyz)
+    atoms = Atoms(numbers=atomnumbers, positions=xyz, cell=vectors, pbc=True)
+    assert natoms == len(atoms)
+    return atoms
+
+
+def read_xv(fname):
+    with open(fname) as myfile:
+        atoms = read_siesta_xv(myfile)
+    return atoms
+
+
+def get_species(atoms, xc, rel="sr", accuracy="standard", fincore=False):
+    finder = DojoFinder()
+    elems = list(dict.fromkeys(atoms.get_chemical_symbols()).keys())
+    elem_dict = dict(zip(elems, range(1, len(elems) + 1)))
+    pseudo_path = finder.get_pp_path(xc=xc)
+    species = [
+        Species(
+            symbol=elem,
+            pseudopotential=finder.get_pp_fname(
+                elem, xc=xc, rel=rel, accuracy=accuracy, fincore=fincore
+            ),
+            ghost=False,
+        )
+        for elem in elem_dict.keys()
+    ]
+    return pseudo_path, species
+
+
+def cart2sph(vec):
+    x, y, z = vec
+    r = np.linalg.norm(vec)  # r
+    if r < 1e-10:
+        theta, phi = 0.0, 0.0
+    else:
+        # note that there are many conventions, here is the ISO convention.
+        phi = math.atan2(y, x) * 180 / math.pi  # phi
+        theta = math.acos(z / r) * 180 / math.pi  # theta
+    return r, theta, phi
+
+
+class MySiesta(Siesta):
+    def __init__(
+        self,
+        atoms=None,
+        command=None,
+        xc="LDA",
+        spin="non-polarized",
+        basis_set="DZP",
+        species=None,
+        ghosts=[],
+        synthetic_atoms={},
+        input_basis_set={},
+        pseudo_path=None,
+        input_pp={},
+        pp_accuracy="standard",
+        fincore=False,
+        **kwargs,
+    ):
+        # non-perturnbative polarized orbital.
+        self.npt_elems = set()
+
+        if fincore:
+            self.synthetic_atoms = synthetic_atoms_dict_fincore.copy()
+            self.synthetic_atoms.update(synthetic_atoms)
+        else:
+            self.synthetic_atoms = synthetic_atoms
+
+        if fincore:
+            input_basis_set.update(fincore_basis)
+        else:
+            input_basis_set.update(withf_basis)
+
+        if atoms is not None:
+            finder = DojoFinder()
+            elems = list(dict.fromkeys(atoms.get_chemical_symbols()).keys())
+            self.elem_dict = dict(zip(elems, range(1, len(elems) + 1)))
+            symbols = atoms.get_chemical_symbols()
+
+            # ghosts
+            ghost_symbols = [symbols[i] for i in ghosts]
+            ghost_elems = list(dict.fromkeys(ghost_symbols).keys())
+            tags = [1 if i in ghosts else 0 for i in range(len(atoms))]
+            atoms.set_tags(tags)
+
+            if pseudo_path is None:
+                pseudo_path = finder.get_pp_path(xc=xc, accuracy=pp_accuracy)
+
+            if spin == "spin-orbit":
+                rel = "fr"
+            else:
+                rel = "sr"
+            species = []
+            for elem, index in self.elem_dict.items():
+                if elem not in input_basis_set:
+                    bselem = basis_set
+                    if elem in ["Li", "Be", "Na", "Mg", "Sm"]:
+                        self.npt_elems.add(f"{elem}.{index}")
+                else:
+                    bselem = PAOBasisBlock(input_basis_set[elem])
+                if elem not in input_pp:
+                    pseudopotential = finder.get_pp_fname(
+                        elem, xc=xc, rel=rel, accuracy=pp_accuracy, fincore=fincore
+                    )
+                else:
+                    pseudopotential = os.path.join(pseudo_path, input_pp[elem])
+
+                if elem in self.synthetic_atoms:
+                    excess_charge = 0
+                else:
+                    excess_charge = None
+
+                species.append(
+                    Species(
+                        symbol=elem,
+                        pseudopotential=pseudopotential,
+                        basis_set=bselem,
+                        ghost=False,
+                        excess_charge=excess_charge,
+                    )
+                )
+            for elem in ghost_elems:
+                species.append(
+                    Species(
+                        symbol=elem,
+                        pseudopotential=finder.get_pp_fname(
+                            elem, xc=xc, rel=rel, accuracy=pp_accuracy, fincore=fincore
+                        ),
+                        tag=1,
+                        ghost=True,
+                    )
+                )
+
+        Siesta.__init__(
+            self,
+            xc=xc,
+            spin=spin,
+            atoms=atoms,
+            pseudo_path=pseudo_path,
+            species=species,
+            **kwargs,
+        )
+        self.set_npt_elements()
+        self.set_synthetic_atoms()
+
+    def _write_species(self, fd, atoms):
+        """Write input related the different species.
+
+        Parameters:
+            - f:     An open file object.
+            - atoms: An atoms object.
+        """
+        species, species_numbers = self.species(atoms)
+
+        if self["pseudo_path"] is not None:
+            pseudo_path = self["pseudo_path"]
+        elif "SIESTA_PP_PATH" in os.environ:
+            pseudo_path = os.environ["SIESTA_PP_PATH"]
+        else:
+            mess = "Please set the environment variable 'SIESTA_PP_PATH'"
+            raise Exception(mess)
+
+        fd.write(format_fdf("NumberOfSpecies", len(species)))
+        fd.write(format_fdf("NumberOfAtoms", len(atoms)))
+
+        pao_basis = []
+        chemical_labels = []
+        basis_sizes = []
+        synth_blocks = []
+        for species_number, spec in enumerate(species):
+            species_number += 1
+            symbol = spec["symbol"]
+            atomic_number = atomic_numbers[symbol]
+
+            if spec["pseudopotential"] is None:
+                if self.pseudo_qualifier() == "":
+                    label = symbol
+                    pseudopotential = label + ".psf"
+                else:
+                    label = ".".join([symbol, self.pseudo_qualifier()])
+                    pseudopotential = label + ".psf"
+            else:
+                pseudopotential = spec["pseudopotential"]
+                label = os.path.basename(pseudopotential)
+                label = ".".join(label.split(".")[:-1])
+
+            if not os.path.isabs(pseudopotential):
+                pseudopotential = join(pseudo_path, pseudopotential)
+
+            if not os.path.exists(pseudopotential):
+                mess = "Pseudopotential '%s' not found" % pseudopotential
+                raise RuntimeError(mess)
+
+            name = os.path.basename(pseudopotential)
+            name = name.split(".")
+            name.insert(-1, str(species_number))
+            if spec["ghost"]:
+                name.insert(-1, "ghost")
+                atomic_number = -atomic_number
+
+            name = ".".join(name)
+            pseudo_targetpath = self.getpath(name)
+
+            if join(os.getcwd(), name) != pseudopotential:
+                if islink(pseudo_targetpath) or isfile(pseudo_targetpath):
+                    os.remove(pseudo_targetpath)
+                symlink_pseudos = self["symlink_pseudos"]
+
+                symlink_pseudos = False
+
+                if symlink_pseudos is None:
+                    symlink_pseudos = not os.name == "nt"
+
+                if symlink_pseudos:
+                    os.symlink(pseudopotential, pseudo_targetpath)
+                else:
+                    shutil.copy(pseudopotential, pseudo_targetpath)
+            if spec["excess_charge"] is not None:
+                atomic_number += 200
+                # n_atoms = sum(np.array(species_numbers) == species_number)
+
+                # if spec["excess_charge"] != 0:
+                #     paec = float(spec["excess_charge"]) / n_atoms
+                #     vc = get_valence_charge(pseudopotential)
+                #     fraction = float(vc + paec) / vc
+                #     pseudo_head = name[:-4]
+                #     fractional_command = os.environ["SIESTA_UTIL_FRACTIONAL"]
+                #     cmd = "%s %s %.7f" % (fractional_command, pseudo_head, fraction)
+                #     os.system(cmd)
+                #
+                #     pseudo_head += "-Fraction-%.5f" % fraction
+                #     synth_pseudo = pseudo_head + ".psf"
+                #     synth_block_filename = pseudo_head + ".synth"
+                #     os.remove(name)
+                #     shutil.copyfile(synth_pseudo, name)
+                #     synth_block = read_vca_synth_block(
+                #         synth_block_filename, species_number=species_number
+                #     )
+                #     synth_blocks.append(synth_block)
+                # else:
+                #     synth_block = self.synthetic_atoms[symbol]
+                if symbol in self.synthetic_atoms:
+                    synth_block = self.synthetic_atoms[symbol]
+                    synth_blocks.append(synth_block)
+
+            if len(synth_blocks) > 0:
+                fd.write(format_fdf("SyntheticAtoms", list(synth_blocks)))
+
+            label = ".".join(np.array(name.split("."))[:-1])
+            string = "    %d %d %s" % (species_number, atomic_number, label)
+            chemical_labels.append(string)
+            if isinstance(spec["basis_set"], PAOBasisBlock):
+                pao_basis.append(spec["basis_set"].script(label))
+            else:
+                basis_sizes.append(("    " + label, spec["basis_set"]))
+        fd.write((format_fdf("ChemicalSpecieslabel", chemical_labels)))
+        fd.write("\n")
+        fd.write((format_fdf("PAO.Basis", pao_basis)))
+        fd.write((format_fdf("PAO.BasisSizes", basis_sizes)))
+        fd.write("\n")
+
+    def set_npt_elements(self):
+        if len(self.npt_elems) > 0:
+            npt_text = []
+            for name in self.npt_elems:
+                npt_text.append(f"{name} non-perturbative ")
+            # npt_text += "%endblock PAO.PolarizationScheme\n"
+            self["fdf_arguments"].update({"PAO.PolarizationScheme": npt_text})
+
+    def set_synthetic_atoms(self):
+        print("setting syn")
+        nsyn = len(self.synthetic_atoms)
+        if nsyn > 0:
+            syntext = []
+            # syntext.append(f"{nsyn}")
+            for name, content in self.synthetic_atoms.items():
+                if name in self.elem_dict:
+                    syntext.append(f"{self.elem_dict[name]}")
+                    syntext.append(" ".join([str(x) for x in content[0]]))
+                    syntext.append(" ".join([str(x) for x in content[1]]))
+            if len(syntext) > 0:
+                self["fdf_arguments"].update({"SyntheticAtoms": syntext})
+
+        # print("setting syn:", syntext)
+
+    def set_fdf_arguments(self, fdf_arguments):
+        self["fdf_arguments"].update(fdf_arguments)
+
+    def set_mixer(
+        self,
+        method="pulay",
+        weight=0.05,
+        history=10,
+        restart=25,
+        restart_save=4,
+        linear_after=0,
+        linear_after_weight=0.1,
+    ):
+        pass
+
+    def update_fdf_arguments(self, fdf_arguments):
+        self["fdf_arguments"].update(fdf_arguments)
+
+    def add_Hubbard_U(
+        self,
+        specy,
+        n=3,
+        l=2,  # noqa: E741
+        U=0,
+        J=0,
+        rc=0.0,
+        Fermi_cut=0.0,
+        scale_factor="0.95",
+    ):
+        if "Udict" not in self.__dict__:
+            self.Udict = dict()
+        idx = self.elem_dict[specy]
+        specy_label = f"{specy}.{idx}"
+        self.Udict[specy_label] = {
+            "n": n,
+            "l": l,
+            "U": U,
+            "J": J,
+            "rc": rc,
+            "Fermi_cut": Fermi_cut,
+            "scale_factor": scale_factor,
+        }
+        self.set_Hubbard_U(self.Udict)
+
+    def set_Hubbard_U(self, Udict):
+        """
+        Udict: {'Fe': {'n':n, 'l':l, 'U':U, 'J', J, 'rc':rc, 'Fermi_cut':Fermi_cut }}
+        """
+        Ublock = []
+        for key, val in Udict.items():
+            Ublock.append("  %s %s " % (key, 1))
+            if val["n"] is not None:
+                Ublock.append("  n=%s %s" % (val["n"], val["l"]))
+            else:
+                Ublock.append("%s" % (val["l"]))
+            Ublock.append("  %s  %s" % (val["U"], val["J"]))
+            if "rc" in val:
+                Ublock.append("  %s  %s" % (val["rc"], val["Fermi_cut"]))
+            Ublock.append("    %s" % val["scale_factor"])
+
+        self.update_fdf_arguments(
+            {"LDAU.Proj": Ublock, "LDAU.ProjectorGenerationMethod": 2}
+        )
+
+    def set_Udict(self, Udict):
+        """
+        Udict: e.g. {"Fe":{"n":3, "l":2, "U":3.0, "J":0.0}, ...}
+        or {"Fe":{[3, 2, 3, 0]}
+
+        """
+        for specy, val in Udict.items():
+            if isinstance(val, dict):
+                self.add_Hubbard_U(specy, **val)
+            else:
+                self.add_Hubbard_U(specy, *val)
+
+    def write_Hubbard_block(self, f):
+        pass
+
+    def relax(
+        self,
+        atoms,
+        TypeOfRun="Broyden",
+        VariableCell=True,
+        ConstantVolume=False,
+        RelaxCellOnly=False,
+        MaxForceTol=0.001,
+        MaxStressTol=1,
+        NumCGSteps=40,
+        relaxed_file="relaxed.vasp",
+    ):
+        pbc = atoms.get_pbc()
+        initial_magnetic_moments = atoms.get_initial_magnetic_moments()
+        self.update_fdf_arguments(
+            {
+                "MD.TypeOfRun": TypeOfRun,
+                "MD.VariableCell": VariableCell,
+                "MD.ConstantVolume": ConstantVolume,
+                "MD.RelaxCellOnly": RelaxCellOnly,
+                "MD.MaxForceTol": "%s eV/Ang" % MaxForceTol,
+                "MD.MaxStressTol": "%s GPa" % MaxStressTol,
+                "MD.NumCGSteps": NumCGSteps,
+            }
+        )
+        self.calculate(atoms)
+        # self.read(self.prefix + '.XV')
+        self.atoms = read_xv(os.path.join(self.directory, self.prefix + ".XV"))
+        self.atoms.set_pbc(pbc)
+        self.atoms.set_initial_magnetic_moments(initial_magnetic_moments)
+        atoms = self.atoms
+        self.update_fdf_arguments(
+            {
+                "MD.NumCGSteps": 0,
+            }
+        )
+        if relaxed_file is not None:
+            write(relaxed_file, atoms, vasp5=True, sort=False)
+        return self.atoms
+
+    def scf_calculation(self, atoms, dos=True, kpts=[7, 7, 7], **kwargs):
+        if dos:
+            k1, k2, k3 = kpts
+            self.update_fdf_arguments(
+                {
+                    "WriteEigenvalues": ".true.",
+                    "ProjectedDensityOfStates": ["-70.00 30.0 0.015 3000 eV"],
+                    "PDOS.kgrid_Monkhorst_Pack": [
+                        f"{k1} 0 0 0.0",
+                        f"0 {k2} 0 0.0",
+                        f"0 0 {k3} 0.0",
+                    ],
+                }
+            )
+        self.calculate(atoms, **kwargs)
+
+    def _write_structure(self, f, atoms):
+        """Translate the Atoms object to fdf-format.
+
+        Parameters:
+            - f:     An open file object.
+            - atoms: An atoms object.
+        """
+        cell = atoms.cell
+        f.write("\n")
+
+        if cell.rank in [1, 2]:
+            raise ValueError(
+                "Expected 3D unit cell or no unit cell.  You may "
+                "wish to add vacuum along some directions."
+            )
+
+        # Write lattice vectors
+        if np.any(cell):
+            f.write(format_fdf("LatticeConstant", "1.0 Ang"))
+            f.write("%block LatticeVectors\n")
+            for i in range(3):
+                for j in range(3):
+                    s = ("    %.15f" % cell[i, j]).rjust(16) + " "
+                    f.write(s)
+                f.write("\n")
+            f.write("%endblock LatticeVectors\n")
+            f.write("\n")
+
+        self._write_atomic_coordinates(f, atoms)
+
+        # Write magnetic moments.
+        magmoms = atoms.get_initial_magnetic_moments()
+
+        # The DM.InitSpin block must be written to initialize to
+        # no spin. SIESTA default is FM initialization, if the
+        # block is not written, but  we must conform to the
+        # atoms object.
+        if magmoms is not None:
+            if len(magmoms) == 0:
+                f.write("#Empty block forces ASE initialization.\n")
+
+            f.write("%block DM.InitSpin\n")
+            if len(magmoms) != 0 and isinstance(magmoms[0], np.ndarray):
+                for n, Mcart in enumerate(magmoms):
+                    M = cart2sph(Mcart)
+                    if M[0] != 0:
+                        f.write(
+                            "    %d %.14f %.14f %.14f \n" % (n + 1, M[0], M[1], M[2])
+                        )
+            elif len(magmoms) != 0 and isinstance(magmoms[0], float):
+                for n, M in enumerate(magmoms):
+                    if M != 0:
+                        f.write("    %d %.14f \n" % (n + 1, M))
+            f.write("%endblock DM.InitSpin\n")
+            f.write("\n")
+
+    def my_read_results(self):
+        """Read the results."""
+        # self.read_number_of_grid_points()
+        self.read_energy()
+        self.read_forces_stress()
+        # self.read_eigenvalues()
+        self.read_kpoints()
+        self.read_dipole()
+        self.read_pseudo_density()
+        # self.read_hsx()
+        self.read_dim()
+        # if self.results['hsx'] is not None:
+        #    self.read_pld(self.results['hsx'].norbitals,
+        #                  len(self.atoms))
+        #    self.atoms.cell = self.results['pld'].cell * Bohr
+        # else:
+        #    self.results['pld'] = None
+
+        # self.read_wfsx()
+        self.read_ion(self.atoms)
+
+        self.read_bands()

TB2Jflows/siesta_basis.py

@@ -0,0 +1,47 @@
+withf_basis = {
+    # "La": "5\nn=5  0  1\n3.889 \n1.0 \nn=6  0  2\n9.113 6.906 \n1.0 1.0 \nn=5  1  1\n4.548 \n1.0 \nn=6  1  1\n9.113 \n1.0 \nn=5  2  2\n7.55 5.398 \n1.0 1.0 \n",
+    "Ce": "6\nn=5  0  1\n3.805 \n1.0 \nn=6  0  2\n9.041 6.837 \n1.0 1.0 \nn=5  1  1\n4.458 \n1.0 \nn=6  1  1\n9.041 \n1.0 \nn=5  2  2\n7.489 5.339 \n1.0 1.0 \nn=4  3  2\n4.114 2.494 \n1.0 1.0 \n",
+    "Pr": "6\nn=5  0  1\n3.737 \n1.0 \nn=6  0  2\n8.879 6.702 \n1.0 1.0 \nn=5  1  1\n4.387 \n1.0 \nn=6  1  1\n8.879 \n1.0 \nn=5  2  2\n7.46 5.307 \n1.0 1.0 \nn=4  3  2\n3.944 2.369 \n1.0 1.0 \n",
+    "Nd": "6\nn=5  0  1\n3.67 \n1.0 \nn=6  0  2\n8.808 6.641 \n1.0 1.0 \nn=5  1  1\n4.317 \n1.0 \nn=6  1  1\n8.808 \n1.0 \nn=5  2  2\n7.445 5.285 \n1.0 1.0 \nn=4  3  2\n3.805 2.271 \n1.0 1.0 \n",
+    "Pm": "6\nn=5  0  1\n3.611 \n1.0 \nn=6  0  2\n8.756 6.588 \n1.0 1.0 \nn=5  1  1\n4.257 \n1.0 \nn=6  1  1\n8.756 \n1.0 \nn=5  2  2\n7.43 5.269 \n1.0 1.0 \nn=4  3  2\n3.692 2.189 \n1.0 1.0 \n",
+    "Sm": "6\nn=5  0  1\n3.554 \n1.0 \nn=6  0  2\n8.668 6.516 \n1.0 1.0 \nn=5  1  1\n4.197 \n1.0 \nn=6  1  1\n8.668 \n1.0 \nn=5  2  2\n7.445 5.269 \n1.0 1.0 \nn=4  3  2\n3.59 2.115 \n1.0 1.0 \n",
+    "Eu": "6\nn=5  0  1\n3.497 \n1.0 \nn=6  0  2\n8.599 6.458 \n1.0 1.0 \nn=5  1  1\n4.139 \n1.0 \nn=6  1  1\n8.599 \n1.0 \nn=5  2  2\n7.46 5.275 \n1.0 1.0 \nn=4  3  2\n3.504 2.052 \n1.0 1.0 \n",
+    "Gd": "6\nn=5  0  1\n3.442 \n1.0 \nn=6  0  2\n8.514 6.374 \n1.0 1.0 \nn=5  1  1\n4.089 \n1.0 \nn=6  1  1\n8.514 \n1.0 \nn=5  2  2\n7.489 5.285 \n1.0 1.0 \nn=4  3  2\n3.435 1.997 \n1.0 1.0 \n",
+    "Tb": "6\nn=5  0  1\n3.394 \n1.0 \nn=6  0  2\n8.395 6.279 \n1.0 1.0 \nn=5  1  1\n4.04 \n1.0 \nn=6  1  1\n8.395 \n1.0 \nn=5  2  2\n7.52 5.301 \n1.0 1.0 \nn=4  3  2\n3.366 1.948 \n1.0 1.0 \n",
+    "Dy": "6\nn=5  0  1\n3.346 \n1.0 \nn=6  0  2\n8.295 6.186 \n1.0 1.0 \nn=5  1  1\n3.992 \n1.0 \nn=6  1  1\n8.295 \n1.0 \nn=5  2  2\n7.565 5.323 \n1.0 1.0 \nn=4  3  2\n3.306 1.901 \n1.0 1.0 \n",
+    "Ho": "6\nn=5  0  1\n3.293 \n1.0 \nn=6  0  2\n8.179 6.093 \n1.0 1.0 \nn=5  1  1\n3.944 \n1.0 \nn=6  1  1\n8.179 \n1.0 \nn=5  2  2\n7.61 5.349 \n1.0 1.0 \nn=4  3  2\n3.254 1.86 \n1.0 1.0 \n",
+    "Er": "6\nn=5  0  1\n3.247 \n1.0 \nn=6  0  2\n8.049 5.972 \n1.0 1.0 \nn=5  1  1\n3.897 \n1.0 \nn=6  1  1\n8.049 \n1.0 \nn=5  2  2\n7.656 5.387 \n1.0 1.0 \nn=4  3  2\n3.208 1.821 \n1.0 1.0 \n",
+    "Tm": "6\nn=5  0  1\n3.202 \n1.0 \nn=6  0  2\n7.921 5.872 \n1.0 1.0 \nn=5  1  1\n3.858 \n1.0 \nn=6  1  1\n7.921 \n1.0 \nn=5  2  2\n7.718 5.419 \n1.0 1.0 \nn=4  3  2\n3.163 1.785 \n1.0 1.0 \n",
+    "Yb": "6\nn=5  0  1\n3.163 \n1.0 \nn=6  0  2\n7.796 5.761 \n1.0 1.0 \nn=5  1  1\n3.812 \n1.0 \nn=6  1  1\n7.796 \n1.0 \nn=5  2  2\n7.78 5.468 \n1.0 1.0 \nn=4  3  2\n3.119 1.753 \n1.0 1.0 \n",
+}
+
+fincore_basis = {
+    # "La": "4\nn=5  0  1\n3.889 \n1.0 \nn=6  0  2\n9.113 6.906 \n1.0 1.0 \nn=5  1  1\n4.548 \n1.0 \nn=6  1  1\n9.113 \n1.0 \nn=5  2  2\n7.55 5.398 \n1.0 1.0 \n",
+    "Ce": "5\nn=5  0  1\n3.805 \n1.0 \nn=6  0  2\n8.968 6.776 \n1.0 1.0 \nn=5  1  1\n4.458 \n1.0 \nn=6  1  1\n8.968 \n1.0 \nn=5  2  2\n7.489 5.339 \n1.0 1.0 \n",
+    "Pr": "5\nn=5  0  1\n3.737 \n1.0 \nn=6  0  2\n8.791 6.621 \n1.0 1.0 \nn=5  1  1\n4.387 \n1.0 \nn=6  1  1\n8.791 \n1.0 \nn=5  2  2\n7.46 5.307 \n1.0 1.0 \n",
+    "Nd": "5\nn=5  0  1\n3.67 \n1.0 \nn=6  0  2\n8.634 6.49 \n1.0 1.0 \nn=5  1  1\n4.317 \n1.0 \nn=6  1  1\n8.634 \n1.0 \nn=5  2  2\n7.445 5.285 \n1.0 1.0 \n",
+    "Pm": "5\nn=5  0  1\n3.611 \n1.0 \nn=6  0  2\n8.446 6.33 \n1.0 1.0 \nn=5  1  1\n4.257 \n1.0 \nn=6  1  1\n8.446 \n1.0 \nn=5  2  2\n7.43 5.269 \n1.0 1.0 \n",
+    "Sm": "5\nn=5  0  1\n3.554 \n1.0 \nn=6  0  2\n8.328 6.223 \n1.0 1.0 \nn=5  1  1\n4.197 \n1.0 \nn=6  1  1\n8.328 \n1.0 \nn=5  2  2\n7.445 5.269 \n1.0 1.0 \n",
+    "Eu": "5\nn=5  0  1\n3.497 \n1.0 \nn=6  0  2\n8.278 6.186 \n1.0 1.0 \nn=5  1  1\n4.139 \n1.0 \nn=6  1  1\n8.278 \n1.0 \nn=5  2  2\n7.46 5.275 \n1.0 1.0 \n",
+    "Gd": "5\nn=5  0  1\n3.442 \n1.0 \nn=6  0  2\n8.278 6.179 \n1.0 1.0 \nn=5  1  1\n4.089 \n1.0 \nn=6  1  1\n8.278 \n1.0 \nn=5  2  2\n7.489 5.285 \n1.0 1.0 \n",
+    "Tb": "5\nn=5  0  1\n3.394 \n1.0 \nn=6  0  2\n8.147 6.063 \n1.0 1.0 \nn=5  1  1\n4.04 \n1.0 \nn=6  1  1\n8.147 \n1.0 \nn=5  2  2\n7.52 5.301 \n1.0 1.0 \n",
+    "Dy": "5\nn=5  0  1\n3.346 \n1.0 \nn=6  0  2\n7.969 5.919 \n1.0 1.0 \nn=5  1  1\n3.992 \n1.0 \nn=6  1  1\n7.969 \n1.0 \nn=5  2  2\n7.565 5.323 \n1.0 1.0 \n",
+    "Ho": "5\nn=5  0  1\n3.293 \n1.0 \nn=6  0  2\n7.827 5.79 \n1.0 1.0 \nn=5  1  1\n3.944 \n1.0 \nn=6  1  1\n7.827 \n1.0 \nn=5  2  2\n7.61 5.349 \n1.0 1.0 \n",
+    "Er": "5\nn=5  0  1\n3.247 \n1.0 \nn=6  0  2\n7.626 5.624 \n1.0 1.0 \nn=5  1  1\n3.897 \n1.0 \nn=6  1  1\n7.626 \n1.0 \nn=5  2  2\n7.656 5.387 \n1.0 1.0 \n",
+    "Tm": "5\nn=5  0  1\n3.202 \n1.0 \nn=6  0  2\n7.474 5.49 \n1.0 1.0 \nn=5  1  1\n3.858 \n1.0 \nn=6  1  1\n7.474 \n1.0 \nn=5  2  2\n7.718 5.419 \n1.0 1.0 \n",
+    "Yb": "5\nn=5  0  1\n3.163 \n1.0 \nn=6  0  2\n7.312 5.36 \n1.0 1.0 \nn=5  1  1\n3.812 \n1.0 \nn=6  1  1\n7.312 \n1.0 \nn=5  2  2\n7.78 5.468 \n1.0 1.0 \n",
+}
+
+
+def get_basis(element, fincore=False):
+    if not fincore:
+        return withf_basis[element]
+    else:
+        return fincore_basis[element]
+
+
+if __name__ == "__main__":
+    print(get_basis("La"))
+    print(get_basis("La", fincore=True))
+    print(get_basis("Ce"))
+    print(get_basis("Ce", fincore=True))

TB2Jflows/siesta_spinphonon.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+Spin-phonon coupling calculation workflow using SIESTA and TB2J.
+
+This module generates distorted structures from phonon modes and computes
+exchange parameters for each structure.
+
+Purpose:
+    Compute exchange parameters as a function of phonon mode amplitude
+    to study spin-phonon coupling.
+
+How to run:
+    python -m TB2Jflows.siesta_spinphonon
+
+Expected behavior:
+    For each amplitude, generates a distorted structure and runs SIESTA+TB2J
+    to compute exchange parameters.
+"""
+
+from pathlib import Path
+from typing import Callable, List, Optional, Union
+
+# Import from phononkit
+from phononkit import generate_structure_for_mode, load_from_phonopy_yaml
+
+from TB2Jflows import auto_siesta_TB2J
+
+
+def compute_spinphonon_coupling(
+    phonon_yaml: str,
+    qpoint: list,
+    mode_index: int,
+    amplitudes: list,
+    supercell: Union[List[int], List[List[int]], None] = None,
+    base_path: str = "./spinphonon_results",
+    spin: str = "collinear",
+    magnetic_elements: Optional[List[str]] = None,
+    Udict: Optional[dict] = None,
+    xc: str = "PBE",
+    kmesh: Optional[List[int]] = None,
+    relax: bool = False,
+    scf: bool = True,
+    TB2J: bool = True,
+    rotate_type: str = "structure",
+    fincore: bool = True,
+    siesta_kwargs: Optional[dict] = None,
+    TB2J_kwargs: Optional[dict] = None,
+    fdf_kwargs: Optional[dict] = None,
+    prepare_atoms_callback: Optional[Callable] = None,
+):
+    """
+    Compute exchange parameters for phonon-distorted structures.
+
+    This function generates distorted structures from a phonon mode at different
+    amplitudes and computes exchange parameters using SIESTA and TB2J for each.
+
+    Parameters:
+        phonon_yaml: Path to phonopy YAML file containing phonon data
+        qpoint: Q-point coordinates [qx, qy, qz] in reduced coordinates
+                (e.g., [0, 0, 0] for Gamma point)
+        mode_index: Index of the phonon mode at the specified q-point (0-based)
+        amplitudes: List of displacement amplitudes in Angstroms
+                   (e.g., [0.1, 0.2, 0.3, 0.4, 0.5])
+        supercell: Supercell specification (optional):
+                  - 3-vector [n1, n2, n3] for diagonal matrix (e.g., [2, 2, 2])
+                  - Full 3x3 matrix [[n1, 0, 0], [0, n2, 0], [0, 0, n3]]
+                  - If None, uses primitive cell
+        base_path: Base directory for output files
+        spin: Spin type ('collinear', 'noncollinear', 'spinorbit')
+        magnetic_elements: List of magnetic element symbols (if None, auto-detect)
+        Udict: Dictionary of Hubbard U parameters {element: U_value}
+        xc: Exchange-correlation functional
+        kmesh: K-point mesh [nk1, nk2, nk3] (if None, auto-generate)
+        relax: Whether to perform structural relaxation
+        scf: Whether to run SCF calculation
+        TB2J: Whether to run TB2J calculation
+        rotate_type: Type of rotation for non-collinear calculations
+        fincore: Whether to use frozen core approximation
+        siesta_kwargs: Additional SIESTA parameters
+        TB2J_kwargs: Additional TB2J parameters
+        fdf_kwargs: Additional FDF file parameters
+        prepare_atoms_callback: Optional callback function to modify atoms
+                               before calculation (e.g., set magnetic moments)
+
+    Returns:
+        dict: Dictionary mapping amplitudes to their calculation directories
+
+    Examples:
+        >>> # Compute exchange for Gamma-point mode 3 at various amplitudes
+        >>> results = compute_spinphonon_coupling(
+        ...     phonon_yaml='phonopy.yaml',
+        ...     qpoint=[0, 0, 0],
+        ...     mode_index=3,
+        ...     amplitudes=[0.1, 0.2, 0.3, 0.4, 0.5],
+        ...     supercell=[2, 2, 2],
+        ...     magnetic_elements=['Fe', 'Co'],
+        ...     Udict={'Fe': 4.0, 'Co': 4.5}
+        ... )
+
+        >>> # Use results
+        >>> for amp, calc_dir in results.items():
+        ...     print(f"Amplitude {amp} Å: {calc_dir}")
+    """
+    # Set defaults
+    if Udict is None:
+        Udict = {}
+    if siesta_kwargs is None:
+        siesta_kwargs = {}
+    if TB2J_kwargs is None:
+        TB2J_kwargs = {}
+    if fdf_kwargs is None:
+        fdf_kwargs = {}
+
+    # Create base directory
+    path_obj = Path(base_path)
+    path_obj.mkdir(parents=True, exist_ok=True)
+
+    # Load phonon data to get the structure
+    print(f"Loading phonon data from: {phonon_yaml}")
+    structure, modes = load_from_phonopy_yaml(phonon_yaml)
+
+    # Auto-detect magnetic elements if not provided
+    if magnetic_elements is None:
+        # For now, assume all unique elements with initial magnetic moments
+        # User should provide this explicitly
+        magnetic_elements = list(set(structure.get_chemical_symbols()))
+        print(f"Warning: Auto-detected magnetic elements: {magnetic_elements}")
+        print("Consider providing magnetic_elements explicitly")
+
+    # Dictionary to store results
+    results = {}
+
+    # Loop over amplitudes
+    for amplitude in amplitudes:
+        print("=" * 70)
+        print(f"Processing amplitude: {amplitude} Å")
+        print("=" * 70)
+
+        # Generate distorted structure
+        print("Generating distorted structure...")
+        print(f"  Q-point: {qpoint}")
+        print(f"  Mode index: {mode_index}")
+        print(f"  Amplitude: {amplitude} Å")
+        if supercell is not None:
+            print(f"  Supercell: {supercell}")
+
+        try:
+            distorted_atoms = generate_structure_for_mode(
+                yaml_path=phonon_yaml,
+                qpoint=qpoint,
+                mode_index=mode_index,
+                amplitude=amplitude,
+                supercell=supercell,
+            )
+            print(f"  Generated structure with {len(distorted_atoms)} atoms")
+
+            # Apply callback if provided
+            if prepare_atoms_callback is not None:
+                distorted_atoms = prepare_atoms_callback(distorted_atoms)
+
+        except Exception as e:
+            print(f"Error generating structure for amplitude {amplitude}: {e}")
+            continue
+
+        # Create calculation directory
+        calc_dir = path_obj / f"amplitude_{amplitude:.4f}"
+        calc_dir.mkdir(parents=True, exist_ok=True)
+
+        print(f"Running SIESTA+TB2J calculation in: {calc_dir}")
+
+        # Run auto_siesta_TB2J
+        try:
+            auto_siesta_TB2J(
+                path=str(calc_dir),
+                atoms=distorted_atoms,
+                spin=spin,
+                elems=magnetic_elements,
+                Udict=Udict,
+                xc=xc,
+                kmesh=kmesh,
+                split_soc=False,
+                relax=relax,
+                scf=scf,
+                TB2J=TB2J,
+                rotate_type=rotate_type,
+                fincore=fincore,
+                siesta_kwargs=siesta_kwargs,
+                TB2J_kwargs=TB2J_kwargs,
+                fdf_kwargs=fdf_kwargs,
+            )
+            results[amplitude] = str(calc_dir)
+            print(f"✓ Completed calculation for amplitude {amplitude} Å")
+        except Exception as e:
+            print(f"✗ Error running calculation for amplitude {amplitude}: {e}")
+            continue
+
+    # Summary
+    print("\n" + "=" * 70)
+    print("Spin-Phonon Coupling Calculation Summary")
+    print("=" * 70)
+    print(f"Total amplitudes processed: {len(results)}/{len(amplitudes)}")
+    print(f"Results stored in: {path_obj}")
+    print("\nCompleted calculations:")
+    for amp, calc_dir in sorted(results.items()):
+        print(f"  {amp:.4f} Å → {calc_dir}")
+
+    return results
+
+
+def main():
+    """
+    Example usage of compute_spinphonon_coupling.
+
+    This example shows how to compute exchange parameters for a phonon mode
+    at multiple amplitudes. Users should modify the parameters below for
+    their specific calculation.
+    """
+    # Example parameters - MODIFY THESE FOR YOUR CALCULATION
+    phonon_yaml = "phonopy.yaml"
+    qpoint = [0, 0, 0]  # Gamma point
+    mode_index = 3  # Fourth mode (0-indexed)
+    amplitudes = [0.1, 0.2, 0.3, 0.4, 0.5]  # Amplitudes in Angstroms
+    supercell = [2, 2, 2]  # 2x2x2 supercell
+    magnetic_elements = ["Fe"]  # Magnetic elements
+    Udict = {"Fe": 4.0}  # Hubbard U parameters
+
+    compute_spinphonon_coupling(
+        phonon_yaml=phonon_yaml,
+        qpoint=qpoint,
+        mode_index=mode_index,
+        amplitudes=amplitudes,
+        supercell=supercell,
+        base_path="./spinphonon_results",
+        spin="collinear",
+        magnetic_elements=magnetic_elements,
+        Udict=Udict,
+        xc="PBE",
+        kmesh=None,  # Auto-generate
+        relax=False,
+        scf=True,
+        TB2J=True,
+        rotate_type="structure",
+    )
+
+    print("\n" + "=" * 70)
+    print("Calculation complete!")
+    print("=" * 70)
+    print("Next steps:")
+    print("1. Check the results in the output directories")
+    print("2. Extract exchange parameters from TB2J output files")
+    print("3. Plot exchange parameters vs. amplitude to study spin-phonon coupling")
+
+
+if __name__ == "__main__":
+    main()

tb2jflows-0.2.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: TB2Jflows
+Version: 0.2.0
+Summary: TB2Jflows: Workflows for automatically calculation of exchange parameters using TB2J
+Author-email: Xu He <mailhexu@gmail.com>
+License: BSD-2-clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.6
+Requires-Dist: ase
+Requires-Dist: sisl
+Requires-Dist: tb2j
+Description-Content-Type: text/markdown
+
+# TB2Jflows
+Workflows for automatically calculation of exchange parameters from DFT
+
+## Installation
+
+First download the package from the github page. Run the following command in the TB2Jflows directory
+
+```
+pip install . --user
+```
+
+will install TB2Jflows and the dependencies.
+
+You need the following things to 
+
+- Siesta built with psml and netcdf.
+- Pseudopotentials from PseudoDojo Dataset. 
+- Configure the command to run siesta and the path to the pseudopotentials, e.g.
+
+```
+export ASE_IESTA_COMMAND="mpirun siesta < PREFIX.fdf > PREFIX.out 2> PREFIX.err"
+export DOJO_PATH='$HOME/.local/pp/dojo'
+```
+
+## Usage
+
+Below is an example of calculating the exchange parameters of SrMnO3:
+
+```python
+from ase.io import read
+from TB2Jflows import SiestaFlow
+
+
+def calculate_siesta_TB2J_SrMnO3():
+    atoms = read('SrMnO3.STRUCT_OUT')
+    atoms.set_initial_magnetic_moments([0, 3, 0, 0, 0])
+    flow = SiestaFlow(atoms,
+                      spin='spin-orbit',
+                      restart=True,
+                      root_path='SrMnO3')
+    flow.write_metadata()
+    atoms = flow.relax(atoms)
+    flow.scf_calculation_with_rotations(atoms)
+    flow.run_TB2J(magnetic_elements='Mn',
+                  nz=50,
+                  kmesh=[7, 7, 7],
+                  Rcut=18,
+                  np=10,
+                  use_cache=True)
+    flow.run_TB2J_merge()
+
+
+if __name__ == '__main__':
+    calculate_siesta_TB2J_SrMnO3()
+~                                     
+```
+

tb2jflows-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+TB2Jflows/__init__.py,sha256=hRwR95ChyiFkUTX2djY2hQI9ph7x2YIJxiOehvxe79I,242
+TB2Jflows/ase_siesta.py,sha256=d8Li-zwUGlulT0haEIKLSSgsveMU6YzV0thrFnDhV2U,14359
+TB2Jflows/auto_siesta_TB2J.py,sha256=c5dviznEbXyO3BJbh-LNBlC9efT7YbdC7ydWxyCJZ5E,3113
+TB2Jflows/find_pp.py,sha256=Od8Zb-Rd0kDC6ALBa39knYFNVKfNxhZx9OLocOS8YUA,2435
+TB2Jflows/mysiesta.py,sha256=IUgfNu_X9rmX_CkqNsHrwFk3Hp8o5Wlp7Fd19PaCZPw,19518
+TB2Jflows/run_abacus.py,sha256=96tZ2n02FFLl8IZf4W_4TvkCcsd6oS1FVEIqhZpY76o,2692
+TB2Jflows/siesta_basis.py,sha256=ysGZUfjwuoOGImj0k-pDicKKG_o6Me0hzJqf5p5x9MQ,5319
+TB2Jflows/siesta_spinphonon.py,sha256=jgTTtyWoJMnhyEJdWMnJ7pjxc6EM_aKEeu_-EgbtUFs,9037
+tb2jflows-0.2.0.dist-info/METADATA,sha256=3Sy89-TX_nkmlZOxbCekV4sVrreG5q-cl9iNm1iX6Ho,2170
+tb2jflows-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tb2jflows-0.2.0.dist-info/licenses/LICENSE,sha256=KNu68sa-XR_2jZJKhDcSnxoNve8jtHgkw_w9PjP1YOk,1315
+tb2jflows-0.2.0.dist-info/RECORD,,

{tb2jflows-0.2.dist-info → tb2jflows-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

tb2jflows-0.2.dist-info/METADATA

@@ -1,31 +0,0 @@
-Metadata-Version: 2.4
-Name: TB2Jflows
-Version: 0.2
-Summary: TB2Jflows: Workflows for automatically calculation of exchange parameters using TB2J
-Author: Xu He
-Author-email: mailhexu@gmail.com
-License: BSD-2-clause
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Chemistry
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: License :: OSI Approved :: BSD License
-Requires-Python: >=3.6
-License-File: LICENSE
-Requires-Dist: TB2J
-Requires-Dist: ase
-Requires-Dist: sisl
-Requires-Dist: pyDFTutils
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
- TB2Jflows: Workflows for automatically calculation of exchange parameters using TB2J 

tb2jflows-0.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-TB2Jflows/__init__.py,sha256=0aRVj9v-u64LxJl7Cyxcr4YUjpeMkBGPuv-nJbxbHOg,100
-TB2Jflows/ase_siesta.py,sha256=tHeiKWszra8sjcJ_7Pq0cOBUC1ZEluRNEeHGj35Oz6M,14476
-TB2Jflows/auto_siesta_TB2J.py,sha256=o1A5Qf0Ru35BY5jwSAIQ2rPXD1mb572LEAQfgNfEVnM,3174
-TB2Jflows/run_abacus.py,sha256=96tZ2n02FFLl8IZf4W_4TvkCcsd6oS1FVEIqhZpY76o,2692
-tb2jflows-0.2.dist-info/licenses/LICENSE,sha256=KNu68sa-XR_2jZJKhDcSnxoNve8jtHgkw_w9PjP1YOk,1315
-tb2jflows-0.2.dist-info/METADATA,sha256=l2Lsj-MqAlL7fizCsUsD94RaqGpg6D-F-1HtmaOesL8,967
-tb2jflows-0.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-tb2jflows-0.2.dist-info/top_level.txt,sha256=iYRLHB7ZeHb59fEZLnbqJDymBKWPqfVgmvqd9S51Txw,10
-tb2jflows-0.2.dist-info/RECORD,,

tb2jflows-0.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-TB2Jflows