diff --git a/autotest/t007_test.py b/autotest/t007_test.py index ca62ea6294..98327bfde0 100644 --- a/autotest/t007_test.py +++ b/autotest/t007_test.py @@ -78,7 +78,7 @@ def export_netcdf(m): fnc.write() except Exception as e: raise Exception( - 'ncdf export fail for namfile {0}:\n{1} '.format(namfile, str(e))) + 'ncdf export fail for namfile {0}:\n{1} '.format(m.name, str(e))) try: nc = netCDF4.Dataset(fnc_name, 'r') except Exception as e: @@ -118,6 +118,44 @@ def export_shapefile(namfile): fnc_name, s.numRecords) return + +def export_shapefile_modelgrid_override(namfile): + try: + import shapefile as shp + except: + return + + from flopy.discretization import StructuredGrid + + print(namfile) + m = flopy.modflow.Modflow.load(namfile, model_ws=pth, verbose=False) + mg0 = m.modelgrid + modelgrid = StructuredGrid(mg0.delc * 0.3048, mg0.delr * 0.3048, + mg0.top, mg0.botm, mg0.idomain, mg0.lenuni, + mg0.epsg, mg0.proj4, xoff=mg0.xoffset, + yoff=mg0.yoffset, angrot=mg0.angrot) + + assert m, 'Could not load namefile {}'.format(namfile) + assert isinstance(m, flopy.modflow.Modflow) + fnc_name = os.path.join(spth, m.name + '.shp') + + try: + fnc = m.export(fnc_name, modelgrid=modelgrid) + #fnc2 = m.export(fnc_name, package_names=None) + #fnc3 = m.export(fnc_name, package_names=['DIS']) + + + except Exception as e: + raise Exception( + 'shapefile export fail for namfile {0}:\n{1} '.format(namfile, + str(e))) + try: + s = shp.Reader(fnc_name) + except Exception as e: + raise Exception( + ' shapefile import fail for {0}:{1}'.format(fnc_name, str(e))) + + def test_freyberg_export(): from flopy.discretization import StructuredGrid namfile = 'freyberg.nam' @@ -1133,6 +1171,12 @@ def test_shapefile(): return +def test_shapefile_export_modelgrid_override(): + for namfile in namfiles[0:2]: + yield export_shapefile_modelgrid_override, namfile + return + + def test_netcdf(): for namfile in namfiles: yield export_mf2005_netcdf, namfile diff --git a/autotest/t064_test_performance.py b/autotest/t064_test_performance.py index b4309ca166..e77004a0c4 100644 --- a/autotest/t064_test_performance.py +++ b/autotest/t064_test_performance.py @@ -62,7 +62,7 @@ def test_init_time(self): """test model and package init time(s).""" mfp = TestModflowPerformance() target = 0.3 # seconds - assert mfp.init_time < target, "model init took {:.2fs}, should take {:.1f}s".format(mfp.init_time, target) + assert mfp.init_time < target, "model init took {:.2f}s, should take {:.1f}s".format(mfp.init_time, target) print('setting up model took {:.2f}s'.format(mfp.init_time)) def test_0_write_time(self): @@ -73,7 +73,7 @@ def test_0_write_time(self): t0 = time.time() mfp.m.write_input() t1 = time.time() - t0 - assert t1 < target, "model write took {:.2fs}, should take {:.1f}s".format(t1, target) + assert t1 < target, "model write took {:.2f}s, should take {:.1f}s".format(t1, target) print('writing input took {:.2f}s'.format(t1)) def test_9_load_time(self): @@ -85,7 +85,7 @@ def test_9_load_time(self): m = fm.Modflow.load('{}.nam'.format(mfp.modelname), model_ws=mfp.model_ws, check=False) t1 = time.time() - t0 - assert t1 < target, "model load took {:.2fs}, should take {:.1f}s".format(t1, target) + assert t1 < target, "model load took {:.2f}s, should take {:.1f}s".format(t1, target) print('loading the model took {:.2f}s'.format(t1)) @classmethod diff --git a/examples/Notebooks/flopy3_shapefile_export.ipynb b/examples/Notebooks/flopy3_shapefile_export.ipynb index f823ade294..118d9537fa 100644 --- a/examples/Notebooks/flopy3_shapefile_export.ipynb +++ b/examples/Notebooks/flopy3_shapefile_export.ipynb @@ -21,12 +21,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "flopy is installed in /Users/jdhughes/Documents/Development/flopy_git/flopy_us/flopy\n", - "3.7.3 (default, Mar 27 2019, 16:54:48) \n", - "[Clang 4.0.1 (tags/RELEASE_401/final)]\n", - "numpy version: 1.16.2\n", - "matplotlib version: 3.0.3\n", - "flopy version: 3.2.12\n" + "flopy is installed in c:\\users\\jlarsen\\desktop\\flopy-dev\\flopy\n", + "3.6.5 |Anaconda, Inc.| (default, Mar 29 2018, 13:32:41) [MSC v.1900 64 bit (AMD64)]\n", + "numpy version: 1.14.3\n", + "matplotlib version: 3.1.1\n", + "flopy version: 3.2.13\n" ] } ], @@ -172,14 +171,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -232,7 +229,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -269,14 +266,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -298,7 +293,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -405,12 +400,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/anaconda3/lib/python3.7/site-packages/pandas/core/frame.py:6692: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n", + "C:\\Users\\jlarsen\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\pandas\\core\\frame.py:6201: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n", "of pandas will change to not sort by default.\n", "\n", - "To accept the future behavior, pass 'sort=False'.\n", + "To accept the future behavior, pass 'sort=True'.\n", "\n", - "To retain the current behavior and silence the warning, pass 'sort=True'.\n", + "To retain the current behavior and silence the warning, pass sort=False\n", "\n", " sort=sort)\n" ] @@ -542,52 +537,52 @@ { "data": { "text/plain": [ - "[,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ]" + "[,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" ] }, "execution_count": 18, @@ -639,14 +634,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAL0AAAEICAYAAAAKp/VCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAYAElEQVR4nO2de5RV5XnGf4+AGDENF0eWUXE0aiJxKTFTYmqS1ks0MVklsSbFhKhUF01rrqs2UXvRmNhi2mpsc7UxiZcoWhKqaa1KiIlZKQFmdAwiEImgIlQgIHiJyODTP/Y3sDmcc+YMc5hh+N7fWrP23u/+9rvfvXnOx7u/c/b3yjZBkBP7DHQAQdDfhOiD7AjRB9kRog+yI0QfZEeIPsiOEP0ejqSfSrpoAM7bKsmShvb3uXc3IfpdQNIKSafvRv/7Slon6YDddY6cCdHvmbwL6LT9wkAHsjcSou8lkm4BxgE/kvSCpM+lNGCqpKclbZD0cUm/L+lXkp6T9NXS8RdI+oWkf5O0UdISSadVnOYs4J7S9hskzU/t75I0uuTvHZL+N53naUkXJPtZkh6T9LykZyRdUuN6Jkpql7RJ0rOSrq1o8lFJT6X/ef6mdNyVkmZKuiOd4yFJJ+zSTe1vbMdfL/+AFcDpab0VMPBNYD/gDOBl4D+Bg4BDgDXAH6b2FwBdwGeBYcCfAhuB0SX/S4A3pvWfAs8AxwEjgB8At6Z944DngXOTrzHAhLRvNfDOtD4KOLHGtcwFPpbWDwBOqriufwdeA5wAbAaOTfuvBLYA56RzXwIsB4YN9L9PT3/R0zePL9p+2fb9wIvA7bbX2H4G+DnwllLbNcBXbG+xfQewFHgfgKQjKYSztNT+FtuP2n4R+Dvgw5KGAB8Ffmz79uTrt7Y70zFbgPGSfs/2BtsP1Yh7C3CUpANtv2D7lxX7v2D7d7YfAR6hEH83HbZn2t4CXEvxoT+pF/dsQAjRN49nS+u/q7Jdfih9xqm7TDwJvD6tv48dUxuApyvaDgMOBA4DflMjnj+hSJOelPQzSW+v0e5C4BhgiaQFkt5fsf//SusvVVzHtrhsvwqsLF3HHkuIftfo609TD5Gk0vY4YFVaPwv474r2h1W03QKsoxDdG6oGaC+wPYkixfpP4M4a7R63fW5qdw0wU9KIBq9jW1yS9gEOLV3HHkuIftd4FjiyD8cfBHxK0jBJHwKOBe6R9BpgIkUeX2aKpPGS9geuAmba3gp8Hzhd0oclDZU0RtKENOT5UUmvS6nHJmBrtUAkTZHUknrq55K5atsqvFXS2Wks/zMUOX9lerTHEaLfNf4R+FtJz1E8yPWWecDRFL311cA5tn8LnAbMtf1yRftbgO9RpBr7AZ8CsP0Uxf8MfwWsBzrZnnN/DFghaRPwcWAKgKRxadRpXGr3HmCRpBeA64HJVc5fi7soHsQ3pPOdnT5kezTaMbUMdjdpSPEi2++osu/rwKO2v97vgfUSSVcCR9meMtCx9Ja97ivmQU4n8KOBDmJvJ0S/B2H7hoGOIQcivQmyIx5kg+zIJr058MAD3draOtBhDBo2P9lJMSq6I9IQhh8+oV9i6OjoWGe7pdl+sxF9a2sr7e3tAx3GoOHXFwyheiJgjvle/9xHSU/uDr+R3gTZEaIPsiNEH2RHiD7IjhB9kB0h+iA7QvRBdoTog+wI0QfZ0ZDo0+RGCyV1SmpPttGSZkt6PC1HJfsoSbPS9BfzJR1X8vNZSYskPSrpdkn7JfsRkuYlX3dI2jfZh6ftZWl/a8nXZcm+VNKZzbslwd5Ob3r6U2xPsN2Wti8F5tg+GpiTtgEup5io6HjgPIq3cZB0CMUbP222jwOGAJPTMdcA1yVfGyheViYtN9g+CrgutUPS+HTsmyne/Pl6mh0gCHqkL+nNJOCmtH4T8IG0Pp7iQ4DtJUCrpLFp31DgNemdyv2BVekF6VOBmVV8lc8xEzgttZ8EzLC92fZyYBnFu6VB0CONit7A/ZI6JE1LtrG2VwOk5UHJ/ghwNhSzZwGHA4em+V/+GXiKYiKijWmOmDHAc7a70vErKSZIIi2fTufoopgUaUzZXuWYIKhLo6I/2faJwHuBiyW9q07b6cAoSZ3AJ4GHga6U808CjqCYG2WEpCmAqvjofrOl1r56x2xD0rQ0ZV372rVr64Qc5ERDore9Ki3XALMoUolnJR0MkJZrUptNtqfankCR07dQTPd2OrDc9tr0xvwPgT+gmBFgpLZPCV2eO2UlaW6VtP91FG/9b7NXOaYc9w2222y3tbQ0/WfZwSClR9FLGiHptd3rFHM1PgrcDZyfmp1PMR0EkkZ2j74AFwEP2t5EkdacJGn/lJefBixOM309wPapNLb5qjjHOcBPUvu7gclpdOcIiuk05u/KDQjyo5GXSMYCs9KEXEOB22zfK2kBcKekCykE/aHU/ljgZklbgcdIIzG250maCTxEMYHpw0D3i9CfB2ZI+lKy35jsNwK3SFpG0cNPTr4WSboz+e8CLna113yCoArZvBje1tbmeHOqcYo3p6pzzPf6p3+R1FEaIm8a8Y1skB0h+iA7QvRBdoTog+wI0QfZEaIPsiNEH2RHiD7IjhB9kB0h+iA7QvRBdoTog+wI0QfZkc389EHvuGnkDLboNTvZh/l3XD0A8TST6OmDqlQTfD37YCJEH2RHiD7IjhB9kB0h+iA7QvRBdoTog+wI0QfZEaIPsiNEH2RH/Awh6BXGHPrdS3ewjRg2nKVTvjBAEfWe6OmDXqEqE0a/uGXzAESy64Tog+wI0QfZEaIPsiNEH/QK71zwhRHDhg9AJLtOjN4EvUKIlVOnD3QYfSJ6+iA7QvRBdoTog+wI0QfZ0dCDrKQVwPPAVqDLdpuk0cAdQCuwAviw7Q2pXux3gDcALwN/ZvvR5Gck8G3gOIq6r39me24dXwKuB84CXgIusP1Q8nU+8LcpxC/Z7q4sHtThjbdesdM3qIPtZwR9pTc9/Sm2J5QKX10KzLF9NDAnbQNcDnTaPp6ijuz1JR/XA/fafhNwArC4B1/vpSiXeTQwDfgGQPqQXAG8jaKm7RXpwxb0QLWfDAy2nxH0lb6kN5OA7t71JuADaX08hXCxvQRolTRW0u8B7yKVy7T9iu3nevA1CbjZBb+kKLJ8MHAmMNv2etsbgNnAe/pwLUFGNCp6A/dL6pA0LdnG2l4NkJYHJfsjwNkAkiYCh1NU9D4SWAt8V9LDkr6dijHX83UI8HQpjpXJVsu+A5KmSWqX1L527doGLzXY22lU9CfbPpEi3bhY0rvqtJ0OjJLUCXySohhyF8Xzw4nAN2y/BXiR7WlMLXb+SV/xAaxl39Fg32C7zXZbS0tLD6cKcqEh0dtelZZrgFkUefSzKdUgLdekNptsT7U9gSKnbwGWU/TGK23PS25nUnwIqOUrHXNYKZRDgVV17EEPVPvJwGD7GUFf6XH0JqUg+9h+Pq2fAVwF3A2cT9Gznw/cldqPBF6y/QpwEfCg7U3AJklPS3qj7aXAaRRl7qnlK9k/IWkGxUPrRturJd0H/EPp4fUM4LK+3IhcyGmUphaNDFmOBWYVo4cMBW6zfa+kBcCdki4EngI+lNofC9wsaSuFqC8s+fok8H1J+wJPAFOTfXoNX/dQDFcuoxiynApge72kLwILUrurbK/v1ZUH2dKj6G0/QTG8WGn/LUVvXWmfSzHEWM1XJ9BWxV7Ll4GLa/j6DsX3AUHQK+Ib2SA7QvRBdsTv6YOqfGLOUvbtenUn+ytD9wHe3/8BNZHo6YOqVBN8PftgIkQfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9kRog+yI0QfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9kRog+yI0QfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9kRog+yI0QfZEdM6xdU5erPfYtXhm/Zyb7v5mH8G389ABE1j+jpg6pUE3w9+2AiRB9kR4g+yI4QfZAdDYle0gpJCyV1SmpPttGSZkt6PC1HJfsoSbMk/UrSfEnHVfgakurI/lfJdoSkecnXHakmFZKGp+1laX9r6ZjLkn2ppDP7fiuCXOhNT3+K7Qm2u2tG1SptfznQaft4ipKa11f4+TSwuMJ2DXBd8rWB7cXZLgQ22D4KuC61Q9J4YDLwZopK4V+XNKQX1xJkTF/Sm1ql7cdTfAiwvQRolTQWQNKhwPuAb3c7UVG28FSKurKVvsrnmAmcltpPAmbY3mx7OUX1wYl9uJYgIxoVvYH7JXVImpZstUrbPwKcDSBpInA4RXFjgK8AnwPK5SzGAM/Z7krb5ZL3hwBPp3N0ARtT+232KscEQV0a/XLqZNurJB0EzJa0pE7b6cD1kjqBhcDDQJek9wNrbHdI+qNS+3ol72vtq3fMdsfFB3QawLhx4+qEHOREQz297VVpuQaYRZFKVC1tb3uT7am2J1Dk9C3AcuBk4I8lrQBmAKdKuhVYB4yU1P0BLJe8Xwkcls4xFHgdsL5sr3JMOe4bbLfZbmtpaWnkUoMM6LGnlzQC2Mf282n9DOAqapS2lzQSeMn2K8BFwIO2N1GUsb8stfkj4BLbU9L2A8A5FB+Gbb5K55ib9v/EtiXdDdwm6Vrg9RTFmuf37VbkyxtvvYIXt2zewXbWcFC1/0/3AhpJb8YCs4rnR4YCt9m+V9ICqpe2Pxa4WdJW4DG2j8TU4/PADElfokiHbkz2G4FbJC2j6OEnA9heJOnO5L8LuNj21gbOE1ShUvCw9woeGhC97SeAE6rYa5W2n0vR89bz+VPgpxXn2Gn0xfbLbP8wVe67Gri6bvBBUIX4RjbIjhB9kB0h+oARw4bvZPNOA8B7D/ESScDSKV/Yyfbnt98+AJH0D9HTB9kRog+yI0QfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9kRog+yI0QfZEeIPsiOEH2QHSH6IDvip8VBVS4buorhenUn+2YP/n5y8F9BsFuoJvh69sFEiD7IjhB9kB0h+iA7QvRBdoTog+wI0QfZEaIPsiNEH2RHiD7IjvgZwiCi2jzyUEzLV22WsqA60dMPIqoJvp49qE6IPsiOEH2QHSH6IDtC9EF2NCR6SSskLZTUKak92UZLmi3p8bQcleyjJM2S9CtJ8yUdl+yHSXpA0mJJiyR9uuS/li9J+ldJy5K/E0vHnJ/aPy7p/GbelD2VasUT6tmD6vRmyPIU2+tK25cCc2xPl3Rp2v48cDnQafuDkt4EfI2iIFsX8Fe2H5L0WqBD0mzbj9Xx9V6Kom1HA28DvgG8TdJo4AqgjaJocoeku21v2NUbMRiIYcnm0Jf0ZhJwU1q/CfhAWh8PzAGwvQRolTTW9mrbDyX788Bitpe2r+VrEnCzC35JUWT5YOBMYLbt9Unos4H39OFagoxoVPQG7pfUkUrPA4y1vRogLQ9K9keAswEkTQQOp6jovQ1JrcBbgHk9+DoEeLp06Mpkq2XfAUnTJLVLal+7dm2Dlxrs7TSa3pxse5Wkg4DZkpbUaTsduF5SJ7CQohhyV/dOSQcAPwA+kyqJ16NaCV/Xse9osG8AbgBoa2vbi0uHBb2hoZ7e9qq0XAPMoih0/GxKNUjLNanNJttTbU8AzgNagOWp3TAKwX/f9g9Lp6jqi6IHP6zU7lBgVR17EPRIj6KXNCI9eCJpBHAG8ChwN9A9anI+cFdqM1LSvsl+EfCg7U2SRFH2frHtaytOU9VXsp+XRnFOAjam9Oc+4Iw0UjQqxXRfL689yJRG0puxwKxCswwFbrN9r6QFwJ2SLgSeYns5+2OBmyVtBR4DLkz2k4GPAQtT6gNwue17KFKiar7uAc4ClgEvAVMBbK+X9EVgQWp3le31vb76IEvkvblKbom2tja3t7cPdBiDhtUzh9Tcd/A5W/slBkkdttua7Te+kQ2yI0QfZEe8RLKbqPbCR7zssWcQPf1uotqLHfGyx55BiD7IjhB9kB0h+iA74kF2NzFi2PCqD7KDhZ93vJ6tr+78E6ch+5gPnzMAATWREP1uYrCP0lQTfD37YCLSmyA7QvRBdoTog+wI0QfZEaIPsiNEH2RHiD7IjhB9kB0h+iA7QvRBdoTog+wI0QfZEaIPsiNEH2RHiD7IjhB9kB0h+iA7QvRBdoTog+wI0QfZES+G76VUm1YQYmpBiJ5+r6XWFIIxtWCIPsiQEH2QHSH6IDsaEr2kFZIWSuqU1J5stUrbj5I0K5W1ny/puJKf90hamsreX1qyHyFpXvJ1R3ehNknD0/aytL+1dMxlyb5U0pnNuR17D7WmEBxMUwvuLnozenOK7XWl7Vql7S8HOm1/UNKbgK8Bp0kaktbfTVESc0Eqbf8YcA1wne0Zkr5JUZztG2m5wfZRkiandn8qaTwwGXgz8Hrgx5KOsd0/xZAGAbmP0NSjL+lNrdL244E5ALaXAK2SxlLUnl1m+wnbrwAzgEmp1OapwMwqvsrnmEnx4VGyz7C92fZyiuqDE/twLUFGNCp6A/dL6pA0LdlqlbZ/BDgbQNJE4HCK4sa1StuPAZ6z3VVhp3xM2r8xta/lKwh6pNH05mTbqyQdBMyWtKRO2+nA9alW7ELgYaCLXSt5vyvHbCN9QKcBjBs3rk7IQU401NPbXpWWa4BZFKlE1dL2tjfZnmp7AnAe0AIsp3Zp+3XASElDK+yUj0n7Xwesr+OrMu4bbLfZbmtpaWnkUoMM6LGnlzQC2Mf282n9DOAqtpe2n06ptL2kkcBLKW+/CHjQ9qZUYfxoSUcAz1A8iH7EtiU9AJxDkedv81U6x9y0/yep/d3AbZKupXiQPRqY3/fbEXTz843vZqt3lscQdXHuAMTTTBpJb8YCs4rnR4YCt9m+N4m4Wmn7Y4GbJW0FHqMYgcF2l6RPAPcBQ4Dv2F6Ujvk8MEPSlyjSoRuT/UbgFknLKHr4ycnXIkl3Jv9dwMUxctNcqgm+nn0w0eMV2H4COKGK/bfAaVXscyl63mq+7gHuqXGOnUZfbL/M9g9T5b6rgat7CD8IdiK+kQ2yI0QfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9kRog+yI0QfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9kRog+yI0QfZEeIPsiOEH2QHSH6IDtC9EF2hOiD7AjRB9khe6d5T/dKJK0FnmyCqwMp5t8cLAymeCtjPdx20ychzUb0zUJSu+22gY6jUQZTvP0Va6Q3QXaE6IPsCNH3nhsGOoBeMpji7ZdYI6cPsiN6+iA7QvRBdmQjekmHSXpA0mJJiyR9OtnvSEWhO1OR6M6K48ZJekHSJSVb04pANzNeScdLmpvaL5S0X7K/NW0vk/SvqSxpvQLYSu2WpSLYJzYzVknDJN2UYlos6bL+vLfYzuIPOBg4Ma2/Fvg1ML6izb8Af19h+wHwH8AlaXsI8BvgSGBfihKi49O+O4HJaf2bwF+k9b8EvpnWJwN3NDteiqoyvwJOSNtjgCFpfT7wdoqqjP8DvDfZvwxcmtYvBa5J62eldgJOAuY1OdaPUNQBBtgfWAG09tu9HWgxDuCH4C7g3aVtUdSmPbpk+wDwT8CVJdG/Hbiv1Oay9CeKbxOHVrajqLP19pI415EGEZoVbxLqrTUEuaS0fS7wrbS+FDi41G5pWv8WcG7pmG3tmhTrucCP0r0Ykz4ko/vr3maT3pRJ/wW+BZhXMr8TeNb246nNCIoCcJX15ptZBLpp8QLHAJZ0n6SHJH2udO6VVeKF2gWwd7k4dYOxzgReBFZTFOn7Z9vr65y3qfd28JeK6yWSDqBIWT5je1Np17nA7aXtLwDX2X4hpcDbXFRxu6tFoJsZ71DgHcDvAy8BcyR1AOVjGj33LsXbi1gnAlspyqGOAn4u6cd1ztvUe5uV6CUNo/hH+b7tH5bsQ4GzgbeWmr8NOEfSl4GRwKuSXgY66KEIdOpxqhWBXqkdi0A3M96VwM9sr0tt7gFOBG5NsVTGC6kAtu3VKhXApsHi1H2I9SPAvba3AGsk/QJoo+ixd/u9zSa9SSMWNwKLbV9bsft0irx3Wxpg+522W223Al8B/sH2V4FtRaDTCMJk4G4XSWV3EWioXgQaSkWgmxkvRW57vKT90z/+HwKPpbTleUknJZ/n1YirMt7z0ijOScDG7jSoSbE+BZya/I+geFheQj/d2wF/oOyvP4r/+k0xwtGZ/s5K+74HfLzOsVeSHmS9/aHx1xQjDX9Tsh9JMVKyjGLEZ3iy75e2l6X9R+6OeIEpwCLgUeDLJXtbsv0G+Crbv4kfA8wBHk/L0d7+4Pm11H4h0NbMWIED0v1YRFEA+6/7897GzxCC7MgmvQmCbkL0QXaE6IPsCNEH2RGiD7IjRB9kR4g+yI7/B0EVaAbMo9BIAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -703,37 +696,37 @@ " \n", " 0\n", " 0\n", - " -940.961656\n", - " 5.088748e+06\n", - " 271358.937474\n", + " -935.700624\n", + " 5.088850e+06\n", + " 272702.422612\n", " \n", " \n", " 1\n", " 1\n", - " -1203.628449\n", - " 5.088767e+06\n", - " 272186.442759\n", + " -1121.593225\n", + " 5.089427e+06\n", + " 271753.679235\n", " \n", " \n", " 2\n", " 2\n", - " -856.466868\n", - " 5.089298e+06\n", - " 270558.085055\n", + " -1019.018413\n", + " 5.088917e+06\n", + " 271709.626936\n", " \n", " \n", " 3\n", " 3\n", - " -1213.623077\n", - " 5.089193e+06\n", - " 272021.172927\n", + " -999.913097\n", + " 5.089178e+06\n", + " 272171.666822\n", " \n", " \n", " 4\n", " 4\n", - " -1047.893293\n", - " 5.088885e+06\n", - " 272616.283311\n", + " -805.152755\n", + " 5.089005e+06\n", + " 272387.160966\n", " \n", " \n", "\n", @@ -741,11 +734,11 @@ ], "text/plain": [ " wellID q x_utm y_utm\n", - "0 0 -940.961656 5.088748e+06 271358.937474\n", - "1 1 -1203.628449 5.088767e+06 272186.442759\n", - "2 2 -856.466868 5.089298e+06 270558.085055\n", - "3 3 -1213.623077 5.089193e+06 272021.172927\n", - "4 4 -1047.893293 5.088885e+06 272616.283311" + "0 0 -935.700624 5.088850e+06 272702.422612\n", + "1 1 -1121.593225 5.089427e+06 271753.679235\n", + "2 2 -1019.018413 5.088917e+06 271709.626936\n", + "3 3 -999.913097 5.089178e+06 272171.666822\n", + "4 4 -805.152755 5.089005e+06 272387.160966" ] }, "execution_count": 21, @@ -798,14 +791,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -868,14 +859,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -953,7 +942,7 @@ " 20.00\n", " 0.0\n", " 0\n", - " <flopy.utils.geometry.LineString object at 0x1...\n", + " <flopy.utils.geometry.LineString object at 0x0...\n", " \n", " \n", " 1\n", @@ -965,7 +954,7 @@ " 19.75\n", " 0.0\n", " 1\n", - " <flopy.utils.geometry.LineString object at 0x1...\n", + " <flopy.utils.geometry.LineString object at 0x0...\n", " \n", " \n", " 2\n", @@ -977,7 +966,7 @@ " 19.50\n", " 0.0\n", " 2\n", - " <flopy.utils.geometry.LineString object at 0x1...\n", + " <flopy.utils.geometry.LineString object at 0x0...\n", " \n", " \n", " 3\n", @@ -989,7 +978,7 @@ " 19.25\n", " 0.0\n", " 3\n", - " <flopy.utils.geometry.LineString object at 0x1...\n", + " <flopy.utils.geometry.LineString object at 0x0...\n", " \n", " \n", " 4\n", @@ -1001,7 +990,7 @@ " 19.00\n", " 0.0\n", " 4\n", - " <flopy.utils.geometry.LineString object at 0x1...\n", + " <flopy.utils.geometry.LineString object at 0x0...\n", " \n", " \n", "\n", @@ -1016,11 +1005,11 @@ "4 0 4 14 19.190001 0.05 19.00 0.0 4 \n", "\n", " geometry \n", - "0 " ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1133,6 +1120,108 @@ "ax.set_ylim(extents[2], extents[3])\n", "ax.set_title(lines_shapefile);" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overriding the model's modelgrid with a user supplied modelgrid\n", + "\n", + "In some cases it may be necessary to override the model's modelgrid instance with a seperate modelgrid. An example of this is if the model discretization is in feet and the user would like it projected in meters. Exporting can be accomplished by supplying a modelgrid as a `kwarg` in any of the `export()` methods within flopy. Below is an example:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote tmp/freyberg.shp\n" + ] + }, + { + "data": { + "text/plain": [ + "'tmp/freyberg.shp'" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mg0 = m.modelgrid\n", + "\n", + "# build a new modelgrid instance with discretization in meters\n", + "modelgrid = flopy.discretization.StructuredGrid(delc=mg0.delc * 0.3048, delr=mg0.delr * 0.3048,\n", + " top= mg0.top, botm=mg0.botm, idomain=mg0.idomain,\n", + " xoff=mg0.xoffset * 0.3048, yoff=mg0.yoffset * 0.3048)\n", + "\n", + "# exporting an entire model\n", + "m.export('{}/freyberg.shp'.format(outdir), modelgrid=modelgrid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And for a specific parameter the method is the same" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote tmp/hk.shp\n" + ] + } + ], + "source": [ + "fname = '{}/hk.shp'.format(outdir)\n", + "m.lpf.hk.export(fname, modelgrid=modelgrid)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plt.subplot(1, 1, 1, aspect='equal')\n", + "extents = modelgrid.extent\n", + "a = m.lpf.hk.array.ravel()\n", + "pc = flopy.plot.plot_shapefile(fname, ax=ax, a=a)\n", + "ax.set_xlim(extents[0], extents[1])\n", + "ax.set_ylim(extents[2], extents[3])\n", + "ax.set_title(fname);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1151,7 +1240,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.6.5" } }, "nbformat": 4, diff --git a/flopy/export/netcdf.py b/flopy/export/netcdf.py index f9999a2228..0d0ac441de 100644 --- a/flopy/export/netcdf.py +++ b/flopy/export/netcdf.py @@ -122,9 +122,13 @@ class NetCdf(object): (default 'down') verbose : if True, stdout is verbose. If str, then a log file is written to the verbose file - forgive: what to do if a duplicate variable name is being created. If + forgive : what to do if a duplicate variable name is being created. If True, then the newly requested var is skipped. If False, then an exception is raised. + **kwargs : keyword arguments + modelgrid : flopy.discretization.Grid instance + user supplied model grid which will be used in lieu of the model + object modelgrid for netcdf production Notes ----- @@ -136,7 +140,7 @@ class NetCdf(object): def __init__(self, output_filename, model, time_values=None, z_positive='up', verbose=None, prj=None, logger=None, - forgive=False): + forgive=False, **kwargs): assert output_filename.lower().endswith(".nc") if verbose is None: @@ -156,6 +160,8 @@ def __init__(self, output_filename, model, time_values=None, self.model = model self.model_grid = model.modelgrid + if "modelgrid" in kwargs: + self.model_grid = kwargs.pop("modelgrid") self.model_time = model.modeltime if prj is not None: self.model_grid.proj4 = prj diff --git a/flopy/export/shapefile_utils.py b/flopy/export/shapefile_utils.py index dbb1083c71..e8ee182aa9 100755 --- a/flopy/export/shapefile_utils.py +++ b/flopy/export/shapefile_utils.py @@ -274,6 +274,14 @@ def model_attributes_to_shapefile(filename, ml, package_names=None, Additional 2D arrays to add as attributes to the shapefile. (default is None) + **kwargs : keyword arguments + modelgrid : fp.modflow.Grid object + if modelgrid is supplied, user supplied modelgrid is used in lieu + of the modelgrid attached to the modflow model object + epsg : int + epsg projection information + prj : str + user supplied prj file Returns ------- @@ -297,7 +305,11 @@ def model_attributes_to_shapefile(filename, ml, package_names=None, else: package_names = [pak.name[0] for pak in ml.packagelist] - grid = ml.modelgrid + if "modelgrid" in kwargs: + grid = kwargs.pop("modelgrid") + else: + grid = ml.modelgrid + if grid.grid_type == 'USG-Unstructured': raise Exception('Flopy does not support exporting to shapefile from ' 'and MODFLOW-USG unstructured grid.') @@ -393,10 +405,10 @@ def model_attributes_to_shapefile(filename, ml, package_names=None, array_dict[name] = arr # write data arrays to a shapefile - write_grid_shapefile2(filename, ml.modelgrid, array_dict) + write_grid_shapefile2(filename, grid, array_dict) epsg = kwargs.get('epsg', None) prj = kwargs.get('prj', None) - write_prj(filename, ml.modelgrid, epsg, prj) + write_prj(filename, grid, epsg, prj) def shape_attr_name(name, length=6, keep_layer=False): diff --git a/flopy/export/utils.py b/flopy/export/utils.py index c3bc2af0ef..3266b3cf69 100644 --- a/flopy/export/utils.py +++ b/flopy/export/utils.py @@ -70,8 +70,8 @@ def ensemble_helper(inputs_filename, outputs_filename, models, add_reals=True, f_in.add_global_attributes({"namefile": ''}) if outputs_filename is not None: - f_out = output_helper(outputs_filename, models[0], models[0]. \ - load_results(as_dict=True), **kwargs) + f_out = output_helper(outputs_filename, models[0], + models[0].load_results(as_dict=True), **kwargs) vdict = {} vdicts = [output_helper(vdict, models[0], models[0]. \ load_results(as_dict=True), **kwargs)] @@ -211,9 +211,15 @@ def output_helper(f, ml, oudic, **kwargs): Parameters ---------- - f : filename for output - must have .shp or .nc extension - ml : BaseModel derived type - oudic : dict {output_filename,flopy datafile/cellbudgetfile instance} + f : str + filename for output - must have .shp or .nc extension + ml : flopy.mbase.ModelInterface derived type + oudic : dict + output_filename,flopy datafile/cellbudgetfile instance + **kwargs : keyword arguments + modelgrid : flopy.discretizaiton.Grid + user supplied model grid instance that will be used for export + in lieu of the models model grid instance Returns ------- @@ -229,6 +235,9 @@ def output_helper(f, ml, oudic, **kwargs): stride = kwargs.pop("stride", 1) forgive = kwargs.pop("forgive", False) kwargs.pop("suffix", None) + mask_vals = [] + if "masked_vals" in kwargs: + mask_vals = kwargs.pop("masked_vals") if len(kwargs) > 0 and logger is not None: str_args = ','.join(kwargs) logger.warn("unused kwargs: " + str_args) @@ -274,13 +283,12 @@ def output_helper(f, ml, oudic, **kwargs): times = [t for t in common_times[::stride]] if isinstance(f, str) and f.lower().endswith(".nc"): f = NetCdf(f, ml, time_values=times, logger=logger, - forgive=forgive) + forgive=forgive, **kwargs) elif isinstance(f, NetCdf): otimes = list(f.nc.variables["time"][:]) assert otimes == times if isinstance(f, NetCdf) or isinstance(f, dict): shape3d = (ml.nlay, ml.nrow, ml.ncol) - mask_vals = [] mask_array3d = None if ml.bas6: mask_vals.append(ml.bas6.hnoflo) @@ -336,6 +344,28 @@ def output_helper(f, ml, oudic, **kwargs): def model_export(f, ml, **kwargs): + """ + Method to export a model to a shapefile or netcdf file + + Parameters + ---------- + f : str + file name (".nc" for netcdf or ".shp" for shapefile) + or dictionary of .... + ml : flopy.modflow.mbase.ModelInterface object + flopy model object + + **kwargs : keyword arguments + modelgrid: flopy.discretization.Grid + user supplied modelgrid object which will supercede the built + in modelgrid object + epsg : int + epsg projection code + prj : str + prj file name + + + """ assert isinstance(ml, ModelInterface) package_names = kwargs.get("package_names", None) if package_names is None: @@ -353,13 +383,13 @@ def model_export(f, ml, **kwargs): for pak in ml.packagelist: if pak.name[0] in package_names: - f = pak.export(f, **kwargs) + f = package_export(f, pak, **kwargs) assert f is not None return f elif isinstance(f, dict): for pak in ml.packagelist: - f = pak.export(f, **kwargs) + f = package_export(f, pak, **kwargs) else: raise NotImplementedError("unrecognized export argument:{0}".format(f)) @@ -368,9 +398,32 @@ def model_export(f, ml, **kwargs): def package_export(f, pak, **kwargs): + """ + Method to export a package to shapefile or netcdf + + Parameters + ---------- + f : str + output file name (ends in .shp for shapefile or .nc for netcdf) + pak : flopy.pakbase.Package object + package to export + ** kwargs : keword arguments + modelgrid: flopy.discretization.Grid + user supplied modelgrid object which will supercede the built + in modelgrid object + epsg : int + epsg projection code + prj : str + prj file name + + Returns + ------- + f : NetCdf object or None + + """ assert isinstance(pak, PackageInterface) if isinstance(f, str) and f.lower().endswith(".nc"): - f = NetCdf(f, pak.parent) + f = NetCdf(f, pak.parent, **kwargs) if isinstance(f, str) and f.lower().endswith(".shp"): shapefile_utils.model_attributes_to_shapefile(f, pak.parent, @@ -381,7 +434,8 @@ def package_export(f, pak, **kwargs): for a in pak.data_list: if isinstance(a, DataInterface): if a.array is not None: - if a.data_type == DataType.array2d and len(a.array.shape) == 2 \ + if a.data_type == DataType.array2d \ + and len(a.array.shape) == 2 \ and a.array.shape[1] > 0: try: f = array2d_export(f, a, **kwargs) @@ -408,12 +462,33 @@ def package_export(f, pak, **kwargs): def generic_array_export(f, array, var_name="generic_array", dimensions=("time", "layer", "y", "x"), precision_str="f4", units="unitless", **kwargs): - # assert isinstance(f,NetCdf),"generic_array_helper() can only be used " +\ - # "with instantiated netCDfs" + """ + Method to export a generic array to NetCdf + + Parameters + ---------- + f : str + filename or existing export instance type (NetCdf only for now) + array : np.ndarray + var_name : str + variable name + dimensions : tuple + netcdf dimensions + precision_str : str + binary precision string, default "f4" + units : string + units of array data + **kwargs : keyword arguments + model : flopy.modflow.mbase + flopy model object + + """ if isinstance(f, str) and f.lower().endswith(".nc"): - assert "model" in kwargs.keys(), "creating a new netCDF using generic_array_helper requires a 'model' kwarg" + assert "model" in kwargs.keys(), "creating a new netCDF using " \ + "generic_array_helper requires a " \ + "'model' kwarg" assert isinstance(kwargs["model"], BaseModel) - f = NetCdf(f, kwargs.pop("model")) + f = NetCdf(f, kwargs.pop("model"), **kwargs) assert array.ndim == len(dimensions), "generic_array_helper() " + \ "array.ndim != dimensions" @@ -456,28 +531,33 @@ def mflist_export(f, mfl, **kwargs): Parameters ----------- - f : string (filename) or existing export instance type - (NetCdf only for now) - mfl : MfList instance + f : str + filename or existing export instance type (NetCdf only for now) + mfl : MfList instance + **kwargs : keyword arguments + modelgrid : flopy.discretization.Grid + model grid instance which will supercede the flopy.model.modelgrid """ assert isinstance(mfl, DataListInterface) and \ isinstance(mfl, DataInterface) \ , "mflist_helper only helps instances that support DataListInterface" + modelgrid = mfl.model.modelgrid + if "modelgrid" in kwargs: + modelgrid = kwargs.pop("modelgrid") + if isinstance(f, str) and f.lower().endswith(".nc"): - f = NetCdf(f, mfl.model) + f = NetCdf(f, mfl.model, **kwargs) if isinstance(f, str) and f.lower().endswith(".shp"): sparse = kwargs.get("sparse", False) kper = kwargs.get("kper", 0) squeeze = kwargs.get("squeeze", True) - model_grid = mfl.model.modelgrid - - if model_grid is None: + if modelgrid is None: raise Exception("MfList.to_shapefile: ModelGrid is not set") - elif model_grid.grid_type == 'USG-Unstructured': + elif modelgrid.grid_type == 'USG-Unstructured': raise Exception('Flopy does not support exporting to shapefile ' 'from a MODFLOW-USG unstructured grid.') @@ -496,26 +576,26 @@ def mflist_export(f, mfl, **kwargs): n = shapefile_utils.shape_attr_name(name, length=4) aname = "{}{}{}".format(n, k + 1, int(kk) + 1) array_dict[aname] = array[k] - shapefile_utils.write_grid_shapefile2(f, model_grid, array_dict) + shapefile_utils.write_grid_shapefile2(f, modelgrid, array_dict) else: from ..export.shapefile_utils import recarray2shp from ..utils.geometry import Polygon #if np.isscalar(kper): # kper = [kper] - model_grid = mfl.mg df = mfl.get_dataframe(squeeze=squeeze) if 'kper' in kwargs or df is None: ra = mfl[kper] - verts = np.array(model_grid.get_cell_vertices(ra.i, ra.j)) + verts = np.array(modelgrid.get_cell_vertices(ra.i, ra.j)) elif df is not None: - verts = np.array([model_grid.get_cell_vertices(i, df.j.values[ix]) + verts = np.array([modelgrid.get_cell_vertices(i, + df.j.values[ix]) for ix, i in enumerate(df.i.values)]) ra = df.to_records(index=False) epsg = kwargs.get('epsg', None) prj = kwargs.get('prj', None) polys = np.array([Polygon(v) for v in verts]) recarray2shp(ra, geoms=polys, shpname=f, - mg=model_grid, epsg=epsg, prj=prj) + mg=modelgrid, epsg=epsg, prj=prj) elif isinstance(f, NetCdf) or isinstance(f, dict): base_name = mfl.package.name[0].lower() @@ -581,10 +661,14 @@ def transient2d_export(f, t2d, **kwargs): Parameters ----------- - f : string (filename) or existing export instance type (NetCdf only for now) - t2d : Transient2d instance + f : str + filename or existing export instance type (NetCdf only for now) + u2d : Transient2d instance + **kwargs : keyword arguments min_valid : minimum valid value max_valid : maximum valid value + modelgrid : flopy.discretization.Grid + model grid instance which will supercede the flopy.model.modelgrid """ @@ -595,25 +679,28 @@ def transient2d_export(f, t2d, **kwargs): min_valid = kwargs.get("min_valid", -1.0e+9) max_valid = kwargs.get("max_valid", 1.0e+9) + modelgrid = t2d.model.modelgrid + if 'modelgrid' in kwargs: + modelgrid = kwargs.pop("modelgrid") + if isinstance(f, str) and f.lower().endswith(".nc"): - f = NetCdf(f, t2d.model) + f = NetCdf(f, t2d.model, **kwargs) if isinstance(f, str) and f.lower().endswith(".shp"): array_dict = {} for kper in range(t2d.model.modeltime.nper): u2d = t2d[kper] - name = '{}_{}'.format( - shapefile_utils.shape_attr_name(u2d.name), kper + 1) + name = '{}_{}'.format(shapefile_utils.shape_attr_name(u2d.name), + kper + 1) array_dict[name] = u2d.array - shapefile_utils.write_grid_shapefile2(f, t2d.model.modelgrid, - array_dict) + shapefile_utils.write_grid_shapefile2(f, modelgrid, array_dict) elif isinstance(f, NetCdf) or isinstance(f, dict): # mask the array is defined by any row col with at lease # one active cell mask = None - if t2d.model.modelgrid.idomain is not None: - ibnd = np.abs(t2d.model.modelgrid.idomain).sum(axis=0) + if modelgrid.idomain is not None: + ibnd = np.abs(modelgrid.idomain).sum(axis=0) mask = ibnd == 0 # f.log("getting 4D array for {0}".format(t2d.name_base)) @@ -691,33 +778,39 @@ def array3d_export(f, u3d, **kwargs): Parameters ----------- - f : string (filename) or existing export instance type (NetCdf only for now) - u3d : Util3d instance + f : str + filename or existing export instance type (NetCdf only for now) + u2d : Util3d instance + **kwargs : keyword arguments min_valid : minimum valid value max_valid : maximum valid value + modelgrid : flopy.discretization.Grid + model grid instance which will supercede the flopy.model.modelgrid """ assert isinstance(u3d, DataInterface), "array3d_export only helps " \ "instances that support " \ "DataInterface" - #assert len(u3d.array.shape) == 3, "array3d_export only supports 3D arrays" min_valid = kwargs.get("min_valid", -1.0e+9) max_valid = kwargs.get("max_valid", 1.0e+9) + modelgrid = u3d.model.modelgrid + if "modelgrid" in kwargs: + modelgrid = kwargs.pop("modelgrid") + if isinstance(f, str) and f.lower().endswith(".nc"): - f = NetCdf(f, u3d.model) + f = NetCdf(f, u3d.model, **kwargs) if isinstance(f, str) and f.lower().endswith(".shp"): array_dict = {} - for ilay in range(u3d.model.modelgrid.nlay): + for ilay in range(modelgrid.nlay): u2d = u3d[ilay] name = '{}_{}'.format( shapefile_utils.shape_attr_name(u2d.name), ilay + 1) array_dict[name] = u2d.array - shapefile_utils.write_grid_shapefile2(f, u3d.model.modelgrid, - array_dict) + shapefile_utils.write_grid_shapefile2(f, modelgrid, array_dict) elif isinstance(f, NetCdf) or isinstance(f, dict): var_name = u3d.name @@ -738,9 +831,8 @@ def array3d_export(f, u3d, **kwargs): # f.log("getting 3D array for {0}".format(var_name)) # mask = None - if u3d.model.modelgrid.idomain is not None and "ibound" not in \ - var_name: - mask = u3d.model.modelgrid.idomain == 0 + if modelgrid.idomain is not None and "ibound" not in var_name: + mask = modelgrid.idomain == 0 if mask is not None and array.shape != mask.shape: # f.log("broadcasting 3D array for {0}".format(var_name)) @@ -771,10 +863,8 @@ def array3d_export(f, u3d, **kwargs): array[mask] = netcdf.FILLVALUE array[array <= min_valid] = netcdf.FILLVALUE array[array >= max_valid] = netcdf.FILLVALUE - if u3d.model.modelgrid.idomain is not None and "ibound" not\ - in var_name: - array[u3d.model.modelgrid.idomain == 0] = \ - netcdf.FILLVALUE + if modelgrid.idomain is not None and "ibound" not in var_name: + array[modelgrid.idomain == 0] = netcdf.FILLVALUE if isinstance(f, dict): f[var_name] = array @@ -823,10 +913,14 @@ def array2d_export(f, u2d, **kwargs): Parameters ---------- - f : string (filename) or existing export instance type (NetCdf only for now) - u2d : Util2d instance + f : str + filename or existing export instance type (NetCdf only for now) + u2d : Util2d instance + **kwargs : keyword arguments min_valid : minimum valid value max_valid : maximum valid value + modelgrid : flopy.discretization.Grid + model grid instance which will supercede the flopy.model.modelgrid """ assert isinstance(u2d, DataInterface), "util2d_helper only helps " \ @@ -837,17 +931,21 @@ def array2d_export(f, u2d, **kwargs): min_valid = kwargs.get("min_valid", -1.0e+9) max_valid = kwargs.get("max_valid", 1.0e+9) + modelgrid = u2d.model.modelgrid + if "modelgrid" in kwargs: + modelgrid = kwargs.pop("modelgrid") + if isinstance(f, str) and f.lower().endswith(".nc"): - f = NetCdf(f, u2d.model) + f = NetCdf(f, u2d.model, **kwargs) if isinstance(f, str) and f.lower().endswith(".shp"): name = shapefile_utils.shape_attr_name(u2d.name, keep_layer=True) - shapefile_utils.write_grid_shapefile2(f, u2d.model.modelgrid, + shapefile_utils.write_grid_shapefile2(f, modelgrid, {name: u2d.array}) return elif isinstance(f, str) and f.lower().endswith(".asc"): - export_array( u2d.model.modelgrid, f, u2d.array, **kwargs) + export_array(modelgrid, f, u2d.array, **kwargs) return elif isinstance(f, NetCdf) or isinstance(f, dict): @@ -859,10 +957,10 @@ def array2d_export(f, u2d, **kwargs): with np.errstate(invalid="ignore"): if array.dtype not in [int, np.int, np.int32, np.int64]: - if u2d.model.modelgrid.idomain is not None and \ + if modelgrid.idomain is not None and \ "ibound" not in u2d.name.lower() and \ "idomain" not in u2d.name.lower(): - array[u2d.model.modelgrid.idomain[0, :, :] == 0] = np.NaN + array[modelgrid.idomain[0, :, :] == 0] = np.NaN array[array <= min_valid] = np.NaN array[array >= max_valid] = np.NaN mx, mn = np.nanmax(array), np.nanmin(array) @@ -870,11 +968,11 @@ def array2d_export(f, u2d, **kwargs): mx, mn = np.nanmax(array), np.nanmin(array) array[array <= min_valid] = netcdf.FILLVALUE array[array >= max_valid] = netcdf.FILLVALUE - if u2d.model.modelgrid.idomain is not None and \ + if modelgrid.idomain is not None and \ "ibound" not in u2d.name.lower() and \ "idomain" not in u2d.name.lower() and \ "icbund" not in u2d.name.lower(): - array[u2d.model.modelgrid.idomain[0, :, :] == 0] = \ + array[modelgrid.idomain[0, :, :] == 0] = \ netcdf.FILLVALUE var_name = u2d.name if isinstance(f, dict): @@ -920,8 +1018,7 @@ def array2d_export(f, u2d, **kwargs): def export_array(modelgrid, filename, a, nodata=-9999, - fieldname='value', - **kwargs): + fieldname='value', **kwargs): """ Write a numpy array to Arc Ascii grid or shapefile with the model reference. @@ -1065,10 +1162,14 @@ def export_contours(modelgrid, filename, contours, Parameters ---------- + modelgrid : flopy.discretization.Grid + flopy modelgrid instance filename : str path of output shapefile contours : matplotlib.contour.QuadContourSet or list of them (object returned by matplotlib.pyplot.contour) + fieldname : str + gis attribute table field name epsg : int EPSG code. See https://www.epsg-registry.org/ or spatialreference.org prj : str @@ -1216,6 +1317,12 @@ def export_array_contours(modelgrid, filename, a, Path of output file with '.shp' extention. a : 2D numpy array Array to contour + fieldname : str + gis field name + levels : list + list of contour levels + maxlevels : int + maximum number of contour levels epsg : int EPSG code. See https://www.epsg-registry.org/ or spatialreference.org prj : str diff --git a/flopy/mbase.py b/flopy/mbase.py index fc971ffe46..c6984e1ec4 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -396,9 +396,24 @@ def next_ext_unit(self): return next_unit def export(self, f, **kwargs): - # for pak in self.packagelist: - # f = pak.export(f) - # return f + """ + Method to export a model to netcdf or shapefile based on the + extension of the file name (.shp for shapefile, .nc for netcdf) + + Parameters + ---------- + f : str + filename + kwargs : keyword arguments + modelgrid : flopy.discretization.Grid instance + user supplied modelgrid which can be used for exporting + in lieu of the modelgrid associated with the model object + + Returns + ------- + None or Netcdf object + + """ from .export import utils return utils.model_export(f, self, **kwargs) diff --git a/flopy/mf6/mfpackage.py b/flopy/mf6/mfpackage.py index 40289ffef4..d46eeab4e4 100644 --- a/flopy/mf6/mfpackage.py +++ b/flopy/mf6/mfpackage.py @@ -1741,6 +1741,24 @@ def get_file_path(self): self._filename) def export(self, f, **kwargs): + """ + Method to export a package to netcdf or shapefile based on the + extension of the file name (.shp for shapefile, .nc for netcdf) + + Parameters + ---------- + f : str + filename + kwargs : keyword arguments + modelgrid : flopy.discretization.Grid instance + user supplied modelgrid which can be used for exporting + in lieu of the modelgrid associated with the model object + + Returns + ------- + None or Netcdf object + + """ from flopy import export return export.utils.package_export(f, self, **kwargs) diff --git a/flopy/pakbase.py b/flopy/pakbase.py index a6c9df695f..5dc0832723 100644 --- a/flopy/pakbase.py +++ b/flopy/pakbase.py @@ -264,6 +264,24 @@ def data_list(self): return dl def export(self, f, **kwargs): + """ + Method to export a package to netcdf or shapefile based on the + extension of the file name (.shp for shapefile, .nc for netcdf) + + Parameters + ---------- + f : str + filename + kwargs : keyword arguments + modelgrid : flopy.discretization.Grid instance + user supplied modelgrid which can be used for exporting + in lieu of the modelgrid associated with the model object + + Returns + ------- + None or Netcdf object + + """ from flopy import export return export.utils.package_export(f, self, **kwargs)