valyte 0.1.0__tar.gz

valyte-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include valyte/Logo.png

valyte-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,185 @@
+<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/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

valyte-0.1.0/setup.py

@@ -0,0 +1,33 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="valyte",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "numpy",
+        "matplotlib",
+        "pymatgen",
+    ],
+    include_package_data=True,
+    package_data={
+        "valyte": ["*.png"],
+    },
+    entry_points={
+        "console_scripts": [
+            "valyte=valyte.cli:main",
+        ],
+    },
+    author="Nikhil",
+    author_email="nikhil@example.com",
+    description="A CLI tool for VASP post-processing (DOS plotting)",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/nikyadav002/Valyte-Project",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)

valyte-0.1.0/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-0.1.0/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