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

valyte/ipr.py

@@ -0,0 +1,186 @@
+"""Inverse participation ratio (IPR) from VASP PROCAR."""
+
+import os
+import re
+import numpy as np
+
+
+def read_procar(filename="PROCAR"):
+    """Read PROCAR and extract atomic total projections."""
+    if not os.path.exists(filename):
+        raise FileNotFoundError(f"{filename} not found")
+
+    with open(filename, "r") as f:
+        lines = f.readlines()
+
+    header_line = next((l for l in lines if "k-points" in l), None)
+    if header_line is None:
+        raise ValueError("Could not find PROCAR header with k-points/bands/ions")
+
+    numbers = [int(x) for x in re.findall(r"\d+", header_line)]
+    if len(numbers) < 3:
+        raise ValueError("PROCAR header does not contain k-points, bands, and ions")
+
+    nkpts, nbands, natoms = numbers[0], numbers[1], numbers[2]
+
+    proj = [[[] for _ in range(nbands)] for _ in range(nkpts)]
+    energies = [[0.0 for _ in range(nbands)] for _ in range(nkpts)]
+
+    ik = -1
+    ib = -1
+
+    for raw in lines:
+        line = raw.strip()
+        if not line:
+            continue
+
+        if line.startswith("k-point"):
+            ik += 1
+            ib = -1
+            continue
+
+        if line.startswith("band"):
+            ib += 1
+            parts = line.split()
+            if len(parts) > 4:
+                energies[ik][ib] = float(parts[4])
+            continue
+
+        if line[0].isdigit() and ik >= 0 and ib >= 0:
+            parts = line.split()
+            proj[ik][ib].append(float(parts[-1]))
+
+    return proj, energies, nkpts, nbands, natoms
+
+
+def compute_ipr_atomic(projections):
+    """Compute atomic IPR from atomic projections."""
+    projections = np.array(projections)
+    tot = projections.sum()
+    if tot < 1e-12:
+        return 0.0
+    weights = projections / tot
+    return np.sum(weights ** 2)
+
+
+def analyze_bands(proj, energies, nkpts, band_indices, verbose=True):
+    """Compute k-averaged atomic IPR for selected bands."""
+    results = []
+
+    for iband in band_indices:
+        ipr_k = []
+        e_k = []
+
+        if verbose:
+            print(f"\nBand {iband}")
+
+        for ik in range(nkpts):
+            ipr = compute_ipr_atomic(proj[ik][iband - 1])
+            ipr_k.append(ipr)
+            e_k.append(energies[ik][iband - 1])
+
+            if verbose:
+                neff = (1 / ipr) if ipr > 0 else 0.0
+                print(
+                    f"  k-point {ik + 1:3d}  "
+                    f"E = {energies[ik][iband - 1]:8.4f} eV  "
+                    f"IPR = {ipr:8.4f}  "
+                    f"N_eff = {neff:8.2f}"
+                )
+
+        avg_ipr = float(np.mean(ipr_k)) if ipr_k else 0.0
+        avg_e = float(np.mean(e_k)) if e_k else 0.0
+        neff = (1 / avg_ipr) if avg_ipr > 0 else 0.0
+
+        if verbose:
+            print("  ------------------------------")
+            print(f"  Avg IPR = {avg_ipr:.4f}")
+            print(f"  N_eff  = {neff:.2f}")
+
+        results.append((iband, avg_e, avg_ipr, neff))
+
+    return results
+
+
+def save_results(results, filename="ipr_procar.dat"):
+    """Save IPR results to a file."""
+    with open(filename, "w") as f:
+        f.write("# Band  Energy(eV)   IPR   N_eff\n")
+        for band, e, ipr, neff in results:
+            f.write(f"{band:5d}  {e:10.6f}  {ipr:8.4f}  {neff:8.2f}\n")
+
+    print(f"\nResults written to {filename}")
+
+
+def _parse_band_indices(text):
+    tokens = re.split(r"[\s,]+", text.strip())
+    indices = []
+    seen = set()
+
+    for token in tokens:
+        if not token:
+            continue
+        if "-" in token:
+            parts = token.split("-")
+            if len(parts) != 2:
+                continue
+            try:
+                start = int(parts[0])
+                end = int(parts[1])
+            except ValueError:
+                continue
+            if start > end:
+                start, end = end, start
+            for i in range(start, end + 1):
+                if i not in seen:
+                    indices.append(i)
+                    seen.add(i)
+        else:
+            try:
+                i = int(token)
+            except ValueError:
+                continue
+            if i not in seen:
+                indices.append(i)
+                seen.add(i)
+
+    return indices
+
+
+def run_ipr_interactive():
+    """Interactive IPR workflow."""
+    procar_file = "PROCAR"
+
+    try:
+        proj, energies, nkpts, nbands, natoms = read_procar(procar_file)
+    except Exception as e:
+        print(f"Error: {e}")
+        return
+
+    print("PROCAR info")
+    print(f"  k-points : {nkpts}")
+    print(f"  bands    : {nbands}")
+    print(f"  atoms    : {natoms}")
+
+    band_text = input("Band indices (e.g., 5 6 7 or 5-7): ").strip()
+    if not band_text:
+        print("No band indices provided.")
+        return
+
+    band_indices = _parse_band_indices(band_text)
+    if not band_indices:
+        print("No valid band indices found.")
+        return
+
+    filtered = [b for b in band_indices if 1 <= b <= nbands]
+    if not filtered:
+        print(f"No bands in range 1..{nbands}.")
+        return
+
+    if len(filtered) != len(band_indices):
+        print("Warning: some bands were out of range and were skipped.")
+
+    show_details = input("Show per-k-point values? [y/N]: ").strip().lower() == "y"
+
+    results = analyze_bands(proj, energies, nkpts, filtered, verbose=show_details)
+    save_results(results, "ipr_procar.dat")

valyte/kpoints.py

@@ -1,96 +1,80 @@
-"""
-Interactive K-Point Generation Module
-=====================================
-
-Handles interactive generation of KPOINTS files based on user input and structure.
-"""
+"""Interactive KPOINTS generation."""
 
 import os
-import sys
 import numpy as np
 from pymatgen.core import Structure
 from pymatgen.io.vasp.inputs import Kpoints
+from valyte.potcar import generate_potcar
+
 
 def generate_kpoints_interactive():
-    """
-    Interactively generates a KPOINTS file based on user input and POSCAR.
-    """
-    print("\n🔮 Valyte K-Point Generator")
-    
-    # Check for POSCAR
+    """Interactively generate a KPOINTS file based on POSCAR and user input."""
+    print("\nValyte K-Point Generator")
+
     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')]
+        files = [f for f in os.listdir(".") if f.startswith("POSCAR")]
         if files:
             poscar_path = files[0]
-            print(f"   Found structure: {poscar_path}")
+            print(f"Found structure: {poscar_path}")
         else:
-            print("❌ POSCAR file not found in current directory.")
+            print("Error: 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}")
+        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'
+    scheme = "MP" if choice == "1" else "Gamma"
 
-    # K-Spacing Input
     print("\nEnter K-Spacing (units of 2π/Å):")
-    print("   (Typical values: 0.03 - 0.04)")
-    
+    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)
+        kspacing = float(kspacing_str) if kspacing_str else 0.04
     except ValueError:
-        print("❌ Invalid number. Exiting.")
+        print("Error: invalid number.")
         return
 
     if kspacing <= 0:
-        print("ℹ️  Using Gamma-Only (1 1 1)")
+        print("Using Gamma-only grid (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':
+
+        # KSPACING-style estimate: N = |b| / kspacing
+        grid = [max(1, int(l / kspacing + 0.5)) for l in b_lengths]
+
+        if scheme == "MP":
             kpts = Kpoints.monkhorst_automatic(grid)
         else:
             kpts = Kpoints.gamma_automatic(grid)
 
-    # Print Summary
-    print("\n📊 Summary")
+    print("\nSummary")
     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}!")
+    print(f"\nGenerated {output_file}.")
+
+    potcar_file = "POTCAR"
+    if not os.path.exists(potcar_file):
+        try:
+            print("\nPOTCAR not found. Generating default POTCAR (PBE)...")
+            generate_potcar(poscar_path=poscar_path, functional="PBE", output=potcar_file)
+        except Exception as e:
+            print(f"Warning: could not generate POTCAR: {e}")
+    else:
+        print("POTCAR already exists; skipping generation.")

valyte/potcar.py

@@ -0,0 +1,36 @@
+import os
+from pymatgen.core import Structure
+from pymatgen.io.vasp.inputs import Potcar
+
+
+def _ordered_symbols(structure):
+    symbols = []
+    seen = set()
+    for site in structure:
+        sym = site.specie.symbol if hasattr(site.specie, "symbol") else str(site.specie)
+        if sym not in seen:
+            symbols.append(sym)
+            seen.add(sym)
+    return symbols
+
+
+def generate_potcar(poscar_path="POSCAR", functional="PBE", output="POTCAR"):
+    """Generate a POTCAR based on species in a POSCAR."""
+    if not os.path.exists(poscar_path):
+        raise FileNotFoundError(f"Input file '{poscar_path}' not found.")
+
+    structure = Structure.from_file(poscar_path)
+    species = _ordered_symbols(structure)
+
+    print(f"Reading structure from {poscar_path}...")
+    print(f"Detected species: {species}")
+
+    try:
+        potcar = Potcar(species, functional=functional)
+    except OSError as e:
+        print(f"Could not find POTCARs for functional '{functional}'.")
+        print("Ensure PMG_VASP_PSP_DIR is set in ~/.pmgrc.yaml")
+        raise e
+
+    potcar.write_file(output)
+    print(f"Generated {output} using functional '{functional}'")

valyte/supercell.py

@@ -1,35 +1,18 @@
-"""
-Supercell generation module for Valyte.
-"""
+"""Supercell generation."""
 
 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.
-    """
-    
+    """Create a supercell from a POSCAR file."""
     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)")
+    print(f"Supercell created: {output} ({supercell_atoms} atoms)")

{valyte-0.1.8.dist-info → valyte-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: valyte
-Version: 0.1.8
+Version: 0.1.11
 Summary: A comprehensive CLI tool for VASP pre-processing (Supercells, K-points) and post-processing (DOS, Band Structure plotting)
 Home-page: https://github.com/nikyadav002/Valyte-Project
 Author: Nikhil
@@ -42,6 +42,7 @@ Requires-Dist: seekpath
   - VBM alignment to 0 eV.
   - Color-coded bands (Purple for VB, Teal for CB).
   - High-symmetry path labels from KPOINTS.
+- **IPR Analysis**: Compute Inverse Participation Ratio from PROCAR to analyze wavefunction localization.
 - **Publication Quality**: Clean aesthetics, custom fonts (Arial, Helvetica, Times New Roman), high DPI output.
 
 ## Installation
@@ -113,6 +114,9 @@ valyte supercell 3 3 1 -i POSCAR_primitive -o POSCAR_3x3x1
 
 Automatically generate a KPOINTS file with high-symmetry paths for band structure calculations.
 
+> [!TIP]
+> **Smart K-Path Generation (New in v0.1.7+)**: Valyte now automatically determines the standard path (e.g., `\Gamma - Y - V` for Monoclinic cells) using the **Bradley-Cracknell** convention by default. This ensures clean, publication-ready labels without external dependencies.
+
 ```bash
 valyte band kpt-gen [options]
 ```
@@ -121,12 +125,20 @@ valyte band kpt-gen [options]
 - `-i`, `--input`: Input POSCAR file (default: `POSCAR`).
 - `-n`, `--npoints`: Points per segment (default: `40`).
 - `-o`, `--output`: Output filename (default: `KPOINTS`).
+- `--mode`: Path convention. Options: `bradcrack` (Default), `seekpath`, `latimer_munro`, `setyawan_curtarolo`.
 
 **Example:**
 ```bash
-valyte band kpt-gen -n 60 -i POSCAR_relaxed -o KPOINTS_band
+# Default (Smart/BradCrack)
+valyte band kpt-gen -n 60
+
+# Explicitly use Seekpath convention
+valyte band kpt-gen --mode seekpath
 ```
 
+> [!IMPORTANT]
+> The command will generate a **`POSCAR_standard`** file. You **MUST** use this structure for your band structure calculation (i.e., `cp POSCAR_standard POSCAR`) because the K-path corresponds to this specific orientation. Using your original POSCAR may result in incorrect paths.
+
 ### 🕸️ Generate K-Points (Interactive)
 
 Generate a `KPOINTS` file for SCF calculations interactively.
@@ -141,6 +153,38 @@ This command will prompt you for:
 
 It automatically calculates the optimal grid based on your `POSCAR` structure.
 
+---
+
+### 🧪 Generate POTCAR
+
+Generate a `POTCAR` file based on the species in your `POSCAR`.
+
+```bash
+valyte potcar [options]
+```
+
+**Options:**
+- `-i`, `--input`: Input POSCAR file (default: `POSCAR`).
+- `-o`, `--output`: Output filename (default: `POTCAR`).
+- `--functional`: Functional to use (default: `PBE`). Options include `PBE`, `PBE_52`, `PBE_54`, `LDA`, etc.
+
+**Example:**
+```bash
+# Generate POTCAR using default PBE functional
+valyte potcar
+
+# Use a specific functional
+valyte potcar --functional PBE_54
+
+# Specify input and output files
+valyte potcar -i POSCAR_relaxed -o POTCAR_new
+```
+
+> [!IMPORTANT]
+> **Pymatgen Configuration Required**: This command requires Pymatgen to be configured with your VASP pseudopotential directory. Set `PMG_VASP_PSP_DIR` in your `~/.pmgrc.yaml` file. See the [Pymatgen documentation](https://pymatgen.org/installation.html#potcar-setup) for setup instructions.
+
+---
+
 #### 2. Plot Band Structure
 
 Plot the electronic band structure from `vasprun.xml`.
@@ -205,4 +249,30 @@ valyte dos -e Fe "Fe(d)"
 valyte dos ./vasp_data --xlim -5 5 -o my_dos.png
 ```
 
+---
+
+### 📐 Compute IPR (Inverse Participation Ratio)
+
+Compute the Inverse Participation Ratio (IPR) from VASP `PROCAR` to analyze wavefunction localization.
+
+```bash
+valyte ipr
+```
+
+This interactive command will:
+1. Read the `PROCAR` file from the current directory.
+2. Display the number of k-points, bands, and atoms.
+3. Prompt you for **band indices** to analyze (e.g., `5 6 7` or `5-7`).
+4. Optionally show per-k-point IPR values.
+5. Save results to `ipr_procar.dat`.
+
+**Output Columns:**
+- **Band**: Band index.
+- **Energy**: Average energy (eV) across k-points.
+- **IPR**: Inverse Participation Ratio (higher = more localized).
+- **N_eff**: Effective number of atoms (1/IPR).
+
+> [!TIP]
+> Use IPR to identify localized defect states. A state localized on a single atom has IPR ≈ 1.0 and N_eff ≈ 1. Delocalized band states have small IPR and large N_eff.
+
 </details>

valyte-0.1.11.dist-info/RECORD

@@ -0,0 +1,19 @@
+valyte/Logo.png,sha256=HSZQsjsCj4y_8zeXE1kR1W7deb-6gXheEnmcLcSKUxw,4327936
+valyte/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valyte/band.py,sha256=ckwLeIvU1goyxRYusWl-yqdZRZDmYBVOF3fhwGzEEAg,8738
+valyte/band_plot.py,sha256=XTx6zFrLaTo_GYYvANulMl_0eFSQCyRqJCPfYJffXdg,2869
+valyte/cli.py,sha256=xmGEOOfOQOsOzJ_dhzMDOSfuimL_1X--nlmBiQ_WG9Q,8816
+valyte/dos_plot.py,sha256=iMjvSevX61PqmOOye7uNirj2bh9uFdlgZZXfCK1oGWo,10771
+valyte/ipr.py,sha256=cT6G10Zt__TRSx-Vt7HiCPRVC8uTz5JNWzQN-2J7df0,5316
+valyte/kpoints.py,sha256=Qh80UmEwt3OssPoEwN8PaVc9E7KG_W-vR0_kP7IzoZ0,2632
+valyte/potcar.py,sha256=7JRo1Tkz1M6kqVYKbAYkkPVlt1gqeqjMKkpFWWzXdTk,1160
+valyte/supercell.py,sha256=5qeeeJN81LAGdzdgEtYIMy8-g4T4xKRm_cxbsVuVBQA,595
+valyte/valyte_band.png,sha256=1Bh-x7qvl1j4D9HGGbQK8OlMUrTU1mhU_kMILUsNiD8,246677
+valyte/valyte_dos.png,sha256=ViE4CycCSqFi_ZtUhA7oGI1nTyt0mHoYI6yg5-Et35k,182523
+valyte/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valyte/data/bradcrack.json,sha256=Jpaf7giqp99BAhFdLv9pRFsx_m-ooQaQpOrPDusuZX4,22614
+valyte-0.1.11.dist-info/METADATA,sha256=PpUiK7lOajinqNTEtpNrzYjS0-5ARSk07hTDv-bLL2s,8160
+valyte-0.1.11.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+valyte-0.1.11.dist-info/entry_points.txt,sha256=Ny3Z5rh3Ia7lEKoMDDZOm4_jS-Zde3qFHv8f1GLUdxk,43
+valyte-0.1.11.dist-info/top_level.txt,sha256=72-UqyU15JSWDjtBQf6cY0_UBqz0EU2FoVeXjd1JZ5M,7
+valyte-0.1.11.dist-info/RECORD,,

valyte-0.1.8.dist-info/RECORD

@@ -1,17 +0,0 @@
-valyte/Logo.png,sha256=HSZQsjsCj4y_8zeXE1kR1W7deb-6gXheEnmcLcSKUxw,4327936
-valyte/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valyte/band.py,sha256=fRum_BwgSqsN_lJsHFc7AhhVD5y4T5Sq7JJNhvB8J8w,11732
-valyte/band_plot.py,sha256=2jP6fEh8qDYHXxDAs4S69xDcxrzWbYcjOAWiGHwjyF4,4766
-valyte/cli.py,sha256=5lqDQTPMJTS_-u19l7MZG6GYwhFQQ0BgEJ0T13LxCtQ,9153
-valyte/dos_plot.py,sha256=PWlUSlF887-s2SXuHEjMiGLdo4_5419SVwVn1xTYvQQ,18972
-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/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valyte/data/bradcrack.json,sha256=Jpaf7giqp99BAhFdLv9pRFsx_m-ooQaQpOrPDusuZX4,22614
-valyte-0.1.8.dist-info/METADATA,sha256=QpGEeHAEwcOeT7cmW9xv4uvxByeS0jYwJeaCwX5WGlc,5506
-valyte-0.1.8.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-valyte-0.1.8.dist-info/entry_points.txt,sha256=Ny3Z5rh3Ia7lEKoMDDZOm4_jS-Zde3qFHv8f1GLUdxk,43
-valyte-0.1.8.dist-info/top_level.txt,sha256=72-UqyU15JSWDjtBQf6cY0_UBqz0EU2FoVeXjd1JZ5M,7
-valyte-0.1.8.dist-info/RECORD,,