examples/Notebooks/flopy3_nwt_options.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with MODFLOW-NWT v 1.1 option blocks\n",
    "\n",
    "In MODFLOW-NWT an option block is present for the WEL file, UZF file, and SFR file. This block takes keyword arguments that are supplied in an option line in other versions of MODFLOW. \n",
    "\n",
    "The `OptionBlock` class was created to provide combatibility with the MODFLOW-NWT option block and allow the user to easily edit values within the option block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.10 (default, May 19 2021, 11:01:55) \n",
      "[Clang 10.0.0 ]\n",
      "flopy version: 3.3.4\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import platform\n",
    "\n",
    "try:\n",
    "    import flopy\n",
    "except:\n",
    "    fpth = os.path.abspath(os.path.join('..', '..'))\n",
    "    sys.path.append(fpth)\n",
    "    import flopy\n",
    "    \n",
    "from flopy.utils import OptionBlock\n",
    "    \n",
    "print(sys.version)\n",
    "print('flopy version: {}'.format(flopy.__version__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_ws = os.path.join(\"..\", \"data\", \"options\", \"sagehen\")\n",
    "model_ws = os.path.join(\"temp\", \"nwt_options\", \"output\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading a MODFLOW-NWT model that has option block options\n",
    "\n",
    "It is critical to set the `version` flag in `flopy.modflow.Modflow.load()` to `version='mfnwt'` \n",
    "\n",
    "We are going to load a modified version of the Sagehen test problem from GSFLOW to illustrate compatibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   loading iuzfbnd array...\n",
      "   loading vks array...\n",
      "   loading eps array...\n",
      "   loading thts array...\n",
      "stress period 1:\n",
      "   loading finf array...\n",
      "stress period 2:\n",
      "\n",
      "creating model workspace...\n",
      "   temp/nwt_options/output\n",
      "\n",
      "changing model workspace...\n",
      "   temp/nwt_options/output\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jdhughes/Documents/Development/flopy_git/flopy_fork/flopy/mbase.py:354: DeprecationWarning: xul/yul have been deprecated. Use xll/yll instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something bad happened.\n"
     ]
    }
   ],
   "source": [
    "mfexe = \"mfnwt\"\n",
    "\n",
    "if platform.system() == 'Windows':\n",
    "    mfexe += '.exe'\n",
    "\n",
    "ml = flopy.modflow.Modflow.load('sagehen.nam', model_ws=load_ws,\n",
    "                                exe_name=mfexe, version='mfnwt')\n",
    "ml.change_model_ws(new_pth=model_ws)\n",
    "ml.write_input()\n",
    "\n",
    "success, buff = ml.run_model(silent=True)\n",
    "if not success:\n",
    "    print ('Something bad happened.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's look at the options attribute of the UZF object\n",
    "\n",
    "The `uzf.options` attribute is an `OptionBlock` object. The representation of this object is the option block that will be written to output, which allows the user to easily check to make sure the block has the options they want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OPTIONS\n",
       "NOSURFLEAK\n",
       "ETSQUARE 0.2\n",
       "SAVEFINF\n",
       "END"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uzf = ml.get_package(\"UZF\")\n",
    "uzf.options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `OptionBlock` object also has attributes which correspond to the option names listed in the online guide to modflow\n",
    "\n",
    "The user can call and edit the options within the option block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(uzf.options.nosurfleak)\n",
    "print(uzf.options.savefinf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OPTIONS\n",
       "NOSURFLEAK\n",
       "SAVEFINF\n",
       "END"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uzf.options.etsquare = False\n",
    "uzf.options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OPTIONS\n",
       "NOSURFLEAK\n",
       "ETSQUARE 0.2\n",
       "SAVEFINF\n",
       "END"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uzf.options.etsquare = True\n",
    "uzf.options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The user can also see the single line representation of the options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NOSURFLEAK ETSQUARE 0.2 SAVEFINF'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uzf.options.single_line_options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### And the user can easily change to single line options writing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "uzf.options.block = False\n",
    "\n",
    "# write out only the uzf file\n",
    "uzf_name = \"uzf_opt.uzf\"\n",
    "uzf.write_file(os.path.join(model_ws, uzf_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's examine the first few lines of the new UZF file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# UZF package for  MODFLOW-NWT, generated by Flopy.\n",
      "\n",
      "NOSURFLEAK ETSQUARE 0.2 SAVEFINF\n",
      "\n",
      "         3         1         0         0         0         0        15       100         4   1.000000E+00 #NUZTOP IUZFOPT IRUNFLG IETFLG ipakcb IUZFCB2 NTRAIL NSETS NUZGAGES                                \n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(os.path.join(model_ws, uzf_name))\n",
    "for ix, line in enumerate(f):\n",
    "    if ix == 3:\n",
    "        break\n",
    "    else:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let's load the new UZF file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   loading iuzfbnd array...\n",
      "   loading vks array...\n",
      "   loading eps array...\n",
      "   loading thts array...\n",
      "stress period 1:\n",
      "   loading finf array...\n",
      "stress period 2:\n"
     ]
    }
   ],
   "source": [
    "uzf2 = flopy.modflow.ModflowUzf1.load(os.path.join(model_ws, uzf_name),\n",
    "                                      ml, check=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we can look at the options object, and check if it's block or line format\n",
    "\n",
    "`block=False` indicates that options will be written as line format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OPTIONS\n",
      "NOSURFLEAK\n",
      "ETSQUARE 0.2\n",
      "SAVEFINF\n",
      "END\n",
      "\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(uzf2.options)\n",
    "print(uzf2.options.block)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finally we can convert back to block format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   loading iuzfbnd array...\n",
      "   loading vks array...\n",
      "   loading eps array...\n",
      "   loading thts array...\n",
      "stress period 1:\n",
      "   loading finf array...\n",
      "stress period 2:\n",
      "\n",
      "\n",
      "OPTIONS\n",
      "NOSURFLEAK\n",
      "ETSQUARE 0.2\n",
      "SAVEFINF\n",
      "END\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "uzf2.options.block = True\n",
    "uzf2.write_file(os.path.join(model_ws, uzf_name))\n",
    "ml.remove_package(\"UZF\")\n",
    "\n",
    "uzf3 = flopy.modflow.ModflowUzf1.load(os.path.join(model_ws, uzf_name),\n",
    "                                      ml, check=False)\n",
    "print(\"\\n\")\n",
    "print(uzf3.options)\n",
    "print(uzf3.options.block)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We can also look at the WEL object "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OPTIONS\n",
       "SPECIFY 0.1 90\n",
       "END"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wel = ml.get_package(\"WEL\")\n",
    "wel.options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write this out as a single line option block and examine the first few lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# WEL package for  MODFLOW-NWT, generated by Flopy.\n",
      "\n",
      "         5         0 NOPRINT \n",
      "\n",
      "SPECIFY 0.1 90\n",
      "\n",
      "         5         0 # stress period 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "wel_name = \"wel_opt.wel\"\n",
    "wel.options.block = False\n",
    "\n",
    "wel.write_file(os.path.join(model_ws, wel_name))\n",
    "\n",
    "\n",
    "f = open(os.path.join(model_ws,wel_name))\n",
    "for ix, line in enumerate(f):\n",
    "    if ix == 4:\n",
    "        break\n",
    "    else:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can load the new single line options WEL file and confirm that it is being read as an option line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ml.remove_package(\"WEL\")\n",
    "wel2 = flopy.modflow.ModflowWel.load(os.path.join(model_ws, wel_name),\n",
    "                                     ml, nper=ml.nper, check=False)\n",
    "\n",
    "wel2.options\n",
    "wel2.options.block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building an OptionBlock from scratch\n",
    "\n",
    "The user can also build an `OptionBlock` object from scratch to add to a `ModflowSfr2`, `ModflowUzf1`, or `ModflowWel` file.\n",
    "\n",
    "The `OptionBlock` class has two required parameters and one optional parameter\n",
    "\n",
    "`option_line`: a one line, string based representation of the options\n",
    "\n",
    "`package`: a modflow package object\n",
    "\n",
    "`block`: boolean flag for line based or block based options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OPTIONS\n",
       "SPECIFY 0.1 20\n",
       "END"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opt_line = \"specify 0.1 20\"\n",
    "options = OptionBlock(opt_line, flopy.modflow.ModflowWel, block=True)\n",
    "options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from here we can set the noprint flag by using `options.noprint`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "options.noprint = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the user can also add auxillary variables by using `options.auxillary`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "options.auxillary = [\"aux\", \"iface\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we can create a new wel file using this `OptionBlock`\n",
    "\n",
    "and write it to output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "wel3 = flopy.modflow.ModflowWel(ml, stress_period_data=wel.stress_period_data,\n",
    "                                options=options, unitnumber=99)\n",
    "\n",
    "wel3.write_file(os.path.join(model_ws, wel_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now let's examine the first few lines of the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# WEL package for  MODFLOW-NWT, generated by Flopy.\n",
      "\n",
      "OPTIONS\n",
      "\n",
      "SPECIFY 0.1 20\n",
      "\n",
      "END\n",
      "\n",
      "         5         0 NOPRINT AUX IFACE\n",
      "\n",
      "         5         0 # stress period 1\n",
      "\n",
      "         1        35        12            20.0\n",
      "\n",
      "         1        36        13            21.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(os.path.join(model_ws, wel_name))\n",
    "for ix, line in enumerate(f):\n",
    "    if ix == 8:\n",
    "        break\n",
    "    else:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that everything that the OptionBlock class writes out options in the correct location."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The user can also switch the options over to option line style and write out the output too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# WEL package for  MODFLOW-NWT, generated by Flopy.\n",
      "\n",
      "         5         0 NOPRINT AUX IFACE\n",
      "\n",
      "SPECIFY 0.1 20\n",
      "\n",
      "         5         0 # stress period 1\n",
      "\n",
      "         1        35        12            20.0\n",
      "\n",
      "         1        36        13            21.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "wel3.options.block = False\n",
    "wel3.write_file(os.path.join(model_ws, wel_name))\n",
    "\n",
    "f = open(os.path.join(model_ws, wel_name))\n",
    "for ix, line in enumerate(f):\n",
    "    if ix == 6:\n",
    "        break\n",
    "    else:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}