valyte 0.1.0__py3-none-any.whl

valyte/band.py

@@ -0,0 +1,56 @@
+"""
+Band structure KPOINTS generation module for Valyte.
+"""
+
+import os
+from pymatgen.core import Structure
+from pymatgen.symmetry.bandstructure import HighSymmKpath
+
+
+def generate_band_kpoints(poscar_path="POSCAR", npoints=40, output="KPOINTS"):
+    """
+    Generates KPOINTS file in line-mode for band structure calculations.
+    Uses SeeK-path method for high-symmetry path determination.
+    
+    Args:
+        poscar_path (str): Path to input POSCAR file.
+        npoints (int): Number of points per segment (default: 40).
+        output (str): Output filename for KPOINTS.
+    """
+    
+    if not os.path.exists(poscar_path):
+        raise FileNotFoundError(f"{poscar_path} not found")
+    
+    # Read structure
+    structure = Structure.from_file(poscar_path)
+    
+    # Get high-symmetry path using SeeK-path method
+    kpath = HighSymmKpath(structure, path_type="setyawan_curtarolo")
+    
+    # Get the path
+    path = kpath.kpath["path"]
+    kpoints = kpath.kpath["kpoints"]
+    
+    # Write KPOINTS file
+    with open(output, 'w') as f:
+        f.write("k-points for band structure\n")
+        f.write(f"{npoints}\n")
+        f.write("Line-mode\n")
+        f.write("Reciprocal\n")
+        
+        # Write each segment
+        for segment in path:
+            for i in range(len(segment) - 1):
+                start = segment[i]
+                end = segment[i + 1]
+                
+                start_coords = kpoints[start]
+                end_coords = kpoints[end]
+                
+                f.write(f"  {start_coords[0]:.6f}  {start_coords[1]:.6f}  {start_coords[2]:.6f}  ! {start}\n")
+                f.write(f"  {end_coords[0]:.6f}  {end_coords[1]:.6f}  {end_coords[2]:.6f}  ! {end}\n")
+                f.write("\n")
+    
+    # Print success message
+    path_str = ' → '.join([' - '.join(seg) for seg in path])
+    print(f"✅ KPOINTS generated: {output} ({path_str}, {npoints} pts/seg)")

valyte/band_plot.py

@@ -0,0 +1,127 @@
+import os
+import numpy as np
+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.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 ---
+    font_map = {
+        "arial": "Arial",
+        "helvetica": "Helvetica",
+        "times": "Times New Roman",
+        "times new roman": "Times New Roman",
+    }
+    font = font_map.get(font.lower(), "Arial")
+    mpl.rcParams["font.family"] = font
+    mpl.rcParams["axes.linewidth"] = 1.4
+    mpl.rcParams["font.weight"] = "bold"
+    mpl.rcParams["font.size"] = 14
+    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
+    fig, ax = plt.subplots(figsize=figsize)
+    
+    # Colors
+    color_vb = "#8e44ad" # Purple
+    color_cb = "#2a9d8f" # Teal
+    
+    # Plot bands
+    # Iterate over segments
+    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
+                    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
+                    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_xticklabels(clean_labels, fontsize=14, fontweight="bold")
+    
+    # Draw vertical lines at high-symmetry points
+    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

valyte/cli.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+Valyte CLI Tool
+===============
+
+A post-processing tool for VASP outputs, designed to create publication-quality
+plots with a modern aesthetic. Supports DOS and band structure plotting.
+
+Features:
+- DOS plotting with gradient fills
+- Band structure plotting
+- Smart legend positioning
+- Custom font support
+"""
+
+import os
+import sys
+import argparse
+import re
+import warnings
+
+# Suppress pymatgen warnings
+warnings.filterwarnings("ignore", category=UserWarning, module="pymatgen")
+
+from valyte.supercell import create_supercell
+from valyte.band import generate_band_kpoints
+from valyte.band_plot import plot_band_structure
+from valyte.dos_plot import load_dos, plot_dos
+from valyte.kpoints import generate_kpoints_interactive
+
+def parse_element_selection(inputs):
+    """
+    Parses user input for elements and orbitals.
+    
+    Args:
+        inputs (list): List of strings, e.g., ["Ag", "Bi(s)", "O(p)"]
+        
+    Returns:
+        tuple: (elements_to_load, plotting_config)
+            elements_to_load (list): Elements to extract from VASP data.
+            plotting_config (list): List of (Element, Orbital) tuples.
+    """
+    if not inputs:
+        return None, None
+
+    elements_to_load = set()
+    plotting_config = []
+    
+    # Regex to match "Element" or "Element(orbital)"
+    pattern = re.compile(r"^([A-Za-z]+)(?:\(([spdf])\))?$")
+    
+    for item in inputs:
+        match = pattern.match(item)
+        if match:
+            el = match.group(1)
+            orb = match.group(2) # None if no orbital specified
+            
+            elements_to_load.add(el)
+            if orb:
+                plotting_config.append((el, orb))
+            else:
+                plotting_config.append((el, 'total'))
+        else:
+            print(f"⚠️ Warning: Could not parse '{item}'. Ignoring.")
+            
+
+    return list(elements_to_load), plotting_config
+
+
+# ===============================================================
+# Main CLI
+# ===============================================================
+def main():
+    """
+    Main entry point for the CLI.
+    """
+    parser = argparse.ArgumentParser(description="Valyte: VASP Post-Processing Tool")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # --- DOS Subcommand ---
+    dos_parser = subparsers.add_parser("dos", help="Plot Density of States (DOS)")
+    dos_parser.add_argument("filepath", nargs="?", help="Path to vasprun.xml or directory containing it (optional)")
+    dos_parser.add_argument("--vasprun", help="Explicit path to vasprun.xml (alternative to positional argument)")
+    dos_parser.add_argument("-e", "--elements", nargs="+", help="Elements/Orbitals to plot (e.g., 'Fe O' or 'Fe(d) O(p)')")
+    dos_parser.add_argument("-o", "--output", default="valyte_dos.png", help="Output filename")
+    dos_parser.add_argument("--xlim", nargs=2, type=float, default=[-6, 6], help="Energy range (min max)")
+    dos_parser.add_argument("--ylim", nargs=2, type=float, help="DOS range (min max)")
+    dos_parser.add_argument("--scale", type=float, default=1.0, help="Scaling factor for Y-axis (zoom in)")
+    dos_parser.add_argument("--fermi", action="store_true", help="Draw dashed line at Fermi level (E=0)")
+    dos_parser.add_argument("--pdos", action="store_true", help="Plot only Projected DOS (hide Total DOS)")
+    dos_parser.add_argument("--legend-cutoff", type=float, default=0.10, help="Threshold for legend visibility (0.0-1.0)")
+    dos_parser.add_argument("--font", default="Arial", help="Font family")
+
+    # --- Supercell Subcommand ---
+    supercell_parser = subparsers.add_parser("supercell", help="Create a supercell")
+    supercell_parser.add_argument("nx", type=int, help="Supercell size x")
+    supercell_parser.add_argument("ny", type=int, help="Supercell size y")
+    supercell_parser.add_argument("nz", type=int, help="Supercell size z")
+    supercell_parser.add_argument("-i", "--input", default="POSCAR", help="Input POSCAR file")
+    supercell_parser.add_argument("-o", "--output", default="POSCAR_supercell", help="Output filename")
+
+    # --- Band Structure Subcommand ---
+    band_parser = subparsers.add_parser("band", help="Band structure utilities")
+    band_subparsers = band_parser.add_subparsers(dest="band_command", help="Band commands")
+
+    # Band Plotting (default if no subcommand)
+    # Note: argparse doesn't easily support default subcommands, so we handle this in logic
+    band_parser.add_argument("--vasprun", default=".", help="Path to vasprun.xml or directory")
+    band_parser.add_argument("--kpoints", help="Path to KPOINTS file (for labels)")
+    band_parser.add_argument("-o", "--output", default="valyte_band.png", help="Output filename")
+    band_parser.add_argument("--ylim", nargs=2, type=float, help="Energy range (min max)")
+    band_parser.add_argument("--font", default="Arial", help="Font family")
+
+    # Band KPOINTS Generation
+    kpt_gen_parser = band_subparsers.add_parser("kpt-gen", help="Generate KPOINTS for band structure")
+    kpt_gen_parser.add_argument("-i", "--input", default="POSCAR", help="Input POSCAR file")
+    kpt_gen_parser.add_argument("-n", "--npoints", type=int, default=40, help="Points per segment")
+    kpt_gen_parser.add_argument("-o", "--output", default="KPOINTS", help="Output filename")
+
+    # --- K-Point Generation (Interactive) ---
+    subparsers.add_parser("kpt", help="Interactive K-Point Generation (SCF)")
+
+    args = parser.parse_args()
+
+    if args.command == "dos":
+        # Resolve filepath: positional > flag > current dir
+        target_path = args.filepath if args.filepath else args.vasprun
+        if not target_path:
+            target_path = "."
+            
+        elements, plotting_config = parse_element_selection(args.elements)
+        
+        try:
+            dos_data, pdos_data = load_dos(target_path, elements)
+            plot_dos(
+                dos_data, pdos_data, 
+                out=args.output,
+                xlim=tuple(args.xlim),
+                ylim=tuple(args.ylim) if args.ylim else None,
+                font=args.font,
+                show_fermi=args.fermi,
+                show_total=not args.pdos,
+                plotting_config=plotting_config,
+                legend_cutoff=args.legend_cutoff,
+                scale_factor=args.scale
+            )
+            # print(f"✅ DOS plot saved to {args.output}") # Silent mode
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+
+    elif args.command == "supercell":
+        try:
+            create_supercell(
+                poscar_path=args.input,
+                nx=args.nx,
+                ny=args.ny,
+                nz=args.nz,
+                output=args.output
+            )
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+            
+    elif args.command == "kpt":
+        try:
+            generate_kpoints_interactive()
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            sys.exit(1)
+
+    elif args.command == "band":
+        if args.band_command == "kpt-gen":
+            try:
+                generate_band_kpoints(
+                    poscar_path=args.input,
+                    npoints=args.npoints,
+                    output=args.output
+                )
+            except Exception as e:
+                print(f"❌ Error: {e}")
+                sys.exit(1)
+        elif args.band_command == "plot" or args.band_command is None:
+             # Default behavior for 'valyte band' is plotting
+            try:
+                # Determine input path: --vasprun > positional > current dir
+                target_path = args.vasprun or args.filepath or "."
+                if os.path.isdir(target_path):
+                    target_path = os.path.join(target_path, "vasprun.xml")
+                
+                # Determine KPOINTS path
+                kpoints_path = args.kpoints
+                if not kpoints_path:
+                    # Try to find KPOINTS in the same directory as vasprun.xml
+                    base_dir = os.path.dirname(target_path)
+                    potential_kpoints = os.path.join(base_dir, "KPOINTS")
+                    if os.path.exists(potential_kpoints):
+                        kpoints_path = potential_kpoints
+
+                plot_band_structure(
+                    vasprun_path=target_path,
+                    kpoints_path=kpoints_path,
+                    output=args.output,
+                    ylim=tuple(args.ylim) if args.ylim else None,
+                    font=args.font
+                )
+            except Exception:
+                import traceback
+                traceback.print_exc()
+                sys.exit(1)
+        else:
+            band_parser.print_help()
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

valyte/dos_plot.py

@@ -0,0 +1,514 @@
+#!/usr/bin/env python3
+"""
+DOS Plotting Module
+===================
+
+Handles Density of States (DOS) plotting with gradient fills and smart legend.
+"""
+
+import os
+import numpy as np
+import matplotlib as mpl
+mpl.use("agg")
+mpl.rcParams["axes.unicode_minus"] = False
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+from matplotlib.patches import Polygon
+from matplotlib.ticker import AutoMinorLocator
+from pymatgen.io.vasp import Vasprun
+from pymatgen.electronic_structure.core import Spin
+
+
+# ===============================================================
+# Gradient fill aesthetic
+# ===============================================================
+def gradient_fill(x, y, ax=None, color=None, xlim=None, **kwargs):
+    """
+    Fills the area under a curve with a vertical gradient.
+
+    Args:
+        x (array-like): X-axis data (Energy).
+        y (array-like): Y-axis data (DOS).
+        ax (matplotlib.axes.Axes, optional): The axes to plot on. Defaults to current axes.
+        color (str, optional): The base color for the gradient.
+        xlim (tuple, optional): X-axis limits to restrict gradient fill.
+        **kwargs: Additional arguments passed to ax.plot.
+
+    Returns:
+        matplotlib.lines.Line2D: The line object representing the curve.
+    """
+    if ax is None:
+        ax = plt.gca()
+    
+    # Don't filter by xlim - use full data range for better appearance
+    if len(x) == 0 or len(y) == 0:
+        return None
+    
+    # Plot the main line
+    line, = ax.plot(x, y, color=color, lw=2, **kwargs)
+    
+    # Determine fill color and alpha
+    fill_color = line.get_color() if color is None else color
+    alpha = line.get_alpha() or 1.0
+    zorder = line.get_zorder()
+
+    # Create a gradient image with more aggressive alpha
+    z = np.empty((100, 1, 4))
+    rgb = mcolors.to_rgb(fill_color)
+    z[:, :, :3] = rgb
+    
+    
+    # Gradient: transparent at bottom (y=0), opaque near the curve
+    # This creates a gradient from bottom to top of the filled area
+    alpha_gradient = np.linspace(0.05, 0.75, 100)
+    
+    # If data is negative (Spin Down), we want opaque at bottom (peak) and transparent at top (axis)
+    # Current extent is [ymin, ymax]. ymin is bottom. ymax is top (0).
+    # So we want High Alpha at index 0 and Low Alpha at index 100.
+    if np.mean(y) < 0:
+        alpha_gradient = alpha_gradient[::-1]
+        
+    z[:, :, -1] = alpha_gradient[:, None]
+    
+    xmin, xmax = x.min(), x.max()
+    ymin, ymax = min(y.min(), 0), max(y.max(), 0)
+    
+    # Handle pure negative or pure positive cases to avoid singular extent
+    if ymax == ymin:
+        ymax += 1e-6
+
+    # Display the gradient image
+    im = ax.imshow(z, aspect="auto", extent=[xmin, xmax, ymin, ymax],
+                   origin="lower", zorder=zorder)
+    
+    # Clip the gradient to the area under the curve
+    # We need to close the polygon at y=0
+    xy = np.column_stack([x, y])
+    
+    # Construct polygon vertices:
+    # Start at (xmin, 0), go along curve (x, y), end at (xmax, 0), close back to start
+    verts = np.vstack([[x[0], 0], xy, [x[-1], 0], [x[0], 0]])
+    
+    clip = Polygon(verts, lw=0, facecolor="none", closed=True)
+    ax.add_patch(clip)
+    im.set_clip_path(clip)
+    
+    return line
+
+
+# ===============================================================
+# Data container
+# ===============================================================
+class ValyteDos:
+    """
+    Container for Total DOS data.
+    
+    Attributes:
+        energies (np.ndarray): Array of energy values (shifted by Fermi energy).
+        densities (dict): Dictionary of {Spin: np.ndarray} for total DOS.
+        efermi (float): Fermi energy.
+    """
+    def __init__(self, energies, densities, efermi):
+        self.energies = np.array(energies)
+        self.densities = densities
+        self.efermi = float(efermi)
+        
+    @property
+    def total(self):
+        """Returns the sum of all spin channels."""
+        tot = np.zeros_like(self.energies)
+        for spin in self.densities:
+            tot += self.densities[spin]
+        return tot
+
+    @property
+    def spin_up(self):
+        return self.densities.get(Spin.up, np.zeros_like(self.energies))
+
+    @property
+    def spin_down(self):
+        return self.densities.get(Spin.down, np.zeros_like(self.energies))
+
+
+# ===============================================================
+# Load DOS
+# ===============================================================
+def load_dos(vasprun, elements=None, **_):
+    """
+    Loads DOS data from a vasprun.xml file using pymatgen.
+
+    Args:
+        vasprun (str): Path to the vasprun.xml file or directory containing it.
+        elements (list or dict, optional): Specific elements to extract PDOS for.
+
+    Returns:
+        tuple: (ValyteDos object, dict of PDOS data)
+    """
+    
+    # Handle directory input
+    if os.path.isdir(vasprun):
+        vasprun = os.path.join(vasprun, "vasprun.xml")
+    
+    if not os.path.exists(vasprun):
+        raise FileNotFoundError(f"{vasprun} not found")
+
+    # Parse VASP output
+    vr = Vasprun(vasprun)
+    dos = vr.complete_dos
+    
+    # Get Fermi Energy
+    efermi = dos.efermi
+    
+    # Attempt to align VBM to 0 for insulators/semiconductors
+    try:
+        # Try using BandStructure first (more robust)
+        bs = vr.get_band_structure()
+        if not bs.is_metal():
+            efermi = bs.get_vbm()["energy"]
+    except Exception:
+        # Fallback to DOS-based detection
+        try:
+            cbm, vbm = dos.get_cbm_vbm()
+            if cbm - vbm > 0.01:  # Band gap detected
+                efermi = vbm
+        except Exception:
+            pass
+    
+    # Shift energies to set reference at 0
+    energies = dos.energies - efermi
+
+    # Extract Projected DOS
+    pdos = get_pdos(dos, elements)
+    
+    return ValyteDos(energies, dos.densities, efermi), pdos
+
+
+# ===============================================================
+# Extract PDOS
+# ===============================================================
+def get_pdos(dos, elements=None):
+    """
+    Extracts Projected DOS (PDOS) for specified elements.
+
+    Args:
+        dos (pymatgen.electronic_structure.dos.CompleteDos): The complete DOS object.
+        elements (list or dict, optional): Elements to extract. If None, extracts all.
+
+    Returns:
+        dict: A dictionary where keys are element symbols and values are dicts of orbital DOS.
+              pdos[element][orbital] = {Spin.up: array, Spin.down: array}
+    """
+    structure = dos.structure
+    symbols = [str(site.specie) for site in structure]
+    
+    # If no elements specified, use all unique elements in the structure
+    if not elements:
+        unique = sorted(set(symbols))
+        elements = {el: () for el in unique}
+    else:
+        # Ensure elements is a dict if passed as list
+        if isinstance(elements, list):
+             elements = {el: () for el in elements}
+
+    pdos = {}
+    for el in elements:
+        # Find all sites corresponding to this element
+        el_sites = [s for s in structure if str(s.specie) == el]
+        el_pdos = {}
+        
+        for site in el_sites:
+            try:
+                site_dos = dos.get_site_spd_dos(site)
+            except Exception:
+                continue
+            
+            # Sum up contributions from orbitals (s, p, d, f)
+            for orb, orb_dos in site_dos.items():
+                label = orb.name[0] # e.g., 's', 'p', 'd'
+                
+                # Initialize dictionaries for spins if not exists
+                if label not in el_pdos:
+                    el_pdos[label] = {}
+                
+                for spin in orb_dos.densities:
+                    if spin not in el_pdos[label]:
+                        el_pdos[label][spin] = np.zeros_like(dos.energies)
+                    el_pdos[label][spin] += orb_dos.densities[spin]
+        
+        pdos[el] = el_pdos
+    return pdos
+
+
+# ===============================================================
+# Plotting with smart legend & font control (Valyte theme)
+# ===============================================================
+def plot_dos(dos, pdos, out="valyte_dos.png",
+             xlim=(-6, 6), ylim=None, figsize=(5, 4),
+             dpi=400, legend_loc="auto", font="Arial",
+             show_fermi=False, show_total=True, plotting_config=None,
+             legend_cutoff=0.10, scale_factor=1.0):
+    """
+    Plots the Total and Projected DOS with the Valyte visual style.
+
+    Args:
+        dos (ValyteDos): The total DOS data.
+        pdos (dict): The projected DOS data.
+        out (str): Output filename.
+        xlim (tuple): Energy range (min, max).
+        ylim (tuple, optional): DOS range (min, max).
+        figsize (tuple): Figure size in inches.
+        dpi (int): Resolution of the output image.
+        legend_loc (str): Legend location strategy.
+        font (str): Font family to use.
+        show_fermi (bool): Whether to draw a dashed line at the Fermi level (E=0).
+        show_total (bool): Whether to plot the Total DOS.
+        plotting_config (list): List of (Element, Orbital) tuples to plot.
+        legend_cutoff (float): Threshold (as fraction) for showing items in legend (default: 0.10).
+        scale_factor (float): Factor to scale the Y-axis limits (zoom in).
+    """
+
+    # --- Font configuration ---
+    font_map = {
+        "arial": "Arial",
+        "helvetica": "Helvetica",
+        "times": "Times New Roman",
+        "times new roman": "Times New Roman",
+    }
+    font = font_map.get(font.lower(), "Arial")
+    mpl.rcParams["font.family"] = font
+    mpl.rcParams["axes.linewidth"] = 1.4
+    mpl.rcParams["font.weight"] = "bold"
+    mpl.rcParams["font.size"] = 12
+
+    plt.style.use("default")
+    fig, ax = plt.subplots(figsize=figsize)
+    
+    # Check if spin-polarized
+    is_spin_polarized = Spin.down in dos.densities
+    
+    # Fermi level line (optional)
+    if show_fermi:
+        ax.axvline(0, color="k", lw=0.8, ls="--", alpha=0.7)
+        
+    # Zero line for spin polarized plots
+    if is_spin_polarized:
+        ax.axhline(0, color="k", lw=0.5, alpha=1.0)
+
+    # Color palette for elements
+    # Expanded color palette for better distinction
+    # Reordered to maximize contrast between consecutive items
+    palette = [
+        "#4b0082", # Indigo
+        "#e63946", # Red
+        "#2a9d8f", # Teal
+        "#ffb703", # Yellow
+        "#0077b6", # Blue
+        "#8e44ad", # Purple
+        "#d62828", # Dark Red
+        "#118ab2", # Light Blue
+        "#f4a261", # Orange
+        "#003049", # Dark Blue
+        "#6a994e", # Green
+        "#023e8a", # Royal Blue
+        "#0096c7", # Cyan
+        "#00b4d8", # Sky Blue
+        "#48cae4", # Light Cyan
+        "#90e0ef", # Pale Blue
+        "#ade8f4", # Very Pale Blue
+        "#caf0f8"  # White Blue
+    ]
+    lines, labels = [], []
+    
+    # Determine mask for visible x-range (used for scaling and legend)
+    x_mask = (dos.energies >= xlim[0]) & (dos.energies <= xlim[1])
+
+    # Determine what to plot
+    if plotting_config:
+        items_to_plot = plotting_config
+    else:
+        # Default: Plot all orbitals for each loaded element
+        items_to_plot = []
+        for el, el_pdos in pdos.items():
+            for orb in el_pdos.keys():
+                items_to_plot.append((el, orb))
+
+    # Plot PDOS
+    max_visible_y = 0  # Track maximum Y value in visible range
+    min_visible_y = 0  # Track minimum Y value (for spin down)
+    
+    for i, (el, orb) in enumerate(items_to_plot):
+        if el not in pdos:
+            continue
+            
+        # Assign unique color for each orbital contribution
+        c = palette[i % len(palette)]
+        
+        # Prepare data for plotting
+        # y_data_up and y_data_down
+        
+        if orb == 'total':
+            # Sum all orbitals for this element
+            y_up = np.zeros_like(dos.energies)
+            y_down = np.zeros_like(dos.energies)
+            
+            for o_data in pdos[el].values():
+                y_up += o_data.get(Spin.up, np.zeros_like(dos.energies))
+                y_down += o_data.get(Spin.down, np.zeros_like(dos.energies))
+                
+            label = el
+        else:
+            if orb in pdos[el]:
+                y_up = pdos[el][orb].get(Spin.up, np.zeros_like(dos.energies))
+                y_down = pdos[el][orb].get(Spin.down, np.zeros_like(dos.energies))
+                label = f"{el}({orb})"
+            else:
+                continue
+        
+        # Invert spin down
+        y_down = -y_down
+        
+        # Check contribution in visible range
+        visible_y_up = y_up[x_mask]
+        visible_y_down = y_down[x_mask]
+        
+        has_visible_data = False
+        current_max_y = 0
+        
+        if len(visible_y_up) > 0:
+            max_y = np.max(visible_y_up)
+            max_visible_y = max(max_visible_y, max_y)
+            current_max_y = max(current_max_y, max_y)
+            if max_y > 1e-6: has_visible_data = True
+            
+        if is_spin_polarized and len(visible_y_down) > 0:
+            min_y = np.min(visible_y_down)
+            min_visible_y = min(min_visible_y, min_y)
+            current_max_y = max(current_max_y, abs(min_y))
+            if abs(min_y) > 1e-6: has_visible_data = True
+
+        # Store for later threshold check and plotting
+        # We plot a dummy line for the legend
+        line, = ax.plot(dos.energies, y_up, lw=1.5, color=c, label=label, alpha=0)
+        lines.append({
+            'line': line,
+            'y_up': y_up,
+            'y_down': y_down,
+            'max_y': current_max_y,
+            'color': c,
+            'label': label
+        })
+    
+    # Calculate threshold (legend_cutoff of max visible)
+    # Use the overall max absolute value found
+    global_max = max(max_visible_y, abs(min_visible_y))
+    threshold = legend_cutoff * global_max
+    
+    # Filter legend items but keep all plot lines
+    final_lines = []
+    final_labels = []
+    
+    for item in lines:
+        line = item['line']
+        y_up = item['y_up']
+        y_down = item['y_down']
+        c = item['color']
+        label = item['label']
+        max_y = item['max_y']
+        
+        # Always plot the line (make it visible)
+        line.set_alpha(1.0)
+        
+        # Apply gradient fill for visible lines
+        # Spin Up
+        gradient_fill(dos.energies, y_up, ax=ax, color=c, alpha=0.9)
+        
+        # Spin Down
+        if is_spin_polarized:
+             gradient_fill(dos.energies, y_down, ax=ax, color=c, alpha=0.9)
+        
+        # Only add to legend if above main threshold
+        if max_y >= threshold:
+            final_lines.append(line)
+            final_labels.append(label)
+    
+    # Update lines and labels for legend creation
+    lines = final_lines
+    labels = final_labels
+
+    # Plot Total DOS
+    if show_total:
+        y_total_up = dos.spin_up
+        y_total_down = -dos.spin_down
+        
+        ax.plot(dos.energies, y_total_up, color="k", lw=1.2, label="Total DOS")
+        gradient_fill(dos.energies, y_total_up, ax=ax, color="k", alpha=0.15)
+        
+        if is_spin_polarized:
+            ax.plot(dos.energies, y_total_down, color="k", lw=1.2)
+            gradient_fill(dos.energies, y_total_down, ax=ax, color="k", alpha=0.15)
+            
+            # Update max/min range for auto-scaling
+            visible_total_up = y_total_up[x_mask]
+            visible_total_down = y_total_down[x_mask]
+            if len(visible_total_up) > 0:
+                max_visible_y = max(max_visible_y, np.max(visible_total_up))
+            if len(visible_total_down) > 0:
+                min_visible_y = min(min_visible_y, np.min(visible_total_down))
+    
+    # Auto-scale Y-axis based on visible range if ylim not provided
+    if not ylim:
+        if max_visible_y > 0 or min_visible_y < 0:
+            # Apply scaling factor to the limit (zoom in)
+            upper_limit = (max_visible_y * 1.1) / scale_factor
+            lower_limit = (min_visible_y * 1.1) / scale_factor if is_spin_polarized else 0
+            
+            # If spin polarized, maybe make symmetric if user wants? 
+            # For now, let's just use the data range.
+            # But often symmetric is nicer. Let's stick to data range for now.
+            
+            ax.set_ylim(lower_limit, upper_limit)
+    else:
+        ax.set_ylim(*ylim)
+
+    # Axis settings
+    ax.set_xlim(*xlim)
+    ax.set_xlabel("Energy (eV)", fontsize=14, weight="bold", labelpad=6)
+    ax.set_ylabel("Density of States", fontsize=14, weight="bold", labelpad=6)
+    
+    # Set x-ticks with 1 eV spacing
+    xticks = np.arange(np.ceil(xlim[0]), np.floor(xlim[1]) + 1, 1)
+    ax.set_xticks(xticks)
+    # Format tick labels: show integers without .0
+    tick_labels = [f'{int(x)}' if x == int(x) else f'{x}' for x in xticks]
+    ax.set_xticklabels(tick_labels, fontweight="bold")
+    ax.set_yticks([])
+
+    # --- Smart legend visibility ---
+    # Only show legend if there are items to display
+    show_legend = len(lines) > 0
+
+    if show_legend:
+        # Check for overlap to decide legend position
+        # Simplified overlap check for now
+        loc, ncol = "upper right", 1
+        
+        # If spin polarized, upper right might cover spin up data
+        # But usually it's fine.
+
+        legend = ax.legend(
+            lines, labels,
+            frameon=False,
+            fontsize=13,
+            loc=loc,
+            ncol=ncol,
+            handlelength=1.5,
+            columnspacing=0.8,
+            handletextpad=0.6,
+        )
+        for text in legend.get_texts():
+            text.set_fontweight("bold")
+
+    ax.xaxis.set_minor_locator(AutoMinorLocator(2))
+    plt.tight_layout(pad=0.4)
+    plt.savefig(out, dpi=dpi)
+    plt.close(fig)

valyte/kpoints.py

@@ -0,0 +1,96 @@
+"""
+Interactive K-Point Generation Module
+=====================================
+
+Handles interactive generation of KPOINTS files based on user input and structure.
+"""
+
+import os
+import sys
+import numpy as np
+from pymatgen.core import Structure
+from pymatgen.io.vasp.inputs import Kpoints
+
+def generate_kpoints_interactive():
+    """
+    Interactively generates a KPOINTS file based on user input and POSCAR.
+    """
+    print("\n🔮 Valyte K-Point Generator")
+    
+    # Check for POSCAR
+    poscar_path = "POSCAR"
+    if not os.path.exists(poscar_path):
+        # Try finding any POSCAR* file
+        files = [f for f in os.listdir('.') if f.startswith('POSCAR')]
+        if files:
+            poscar_path = files[0]
+            print(f"   Found structure: {poscar_path}")
+        else:
+            print("❌ POSCAR file not found in current directory.")
+            return
+
+    try:
+        structure = Structure.from_file(poscar_path)
+    except Exception as e:
+        print(f"❌ Error reading structure: {e}")
+        return
+
+    # Scheme Selection
+    print("\nSelect K-Mesh Scheme:")
+    print("  1. Monkhorst-Pack")
+    print("  2. Gamma (Default)")
+    
+    choice = input("   > ").strip()
+    
+    if choice == '1':
+        scheme = 'MP'
+    else:
+        scheme = 'Gamma'
+
+    # K-Spacing Input
+    print("\nEnter K-Spacing (units of 2π/Å):")
+    print("   (Typical values: 0.03 - 0.04)")
+    
+    try:
+        kspacing_str = input("   > ").strip()
+        if not kspacing_str:
+            kspacing = 0.04 # Default
+        else:
+            kspacing = float(kspacing_str)
+    except ValueError:
+        print("❌ Invalid number. Exiting.")
+        return
+
+    if kspacing <= 0:
+        print("ℹ️  Using Gamma-Only (1 1 1)")
+        kpts = Kpoints.gamma_automatic((1, 1, 1))
+        grid = (1, 1, 1)
+    else:
+        # Calculate grid based on spacing
+        # Formula: N = |b| / (spacing * 2*pi)
+        # pymatgen reciprocal lattice lengths include the 2*pi factor.
+        
+        recip_lattice = structure.lattice.reciprocal_lattice
+        b_lengths = recip_lattice.abc
+        
+        # We multiply spacing by 2*pi because the input is a coefficient of 2*pi/A?
+        # Or rather, standard convention (like VASP KSPACING) often implies 2*pi is involved in the density.
+        # Empirically: N = |b| / (input * 2*pi) matches expected results.
+        grid = [max(1, int(l / (kspacing * 2 * np.pi) + 0.5)) for l in b_lengths]
+        
+        # Create Kpoints object
+        if scheme == 'MP':
+            kpts = Kpoints.monkhorst_automatic(grid)
+        else:
+            kpts = Kpoints.gamma_automatic(grid)
+
+    # Print Summary
+    print("\n📊 Summary")
+    print(f"   Structure: {structure.formula}")
+    print(f"   Lattice:   a={structure.lattice.a:.2f}, b={structure.lattice.b:.2f}, c={structure.lattice.c:.2f} Å")
+    print(f"   K-Mesh:    {grid[0]} x {grid[1]} x {grid[2]} ({scheme})")
+
+    # Write KPOINTS
+    output_file = "KPOINTS"
+    kpts.write_file(output_file)
+    print(f"\n✅ Generated {output_file}!")

valyte/supercell.py

@@ -0,0 +1,35 @@
+"""
+Supercell generation module for Valyte.
+"""
+
+import os
+from pymatgen.core import Structure
+
+
+def create_supercell(poscar_path="POSCAR", nx=1, ny=1, nz=1, output="POSCAR_supercell"):
+    """
+    Creates a supercell from a POSCAR file.
+    
+    Args:
+        poscar_path (str): Path to input POSCAR file.
+        nx (int): Supercell size in x direction.
+        ny (int): Supercell size in y direction.
+        nz (int): Supercell size in z direction.
+        output (str): Output filename for the supercell POSCAR.
+    """
+    
+    if not os.path.exists(poscar_path):
+        raise FileNotFoundError(f"{poscar_path} not found")
+    
+    # Read structure
+    structure = Structure.from_file(poscar_path)
+    
+    # Create supercell
+    supercell = structure.copy()
+    supercell.make_supercell([nx, ny, nz])
+    
+    # Write output
+    supercell.to(filename=output, fmt="poscar")
+    
+    supercell_atoms = len(supercell)
+    print(f"✅ Supercell created: {output} ({supercell_atoms} atoms)")

valyte-0.1.0.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.2
+Name: valyte
+Version: 0.1.0
+Summary: A CLI tool for VASP post-processing (DOS plotting)
+Home-page: https://github.com/nikyadav002/Valyte-Project
+Author: Nikhil
+Author-email: nikhil@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pymatgen
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="valyte/Logo.png" alt="Valyte Logo" width="100%"/>
+</p>
+
+# Valyte
+
+**Valyte** is a comprehensive CLI tool for VASP workflows, providing both pre-processing and post-processing capabilities with a focus on clean, publication-quality outputs and modern aesthetics.
+
+## Features
+
+### Pre-processing
+- **Supercell Creation**: Generate supercells from POSCAR files.
+- **Interactive K-Point Generation**: Create KPOINTS files with automatic grid calculation based on K-spacing.
+- **Band KPOINTS Generation**: Automatic high-symmetry path detection for band structure calculations.
+
+### Post-processing
+- **DOS Plotting**: 
+  - Smart Plotting: Automatically handles total DOS and Projected DOS (PDOS).
+  - Orbital-Resolved: Plots individual orbitals (s, p, d, f) by default.
+  - Adaptive Legend: Intelligently hides the legend if PDOS contributions are low.
+  - Gradient Fill: Aesthetically pleasing gradient fills for DOS peaks.
+- **Band Structure Plotting**:
+  - VBM alignment to 0 eV.
+  - Color-coded bands (Purple for VB, Teal for CB).
+  - High-symmetry path labels from KPOINTS.
+- **Publication Quality**: Clean aesthetics, custom fonts (Arial, Helvetica, Times New Roman), high DPI output.
+
+## Installation
+
+Clone the repository and install in editable mode:
+
+```bash
+git clone https://github.com/nikyadav002/Valyte-Project
+cd Valyte-Project
+pip install -e .
+```
+
+## Examples
+
+<p align="center">
+  <img src="valyte/valyte_dos.png" alt="DOS Plot Example" width="47%"/>
+  <img src="valyte/valyte_band.png" alt="Band Structure Example" width="38%"/>
+</p>
+
+## Updating Valyte
+
+To update to the latest version:
+
+```bash
+cd Valyte-Project
+git pull
+pip install -e .
+```
+
+## Usage
+
+The main command is `valyte`.
+
+<details>
+<summary><strong>Click to view detailed usage instructions</strong></summary>
+
+<br>
+
+### 🧊 Create Supercell
+
+Generate a supercell from a POSCAR file:
+
+```bash
+valyte supercell nx ny nz [options]
+```
+
+**Example:**
+```bash
+# Create a 2×2×2 supercell
+valyte supercell 2 2 2
+
+# Specify input and output files
+valyte supercell 3 3 1 -i POSCAR_primitive -o POSCAR_3x3x1
+```
+
+**Options:**
+- `-i`, `--input`: Input POSCAR file (default: `POSCAR`).
+- `-o`, `--output`: Output filename (default: `POSCAR_supercell`).
+
+---
+
+### 📉 Band Structure
+
+#### 1. Generate KPOINTS
+
+Automatically generate a KPOINTS file with high-symmetry paths for band structure calculations.
+
+```bash
+valyte band kpt-gen [options]
+```
+
+**Options:**
+- `-i`, `--input`: Input POSCAR file (default: `POSCAR`).
+- `-n`, `--npoints`: Points per segment (default: `40`).
+- `-o`, `--output`: Output filename (default: `KPOINTS`).
+
+**Example:**
+```bash
+valyte band kpt-gen -n 60 -i POSCAR_relaxed -o KPOINTS_band
+```
+
+### 🕸️ Generate K-Points (Interactive)
+
+Generate a `KPOINTS` file for SCF calculations interactively.
+
+```bash
+valyte kpt
+```
+
+This command will prompt you for:
+1. **K-Mesh Scheme**: Monkhorst-Pack or Gamma.
+2. **K-Spacing**: Value in $2\pi/\AA$ (e.g., 0.04).
+
+It automatically calculates the optimal grid based on your `POSCAR` structure.
+
+#### 2. Plot Band Structure
+
+Plot the electronic band structure from `vasprun.xml`.
+
+```bash
+valyte band [options]
+```
+
+**Options:**
+- `--vasprun`: Path to `vasprun.xml` (default: current directory).
+- `--kpoints`: Path to `KPOINTS` file for path labels (default: looks for `KPOINTS` in same dir).
+- `--ylim`: Energy range, e.g., `--ylim -4 4`.
+- `-o, --output`: Output filename (default: `valyte_band.png`).
+
+**Example:**
+```bash
+valyte band --ylim -3 3 -o my_bands.png
+```
+
+---
+
+### 📊 Plot DOS
+
+```bash
+valyte dos [path/to/vasprun.xml] [options]
+```
+
+You can provide the path as a positional argument, use the `--vasprun` flag, or omit it to use the current directory.
+
+**Examples:**
+```bash
+# Plot all orbitals for all elements (Default)
+valyte dos
+
+# Plot specific elements (Total PDOS)
+valyte dos -e Fe O
+
+# Plot specific orbitals
+valyte dos -e "Fe(d)" "O(p)"
+
+# Plot mixed (Fe Total and Fe d-orbital)
+valyte dos -e Fe "Fe(d)"
+```
+
+**Options:**
+- `-e`, `--elements`: Specific elements or orbitals to plot.
+    - Example: `-e Fe O` (Plots Total PDOS for Fe and O).
+    - Example: `-e Fe(d) O(p)` (Plots Fe d-orbital and O p-orbital).
+    - Example: `-e Fe Fe(d)` (Plots Fe Total and Fe d-orbital).
+- `--xlim`: Energy range (default: `-6 6`).
+- `--ylim`: DOS range (e.g., `--ylim 0 10`).
+- `--scale`: Scaling factor for Y-axis (e.g., `--scale 3` divides DOS by 3).
+- `--fermi`: Draw a dashed line at the Fermi level (E=0). Default is OFF.
+- `--pdos`: Plot only Projected DOS (hide Total DOS).
+- `--legend-cutoff`: Threshold for legend visibility (default: `0.10` = 10%).
+- `-o`, `--output`: Output filename (default: `valyte_dos.png`).
+- `--font`: Font family (default: `Arial`).
+
+**Example:**
+
+```bash
+valyte dos ./vasp_data --xlim -5 5 -o my_dos.png
+```
+
+</details>

valyte-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+valyte/Logo.png,sha256=HSZQsjsCj4y_8zeXE1kR1W7deb-6gXheEnmcLcSKUxw,4327936
+valyte/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valyte/band.py,sha256=qipx3YIlcl2yV-g6nn_YPRJCidvlrxZKEQzSRyBkwac,1917
+valyte/band_plot.py,sha256=2jP6fEh8qDYHXxDAs4S69xDcxrzWbYcjOAWiGHwjyF4,4766
+valyte/cli.py,sha256=c5At8G4t6IoZEQKEJdBP72TzsKweUX5DIiaaUd9aQXg,8847
+valyte/dos_plot.py,sha256=ddEjLFlBs6acHZygaLPBEGVti6qTzwM4pO1zF-pGFUU,17687
+valyte/kpoints.py,sha256=_LISADqe11NBlv8LMjMkF5rWrREHB3aU5-nHvqxj3jk,3055
+valyte/supercell.py,sha256=w6Ik_krXoshgliJDiyjoIZXuifzN0ydi6VSmpzutm9Y,996
+valyte/valyte_band.png,sha256=1Bh-x7qvl1j4D9HGGbQK8OlMUrTU1mhU_kMILUsNiD8,246677
+valyte/valyte_dos.png,sha256=ViE4CycCSqFi_ZtUhA7oGI1nTyt0mHoYI6yg5-Et35k,182523
+valyte-0.1.0.dist-info/METADATA,sha256=0wSkS7JBoPQd2Rcm0SfC_I45pfxuV_TDFyixkfrc4JQ,5539
+valyte-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+valyte-0.1.0.dist-info/entry_points.txt,sha256=Ny3Z5rh3Ia7lEKoMDDZOm4_jS-Zde3qFHv8f1GLUdxk,43
+valyte-0.1.0.dist-info/top_level.txt,sha256=72-UqyU15JSWDjtBQf6cY0_UBqz0EU2FoVeXjd1JZ5M,7
+valyte-0.1.0.dist-info/RECORD,,

valyte-0.1.0.dist-info/WHEEL

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

valyte-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+valyte = valyte.cli:main

valyte-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+valyte