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

TB2J/agent_files/debug_spinphon_fd/debug_main.py

@@ -1,156 +0,0 @@
-"""
-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

@@ -1,272 +0,0 @@
-"""
-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()

TB2J/agent_files/debug_spinphon_fd/test_ispin0_only.py

@@ -1,120 +0,0 @@
-"""
-Test script for ispin0_only parameter.
-
-PURPOSE:
-    Tests that ispin0_only=True correctly filters exchange pairs to only include
-    those where the first spin index (ispin) is 0, significantly reducing computation time.
-
-USAGE:
-    uv run python TB2J/agent_files/debug_spinphon_fd/test_ispin0_only.py
-
-EXPECTED OUTPUT:
-    - Comparison of number of pairs computed with ispin0_only=False vs True
-    - Verification that all pairs in ispin0_only=True output have ispin=0
-    - Demonstration of computational savings
-"""
-
-import sys
-import os
-sys.path.insert(0, '../..')
-from test_compute_dJdx import compute_dJdx_from_exchanges, load_exchange
-
-print("Testing ispin0_only parameter...")
-print("=" * 80)
-
-# Use available test data
-base_path = 'FD_spinphon_results_0.001_k333_nocenter/idisp0_Ru0_0_0'
-
-print("\n1. Testing with ispin0_only=False (default - all pairs)")
-print("-" * 80)
-neg = load_exchange(os.path.join(base_path, 'negative/TB2J.pickle'))
-pos = load_exchange(os.path.join(base_path, 'positive/TB2J.pickle'))
-
-compute_dJdx_from_exchanges(None, neg, pos, 0.001, 'test_all_pairs_output', compute_d2J=False)
-
-# Count total pairs
-with open('test_all_pairs_output/exchange.out', 'r') as f:
-    all_pairs_count = sum(1 for line in f if not line.startswith('#'))
-
-print(f"Total number of exchange pairs computed: {all_pairs_count}")
-
-# Check ispin distribution
-ispin_counts = {}
-with open('test_all_pairs_output/exchange.out', 'r') as f:
-    for line in f:
-        if not line.startswith('#'):
-            parts = line.split()
-            ispin = int(parts[0])
-            ispin_counts[ispin] = ispin_counts.get(ispin, 0) + 1
-
-print(f"Distribution by ispin: {dict(sorted(ispin_counts.items()))}")
-
-print("\n2. Testing with ispin0_only=True (only ispin=0 or jspin=0 pairs)")
-print("-" * 80)
-
-# Note: In actual usage, we would create new Exchange objects with ispin0_only=True
-# Here we're just testing the filtering in compute_dJdx_from_exchanges
-# The real performance gain comes from Exchange class not computing the other pairs
-
-# For this test, we manually filter to simulate the behavior
-neg_filtered = load_exchange(os.path.join(base_path, 'negative/TB2J.pickle'))
-pos_filtered = load_exchange(os.path.join(base_path, 'positive/TB2J.pickle'))
-
-# Filter the dictionaries
-def filter_ispin0(exchange_dict):
-    """Filter exchange dict to only include pairs where ispin=0 or jspin=0"""
-    filtered = {}
-    filtered['exchange_Jdict'] = {k: v for k, v in exchange_dict['exchange_Jdict'].items() if k[1] == 0 or k[2] == 0}
-    filtered['distance_dict'] = {k: v for k, v in exchange_dict['distance_dict'].items() if k[1] == 0 or k[2] == 0}
-    return filtered
-
-neg_filtered = filter_ispin0(neg_filtered)
-pos_filtered = filter_ispin0(pos_filtered)
-
-compute_dJdx_from_exchanges(None, neg_filtered, pos_filtered, 0.001, 'test_ispin0_output', compute_d2J=False)
-
-# Count ispin0 pairs
-with open('test_ispin0_output/exchange.out', 'r') as f:
-    ispin0_pairs_count = sum(1 for line in f if not line.startswith('#'))
-
-print(f"Number of exchange pairs with ispin=0 or jspin=0: {ispin0_pairs_count}")
-
-# Verify all pairs have ispin=0 or jspin=0
-all_valid = True
-ispin0_count = 0
-jspin0_count = 0
-both0_count = 0
-with open('test_ispin0_output/exchange.out', 'r') as f:
-    for line in f:
-        if not line.startswith('#'):
-            parts = line.split()
-            ispin = int(parts[0])
-            jspin = int(parts[1])
-            if ispin != 0 and jspin != 0:
-                all_valid = False
-                print(f"ERROR: Found pair with ispin={ispin}, jspin={jspin}")
-                break
-            if ispin == 0 and jspin == 0:
-                both0_count += 1
-            elif ispin == 0:
-                ispin0_count += 1
-            elif jspin == 0:
-                jspin0_count += 1
-
-if all_valid:
-    print("✓ All pairs have ispin=0 or jspin=0")
-    print(f"  - Pairs with both ispin=0 and jspin=0: {both0_count}")
-    print(f"  - Pairs with ispin=0 only: {ispin0_count}")
-    print(f"  - Pairs with jspin=0 only: {jspin0_count}")
-
-print("\n3. Performance comparison")
-print("-" * 80)
-reduction = (all_pairs_count - ispin0_pairs_count) / all_pairs_count * 100
-print(f"Pairs reduced: {all_pairs_count} → {ispin0_pairs_count}")
-print(f"Reduction: {reduction:.1f}%")
-print(f"Speedup factor: ~{all_pairs_count / ispin0_pairs_count:.1f}x")
-
-print("\n" + "=" * 80)
-print("Test completed successfully!")
-print("\nNOTE: In actual usage with Exchange class, the performance gain comes from")
-print("not computing the filtered pairs at all, not just filtering the output.")

TB2J/agent_files/debug_spinphon_fd/test_no_d2j.py

@@ -1,31 +0,0 @@
-"""Test script with compute_d2J=False"""
-import sys
-import os
-sys.path.insert(0, '../..')
-from test_compute_dJdx import compute_dJdx_from_exchanges, load_exchange
-
-print("Testing with compute_d2J=False (skips J_0 computation)...")
-
-# Use available test data
-base_path = 'FD_spinphon_results_0.001_k333_nocenter/idisp0_Ru0_0_0'
-neg = load_exchange(os.path.join(base_path, 'negative/TB2J.pickle'))
-pos = load_exchange(os.path.join(base_path, 'positive/TB2J.pickle'))
-
-# Note: passing orig=None when compute_d2J=False
-compute_dJdx_from_exchanges(None, neg, pos, 0.001, 'test_no_d2j_output', compute_d2J=False)
-
-print("\nFirst 12 lines of output:")
-with open('test_no_d2j_output/exchange.out', 'r') as f:
-    for i, line in enumerate(f):
-        if i < 12:
-            print(line.rstrip())
-
-print("\nChecking number of columns:")
-with open('test_no_d2j_output/exchange.out', 'r') as f:
-    for line in f:
-        if not line.startswith('#'):
-            parts = line.split()
-            print(f"Found {len(parts)} columns (expected 12: no J_0, no d2J/dx2)")
-            break
-
-print("\nTest completed!")

TB2J/agent_files/debug_spinphon_fd/test_with_d2j.py

@@ -1,28 +0,0 @@
-"""Test script with compute_d2J=True (default)"""
-import sys
-sys.path.insert(0, '../..')
-from test_compute_dJdx import compute_dJdx_from_exchanges, load_exchange
-
-print("Testing with compute_d2J=True (default)...")
-
-orig = load_exchange('FD_spinphon_results_222/original/TB2J.pickle')
-neg = load_exchange('FD_spinphon_results_222/negative/TB2J.pickle')
-pos = load_exchange('FD_spinphon_results_222/positive/TB2J.pickle')
-
-compute_dJdx_from_exchanges(orig, neg, pos, 0.01, 'test_with_d2j_output')
-
-print("\nFirst 12 lines of output:")
-with open('test_with_d2j_output/exchange.out', 'r') as f:
-    for i, line in enumerate(f):
-        if i < 12:
-            print(line.rstrip())
-
-print("\nChecking number of columns:")
-with open('test_with_d2j_output/exchange.out', 'r') as f:
-    for line in f:
-        if not line.startswith('#'):
-            parts = line.split()
-            print(f"Found {len(parts)} columns (expected 14 with d2J)")
-            break
-
-print("\nTest completed!")

TB2J/interfaces/abacus/test_read_HRSR.py

@@ -1,43 +0,0 @@
-from abacus_api import read_HR_SR
-
-
-def main():
-    # nspin = 2 case
-    nspin = 2
-    binary = False
-    file_path = "../abacus_example/case_Sr2Mn2O6/1_no_soc/OUT.Sr2Mn2O6/"
-    HR_file = [
-        file_path + "data-HR-sparse_SPIN0.csr",
-        file_path + "data-HR-sparse_SPIN1.csr",
-    ]
-    SR_file = file_path + "data-SR-sparse_SPIN0.csr"
-
-    basis_num, R_direct_coor, HR_up, HR_dn, SR = read_HR_SR(
-        nspin, binary, HR_file, SR_file
-    )
-
-    print("basis_num =", basis_num)
-    print("R_direct_coor =", R_direct_coor)
-    print("HR_up[1, 0, 15:22] =", HR_up[1, 0, 15:22])
-    print("HR_dn[1, 0, 15:22] =", HR_dn[1, 0, 15:22])
-    print("SR[1, 0, 15:22] =", SR[1, 0, 15:22])
-
-    # nspin = 4 case
-    nspin = 4
-    binary = False
-    file_path = "../abacus_example/case_Sr2Mn2O6/2_soc/OUT.Sr2Mn2O6/"
-    HR_file = file_path + "data-HR-sparse_SPIN0.csr"
-    SR_file = file_path + "data-SR-sparse_SPIN0.csr"
-
-    basis_num, R_direct_coor, HR, SR = read_HR_SR(nspin, binary, HR_file, SR_file)
-
-    print("basis_num =", basis_num)
-    print("R_direct_coor =", R_direct_coor)
-    print("HR[1, 0, 30:37] =", HR[1, 0, 30:37])
-    print("SR[1, 0, 30:37] =", SR[1, 0, 30:37])
-
-    return
-
-
-if __name__ == "__main__":
-    main()

TB2J/interfaces/abacus/test_read_stru.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@File    :   test_read_stru.py
-@Time    :   2024/02/02 09:52:23
-@Author  :   Shen Zhen-Xiong
-@Email   :   shenzx@iai.ustc.edu.cn
-"""
-
-import os
-
-from stru_api import read_abacus, read_input, write_abacus
-
-
-def main():
-    # stru_fe = read_abacus(os.path.join(os.getcwd(), "input/Fe.STRU"))
-    stru_sr2mn2o6 = read_abacus(
-        os.path.join(os.getcwd(), "input/Sr2Mn2O6.STRU"), verbose=True
-    )
-    write_abacus(
-        file=os.path.join(os.getcwd(), "STRU"),
-        atoms=stru_sr2mn2o6,
-        pp=stru_sr2mn2o6.info["pp"],
-        basis=stru_sr2mn2o6.info["basis"],
-    )
-    input_file = read_input(os.path.join(os.getcwd(), "input/INPUT"))
-    print(input_file["pseudo_dir"])
-    return
-
-
-if __name__ == "__main__":
-    main()