valyte 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

valyte/band.py

@@ -1,289 +1,247 @@
-"""
-Band structure KPOINTS generation module for Valyte.
-"""
+"""Band structure KPOINTS generation."""
 
 import os
 import json
 import numpy as np
 import seekpath
-import spglib
 from pymatgen.core import Structure
 from pymatgen.symmetry.bandstructure import HighSymmKpath
 from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
 try:
     from importlib.resources import files as ilr_files
 except ImportError:
-    import importlib_resources as ilr_files
+    from importlib_resources import files as ilr_files
 
 from valyte.potcar import generate_potcar
 
 
 def generate_band_kpoints(poscar_path="POSCAR", npoints=40, output="KPOINTS", symprec=0.01, mode="bradcrack"):
-    """
-    Generates KPOINTS file in line-mode for band structure calculations.
-    Uses SeeK-path method for high-symmetry path determination.
-    
-    IMPORTANT: Writes a standardized POSCAR (POSCAR_standard) that MUST be used
-    for the band structure calculation to ensure K-points are valid.
-    
-    Args:
-        poscar_path (str): Path to input POSCAR file.
-        npoints (int): Number of points per segment (default: 40).
-        output (str): Output filename for KPOINTS.
-        symprec (float): Symmetry precision for standardization (default: 0.01).
-        mode (str): Standardization convention (default: "bradcrack").
-    """
-    
+    """Generate a line-mode KPOINTS file for band structure calculations."""
+
     if not os.path.exists(poscar_path):
         raise FileNotFoundError(f"{poscar_path} not found")
-    
-    # Read structure
+
+    mode = (mode or "bradcrack").lower()
+
     structure = Structure.from_file(poscar_path)
-    
-    # --- K-Point Generation Logic ---
+
     if mode == "bradcrack":
         try:
             kpath = BradCrackKpath(structure, symprec=symprec)
             prim_std = kpath.prim
             path = kpath.path
             kpoints = kpath.kpoints
-            
-            # Write standardized POSCAR from BradCrack logic
+
             standard_filename = "POSCAR_standard"
             prim_std.to(filename=standard_filename)
         except Exception as e:
-            print(f"❌ Error generating BradCrack path: {e}")
-            return
-
-    else: 
-        # Fallback to Pymatgen logic for other modes
+            raise RuntimeError(f"Error generating Bradley-Cracknell path: {e}")
+    else:
         try:
-            # Map 'seekpath' alias to 'hinuma' which pymatgen uses (wrapper around seekpath)
             if mode == "seekpath":
                 mode = "hinuma"
 
-            # Standardize structure first using SpacegroupAnalyzer
             sga = SpacegroupAnalyzer(structure, symprec=symprec)
             prim_std = sga.get_primitive_standard_structure()
         except Exception as e:
-            print(f"❌ Error during standardization: {e}")
-            return
+            raise RuntimeError(f"Error during standardization: {e}")
 
-        # Get high-symmetry path for the STANDARDIZED structure
         try:
             kpath = HighSymmKpath(prim_std, path_type=mode, symprec=symprec)
-            
-            # Write the standardized primitive structure
+
             standard_filename = "POSCAR_standard"
             prim_std.to(filename=standard_filename)
-            
-            # Get the path
+
             path = kpath.kpath["path"]
             kpoints = kpath.kpath["kpoints"]
         except Exception as e:
-            print(f"❌ Error generating K-path: {e}")
-            return
+            raise RuntimeError(f"Error generating K-path: {e}")
 
-    # Write KPOINTS file
     try:
         with open(output, "w") as f:
             f.write("KPOINTS for Band Structure\n")
             f.write(f"{npoints}\n")
             f.write("Line-mode\n")
             f.write("Reciprocal\n")
-            
+
             for subpath in path:
                 for i in range(len(subpath) - 1):
                     start_label = subpath[i]
-                    end_label = subpath[i+1]
-                    
+                    end_label = subpath[i + 1]
+
                     start_coords = kpoints[start_label]
                     end_coords = kpoints[end_label]
-                    
-                    f.write(f"{start_coords[0]:10.6f} {start_coords[1]:10.6f} {start_coords[2]:10.6f} ! {start_label}\n")
-                    f.write(f"{end_coords[0]:10.6f} {end_coords[1]:10.6f} {end_coords[2]:10.6f} ! {end_label}\n")
-                    f.write("\n") # Optional newline between segments
-
-        print(f"✅ Generated {output} ({' - '.join([' - '.join(seg) for seg in path])})")
-        print(f"✅ Generated {standard_filename} (Standardized Primitive Cell)")
-        print(f"\n⚠️  IMPORTANT: You MUST use '{standard_filename}' for your band calculation!")
-        print(f"   The K-points are generated for this standardized orientation.")
-        print(f"   Using your original POSCAR may result in incorrect paths or 'Reciprocal lattice' errors.")
 
+                    f.write(
+                        f"{start_coords[0]:10.6f} {start_coords[1]:10.6f} {start_coords[2]:10.6f} ! {start_label}\n"
+                    )
+                    f.write(
+                        f"{end_coords[0]:10.6f} {end_coords[1]:10.6f} {end_coords[2]:10.6f} ! {end_label}\n"
+                    )
+                    f.write("\n")
+
+        print(f"Generated {output} ({' - '.join([' - '.join(seg) for seg in path])})")
+        print(f"Generated {standard_filename} (Standardized Primitive Cell)")
+        print("IMPORTANT: Use POSCAR_standard for the band calculation.")
     except Exception as e:
-        print(f"❌ Error writing KPOINTS file: {e}")
+        raise RuntimeError(f"Error writing KPOINTS file: {e}")
 
-    # --- POTCAR Generation ---
     try:
-        print("ℹ️  Generating default POTCAR (PBE)...")
+        print("Generating default POTCAR (PBE)...")
         generate_potcar(poscar_path=poscar_path, functional="PBE", output="POTCAR")
     except Exception as e:
-        print(f"⚠️  Could not generate POTCAR: {e}")
-        print("   (Proceeding without stopping, as KPOINTS are already generated)")
-
+        print(f"Warning: could not generate POTCAR: {e}")
+        print("Proceeding without POTCAR generation.")
 
 
 class BradCrackKpath:
-    """
-    Native implementation of Bradley-Cracknell K-path generation.
-    Replicates logic from Sumo/SeeK-path to determine standard paths.
-    """
+    """Bradley-Cracknell K-path generation using SeeK-path output."""
+
     def __init__(self, structure, symprec=0.01):
         self.structure = structure
         self.symprec = symprec
-        
-        # Use SpacegroupAnalyzer for basic data
+
         sga = SpacegroupAnalyzer(structure, symprec=symprec)
         self._spg_data = sga.get_symmetry_dataset()
-        
-        # Use SeeK-path to get primitive/conventional structures matches Sumo Kpath.__init__
-        
-        # refine_cell logic from Sumo base class
-        # atom_numbers = [site.specie.number for site in structure] 
-        # But pymatgen structure to spglib cell tuple:
-        # cell = (lattice, positions, numbers)
-        cell = (structure.lattice.matrix, structure.frac_coords, [s.specie.number for s in structure])
-        
-        # Sumo uses spglib.refine_cell on the cell first? 
-        # "std = spglib.refine_cell(sym._cell, symprec=symprec)" 
-        # pymatgen sga._cell is (lattice, positions, numbers)
-        
-        # seekpath.get_path takes the cell structure
-        # output is dictionary
+
+        cell = (
+            structure.lattice.matrix,
+            structure.frac_coords,
+            [s.specie.number for s in structure],
+        )
+
         self._seek_data = seekpath.get_path(cell, symprec=symprec)
-        
-        # Reconstruct primitive structure from seekpath output
+
         prim_lattice = self._seek_data["primitive_lattice"]
         prim_pos = self._seek_data["primitive_positions"]
         prim_types = self._seek_data["primitive_types"]
-        # Map types back to species? 
-        # We need a map from number to Element. 
-        # unique_species from sga?
-        # Let's just use explicit element list from input structure, assuming types are consistent?
-        # Or better, use sga to map Z to elements.
-        
-        # Setup element mapping
-        # Create a map from atomic number to Element object from input structure
+
         z_to_specie = {s.specie.number: s.specie for s in structure}
         prim_species = [z_to_specie[z] for z in prim_types]
-        
+
         self.prim = Structure(prim_lattice, prim_species, prim_pos)
-        
+
         conv_lattice = self._seek_data["conv_lattice"]
         conv_pos = self._seek_data["conv_positions"]
         conv_types = self._seek_data["conv_types"]
         conv_species = [z_to_specie[z] for z in conv_types]
         self.conv = Structure(conv_lattice, conv_species, conv_pos)
-        
-        # Now determine Bravais lattice for BradCrack
+
         self._get_bradcrack_path()
 
     def _get_bradcrack_path(self):
-        
-        # Determine lattice parameters from CONVENTIONAL cell
         a, b, c = self.conv.lattice.abc
         angles = self.conv.lattice.angles
-        # finding unique axis for monoclinic
-        # logic from BradCrackKpath.__init__
-        # "unique = angles.index(min(angles, key=angles.count))"
-        # usually 90, 90, beta. So unique is beta (non-90) index? No.
-        # Monoclinic: alpha=gamma=90, beta!=90. 90 appears twice. non-90 appears once.
-        # min count of angle values?
-        # if angles are [90, 90, 105], counts are {90:2, 105:1}. min count is 1. value is 105. index is 2.
-        # so unique is index of non-90 degree angle.
-        
-        # Round angles to avoid float issues
+
         angles_r = [round(x, 3) for x in angles]
         unique_val = min(angles_r, key=angles_r.count)
         unique = angles_r.index(unique_val)
 
-        # Get Space Group Symbol and Number
-        # From seekpath? or sga? 
-        # Sumo uses: "spg_symbol = self.spg_symbol" which is "self._spg_data['international']"
-        # spglib dataset returns 'international'
         spg_symbol = self._spg_data["international"]
         spg_number = self._spg_data["number"]
-        
+
         lattice_type = self.get_lattice_type(spg_number)
-        
         bravais = self._get_bravais_lattice(spg_symbol, lattice_type, a, b, c, unique)
-        
-        # Load JSON
-        
+
         json_file = ilr_files("valyte.data").joinpath("bradcrack.json")
-        with open(json_file, 'r') as f:
+        with json_file.open("r") as f:
             data = json.load(f)
-            
+
         if bravais not in data:
             raise ValueError(f"Bravais lattice code '{bravais}' not found in BradCrack data.")
-            
+
         self.bradcrack_data = data[bravais]
         self.kpoints = self.bradcrack_data["kpoints"]
         self.path = self.bradcrack_data["path"]
 
     def get_lattice_type(self, number):
-        # Logic from Sumo
-        if 1 <= number <= 2: return "triclinic"
-        if 3 <= number <= 15: return "monoclinic"
-        if 16 <= number <= 74: return "orthorhombic"
-        if 75 <= number <= 142: return "tetragonal"
-        if 143 <= number <= 167: 
-            if number in [146, 148, 155, 160, 161, 166, 167]: return "rhombohedral"
+        if 1 <= number <= 2:
+            return "triclinic"
+        if 3 <= number <= 15:
+            return "monoclinic"
+        if 16 <= number <= 74:
+            return "orthorhombic"
+        if 75 <= number <= 142:
+            return "tetragonal"
+        if 143 <= number <= 167:
+            if number in [146, 148, 155, 160, 161, 166, 167]:
+                return "rhombohedral"
             return "trigonal"
-        if 168 <= number <= 194: return "hexagonal"
-        if 195 <= number <= 230: return "cubic"
+        if 168 <= number <= 194:
+            return "hexagonal"
+        if 195 <= number <= 230:
+            return "cubic"
         return "unknown"
 
     def _get_bravais_lattice(self, spg_symbol, lattice_type, a, b, c, unique):
-        # Logic from Sumo BradCrackKpath._get_bravais_lattice
-        if lattice_type == "triclinic": return "triclinic"
-        
-        elif lattice_type == "monoclinic":
+        if lattice_type == "triclinic":
+            return "triclinic"
+
+        if lattice_type == "monoclinic":
+            if "P" in spg_symbol:
+                if unique == 0:
+                    return "mon_p_a"
+                if unique == 1:
+                    return "mon_p_b"
+                if unique == 2:
+                    return "mon_p_c"
+            if "C" in spg_symbol:
+                if unique == 0:
+                    return "mon_c_a"
+                if unique == 1:
+                    return "mon_c_b"
+                if unique == 2:
+                    return "mon_c_c"
+
+        if lattice_type == "orthorhombic":
             if "P" in spg_symbol:
-                if unique == 0: return "mon_p_a"
-                elif unique == 1: return "mon_p_b"
-                elif unique == 2: return "mon_p_c"
-            elif "C" in spg_symbol:
-                if unique == 0: return "mon_c_a"
-                elif unique == 1: return "mon_c_b"
-                elif unique == 2: return "mon_c_c"
-        
-        elif lattice_type == "orthorhombic":
-            if "P" in spg_symbol: return "orth_p"
-            elif "A" in spg_symbol or "C" in spg_symbol:
-                if a > b: return "orth_c_a"
-                elif b > a: return "orth_c_b"
-            elif "F" in spg_symbol:
-                # 1/a^2 etc conditions... need to replicate exact math
-                # Copied from Sumo source view
-                inv_a2 = 1/a**2; inv_b2 = 1/b**2; inv_c2 = 1/c**2
+                return "orth_p"
+            if "A" in spg_symbol or "C" in spg_symbol:
+                if a > b:
+                    return "orth_c_a"
+                if b > a:
+                    return "orth_c_b"
+            if "F" in spg_symbol:
+                inv_a2 = 1 / a**2
+                inv_b2 = 1 / b**2
+                inv_c2 = 1 / c**2
                 if (inv_a2 < inv_b2 + inv_c2) and (inv_b2 < inv_c2 + inv_a2) and (inv_c2 < inv_a2 + inv_b2):
                     return "orth_f_1"
-                elif inv_c2 > inv_a2 + inv_b2: return "orth_f_2"
-                elif inv_b2 > inv_a2 + inv_c2: return "orth_f_3"
-                elif inv_a2 > inv_c2 + inv_b2: return "orth_f_4"
-            elif "I" in spg_symbol:
-                if a > b and a > c: return "orth_i_a"
-                elif b > a and b > c: return "orth_i_b"
-                elif c > a and c > b: return "orth_i_c"
-
-        elif lattice_type == "tetragonal":
-            if "P" in spg_symbol: return "tet_p"
-            elif "I" in spg_symbol:
-                if a > c: return "tet_i_a"
-                else: return "tet_i_c"
-
-        elif lattice_type in ["trigonal", "hexagonal", "rhombohedral"]:
+                if inv_c2 > inv_a2 + inv_b2:
+                    return "orth_f_2"
+                if inv_b2 > inv_a2 + inv_c2:
+                    return "orth_f_3"
+                if inv_a2 > inv_c2 + inv_b2:
+                    return "orth_f_4"
+            if "I" in spg_symbol:
+                if a > b and a > c:
+                    return "orth_i_a"
+                if b > a and b > c:
+                    return "orth_i_b"
+                if c > a and c > b:
+                    return "orth_i_c"
+
+        if lattice_type == "tetragonal":
+            if "P" in spg_symbol:
+                return "tet_p"
+            if "I" in spg_symbol:
+                return "tet_i_a" if a > c else "tet_i_c"
+
+        if lattice_type in ["trigonal", "hexagonal", "rhombohedral"]:
             if "R" in spg_symbol:
-                if a > np.sqrt(2)*c: return "trig_r_a"
-                else: return "trig_r_c"
-            elif "P" in spg_symbol:
-                if unique == 0: return "trig_p_a"
-                elif unique == 2: return "trig_p_c"
-
-        elif lattice_type == "cubic":
-            if "P" in spg_symbol: return "cubic_p"
-            elif "I" in spg_symbol: return "cubic_i"
-            elif "F" in spg_symbol: return "cubic_f"
-            
+                return "trig_r_a" if a > np.sqrt(2) * c else "trig_r_c"
+            if "P" in spg_symbol:
+                if unique == 0:
+                    return "trig_p_a"
+                if unique == 2:
+                    return "trig_p_c"
+
+        if lattice_type == "cubic":
+            if "P" in spg_symbol:
+                return "cubic_p"
+            if "I" in spg_symbol:
+                return "cubic_i"
+            if "F" in spg_symbol:
+                return "cubic_f"
+
         return "unknown"

valyte/band_plot.py

@@ -4,25 +4,17 @@ import matplotlib as mpl
 mpl.use("agg")
 mpl.rcParams["axes.unicode_minus"] = False
 import matplotlib.pyplot as plt
-from pymatgen.io.vasp import Vasprun, BSVasprun
+from pymatgen.io.vasp import BSVasprun
 from pymatgen.electronic_structure.plotter import BSPlotter
 
+
 def plot_band_structure(vasprun_path, kpoints_path=None, output="valyte_band.png",
                         ylim=None, figsize=(4, 4), dpi=400, font="Arial"):
-    """
-    Plots the electronic band structure from vasprun.xml.
-    
-    Args:
-        vasprun_path (str): Path to vasprun.xml file.
-        kpoints_path (str, optional): Path to KPOINTS file (for labels).
-        output (str): Output filename.
-        ylim (tuple, optional): Energy range (min, max).
-        figsize (tuple): Figure size in inches.
-        dpi (int): Resolution of the output image.
-        font (str): Font family.
-    """
-    
-    # --- Font configuration ---
+    """Plot the electronic band structure from a VASP vasprun.xml."""
+
+    if os.path.isdir(vasprun_path):
+        vasprun_path = os.path.join(vasprun_path, "vasprun.xml")
+
     font_map = {
         "arial": "Arial",
         "helvetica": "Helvetica",
@@ -37,91 +29,58 @@ def plot_band_structure(vasprun_path, kpoints_path=None, output="valyte_band.png
     mpl.rcParams["xtick.major.width"] = 1.2
     mpl.rcParams["ytick.major.width"] = 1.2
 
-    # print(f"🔍 Reading {vasprun_path} ...") # Silent mode
-    
     try:
-        # Load VASP output
-        # BSVasprun is optimized for band structures
         vr = BSVasprun(vasprun_path, parse_projected_eigen=False)
         bs = vr.get_band_structure(kpoints_filename=kpoints_path, line_mode=True)
     except Exception as e:
         raise ValueError(f"Failed to load band structure: {e}")
 
-    # Use BSPlotter to get the data in a plot-friendly format
     bs_plotter = BSPlotter(bs)
     data = bs_plotter.bs_plot_data(zero_to_efermi=True)
-    
-    # Extract data
-    distances = data['distances'] # List of lists (one per segment)
-    energies = data['energy']     # Can be list of dicts OR dict of lists depending on pymatgen version/structure
-    ticks = data['ticks']         # Dict with 'distance' and 'label'
-    
-    # Setup plot
+
+    distances = data["distances"]
+    energies = data["energy"]
+    ticks = data["ticks"]
+
     fig, ax = plt.subplots(figsize=figsize)
-    
-    # Colors
-    color_vb = "#8e44ad" # Purple
-    color_cb = "#2a9d8f" # Teal
-    
-    # Plot bands
-    # Iterate over segments
+
+    color_vb = "#8e44ad"
+    color_cb = "#2a9d8f"
+
     for i in range(len(distances)):
         d = distances[i]
-        
-        # Handle different energy data structures
+
         if isinstance(energies, dict):
-            # Structure: {'1': [seg1, seg2, ...], '-1': ...}
-            # Iterate over spins
             for spin in energies:
-                # energies[spin] is a list of segments
-                # energies[spin][i] is the list of bands for segment i
                 for band in energies[spin][i]:
-                    # Determine color based on energy relative to VBM (0 eV)
-                    if np.mean(band) <= 0:
-                        c = color_vb
-                    else:
-                        c = color_cb
+                    c = color_vb if np.mean(band) <= 0 else color_cb
                     ax.plot(d, band, color=c, lw=1.5, alpha=1.0)
         else:
-            # Structure: [{'1': bands, ...}, {'1': bands, ...}] (List of dicts)
-            # Iterate over spin channels in this segment
             for spin in energies[i]:
-                # energies[i][spin] is a list of arrays (one per band)
                 for band in energies[i][spin]:
-                    if np.mean(band) <= 0:
-                        c = color_vb
-                    else:
-                        c = color_cb
+                    c = color_vb if np.mean(band) <= 0 else color_cb
                     ax.plot(d, band, color=c, lw=1.5, alpha=1.0)
 
-    # Setup X-axis (K-path)
-    ax.set_xticks(ticks['distance'])
-    # Clean up labels (remove formatting like $ if needed, but pymatgen usually does a good job)
-    clean_labels = [l.replace("$\\mid$", "|") for l in ticks['label']]
+    ax.set_xticks(ticks["distance"])
+    clean_labels = [(l or "").replace("$\\mid$", "|") for l in ticks["label"]]
     ax.set_xticklabels(clean_labels, fontsize=14, fontweight="bold")
-    
-    # Draw vertical lines at high-symmetry points
-    for d in ticks['distance']:
+
+    for d in ticks["distance"]:
         ax.axvline(d, color="k", lw=0.8, ls="-", alpha=0.3)
-        
-    # Draw VBM line (E=0)
+
     ax.axhline(0, color="k", lw=0.8, ls="--", alpha=0.5)
 
-    # Setup Y-axis
     ax.set_ylabel("Energy (eV)", fontsize=16, fontweight="bold", labelpad=8)
     if ylim:
         ax.set_ylim(ylim)
-        # Set y-ticks with 1 eV spacing
         yticks = np.arange(np.ceil(ylim[0]), np.floor(ylim[1]) + 1, 1)
         ax.set_yticks(yticks)
     else:
-        # Default zoom around gap
         ax.set_ylim(-4, 4)
         ax.set_yticks(np.arange(-4, 5, 1))
-        
+
     ax.set_xlim(distances[0][0], distances[-1][-1])
 
     plt.tight_layout()
     plt.savefig(output, dpi=dpi)
     plt.close(fig)
-    # print(f"✅ Band structure saved to {output}") # Silent mode