From be1c3314e361e6f2aaa4e635d06699558ce88464 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 12:01:12 +0200 Subject: [PATCH 01/12] add check for length of z for semi confined modelmaq, - improve assert messages --- timflow/steady/aquifer_parameters.py | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/timflow/steady/aquifer_parameters.py b/timflow/steady/aquifer_parameters.py index be726e3..6a2322a 100644 --- a/timflow/steady/aquifer_parameters.py +++ b/timflow/steady/aquifer_parameters.py @@ -46,26 +46,30 @@ def param_maq(kaq, z, c, npor, top): ltype = np.array(list(Naq * "la")) if len(kaq) == 1: kaq = kaq * np.ones(Naq) - assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or" + str(Naq) + assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or " + str(Naq) H = z[:-1] - z[1:] - assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative" + str(H) + assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative " + str(H) if top.startswith("con"): if len(c) == 1: c = c * np.ones(Naq - 1) if len(npor) == 1: npor = npor * np.ones(2 * Naq - 1) - assert len(c) == Naq - 1, "Error: Length of c needs to be 1 or" + str(Naq - 1) - assert len(npor) == 2 * Naq - 1, "Error: Length of npor needs to be 1 or" + str( + assert len(c) == Naq - 1, "Error: Length of c needs to be 1 or " + str(Naq - 1) + assert len(npor) == 2 * Naq - 1, "Error: Length of npor needs to be 1 or " + str( 2 * Naq - 1 ) c = np.hstack((1e100, c)) else: # leaky layer on top + assert len(z) % 2 == 1, ( + "Error: Length of z must be 2 * number of aquifers + 1 " + "when topboundary is leaky in Model" + ) if len(c) == 1: c = c * np.ones(Naq) if len(npor) == 1: npor = npor * np.ones(2 * Naq) - assert len(c) == Naq, "Error: Length of c needs to be 1 or" + str(Naq) - assert len(npor) == 2 * Naq, "Error: Length of npor needs to be 1 or" + str( + assert len(c) == Naq, "Error: Length of c needs to be 1 or " + str(Naq) + assert len(npor) == 2 * Naq, "Error: Length of npor needs to be 1 or " + str( 2 * Naq ) return kaq, c, npor, ltype @@ -112,23 +116,23 @@ def param_3d(kaq, z, kzoverkh, npor, top="conf", topres=0): ltype = np.hstack(("l", Naq * ["a"])) if len(kaq) == 1: kaq = kaq * np.ones(Naq) - assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or" + str(Naq) + assert len(kaq) == Naq, "Error: length of kaq needs to be 1 or " + str(Naq) if len(kzoverkh) == 1: kzoverkh = kzoverkh * np.ones(Naq) - assert len(kzoverkh) == Naq, "Error: length of kzoverkh needs to be 1 or" + str(Naq) + assert len(kzoverkh) == Naq, "Error: length of kzoverkh needs to be 1 or " + str(Naq) if len(npor) == 1: if top.startswith("con"): npor = npor * np.ones(Naq) elif top.startswith("sem"): npor = npor * np.ones(Naq + 1) if top.startswith("con"): - assert len(npor) == Naq, "Error: length of npor needs to be 1 or" + str(Naq) + assert len(npor) == Naq, "Error: length of npor needs to be 1 or " + str(Naq) elif top.startswith("sem"): - assert len(npor) == Naq + 1, "Error: length of npor needs to be 1 or" + str( + assert len(npor) == Naq + 1, "Error: length of npor needs to be 1 or " + str( Naq + 1 ) H = z[:-1] - z[1:] - assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative" + str(H) + assert np.all(H >= 0), "Error: Not all layers thicknesses are non-negative " + str(H) c = 0.5 * H[:-1] / (kzoverkh[:-1] * kaq[:-1]) + 0.5 * H[1:] / (kzoverkh[1:] * kaq[1:]) if top.startswith("con"): c = np.hstack((1e100, c)) From 19f9e88d3aecd7a57d670886ac4763fb8b373082 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 12:01:44 +0200 Subject: [PATCH 02/12] add gaps check for modelxsection --- timflow/steady/model.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/timflow/steady/model.py b/timflow/steady/model.py index 7ffa8d3..0af9b91 100644 --- a/timflow/steady/model.py +++ b/timflow/steady/model.py @@ -889,8 +889,10 @@ def check_inhoms(self): if not check.all(): raise ValueError(f"Number of aquifers does not match {self.aq.naq}:\n{naqs}") # check -inf to inf - xmin = min([inhom.x1 for inhom in self.aq.inhomlist]) - xmax = max([inhom.x2 for inhom in self.aq.inhomlist]) + x1list = np.array([inhom.x1 for inhom in self.aq.inhomlist]) + x2list = np.array([inhom.x2 for inhom in self.aq.inhomlist]) + xmin = x1list.min() + xmax = x2list.max() if not (np.isinf(xmin) and np.sign(xmin) < 0): raise ValueError( f"XsectionModel boundary error: left-most boundary must be at x=-np.inf, " @@ -906,6 +908,16 @@ def check_inhoms(self): f"(Model may consist of multiple Xsections, but their combined " f"domain must span from -∞ to +∞)" ) + # check domain for gaps + if not np.allclose(x1list[1:], x2list[:-1]): + mask = (x1list[1:] - x2list[:-1]) > 1e-10 + x1missing = x1list[1:][mask] + x2missing = x2list[:-1][mask] + msg = [f"{ix1}-{ix2}" for ix1, ix2 in zip(x2missing, x1missing, strict=True)] + raise ValueError( + "XsectionModel boundary error: missing section(s) between: " + + ", ".join(msg) + ) # # shared boundary check # # NOTE: does not deal with nested inhoms From cef18ad26b5168fdc9fec5a8f3d8b2b0ddbfbbfd Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 12:02:02 +0200 Subject: [PATCH 03/12] add gaps check for modelxsection --- timflow/transient/model.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/timflow/transient/model.py b/timflow/transient/model.py index f6a47b0..73290f2 100644 --- a/timflow/transient/model.py +++ b/timflow/transient/model.py @@ -1096,8 +1096,10 @@ def check_inhoms(self): if not check.all(): raise ValueError(f"Number of aquifers does not match {self.aq.naq}:\n{naqs}") # check -inf to inf - xmin = min([inhom.x1 for inhom in self.aq.inhomdict.values()]) - xmax = max([inhom.x2 for inhom in self.aq.inhomdict.values()]) + x1list = np.array([inhom.x1 for inhom in self.aq.inhomdict.values()]) + x2list = np.array([inhom.x2 for inhom in self.aq.inhomdict.values()]) + xmin = x1list.min() + xmax = x2list.max() if not (np.isinf(xmin) and np.sign(xmin) < 0): raise ValueError( f"XsectionModel boundary error: left-most boundary must be at x=-np.inf, " @@ -1113,6 +1115,16 @@ def check_inhoms(self): f"(Model may consist of multiple Xsections, but their combined " f"domain must span from -∞ to +∞)" ) + # check domain for gaps + if not np.allclose(x1list[1:], x2list[:-1]): + mask = (x1list[1:] - x2list[:-1]) > 1e-10 + x1missing = x1list[1:][mask] + x2missing = x2list[:-1][mask] + msg = [f"{ix1}-{ix2}" for ix1, ix2 in zip(x2missing, x1missing, strict=True)] + raise ValueError( + "XsectionModel boundary error: missing section(s) between: " + + ", ".join(msg) + ) # # shared boundary check # # NOTE: does not deal with nested inhoms From fe195fc1882aef7f29beee9daff9dc6575d65c0e Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 12:02:15 +0200 Subject: [PATCH 04/12] improve formatting --- timflow/transient/aquifer_parameters.py | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/timflow/transient/aquifer_parameters.py b/timflow/transient/aquifer_parameters.py index 94c88d9..5c6ad97 100644 --- a/timflow/transient/aquifer_parameters.py +++ b/timflow/transient/aquifer_parameters.py @@ -17,7 +17,7 @@ def param_maq( poraq=[0.3], porll=[0.3], topboundary="conf", - phreatictop=False, + phreatictop=False, # deprecated ): # Computes the parameters for a TimModel from input for a maq model z = np.atleast_1d(z).astype(float) @@ -29,9 +29,7 @@ def param_maq( porll = np.atleast_1d(porll).astype(float) leffaq = np.atleast_1d(leffaq).astype(float) H = z[:-1] - z[1:] - assert np.all(H >= 0), ( - "Error: Not all layer thicknesses are" + " non-negative" + str(H) - ) + assert np.all(H >= 0), "Error: Not all layer thicknesses are non-negative" + str(H) if topboundary[:3] == "con" or topboundary[:3] == "phr": assert len(z) % 2 == 0, ( "Error: Length of z must be 2 * number of aquifers " @@ -57,14 +55,10 @@ def param_maq( assert len(Sll) == naq - 1, "Error: Length of Sll needs to be " + str(naq - 1) assert len(porll) == naq - 1, "Error: Length of porll needs to be " + str(naq - 1) Haq = H[::2] - assert np.all(Haq > 0), ( - "Error: Some thicknesses of aquifer layers " + "are negative" - ) + assert np.all(Haq > 0), "Error: Some thicknesses of aquifer layers are negative" Hll = H[1::2] Hll = np.maximum(Hll, 1e-20) # make sure none are negative - assert np.all(Hll > 0), ( - "Error: Some thicknesses of leaky layers " + "are negative" - ) + assert np.all(Hll > 0), "Error: Some thicknesses of leaky layers are negative" c = np.hstack((1e100, c)) Sll = np.hstack((1e-20, Sll)) Hll = np.hstack((1e-20, Hll)) @@ -76,7 +70,7 @@ def param_maq( else: # leaky layers on top assert len(z) % 2 == 1, ( "Error: Length of z must be 2 * number of aquifers + 1 " - "when topboundary is leaky in MaqModel" + "when topboundary is leaky in ModelMaq" ) naq = int((len(z) - 1) / 2) if len(kaq) == 1: From 952f1f6d4dbb99c9c14387e1d75caf556fecae66 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 15:30:34 +0200 Subject: [PATCH 05/12] clean up inits --- timflow/steady/__init__.py | 12 +++++------- timflow/transient/__init__.py | 11 ++++------- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/timflow/steady/__init__.py b/timflow/steady/__init__.py index dabf24c..a945864 100644 --- a/timflow/steady/__init__.py +++ b/timflow/steady/__init__.py @@ -45,17 +45,18 @@ Ditch, DitchString, HeadLineSink, # Deprecated alias for River - # HeadLineSinkContainer, HeadLineSinkString, # Deprecated alias for RiverString - # HeadLineSinkZero, - LineSinkBase, LineSinkDitch, # Deprecated alias for Ditch LineSinkDitchString, # Deprecated alias for DitchString RadialCollectorWell, River, RiverString, ) -from timflow.steady.linesink1d import HeadLineSink1D, LineSink1D, River1D +from timflow.steady.linesink1d import ( + HeadLineSink1D, # Deprecated alias for River1D + LineSink1D, + River1D, +) from timflow.steady.model import Model, Model3D, ModelMaq, ModelXsection from timflow.steady.stripareasink import XsectionAreaSink from timflow.steady.trace import timtraceline, timtracelines @@ -63,11 +64,8 @@ from timflow.steady.well import ( HeadWell, HeadWellString, - LargeDiameterWell, TargetHeadWell, TargetHeadWellString, Well, - WellBase, WellString, - WellStringBase, ) diff --git a/timflow/transient/__init__.py b/timflow/transient/__init__.py index 2408d39..04ecd5e 100644 --- a/timflow/transient/__init__.py +++ b/timflow/transient/__init__.py @@ -16,7 +16,10 @@ LeakyWall, LeakyWallString, ) -from timflow.transient.linedoublet1d import LeakyLineDoublet1D, LeakyWall1D +from timflow.transient.linedoublet1d import ( + LeakyLineDoublet1D, # deprecated + LeakyWall1D, +) from timflow.transient.linesink import ( DitchString, HeadLineSink, # deprecated @@ -29,12 +32,8 @@ RiverString, ) from timflow.transient.linesink1d import ( - DischargeLineSink1D, - FluxDiffLineSink1D, - HeadDiffLineSink1D, HeadLineSink1D, # deprecated LineSink1D, - LineSink1DBase, River1D, ) @@ -46,6 +45,4 @@ HeadWell, Well, WellString, - WellStringBase, - WellTest, ) From ffe1eeb4c40f319f72b411f6fc6bef7961a051f0 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 15:38:30 +0200 Subject: [PATCH 06/12] update notebooks and clear --- .../tutorial1_well_multi_layer_aquifer.ipynb | 14 +- .../02examples/01_well_in_uniform_flow.ipynb | 14 +- .../03xsections/cross_section_models.ipynb | 8 +- .../test_linesink_discharge.ipynb | 2 +- .../howto_fluctuating_head_boundary.ipynb | 14 +- .../howtos/howto_pumpingtest.ipynb | 14 +- .../howtos/howto_select_a_model.ipynb | 14 +- .../tutorials/tutorial0_start_a_model.ipynb | 14 +- .../02examples/connected_wells.ipynb | 14 +- .../02examples/horizontal_well.ipynb | 14 +- .../02examples/line_sink_well_sol.ipynb | 14 +- .../02examples/meandering_river.ipynb | 14 +- .../well_in_multilayer_system.ipynb | 14 +- docs/transient/03xsections/1d_elements.ipynb | 18 +- .../03xsections/1d_given_linesink.ipynb | 16 +- .../03xsections/1d_inhom_elements.ipynb | 19 +- .../transient/03xsections/stripareasink.ipynb | 14 +- .../confined1_oude_korendijk.ipynb | 186 ++---------- .../04pumpingtests/confined2_grindley.ipynb | 178 +----------- .../04pumpingtests/confined3_sioux.ipynb | 178 +----------- .../04pumpingtests/confined4_nevada.ipynb | 270 ++---------------- .../04pumpingtests/leaky1_dalem.ipynb | 94 +----- .../04pumpingtests/leaky2_hardixveld.ipynb | 30 +- .../04pumpingtests/leaky3_texashill.ipynb | 186 +----------- .../04pumpingtests/slug1_pratt_county.ipynb | 190 ++---------- .../04pumpingtests/slug2_multiwell.ipynb | 196 ++----------- .../04pumpingtests/slug3_falling_head.ipynb | 32 +-- .../04pumpingtests/slug4_dawsonville.ipynb | 206 +------------ .../04pumpingtests/unconfined1_moench.ipynb | 32 +-- docs/transient/05benchmarks/river1d.ipynb | 14 +- .../05benchmarks/ttim_neuman_comparison.ipynb | 14 +- ...validation_tidal_wave_with_Bruggeman.ipynb | 14 +- .../05benchmarks/well_near_leaky_river.ipynb | 14 +- .../well_near_river_or_wall.ipynb | 14 +- tests/steady/test_well.py | 10 +- 35 files changed, 185 insertions(+), 1904 deletions(-) diff --git a/docs/steady/00userguide/tutorials/tutorial1_well_multi_layer_aquifer.ipynb b/docs/steady/00userguide/tutorials/tutorial1_well_multi_layer_aquifer.ipynb index 18709cd..c12a584 100755 --- a/docs/steady/00userguide/tutorials/tutorial1_well_multi_layer_aquifer.ipynb +++ b/docs/steady/00userguide/tutorials/tutorial1_well_multi_layer_aquifer.ipynb @@ -254,21 +254,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/steady/02examples/01_well_in_uniform_flow.ipynb b/docs/steady/02examples/01_well_in_uniform_flow.ipynb index eca5b52..d71b590 100755 --- a/docs/steady/02examples/01_well_in_uniform_flow.ipynb +++ b/docs/steady/02examples/01_well_in_uniform_flow.ipynb @@ -233,21 +233,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/steady/03xsections/cross_section_models.ipynb b/docs/steady/03xsections/cross_section_models.ipynb index e0adceb..34b9bbc 100644 --- a/docs/steady/03xsections/cross_section_models.ipynb +++ b/docs/steady/03xsections/cross_section_models.ipynb @@ -499,9 +499,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "from timflow.steady.linesink1d import FluxDiffLineSink1D, HeadDiffLineSink1D" - ] + "source": [] }, { "cell_type": "code", @@ -512,8 +510,8 @@ "ml = tfs.ModelMaq(kaq=[10], z=[0, -10], topboundary=\"conf\")\n", "ls = tfs.River1D(ml, xls=0, hls=1, wh=\"H\", layers=0)\n", "ls = tfs.River1D(ml, xls=200, hls=0, wh=\"H\", layers=0)\n", - "hd = HeadDiffLineSink1D(ml, xls=100)\n", - "fd = FluxDiffLineSink1D(ml, xls=100)\n", + "hd = tfs.linesink1d.HeadDiffLineSink1D(ml, xls=100)\n", + "fd = tfs.linesink1d.FluxDiffLineSink1D(ml, xls=100)\n", "ml.solve()\n", "\n", "x = np.linspace(0, 200, 101)\n", diff --git a/docs/steady/04benchmarks/test_linesink_discharge.ipynb b/docs/steady/04benchmarks/test_linesink_discharge.ipynb index 426a84f..a965820 100644 --- a/docs/steady/04benchmarks/test_linesink_discharge.ipynb +++ b/docs/steady/04benchmarks/test_linesink_discharge.ipynb @@ -36,7 +36,7 @@ "source": [ "ml1 = tfs.ModelMaq(kaq=20)\n", "rf1 = tfs.Constant(ml1, xr=0, yr=20, hr=30)\n", - "ls1 = tfs.LineSinkBase(ml1, x1=-10, y1=-10, x2=10, y2=10, Qls=1000)\n", + "ls1 = tfs.linesink.LineSinkBase(ml1, x1=-10, y1=-10, x2=10, y2=10, Qls=1000)\n", "ml1.solve()" ] }, diff --git a/docs/transient/00userguide/howtos/howto_fluctuating_head_boundary.ipynb b/docs/transient/00userguide/howtos/howto_fluctuating_head_boundary.ipynb index 798ab53..542afb5 100644 --- a/docs/transient/00userguide/howtos/howto_fluctuating_head_boundary.ipynb +++ b/docs/transient/00userguide/howtos/howto_fluctuating_head_boundary.ipynb @@ -255,21 +255,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/00userguide/howtos/howto_pumpingtest.ipynb b/docs/transient/00userguide/howtos/howto_pumpingtest.ipynb index eb846bf..8472bf6 100755 --- a/docs/transient/00userguide/howtos/howto_pumpingtest.ipynb +++ b/docs/transient/00userguide/howtos/howto_pumpingtest.ipynb @@ -437,21 +437,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/00userguide/howtos/howto_select_a_model.ipynb b/docs/transient/00userguide/howtos/howto_select_a_model.ipynb index f3c8fe0..f96c787 100644 --- a/docs/transient/00userguide/howtos/howto_select_a_model.ipynb +++ b/docs/transient/00userguide/howtos/howto_select_a_model.ipynb @@ -84,21 +84,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/00userguide/tutorials/tutorial0_start_a_model.ipynb b/docs/transient/00userguide/tutorials/tutorial0_start_a_model.ipynb index 4ff3719..1b927c6 100755 --- a/docs/transient/00userguide/tutorials/tutorial0_start_a_model.ipynb +++ b/docs/transient/00userguide/tutorials/tutorial0_start_a_model.ipynb @@ -133,21 +133,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/02examples/connected_wells.ipynb b/docs/transient/02examples/connected_wells.ipynb index 22df84b..0456709 100755 --- a/docs/transient/02examples/connected_wells.ipynb +++ b/docs/transient/02examples/connected_wells.ipynb @@ -567,21 +567,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/02examples/horizontal_well.ipynb b/docs/transient/02examples/horizontal_well.ipynb index 0479efd..19f5983 100644 --- a/docs/transient/02examples/horizontal_well.ipynb +++ b/docs/transient/02examples/horizontal_well.ipynb @@ -162,21 +162,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/02examples/line_sink_well_sol.ipynb b/docs/transient/02examples/line_sink_well_sol.ipynb index b52c820..47aef4a 100755 --- a/docs/transient/02examples/line_sink_well_sol.ipynb +++ b/docs/transient/02examples/line_sink_well_sol.ipynb @@ -178,21 +178,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/02examples/meandering_river.ipynb b/docs/transient/02examples/meandering_river.ipynb index ae7d1ec..1d5347f 100644 --- a/docs/transient/02examples/meandering_river.ipynb +++ b/docs/transient/02examples/meandering_river.ipynb @@ -77,21 +77,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/02examples/well_in_multilayer_system.ipynb b/docs/transient/02examples/well_in_multilayer_system.ipynb index efae6a1..61aa8ed 100755 --- a/docs/transient/02examples/well_in_multilayer_system.ipynb +++ b/docs/transient/02examples/well_in_multilayer_system.ipynb @@ -224,21 +224,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/03xsections/1d_elements.ipynb b/docs/transient/03xsections/1d_elements.ipynb index 23f39ee..ab501cc 100644 --- a/docs/transient/03xsections/1d_elements.ipynb +++ b/docs/transient/03xsections/1d_elements.ipynb @@ -153,7 +153,7 @@ "outputs": [], "source": [ "mlconf = tft.ModelMaq(kaq=k, z=[0, -H], Saq=Ss, tmin=1e-3, tmax=1e3, topboundary=\"conf\")\n", - "ls = tft.DischargeLineSink1D(mlconf, tsandq=[(0, Q)], layers=[0])\n", + "ls = tft.LineSink1D(mlconf, tsandq=[(0, Q)], layers=[0])\n", "mlconf.solve()" ] }, @@ -200,7 +200,7 @@ "outputs": [], "source": [ "ml = tft.ModelMaq(kaq=k, z=[1, 0, -H], c=[10], tmin=1e-3, tmax=1e3, topboundary=\"semi\")\n", - "ls = tft.DischargeLineSink1D(ml, tsandq=[(0, Q)], layers=[0])\n", + "ls = tft.LineSink1D(ml, tsandq=[(0, Q)], layers=[0])\n", "ml.solve()" ] }, @@ -613,21 +613,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/03xsections/1d_given_linesink.ipynb b/docs/transient/03xsections/1d_given_linesink.ipynb index 8050d4d..89a0217 100755 --- a/docs/transient/03xsections/1d_given_linesink.ipynb +++ b/docs/transient/03xsections/1d_given_linesink.ipynb @@ -72,7 +72,7 @@ " topboundary=\"phreatic\",\n", ")\n", "\n", - "qls = tft.DischargeLineSink1D(\n", + "qls = tft.linesink1d.DischargeLineSink1D(\n", " mlconf,\n", " xls=0.0,\n", " tsandq=[(0, 1.0), (10.0, 2.0)],\n", @@ -147,21 +147,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/03xsections/1d_inhom_elements.ipynb b/docs/transient/03xsections/1d_inhom_elements.ipynb index ad99f96..dbb7ddb 100644 --- a/docs/transient/03xsections/1d_inhom_elements.ipynb +++ b/docs/transient/03xsections/1d_inhom_elements.ipynb @@ -20,6 +20,7 @@ "\n", "import timflow.steady as tfs\n", "import timflow.transient as tft\n", + "from timflow.transient.linesink1d import FluxDiffLineSink1D, HeadDiffLineSink1D\n", "\n", "plt.rcParams[\"figure.figsize\"] = (10, 4)" ] @@ -56,8 +57,8 @@ "hls_right = tft.River1D(mlconf, xls=200.0, tsandh=[(0, 0.0)], layers=[0])\n", "\n", "# headdiff on right side, fluxdiff on left side\n", - "hdiff = tft.HeadDiffLineSink1D(mlconf, xls=100.0 + 1e-12, layers=[0])\n", - "qdiff = tft.FluxDiffLineSink1D(mlconf, xls=100.0 - 1e-12, layers=[0])\n", + "hdiff = HeadDiffLineSink1D(mlconf, xls=100.0 + 1e-12, layers=[0])\n", + "qdiff = FluxDiffLineSink1D(mlconf, xls=100.0 - 1e-12, layers=[0])\n", "\n", "mlconf.solve()" ] @@ -618,21 +619,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/03xsections/stripareasink.ipynb b/docs/transient/03xsections/stripareasink.ipynb index da87ffa..53c0dc3 100644 --- a/docs/transient/03xsections/stripareasink.ipynb +++ b/docs/transient/03xsections/stripareasink.ipynb @@ -685,21 +685,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/confined1_oude_korendijk.ipynb b/docs/transient/04pumpingtests/confined1_oude_korendijk.ipynb index ea8b6b6..6633d96 100644 --- a/docs/transient/04pumpingtests/confined1_oude_korendijk.ipynb +++ b/docs/transient/04pumpingtests/confined1_oude_korendijk.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -92,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -105,18 +105,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "# timflow model\n", "ml = tft.ModelMaq(kaq=60, z=[zt, zb], Saq=1e-4, tmin=1e-5, tmax=1)\n", @@ -134,18 +125,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "................................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "# unknown parameters: kaq, Saq\n", "cal = tft.Calibrate(ml)\n", @@ -158,63 +140,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
optimal
kaq_0_066.088542
Saq_0_00.000025
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_0_0 66.088542\n", - "Saq_0_0 0.000025" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.050 m\n" - ] - } - ], + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -222,26 +150,9 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "hm1 = ml.head(ro1, 0, to1)\n", "hm2 = ml.head(ro2, 0, to2)\n", @@ -276,62 +187,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\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", - "
 k [m/d]Ss [1/m]RMSE [m]
timflow66.092.54e-050.050
MLU63.513.58e-050.833
K&dR55.711.70e-041.293
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE [m]\"],\n", @@ -373,21 +231,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/confined2_grindley.ipynb b/docs/transient/04pumpingtests/confined2_grindley.ipynb index 8572384..afb08f8 100644 --- a/docs/transient/04pumpingtests/confined2_grindley.ipynb +++ b/docs/transient/04pumpingtests/confined2_grindley.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -153,18 +153,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "ml = tft.ModelMaq(kaq=10, z=[0, -H], Saq=0.001, tmin=0.001, tmax=1, topboundary=\"conf\")\n", "w = tft.Well(ml, xw=0, yw=0, rw=rw, tsandQ=[(0, Q)], rc=rw, layers=0)\n", @@ -199,18 +190,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ".............................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "# unknown parameters: kaq, Saq\n", "cal = tft.Calibrate(ml) # create Calibrate object\n", @@ -225,63 +207,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
optimal
kaq_0_038.087051
Saq_0_00.000001
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_0_0 38.087051\n", - "Saq_0_0 0.000001" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.259 m\n" - ] - } - ], + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -289,26 +217,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "hm1 = ml.head(r, 0, to1)\n", "hm2 = w.headinside(to2)\n", @@ -353,56 +264,9 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 k [m/d]Ss [1/m]RMSE [m]
timflow38.091.19e-060.259
AQTESOLV22.953.72e-06-
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE [m]\"], index=[\"timflow\", \"AQTESOLV\"]\n", @@ -455,18 +319,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/confined3_sioux.ipynb b/docs/transient/04pumpingtests/confined3_sioux.ipynb index c35f31c..6a5530c 100644 --- a/docs/transient/04pumpingtests/confined3_sioux.ipynb +++ b/docs/transient/04pumpingtests/confined3_sioux.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -132,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -149,18 +149,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "# timflow model\n", "ml = tft.ModelMaq(kaq=10, z=[0, -b], Saq=0.001, tmin=0.001, tmax=10, topboundary=\"conf\")\n", @@ -183,18 +174,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "...............................................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "# unknown parameters: k, Saq\n", "cal = tft.Calibrate(ml)\n", @@ -208,63 +190,9 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
optimal
kaq_0_0282.795232
Saq_0_00.004209
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_0_0 282.795232\n", - "Saq_0_0 0.004209" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.004 m\n" - ] - } - ], + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -272,26 +200,9 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "hm1 = ml.head(r1, 0, t1)\n", "hm2 = ml.head(r2, 0, t2)\n", @@ -327,56 +238,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 k [m/d]Ss [1/m]RMSE [m]
timflow282.804.21e-030.004
AQTESOLV282.664.04e-03-
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE [m]\"], index=[\"timflow\", \"AQTESOLV\"]\n", @@ -435,18 +299,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/confined4_nevada.ipynb b/docs/transient/04pumpingtests/confined4_nevada.ipynb index 0d0bb94..07ad424 100644 --- a/docs/transient/04pumpingtests/confined4_nevada.ipynb +++ b/docs/transient/04pumpingtests/confined4_nevada.ipynb @@ -16,14 +16,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -74,14 +68,8 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "# time and drawdown of pumped well UE-25b#1\n", @@ -104,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -123,14 +111,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "# parameters calculated by Kruseman and de Ridder (1970)\n", @@ -140,24 +122,9 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "ml = tft.ModelMaq(\n", " kaq=[km, 1],\n", @@ -183,24 +150,9 @@ }, { "cell_type": "code", - "execution_count": 47, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ".........................................................................................................................................................................................................\n", - "Fit succeeded.\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "cal = tft.Calibrate(ml)\n", "cal.set_parameter(name=\"kaq\", initial=10, layers=1)\n", @@ -215,79 +167,9 @@ }, { "cell_type": "code", - "execution_count": 41, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\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", - "
optimal
kaq_1_10.877136
Saq_1_10.000005
c_1_112.912474
rc0.105678
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_1_1 0.877136\n", - "Saq_1_1 0.000005\n", - "c_1_1 12.912474\n", - "rc 0.105678" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.198 m\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -295,26 +177,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "hm1 = w.headinside(t1)\n", "hm2 = ml.head(r, 0, t2)\n", @@ -350,88 +215,9 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\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", - "
 km [m/d]Sm [1/m]kf [m/d]Sf [1/m]c [d]rc [m]RMSE [m]
timflow0.003.75e-040.885.07e-0612.910.110.198
AQTESOLV0.155.48e-040.941.95e-03-0.11-
MLU0.003.75e-040.848.05e-065.20--
K&dR0.833.75e-040.834.00e-06---
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\n", @@ -485,18 +271,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/leaky1_dalem.ipynb b/docs/transient/04pumpingtests/leaky1_dalem.ipynb index ba4c300..52b9a28 100644 --- a/docs/transient/04pumpingtests/leaky1_dalem.ipynb +++ b/docs/transient/04pumpingtests/leaky1_dalem.ipynb @@ -29,13 +29,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -92,13 +86,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "# data of observation well 30 m away from pumping well\n", @@ -138,13 +126,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "# known parameters\n", @@ -176,13 +158,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "# unkonwn parameters: kaq, Saq, c\n", @@ -210,13 +186,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "cal = tft.Calibrate(ml)\n", @@ -234,13 +204,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", @@ -250,13 +214,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "hm_1 = ml.head(r1, 0, t1)\n", @@ -299,13 +257,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "cal2 = tft.Calibrate(ml)\n", @@ -323,13 +275,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "display(cal2.parameters[[\"optimal\"]])\n", @@ -367,15 +313,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, + "metadata": {}, "outputs": [], "source": [ "t = pd.DataFrame(\n", @@ -429,18 +367,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/leaky2_hardixveld.ipynb b/docs/transient/04pumpingtests/leaky2_hardixveld.ipynb index 2de7e8e..27a3660 100644 --- a/docs/transient/04pumpingtests/leaky2_hardixveld.ipynb +++ b/docs/transient/04pumpingtests/leaky2_hardixveld.ipynb @@ -215,13 +215,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "tm = np.logspace(np.log10(to[0]), np.log10(to[-1]), 100)\n", @@ -272,15 +266,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, + "metadata": {}, "outputs": [], "source": [ "t = pd.DataFrame(\n", @@ -321,18 +307,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/leaky3_texashill.ipynb b/docs/transient/04pumpingtests/leaky3_texashill.ipynb index 4d1fffa..a4abfec 100644 --- a/docs/transient/04pumpingtests/leaky3_texashill.ipynb +++ b/docs/transient/04pumpingtests/leaky3_texashill.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -146,18 +146,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "ml = tft.ModelMaq(\n", " kaq=10,\n", @@ -189,18 +180,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "...................................................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "# unknown parameters: kaq, Saq, c\n", "cal = tft.Calibrate(ml)\n", @@ -215,74 +197,9 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
optimal
kaq_0_0224.627650
Saq_0_00.000213
c_0_043.880381
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_0_0 224.627650\n", - "Saq_0_0 0.000213\n", - "c_0_0 43.880381" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.060 m\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -290,20 +207,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# plot the fitted curves\n", "hm1_1 = ml.head(r1, 0, t1)\n", @@ -349,59 +255,9 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\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", - "
 k [m/d]Ss [1/m]c [d]RMSE [m]
timflow224.632.13e-0443.880.060
AQTESOLV224.722.12e-0444.00-
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"c [d]\", \"RMSE [m]\"],\n", @@ -445,18 +301,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/slug1_pratt_county.ipynb b/docs/transient/04pumpingtests/slug1_pratt_county.ipynb index 85862eb..89fdb58 100644 --- a/docs/transient/04pumpingtests/slug1_pratt_county.ipynb +++ b/docs/transient/04pumpingtests/slug1_pratt_county.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -96,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -120,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -148,17 +148,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "volume of slug: 0.00863 m^3\n" - ] - } - ], + "outputs": [], "source": [ "Q = np.pi * rc**2 * H0 # instantaneous discharge\n", "print(f\"volume of slug: {Q:.5f} m^3\")" @@ -180,18 +172,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "ml = tft.Model3D(kaq=10, z=[0, zt, zb, -b], Saq=1e-4, kzoverkh=1, tmin=1e-6, tmax=0.01)\n", "w = tft.Well(ml, xw=0, yw=0, rw=rw, rc=rc, tsandQ=[(0, -Q)], layers=1, wbstype=\"slug\")\n", @@ -214,18 +197,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ".......................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "cal = tft.Calibrate(ml)\n", "cal.set_parameter(name=\"kaq\", layers=[0, 1, 2], initial=10)\n", @@ -236,69 +210,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
optimal
kaq_0_26.048673
Saq_0_20.000213
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_0_2 6.048673\n", - "Saq_0_2 0.000213" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.003 m\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -306,20 +220,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "tm = np.logspace(np.log10(to[0]), np.log10(to[-1]), 100)\n", "hm = ml.head(0, 0, tm, layers=1)\n", @@ -361,56 +264,9 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 k [m/d]Ss [1/m]RMSE [m]
timflow6.052.13e-040.0029
AQTESOLV4.033.83e-040.0030
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE [m]\"],\n", @@ -455,18 +311,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/slug2_multiwell.ipynb b/docs/transient/04pumpingtests/slug2_multiwell.ipynb index f59d806..be3d4e5 100644 --- a/docs/transient/04pumpingtests/slug2_multiwell.ipynb +++ b/docs/transient/04pumpingtests/slug2_multiwell.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -140,17 +140,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Slug: 0.02286 m^3\n" - ] - } - ], + "outputs": [], "source": [ "Q = np.pi * rc1**2 * H0\n", "print(f\"Slug: {Q:.5f} m^3\")" @@ -158,18 +150,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "ml = tft.ModelMaq(kaq=10, z=[0, -b], Saq=1e-4, tmin=1e-5, tmax=0.01)\n", "w = tft.Well(ml, xw=0, yw=0, rw=rw1, rc=rc1, tsandQ=[(0, -Q)], layers=0, wbstype=\"slug\")\n", @@ -192,18 +175,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "...........................................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "# unknown parameters: kaq, Saq\n", "cal = tft.Calibrate(ml)\n", @@ -216,69 +190,9 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
optimal
kaq_0_01.166109
Saq_0_00.000009
\n", - "
" - ], - "text/plain": [ - " optimal\n", - "kaq_0_0 1.166109\n", - "Saq_0_0 0.000009" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "RMSE: 0.010 m\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", "print(f\"RMSE: {cal.rmse():.3f} m\")" @@ -286,20 +200,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "hm1 = w.headinside(t1)\n", "hm2 = ml.head(r, 0, t2, layers=0)\n", @@ -331,62 +234,9 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\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", - "
 k [m/d]Ss [1/m]RMSE [m]
timflow1.179.38e-060.010
AQTESOLV1.179.37e-06-
MLU1.318.20e-06-
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE [m]\"],\n", @@ -438,18 +288,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/slug3_falling_head.ipynb b/docs/transient/04pumpingtests/slug3_falling_head.ipynb index b9d5618..c33ce67 100644 --- a/docs/transient/04pumpingtests/slug3_falling_head.ipynb +++ b/docs/transient/04pumpingtests/slug3_falling_head.ipynb @@ -186,13 +186,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "display(cal.parameters.loc[:, [\"optimal\"]])\n", @@ -227,15 +221,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, + "metadata": {}, "outputs": [], "source": [ "t = pd.DataFrame(\n", @@ -276,21 +262,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/slug4_dawsonville.ipynb b/docs/transient/04pumpingtests/slug4_dawsonville.ipynb index 531d22e..312fc06 100644 --- a/docs/transient/04pumpingtests/slug4_dawsonville.ipynb +++ b/docs/transient/04pumpingtests/slug4_dawsonville.ipynb @@ -22,14 +22,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -80,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -104,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -119,18 +113,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "self.neq 1\n", - "solution complete\n" - ] - } - ], + "outputs": [], "source": [ "ml = tft.ModelMaq(kaq=10, z=[zt, zb], Saq=1e-4, tmin=1e-6, tmax=1e-3, topboundary=\"conf\")\n", "w = tft.Well(ml, xw=0, yw=0, rw=rw, rc=rc, tsandQ=[(0, -Q)], layers=0, wbstype=\"slug\")\n", @@ -148,18 +133,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "..............................\n", - "Fit succeeded.\n" - ] - } - ], + "outputs": [], "source": [ "# unknown parameters: kay, Saq\n", "cal = tft.Calibrate(ml)\n", @@ -171,91 +147,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\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", - "
layersoptimalstdperc_stdpminpmaxinitialinhomsparray
kaq0_0_000.4209120.0184044.3724980.0inf10.0000None[[0.4209121893500565]]
Saq0_0_000.0000170.00000531.179338-infinf0.0001None[[1.700498848737957e-05]]
\n", - "
" - ], - "text/plain": [ - " layers optimal std perc_std pmin pmax initial inhoms \\\n", - "kaq0_0_0 0 0.420912 0.018404 4.372498 0.0 inf 10.0000 None \n", - "Saq0_0_0 0 0.000017 0.000005 31.179338 -inf inf 0.0001 None \n", - "\n", - " parray \n", - "kaq0_0_0 [[0.4209121893500565]] \n", - "Saq0_0_0 [[1.700498848737957e-05]] " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rmse: 0.004409555968801705\n" - ] - } - ], + "outputs": [], "source": [ "display(cal.parameters)\n", "print(\"rmse:\", cal.rmse())" @@ -263,20 +157,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "tm = np.logspace(np.log10(to[0]), np.log10(to[-1]), 100)\n", "hm = ml.head(0, 0, tm)\n", @@ -300,56 +183,9 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 k [m/d]Ss [1/m]RMSE [m]
timflow0.421.70e-050.004
MLU0.411.94e-050.004
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "t = pd.DataFrame(\n", " columns=[\"k [m/d]\", \"Ss [1/m]\", \"RMSE [m]\"],\n", @@ -390,18 +226,6 @@ "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.13.3" } }, "nbformat": 4, diff --git a/docs/transient/04pumpingtests/unconfined1_moench.ipynb b/docs/transient/04pumpingtests/unconfined1_moench.ipynb index 35dd314..3afd4a5 100644 --- a/docs/transient/04pumpingtests/unconfined1_moench.ipynb +++ b/docs/transient/04pumpingtests/unconfined1_moench.ipynb @@ -17,13 +17,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -219,15 +213,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "hide-input" - ] - }, + "metadata": {}, "outputs": [], "source": [ "t = pd.DataFrame(\n", @@ -263,21 +249,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/05benchmarks/river1d.ipynb b/docs/transient/05benchmarks/river1d.ipynb index f37d915..7a7e7ad 100644 --- a/docs/transient/05benchmarks/river1d.ipynb +++ b/docs/transient/05benchmarks/river1d.ipynb @@ -335,21 +335,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/05benchmarks/ttim_neuman_comparison.ipynb b/docs/transient/05benchmarks/ttim_neuman_comparison.ipynb index e2cc48a..d7b9164 100644 --- a/docs/transient/05benchmarks/ttim_neuman_comparison.ipynb +++ b/docs/transient/05benchmarks/ttim_neuman_comparison.ipynb @@ -118,21 +118,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/05benchmarks/validation_tidal_wave_with_Bruggeman.ipynb b/docs/transient/05benchmarks/validation_tidal_wave_with_Bruggeman.ipynb index 7a6d2fc..7e9cbd5 100644 --- a/docs/transient/05benchmarks/validation_tidal_wave_with_Bruggeman.ipynb +++ b/docs/transient/05benchmarks/validation_tidal_wave_with_Bruggeman.ipynb @@ -500,21 +500,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/05benchmarks/well_near_leaky_river.ipynb b/docs/transient/05benchmarks/well_near_leaky_river.ipynb index 7e5a273..0e2a743 100644 --- a/docs/transient/05benchmarks/well_near_leaky_river.ipynb +++ b/docs/transient/05benchmarks/well_near_leaky_river.ipynb @@ -195,21 +195,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/docs/transient/05benchmarks/well_near_river_or_wall.ipynb b/docs/transient/05benchmarks/well_near_river_or_wall.ipynb index 0ec8453..2bb9b82 100644 --- a/docs/transient/05benchmarks/well_near_river_or_wall.ipynb +++ b/docs/transient/05benchmarks/well_near_river_or_wall.ipynb @@ -128,21 +128,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "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.13.5" } }, "nbformat": 4, diff --git a/tests/steady/test_well.py b/tests/steady/test_well.py index 14d9c3e..2e86cef 100644 --- a/tests/steady/test_well.py +++ b/tests/steady/test_well.py @@ -6,7 +6,7 @@ def test_wellstring_layers_int(): # int ml = tfs.Model3D(z=[0, -1, -2, -3]) - ws = tfs.WellStringBase(ml, [(0, 0), (10, 0), (0, 10)], layers=2) + ws = tfs.well.WellStringBase(ml, [(0, 0), (10, 0), (0, 10)], layers=2) assert (ws.layers == 2).all() assert ws.layers.shape[0] == 3 assert ws.nlayers == 1 @@ -15,7 +15,7 @@ def test_wellstring_layers_int(): def test_wellstring_layers_list(): # list ml = tfs.Model3D(z=[0, -1, -2, -3]) - ws = tfs.WellStringBase(ml, [(0, 0), (10, 0), (0, 10)], layers=[1, 2]) + ws = tfs.well.WellStringBase(ml, [(0, 0), (10, 0), (0, 10)], layers=[1, 2]) assert (ws.layers == np.array([[1, 2], [1, 2], [1, 2]])).all() assert ws.nlayers == 2 @@ -23,7 +23,7 @@ def test_wellstring_layers_list(): def test_wellstring_layers_list_of_tuples(): # list of differently sized tuples ml = tfs.Model3D(z=[0, -1, -2, -3]) - ws = tfs.WellStringBase( + ws = tfs.well.WellStringBase( ml, [(0, 0), (10, 0), (0, 10)], layers=[(0, 1, 2), (2, 3), (3,)] ) assert ws.layers == [(0, 1, 2), (2, 3), (3,)] @@ -33,7 +33,7 @@ def test_wellstring_layers_list_of_tuples(): def test_wellstring_layers_1d_array(): # 1d array ml = tfs.Model3D(z=[0, -1, -2, -3]) - ws = tfs.WellStringBase(ml, [(0, 0), (10, 0), (0, 10)], layers=np.arange(1, 4)) + ws = tfs.well.WellStringBase(ml, [(0, 0), (10, 0), (0, 10)], layers=np.arange(1, 4)) assert (ws.layers == np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])).all() assert ws.nlayers == 3 @@ -41,7 +41,7 @@ def test_wellstring_layers_1d_array(): def test_wellstring_layers_2d_array(): # 2d array ml = tfs.Model3D(z=[0, -1, -2, -3]) - ws = tfs.WellStringBase( + ws = tfs.well.WellStringBase( ml, [(0, 0), (10, 0), (0, 10)], layers=np.arange(1, 7).reshape((3, 2)) ) assert (ws.layers == np.arange(1, 7).reshape((3, 2))).all() From d4ba7d617a9ec8f3cf84cc7d25364662a64f7e1d Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Tue, 12 May 2026 15:40:22 +0200 Subject: [PATCH 07/12] sort xsection coordinates prior to gap check --- timflow/transient/model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/timflow/transient/model.py b/timflow/transient/model.py index 73290f2..acf3c17 100644 --- a/timflow/transient/model.py +++ b/timflow/transient/model.py @@ -1096,8 +1096,8 @@ def check_inhoms(self): if not check.all(): raise ValueError(f"Number of aquifers does not match {self.aq.naq}:\n{naqs}") # check -inf to inf - x1list = np.array([inhom.x1 for inhom in self.aq.inhomdict.values()]) - x2list = np.array([inhom.x2 for inhom in self.aq.inhomdict.values()]) + x1list = np.sort([inhom.x1 for inhom in self.aq.inhomdict.values()]) + x2list = np.sort([inhom.x2 for inhom in self.aq.inhomdict.values()]) xmin = x1list.min() xmax = x2list.max() if not (np.isinf(xmin) and np.sign(xmin) < 0): From 11947627876d9bb0bd3c7c2d1a292994c660ed4d Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Thu, 14 May 2026 13:18:07 +0200 Subject: [PATCH 08/12] improve coordinate checks for Xsections that may span to infinity --- timflow/transient/inhom1d.py | 35 ++++++++++++++---------------- timflow/transient/stripareasink.py | 13 +++++++++-- 2 files changed, 27 insertions(+), 21 deletions(-) diff --git a/timflow/transient/inhom1d.py b/timflow/transient/inhom1d.py index ee2f401..ea73ccc 100644 --- a/timflow/transient/inhom1d.py +++ b/timflow/transient/inhom1d.py @@ -162,11 +162,22 @@ def initialize(self): def create_elements(self): """Create linesinks to meet the continuity conditions the at the boundaries.""" - if (self.x1 == -np.inf) and (self.x2 == np.inf): - # no reason to add elements - pass + if np.isfinite(self.x1) and np.isfinite(self.x2): + xin = 0.5 * (self.x1 + self.x2) + # xoutleft = self.x1 - self.tiny + # xoutright = self.x2 + self.tiny + aqin = self.model.aq.find_aquifer_data(xin, 0) + # aqleft = self.model.aq.find_aquifer_data(xoutleft, 0) + # aqright = self.model.aq.find_aquifer_data(xoutright, 0) + if self.addlinesinks: + HeadDiffLineSink1D( + self.model, self.x2, range(self.naq), label=None, aq=aqin + ) + FluxDiffLineSink1D( + self.model, self.x1, range(self.naq), label=None, aq=aqin + ) # HeadDiff on right side, FluxDiff on left side - elif self.x1 == -np.inf: + elif np.isneginf(self.x1): xin = self.x2 - self.tiny # xoutright = self.x2 + self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) @@ -179,7 +190,7 @@ def create_elements(self): aq=aqin, label=None, ) - elif self.x2 == np.inf: + elif np.isposinf(self.x2): xin = self.x1 + self.tiny # xoutleft = self.x1 - self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) @@ -188,20 +199,6 @@ def create_elements(self): FluxDiffLineSink1D( self.model, self.x1, range(self.naq), aq=aqin, label=None ) - else: - xin = 0.5 * (self.x1 + self.x2) - # xoutleft = self.x1 - self.tiny - # xoutright = self.x2 + self.tiny - aqin = self.model.aq.find_aquifer_data(xin, 0) - # aqleft = self.model.aq.find_aquifer_data(xoutleft, 0) - # aqright = self.model.aq.find_aquifer_data(xoutright, 0) - if self.addlinesinks: - HeadDiffLineSink1D( - self.model, self.x2, range(self.naq), label=None, aq=aqin - ) - FluxDiffLineSink1D( - self.model, self.x1, range(self.naq), label=None, aq=aqin - ) if self.tsandN is not None: assert self.topboundary[:3] == "con" or self.topboundary[:3] == "phr", ( Exception("Infiltration can only be applied to a confined aquifer.") diff --git a/timflow/transient/stripareasink.py b/timflow/transient/stripareasink.py index 66f7eb9..5445d70 100644 --- a/timflow/transient/stripareasink.py +++ b/timflow/transient/stripareasink.py @@ -44,7 +44,14 @@ def __repr__(self): return f"{self.__class__.__name__}: " + str([self.x1, self.x2]) def initialize(self): - self.xc = (self.x1 + self.x2) / 2.0 + if np.isfinite(self.x1) and np.isfinite(self.x2): + self.xc = (self.x1 + self.x2) / 2.0 + elif np.isneginf(self.x1): + self.xc = self.x2 - 1e-5 + elif np.isposinf(self.x2): + self.xc = self.x1 + 1e-5 + else: + self.xc = 0.0 self.L = np.abs(self.x2 - self.x1) self.aq = self.model.aq.find_aquifer_data(self.xc, 0.0) self.setbc() @@ -128,12 +135,14 @@ def __repr__(self): return f"{self.__class__.__name__}: " + str([self.x1, self.x2]) def initialize(self): + if np.isfinite(self.x1) and np.isfinite(self.x2): + self.xc = (self.x1 + self.x2) / 2.0 if not np.isfinite(self.x1): self.xc = self.x2 - 1e-5 elif not np.isfinite(self.x2): self.xc = self.x1 + 1e-5 else: - self.xc = (self.x1 + self.x2) / 2.0 + self.xc = 0.0 self.L = np.abs(self.x2 - self.x1) self.aq = self.model.aq.find_aquifer_data(self.xc, 0.0) self.setbc() From 1e6d44fc7d82a209291f4ffbd9d414f118fcdaf4 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Thu, 14 May 2026 13:18:29 +0200 Subject: [PATCH 09/12] add check method to ModelXsection that checks for elements on boundaries --- timflow/transient/model.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/timflow/transient/model.py b/timflow/transient/model.py index acf3c17..9b43d54 100644 --- a/timflow/transient/model.py +++ b/timflow/transient/model.py @@ -1135,6 +1135,28 @@ def check_inhoms(self): # if not np.all(np.diff(xcoords[1:-1])[::2] < 1e-10): # raise ValueError("Not all inhomogeneities have shared boundaries.") + def check_elements(self): + """Check elements. + + Checks that no elements are located exactly on the boundaries between + inhomogeneities. + """ + x1list = np.sort([inhom.x1 for inhom in self.aq.inhomdict.values()]) + x2list = np.sort([inhom.x2 for inhom in self.aq.inhomdict.values()]) + elements = [e for e in self.elementlist if not e.inhomelement] + mask = np.isin([e.xc.squeeze() for e in elements], x1list) | np.isin( + [e.xc.squeeze() for e in elements], x2list + ) + if mask.any(): + elems = [str(e) for e, m in zip(elements, mask, strict=True) if m] + raise ValueError( + "Elements cannot be located exactly on the boundaries between " + "inhomogeneities.\nConsider nudging the location(s) of the following " + "element(s) (by e.g. 1e-6):\n- " + + "\n- ".join(elems) + ) + def initialize(self): self.check_inhoms() super().initialize() + self.check_elements() From 0817e907afac84e744e4dea233a394c5db2f7c48 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Thu, 14 May 2026 13:31:34 +0200 Subject: [PATCH 10/12] ruff and make nudge smaller --- docs/transient/03xsections/1d_inhom_elements.ipynb | 2 +- timflow/transient/model.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/transient/03xsections/1d_inhom_elements.ipynb b/docs/transient/03xsections/1d_inhom_elements.ipynb index dbb7ddb..c68961e 100644 --- a/docs/transient/03xsections/1d_inhom_elements.ipynb +++ b/docs/transient/03xsections/1d_inhom_elements.ipynb @@ -392,7 +392,7 @@ " topboundary=\"phreatic\",\n", ")\n", "\n", - "d = -1e-3\n", + "d = -1e-6\n", "hls_left = tft.River1D(mlconf, xls=-L / 2 + d, tsandh=[(0, 0.0)], layers=[0])\n", "hls_right = tft.River1D(mlconf, xls=L / 2 - d, tsandh=[(0, 0.0)], layers=[0])\n", "\n", diff --git a/timflow/transient/model.py b/timflow/transient/model.py index 9b43d54..26cf079 100644 --- a/timflow/transient/model.py +++ b/timflow/transient/model.py @@ -1152,8 +1152,7 @@ def check_elements(self): raise ValueError( "Elements cannot be located exactly on the boundaries between " "inhomogeneities.\nConsider nudging the location(s) of the following " - "element(s) (by e.g. 1e-6):\n- " - + "\n- ".join(elems) + "element(s) (by e.g. 1e-6):\n- " + "\n- ".join(elems) ) def initialize(self): From 2b5b3f63cebcde866cdbd954f9845e728f21b9e3 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Thu, 14 May 2026 13:43:28 +0200 Subject: [PATCH 11/12] forgot some checks in the if statement --- timflow/transient/inhom1d.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/timflow/transient/inhom1d.py b/timflow/transient/inhom1d.py index ea73ccc..0c3cb4e 100644 --- a/timflow/transient/inhom1d.py +++ b/timflow/transient/inhom1d.py @@ -177,7 +177,7 @@ def create_elements(self): self.model, self.x1, range(self.naq), label=None, aq=aqin ) # HeadDiff on right side, FluxDiff on left side - elif np.isneginf(self.x1): + elif np.isneginf(self.x1) and not np.isposinf(self.x2): xin = self.x2 - self.tiny # xoutright = self.x2 + self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) @@ -190,7 +190,7 @@ def create_elements(self): aq=aqin, label=None, ) - elif np.isposinf(self.x2): + elif np.isposinf(self.x2) and not np.isneginf(self.x1): xin = self.x1 + self.tiny # xoutleft = self.x1 - self.tiny aqin = self.model.aq.find_aquifer_data(xin, 0) From ffc42b7271210bcea129495b05017f7e74282719 Mon Sep 17 00:00:00 2001 From: dbrakenhoff Date: Thu, 14 May 2026 14:48:52 +0200 Subject: [PATCH 12/12] attempt to speed up some notebooks --- docs/transient/02examples/line_sink_well_sol.ipynb | 1 + docs/transient/02examples/well_near_wall.ipynb | 2 +- docs/transient/03xsections/river_in_cross_section.ipynb | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/transient/02examples/line_sink_well_sol.ipynb b/docs/transient/02examples/line_sink_well_sol.ipynb index 47aef4a..cc224eb 100755 --- a/docs/transient/02examples/line_sink_well_sol.ipynb +++ b/docs/transient/02examples/line_sink_well_sol.ipynb @@ -118,6 +118,7 @@ " labels=True,\n", " decimals=2,\n", " ax=ax,\n", + " parallel=True,\n", " )\n", " ax.set_aspect(\"equal\", adjustable=\"box\")" ] diff --git a/docs/transient/02examples/well_near_wall.ipynb b/docs/transient/02examples/well_near_wall.ipynb index af4c2e4..1918870 100644 --- a/docs/transient/02examples/well_near_wall.ipynb +++ b/docs/transient/02examples/well_near_wall.ipynb @@ -103,7 +103,7 @@ "metadata": {}, "outputs": [], "source": [ - "ml2.contour(win=[-30, 50, -10, 30], ngr=40, t=1, decimals=2);" + "ml2.plots.contour(win=[-30, 50, -10, 30], ngr=40, t=1, decimals=2, parallel=True);" ] } ], diff --git a/docs/transient/03xsections/river_in_cross_section.ipynb b/docs/transient/03xsections/river_in_cross_section.ipynb index 375fa94..aad86a4 100644 --- a/docs/transient/03xsections/river_in_cross_section.ipynb +++ b/docs/transient/03xsections/river_in_cross_section.ipynb @@ -529,7 +529,7 @@ ")\n", "\n", "# run the calibration\n", - "cal.fit(report=False)\n", + "cal.fit(report=False, xtol=1e-4, ftol=1e-4)\n", "# cal.fit_least_squares(report=False, method=\"trf\")\n", "\n", "# print the RMSE\n",