TB2Jflows 0.0.1__py3-none-any.whl

TB2Jflows/__init__.py

@@ -0,0 +1,2 @@
+from TB2Jflows.ase_siesta import SiestaFlow
+from TB2Jflows.auto_siesta_TB2J import auto_siesta_TB2J

TB2Jflows/ase_siesta.py

@@ -0,0 +1,425 @@
+import copy
+import json
+import os
+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
+
+
+class SiestaFlow:
+    def __init__(
+        self,
+        atoms,
+        basis_set: str = "DZP",
+        xc: str = "PBEsol",
+        spin: str = "collinear",
+        kpts=[6, 6, 6],
+        Udict: dict = {},
+        root_path="./",
+        restart=True,
+        metadata={},
+        fdf_arguments={},
+        split_soc=False,
+        **kwargs,
+    ):
+        self.atoms = atoms
+        self.basis_set = basis_set
+        self.xc = xc
+        self.kpts = kpts
+        self.Udict = Udict
+        # default fdf arguments
+        self.fdf_arguments = {
+            "MaxSCFIterations": 350,
+            "SCF.Mixer.Method": "Pulay",
+            "SCF.Mixer.History": 16,
+            "SCF.Mixer.Weight": 0.4,
+            "SCF.Mix.Spin": "sum",
+            "SCF.DM.Tolerance": 1e-4,
+            "SCF.EDM.Tolerance": "1e-2 eV",
+            "SCF.H.Tolerance": "1e-3 eV",
+            "Diag.ParallelOverK": "True",
+        }
+        if fdf_arguments:
+            self.fdf_arguments.update(fdf_arguments)
+        self.spin = spin
+        self.root_path = root_path
+        self.restart = restart
+        self.kwargs = kwargs
+
+        # paths
+        self.metadata_path = os.path.join(self.root_path, "metadata.json")
+        if not os.path.exists(self.root_path):
+            os.makedirs(self.root_path)
+        self.relax_path = os.path.join(self.root_path, "relax")
+        self.scf_path = os.path.join(self.root_path, "scf")
+
+        self.relaxed_atoms = None
+        self.split_soc = split_soc
+        self.initialize_metadata(metadata)
+
+    def initialize_metadata(self, metadata):
+        """Initialize the metadata.
+        If already exist, read from it.
+
+        """
+        if (
+            self.restart
+            and os.path.exists(self.metadata_path)
+            and os.path.isfile(self.metadata_path)
+        ):
+            self.load_metadata()
+        else:
+            self.metadata = {
+                "root_path": self.root_path,
+                "calculator": "siesta",
+                "initial_atoms": encode(self.atoms),
+                "spin": self.spin,
+                "xc": self.xc,
+                "already_relaxed": False,
+            }
+            self.metadata.update(metadata)
+
+    def load_metadata(self):
+        with open(self.metadata_path, "r") as myfile:
+            self.metadata = json.load(myfile)
+            self.initial_atoms = decode(self.metadata["initial_atoms"])
+            if ("relaxed_atoms" in self.metadata) and (
+                self.metadata["relaxed_atoms"] is not None
+            ):
+                self.relaxed_atoms = decode(self.metadata["relaxed_atoms"])
+
+    def write_metadata(self):
+        with open(self.metadata_path, "w") as myfile:
+            json.dump(self.metadata, myfile)
+
+    def update_metadata(self, d):
+        self.initialize_metadata(d)
+        self.write_metadata()
+
+    @property
+    def spin(self):
+        return self._spin
+
+    @spin.setter
+    def spin(self, spin):
+        self._spin = spin
+        if spin == "spin-orbit":
+            self.fdf_arguments.update({"SCF.Mix": "hamiltonian", "WriteOrbMom": True})
+        else:
+            if "writeOrbMom" in self.fdf_arguments:
+                self.fdf_arguments.pop("WriteOrbMom")
+        if spin == "spin-orbit":
+            self.rel = "fr"
+        else:
+            self.rel = "sr"
+
+    def get_calculator(
+        self,
+        atoms: ase.Atoms,
+        path="./",
+        label="siesta",
+        fdf_arguments={},
+    ):
+        fdf_args = copy.deepcopy(self.fdf_arguments)
+        fdf_args.update(fdf_arguments)
+        calc = MySiesta(
+            atoms=atoms,
+            label=label,
+            xc=self.xc,
+            basis_set=self.basis_set,
+            kpts=self.kpts,
+            spin=self.spin,
+            fdf_arguments=fdf_args,
+            **self.kwargs,
+        )
+        if self.Udict:
+            # calc.set_Hubbard_U(self.Udict)
+            calc.set_Udict(self.Udict)
+        calc.directory = path
+        calc.atoms = atoms
+        return copy.deepcopy(calc)
+
+    def relax(
+        self,
+        atoms,
+        use_collinear=True,
+        path="./relax",
+        label="siesta",
+        TypeOfRun="Broyden",
+        VariableCell=True,
+        ConstantVolume=False,
+        RelaxCellOnly=False,
+        MaxForceTol=0.001,
+        MaxStressTol=0.1,
+        NumCGSteps=200,
+    ):
+        if (
+            self.restart
+            and self.metadata["already_relaxed"]
+            and self.relaxed_atoms is not None
+        ):
+            self.load_metadata()
+            atoms = self.relaxed_atoms
+        else:
+            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
+            self.update_metadata(
+                {
+                    "already_relaxed": True,
+                    "relax_path": self.relax_path,
+                    "relaxed_atoms": encode(self.relaxed_atoms),
+                }
+            )
+        return atoms
+
+    def scf_calculation(self, atoms, path="./scf", label="siesta"):
+        print(f"SCF calculation in {path}")
+        HS_args = {
+            "SaveHS": True,
+            #'CDF.Save': True,
+            #'CDF.Compress': 9,
+        }
+        calc = self.get_calculator(atoms, path=path, label=label, fdf_arguments=HS_args)
+        calc.get_potential_energy()
+
+    def scf_calculation_with_rotations(
+        self, atoms, label="siesta", rotate_type="structure"
+    ):
+        self.fdf_arguments["Spin.Fix"] = False
+        self.spin = "spin-orbit"
+        if rotate_type == "structure":
+            atoms_xyz = rotate_atom_xyz(atoms)
+        elif rotate_type == "spin":
+            atoms_xyz = rotate_atom_spin(atoms)
+        else:
+            raise NotImplementedError(f"rotate_type={rotate_type} is not implemented")
+        for ratoms, rot in zip(atoms_xyz, ("x", "y", "z")):
+            self.scf_calculation(
+                ratoms, path=os.path.join(self.scf_path, rot), label=label
+            )
+
+    def scf_calculation_single_noncollinear(self, atoms, label="siesta"):
+        self.fdf_arguments["Spin.Fix"] = False
+        self.scf_calculation(
+            atoms, path=os.path.join(self.scf_path, "single_noncollinear"), label=label
+        )
+
+    def scf_calculatoin_split_soc(self, atoms, label="siesta", nscf=False):
+        fdf_args = {
+            "SOC_split_SR_SO": True,
+            #"Spin.OrbitStrength": 3,
+            "SaveHS.so": True,
+            "SaveHS": True,
+            "Spin.Fix": False, 
+        }
+        nscf_args={"SCF.DM.Converge": True, 
+                "SCF.DM.Tolerance": 1e4, 
+                "SCF.H.Converge": False, 
+                "SCF.EDM.Converge": False, 
+                "SCF.Mix.First": False, 
+                "SCF.Mix": "density", 
+                "MaxSCFIterations": 1,
+                }
+        if nscf:
+            fdf_args.update(nscf_args)
+
+        self.spin = "spin-orbit"
+        path = Path(self.scf_path) / "split_soc"
+        path.mkdir(parents=True, exist_ok=True)
+        collinear_path = Path(self.scf_path) / "collinear"
+        # density matrix from collinear calculation
+        # copy density matrix from collinear calculation
+        dmfile = collinear_path / f"{label}.DM"
+        if dmfile.exists():
+            dmfile_new = path / f"{label}.DM"
+            print(f"Copying {dmfile} to {dmfile_new}")
+            os.system(f"cp {dmfile} {dmfile_new}")
+        calc = self.get_calculator(
+            atoms, path=path, label=label, fdf_arguments=fdf_args
+        )
+        calc.get_potential_energy()
+
+    def scf_calculation_collinear(self, atoms, label="siesta"):
+        old_spin = self.spin
+        self.spin = "collinear"
+        self.scf_calculation(
+            atoms, path=os.path.join(self.scf_path, "collinear"), label=label
+        )
+        self.spin = old_spin
+
+    def run_TB2J_collinear(self, **kwargs):
+        path = os.path.join(self.scf_path, "collinear")
+        fdf_fname = os.path.join(path, "siesta.fdf")
+        gen_exchange_siesta(
+            fdf_fname=fdf_fname,
+            **kwargs,
+            output_path=os.path.join(self.root_path, "TB2J_results_collinear"),
+        )
+
+    def run_TB2J_single_noncollinear(self, **kwargs):
+        path = os.path.join(self.scf_path, "single_noncollinear")
+        fdf_fname = os.path.join(path, "siesta.fdf")
+        gen_exchange_siesta(
+            fdf_fname=fdf_fname,
+            **kwargs,
+            output_path=os.path.join(
+                self.root_path, "TB2J_results_single_noncollinear"
+            ),
+        )
+
+    def set_nonscf_params(self):
+        nscf_params={"SCF.DM.Converge": False, 
+                "SCF.DM.Tolerance": 1e4, 
+                "SCF.H.Converge": False, 
+                "SCF.EDM.Converge": False, 
+                "SCF.Mix.First": False, 
+                "SCF.Mix": "density", 
+                "MaxSCFIterations": 1,
+                }
+
+    def run_TB2J_split_soc(self, **kwargs):
+        path = os.path.join(self.scf_path, "split_soc")
+        fdf_fname = os.path.join(path, "siesta.fdf")
+        gen_exchange_siesta(
+            fdf_fname=fdf_fname,
+            read_H_soc=True,
+            **kwargs,
+            output_path=os.path.join(self.root_path, "TB2J_results_split_soc"),
+        )
+        # merge results
+        paths = [
+            os.path.join(self.root_path, f"TB2J_results_split_soc_{rot}")
+            for rot in ("x", "y", "z")
+        ]
+        merge(
+            *paths,
+            # method=rotate_type,
+            write_path=os.path.join(self.root_path, "TB2J_results_merged"),
+        )
+
+    def run_TB2J(self, skip=False, **kwargs):
+        paths = []
+        for rot in ("x", "y", "z"):
+            path = os.path.join(self.scf_path, rot)
+            paths.append(path)
+            TB2J_path = os.path.join(self.root_path, f"TB2J_results_{rot}")
+            if not (skip and os.path.exists(os.path.join(TB2J_path, "exchange.txt"))):
+                fdf_fname = os.path.join(path, "siesta.fdf")
+                gen_exchange_siesta(
+                    fdf_fname=fdf_fname, **kwargs, output_path=TB2J_path
+                )
+
+    def run_TB2J_rotate_structure(self, skip=False, **kwargs):
+        paths = []
+        for rot in ("x", "y", "z"):
+            path = os.path.join(self.scf_path, rot)
+            paths.append(path)
+            TB2J_path = os.path.join(self.root_path, f"TB2J_results_{rot}")
+            if not (skip and os.path.exists(os.path.join(TB2J_path, "exchange.txt"))):
+                fdf_fname = os.path.join(path, "siesta.fdf")
+                gen_exchange_siesta(
+                    fdf_fname=fdf_fname, **kwargs, output_path=TB2J_path
+                )
+
+    def run_TB2J_merge(self, rotate_type="structure"):
+        paths = [
+            os.path.join(self.root_path, f"TB2J_results_{rot}")
+            for rot in ("x", "y", "z")
+        ]
+        merge(
+            *paths,
+            # method=rotate_type,
+            write_path=os.path.join(self.root_path, "TB2J_results_merged"),
+        )
+
+    def runall_collinear(self, atoms, relax=True, scf=True, TB2J=True, **kwargs):
+        if relax:
+            atoms = self.relax(atoms)
+        if scf:
+            self.scf_calculation_collinear(atoms, label="siesta")
+        if TB2J:
+            self.run_TB2J_collinear(**kwargs)
+
+    def runall_nc(
+        self, atoms, relax=True, scf=True, TB2J=True, rotate_type="structure", **kwargs
+    ):
+        if relax:
+            atoms = self.relax(atoms)
+        if scf:
+            self.scf_calculation_with_rotations(
+                atoms, rotate_type=rotate_type, label="siesta"
+            )
+        if TB2J:
+            self.run_TB2J(**kwargs)
+            self.run_TB2J_merge(rotate_type=rotate_type)
+
+    def runall_split_soc(self, atoms, relax=True, scf=True, TB2J=True, **kwargs):
+        if relax:
+            atoms = self.relax(atoms)
+        if scf:
+            self.scf_calculatoin_split_soc(atoms, label="siesta")
+        if TB2J:
+            self.run_TB2J_split_soc(**kwargs)
+
+    def runall(
+        self, atoms, relax=True, scf=True, TB2J=True, rotate_type="structure", **kwargs
+    ):
+        if self.spin == "collinear":
+            self.runall_collinear(atoms, relax=relax, scf=scf, TB2J=TB2J, **kwargs)
+        elif self.spin == "spin-orbit+onsite":
+            self.runall_nc(
+                atoms,
+                relax=relax,
+                scf=scf,
+                TB2J=TB2J,
+                rotate_type=rotate_type,
+                **kwargs,
+            )
+
+        elif self.spin == "spin-orbit":
+            if self.split_soc:
+                self.runall_split_soc(atoms, relax=relax, scf=scf, TB2J=TB2J, **kwargs)
+            else:
+                self.runall_nc(
+                    atoms,
+                    relax=relax,
+                    scf=scf,
+                    TB2J=TB2J,
+                    rotate_type=rotate_type,
+                    **kwargs,
+                )
+        elif self.spin == "collinear+spin-orbit":
+            self.runall_collinear(atoms, relax=relax, scf=scf, TB2J=TB2J, **kwargs)
+            if self.split_soc:
+                self.runall_split_soc(atoms, relax=relax, scf=scf, TB2J=TB2J, **kwargs)
+            else:
+                self.runall_nc(
+                    atoms,
+                    relax=relax,
+                    scf=scf,
+                    TB2J=TB2J,
+                    rotate_type=rotate_type,
+                    **kwargs,
+                )
+        else:
+            raise NotImplementedError(f"spin={self.spin} is not implemented in runall")

TB2Jflows/auto_siesta_TB2J.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+import numpy as np
+from ase.io import read
+from ase.units import Ry
+
+from TB2Jflows import SiestaFlow
+
+
+def atoms_mag_along_z(atoms, mag, toz=True):
+    symbols = atoms.get_chemical_symbols()
+    symbols = np.array(symbols)
+
+    norm = np.linalg.norm(mag, axis=1)
+    imaxmag = np.argmax(norm)
+    ipolarized = np.where(norm > 0.1)
+
+    elems = set(symbols[ipolarized])
+
+    # rotate to collinear
+    if toz:
+        m_col = np.zeros(mag.shape[0], dtype=float)
+        m_ref = mag[imaxmag]
+        for i, m in enumerate(mag):
+            mrot = m @ m_ref
+            n = np.linalg.norm(m)
+            m_col[i] = n if mrot > 0 else -n
+        atoms.set_initial_magnetic_moments(None)
+    else:
+        atoms.set_initial_magnetic_moments(mag)
+    return atoms, elems
+
+
+def read_to_collinear_mag_atoms(name):
+    path = f"../structures/{name}"
+    mag = np.load(f"{path}/mag.npy")
+    atoms = read(f"{path}/POSCAR.vasp")
+    atoms, elems = atoms_mag_along_z(atoms, mag)
+    return atoms, elems
+
+
+def auto_siesta_TB2J(
+    path,
+    atoms,
+    spin,
+    elems,
+    Udict={},
+    xc="PBE",
+    kmesh=None,
+    split_soc=False,
+    relax=False,
+    scf=True,
+    TB2J=True,
+    rotate_type="structure",
+    fincore=True,
+    siesta_kwargs={},
+    TB2J_kwargs={},
+    fdf_kwargs={},
+):
+    # mag_elems = list(elems)
+    symbols = atoms.get_chemical_symbols()
+    cell = atoms.get_cell_lengths_and_angles()
+    Uname = {}
+    sset = set()
+    for s in symbols:
+        if s not in sset:
+            sset.add(s)
+            Uname[s] = s + f".{len(sset)}"
+    if kmesh is None:
+        kmesh = [int(40 // cell[0] + 1), int(40 // cell[1] + 1), int(40 // cell[2] + 1)]
+
+    fdf_arguments = {
+        "SCF.DM.Tolerance": "0.0001",
+        "ElectronicTemperature": "100 K",
+        "SCF.Mixer.Weight": "0.1",
+        "SCF.Mixer.History": "16",
+        "SCF.Mix.Spin": "sum",
+        "DM.NumberPulay": "6",
+        "SCF.Mixer.Method": "Pulay",
+        "MaxSCFIterations": 500,
+        "SCF.MustConverge": "False",
+        "SCFMustConverge": "False",
+        "WriteMullikenPop": "1",
+        "MullikenInSCF": "True",
+        "WriteHirshfeldPop": "True",
+        "WriteVoronoiPop": "True",
+        "CDF.save": "True",
+    }
+    fdf_arguments.update(fdf_kwargs)
+    flow = SiestaFlow(
+        atoms=atoms,
+        xc=xc,
+        spin=spin,
+        restart=True,
+        root_path=path,
+        kpts=kmesh,
+        mesh_cutoff=600 * Ry,
+        energy_shift=0.1,
+        fdf_arguments=fdf_arguments,
+        fincore=fincore,
+        Udict=Udict,
+        split_soc=split_soc,
+        **siesta_kwargs,
+    )
+    flow.write_metadata()
+    flow.runall(
+        atoms,
+        relax=relax,
+        scf=scf,
+        TB2J=TB2J,
+        rotate_type=rotate_type,
+        magnetic_elements=elems,
+        **TB2J_kwargs,
+    )
+
+
+if __name__ == "__main__":
+    atoms = None
+    elems = None
+    path = "./"
+    auto_siesta_TB2J(
+        path,
+        atoms,
+        spin="collinear",
+        elems=elems,
+        Udict={},
+        kmesh=None,
+        relax=False,
+        scf=True,
+        rotate_type="structure",
+    )

TB2Jflows/run_abacus.py

@@ -0,0 +1,120 @@
+from ase import Atoms
+from ase.calculators.abacus import Abacus, AbacusProfile
+from pathlib import Path
+import shutil
+
+abacus = "/home/hexu/.local/bin/abacus"
+profile = AbacusProfile(argv=["mpirun", "-n", "8", abacus])
+
+
+def gen_atoms():
+    """
+    2D Fe slab
+    """
+    atoms = Atoms(
+        "Fe", scaled_positions=[(0, 0, 0)], cell=(2.315, 2.315, 15), pbc=(1, 1, 1)
+    )
+    return atoms
+
+
+def gen_atoms_x():
+    """
+    2D Fe slab
+    """
+    atoms = Atoms(
+        "Fe", scaled_positions=[(0, 0, 0)], cell=(15, 2.315, 2.315), pbc=(1, 1, 1)
+    )
+    return atoms
+
+pdir = "/home/hexu/.local/pp/abacus/ABACUS-orbitals-main/Dojo-NC-FR"
+
+default_params = dict(
+    profile=profile,
+    directory="Fe_soc0_x",
+    pseudo_dir=f"{pdir}/Pseudopotential",
+    orbital_dir=f"{pdir}/Orbitals/Fe/Orbital_Fe_DZP",
+    pp={"Fe": "Fe.upf"},
+    basis={"Fe": "Fe_gga_10au_100Ry_4s2p2d1f.orb"},
+    calculation="scf",
+    xc="PBE",
+    kpts=(9, 9, 1),
+    nspin=4,
+    symmetry=0,
+    noncolin=1,
+    lspinorb=1,
+    ecutwfc=100,
+    scf_thr=1.0e-6,
+    init_chg="atomic",
+    out_mul=1,
+    out_chg=1,
+    out_dos=0,
+    out_band=0,
+    out_wfc_lcao=1,
+    out_mat_hs2=1,  # output H(R) and S(R) matrix
+    ks_solver="scalapack_gvx",
+    scf_nmax=500,
+    out_bandgap=0,
+    basis_type="lcao",
+    gamma_only=0,
+    smearing_method="gaussian",
+    smearing_sigma=0.01,
+    mixing_type="broyden",
+    mixing_beta=0.5,
+    soc_lambda=1.0,
+)
+
+params_nosoc = default_params.copy()
+params_nosoc.update(dict(
+    soc_lambda=0.0,
+    noncolin=1,
+    ))
+
+params_soc_nscf = default_params.copy()
+params_soc_nscf.update(dict(
+    calculation="scf",
+    soc_lambda=1.0,
+    init_chg="file",
+    init_wfc="file",
+    out_chg=0,
+    out_wfc_lcao=0,
+    scf_nmax=1,
+    mixing_beta=1e-6,
+    scf_thr=1e6,
+    ))
+
+
+def run_abacus(root="Fe_x", M=[[3, 0, 0]]):
+    atoms = gen_atoms()
+    atoms.set_initial_magnetic_moments(M)
+
+    path0=Path(root)/"soc0"
+    path1=Path(root)/"soc1"
+
+    params = params_nosoc.copy()
+    params.update(directory=path0)
+
+    calc = Abacus(**params)
+    atoms.set_calculator(calc)
+    atoms.get_potential_energy()
+    
+    path1.mkdir(parents=True, exist_ok=True)
+    if (path1/"OUT.ABACUS").exists():
+        shutil.rmtree(str(path1/"OUT.ABACUS"))
+    shutil.copytree(str(path0/"OUT.ABACUS"), str(path1/"OUT.ABACUS"))
+
+    params = params_soc_nscf.copy()
+    params.update(directory=path1)
+    calc = Abacus(**params)
+    atoms.set_calculator(calc)
+    atoms.get_potential_energy()
+
+
+def main():
+    run_abacus("Fe_x", [[3, 0, 0]])
+    run_abacus("Fe_z", [[0, 0, 3]])
+    run_abacus("Fe_-z", [[0, 0, -3]])
+    run_abacus("Fe_-x", [[-3, 0, 0]])
+
+
+if __name__ == "__main__":
+    main()

tb2jflows-0.0.1.dist-info/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2020, Xu He
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tb2jflows-0.0.1.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: TB2Jflows
+Version: 0.0.1
+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: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+ TB2Jflows: Workflows for automatically calculation of exchange parameters using TB2J 

tb2jflows-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+TB2Jflows/__init__.py,sha256=0aRVj9v-u64LxJl7Cyxcr4YUjpeMkBGPuv-nJbxbHOg,100
+TB2Jflows/ase_siesta.py,sha256=BagiujWCwUZ6Aj03oRFdAL1DzJ4pw1_upW4G5d9tMXw,14363
+TB2Jflows/auto_siesta_TB2J.py,sha256=c5dviznEbXyO3BJbh-LNBlC9efT7YbdC7ydWxyCJZ5E,3113
+TB2Jflows/run_abacus.py,sha256=96tZ2n02FFLl8IZf4W_4TvkCcsd6oS1FVEIqhZpY76o,2692
+tb2jflows-0.0.1.dist-info/LICENSE,sha256=KNu68sa-XR_2jZJKhDcSnxoNve8jtHgkw_w9PjP1YOk,1315
+tb2jflows-0.0.1.dist-info/METADATA,sha256=avwrwge2xfv6PgTUy92JCpBdqUFrJNbiNlQpurzX7Ss,947
+tb2jflows-0.0.1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+tb2jflows-0.0.1.dist-info/top_level.txt,sha256=iYRLHB7ZeHb59fEZLnbqJDymBKWPqfVgmvqd9S51Txw,10
+tb2jflows-0.0.1.dist-info/RECORD,,

tb2jflows-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tb2jflows-0.0.1.dist-info/top_level.txt

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