Refactor TTim to compute per log t-interval

docs/03examples/test_t_intervals2.ipynb

@@ -0,0 +1,374 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TTim: compute per log time interval\n",
+    "\n",
+    "Import packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ttim: /Users/mark/git/ttim/docs/03examples/../../ttim/__init__.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from scipy.special import exp1\n",
+    "\n",
+    "use_fork = True\n",
+    "if use_fork:\n",
+    "    sys.path.insert(1, \"../..\")\n",
+    "import ttim\n",
+    "\n",
+    "# check which ttim\n",
+    "print(\"ttim:\", ttim.__file__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "self.neq  1\n",
+      "solution complete\n"
+     ]
+    }
+   ],
+   "source": [
+    "k = 25\n",
+    "H = 20\n",
+    "Ss = 1e-4 / H\n",
+    "t = np.logspace(0, 1, 100)\n",
+    "Q = 500\n",
+    "rw = 0.2\n",
+    "#ml = ttim.ModelMaq(kaq=k, z=[H, 0], tmin=1e-3, tmax=10)\n",
+    "ml = ttim.Model3D(kaq=k, z=np.linspace(H, 0, 3), Saq=Ss, tmin=1, tmax=10, M=10)\n",
+    "w = ttim.Well(ml, tsandQ=[(0, Q)], rw=rw, layers=[0])\n",
+    "\n",
+    "ml.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 1, 21)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "w.parameters[0].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1.45490671],\n",
+       "       [-0.83091413]])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.head(2, 3, 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "self.neq  2\n",
+      "solution complete\n"
+     ]
+    }
+   ],
+   "source": [
+    "k = 25\n",
+    "H = 20\n",
+    "Ss = 1e-4 / H\n",
+    "t = np.logspace(0, 1, 100)\n",
+    "Q = 500\n",
+    "rw = 0.2\n",
+    "#ml = ttim.ModelMaq(kaq=k, z=[H, 0], tmin=1e-3, tmax=10)\n",
+    "ml = ttim.Model3D(kaq=k, z=np.linspace(H, 0, 3), Saq=Ss, tmin=1, tmax=10, M=10)\n",
+    "w = ttim.Well(ml, tsandQ=[(0, Q)], rw=rw, layers=[0, 1])\n",
+    "\n",
+    "ml.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1.14291044],\n",
+       "       [-1.14291044]])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.head(2, 3, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Headwell"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "self.neq  2\n",
+      "solution complete\n"
+     ]
+    }
+   ],
+   "source": [
+    "k = 25\n",
+    "H = 20\n",
+    "Ss = 1e-4 / H\n",
+    "t = np.logspace(0, 1, 100)\n",
+    "Q = 500\n",
+    "rw = 0.2\n",
+    "hwell = -2\n",
+    "\n",
+    "ml = ttim.Model3D(kaq=k, z=np.linspace(H, 0, 3), Saq=Ss, tmin=0.1, tmax=10, M=10)\n",
+    "w = ttim.HeadWell(ml, tsandh=[(0, hwell)], rw=rw, layers=[0, 1])\n",
+    "ml.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1.99999997],\n",
+       "       [-1.99999997]])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.head(rw, 0, 0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1.99999996],\n",
+       "       [-1.99999998]])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.head(rw, 0, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TO DO: `w.discharge` and `w.headinside`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "self.neq  3\n",
+      "solution complete\n"
+     ]
+    }
+   ],
+   "source": [
+    "k = 25\n",
+    "H = 20\n",
+    "Ss = 1e-4 / H\n",
+    "t = np.logspace(0, 1, 100)\n",
+    "Q = 500\n",
+    "rw = 0.2\n",
+    "hwell = -2\n",
+    "\n",
+    "ml = ttim.Model3D(kaq=k, z=np.linspace(H, 0, 3), Saq=Ss, tmin=0.1, tmax=10, M=10)\n",
+    "w1 = ttim.Well(ml, xw=0, yw=0, tsandQ=[(0, Q)], layers=0)\n",
+    "w2 = ttim.HeadWell(ml, xw=100, yw=50, tsandh=[(0, 2)], rw=rw, layers=[0, 1])\n",
+    "ml.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([[-1.40355951],\n",
+       "        [ 0.13485716]]),\n",
+       " array([[1.99974041],\n",
+       "        [1.9997507 ]]))"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.head(rw, 0, 2), ml.head(100, 50, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `DischargeWell`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "self.neq  0\n",
+      "No unknowns. Solution complete\n"
+     ]
+    }
+   ],
+   "source": [
+    "k = 25\n",
+    "H = 20\n",
+    "Ss = 1e-4 / H\n",
+    "t = np.logspace(0, 1, 100)\n",
+    "Q = 500\n",
+    "rw = 0.2\n",
+    "hwell = -2\n",
+    "\n",
+    "ml = ttim.Model3D(kaq=k, z=np.linspace(H, 0, 3), Saq=Ss, tmin=0.1, tmax=10, M=10)\n",
+    "w1 = ttim.DischargeWell(ml, xw=0, yw=0, tsandQ=[(0, Q)], layers=[0, 1])\n",
+    "#w2 = ttim.HeadWell(ml, xw=100, yw=50, tsandh=[(0, 2)], rw=rw, layers=[0, 1])\n",
+    "ml.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-2.28582088],\n",
+       "       [-2.28582087]])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ml.head(2, 3, 2)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

examples/test4.py

@@ -57,7 +57,7 @@ def quadfunc(p0, p1, func):
     M=20,
 )
 ml2.initialize()
-fp = np.zeros(41, "D")
+fp = np.zeros(41, dtype=complex)
 p = ml2.p
 for i in range(41):
     p0 = p[i].real

examples/test5.py

@@ -56,7 +56,7 @@ def func(t):
     M=20,
 )
 ml2.initialize()
-fp = np.zeros(len(ml2.p), "D")
+fp = np.zeros(len(ml2.p), dtype=complex)
 p = ml2.p
 for i in range(len(p)):
     p0 = p[i].real