examples/Notebooks/flopy3_vtk_export.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FloPy VTK Export Demo\n",
    "\n",
    "The `Vtk()` class in FloPy allows users to export Structured, Vertex, and Unstructured Grid based models to Visualization ToolKit files for display. This notebook demonstrates how to use FloPy to export to vtk (.vtu) files. This example will cover:\n",
    "\n",
    "   - basic exporting of information for a model, individual package, or array to `Vtk()`\n",
    "   - example usage of the `Vtk()` class object to output data \n",
    "   - exporting heads and model output data\n",
    "   - exporting modpath pathlines to `Vtk()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.11 (default, Aug  6 2021, 08:56:27) \n",
      "[Clang 10.0.0 ]\n",
      "flopy version: 3.3.5\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\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.export import vtk\n",
    "\n",
    "print(sys.version)\n",
    "print(\"flopy version: {}\".format(flopy.__version__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load model for examples\n",
    "nam_file = \"freyberg.nam\"\n",
    "model_ws = os.path.join(\"..\", \"data\", \"freyberg_multilayer_transient\")\n",
    "ml = flopy.modflow.Modflow.load(nam_file, model_ws=model_ws, check=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output folder to store the outputs from the notebook\n",
    "workspace = os.path.join(\".\", \"temp\", \"VTK_EXAMPLE_OUTPUTS\")\n",
    "if not os.path.isdir(workspace):\n",
    "    os.makedirs(workspace, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic exporting to VTK using the `.export()` method\n",
    "\n",
    "For all export calls **a folder path must be provided** provided and the the `fmt` flag should be set to 'vtk'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exporting FloPy arrays to .vtu files\n",
    "\n",
    "All array exports have the following optional keyword arguments:\n",
    "   - `smooth`: True creates a smooth surface, default is False\n",
    "   - `point_scalars`: True outputs point scalar values as well as cell values, default is False.\n",
    "   - `name`: A name can be specified to use for the output filename and array scalar name, by default the FloPy array name is used\n",
    "   - `binary`: argument that can be specified to switch between binary and ASCII, default is True\n",
    "   - `xml`: True will write an xml base vtk file, default is False\n",
    "   - `masked_values`: list or tuple of values to mask (set to nan) when writing a array\n",
    "   - `vertical_exageration`: floating point value that can be used to scale the vertical exageration of the vtk points. Default is 1.\n",
    "   \n",
    "Tranient type array exports (\"stress_period_data\"; ex. recharge data, well flux, etc ...) have additional optional keyword arguments:\n",
    "   - `pvd`: True will write a paraview data file with simulation time for animations. Default is False\n",
    "   - `kper`: a list, tuple, or integer value of specific stess periods to output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export model top"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create output folder\n",
    "output_dir = os.path.join(workspace, \"arrays_test\")\n",
    "if not os.path.isdir(output_dir):\n",
    "    os.makedirs(output_dir, exist_ok=True)\n",
    "\n",
    "# export model top\n",
    "model_top_dir = os.path.join(output_dir, \"TOP\")\n",
    "ml.dis.top.export(model_top_dir, fmt=\"vtk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export model bottoms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3D Array export\n",
    "# export model bottoms\n",
    "model_bottom_dir = os.path.join(output_dir, \"BOTM\")\n",
    "ml.dis.botm.export(model_bottom_dir, fmt=\"vtk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export transient array recharge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Switching to xml, ASCII and standard binary are not supported by Paraview's PVD reader\n"
     ]
    }
   ],
   "source": [
    "# transient 2d array\n",
    "# export recharge\n",
    "model_recharge_dir = os.path.join(output_dir, \"RECH\")\n",
    "ml.rch.rech.export(model_recharge_dir, fmt=\"vtk\", pvd=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export HK with point scalars\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3D Array export\n",
    "# hk export, with points\n",
    "model_hk_dir = os.path.join(output_dir, \"HK\")\n",
    "ml.upw.hk.export(\n",
    "    model_hk_dir, smooth=True, fmt=\"vtk\", name=\"HK\", point_scalars=True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Package export to .vtu files\n",
    "\n",
    "Package export has the following keyword arguments:\n",
    "   - `smooth`: True creates a smooth surface, default is False\n",
    "   - `point_scalars`: True outputs point scalar values as well as cell values, default is False.\n",
    "   - `name`: A name can be specified to use for the output filename and array scalar name, by default the FloPy array name is used\n",
    "   - `binary`: argument that can be specified to switch between binary and ASCII, default is True\n",
    "   - `xml`: True will write an xml base vtk file, default is False\n",
    "   - `masked_values`: list or tuple of values to mask (set to nan) when writing a array\n",
    "   - `vertical_exageration`: floating point value that can be used to scale the vertical exageration of the vtk points. Default is 1.\n",
    "   - `pvd`: True will write a paraview data file with simulation time for animations. Default is False\n",
    "   - `kper`: a list, tuple, or integer value of specific stess periods to output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export dis and upw package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# package export\n",
    "# set up package export folder\n",
    "output_dir = os.path.join(workspace, \"package_output_test\")\n",
    "if not os.path.isdir(output_dir):\n",
    "    os.makedirs(output_dir, exist_ok=True)\n",
    "\n",
    "# export dis\n",
    "dis_output_dir = os.path.join(output_dir, \"DIS\")\n",
    "ml.dis.export(dis_output_dir, fmt=\"vtk\")\n",
    "\n",
    "# export upw with point scalars as a binary xml based vtk file\n",
    "upw_output_dir = os.path.join(output_dir, \"UPW\")\n",
    "ml.upw.export(upw_output_dir, fmt=\"vtk\", point_scalars=True, xml=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model export to .vtu files\n",
    "\n",
    "Model export has the following optional keyword arguments:\n",
    "   \n",
    "   - `package_names`: a list of package names to export, default is None and will export all packages in the model.\n",
    "   - `smooth`: True creates a smooth surface, default is False\n",
    "   - `point_scalars`: True outputs point scalar values as well as cell values, default is False.\n",
    "   - `name`: A name can be specified to use for the output filename and array scalar name, by default the FloPy array name is used\n",
    "   - `binary`: argument that can be specified to switch between binary and ASCII, default is True\n",
    "   - `xml`: True will write an xml base vtk file, default is False\n",
    "   - `masked_values`: list or tuple of values to mask (set to nan) when writing a array\n",
    "   - `vertical_exageration`: floating point value that can be used to scale the vertical exageration of the vtk points. Default is 1.\n",
    "   - `pvd`: True will write a paraview data file with simulation time for animations. Default is False\n",
    "   - `kper`: a list, tuple, or integer value of specific stess periods to output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export model as a binary unstructured vtk file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./temp/VTK_EXAMPLE_OUTPUTS/model_output_test'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_output_dir = os.path.join(workspace, \"model_output_test\")\n",
    "ml.export(model_output_dir, fmt=\"vtk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exporting using the `Vtk()` class object \n",
    "\n",
    "To export custom arrays, or choose a custom combination of model inputs to view, the user first needs to instantiate a new `Vtk()` object. The `Vtk()` object has a single required parameter and a number of optional parameters that the user can take advantage of. These parameters are as follows:\n",
    "\n",
    "   - `model`: any flopy model object can be supplied to create the vtk geometry. Either the model (recommended!) or modelgrid parameter must be supplied to the Vtk() object.\n",
    "   - `modelgrid`: any flopy modelgrid object (StructuredGrid, VertexGrid, UnstructuredGrid) can be supplied, in leiu of a model object, to create the vtk geometery. \n",
    "   - `vertical_exageration`: floating point value that can be used to scale the vertical exageration of the vtk points. Default is 1.\n",
    "   - `binary`: boolean flag to switch between binary and ASCII vtk files. Default is True.\n",
    "   - `xml`: boolean flag to write xml based vtk files. Default is False\n",
    "   - `pvd`: boolean flag to write a paraview data file for transient series of vtu files. This file relates model time to vtu file for animations. Default is False. If set to True Vtk() will automatically write xml based vtu files. \n",
    "   - `shared_points`: boolean flag to write shared vertices within the vtk file. Default is False.\n",
    "   - `smooth`: boolean flag to interpolate vertex elevations using IDW based on shared cell elevations. Default is False.\n",
    "   - `point_scalars`: boolean flag to write interpolated data at each point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<flopy.export.vtk.Vtk at 0x1265760a0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a binary XML VTK object and enable PVD file writing\n",
    "vtkobj = vtk.Vtk(ml, xml=True, pvd=True, vertical_exageration=10)\n",
    "vtkobj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding array data to the `Vtk()` object\n",
    "\n",
    "The `Vtk()` object has an `add_array()` method that lets the user add array data to the Field data section of the VTK file.\n",
    "\n",
    "`add_array()` has a few parameters for the user:\n",
    "   - `array` : numpy array that has a size equal to the number of cells in the model (modelgrid.nnodes).\n",
    "   - `name` : array name (string)\n",
    "   - `masked_values` : list of array values to mask/set to NaN "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a vtk object\n",
    "vtkobj = vtk.Vtk(ml, vertical_exageration=10)\n",
    "\n",
    "## create some random array data\n",
    "r_array = np.random.random(ml.modelgrid.nnodes) * 100\n",
    "\n",
    "## add random data to the VTK object\n",
    "vtkobj.add_array(r_array, \"random_data\")\n",
    "\n",
    "## add the model botom data to the VTK object\n",
    "vtkobj.add_array(ml.dis.botm.array, \"botm\")\n",
    "\n",
    "## write the vtk object to file\n",
    "vtkobj.write(os.path.join(output_dir, \"Array_example\", \"model.vtu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding transient array data to the `Vtk()` object\n",
    "\n",
    "The `Vtk()` class has an `add_transient_array()` method that allows the user to create a series of time varying `Vtk()` files that can be used for animation in VTK viewers.\n",
    "\n",
    "The `add_transient_array()` method accepts a dictionary of array2d, array3d, or numpy array objects. Parameters include:\n",
    "   - `d`: dictionary of array2d, array3d, or numpy array objects\n",
    "   - `name`: parameter name, required when user provides a dictionary of numpy arrays\n",
    "   - `masked_values`: optional list of values to set equal to NaN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a vtk object\n",
    "vtkobj = vtk.Vtk(ml, xml=True, pvd=True, vertical_exageration=10)\n",
    "\n",
    "## add recharge to the VTK object\n",
    "recharge = ml.rch.rech.transient_2ds\n",
    "vtkobj.add_transient_array(\n",
    "    recharge,\n",
    "    \"recharge\",\n",
    "    masked_values=[\n",
    "        0,\n",
    "    ],\n",
    ")\n",
    "\n",
    "## write vtk files\n",
    "vtkobj.write(os.path.join(output_dir, \"tr_array_example\", \"recharge.vtu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding transient list data to the `Vtk()` object\n",
    "\n",
    "The `Vtk()` class has an `add_transient_list()` method that allows the user to create a series of time varying `Vtk()` files that can be used for animation in VTK viewers.\n",
    "\n",
    "The `add_transient_list()` method accepts a FloPy mflist (transient list) type object. Parameters include:\n",
    "   - `mflist`: flopy transient list object\n",
    "   - `masked_values`: list of values to set equal to NaN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the vtk object\n",
    "vtkobj = vtk.Vtk(ml, xml=True, pvd=True, vertical_exageration=10)\n",
    "\n",
    "## add well fluxes to the VTK object\n",
    "spd = ml.wel.stress_period_data\n",
    "vtkobj.add_transient_list(\n",
    "    spd,\n",
    "    masked_values=[\n",
    "        0,\n",
    "    ],\n",
    ")\n",
    "\n",
    "## write vtk files\n",
    "vtkobj.write(os.path.join(output_dir, \"tr_list_example\", \"wel_flux.vtu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding packages to the `Vtk` object\n",
    "\n",
    "The `Vtk()` class has a method for adding package data to a VTK file as Field Data. The `add_package()` method allows the user to add packages for subsequent export. `add_package()` takes the following parameters:\n",
    "\n",
    "   - `pkg`: flopy package object\n",
    "   - `masked_values`: optional list of values to set to NaN.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, a HFB package is added to the existing freyberg model and then exported with the WEL package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a HFB package for the example\n",
    "hfb_data = []\n",
    "for k in range(3):\n",
    "    for i in range(20):\n",
    "        rec = [k, i, 6, i, 7, 1e-06]\n",
    "        hfb_data.append(rec)\n",
    "\n",
    "hfb = flopy.modflow.ModflowHfb(ml, hfb_data=hfb_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export HFB and WEL packages using Vtk()\n",
    "vtkobj = vtk.Vtk(ml, vertical_exageration=10)\n",
    "\n",
    "vtkobj.add_package(hfb)\n",
    "vtkobj.add_package(ml.wel)\n",
    "\n",
    "vtkobj.write(os.path.join(output_dir, \"package_example\", \"package_export.vtu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export heads to binary .vtu files\n",
    "\n",
    "Once a `Vtk()` object is instantiated (see above), the `Vtk()` class has an `add_heads()` method. This method has a few parameters:\n",
    "  - `hds`: a flopy FormattedHeadFile or HeadFile object. This method also accepts DrawdownFile, and ConcentrationFile objects.\n",
    "  - `kstpkper`: optional list of zero based (timestep, stress period) tuples to output. Default is None and will output all data to a series of vtu files\n",
    "  - `masked_values`: optional list of values to set to NaN, default is None.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the HeadFile reader and read in the head file\n",
    "from flopy.utils import HeadFile\n",
    "\n",
    "head_file = os.path.join(model_ws, \"freyberg.hds\")\n",
    "hds = HeadFile(head_file)\n",
    "\n",
    "\n",
    "# create the vtk object and export heads\n",
    "vtkobj = vtk.Vtk(ml, xml=True, pvd=True, vertical_exageration=10)\n",
    "vtkobj.add_heads(hds)\n",
    "vtkobj.write(os.path.join(workspace, \"heads_output_test\", \"freyberg_head.vtu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export heads as point scalar arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export heads as point scalars\n",
    "vtkobj = vtk.Vtk(\n",
    "    ml, xml=True, pvd=True, point_scalars=True, vertical_exageration=10\n",
    ")\n",
    "\n",
    "# export heads for time step 1, stress periods 1, 50, 100, 1000\n",
    "vtkobj.add_heads(hds, kstpkper=[(0, 0), (0, 49), (0, 99), (0, 999)])\n",
    "vtkobj.write(\n",
    "    os.path.join(\n",
    "        workspace, \"heads_output_test_parameters\", \"freyberg_head.vtu\"\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export cell budget information\n",
    "\n",
    "Once a `Vtk()` object is instantiated (see above), the `Vtk()` class has an `add_cell_budget()` method. This method has a few parameters:\n",
    "   - `cbc`: flopy CellBudgetFile object\n",
    "   - `text`: Optional text identifier for a record type. Examples include 'RIVER LEAKAGE', 'STORAGE', etc... Default is None and will export all cell budget information to vtk files\n",
    "   - `kstpkper`: optional list of zero based (timestep, stress period) tuples to output. Default is None and will output all data to a series of vtu files\n",
    "   - `masked_values`: optional list of values to set to NaN, default is None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the CellBudgetFile reader and read the CBC file\n",
    "from flopy.utils import CellBudgetFile\n",
    "\n",
    "cbc_file = os.path.join(model_ws, \"freyberg.cbc\")\n",
    "cbc = CellBudgetFile(cbc_file)\n",
    "\n",
    "# export the cbc file to a series of Vtu files with a PVD file for animation\n",
    "vtkobj = vtk.Vtk(ml, xml=True, pvd=True, vertical_exageration=10)\n",
    "vtkobj.add_cell_budget(cbc, kstpkper=[(0, 0), (0, 9), (0, 10), (0, 11)])\n",
    "vtkobj.write(\n",
    "    os.path.join(workspace, \"cbc_output_test_parameters\", \"freyberg_cbc.vtu\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exporting vectors from the Cell Budget File with the `Vtk()` class\n",
    "\n",
    "The `Vtk()` class has an `add_vector()` method that allows the user to write vector information to VTK files. This method can be used to export information such as cell centered specific discharge.\n",
    "\n",
    "The `add_vector()` method accepts a numpy array of vector data. The array size must be 3 * the number of model cells (3 * modelgrid.nnodes). Parameters include:\n",
    "   - `vector`: numpy array of size 3 * nnodes\n",
    "   - `name`: name of the vector \n",
    "   - `masked_values`: list of values to set equal to NaN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get frf, fff, flf from the Cell Budget file (or SPDIS when using MF6)\n",
    "from flopy.utils import postprocessing\n",
    "\n",
    "frf = cbc.get_data(text=\"FLOW RIGHT FACE\", kstpkper=(0, 9), full3D=True)[0]\n",
    "fff = cbc.get_data(text=\"FLOW FRONT FACE\", kstpkper=(0, 9), full3D=True)[0]\n",
    "flf = cbc.get_data(text=\"FLOW LOWER FACE\", kstpkper=(0, 9), full3D=True)[0]\n",
    "\n",
    "spdis = postprocessing.get_specific_discharge((frf, fff, flf), ml)\n",
    "\n",
    "# create the Vtk() object\n",
    "vtkobj = vtk.Vtk(ml, vertical_exageration=10)\n",
    "\n",
    "# add the vector\n",
    "vtkobj.add_vector(spdis, name=\"spdis\")\n",
    "\n",
    "# write to file\n",
    "vtkobj.write(os.path.join(output_dir, \"vector_example\", \"spdis_vector.vtu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adding Modpath timeseries or pathline data to `Vtk()`\n",
    "\n",
    "The `Vtk()` class support writing MODPATH pathline/timeseries data to a Vtk file. To start the example, let's first load and run a MODPATH simulation (see flopy3_modpath7_unstructured_example for details) and then add the output to a `Vtk()` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: Unable to resolve dimension of ('gwf6', 'disv', 'cell2d', 'cell2d', 'icvert') based on shape \"ncvert\".\n",
      "writing simulation...\n",
      "  writing simulation name file...\n",
      "  writing simulation tdis package...\n",
      "  writing ims package ims...\n",
      "  writing model mp7p2...\n",
      "    writing model name file...\n",
      "    writing package disv...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    writing package ic...\n",
      "    writing package npf...\n",
      "    writing package wel_0...\n",
      "INFORMATION: maxbound in ('gwf6', 'wel', 'dimensions') changed to 1 based on size of stress_period_data\n",
      "    writing package rcha_0...\n",
      "    writing package riv_0...\n",
      "INFORMATION: maxbound in ('gwf6', 'riv', 'dimensions') changed to 21 based on size of stress_period_data\n",
      "    writing package oc...\n",
      "FloPy is using the following executable to run the model: /Users/jdhughes/.local/bin/mf6\n",
      "                                   MODFLOW 6\n",
      "                U.S. GEOLOGICAL SURVEY MODULAR HYDROLOGIC MODEL\n",
      "                            VERSION 6.2.2 07/30/2021\n",
      "                               ***DEVELOP MODE***\n",
      "\n",
      "  MODFLOW 6 compiled Aug 31 2021 16:00:07 with GFORTRAN compiler (ver. 10.3.0)\n",
      "\n",
      "This software has been approved for release by the U.S. Geological \n",
      "Survey (USGS). Although the software has been subjected to rigorous \n",
      "review, the USGS reserves the right to update the software as needed \n",
      "pursuant to further analysis and review. No warranty, expressed or \n",
      "implied, is made by the USGS or the U.S. Government as to the \n",
      "functionality of the software and related material nor shall the \n",
      "fact of release constitute any such warranty. Furthermore, the \n",
      "software is released on condition that neither the USGS nor the U.S. \n",
      "Government shall be held liable for any damages resulting from its \n",
      "authorized or unauthorized use. Also refer to the USGS Water \n",
      "Resources Software User Rights Notice for complete use, copyright, \n",
      "and distribution information.\n",
      "\n",
      "\n",
      " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/10/25 16:46:10\n",
      "\n",
      " Writing simulation list file: mfsim.lst\n",
      " Using Simulation name file: mfsim.nam\n",
      "\n",
      "    Solving:  Stress period:     1    Time step:     1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/10/25 16:46:10\n",
      " Elapsed run time:  0.276 Seconds\n",
      "\n",
      "\n",
      "WARNING REPORT:\n",
      "\n",
      "  1. NONLINEAR BLOCK VARIABLE 'OUTER_HCLOSE' IN FILE 'mp7p2.ims' WAS\n",
      "     DEPRECATED IN VERSION 6.1.1. SETTING OUTER_DVCLOSE TO OUTER_HCLOSE VALUE.\n",
      "  2. LINEAR BLOCK VARIABLE 'INNER_HCLOSE' IN FILE 'mp7p2.ims' WAS DEPRECATED\n",
      "     IN VERSION 6.1.1. SETTING INNER_DVCLOSE TO INNER_HCLOSE VALUE.\n",
      " Normal termination of simulation.\n",
      "FloPy is using the following executable to run the model: /Users/jdhughes/.local/bin/mp7\n",
      "\n",
      "MODPATH Version 7.2.001   \n",
      "Program compiled Aug 01 2021 12:57:00 with IFORT compiler (ver. 19.10.3)        \n",
      " \n",
      " \n",
      "Run particle tracking simulation ...\n",
      "Processing Time Step     1 Period     1.  Time =  1.00000E+03  Steady-state flow                                                    \n",
      "\n",
      "Particle Summary:\n",
      "         0 particles are pending release.\n",
      "         0 particles remain active.\n",
      "        16 particles terminated at boundary faces.\n",
      "         0 particles terminated at weak sink cells.\n",
      "         0 particles terminated at weak source cells.\n",
      "         0 particles terminated at strong source/sink cells.\n",
      "         0 particles terminated in cells with a specified zone number.\n",
      "         0 particles were stranded in inactive or dry cells.\n",
      "         0 particles were unreleased.\n",
      "         0 particles have an unknown status.\n",
      " \n",
      "Normal termination.                                                        \n",
      "FloPy is using the following executable to run the model: /Users/jdhughes/.local/bin/mp7\n",
      "\n",
      "MODPATH Version 7.2.001   \n",
      "Program compiled Aug 01 2021 12:57:00 with IFORT compiler (ver. 19.10.3)        \n",
      " \n",
      " \n",
      "Run particle tracking simulation ...\n",
      "Processing Time Step     1 Period     1.  Time =  1.00000E+03  Steady-state flow                                                    \n",
      "\n",
      "Particle Summary:\n",
      "         0 particles are pending release.\n",
      "         0 particles remain active.\n",
      "       416 particles terminated at boundary faces.\n",
      "         0 particles terminated at weak sink cells.\n",
      "         0 particles terminated at weak source cells.\n",
      "         0 particles terminated at strong source/sink cells.\n",
      "         0 particles terminated in cells with a specified zone number.\n",
      "         0 particles were stranded in inactive or dry cells.\n",
      "         0 particles were unreleased.\n",
      "         0 particles have an unknown status.\n",
      " \n",
      "Normal termination.                                                        \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output file located: mp7p2.hds\n",
      "Output file located: mp7p2.cbb\n"
     ]
    }
   ],
   "source": [
    "# load and run the vertex grid model and modpath7\n",
    "sys.path.append(os.path.join(\"..\", \"common\"))\n",
    "import setup_pmv_demo\n",
    "\n",
    "setup_pmv_demo.run()\n",
    "\n",
    "# check if model ran properly\n",
    "modelpth = os.path.join(\"data\", \"mp7_ex2\", \"mf6\")\n",
    "files = [\"mp7p2.hds\", \"mp7p2.cbb\"]\n",
    "for f in files:\n",
    "    if os.path.isfile(os.path.join(modelpth, f)):\n",
    "        msg = \"Output file located: {}\".format(f)\n",
    "        print(msg)\n",
    "    else:\n",
    "        errmsg = \"Error. Output file cannot be found: {}\".format(f)\n",
    "        print(errmsg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading simulation...\n",
      "  loading simulation name file...\n",
      "  loading tdis package...\n",
      "  loading model gwf6...\n",
      "    loading package disv...\n",
      "WARNING: Unable to resolve dimension of ('gwf6', 'disv', 'cell2d', 'cell2d', 'icvert') based on shape \"ncvert\".\n",
      "    loading package ic...\n",
      "    loading package npf...\n",
      "    loading package wel...\n",
      "    loading package rch...\n",
      "    loading package riv...\n",
      "    loading package oc...\n",
      "  loading ims package mp7p2...\n"
     ]
    }
   ],
   "source": [
    "# load the simulation and get the model\n",
    "vertex_sim_name = \"mfsim.nam\"\n",
    "vertex_sim = flopy.mf6.MFSimulation.load(\n",
    "    sim_name=vertex_sim_name, exe_name=\"mf6\", sim_ws=modelpth\n",
    ")\n",
    "vertex_ml6 = vertex_sim.get_model(\"mp7p2\")\n",
    "\n",
    "# load the MODPATH-7 results\n",
    "mp_namea = \"mp7p2a_mp\"\n",
    "fpth = os.path.join(modelpth, mp_namea + \".mppth\")\n",
    "p = flopy.utils.PathlineFile(fpth)\n",
    "p0 = p.get_alldata()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the `Vtk()` object and add all of the model data to it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "vtkobj = vtk.Vtk(vertex_ml6, xml=True, pvd=True, vertical_exageration=10)\n",
    "vtkobj.add_model(vertex_ml6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add modpath data to the `Vtk()` object.\n",
    "\n",
    "*Note: this will create a second vtk file that has the file signiture (myfilename)_pathline.vtu*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "vtkobj.add_pathline_points(p0, timeseries=False)\n",
    "vtkobj.write(os.path.join(output_dir, \"mp7_vertex_example\", \"vertex_ex.vtu\"))"
   ]
  },
  {
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}