examples/Notebooks/flopy3_vtk_export.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FloPy VTK Export Demo\n",
    " 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\n",
    "     . exporting heads and model output data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.6 | packaged by conda-forge | (default, Oct  7 2020, 18:42:56) \n",
      "[Clang 10.0.1 ]\n",
      "flopy version: 3.3.3\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.exists(workspace):\n",
    "    os.makedirs(workspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exporting to VTK\n",
    "\n",
    " for all export calls a folder is provided and the the fmt flag is set to 'vtk'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exporting FloPy arrays to .vtu files\n",
    "\n",
    "    All array exports have the following kwargs:\n",
    "    \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",
    "                   Outputing point scalars will set smooth to True\n",
    "        . name: A name can be specified to use for the output filename and array scalar name,\n",
    "            by default the FloPy array name is used\n",
    "        . binary: True turns on binary vtk export, deault is False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Export model top"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create output folder\n",
    "ot_arrays_folder = os.path.join(workspace, 'arrays_test')\n",
    "if not os.path.exists(ot_arrays_folder):\n",
    "    os.mkdir(ot_arrays_folder)\n",
    "# export model top\n",
    "model_top_output = os.path.join(ot_arrays_folder, 'TOP')\n",
    "ml.dis.top.export(model_top_output, 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_output = os.path.join(ot_arrays_folder, 'BOTM')\n",
    "ml.dis.botm.export(model_bottom_output, fmt='vtk')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Export transient array recharge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transient 2d array\n",
    "# export recharge\n",
    "model_recharge_output = os.path.join(ot_arrays_folder, 'RECH')\n",
    "ml.rch.rech.export(model_recharge_output, fmt='vtk')"
   ]
  },
  {
   "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_export = os.path.join(ot_arrays_folder, 'HK')\n",
    "ml.upw.hk.export(model_hk_export, smooth=True, fmt='vtk', name='HK', point_scalars=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Package export to .vtu files\n",
    "\n",
    "    Package export has the following kwargs:\n",
    "    \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",
    "                   Outputing point scalars will set smooth to True\n",
    "        . binary: True turns on binary vtk export, default is False"
   ]
  },
  {
   "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",
    "package_output = os.path.join(workspace, 'package_output_test')\n",
    "if not os.path.exists(package_output):\n",
    "    os.mkdir(package_output)\n",
    "# export dis\n",
    "dis_output = os.path.join(package_output, 'DIS')\n",
    "ml.dis.export(dis_output,  fmt='vtk')\n",
    "#export upw with point scalars\n",
    "upw_output = os.path.join(package_output, 'UPW')\n",
    "ml.upw.export(upw_output,  fmt='vtk', point_scalars=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model export to .vtu files\n",
    "\n",
    "    Package export has the following kwargs:\n",
    "    \n",
    "    . package_names: list of package names to export\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",
    "               Outputing point scalars will set smooth to True\n",
    "    . binary: True turns on binary vtk export, default is False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Export model as binary .vtu files"
   ]
  },
  {
   "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": [
    "\n",
    "model_output = os.path.join(workspace, 'model_output_test')\n",
    "ml.export(model_output, fmt='vtk', binary=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export heads\n",
    "\n",
    "    vtk.export_heads(model, headsfile, output_folder)\n",
    "\n",
    "    Heads export has the following arguments:\n",
    "\n",
    "    . nanval: No data value default is -1e20\n",
    "    . kstpkper: A tuple containing the time step and stress period (kstp, kper) or\n",
    "        list of (kstp, kper) tuples. The kstp and kper values are zero based.\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",
    "               Outputing point scalars will set smooth to True\n",
    "    . binary: True turns on binary vtk export, default is False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export heads to binary .vtu files\n",
    "\n",
    "#### Exports a .pvd file that can be loaded into Paraview to view heads as time series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export binary heads\n",
    "heads_file = os.path.join(model_ws, 'freyberg.hds')\n",
    "heads_output_folder = os.path.join(workspace, 'heads_output_test')\n",
    "vtk.export_heads(ml, heads_file, heads_output_folder, binary=True, nanval=-999.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export heads to binary .vtu files with point head scalars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export heads with parameters\n",
    "heads_file = os.path.join(model_ws, 'freyberg.hds')\n",
    "heads_output_folder = os.path.join(workspace, 'heads_output_test_parameters')\n",
    "# export heads for time step 1, stress periods 1, 50, 100, 1000\n",
    "vtk.export_heads(ml, heads_file, heads_output_folder, kstpkper=[(0,0), (0, 49), (0, 99), (0, 999)],\n",
    "                 point_scalars=True, nanval=-999.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export output cell by cell file to .vtu\n",
    "\n",
    "    vtk.export_heads(model, cellbycellfile, outputfolder)\n",
    "\n",
    "        Heads export has the following arguments:\n",
    "\n",
    "        . precision: Default is single\n",
    "        . nanval: No data value default is -1e20\n",
    "        . kstpkper: A tuple containing the time step and stress period (kstp, kper) or\n",
    "            list of (kstp, kper) tuples. The kstp and kper values are zero based.\n",
    "        . text: The text identifier for the record. Can be a str or list of strings.\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",
    "                   Outputing point scalars will set smooth to True\n",
    "        . binary: True turns on binary vtk export, default is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbc_file = os.path.join(model_ws, 'freyberg.cbc')\n",
    "cbc_output_folder = os.path.join(workspace, 'cbc_output_test_parameters')\n",
    "vtk.export_cbc(ml, cbc_file, cbc_output_folder, kstpkper=[(0, 0), (0, 9), (0, 10), (0, 11)],\n",
    "               text=['CONSTANT HEAD', 'STORAGE'], point_scalars=True, binary=True)"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}