tools4vasp 0.0.2__tar.gz

tools4vasp-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Patrick Melix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tools4vasp-0.0.2/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.1
+Name: tools4vasp
+Version: 0.0.2
+Summary: Python tools for VASP
+Home-page: https://github.com/Tonner-Zech-Group/VASP-tools
+Author: Patrick Melix
+Author-email: Patrick Melix <patrick.melix@uni-leipzig.de>
+Project-URL: Homepage, https://github.com/Tonner-Zech-Group/VASP-tools
+Project-URL: Issues, https://github.com/Tonner-Zech-Group/VASP-tools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Unix Shell
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Unix
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ase>=1.0
+Requires-Dist: matplotlib>=3.8.4
+Requires-Dist: natsort>=8.3.1
+Requires-Dist: numpy>=1.24.3
+Requires-Dist: pymatgen>=2023.5.10
+
+# VASP-tools
+
+Our collection of tools for pre- and post-processing VASP calculations. Mainly Python and Bash.
+
+## Installation
+
+Clone this repository and run `pip install .` inside the main directory. If you want to always use the latest content of the repo you can use the 'developement' install of pip by running `pip install -e .`. Just doing `git pull` to get the latest content of the repo will then automatically result in the usage of the latest code without need to reinstall.
+
+You can also use the latest release by installing it from PyPi:
+
+```bash
+pip install orcatools
+```
+
+## Dependencies
+
+Different for each script, but mainly
+
+- [ASE](https://wiki.fysik.dtu.dk/ase/)
+- [VTST](http://theory.cm.utexas.edu/vtsttools/)
+- [Pymatgen](https://pymatgen.org/)
+- [Geodesic Interpolation](https://github.com/virtualzx-nad/geodesic-interpolate)
+
+## Pre-Processing
+
+- freq2mode: generates MODECAR and mass-weighted MODCAR files from frequency calculations
+
+## Post-Processing
+
+- chgcar2cube.py: Convert CHGCAR-like files to cube files using Pymatgen and ASE.
+- neb2movie.py: Convert VASP NEB to ASE ext-xyz movie, just like nebmovie.pl of VTST.
+- poscar2nbands.py: Helper to get the NBANDS value for LOBSTER calculations using the current POSCAR, INCAR and POTCAR setup with 'standard' options.
+- vasp2traj.py: Convert VASP geometry optimization output to ASE compatible ext-xyz trajectory file.
+- vasp-check.py: Assert proper occupations and SCF+GO convergence in VASP using ASE.
+- vaspGetEF.py: Creates a plot of energy and forces along multiple GO runs (e.g. for restart jobs). Gathers data in all numeric subfolders and this folder containing a vasprun.xml file (depth one) and combines them in a single plot.
+- visualize-magnetization.sh: Creates a VMD visualisation state file for the magnetization denisty by splitting the CHGCAR (by running chgsplit.pl), converting it to a cube file (by running chgcar2cube.sh) and then creating representations for VMD.
+- viewMode.py: Shows a graphical preview of a MODECAR file using ase gui
+- plotIRC: Tool that creates a plot of VASP IRC calculations in both direction and is compatible with shifts in the starting structure.
+- replace_potcar_symlinks.sh: Searches for POTCARS in subdirs and replaces them with symlinks. CAREFUL!

tools4vasp-0.0.2/README.md

@@ -0,0 +1,39 @@
+# VASP-tools
+
+Our collection of tools for pre- and post-processing VASP calculations. Mainly Python and Bash.
+
+## Installation
+
+Clone this repository and run `pip install .` inside the main directory. If you want to always use the latest content of the repo you can use the 'developement' install of pip by running `pip install -e .`. Just doing `git pull` to get the latest content of the repo will then automatically result in the usage of the latest code without need to reinstall.
+
+You can also use the latest release by installing it from PyPi:
+
+```bash
+pip install orcatools
+```
+
+## Dependencies
+
+Different for each script, but mainly
+
+- [ASE](https://wiki.fysik.dtu.dk/ase/)
+- [VTST](http://theory.cm.utexas.edu/vtsttools/)
+- [Pymatgen](https://pymatgen.org/)
+- [Geodesic Interpolation](https://github.com/virtualzx-nad/geodesic-interpolate)
+
+## Pre-Processing
+
+- freq2mode: generates MODECAR and mass-weighted MODCAR files from frequency calculations
+
+## Post-Processing
+
+- chgcar2cube.py: Convert CHGCAR-like files to cube files using Pymatgen and ASE.
+- neb2movie.py: Convert VASP NEB to ASE ext-xyz movie, just like nebmovie.pl of VTST.
+- poscar2nbands.py: Helper to get the NBANDS value for LOBSTER calculations using the current POSCAR, INCAR and POTCAR setup with 'standard' options.
+- vasp2traj.py: Convert VASP geometry optimization output to ASE compatible ext-xyz trajectory file.
+- vasp-check.py: Assert proper occupations and SCF+GO convergence in VASP using ASE.
+- vaspGetEF.py: Creates a plot of energy and forces along multiple GO runs (e.g. for restart jobs). Gathers data in all numeric subfolders and this folder containing a vasprun.xml file (depth one) and combines them in a single plot.
+- visualize-magnetization.sh: Creates a VMD visualisation state file for the magnetization denisty by splitting the CHGCAR (by running chgsplit.pl), converting it to a cube file (by running chgcar2cube.sh) and then creating representations for VMD.
+- viewMode.py: Shows a graphical preview of a MODECAR file using ase gui
+- plotIRC: Tool that creates a plot of VASP IRC calculations in both direction and is compatible with shifts in the starting structure.
+- replace_potcar_symlinks.sh: Searches for POTCARS in subdirs and replaces them with symlinks. CAREFUL!

tools4vasp-0.0.2/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tools4vasp"
+dependencies = [
+  'ase >= 1.0',
+  'matplotlib >= 3.8.4',
+  'natsort >= 8.3.1',
+  'numpy >= 1.24.3',
+  'pymatgen >= 2023.5.10',  
+]
+version = "0.0.2"
+authors = [
+  { name="Patrick Melix", email="patrick.melix@uni-leipzig.de" },
+]
+description = "Python tools for VASP"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Unix Shell",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Unix",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Chemistry",
+]
+
+[project.urls]
+Homepage = "https://github.com/Tonner-Zech-Group/VASP-tools"
+Issues = "https://github.com/Tonner-Zech-Group/VASP-tools/issues"

tools4vasp-0.0.2/setup.cfg

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

tools4vasp-0.0.2/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup
+import glob
+import site
+import sys
+site.ENABLE_USER_SITE = "--user" in sys.argv[1:]
+
+with open("README.md", 'r') as f:
+    long_description = f.read()
+
+scripts = []
+for file in glob.glob('tools4vasp/*'):
+    if file.endswith('.py'):
+        scripts.append(file)
+    elif file.endswith('.sh'):
+        scripts.append(file)
+
+setup(
+   name='tools4vasp',
+   version='1.0',
+   description='Python tools for VASP',
+   long_description=open('README.md').read(),
+   long_description_content_type='text/markdown',
+   author='Patrick Melix',
+   author_email='patrick.melix@uni-leipzig.de',
+   url="https://github.com/Tonner-Zech-Group/VASP-tools",
+   packages=['tools4vasp'],
+   install_requires=['ase', 'numpy', 'matplotlib', 'natsort', 'pymatgen'],
+   console_scripts = scripts
+)

tools4vasp-0.0.2/test/test_tools4vasp.py

@@ -0,0 +1,3 @@
+def test_dummy():
+        pass
+

tools4vasp-0.0.2/tools4vasp/add-MODECAR.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+from ase import io
+import numpy as np
+
+poscar = io.read('POSCAR')
+
+add = np.loadtxt('MODECAR')
+
+poscar.write('poscar+modecar.xyz')
+
+poscar.positions += add
+
+poscar.write('poscar+modecar.xyz', append=True)

tools4vasp-0.0.2/tools4vasp/chgcar2cube.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+#
+# Script to convert CHGCAR files to cube files and convert to e-/Ang^3
+# by Patrick Melix
+# 2022/04/04
+#
+# You can import the module and then call .main() or use it as a script
+from pymatgen.io.vasp.outputs import Chgcar
+from pymatgen.io.ase import AseAtomsAdaptor
+from ase.io.cube import write_cube
+import numpy as np
+import os
+
+
+def main(inFiles, outFiles, verbose=True, return_integrals=False, return_spin_integrals=False, mult_volume=False):
+    assert len(inFiles) == len(outFiles), "Number of input and output files must be equal!"
+    integrals = []
+    spin_integrals = []
+    for iFile,inFile in enumerate(inFiles):
+        if not os.path.isfile(inFile):
+            raise ValueError('File {:} does not exist'.format(inFile))
+
+        #if output exists mv to .bak
+        if os.path.isfile(outFiles[iFile]):
+            if verbose:
+                print('ATTENTION: {:} exists, moving to *.bak'.format(outFiles[iFile]))
+            os.rename(outFiles[iFile], outFiles[iFile]+'.bak')
+
+        if verbose:
+            print("Reading {}".format(inFile))
+        full_chgcar = Chgcar.from_file(inFile)
+        spinpol = 'diff' in full_chgcar.data.keys()
+        if return_spin_integrals and not spinpol:
+            raise ValueError("File {} is not spinpolarized!".format(inFile))
+        shape = full_chgcar.data['total'].shape
+        n_data = np.prod(shape)
+        
+        if return_integrals:
+            integrals.append(np.sum(np.abs(full_chgcar.data['total'])))
+            integrals[-1] /= n_data
+        if return_spin_integrals:
+            spin_integrals.append(np.sum(np.abs(full_chgcar.data['diff'])))
+            spin_integrals[-1] /= n_data
+        if verbose:
+            print("Shape of data: {}".format(shape))
+            print("Total number of datapoints: {}".format(n_data))
+            if return_integrals:
+                integral = integrals[-1]
+            else:
+                integral = np.sum(np.abs(full_chgcar.data['total']))
+                integral /= n_data
+            print("Integral of total data is {}".format(integral))
+            if spinpol:
+                if return_spin_integrals:
+                    spin_integral = spin_integrals[-1]
+                else:
+                    spin_integral = np.sum(np.abs(full_chgcar.data['diff']))
+                    spin_integral /= n_data
+                print("Integral of diff data is {}".format(spin_integral))
+
+            origin = np.zeros(3)
+            atoms = AseAtomsAdaptor.get_atoms(full_chgcar.structure)
+
+            #Contrary to VASP Wiki, the CHGCAR is not rho*V, but rho*n_data.
+            #So in order to have the integral over space = nelectrons, we need to divide by n_data.
+            #Since this would result in super small numbers, we can transform to rho*V
+            factor = n_data
+            if mult_volume:
+                factor /= atoms.get_volume()
+            full_chgcar.data['total'] /= factor
+            if spinpol:
+                full_chgcar.data['diff'] /= factor
+            #write cube
+            filename = "{}.cube".format(outFiles[iFile])
+            if verbose:
+                print("Writing {}".format(filename))
+            with open(filename, 'w') as f:
+                write_cube(f, atoms, data=full_chgcar.data['total'], origin=origin)
+            if spinpol:
+                filename = "{}_mag.cube".format(outFiles[iFile])
+                if verbose:
+                    print("Writing {}".format(filename))
+                with open(filename, 'w') as f:
+                    write_cube(f, atoms, data=full_chgcar.data['diff'], origin=origin)
+                
+    if return_integrals:
+        if len(integrals) == 1:
+            if return_spin_integrals:
+                return integrals[0], spin_integrals[0]
+            else:
+                return integrals[0]
+        else:
+            if return_spin_integrals:
+                return integrals, spin_integrals
+            else:
+                return integrals
+    else:
+        return
+
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description='Convert one or many CHGCAR-like files to cube format.')
+    parser.add_argument('input', type=str, nargs='+', help='Input Files')
+    parser.add_argument('-output', type=str, nargs='+', help='Output File Names (no extension)')
+    parser.add_argument('-v', help='Verbose', action='store_true')
+    parser.add_argument('--integral', help='Print Integrals', action='store_true')
+    parser.add_argument('--volume', help='Multiply the Density with the Cell Volume', action='store_true')
+    args = parser.parse_args()
+    main(args.input, args.output, verbose=args.v, return_integrals=args.integral, mult_volume=args.volume)

tools4vasp-0.0.2/tools4vasp/elf2cube.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+#
+# Script to convert ELFCAR files to cube files
+# by Patrick Melix
+# 2022/04/04
+#
+# You can import the module and then call .main() or use it as a script
+from pymatgen.io.vasp.outputs import Elfcar
+from pymatgen.io.ase import AseAtomsAdaptor
+from ase.io.cube import write_cube
+import numpy as np
+import os
+
+
+def main(inFiles, outFiles, verbose=True, return_integrals=False, return_spin_integrals=False):
+    assert len(inFiles) == len(outFiles), "Number of input and output files must be equal!"
+    integrals = []
+    spin_integrals = []
+    for iFile, inFile in enumerate(inFiles):
+        if not os.path.isfile(inFile):
+            raise ValueError('File {:} does not exist'.format(inFile))
+
+        # if output exists mv to .bak
+        if os.path.isfile(outFiles[iFile]):
+            if verbose:
+                print('ATTENTION: {:} exists, moving to *.bak'.format(outFiles[iFile]))
+            os.rename(outFiles[iFile], outFiles[iFile]+'.bak')
+
+        if verbose:
+            print("Reading {}".format(inFile))
+        full_elfcar = Elfcar.from_file(inFile)
+        spinpol = 'diff' in full_elfcar.data.keys()
+        #pymatgen: “total” key refers to Spin.up, and “diff” refers to Spin.down.
+        if return_spin_integrals and not spinpol:
+            raise ValueError("File {} is not spinpolarized!".format(inFile))
+        shape = full_elfcar.data['total'].shape
+        n_data = np.prod(shape)
+
+        if spinpol:
+            full_data = full_elfcar.data['total'] + full_elfcar.data['diff']
+        else:
+            full_data = full_elfcar.data['total']
+
+        if return_integrals:
+            integrals.append(np.sum(np.abs(full_data)))
+        if return_spin_integrals:
+            spin_integrals.append((np.sum(np.abs(full_elfcar.data['total'])), np.sum(np.abs(full_elfcar.data['diff']))))
+        if verbose:
+            print("Shape of data: {}".format(shape))
+            print("Total number of datapoints: {}".format(n_data))
+            if return_integrals:
+                integral = integrals[-1]
+            else:
+                integral = np.sum(np.abs(full_data))
+            print("Integral of total data is {}".format(integral))
+            if spinpol:
+                if return_spin_integrals:
+                    spin_integral = spin_integrals[-1]
+                else:
+                    spin_integral = (np.sum(np.abs(full_elfcar.data['total'])), np.sum(np.abs(full_elfcar.data['diff'])))
+                print("Integral of spin data is up: {}, down: {}".format(*spin_integral))
+
+            origin = np.zeros(3)
+            atoms = AseAtomsAdaptor.get_atoms(full_elfcar.structure)
+
+            # write cubes
+            if spinpol:
+                filename = "{}_up.cube".format(outFiles[iFile])
+                if verbose:
+                    print("Writing {}".format(filename))
+                with open(filename, 'w') as f:
+                    write_cube(f, atoms, data=full_elfcar.data['total'], origin=origin)
+                filename = "{}_down.cube".format(outFiles[iFile])
+                if verbose:
+                    print("Writing {}".format(filename))
+                with open(filename, 'w') as f:
+                    write_cube(f, atoms, data=full_elfcar.data['diff'], origin=origin)
+                filename = "{}_diff.cube".format(outFiles[iFile])
+                if verbose:
+                    print("Writing {}".format(filename))
+                with open(filename, 'w') as f:
+                    write_cube(f, atoms, data=full_elfcar.data['total']-full_elfcar.data['diff'], origin=origin)
+            else:
+                filename = "{}.cube".format(outFiles[iFile])
+                if verbose:
+                    print("Writing {}".format(filename))
+                with open(filename, 'w') as f:
+                    write_cube(f, atoms, data=full_data, origin=origin)
+
+    if return_integrals:
+        if len(integrals) == 1:
+            if return_spin_integrals:
+                return integrals[0], spin_integrals[0]
+            else:
+                return integrals[0]
+        else:
+            if return_spin_integrals:
+                return integrals, spin_integrals
+            else:
+                return integrals
+    else:
+        return
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description='Convert one or many ELFCAR files to cube format.')
+    parser.add_argument('input', type=str, nargs='+', help='Input Files')
+    parser.add_argument('-output', type=str, nargs='+', help='Output File Names (no extension)')
+    parser.add_argument('-v', help='Verbose', action='store_true')
+    args = parser.parse_args()
+    main(args.input, args.output, verbose=args.v)

tools4vasp-0.0.2/tools4vasp/freq2jmol.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+from ase.calculators.vasp import Vasp
+import os
+os.environ['VASP_PP_PATH'] = "/home/patrickm/lib/vasp/ase"
+
+calc = Vasp(restart=True, directory='./')
+vibs = calc.get_vibrations()
+vibs.write_jmol()
+
+energies = vibs.get_energies()
+nVibs = len(energies)
+for i in range(nVibs):
+    with open("vib-{:03d}.xyz".format(i+1), 'w') as f:
+        for frame in vibs.iter_animated_mode(i):
+            frame.write(f, format='extxyz')
+    print("Frequency #{:03d}: {:10.6f} cm-1".format(i+1, energies[i]))

tools4vasp-0.0.2/tools4vasp/freq2mode.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+import argparse
+import math
+from ase.data import atomic_masses
+import ase.io
+from ase.units import _amu as amu, _me as me
+
+
+def get_atomic_mass(element_symbol):
+    mass_in_amu = atomic_masses[element_symbol]
+    # Convert mass to atomic units (1 amu = 1.66053904e-27 kg)
+    mass_in_au = mass_in_amu * amu / me
+    return mass_in_au
+
+
+def getAtomsFromOutcar(outcar_file):
+    atoms = ase.io.read(outcar_file)
+    return atoms
+
+
+def get_frequencies(outcar):
+    freqLines = []
+    for line in outcar:
+        if " f/i=" in line:
+            freqLines.append(line)
+        if "Eigenvectors after division by SQRT(mass)" in line:
+            break
+    return freqLines
+
+
+def generate_mw(frequency, atoms):
+    weights = atoms.get_masses()
+    freq_mw = []
+    for i in range(len(frequency)):
+        freq_line = frequency[i]
+        factor = math.sqrt(weights[i])
+        new_freq_line = []
+        for freq in freq_line:
+            if not freq == 0:
+                new_freq_line.append(freq / factor)
+            else:
+                new_freq_line.append(0.0)
+        freq_mw.append(new_freq_line)
+    return freq_mw
+
+
+def write_modecar(frequency, filename):
+    filestring = ""
+    for freq_line in frequency:
+        line = ""
+        for freq in freq_line:
+            if freq >= 0:
+                line += "    "
+            else:
+                line += "   "
+            line += "{:.10E}".format(freq)
+        filestring += line + "\n"
+        with open(filename, "w") as file:
+            file.write(filestring)
+
+
+def read_frequency_from_outcar(outcar, freq_line, atoms):
+    current_frequency = []
+    start_index = outcar.index(freq_line) + 2
+    end_index = start_index + 0 + len(atoms)
+    for line in outcar[start_index:end_index]:
+        vals = line.split()
+        current_frequency.append([float(vals[3]), float(vals[4]), float(vals[5])])
+    return current_frequency
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog="freq2mode",
+        description="A VASP tool, which generates MODECAR and mass-weighted MODCAR files from frequency calculations",
+        epilog=""
+    )
+    parser.add_argument("-o", "--outcar", type=str, help="Optional: specify OUTCAR file", required=False, default="OUTCAR")
+    parser.add_argument("-i", "--index", type=int, help="Force non interactive mode by specifying the index of the imaginary frequency to use", required=False, default=-1)
+    args = parser.parse_args()
+    outcar_file = args.outcar
+    with open(outcar_file, "r") as f:
+        outcar = f.readlines()
+    atoms = getAtomsFromOutcar(outcar_file)
+    freqs = get_frequencies(outcar)
+    if len(freqs) == 0:
+        print("No imaginary frequencies found")
+        exit(0)
+    if len(freqs) < args.index + 1:
+        print("The specified mode was not found in the OUTCAR file")
+        exit(1)
+    if len(freqs) > 1:
+        print(f"Found {len(freqs)} imaginary frequencies. Select the frequency for MODECAR generation")
+        freq_index = 0
+        for freq in freqs:
+            print(f"{freq_index}    {freq}")
+            freq_index += 1
+        if args.index == -1:
+            freq_index = int(input("Frequency for MODECAR generation:"))
+        else:
+            print(f"Using Frequency {args.index}")
+            freq_index = args.index
+    else:
+        print("Found one imaginary mode:")
+        print(freqs[0])
+        print("Using this mode for MODECAR generation")
+        freq_index = 0
+    frequency = read_frequency_from_outcar(outcar, freqs[freq_index], atoms)
+    print("Writing MODECAR file")
+    write_modecar(frequency, "MODECAR")
+    print("Writing mass-weighted MODECAR file")
+    frequency_mw = generate_mw(frequency, atoms)
+    write_modecar(frequency_mw, "MODECAR.MW")

tools4vasp-0.0.2/tools4vasp/kgrid2kspacing.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+#
+# Script to get a KSPACING from a KPOINTS file and a POSCAR
+# by Patrick Melix
+# 2023/05/22
+#
+
+
+def get_kspacing():
+    from ase import io
+    import numpy as np
+    mol = io.read('POSCAR')
+    cellparams = mol.cell.cellpar()
+    r_cell = mol.cell.reciprocal()
+    print("The cell parameters are |a|={} |b|={} |c|={} alpha={} beta={} gamma={}".format(*[ round(x,2) for x in cellparams]))
+    print("The reciprocal cell is: {}".format(r_cell))
+    with open('KPOINTS', 'r') as f:
+        kpoints = f.readlines()
+    if kpoints[1].strip() != "0":
+        raise ValueError("KPOINTS file does not use Automatic Scheme, but only this is supported!")
+    kgrid = [ int(k) for k in kpoints[3].split() ]
+    assert len(kgrid) == 3, "Expected to find 3 integers in line 4 of KPOINTS file!"
+    print("The KGRID from KPOINTS is: {} {} {}".format(*kgrid))
+    kspacing = [ np.linalg.norm(r_cell[i])*2*np.pi/kgrid[i] for i in range(3) ]
+    #kgrid = [ int(max(1, np.ceil(np.linalg.norm(r_cell[i])*2*np.pi/kspacing))) for i in range(3)]
+    print("The corresponding KSPACING for KGRID {} {} {} is {}Å^-1, {}Å^-1, {}Å^-1".format(*kgrid, *[ round(k, 3) for k in kspacing ]))
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(
+        description='Get a KSPACING from current POSCAR and KPOINTS')
+    args = parser.parse_args()
+    get_kspacing()

tools4vasp-0.0.2/tools4vasp/kspacing2kgrid.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+#
+# Script to get a KGrid from a KSPACING value and a POSCAR
+# by Patrick Melix
+# 2023/05/22
+#
+
+
+def get_kgrid(kspacing):
+    from ase import io
+    import numpy as np
+    mol = io.read('POSCAR')
+    cellparams = mol.cell.cellpar()
+    r_cell = mol.cell.reciprocal()
+    print("The cell parameters are |a|={} |b|={} |c|={} alpha={} beta={} gamma={}".format(*[ round(x,2) for x in cellparams]))
+    print("The reciprocal cell is: {}".format(r_cell))
+    kgrid = [ int(max(1, np.ceil(np.linalg.norm(r_cell[i])*2*np.pi/kspacing))) for i in range(3)]
+    print("The corresponding KGRID for KSPACING {}Å^-1 is: {} {} {}".format(kspacing, *kgrid))
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(
+        description='Get a KGrid from current POSCAR and a KSPACING value')
+    parser.add_argument('kspacing', type=float, help='KSPACING value')
+    args = parser.parse_args()
+    get_kgrid(args.kspacing)