TB2J 0.9.12.7__py3-none-any.whl → 0.9.12.18__py3-none-any.whl

TB2J/.gitignore

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

TB2J/Jdownfolder.py

@@ -47,8 +47,8 @@ class JDownfolder:
         self.qmesh = qmesh
         self.qpts = monkhorst_pack(qmesh)
         self.nqpt = len(self.qpts)
-        self.nMn = self.nM * 3
-        self.nLn = self.nL * 3
+        self.nMn = self.nM * self.nxyz
+        self.nLn = self.nL * self.nxyz
         self.iso_only = iso_only
 
     def get_JR(self):
@@ -62,6 +62,7 @@ class JDownfolder:
             for iR, R in enumerate(self.Rlist):
                 phase = np.exp(-2.0j * np.pi * np.dot(q, R))
                 JR_downfolded[iR] += np.real(Jq_downfolded[iq] * phase / self.nqpt)
+        return JR_downfolded, self.Rlist
 
     def downfold_oneq(self, J):
         JMM = J[np.ix_(self.iMn, self.iMn)]
@@ -121,7 +122,7 @@ class PWFDownfolder:
             marker="o",
             ax=None,
             savefig="downfold_band.png",
-            show=True,
+            show=False,
         )
         self.JR_downfolded = ewf.HwannR
         self.Rlist = ewf.Rlist

TB2J/MAEGreen.py

@@ -51,7 +51,7 @@ class MAEGreen(ExchangeNCL):
 
         nangles = len(self.thetas)
         self.es = np.zeros(nangles, dtype=complex)
-        self.es_atom = np.zeros((nangles, self.natoms), dtype=complex)
+        self.es_matrix = np.zeros((nangles, self.natoms, self.natoms), dtype=complex)
         self.es_atom_orb = DefaultDict(lambda: 0)
 
     def set_angles_xyz(self):
@@ -153,9 +153,8 @@ class MAEGreen(ExchangeNCL):
         Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
         na = len(thetas)
         dE_angle = np.zeros(na, dtype=complex)
-        dE_angle_atom = np.zeros((na, self.natoms), dtype=complex)
+        dE_angle_matrix = np.zeros((na, self.natoms, self.natoms), dtype=complex)
         # dE_angle_orbitals = np.zeros((na, self.natoms, self.norb, self.norb), dtype=complex)
-        # dE_angle_orbitals = DefaultDict(lambda: 0)
         dE_angle_atom_orb = DefaultDict(lambda: 0)
         for iangle, (theta, phi) in enumerate(zip(thetas, phis)):
             for ik, dHk in enumerate(Hsoc_k):
@@ -179,23 +178,30 @@ class MAEGreen(ExchangeNCL):
                 # dE_angle[iangle] += np.trace(GdH@GdH) * self.G.kweights[ik]
                 # dE_angle[iangle] += np.trace(GdH@G0K[ik].T.conj()@dHi ) * self.G.kweights[ik]
                 dE_angle[iangle] += dG2sum * self.G.kweights[ik]
+
+                # Calculate atom-atom matrix interactions
                 for iatom in range(self.natoms):
                     iorb = self.iorb(iatom)
-                    # dG2= dG2[::2, ::2] + dG2[1::2, 1::2] + dG2[1::2, ::2] + dG2[::2, 1::2]
-                    dE_atom_orb = dG2[np.ix_(iorb, iorb)] * self.G.kweights[ik]
-                    dE_atom_orb = (
-                        dE_atom_orb[::2, ::2]
-                        + dE_atom_orb[1::2, 1::2]
-                        + dE_atom_orb[1::2, ::2]
-                        + dE_atom_orb[::2, 1::2]
-                    )
-                    dE_atom = np.sum(dE_atom_orb)
-                    mmat = self.mmats[iatom]
-                    dE_atom_orb = mmat.T @ dE_atom_orb @ mmat
-                    dE_angle_atom_orb[(iangle, iatom)] += dE_atom_orb
-                    # dE_atom = np.sum(dG2diag[iorb]) * self.G.kweights[ik]
-                    dE_angle_atom[iangle, iatom] += dE_atom
-        return dE_angle, dE_angle_atom, dE_angle_atom_orb
+                    for jatom in range(self.natoms):
+                        jorb = self.iorb(jatom)
+                        # Calculate cross terms between atoms i and j
+                        dE_ij_orb = dG2[np.ix_(iorb, jorb)] * self.G.kweights[ik]
+                        dE_ij_orb = (
+                            dE_ij_orb[::2, ::2]
+                            + dE_ij_orb[1::2, 1::2]
+                            + dE_ij_orb[1::2, ::2]
+                            + dE_ij_orb[::2, 1::2]
+                        )
+                        dE_ij = np.sum(dE_ij_orb)
+                        # Transform to local orbital basis
+                        mmat_i = self.mmats[iatom]
+                        mmat_j = self.mmats[jatom]
+                        dE_ij_orb = mmat_i.T @ dE_ij_orb @ mmat_j
+                        dE_angle_matrix[iangle, iatom, jatom] += dE_ij
+                        # Store orbital-resolved data for diagonal terms
+                        if iatom == jatom:
+                            dE_angle_atom_orb[(iangle, iatom)] += dE_ij_orb
+        return dE_angle, dE_angle_matrix, dE_angle_atom_orb
 
     def get_perturbed_R(self, e, thetas, phis):
         self.tbmodel.set_so_strength(0.0)
@@ -233,16 +239,16 @@ class MAEGreen(ExchangeNCL):
             npole = len(self.contour.path)
             results = map(func, tqdm.tqdm(self.contour.path, total=npole))
         for i, result in enumerate(results):
-            dE_angle, dE_angle_atom, dE_angle_atom_orb = result
+            dE_angle, dE_angle_matrix, dE_angle_atom_orb = result
             self.es += dE_angle * self.contour.weights[i]
-            self.es_atom += dE_angle_atom * self.contour.weights[i]
+            self.es_matrix += dE_angle_matrix * self.contour.weights[i]
             for key, value in dE_angle_atom_orb.items():
                 self.es_atom_orb[key] += (
                     dE_angle_atom_orb[key] * self.contour.weights[i]
                 )
 
         self.es = -np.imag(self.es) / (2 * np.pi)
-        self.es_atom = -np.imag(self.es_atom) / (2 * np.pi)
+        self.es_matrix = -np.imag(self.es_matrix) / (2 * np.pi)
         for key, value in self.es_atom_orb.items():
             self.es_atom_orb[key] = -np.imag(value) / (2 * np.pi)
 
@@ -260,6 +266,7 @@ class MAEGreen(ExchangeNCL):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
+        fname_matrix = f"{output_path}/MAE_matrix.dat"
         # fname_tensor = f"{output_path}/MAE_tensor.dat"
         # if figure3d is not None:
         #    fname_fig3d = f"{output_path}/{figure3d}"
@@ -270,24 +277,32 @@ class MAEGreen(ExchangeNCL):
         if with_eigen:
             fname_eigen = f"{output_path}/MAE_eigen.dat"
             with open(fname_eigen, "w") as f:
-                f.write("# theta, phi, MAE(total), MAE(atom-wise) Unit: meV\n")
-                for i, (theta, phi, e, es) in enumerate(
-                    zip(self.thetas, self.phis, self.es2, self.es_atom)
+                f.write("# theta, phi, MAE(total) Unit: meV\n")
+                for i, (theta, phi, e) in enumerate(
+                    zip(self.thetas, self.phis, self.es2)
                 ):
-                    f.write(f"{theta:.5f} {phi:.5f} {e*1e3:.8f} ")
-                    for ea in es:
-                        f.write(f"{ea*1e3:.8f} ")
-                    f.write("\n")
+                    f.write(f"{theta:.5f} {phi:.5f} {e*1e3:.8f}\n")
 
         with open(fname, "w") as f:
-            f.write("# theta (rad), phi(rad), MAE(total), MAE(atom-wise) Unit: meV\n")
-            for i, (theta, phi, e, es) in enumerate(
-                zip(self.thetas, self.phis, self.es, self.es_atom)
-            ):
-                f.write(f"{theta%np.pi:.5f} {phi%(2*np.pi):.5f} {e*1e3:.8f} ")
-                for ea in es:
-                    f.write(f"{ea*1e3:.8f} ")
-                f.write("\n")
+            f.write("# theta (rad), phi(rad), MAE(total) Unit: meV\n")
+            for i, (theta, phi, e) in enumerate(zip(self.thetas, self.phis, self.es)):
+                f.write(f"{theta%np.pi:.5f} {phi%(2*np.pi):.5f} {e*1e3:.8f}\n")
+
+        # Write matrix data to MAE_matrix.dat
+        with open(fname_matrix, "w") as fmat:
+            fmat.write("# MAE atom-atom interaction matrices\n")
+            fmat.write("# Format: angle_index theta phi atom_i atom_j MAE_ij(meV)\n")
+            fmat.write("# Units: theta and phi in radians, MAE in meV\n")
+            for iangle, (theta, phi) in enumerate(zip(self.thetas, self.phis)):
+                for iatom in range(self.natoms):
+                    for jatom in range(self.natoms):
+                        mae_ij = (
+                            self.es_matrix[iangle, iatom, jatom] * 1e3
+                        )  # Convert to meV
+                        fmat.write(
+                            f"{iangle:4d} {theta:.5f} {phi:.5f} {iatom:4d} {jatom:4d} {mae_ij:.8f}\n"
+                        )
+                fmat.write("\n")  # Empty line between angles for readability
 
         # self.ani = self.fit_anisotropy_tensor()
         # with open(fname_tensor, "w") as f:
@@ -313,34 +328,37 @@ class MAEGreen(ExchangeNCL):
                 for orb in self.orbital_names[iatom]:
                     f.write(f"{orb} ")
                 f.write("\n")
-            for i, (theta, phi, e, eatom) in enumerate(
-                zip(self.thetas, self.phis, self.es, self.es_atom)
-            ):
+            for i, (theta, phi, e) in enumerate(zip(self.thetas, self.phis, self.es)):
                 f.write("-" * 60 + "\n")
                 f.write(f"Angle {i:03d}:   theta={theta:.5f} phi={phi:.5f} \n ")
                 f.write(f"E: {e*1e3:.8f} \n")
-                for iatom, ea in enumerate(eatom):
-                    f.write(f"Atom {iatom:03d}: {ea*1e3:.8f} \n")
-                    f.write("Orbital: ")
-                    eorb = self.es_atom_orb[(i, iatom)]
-
-                    # write numpy matrix to file
-                    f.write(
-                        np.array2string(
-                            eorb * 1e3, precision=4, separator=",", suppress_small=True
-                        )
-                    )
-
-                    eorb_diff = eorb - self.es_atom_orb[(0, iatom)]
-                    f.write("Diference to the first angle: ")
-                    f.write(
-                        np.array2string(
-                            eorb_diff * 1e3,
-                            precision=4,
-                            separator=",",
-                            suppress_small=True,
+                for iatom in range(self.natoms):
+                    f.write(f"Atom {iatom:03d} orbital matrix:\n")
+                    if (i, iatom) in self.es_atom_orb:
+                        eorb = self.es_atom_orb[(i, iatom)]
+                        # write numpy matrix to file
+                        f.write(
+                            np.array2string(
+                                eorb * 1e3,
+                                precision=4,
+                                separator=",",
+                                suppress_small=True,
+                            )
                         )
-                    )
+                        f.write("\n")
+
+                        if (0, iatom) in self.es_atom_orb:
+                            eorb_diff = eorb - self.es_atom_orb[(0, iatom)]
+                            f.write("Difference to the first angle: ")
+                            f.write(
+                                np.array2string(
+                                    eorb_diff * 1e3,
+                                    precision=4,
+                                    separator=",",
+                                    suppress_small=True,
+                                )
+                            )
+                            f.write("\n")
                 f.write("\n")
 
     def run(self, output_path="TB2J_anisotropy", with_eigen=False):

TB2J/__init__.py

@@ -1,5 +1,3 @@
 import importlib.metadata
-import TB2J
 
 __version__ = importlib.metadata.version("TB2J")
-

TB2J/agent_files/debug_spinphon_fd/debug_main.py

@@ -0,0 +1,156 @@
+"""
+Debug script for spin-phonon coupling using double-sided finite difference method.
+
+PURPOSE:
+    This script uses the double-sided finite difference method from Oiju_FD2.py to
+    calculate spin-phonon coupling parameters and their derivatives dJ/dx. It computes
+    exchange parameters at both positive and negative displacements, then calculates
+    dJ/dx = (J(+dx) - J(-dx)) / (2*dx).
+
+USAGE:
+    uv run python agent_files/debug_spinphon_fd/debug_main.py
+
+EXPECTED OUTPUT:
+    The script will create output directories with subdirectories:
+    - original/: Exchange parameters at zero displacement (only if compute_d2J=True)
+    - negative/: Exchange parameters at -amplitude displacement
+    - positive/: Exchange parameters at +amplitude displacement
+    - dJdx/: Computed derivatives dJ/dx in both text and pickle formats
+
+PERFORMANCE OPTIONS:
+    - compute_d2J: Set False to skip J(0) calculation and d2J/dx2 (~33% faster)
+    - ispin0_only: Set True to only compute pairs with ispin=0 or jspin=0 (~93% faster)
+    - Combined: ~95% reduction in computation time!
+
+FILES USED:
+    - Oiju_FD2.py: Source of double-sided finite difference implementation
+    - Oiju_epw2.py: Reference for data path structure and interface
+
+DEBUG NOTES:
+    - Uses double-sided finite difference for better numerical accuracy
+    - Computes full exchange tensor derivatives including DMI components
+    - Results include isotropic, anisotropic, and DMI contributions to dJ/dx
+    - Default settings use both optimizations for maximum speed
+"""
+
+
+# Add the TB2J directory to the Python path
+# sys.path.insert(0, '/home_phythema/hexu/projects/TB2J/TB2J')
+
+import numpy as np
+
+from TB2J.Oiju_FD2 import gen_exchange_Oiju_FD_double_sided
+
+
+def main():
+    """Main function to run spin-phonon coupling calculation using double-sided finite difference method."""
+
+    # Use the same data path structure as Oiju_epw2.py
+    path = "/home_phythema/hexu/spinphon/2025-10-02_newdata/k555q555"
+    nsc=2
+    nkpt = 5
+
+
+    # Configuration parameters matching Oiju_epw2.py example
+    config = {
+        "path": path,
+        "colinear": True,
+        "posfile": "scf.pwi",
+        "prefix_up": "up/SrMnO3",
+        "prefix_dn": "down/SrMnO3.down",
+        "prefix_SOC": "wannier90",
+        "epw_up_path": f"{path}/up",
+        "epw_down_path": f"{path}/down",
+        "epw_prefix_up": "epmat",
+        "epw_prefix_dn": "epmat",
+        "Ru": (0, 0, 0),
+        "Rcut": 5,
+        "efermi": 11.26,
+        "magnetic_elements": ["Mn"],
+        "kmesh": [3, 3, 3],
+        "emin": -7.3363330034071295,
+        "emax": 0.0,
+        "nz": 70,
+        "np": 1,
+        "exclude_orbs": [],
+        "description": "Double-sided finite difference calculation for dJ/dx",
+        "list_iatom": None,
+        "output_path": f"FD_spinphon_results_sc{nsc}_k{nkpt}",
+        # Additional parameters for finite difference method
+        "supercell_matrix": np.eye(3, dtype=int)*nsc,
+        "amplitude": 0.003,
+        "max_distance": None,
+        # Performance optimization options
+        "compute_d2J": False,      # Set True to compute second derivative d2J/dx2
+        "ispin0_only": True,       # Set True to only compute pairs with ispin=0 or jspin=0
+    }
+
+    # Run calculation for a single displacement pattern (idisp=0)
+    # You can modify this to loop over multiple displacement patterns
+    displacement_patterns = [5, 6, 8, 0]  # Change to range(15) for all patterns
+
+    print("=" * 80)
+    print("Starting double-sided finite difference spin-phonon coupling calculation")
+    print("=" * 80)
+    print(f"Data path: {path}")
+    print(f"Output path: {config['output_path']}")
+    print(f"Displacement patterns: {displacement_patterns}")
+    print(f"Amplitude: {config['amplitude']}")
+    print(
+        f"Method: dJ/dx = (J(+{config['amplitude']}) - J(-{config['amplitude']})) / (2*{config['amplitude']})"
+    )
+    print("\nPerformance optimizations:")
+    print(f"  - compute_d2J: {config['compute_d2J']} {'(computes d2J/dx2)' if config['compute_d2J'] else '(skips J(0) calculation, ~33% faster)'}")
+    print(f"  - ispin0_only: {config['ispin0_only']} {'(only pairs with ispin=0 or jspin=0, ~93% faster)' if config['ispin0_only'] else '(all pairs)'}")
+    if not config['compute_d2J'] and config['ispin0_only']:
+        print(f"  - Combined speedup: ~95% reduction in computation time!")
+    print("=" * 80)
+
+    for idisp in displacement_patterns:
+        print(f"\n{'='*80}")
+        print(f"Processing displacement pattern {idisp}")
+        print(f"{'='*80}")
+
+        try:
+            gen_exchange_Oiju_FD_double_sided(idisp=idisp, **config)
+            print(f"\n{'='*80}")
+            print(f"Successfully completed displacement pattern {idisp}")
+            print("Results saved in:")
+            if config['compute_d2J']:
+                print(f"  - {config['output_path']}/idisp{idisp}_Ru{config['Ru'][0]}_{config['Ru'][1]}_{config['Ru'][2]}/original/")
+            print(f"  - {config['output_path']}/idisp{idisp}_Ru{config['Ru'][0]}_{config['Ru'][1]}_{config['Ru'][2]}/negative/")
+            print(f"  - {config['output_path']}/idisp{idisp}_Ru{config['Ru'][0]}_{config['Ru'][1]}_{config['Ru'][2]}/positive/")
+            print(f"  - {config['output_path']}/idisp{idisp}_Ru{config['Ru'][0]}_{config['Ru'][1]}_{config['Ru'][2]}/dJdx/")
+            print(f"{'='*80}")
+
+        except Exception as e:
+            print(f"\nError processing displacement pattern {idisp}: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    print("\n" + "=" * 80)
+    print("Calculation completed!")
+    print("=" * 80)
+    print("Results structure:")
+    print(f"  {config['output_path']}/")
+    print(f"  └── idisp{{N}}_Ru{{X}}_{{Y}}_{{Z}}/")
+    if config['compute_d2J']:
+        print("      ├── original/         # Exchange at zero displacement")
+    print("      ├── negative/         # Exchange at -amplitude")
+    print("      ├── positive/         # Exchange at +amplitude")
+    print("      └── dJdx/             # Computed dJ/dx derivatives")
+    print("          ├── exchange.out  # Human-readable format")
+    print("          └── dJdx.pickle   # Python dictionary format")
+    print("\nOutput format:")
+    if config['compute_d2J']:
+        print("  - 14 columns: includes J_0, J_neg, J_pos, dJ/dx, d2J/dx2")
+    else:
+        print("  - 12 columns: includes J_neg, J_pos, dJ/dx (no J_0, no d2J/dx2)")
+    if config['ispin0_only']:
+        print("  - Only pairs with ispin=0 or jspin=0 included")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()

TB2J/agent_files/debug_spinphon_fd/test_compute_dJdx.py

@@ -0,0 +1,272 @@
+"""
+Test script for compute_dJdx_from_exchanges function with distance-based sorting.
+
+PURPOSE:
+    Tests the compute_dJdx_from_exchanges function using existing exchange data
+    from FD_spinphon_results to verify:
+    1. Distance-based sorting works correctly
+    2. Output format matches TB2J exchange output order
+    3. dJ/dx and d²J/dx² values are reasonable
+
+USAGE:
+    uv run python agent_files/debug_spinphon_fd/test_compute_dJdx.py
+
+EXPECTED OUTPUT:
+    Creates dJdx/exchange.out with sorted exchange interactions by distance
+    and prints verification information.
+
+FILES USED:
+    - FD_spinphon_results/original/TB2J.pickle
+    - FD_spinphon_results/negative/TB2J.pickle
+    - FD_spinphon_results/positive/TB2J.pickle
+
+DEBUG NOTES:
+    - Uses pickle.load to read existing ExchangeNCL objects
+    - Does not require supercellmap module
+    - Tests only the derivative computation and output formatting
+"""
+
+import os
+import pickle
+
+
+def load_exchange(pickle_path):
+    """Load exchange object from pickle file."""
+    with open(pickle_path, "rb") as f:
+        return pickle.load(f)
+
+
+def compute_dJdx_from_exchanges(
+    exchange_orig, exchange_neg, exchange_pos, amplitude, output_path, compute_d2J=True
+):
+    """
+    Compute dJ/dx and optionally d²J/dx² from exchanges at three positions using finite difference.
+
+    Args:
+        exchange_orig: Exchange dict at zero displacement (can be None if compute_d2J=False)
+        exchange_neg: Exchange dict at -amplitude
+        exchange_pos: Exchange dict at +amplitude
+        amplitude: Displacement amplitude in Angstrom
+        output_path: Directory to save dJdx results
+        compute_d2J: Whether to compute second derivative (default=True)
+    """
+    os.makedirs(output_path, exist_ok=True)
+
+    # Extract isotropic exchange values (dict already contains the data)
+    Jiso_orig = exchange_orig["exchange_Jdict"] if exchange_orig is not None else None
+    Jiso_neg = exchange_neg["exchange_Jdict"]
+    Jiso_pos = exchange_pos["exchange_Jdict"]
+
+    # Get distance information (use neg or pos if orig not available)
+    if exchange_orig is not None:
+        distance_dict = exchange_orig["distance_dict"]
+    else:
+        distance_dict = exchange_neg["distance_dict"]
+
+    # Compute first derivative: dJ/dx = (J_pos - J_neg) / (2*dx)
+    # Note: multiply by 1e3 to convert from eV/A to meV/A
+    dJiso_dx = {}
+    keys_to_use = Jiso_orig.keys() if Jiso_orig is not None else Jiso_neg.keys()
+    for key in keys_to_use:
+        if key in Jiso_pos and key in Jiso_neg:
+            dJiso_dx[key] = (Jiso_pos[key] - Jiso_neg[key]) / (2.0 * amplitude) * 1e3
+
+    # Compute second derivative: d²J/dx² = (J_pos - 2*J_orig + J_neg) / (dx²)
+    # Note: multiply by 1e3 to convert from eV/A² to meV/A²
+    d2Jiso_dx2 = {}
+    if compute_d2J and Jiso_orig is not None:
+        for key in Jiso_orig.keys():
+            if key in Jiso_pos and key in Jiso_neg:
+                d2Jiso_dx2[key] = (
+                    (Jiso_pos[key] - 2.0 * Jiso_orig[key] + Jiso_neg[key])
+                    / (amplitude**2)
+                    * 1e3
+                )
+
+    # Sort keys by first atom index (ispin), then by distance
+    sorted_keys = sorted(dJiso_dx.keys(), key=lambda x: (x[1], distance_dict[x][1]))
+
+    # Save results in text format (sorted by ispin then distance)
+    output_file = os.path.join(output_path, "exchange.out")
+    with open(output_file, "w") as f:
+        if compute_d2J:
+            f.write(
+                "# Derivatives of isotropic exchange computed from finite difference\n"
+            )
+        else:
+            f.write(
+                "# First derivative of isotropic exchange computed from finite difference\n"
+            )
+        f.write(f"# dJ/dx = (J(+{amplitude}) - J(-{amplitude})) / (2*{amplitude})\n")
+        if compute_d2J:
+            f.write(
+                f"# d²J/dx² = (J(+{amplitude}) - 2*J(0) + J(-{amplitude})) / ({amplitude}²)\n"
+            )
+        if compute_d2J:
+            f.write(
+                "# Units: J in meV, distances in Angstrom, dJ/dx in meV/Angstrom, d²J/dx² in meV/Angstrom²\n"
+            )
+        else:
+            f.write("# Units: J in meV, distances in Angstrom, dJ/dx in meV/Angstrom\n")
+        f.write("# Sorted by: first atom index (ispin), then by distance\n")
+        if compute_d2J and Jiso_orig is not None:
+            f.write(
+                "# ispin jspin Rx Ry Rz distance(A) dx(A) dy(A) dz(A) J_0(meV) J_neg(meV) J_pos(meV) dJ/dx d2J/dx2\n"
+            )
+        elif Jiso_orig is None:
+            if compute_d2J:
+                f.write(
+                    "# ispin jspin Rx Ry Rz distance(A) dx(A) dy(A) dz(A) J_neg(meV) J_pos(meV) dJ/dx d2J/dx2\n"
+                )
+            else:
+                f.write(
+                    "# ispin jspin Rx Ry Rz distance(A) dx(A) dy(A) dz(A) J_neg(meV) J_pos(meV) dJ/dx\n"
+                )
+        else:
+            f.write(
+                "# ispin jspin Rx Ry Rz distance(A) dx(A) dy(A) dz(A) J_0(meV) J_neg(meV) J_pos(meV) dJ/dx\n"
+            )
+
+        for key in sorted_keys:
+            R, ispin, jspin = key
+            Rx, Ry, Rz = R
+
+            # Get distance vector and norm
+            vec, distance = distance_dict[key]
+
+            # Get J values (convert from eV to meV)
+            Jneg = Jiso_neg[key] * 1e3
+            Jpos = Jiso_pos[key] * 1e3
+
+            # Write output line
+            line = (
+                f"{ispin:3d} {jspin:3d} {Rx:3d} {Ry:3d} {Rz:3d} "
+                f"{distance:12.8f} {vec[0]:10.6f} {vec[1]:10.6f} {vec[2]:10.6f} "
+            )
+            if Jiso_orig is not None:
+                J0 = Jiso_orig[key] * 1e3
+                line += f"{J0:16.8f} "
+            line += f"{Jneg:16.8f} {Jpos:16.8f} {dJiso_dx[key]:16.8f}"
+            if compute_d2J and key in d2Jiso_dx2:
+                line += f" {d2Jiso_dx2[key]:16.8f}"
+            line += "\n"
+            f.write(line)
+
+    # Save in pickle format
+    pickle_file = os.path.join(output_path, "dJdx.pickle")
+    results = {
+        "dJiso_dx": dJiso_dx,
+        "Jiso_neg": Jiso_neg,
+        "Jiso_pos": Jiso_pos,
+        "amplitude": amplitude,
+    }
+    if Jiso_orig is not None:
+        results["Jiso_orig"] = Jiso_orig
+    if compute_d2J:
+        results["d2Jiso_dx2"] = d2Jiso_dx2
+
+    with open(pickle_file, "wb") as f:
+        pickle.dump(results, f)
+
+    print("Results saved to:")
+    print(f"  {output_file}")
+    print(f"  {pickle_file}")
+    print(f"\nNumber of exchange interactions: {len(dJiso_dx)}")
+
+
+def main():
+    """Test compute_dJdx_from_exchanges with existing data."""
+
+    # Define paths
+    results_dir = "FD_spinphon_results"
+    orig_pickle = os.path.join(results_dir, "original", "TB2J.pickle")
+    neg_pickle = os.path.join(results_dir, "negative", "TB2J.pickle")
+    pos_pickle = os.path.join(results_dir, "positive", "TB2J.pickle")
+    dJdx_dir = os.path.join(results_dir, "dJdx")
+
+    print("=" * 80)
+    print("Testing compute_dJdx_from_exchanges with distance-based sorting")
+    print("=" * 80)
+
+    # Load exchange objects
+    print("\nLoading exchange data...")
+    print(f"  Original: {orig_pickle}")
+    print(f"  Negative: {neg_pickle}")
+    print(f"  Positive: {pos_pickle}")
+
+    exchange_orig = load_exchange(orig_pickle)
+    exchange_neg = load_exchange(neg_pickle)
+    exchange_pos = load_exchange(pos_pickle)
+
+    print("\nExchange objects loaded successfully!")
+    print(f"  Original has {len(exchange_orig['exchange_Jdict'])} interactions")
+    print(f"  Negative has {len(exchange_neg['exchange_Jdict'])} interactions")
+    print(f"  Positive has {len(exchange_pos['exchange_Jdict'])} interactions")
+
+    # Compute derivatives
+    amplitude = 0.01  # Angstrom
+    print(f"\nComputing dJ/dx with amplitude = {amplitude} Angstrom...")
+
+    compute_dJdx_from_exchanges(
+        exchange_orig, exchange_neg, exchange_pos, amplitude, dJdx_dir
+    )
+
+    # Read and display first few lines of output
+    output_file = os.path.join(dJdx_dir, "exchange.out")
+    print("\n" + "=" * 80)
+    print("First 10 lines of output (sorted by distance):")
+    print("=" * 80)
+
+    with open(output_file, "r") as f:
+        lines = f.readlines()
+        for i, line in enumerate(lines[:15]):  # Show header + first 10 data lines
+            print(line.rstrip())
+
+    # Verify manual calculation for first non-header line
+    print("\n" + "=" * 80)
+    print("Manual verification of first interaction:")
+    print("=" * 80)
+
+    # Find first data line
+    with open(output_file, "r") as f:
+        for line in f:
+            if not line.startswith("#"):
+                parts = line.split()
+                if len(parts) == 14:  # Updated: now has distance vector components
+                    ispin, jspin, Rx, Ry, Rz = map(int, parts[:5])
+                    distance, dx, dy, dz, J0, Jneg, Jpos, dJdx, d2Jdx2 = map(
+                        float, parts[5:]
+                    )
+
+                    print(
+                        f"Interaction: ispin={ispin}, jspin={jspin}, R=({Rx},{Ry},{Rz})"
+                    )
+                    print(f"Distance: {distance:.8f} Å")
+                    print(f"Distance vector: ({dx:.8f}, {dy:.8f}, {dz:.8f}) Å")
+                    print(f"J(0) = {J0:.8f} meV")
+                    print(f"J(-dx) = {Jneg:.8f} meV")
+                    print(f"J(+dx) = {Jpos:.8f} meV")
+                    print(f"\nComputed dJ/dx = {dJdx:.8f} meV/Å")
+
+                    # Manual calculation
+                    manual_dJdx = (Jpos - Jneg) / (2.0 * amplitude)
+                    print(f"Manual dJ/dx = (J(+dx) - J(-dx)) / (2*{amplitude})")
+                    print(f"             = ({Jpos:.8f} - {Jneg:.8f}) / {2*amplitude}")
+                    print(f"             = {manual_dJdx:.8f} meV/Å")
+
+                    if abs(dJdx - manual_dJdx) < 1e-6:
+                        print("\n✓ Manual calculation matches!")
+                    else:
+                        print(
+                            f"\n✗ Manual calculation differs by {abs(dJdx - manual_dJdx):.2e}"
+                        )
+
+                    break
+
+    print("\n" + "=" * 80)
+    print("Test completed successfully!")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()