tools4vasp 0.0.2__py3-none-any.whl

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/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/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/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/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/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/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)

tools4vasp/mixed_interpolate.py

@@ -0,0 +1,145 @@
+#!/usr/bin/python
+
+# Uses geodesic interpolation for the molecule and idpp interpolation for the surface of a molecule
+
+from ase.io import read
+from ase import Atoms
+from ase.mep import NEB
+# from ase.calculators.lj import LennardJones as LJ
+from ase.io import Trajectory
+from ase.visualize import view
+from pathlib import Path
+from geodesic_interpolate.interpolation import redistribute
+from geodesic_interpolate.geodesic import Geodesic
+from math import floor,ceil
+
+######## Functions as copied from geodesic_wrapper.py ########
+def ase_geodesic_interpolate(initial_mol,final_mol, n_images = 20, friction = 0.01, dist_cutoff = 3, scaling = 1.7, sweep = None, tol = 0.002, maxiter = 15, microiter = 20):
+    atom_string = initial_mol.symbols
+    
+    atoms = list(atom_string)
+
+    initial_pos = [initial_mol.positions]
+    final_pos = [final_mol.positions]
+
+    total_pos = initial_pos + final_pos
+
+    # First redistribute number of images.  Perform interpolation if too few and subsampling if too many
+    # images are given
+    raw = redistribute(atoms, total_pos, n_images, tol=tol * 5)
+
+    # Perform smoothing by minimizing distance in Cartesian coordinates with redundant internal metric
+    # to find the appropriate geodesic curve on the hyperspace.
+    smoother = Geodesic(atoms, raw, scaling, threshold=dist_cutoff, friction=friction)
+
+    if sweep is None:
+        sweep = len(atoms) > 35
+    try:
+        if sweep:
+            smoother.sweep(tol=tol, max_iter=maxiter, micro_iter=microiter)
+        else:
+            smoother.smooth(tol=tol, max_iter=maxiter)
+    finally:
+
+        all_mols = []
+        
+        for pos in smoother.path:
+            mol = Atoms(atom_string, pos)
+            all_mols.append(mol)
+        
+        return all_mols
+
+########## Functions copied from geodesic_wrapper.py ##########
+def interpolate_traj(initial,final,LEN,method,calculator=None):
+    interpolated_length=LEN
+    initial_1=initial.copy()
+    initial_1.calc=calculator #attach calculator to images between start and end
+    # RETURN=initial_1.copy()
+    images = [initial]
+    images += [initial_1.copy() for i in range(interpolated_length)] #create LEN instances
+    images += [final]
+    nebts = NEB(images)
+    nebts.interpolate(mic=True,method=method,apply_constraint=True)
+    new_traj=Trajectory(f'{LEN}_{method}_interpol.traj',mode='w')
+    for im in images:
+        new_traj.write(im)
+def create_trajs(START,END,LEN,method):
+    pass
+    # calc = LJ()
+    # TRAJ=interpolate_traj(START,END,LEN,method,calculator=calc)
+
+def vprint(words):
+    if args.verbose:
+        print(words)
+
+def create_both(initial_mol, final_mol, LEN, method):
+    create_trajs(initial_mol, final_mol, LEN, method) #create the interpolated trajectory using the idpp/direct method
+    trajectory_pbc=read(f'{LEN}_{method}_interpol.traj',index=':') #read the interpolated trajectory
+    vprint(f"Interpolated trajectory created with {len(trajectory_pbc)} images using {method} method")
+    trajectory_geodesic = ase_geodesic_interpolate(initial_mol,final_mol, n_images= LEN+1) #create the geodesic interpolated trajectory
+    vprint(f"Geodesic interpolated trajectory created with {len(trajectory_geodesic)} images")
+    difference=initial_mol[0].position-trajectory_geodesic[0][0].position
+    for image in trajectory_geodesic: #fix the the position of the shifted molecule since the geodesic interpolation does not use pbc
+        image.set_cell(initial_mol.cell)
+        for at in image:
+            at.position=at.position+difference
+    trajectory_geodesic.append(final_mol)
+    return(trajectory_pbc, trajectory_geodesic)
+######### Combination ######### @FThiemann
+
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Interpolate Mixing the geodesic and idpp/direct interpolation methods.')
+    parser.add_argument('start', type=str, help='POSCAR file of initial molecule')
+    parser.add_argument('end', type=str, help='POSCAR file of final molecule')
+    parser.add_argument('Images', type=int, help='Number of NEB Images to generate')
+    parser.add_argument('SurfaceCutoff', type=int, help='Length of the molecule')
+    parser.add_argument('method', type=str,choices=['idpp','direct'] , help='Interpolation method')
+    parser.add_argument('-c','--check', action='store_true', help='Check the cutoff trajectory')
+    parser.add_argument('-s','--show', action='store_true', help='view trajectory')
+    parser.add_argument('-v','--verbose', action='store_true', help='verbosity of output')
+    parser.add_argument('-i','--intermediate',help='Use a guess for the transition state, will be interpolated from start to I and from I to end')
+    global args
+    args = parser.parse_args()
+
+    initial_mol = read(args.start)
+    final_mol = read(args.end)
+    LEN = args.Images
+    moleculeStart = -1 * args.SurfaceCutoff
+    method = args.method
+
+    if args.intermediate:
+        vprint(f"using intermediate. first segment: {floor(LEN/2)}, second {ceil(LEN/2)} ")
+        in_read = read(args.intermediate)
+        trajectory_pbc1, trajectory_geodesic1 = create_both(initial_mol, in_read, floor((LEN)/2)-1, method)
+        trajectory_pbc2, trajectory_geodesic2 = create_both(in_read , final_mol, ceil((LEN)/2)-1, method)
+        trajectory_pbc = trajectory_pbc1.copy()
+        trajectory_pbc += trajectory_pbc2
+        trajectory_geodesic = trajectory_geodesic1.copy()
+        trajectory_geodesic += trajectory_geodesic2
+        vprint(f"total length of geodesic: {len(trajectory_geodesic)}; pbc: {len(trajectory_pbc)}")
+    else:
+        trajectory_pbc, trajectory_geodesic = create_both(initial_mol, final_mol, LEN, method)
+    newTrajectory = trajectory_pbc.copy()
+    new_traj=Trajectory(f'{LEN}_interpol.traj',mode='w')
+    for nr, image in enumerate(trajectory_pbc):
+        atoms_idpp = trajectory_pbc[nr]
+        atoms_geodesic = trajectory_geodesic[nr]
+        molecule = atoms_geodesic[moleculeStart:]
+        surface = atoms_idpp[:moleculeStart]
+        if nr == 0 and args.check is True: #check the cutoff
+            view(surface)
+            view(molecule)
+        merged = Atoms(surface + molecule) #merge the molecule and the surface
+        newTrajectory[nr] = merged
+        new_traj.write(merged)
+        N=f'{nr:02d}'
+        vprint(f'Writing {N}/POSCAR')
+        Path(N).mkdir(parents=True,exist_ok=True)
+        newTrajectory[nr].write(f'{N}/POSCAR',format='vasp')
+    
+    if args.show is True:
+        view(newTrajectory)
+main()

tools4vasp/neb2movie.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+#
+# Script to convert VASP NEB calculation to ASE-extxyz trajectory
+# by Patrick Melix
+#
+# You can import the module and then call .main() or use it as a script
+from ase import io
+import os
+import glob
+
+def main(outFile='movie.xyz', workdir='.', wrap='False', use=None):
+    """
+        use: None -> Auto use CONTCAR if available, otherwise POSCAR
+             CONTCAR or POSCAR
+    """
+
+    #if output exists mv to .bak
+    if os.path.isfile(outFile):
+        print('ATTENTION: {:} exists, moving to *.bak'.format(outFile))
+        os.rename(outFile, outFile+'.bak')
+
+    if use:
+        filename = use
+    else:
+        if os.path.isfile(os.path.join(workdir,'01','CONTCAR')):
+            filename = 'CONTCAR'
+        elif os.path.isfile(os.path.join(workdir,'01','POSCAR')):
+            filename = 'POSCAR'
+        else:
+            raise RuntimeError("Could neither find CONTCAR nor POSCAR in {:}".format(os.path.join(workdir,'01')))
+        print("Using {:} files.".format(filename))
+    mol = []
+    dirs = glob.glob(os.path.join(workdir,'[0-9][0-9]'))
+    dirs.sort()
+    print("Found {:} NEB subdirs.".format(len(dirs)))
+    print("Loading images ", end='')
+    for i,image in enumerate(dirs):
+        if (i == 0) or (i == len(dirs)-1):
+            imagePath = os.path.join(image, 'POSCAR')
+        else:
+            imagePath = os.path.join(image,filename)
+        if not os.path.isfile(imagePath):
+            raise RuntimeError('File {:} does not exist'.format(str(imagePath)))
+
+        print(" {:}".format(os.path.split(image)[-1]), end='')
+        mol.append(io.read(imagePath, format='vasp'))
+
+    print("")
+    for frame in mol:
+        if wrap:
+            frame.wrap(center=(0.0,0.0,0.0))
+        frame.write(outFile,append=True)
+    return
+
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description='Convert VASP NEB to ASE-extxyz trajectory')
+    parser.add_argument('-o', type=str, help='Output xyz file', default='movie.xyz')
+    parser.add_argument('-i', type=str, help='Workdir', default='.')
+    parser.add_argument('-w', help='Wrap structure with origin as center', action='store_const', default=False, const=True)
+    parser.add_argument('use', type=str, help='Use 1: CONTCAR or 0: POSCAR, default: Auto choose CONTCAR over POSCAR.', nargs='?')
+    args = parser.parse_args()
+    if args.use == "1":
+        use = 'CONTCAR'
+    elif args.use == "0":
+        use = 'POSCAR'
+    else:
+        use = None
+    main(args.o, args.i, args.w, use)
+
+