LAMMPS-Tutorials-02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LAMMPS Tutorials 02. Using variables and iterating in LAMMPS!\n",
    "\n",
    "### Author: Mark Tschopp, mark.a.tschopp.civ at mail.mil\n",
    "\n",
    "Please contact me if you have a problem with this tutorial, so I can modify in Github.  I have added FAQs, and will update my versions of LAMMPS in the future to keep the scripts current.\n",
    "\n",
    "The latest version of this [Jupyter Notebook](http://ipython.org/notebook.html) tutorial is available at https://github.com/mrkllntschpp/lammps-tutorials.\n",
    "\n",
    "The original tutorials are given here: https://icme.hpc.msstate.edu/mediawiki/index.php/LAMMPS_tutorials.  A number of these tutorials are out of date and have been ported over into the current iPython Jupyter Notebook tutorials on github.\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Description:\n",
    "<a id=\"Sec1\"></a>\n",
    "This is part two of a tutorial for running LAMMPS simulation on a Windows machine. For this example, the molecular dynamics simulation calculates the equilibrium lattice constant and the corresponding cohesive energy for aluminum. This tutorial will introduce the use of variables via command line and using MATLAB/Python for running LAMMPS. \n",
    "\n",
    "<img src=\"https://icme.hpc.msstate.edu/mediawiki/images/e/ef/Fcc_stereo.gif\" alt=\"Face-centered Cubic Lattice Structure\" title=\"FCC Lattice Structure\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complete Tutorial One \n",
    "\n",
    "If you have not done so already, complete the first tutorial available [here](https://github.com/mrkllntschpp/lammps-tutorials). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Step 1: Modify the input file \n",
    "\n",
    "This input script was run using the 24Jan2020 version of LAMMPS. Changes in some commands may require revision of the input script. In the below input script, the initial lattice constant (4) was replaced with the variable **latconst** (\\${latconst}). Either modify the initial script `calc_fcc.in` or copy the text below and paste it into a new text file. Name the modified file: `calc_fcc_ver1.in`. If pasting, use the `Paste Special` command with `Unformatted Text`. Note, this requires the variable **latconst** to be manually passed in from the command line when executing lammps, e.g. `lmp_win_no-mpi -in calc_fcc_ver1.in -var latconst 4`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting calc_fcc_ver1.in\n"
     ]
    }
   ],
   "source": [
    "%%writefile calc_fcc_ver1.in\n",
    "######################################\n",
    "# LAMMPS INPUT SCRIPT\n",
    "# Find minimum energy fcc configuration\n",
    "# Mark Tschopp\n",
    "# This requires the variable latconst to be input via the command line\n",
    "# e.g., lmp_win_no-mpi -var latconst 4 < calc_fcc_ver1.in\n",
    "\n",
    "######################################\n",
    "# INITIALIZATION\n",
    "clear \n",
    "units metal \n",
    "dimension 3 \n",
    "boundary p p p \n",
    "atom_style atomic \n",
    "atom_modify map array\n",
    "\n",
    "######################################\n",
    "# ATOM DEFINITION\n",
    "lattice fcc ${latconst}\n",
    "region box block 0 1 0 1 0 1 units lattice\n",
    "create_box 1 box\n",
    "\n",
    "lattice fcc ${latconst} orient x 1 0 0 orient y 0 1 0 orient z 0 0 1  \n",
    "create_atoms 1 box\n",
    "replicate 1 1 1\n",
    "\n",
    "######################################\n",
    "# DEFINE INTERATOMIC POTENTIAL\n",
    "pair_style eam/alloy \n",
    "pair_coeff * * Al99.eam.alloy Al\n",
    "neighbor 2.0 bin \n",
    "neigh_modify delay 10 check yes \n",
    " \n",
    "######################################\n",
    "# DEFINE COMPUTES \n",
    "compute eng all pe/atom \n",
    "compute eatoms all reduce sum c_eng \n",
    "\n",
    "#####################################################\n",
    "# MINIMIZATION\n",
    "reset_timestep 0 \n",
    "fix 1 all box/relax iso 0.0 vmax 0.001\n",
    "thermo 10 \n",
    "thermo_style custom step pe lx ly lz press pxx pyy pzz c_eatoms \n",
    "min_style cg \n",
    "minimize 1e-25 1e-25 5000 10000 \n",
    "\n",
    "variable natoms equal \"count(all)\" \n",
    "variable teng equal \"c_eatoms\"\n",
    "variable length equal \"lx\"\n",
    "variable ecoh equal \"v_teng/v_natoms\"\n",
    "\n",
    "print \"Total energy (eV) = ${teng};\"\n",
    "print \"Number of atoms = ${natoms};\"\n",
    "print \"Lattice constant (Angstoms) = ${length};\"\n",
    "print \"Cohesive energy (eV) = ${ecoh};\"\n",
    "\n",
    "print \"All done!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Step 2: Run in LAMMPS \n",
    "OK. Get to the command prompt and run the script that we just wrote.  It should look like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LAMMPS (3 Mar 2020)\r\n",
      "Lattice spacing in x,y,z = 4 4 4\r\n",
      "Created orthogonal box = (0 0 0) to (4 4 4)\r\n",
      "  1 by 1 by 1 MPI processor grid\r\n",
      "Lattice spacing in x,y,z = 4 4 4\r\n",
      "Created 4 atoms\r\n",
      "  create_atoms CPU = 0.000392914 secs\r\n",
      "Replicating atoms ...\r\n",
      "  orthogonal box = (0 0 0) to (4 4 4)\r\n",
      "  1 by 1 by 1 MPI processor grid\r\n",
      "  4 atoms\r\n",
      "  replicate CPU = 0.000504971 secs\r\n",
      "WARNING: Using 'neigh_modify every 1 delay 0 check yes' setting during minimization (src/min.cpp:190)\r\n",
      "Neighbor list info ...\r\n",
      "  update every 1 steps, delay 0 steps, check yes\r\n",
      "  max neighbors/atom: 2000, page size: 100000\r\n",
      "  master list distance cutoff = 8.28721\r\n",
      "  ghost atom cutoff = 8.28721\r\n",
      "  binsize = 4.1436, bins = 1 1 1\r\n",
      "  1 neighbor lists, perpetual/occasional/extra = 1 0 0\r\n",
      "  (1) pair eam/alloy, perpetual\r\n",
      "      attributes: half, newton on\r\n",
      "      pair build: half/bin/atomonly/newton\r\n",
      "      stencil: half/bin/3d/newton\r\n",
      "      bin: standard\r\n",
      "Setting up cg style minimization ...\r\n",
      "  Unit style    : metal\r\n",
      "  Current step  : 0\r\n",
      "WARNING: Energy due to 1 extra global DOFs will be included in minimizer energies\r\n",
      "Per MPI rank memory allocation (min/avg/max) = 4.495 | 4.495 | 4.495 Mbytes\r\n",
      "Step PotEng Lx Ly Lz Press Pxx Pyy Pzz c_eatoms \r\n",
      "       0   -13.417787            4            4            4     29590.11     29590.11     29590.11     29590.11   -13.417787 \r\n",
      "      10   -13.439104         4.04         4.04         4.04    5853.9553    5853.9553    5853.9553    5853.9553   -13.439104 \r\n",
      "      19       -13.44    4.0500047    4.0500047    4.0500047 -2.9409537e-10 -2.9855812e-10 -2.9052516e-10 -2.9320282e-10       -13.44 \r\n",
      "Loop time of 0.000791073 on 1 procs for 19 steps with 4 atoms\r\n",
      "\r\n",
      "50.2% CPU use with 1 MPI tasks x no OpenMP threads\r\n",
      "\r\n",
      "Minimization stats:\r\n",
      "  Stopping criterion = energy tolerance\r\n",
      "  Energy initial, next-to-last, final = \r\n",
      "        -13.4177872966     -13.4399999527     -13.4399999527\r\n",
      "  Force two-norm initial, final = 3.54599 3.61316e-14\r\n",
      "  Force max component initial, final = 3.54599 3.61302e-14\r\n",
      "  Final line search alpha, max atom move = 1 3.61302e-14\r\n",
      "  Iterations, force evaluations = 19 26\r\n",
      "\r\n",
      "MPI task timing breakdown:\r\n",
      "Section |  min time  |  avg time  |  max time  |%varavg| %total\r\n",
      "---------------------------------------------------------------\r\n",
      "Pair    | 0.00039339 | 0.00039339 | 0.00039339 |   0.0 | 49.73\r\n",
      "Neigh   | 0          | 0          | 0          |   0.0 |  0.00\r\n",
      "Comm    | 9.3937e-05 | 9.3937e-05 | 9.3937e-05 |   0.0 | 11.87\r\n",
      "Output  | 1.502e-05  | 1.502e-05  | 1.502e-05  |   0.0 |  1.90\r\n",
      "Modify  | 0          | 0          | 0          |   0.0 |  0.00\r\n",
      "Other   |            | 0.0002887  |            |       | 36.50\r\n",
      "\r\n",
      "Nlocal:    4 ave 4 max 4 min\r\n",
      "Histogram: 1 0 0 0 0 0 0 0 0 0\r\n",
      "Nghost:    662 ave 662 max 662 min\r\n",
      "Histogram: 1 0 0 0 0 0 0 0 0 0\r\n",
      "Neighs:    280 ave 280 max 280 min\r\n",
      "Histogram: 1 0 0 0 0 0 0 0 0 0\r\n",
      "\r\n",
      "Total # of neighbors = 280\r\n",
      "Ave neighs/atom = 70\r\n",
      "Neighbor list builds = 0\r\n",
      "Dangerous builds = 0\r\n",
      "Total energy (eV) = -13.4399999527351;\r\n",
      "Number of atoms = 4;\r\n",
      "Lattice constant (Angstoms) = 4.05000466178543;\r\n",
      "Cohesive energy (eV) = -3.35999998818377;\r\n",
      "All done!\r\n",
      "Total wall time: 0:00:00\r\n"
     ]
    }
   ],
   "source": [
    "!lmp_serial -var latconst 4.0 < calc_fcc_ver1.in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try modifying the starting lattice constant from the command line, *e.g.*, to start with a lattice constant of 3.0 Angstroms, type 'lmp_serial -var latconst 3.0 < calc_fcc_ver1.in'. This will not affect the final values (above), but it will start the simulation with a lower lattice constant for the FCC structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/bin/sh: 1: C:/Program Files/LAMMPS 64-bit 24Jan2020/bin/lmp_serial: not found\r\n"
     ]
    }
   ],
   "source": [
    "!\"C:/Program Files/LAMMPS 64-bit 24Jan2020/bin/lmp_serial\" -var latconst 3.0 < calc_fcc_ver1.in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Step 3: Iterate and Run in MATLAB \n",
    "\n",
    "Now, the exciting part! In this section, MATLAB will be used to run a LAMMPS simulation in Windows. Follow these steps: \n",
    "1. Open MATLAB \n",
    "1. Change to the directory that contains the LAMMPS executable (`lmp_serial.exe`), the input script (`calc_fcc_ver1.in`), and the potential file (`Al99.eam.alloy`). \n",
    "1. Type `system('lmp_serial -var latconst 4 < calc_fcc_ver1.in');` \n",
    "1. The simulation should show up on the MATLAB screen. When it completes, it will display \"All done\"! \n",
    "\n",
    "Now that you can run a simulation from MATLAB, it is easy to loop over a number of different lattice constants to calculate the energy. For instance, modify the input script again to only display the energy for the lattice constant input through the command line. The script should look like this: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting calc_fcc_ver2.in\n"
     ]
    }
   ],
   "source": [
    "%%writefile calc_fcc_ver2.in\n",
    "######################################\n",
    "# LAMMPS INPUT SCRIPT\n",
    "# Find minimum energy fcc configuration\n",
    "# Mark Tschopp\n",
    "# This requires the variable latconst to be input via the command line\n",
    "# e.g., lmp_win_no-mpi -var latconst 4 < calc_fcc_ver1.in\n",
    "\n",
    "######################################\n",
    "# INITIALIZATION\n",
    "clear \n",
    "units metal \n",
    "dimension 3 \n",
    "boundary p p p \n",
    "atom_style atomic \n",
    "atom_modify map array\n",
    "\n",
    "######################################\n",
    "# ATOM DEFINITION\n",
    "lattice fcc ${latconst} orient x 1 0 0 orient y 0 1 0 orient z 0 0 1  \n",
    "region box block 0 1 0 1 0 1 units lattice\n",
    "create_box 1 box\n",
    "create_atoms 1 box\n",
    "replicate 1 1 1\n",
    "\n",
    "######################################\n",
    "# DEFINE INTERATOMIC POTENTIAL\n",
    "pair_style eam/alloy \n",
    "pair_coeff * * Al99.eam.alloy Al\n",
    "neighbor 2.0 bin \n",
    "neigh_modify delay 10 check yes \n",
    " \n",
    "######################################\n",
    "# RUN 0\n",
    "run 0\n",
    "\n",
    "variable natoms equal \"count(all)\" \n",
    "variable teng equal \"pe\"\n",
    "variable length equal \"lx\"\n",
    "variable ecoh equal \"v_teng/v_natoms\"\n",
    "\n",
    "print \"Total energy (eV) = ${teng};\"\n",
    "print \"Number of atoms = ${natoms};\"\n",
    "print \"Lattice constant (Angstoms) = ${length};\"\n",
    "print \"Cohesive energy (eV) = ${ecoh};\"\n",
    "print \"%% ecoh = ${ecoh};\"\n",
    "\n",
    "print \"All done!\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `run 0` command can be used to calculate the energy of the system without actually running an iteration. Name this `calc_fcc_ver2.in` and combine this with a simple MATLAB script like this: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```OCTAVE\n",
    "% MATLAB Script for running LAMMPS multiple times\n",
    "\n",
    "count = 0;\n",
    "for i = 3.0:0.10:5.0\n",
    "    command_line = ['lmp_win_no-mpi -var latconst ' num2str(i) ' < calc_fcc_ver2.in'];\n",
    "\n",
    "    % this next line executes the command line\n",
    "    system(command_line)\n",
    "\n",
    "    % all that is left is to mine the 'log.lammps' file for the energy\n",
    "    fid = fopen('log.lammps');\n",
    "        tline = fgetl(fid);\n",
    "        while ~feof(fid)\n",
    "           matches = strfind(tline, '%%');\n",
    "           num = length(matches);\n",
    "           if num > 0 && matches == 1\n",
    "                teval = strrep(tline,'%%','');\n",
    "                eval(teval)\n",
    "           end\n",
    "           tline = fgetl(fid);\n",
    "        end\n",
    "    fclose(fid);\n",
    "\n",
    "   % store the values in a matrix\n",
    "   count = count + 1;\n",
    "   X(count) = i; Y(count) = ecoh;\n",
    "end\n",
    "\n",
    "plot(X,Y,'-*r'), axis square\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This script increases the lattice constant (variable `i`) from 3.0 to 5.0 Angstroms in increments of 0.10 Angstroms (`3.0:0.10:0.50`) AND calculates the energy for each lattice constant. As an easy extension, MATLAB can now be used to run hundreds of simulations, extract energies, and plot the lattice constant-energy curve in a matter of a minute or so. Notice the line `print \"%% ecoh = ${ecoh};\"` in the `calc_fcc_ver2.in` script.  The '\\%\\%' is used as a flag for when MATLAB mines the `log.lammps` file. This MATLAB script iteratively reads every line in the `log.lammps` file and checks to see if the flag \\%\\% is contained within each line. When MATLAB finds a line with the flag, it removes the flag, and evaluates (`eval`) the rest of the line in MATLAB (which converts the string to a variable in the MATLAB stack). Notice that vector `X` in MATLAB contains the lattice constant that is passed to LAMMPS and vector `Y` in MATLAB now contains the potential energy `ecoh` that was computed in LAMMPS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Run Iteratively in Python\n",
    "\n",
    "Now let's try it in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.00 -log log_000.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.10 -log log_001.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.20 -log log_002.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.30 -log log_003.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.40 -log log_004.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.50 -log log_005.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.60 -log log_006.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.70 -log log_007.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.80 -log log_008.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.90 -log log_009.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.00 -log log_010.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.10 -log log_011.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.20 -log log_012.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.30 -log log_013.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.40 -log log_014.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.50 -log log_015.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.60 -log log_016.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.70 -log log_017.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.80 -log log_018.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.90 -log log_019.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 5.00 -log log_020.lammps\n",
      "[3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0]\n",
      "--- 0.3668992519378662 seconds ---\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import subprocess \n",
    "import shlex\n",
    "import time\n",
    "\n",
    "start_time = time.time()\n",
    "j = 0\n",
    "x = []\n",
    "for i in list(np.arange(3.00, 5.05, 0.10)):\n",
    "    command_line = f'lmp_serial -in calc_fcc_ver2.in -var latconst {i:0.02f} -log log_{j:03d}.lammps'\n",
    "    x.append(round(i,3))\n",
    "    j += 1\n",
    "    print(command_line)\n",
    "    args = shlex.split(command_line)\n",
    "#    p = subprocess.call(args) # Success! but much slower...\n",
    "    p = subprocess.Popen(args) # Success!\n",
    "    \n",
    "print(x)\n",
    "print(\"--- %s seconds ---\" % (time.time() - start_time))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow!  That ran quickly.  And, it created a bunch of log files.  I purposedly separated the different parts of this process in Python.  Now, we are going to read the cohesive energy for each lattice constant into a variable and store it in a vector.  While I removed the `;` in the flagged line for execution in Python, I could have just modified the script so that it was Python executable, as opposed to MATLAB executable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0.00502324104309082 seconds ---\n"
     ]
    }
   ],
   "source": [
    "# how do I read each line in script, find the flag, and assign ecoh to a vector Y for plotting\n",
    "\n",
    "import glob, os\n",
    "import time\n",
    "\n",
    "start_time = time.time()\n",
    "target = \"%%\"\n",
    "y = []\n",
    "for file in glob.glob(\"log_*.lammps\"):\n",
    "    with open(file) as f:\n",
    "        for line in f:\n",
    "            if target in line and \"print\" not in line:\n",
    "                exec(line.replace(\"%% \",\"\").replace(\";\",\"\"))\n",
    "                y.append(ecoh)\n",
    "\n",
    "print(\"--- %s seconds ---\" % (time.time() - start_time))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK.  Now that I have both of those, let's put everything together and plot it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.00 -log log_000.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.10 -log log_001.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.20 -log log_002.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.30 -log log_003.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.40 -log log_004.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.50 -log log_005.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.60 -log log_006.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.70 -log log_007.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.80 -log log_008.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 3.90 -log log_009.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.00 -log log_010.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.10 -log log_011.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.20 -log log_012.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.30 -log log_013.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.40 -log log_014.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.50 -log log_015.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.60 -log log_016.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.70 -log log_017.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.80 -log log_018.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 4.90 -log log_019.lammps\n",
      "lmp_serial -in calc_fcc_ver2.in -var latconst 5.00 -log log_020.lammps\n",
      "--- 0.9060752391815186 seconds ---\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import subprocess \n",
    "import shlex\n",
    "import glob, os\n",
    "import time\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "j = 0\n",
    "x = []\n",
    "y = []\n",
    "target = \"%%\"\n",
    "for i in list(np.arange(3.00, 5.05, 0.10)):\n",
    "    command_line = f'lmp_serial -in calc_fcc_ver2.in -var latconst {i:0.02f} -log log_{j:03d}.lammps'\n",
    "    x.append(round(i,3))\n",
    "    file = f\"log_{j:03d}.lammps\"\n",
    "    j += 1\n",
    "    print(command_line)\n",
    "    args = shlex.split(command_line)\n",
    "    p = subprocess.Popen(args) # Success!\n",
    "    p.wait()\n",
    "    with open(file) as f:\n",
    "        for line in f:\n",
    "            if target in line and \"print\" not in line:\n",
    "                exec(line.replace(\"%% \",\"\").replace(\";\",\"\"))\n",
    "                y.append(ecoh)\n",
    "\n",
    "print(\"--- %s seconds ---\" % (time.time() - start_time))\n",
    "                \n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import *\n",
    "figure()\n",
    "plot(x, y, 'r*-')\n",
    "xlabel('Lattice constant (Angstrom)')\n",
    "ylabel('Cohesive Energy (eV)')\n",
    "title('aluminum cohesive energy evolution')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmm.  It's quite a bit slower when you have to wait within a loop for each subprocess to finish with the `.wait()` command.  I had to put that in the script so it didn't start a subprocess and while it is still running, the Python script would try to open up the log file.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## LAMMPS Input Script Explained\n",
    "\n",
    "In this section, we will break down what LAMMPS is doing. The easy way to do this on your own is to consult the LAMMPS manual for each command or go to the Internet LAMMPS manual, *i.e.*, at https://lammps.sandia.gov\n",
    "\n",
    "So, first, what is different in this example?  Many of the LAMMPS commands have been explained in Tutorial 1.  Here is what I think is important in this tutorial.\n",
    "\n",
    "### `Variable` command\n",
    "\n",
    "<br>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "lattice fcc \\${latconst} <br>\n",
    "region box block 0 1 0 1 0 1 units lattice <br>\n",
    "create_box 1 box <br><br>\n",
    "lattice fcc \\${latconst} orient x 1 0 0 orient y 0 1 0 orient z 0 0 1 <br>\n",
    "create_atoms 1 box <br>\n",
    "replicate 1 1 1\n",
    "</div>\n",
    "\n",
    "OK. Do you remember those variables from the first LAMMPS input script? They can be fed in from the command line as well.  This is a great example of passing in the constant `latconst` from the command line and then using it within other LAMMPS commands.  If you combed through the script, you won't find any `variable` command that sets `latconst` to anything, i.e., because it is meant to be set from the command line.  It's usually a good idea to add a comment about the command line syntax or what variables need to be set outside of the script.\n",
    "\n",
    "### Print `%%` in log file.  Print and retrieve!\n",
    "\n",
    "<br>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "print \"%% ecoh = ${ecoh};\"\n",
    "</div>\n",
    "\n",
    "You are likely to miss this line if I didn't specifically call it out in the tutorial. This was just an easy way to flag certain lines within the log file, which is filled with all sorts of stuff.  There are a number of different iterations of this and you'll see in the tutorials how this is used in different ways to extract data from the LAMMPS simulations.  I like having all the information in a file, and then being able to extract it when I need to.\n",
    "\n",
    "But Mark, why didn't you just compile LAMMPS with Python and seemlessly pass information back-and-forth?  Well, because this is really easy to set up. Plus, my days of compiling Fortran versions of codes like LAMMPS on various supercomputers has left me permanently scarred.  It's gotten better, I know, but if I can not compile LAMMPS on a **WINDOWS** machine to people how to do a few things... I'll take it! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## FAQs \n",
    "\n",
    "<br>\n",
    "<div class=\"alert alert-danger\">\n",
    "Q1: So, what does the `run 0` command actually do? Is it minimization? Is it molecular dynamics?\n",
    "</div>\n",
    "\n",
    "A: The `run 0` command is not minimization or molecular dynamics. The atoms are not displaced at all by this command. This is merely a way for LAMMPS to know that it needs to calculate additionally information for each atom or for the entire system. For instance, before the `run 0` command, LAMMPS may not know the forces on each atom or the energy for the entire system. By executing the `run 0` command, LAMMPS will calculate all the forces and attributes necessary to run molecular dynamics, but will not actually perform the timestep at the end, moving the atoms. Now, the user can print these attributes to screen or to a dumpfile, etc. \n",
    "\n",
    "In some cases, the user will need to tell LAMMPS what values they want LAMMPS to calculate prior to a `run 0` command. For example, if you want the stresses on every atom, you will need to define a compute or a variable command prior to `run 0` and then let LAMMPS know that you need this value by inserting it in to the `thermo_style` command (like in Tutorial 3!). For more information, see the LAMMPS documentation on the run command. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Tutorial Links\n",
    "\n",
    "* [Click here to open Tutorial 1](LAMMPS-Tutorials-01.ipynb)\n",
    "* [Click here to open the next tutorial](LAMMPS-Tutorials-03.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## References \n",
    "\n",
    "1. S. Plimpton, \"Fast Parallel Algorithms for Short-Range Molecular Dynamics,\" J. Comp. Phys., 117, 1-19 (1995)."
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}