TB2Jflows 0.1.0__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__(
@@ -32,6 +33,7 @@ class SiestaFlow:
         self.xc = xc
         self.kpts = kpts
         self.Udict = Udict
+
         # default fdf arguments
         self.fdf_arguments = {
             "MaxSCFIterations": 350,

TB2Jflows/find_pp.py

@@ -1,67 +1,91 @@
 import os
-from ase.data import chemical_symbols, atomic_numbers
 
+from ase.data import atomic_numbers
 
-class PPFinder():
+
+class PPFinder:
     def __init__(self):
         pass
 
     def get_pp_path(self, element, xc, label, rel):
         pass
 
-class DojoFinder():
+
+class DojoFinder:
     def __init__(self, path=None):
         if path is None:
-            self.path = os.environ['DOJO_PATH']
+            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="pw"
-        dirname = os.path.join(self.path, f"{typ}-{rel}-{version}_{xc}_{accuracy}_{fmt}")
+    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:
+    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}")
+                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}")
+                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}")
+            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'))
-    fname=finder.get_pp_path(element='Sr', xc='pbesol')
-    fname=finder.get_pp_path(element='Srg', xc='pbe')
+    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__':
+if __name__ == "__main__":
     test()

TB2Jflows/mysiesta.py

@@ -1,35 +1,52 @@
-import os
 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.calculator import FileIOCalculator, ReadError
-from ase.calculators.siesta.parameters import format_fdf
-from ase.calculators.siesta.parameters import Species, PAOBasisBlock
+from ase.calculators.siesta.parameters import PAOBasisBlock, Species, format_fdf
+from ase.data import atomic_numbers
 from ase.io import write
-import copy
+from ase.units import Bohr
 
-import shutil
-from os.path import join, isfile, islink
-import numpy as np
-from ase.units import Ry, eV, Bohr
-from ase.data import atomic_numbers
-#from ase.io.siesta import read_siesta_xv
-#from ase.calculators.siesta.import_functions import \
-#    get_valence_charge, read_vca_synth_block
-from ase.calculators.calculator import FileIOCalculator, ReadError
-from ase.calculators.calculator import Parameters, all_changes
-from ase.calculators.siesta.parameters import PAOBasisBlock, Species
-from ase.calculators.siesta.parameters import format_fdf
-#from pyDFTutils.siesta.pdos import gen_pdos_figure, plot_layer_pdos 
+from .find_pp import DojoFinder
 
-from .siesta_basis  import get_basis, fincore_basis, withf_basis
-from .findpp import DojoFinder
+# from pyDFTutils.siesta.pdos import gen_pdos_figure, plot_layer_pdos
+from .siesta_basis import fincore_basis, withf_basis
 
 
-synthetic_atoms_dict_fincore={
-        "Yb":((6,5,5,5), (2,6,1,0))
-        }
+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 = []
@@ -46,69 +63,80 @@ def read_siesta_xv(fd):
         if len(line) > 5:  # Ignore blank lines
             data = line.split()
             speciesnumber.append(int(data[0]))
-            atomnumbers.append(int(data[1])%200)
+            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)
+    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)
+        atoms = read_siesta_xv(myfile)
     return atoms
 
 
-def get_species(atoms, xc, rel='sr', accuracy='standard'):
+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()
+        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
+    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
+        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):
+    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()
-        self.synthetic_atoms=synthetic_atoms
+
+        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)
@@ -130,52 +158,60 @@ class MySiesta(Siesta):
             if pseudo_path is None:
                 pseudo_path = finder.get_pp_path(xc=xc, accuracy=pp_accuracy)
 
-            if spin == 'spin-orbit':
-                rel = 'fr'
+            if spin == "spin-orbit":
+                rel = "fr"
             else:
-                rel = 'sr'
+                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']:
+                    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)
+                        elem, xc=xc, rel=rel, accuracy=pp_accuracy, fincore=fincore
+                    )
                 else:
-                    pseudopotential = os.path.join(
-                        pseudo_path, input_pp[elem])
+                    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))
+                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)
+                    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()
 
@@ -188,16 +224,16 @@ class MySiesta(Siesta):
         """
         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']
+        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)))
+        fd.write(format_fdf("NumberOfSpecies", len(species)))
+        fd.write(format_fdf("NumberOfAtoms", len(atoms)))
 
         pao_basis = []
         chemical_labels = []
@@ -205,20 +241,20 @@ class MySiesta(Siesta):
         synth_blocks = []
         for species_number, spec in enumerate(species):
             species_number += 1
-            symbol = spec['symbol']
+            symbol = spec["symbol"]
             atomic_number = atomic_numbers[symbol]
 
-            if spec['pseudopotential'] is None:
-                if self.pseudo_qualifier() == '':
+            if spec["pseudopotential"] is None:
+                if self.pseudo_qualifier() == "":
                     label = symbol
-                    pseudopotential = label + '.psf'
+                    pseudopotential = label + ".psf"
                 else:
-                    label = '.'.join([symbol, self.pseudo_qualifier()])
-                    pseudopotential = label + '.psf'
+                    label = ".".join([symbol, self.pseudo_qualifier()])
+                    pseudopotential = label + ".psf"
             else:
-                pseudopotential = spec['pseudopotential']
+                pseudopotential = spec["pseudopotential"]
                 label = os.path.basename(pseudopotential)
-                label = '.'.join(label.split('.')[:-1])
+                label = ".".join(label.split(".")[:-1])
 
             if not os.path.isabs(pseudopotential):
                 pseudopotential = join(pseudo_path, pseudopotential)
@@ -228,138 +264,138 @@ class MySiesta(Siesta):
                 raise RuntimeError(mess)
 
             name = os.path.basename(pseudopotential)
-            name = name.split('.')
+            name = name.split(".")
             name.insert(-1, str(species_number))
-            if spec['ghost']:
-                name.insert(-1, 'ghost')
+            if spec["ghost"]:
+                name.insert(-1, "ghost")
                 atomic_number = -atomic_number
 
-            name = '.'.join(name)
+            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 = self["symlink_pseudos"]
 
                 symlink_pseudos = False
 
                 if symlink_pseudos is None:
-                    symlink_pseudos = not os.name == 'nt'
+                    symlink_pseudos = not os.name == "nt"
 
                 if symlink_pseudos:
                     os.symlink(pseudopotential, pseudo_targetpath)
                 else:
                     shutil.copy(pseudopotential, pseudo_targetpath)
-            if not spec['excess_charge'] is None:
+            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:
+                # 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)))
+                fd.write(format_fdf("SyntheticAtoms", list(synth_blocks)))
 
-            label = '.'.join(np.array(name.split('.'))[:-1])
-            string = '    %d %d %s' % (species_number, atomic_number, label)
+            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))
+            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')
-
+                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.append(f"{name} non-perturbative ")
             # npt_text += "%endblock PAO.PolarizationScheme\n"
-            self['fdf_arguments'].update({"PAO.PolarizationScheme": npt_text})
+            self["fdf_arguments"].update({"PAO.PolarizationScheme": npt_text})
 
     def set_synthetic_atoms(self):
         print("setting syn")
-        nsyn=len(self.synthetic_atoms)
-        if  nsyn> 0:
+        nsyn = len(self.synthetic_atoms)
+        if nsyn > 0:
             syntext = []
-            #syntext.append(f"{nsyn}")
+            # syntext.append(f"{nsyn}")
             for name, content in self.synthetic_atoms.items():
-                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]]))
-            self['fdf_arguments'].update({"SyntheticAtoms": syntext})
+                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)
+        # 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):
+        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):
-        fdf = self['fdf_arguments'].update(fdf_arguments)
-
-    def add_Hubbard_U(self,
-                      specy,
-                      n=3,
-                      l=2,
-                      U=0,
-                      J=0,
-                      rc=0.0,
-                      Fermi_cut=0.0,
-                      scale_factor='0.95'):
-        if not 'Udict' in self.__dict__:
+        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}"
+        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
+            "n": n,
+            "l": l,
+            "U": U,
+            "J": J,
+            "rc": rc,
+            "Fermi_cut": Fermi_cut,
+            "scale_factor": scale_factor,
         }
         self.set_Hubbard_U(self.Udict)
 
@@ -369,18 +405,19 @@ class MySiesta(Siesta):
         """
         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']))
+            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'])
+                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})
+            {"LDAU.Proj": Ublock, "LDAU.ProjectorGenerationMethod": 2}
+        )
 
     def set_Udict(self, Udict):
         """
@@ -400,47 +437,57 @@ class MySiesta(Siesta):
     def relax(
         self,
         atoms,
-        TypeOfRun='Broyden',
+        TypeOfRun="Broyden",
         VariableCell=True,
         ConstantVolume=False,
         RelaxCellOnly=False,
         MaxForceTol=0.001,
         MaxStressTol=1,
         NumCGSteps=40,
-        relaxed_file="relaxed.vasp"
+        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.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.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,
-        })
+        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):
+    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.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):
@@ -451,23 +498,25 @@ class MySiesta(Siesta):
             - atoms: An atoms object.
         """
         cell = atoms.cell
-        f.write('\n')
+        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.')
+            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')
+            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) + ' '
+                    s = ("    %.15f" % cell[i, j]).rjust(16) + " "
                     f.write(s)
-                f.write('\n')
-            f.write('%endblock LatticeVectors\n')
-            f.write('\n')
+                f.write("\n")
+            f.write("%endblock LatticeVectors\n")
+            f.write("\n")
 
         self._write_atomic_coordinates(f, atoms)
 
@@ -480,26 +529,26 @@ class MySiesta(Siesta):
         # atoms object.
         if magmoms is not None:
             if len(magmoms) == 0:
-                f.write('#Empty block forces ASE initialization.\n')
+                f.write("#Empty block forces ASE initialization.\n")
 
-            f.write('%block DM.InitSpin\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]))
+                        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')
+                        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()
+        """Read the results."""
+        # self.read_number_of_grid_points()
         self.read_energy()
         self.read_forces_stress()
         # self.read_eigenvalues()

TB2Jflows/siesta_basis.py

@@ -1,6 +1,5 @@
-
 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",
+    # "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",
@@ -13,11 +12,11 @@ withf_basis = {
     "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"
+    "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",
+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",
@@ -30,21 +29,19 @@ fincore_basis ={
     "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"
+    "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]
-    elif basis == "fincore":
-        return fincore_basis[element]
     else:
-        raise ValueError("Invalid basis set: {}".format(basis))
+        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.1.0.dist-info → tb2jflows-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2Jflows
-Version: 0.1.0
+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

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.1.0.dist-info → tb2jflows-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

tb2jflows-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-TB2Jflows/__init__.py,sha256=0aRVj9v-u64LxJl7Cyxcr4YUjpeMkBGPuv-nJbxbHOg,100
-TB2Jflows/ase_siesta.py,sha256=1b6j0dFNnXCeLnCTWoLAJ158JQul8UcORIttGOhNydw,14366
-TB2Jflows/auto_siesta_TB2J.py,sha256=c5dviznEbXyO3BJbh-LNBlC9efT7YbdC7ydWxyCJZ5E,3113
-TB2Jflows/find_pp.py,sha256=iTqxLPuR88Jsuh4lc7hPEzFczhoOB0x6K5MWqYTEeiQ,2134
-TB2Jflows/mysiesta.py,sha256=DV9dnYibrpPzegKy_MvoMOOrmoom2NPKblhVNBUZkeg,18943
-TB2Jflows/run_abacus.py,sha256=96tZ2n02FFLl8IZf4W_4TvkCcsd6oS1FVEIqhZpY76o,2692
-TB2Jflows/siesta_basis.py,sha256=UIO0VF_558jIK6kGctqEwHyyV_t7KEWGOtv4Obw4fyg,5408
-tb2jflows-0.1.0.dist-info/METADATA,sha256=mnUu8VXO3Dndka3rbgqWJ0hiWxOXmWyF9AjauzpVQZk,2170
-tb2jflows-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tb2jflows-0.1.0.dist-info/licenses/LICENSE,sha256=KNu68sa-XR_2jZJKhDcSnxoNve8jtHgkw_w9PjP1YOk,1315
-tb2jflows-0.1.0.dist-info/RECORD,,