Refactor TTim to compute per log t-interval

docs/03examples/test_t_intervals2.ipynb

@@ -242,10 +242,112 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "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": {

ttim/element.py

@@ -112,15 +112,6 @@ def unitpotential(self, x, y, t_int, aq=None):
             aq = self.model.aq.find_aquifer_data(x, y)
         return np.sum(self.potinf(x, y, t_int, aq), 0)
 
-    def unitpotentialone(self, x, y, jtime, aq=None):
-        """Returns complex array of size (naq, npval).
-
-        Can be more efficient for given elements.
-        """
-        if aq is None:
-            aq = self.model.aq.find_aquifer_data(x, y)
-        return np.sum(self.potinfone(x, y, jtime, aq), 0)
-
     @abstractmethod
     def disvecinf(self, x, y, t_int, aq=None):
         """Returns 2 complex arrays of size (nparam, naq, nppar)."""

ttim/model.py

@@ -235,7 +235,7 @@ def potential(self, x, y, time, layers=None, aq=None, derivative=0, returnphi=0)
         time = np.atleast_1d(time) - self.tstart  # used to be ).copy()
         pot = np.zeros((self.ngvbc, aq.naq, self.nppar), dtype=complex)
         for i in range(self.ngbc):
-            pot[i, :] += self.gbclist[i].unitpotentialone(x, y, t_int, aq)
+            pot[i, :] += self.gbclist[i].unitpotential(x, y, t_int, aq)
         for e in self.vzbclist:
             pot += e.potential(x, y, t_int, aq)
         # multiply by eigenvectors

ttim/well.py

@@ -233,7 +233,7 @@ def changetrace(
 
 
 class DischargeWell(WellBase):
-    r"""Well with a specified discharge for each layer that the well is screened in.
+    r"""Well with one specified discharge for each layer that the well is screened in.
 
     This is not very common and is likely only used for testing and comparison with
     other codes. The discharge must be specified for each screened layer. The resistance
@@ -265,13 +265,17 @@ class DischargeWell(WellBase):
     label : string or None (default: None)
         label of the well
 
+    Implementation
+    --------------
+    This element doesn't compute or store parameters as everything is given.
+
     Examples
     --------
     Example of a well that pumps with a discharge of 100 between times
     10 and 50, with a discharge of 20 between times 50 and 200, and zero
-    discharge after time 200.
+    discharge after time 200. All from layer 0 (default).
 
-    >>> Well(ml, tsandQ=[(10, 100), (50, 20), (200, 0)])
+    >>> DischargeWell(ml, tsandQ=[(10, 100), (50, 20), (200, 0)])
     """
 
     def __init__(
@@ -292,6 +296,18 @@ def __init__(
             label=label,
         )
 
+    def initialize(self):
+        super().initialize()
+        self.parameters = {}
+        for t_int in self.model.logtintervals:
+            self.initialize_interval(t_int)
+
+    def initialize_interval(self, t_int):
+        super().initialize_interval(t_int)
+        self.parameters[t_int] = np.zeros(
+            (self.model.ngvbc, self.nparam, self.model.nppar), "D"
+        )
+
 
 class Well(WellBase, WellBoreStorageEquation):
     r"""Create a well with a specified discharge.