{ "cells": [ { "cell_type": "markdown", "id": "8fcccfd3", "metadata": {}, "source": [ "## Set up imports and helper functions\n", "\n", "This example runs a VASP geometry optimization through AMS and PLAMS and then inspects the generated VASP input files.\n", "\n", "For a **real** VASP calculation, you must replace the `VASPExec` and `POTCARLibrary` values below with paths for your own VASP installation and POTCAR library. In this notebook they are intentionally set to bundled **dummy** example values so that you can focus on the workflow and inspect the generated VASP files.\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "78f5ca28", "metadata": { "tags": [] }, "outputs": [], "source": [ "import os\n", "from pathlib import Path\n", "from typing import Optional\n", "\n", "import numpy as np\n", "from scm.base import ChemicalSystem, Lattice\n", "from scm.plams import AMSJob, Settings, view\n", "\n", "AMSHOME = Path(os.environ[\"AMSHOME\"])\n", "AMSBIN = Path(os.environ[\"AMSBIN\"])\n", "\n", "\n", "def print_tree(root: Path, max_depth: Optional[int] = None, depth: int = 0) -> None:\n", " \"\"\"Print a small directory tree rooted at ``root``.\"\"\"\n", " if depth == 0:\n", " print(root)\n", " if max_depth is not None and depth >= max_depth:\n", " return\n", "\n", " entries = sorted(root.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))\n", " for entry in entries:\n", " indent = \" \" * depth\n", " suffix = \"/\" if entry.is_dir() else \"\"\n", " print(f\"{indent}- {entry.name}{suffix}\")\n", " if entry.is_dir():\n", " print_tree(entry, max_depth=max_depth, depth=depth + 1)" ] }, { "cell_type": "markdown", "id": "c5892b5d", "metadata": {}, "source": [ "## Build the starting `ChemicalSystem`\n", "\n", "We start from `ChemicalSystem.from_smiles(\"COCO\")`, add a cubic `Lattice`, and shift the atoms into the middle of the unit cell. We explicitly enable the `vasp` atom attributes on the `ChemicalSystem` and set `atom.vasp.label = \"O_h\"` for every oxygen atom - this will use the `O_h` (hard) POTCAR files from the POTCAR library.\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "11b72cb0-d023-4333-be5f-e54dde30abca", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "System\n", " Atoms\n", " C 2.6856794203061445 3.9199419901846846 4.058575669511302\n", " O 3.7601207518845516 3.5083608227031062 4.6401629714014945 vasp.label=O_h\n", " C 4.933021513344075 3.872375390301085 3.7167210558876325\n", " O 6.059029715136155 3.4526577254417194 4.254444615424399 vasp.label=O_h\n", " H 2.45775147329223 3.5034676502464945 3.0599538733326\n", " H 2.6106929948919837 5.173283492865718 3.98527725134316\n", " H 1.7796445906520648 3.583834088594838 4.8894057730456595\n", " H 4.941336171978787 5.159401738868146 3.5394929899243293\n", " H 4.785515193212129 3.479040834222635 2.6738949779003613\n", " H 6.368007465768469 4.055758604343035 5.05540326186522\n", " End\n", " Lattice\n", " 8 0 0\n", " 0 8 0\n", " 0 0 8\n", " End\n", "End\n" ] } ], "source": [ "system = ChemicalSystem.from_smiles(\"COCO\")\n", "system.lattice = Lattice([[8.0, 0.0, 0.0], [0.0, 8.0, 0.0], [0.0, 0.0, 8.0]])\n", "system.perturb_coordinates(0.1)\n", "system.translate([4.0, 4.0, 4.0])\n", "system.bonds.clear_bonds()\n", "\n", "system.enable_atom_attributes(\"vasp\")\n", "for atom in system:\n", " if atom.symbol == \"O\":\n", " atom.vasp.label = \"O_h\"\n", "\n", "\n", "print(system)" ] }, { "cell_type": "code", "execution_count": 3, "id": "356ab41e-992e-4399-a0d8-4134a6865a9a", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "view(system, width=400, height=300, guess_bonds=True, direction=\"tilt_z\")" ] }, { "cell_type": "markdown", "id": "e83ce883", "metadata": {}, "source": [ "## Show the dummy VASPExec and POTCAR library used in this example\n", "\n", "The current `POTCARLibrary` path is only meant as an example value. For your own calculations, point `POTCARLibrary` to your real VASP pseudopotential library, and point `VASPExec` to the command that launches your VASP executable.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "ed02025a-8204-4316-8b72-635ddb082eac", "metadata": { "tags": [] }, "outputs": [], "source": [ "VASP_EXEC_DUMMY = f\"{AMSBIN}/amspython {AMSHOME}/scripting/scm/external_engines/backends/_vasp/fakevasp.py 6.4.0\"\n", "POTCAR_LIBRARY_DUMMY = AMSHOME / \"atomicdata\" / \"VASP\" / \"test_potcars\"" ] }, { "cell_type": "markdown", "id": "a29666cb-a921-47ec-b401-a1f8336020b2", "metadata": {}, "source": [ "### Command to execute VASP" ] }, { "cell_type": "code", "execution_count": 5, "id": "ad97f05f-0238-417e-90f5-02bdae7c0d6c", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dummy VASPExec:\n", "/home/hellstrom/adfhome/bin/amspython /home/hellstrom/adfhome/scripting/scm/external_engines/backends/_vasp/fakevasp.py 6.4.0\n", "\n" ] } ], "source": [ "print(\"Dummy VASPExec:\")\n", "print(VASP_EXEC_DUMMY)\n", "print()" ] }, { "cell_type": "markdown", "id": "e6ff620d-354f-44be-86d2-0af3a1247b89", "metadata": {}, "source": [ "### POTCAR Library" ] }, { "cell_type": "code", "execution_count": 6, "id": "090f2676-38b2-4fb6-ad14-248212026a04", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dummy POTCARLibrary:\n", "/home/hellstrom/adfhome/atomicdata/VASP/test_potcars\n", "\n", "Current POTCAR library structure:\n", "/home/hellstrom/adfhome/atomicdata/VASP/test_potcars\n", "- C/\n", " - POTCAR\n", "- C_compressed/\n", " - POTCAR.Z\n", "- H/\n", " - POTCAR\n", "- H.75/\n", " - POTCAR\n", "- H1.25/\n", " - POTCAR\n", "- O/\n", " - POTCAR\n", "- O_h/\n", " - POTCAR\n", "- O_s/\n", " - POTCAR\n" ] } ], "source": [ "print(\"Dummy POTCARLibrary:\")\n", "print(POTCAR_LIBRARY_DUMMY)\n", "print()\n", "print(\"Current POTCAR library structure:\")\n", "print_tree(POTCAR_LIBRARY_DUMMY, max_depth=2)" ] }, { "cell_type": "markdown", "id": "c65893f0", "metadata": {}, "source": [ "## Build the PLAMS `Settings` object\n", "\n", "The `VASPExec` and `POTCARLibrary` settings are essential for the VASP engine. In this notebook they use the dummy paths shown above, so replace them before using this workflow with a real VASP installation.\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "551deca3", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Task GeometryOptimization\n", "\n", "System\n", " Atoms\n", " C 2.6856794203061445 3.9199419901846846 4.058575669511302\n", " O 3.7601207518845516 3.5083608227031062 4.6401629714014945 vasp.label=O_h\n", " C 4.933021513344075 3.872375390301085 3.7167210558876325\n", " O 6.059029715136155 3.4526577254417194 4.254444615424399 vasp.label=O_h\n", " H 2.45775147329223 3.5034676502464945 3.0599538733326\n", " H 2.6106929948919837 5.173283492865718 3.98527725134316\n", " H 1.7796445906520648 3.583834088594838 4.8894057730456595\n", " H 4.941336171978787 5.159401738868146 3.5394929899243293\n", " H 4.785515193212129 3.479040834222635 2.6738949779003613\n", " H 6.368007465768469 4.055758604343035 5.05540326186522\n", " End\n", " Lattice\n", " 8 0 0\n", " 0 8 0\n", " 0 0 8\n", " End\n", "End\n", "\n", "Engine VASP\n", " EnergyCutoff 400\n", " KPOINTSOrigin Gamma-centered\n", " Occupation Gaussian\n", " POTCARLibrary /home/hellstrom/adfhome/atomicdata/VASP/test_potcars\n", " Smearing 0.01\n", " VASPExec /home/hellstrom/adfhome/bin/amspython /home/hellstrom/adfhome/scripting/scm/external_engines/backends/_vasp/fakevasp.py 6.4.0\n", " nk1 1\n", " nk2 1\n", " nk3 1\n", "EndEngine\n", "\n", "\n" ] } ], "source": [ "settings = Settings()\n", "\n", "settings.input.ams.Task = \"GeometryOptimization\"\n", "\n", "settings.input.VASP.EnergyCutoff = 400\n", "settings.input.VASP.VASPExec = VASP_EXEC_DUMMY\n", "settings.input.VASP.POTCARLibrary = str(POTCAR_LIBRARY_DUMMY)\n", "settings.input.VASP.KPOINTSOrigin = \"Gamma-centered\"\n", "settings.input.VASP.nk1 = 1\n", "settings.input.VASP.nk2 = 1\n", "settings.input.VASP.nk3 = 1\n", "settings.input.VASP.Occupation = \"Gaussian\"\n", "settings.input.VASP.Smearing = 0.01\n", "\n", "job = AMSJob(settings=settings, molecule=system, name=\"vasp_geoopt\")\n", "print(job.get_input())" ] }, { "cell_type": "markdown", "id": "e567b0a6", "metadata": {}, "source": [ "## Run the geometry optimization\n", "\n", "The AMS driver performs the geometry optimization, while the VASP engine writes the VASP-style files in the worker directory. In this documentation example, the engine command is the bundled fake-VASP executable.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "adf7e928", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[17.03|13:18:05] JOB vasp_geoopt STARTED\n", "[17.03|13:18:05] JOB vasp_geoopt RUNNING\n", "[17.03|13:18:10] JOB vasp_geoopt FINISHED\n", "[17.03|13:18:10] JOB vasp_geoopt SUCCESSFUL\n", "Job status ok: True\n", "Job directory: /home/hellstrom/adfhome/userdoc/ScriptingExamples/vasp-geometry-optimization/plams_workdir.004/vasp_geoopt\n" ] } ], "source": [ "results = job.run()\n", "print(f\"Job status ok: {results.ok()}\")\n", "print(f\"Job directory: {job.path}\")" ] }, { "cell_type": "markdown", "id": "512cf9c5", "metadata": {}, "source": [ "## Inspect the job directory\n", "\n", "The generated VASP files live inside the `worker.0.0.0` subdirectory of the PLAMS job directory.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "4956fd2b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/home/hellstrom/adfhome/userdoc/ScriptingExamples/vasp-geometry-optimization/plams_workdir.004/vasp_geoopt\n", "- worker.0.0.0/\n", " - def.py\n", " - EngineVASP.log\n", " - INCAR\n", " - KPOINTS\n", " - OUTCAR\n", " - POSCAR\n", " - POTCAR\n", " - VASP.log\n", "- ams.log\n", "- ams.rkf\n", "- input.json\n", "- output.xyz\n", "- system.system_in\n", "- vasp.rkf\n", "- vasp_geoopt.dill\n", "- vasp_geoopt.err\n", "- vasp_geoopt.in\n", "- vasp_geoopt.out\n", "- vasp_geoopt.run\n" ] } ], "source": [ "job_dir = Path(job.path)\n", "worker_dir = next(job_dir.glob(\"worker.*\"))\n", "\n", "print_tree(job_dir, max_depth=2)" ] }, { "cell_type": "markdown", "id": "376c41b0", "metadata": {}, "source": [ "## Inspect `INCAR`, `KPOINTS`, and `POTCAR`\n", "\n", "The files below are generated from the `Engine VASP` block and the atom labels on the `ChemicalSystem`:\n", "\n", "- `INCAR` reflects keywords such as `EnergyCutoff`, `Occupation`, and `Smearing`.\n", "- `KPOINTS` reflects `KPOINTSOrigin`, `nk1`, `nk2`, and `nk3`.\n", "- `POTCAR` is assembled from `POTCARLibrary` together with the atom labels, so the oxygen atoms labeled `O_h` pick up the `O_h/POTCAR` entry.\n" ] }, { "cell_type": "markdown", "id": "ba37bced-e82d-49f7-b176-e71cea53621f", "metadata": {}, "source": [ "### INCAR" ] }, { "cell_type": "code", "execution_count": 10, "id": "83df18cc-36b8-4fdf-b48b-ec97f66cac07", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# INPUT GENERATED BY VASP INTERACTIVE\n", "\n", "# MANDATORY INPUT\n", "POTIM = 0.0\n", "IBRION = -1\n", "INTERACTIVE = .TRUE.\n", "EDIFFG = 0\n", "NSW = 999999999\n", "\n", "# DEFAULT INPUT\n", "IWAVPR = 11\n", "ISYM = 0\n", "ISIF = 3\n", "\n", "# OPTIONAL INPUT\n", "ISPIN = 1\n", "ISMEAR = 0\n", "ENCUT = 400.0\n", "SIGMA = 0.01\n", "PREC = Normal\n", "IVDW = 0\n", "\n" ] } ], "source": [ "print((worker_dir / \"INCAR\").read_text())" ] }, { "cell_type": "markdown", "id": "0a788f81-34f5-4d8a-b5ab-b6015c77bf16", "metadata": {}, "source": [ "### KPOINTS" ] }, { "cell_type": "code", "execution_count": 11, "id": "0336ea05-12d6-4d10-9545-e9395f6a61f8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# KPOINTS GENERATED BY VASP INTERACTIVE\n", "0\n", "Gamma\n", " 1 1 1 \n", " 0.0 0.0 0.0 \n", "\n" ] } ], "source": [ "print((worker_dir / \"KPOINTS\").read_text())" ] }, { "cell_type": "markdown", "id": "afdfed52-f255-447c-9778-8abede4fd167", "metadata": {}, "source": [ "### POTCAR\n", "\n", "Note: each dummy POTCAR file is just a single line. Real POTCAR files are much bigger and have real data." ] }, { "cell_type": "code", "execution_count": 12, "id": "505a3266-af6e-4f6a-bf8e-eeeb51d270cd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "C POTCAR\n", "O_h POTCAR\n", "C POTCAR\n", "O_h POTCAR\n", "H POTCAR\n", "\n" ] } ], "source": [ "print((worker_dir / \"POTCAR\").read_text())" ] }, { "cell_type": "markdown", "id": "4307a8d3-800a-4d37-a564-607715a24c8c", "metadata": {}, "source": [ "## Avoid looking at `POSCAR`\n", "\n", "When running VASP via AMS, the `POSCAR` in the worker directory does **not** necessarily correspond to the original input structure. This is because sometimes VASP needs to be restarted (in case of changing composition, lattice, ...).\n", "\n", "Here is the POSCAR file for reference:\n", "\n", "### POSCAR" ] }, { "cell_type": "code", "execution_count": 13, "id": "867b7acf-f0d6-4e15-aca4-c080e051c466", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "System POTCARS: C, O_h, C, O_h, H\n", " 1.0000000000000000\n", " 8.0000000000000000 0.0000000000000000 0.0000000000000000\n", " 0.0000000000000000 8.0000000000000000 0.0000000000000000\n", " 0.0000000000000000 0.0000000000000000 8.0000000000000000\n", "C O C O H\n", "1 1 1 1 6\n", "Cartesian\n", " 2.6856794203061445 3.9199419901846846 4.0585756695113018\n", " 3.7601207518845516 3.5083608227031062 4.6401629714014945\n", " 4.9330215133440749 3.8723753903010851 3.7167210558876325\n", " 6.0590297151361554 3.4526577254417194 4.2544446154243989\n", " 2.4577514732922299 3.5034676502464945 3.0599538733326002\n", " 2.6106929948919837 5.1732834928657176 3.9852772513431600\n", " 1.7796445906520648 3.5838340885948381 4.8894057730456595\n", " 4.9413361719787874 5.1594017388681461 3.5394929899243293\n", " 4.7855151932121291 3.4790408342226349 2.6738949779003613\n", " 6.3680074657684687 4.0557586043430351 5.0554032618652203\n", "\n" ] } ], "source": [ "print((worker_dir / \"POSCAR\").read_text())" ] }, { "cell_type": "markdown", "id": "7dbc2c8b-5ccd-442e-870a-cbf6c5d3746e", "metadata": {}, "source": [ "In general, **prefer the normal AMS methods** to get the input or output systems from a finished job:" ] }, { "cell_type": "markdown", "id": "9744b8ae-3dd6-4c34-8b77-bc37ecfa1f57", "metadata": {}, "source": [ "### Input system" ] }, { "cell_type": "code", "execution_count": 14, "id": "a3c263f1-726e-45ac-b0c7-0b773d85ae11", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "System\n", " Atoms\n", " C 2.6856794203061445 3.9199419901846846 4.058575669511302\n", " O 3.7601207518845516 3.5083608227031062 4.6401629714014945 vasp.label=O_h\n", " C 4.933021513344075 3.872375390301085 3.7167210558876325\n", " O 6.059029715136155 3.4526577254417194 4.254444615424399 vasp.label=O_h\n", " H 2.45775147329223 3.5034676502464945 3.0599538733326\n", " H 2.6106929948919837 5.173283492865718 3.98527725134316\n", " H 1.7796445906520648 3.583834088594838 4.8894057730456595\n", " H 4.941336171978787 5.159401738868146 3.5394929899243293\n", " H 4.785515193212129 3.479040834222635 2.6738949779003613\n", " H 6.368007465768469 4.055758604343035 5.05540326186522\n", " End\n", " Lattice\n", " 8 0 0\n", " 0 8 0\n", " 0 0 8\n", " End\n", "End\n" ] } ], "source": [ "input_system = results.get_input_system()\n", "print(input_system)" ] }, { "cell_type": "markdown", "id": "f30441cd-993e-4fef-a9f2-1c9ae8785a6c", "metadata": {}, "source": [ "### Output system" ] }, { "cell_type": "code", "execution_count": 15, "id": "94a6807a-1ffe-4b8b-96ac-76ce10d82ebb", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "System\n", " Atoms\n", " C 2.6329504031813014 3.9918774506365327 4.083412503363929\n", " O 3.8660880228152315 3.534843359870515 4.591979968873295 vasp.label=O_h\n", " C 4.904959292879035 3.921219069595505 3.716720304465348\n", " O 6.128394423475451 3.465882633039338 4.221381820199423 vasp.label=O_h\n", " H 2.414581165435873 3.5421932329137946 3.0891805654541704\n", " H 2.609218201907933 5.102721856605182 4.0214124839331085\n", " H 1.8261189342303186 3.6779111031336296 4.777176727109537\n", " H 4.945202980489115 5.030700143042123 3.603445015365042\n", " H 4.7597209992206 3.4636746564444505 2.7124977605685223\n", " H 6.293564866831727 3.9770988324903884 5.056125290303781\n", " End\n", " Lattice\n", " 8 0 0\n", " 0 8 0\n", " 0 0 8\n", " End\n", "End\n" ] } ], "source": [ "optimized_system = results.get_main_system()\n", "print(optimized_system)" ] }, { "cell_type": "markdown", "id": "c89e6d8b-ff77-40f0-8d2f-a582ce221976", "metadata": {}, "source": [ "## Appendix: sort system by vasp.label\n", "\n", "It is common in VASP to sort the input structure by element (or, more precisely, by elemental POTCAR file). This reduces the size of the overall POTCAR file. You can do it like this:" ] }, { "cell_type": "code", "execution_count": 16, "id": "6e9e84ae-5fcb-4d85-9e96-f6995da2fb49", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "System\n", " Atoms\n", " C 2.6856794203061445 3.9199419901846846 4.058575669511302\n", " C 4.933021513344075 3.872375390301085 3.7167210558876325\n", " H 2.45775147329223 3.5034676502464945 3.0599538733326\n", " H 2.6106929948919837 5.173283492865718 3.98527725134316\n", " H 1.7796445906520648 3.583834088594838 4.8894057730456595\n", " H 4.941336171978787 5.159401738868146 3.5394929899243293\n", " H 4.785515193212129 3.479040834222635 2.6738949779003613\n", " H 6.368007465768469 4.055758604343035 5.05540326186522\n", " O 3.7601207518845516 3.5083608227031062 4.6401629714014945 vasp.label=O_h\n", " O 6.059029715136155 3.4526577254417194 4.254444615424399 vasp.label=O_h\n", " End\n", " Lattice\n", " 8 0 0\n", " 0 8 0\n", " 0 0 8\n", " End\n", "End\n" ] } ], "source": [ "sorted_system = system.copy()\n", "sorted_system.enable_atom_attributes(\"vasp\")\n", "sorted_system.sort_atoms(lambda A, B: (A.vasp.label or A.symbol) < (B.vasp.label or B.symbol))\n", "print(sorted_system)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.12" } }, "nbformat": 4, "nbformat_minor": 5 }