diff --git a/docs/advanced/index.md b/docs/advanced/index.md index e83b680e..c9e9a5e6 100644 --- a/docs/advanced/index.md +++ b/docs/advanced/index.md @@ -38,6 +38,11 @@ Dynamic remeshing and adaptive refinement strategies. **[→ Mesh Adaptation](mesh-adaptation.md)** +### Porous Media Flow +Darcy flow, Richards equation, and variably-saturated groundwater modelling. + +**[→ Porous Media Flow](porous-flow.md)** + ### Troubleshooting Common issues, debugging strategies, and solutions. @@ -72,6 +77,7 @@ complex-rheologies custom-meshes curved-boundary-conditions mesh-adaptation +porous-flow troubleshooting api-patterns SWARM-INTEGRATION-STATISTICS diff --git a/docs/advanced/porous-flow.md b/docs/advanced/porous-flow.md new file mode 100644 index 00000000..e3219009 --- /dev/null +++ b/docs/advanced/porous-flow.md @@ -0,0 +1,299 @@ +--- +title: "Porous Media Flow" +--- + +# Porous Media Flow + +Underworld3 provides a hierarchy of solvers for groundwater and variably-saturated +porous media flow. This guide explains when to use each solver, how to configure +retention curves, and practical tips for nonlinear convergence. + +## Solver Hierarchy + +Three solvers are available, each building on the previous one: + +| Solver | Equation | Use case | +|--------|----------|----------| +| {class}`~underworld3.systems.solvers.SNES_Darcy` | $-\nabla\cdot[K\nabla h - \mathbf{s}] = f$ | Steady-state, fully saturated | +| {class}`~underworld3.systems.solvers.SNES_TransientDarcy` | $S_s\,\partial h/\partial t - \nabla\cdot[K\nabla h - \mathbf{s}] = f$ | Transient, constant storage | +| {class}`~underworld3.systems.solvers.SNES_Richards` | $\partial\theta/\partial t - \nabla\cdot[K(\psi)(\nabla\psi - \mathbf{s})] = f$ | Variably-saturated, nonlinear | + +All three use the `DarcyFlowModel` constitutive model, which defines +permeability $K$ and a gravity-like source vector $\mathbf{s}$. + +### Choosing a Solver + +- **Steady-state, constant permeability** — use `SteadyStateDarcy` (alias for `SNES_Darcy`). + No time stepping needed; just call `solve()`. +- **Transient, constant storage** — use `TransientDarcy`. + Set `solver.storage` to the specific storage coefficient $S_s$ and advance with + `solve(timestep=dt)`. +- **Variably-saturated** — use `Richards`. + Permeability and storage depend nonlinearly on pressure head $\psi$. + This solver handles the stiff nonlinearities arising from soil-water retention curves. + +Python access: + +```python +import underworld3 as uw + +darcy = uw.systems.SteadyStateDarcy(mesh, h_Field=h, v_Field=v) +transient = uw.systems.TransientDarcy(mesh, h_Field=h, v_Field=v, order=1) +richards = uw.systems.Richards(mesh, psi_Field=psi, v_Field=v, order=1) +``` + +## Retention Curves + +The Richards equation requires soil-water retention curves that describe how +moisture content $\theta$ and hydraulic conductivity $K$ vary with +pressure head $\psi$. + +Underworld3 provides three models in +{mod}`underworld3.utilities.retention_curves`: + +### Van Genuchten--Mualem + +The most widely used model in hydrology. Parameters: $\alpha$, $n$, $K_s$, +$\theta_r$, $\theta_s$. + +```python +from underworld3.utilities.retention_curves import ( + van_genuchten_K, + van_genuchten_theta, +) + +psi_sym = psi.sym[0] + +K_expr = van_genuchten_K(psi_sym, Ks=1e-4, alpha=3.35, n=2.0) +theta_expr = van_genuchten_theta( + psi_sym, theta_r=0.045, theta_s=0.43, alpha=3.35, n=2.0 +) +``` + +Typical parameter ranges (SI units, $\psi$ in metres): + +| Soil type | $\alpha$ (1/m) | $n$ | $K_s$ (m/s) | $\theta_r$ | $\theta_s$ | +|-----------|----------------|-----|-------------|-------------|-------------| +| Sand | 14.5 | 2.68 | $8.25 \times 10^{-5}$ | 0.045 | 0.43 | +| Loam | 3.6 | 1.56 | $2.89 \times 10^{-6}$ | 0.078 | 0.43 | +| Clay | 0.8 | 1.09 | $5.56 \times 10^{-7}$ | 0.068 | 0.38 | + +### Gardner Exponential + +A simpler model with an analytical steady-state solution — ideal for +verification: + +$$K(\psi) = K_s \, e^{\alpha\psi}$$ + +```python +from underworld3.utilities.retention_curves import ( + gardner_K, + gardner_theta, + gardner_steady_state_psi, +) + +K_expr = gardner_K(psi_sym, Ks=1.0, alpha=2.0) +theta_expr = gardner_theta(psi_sym, theta_r=0.05, theta_s=0.4, alpha=2.0) + +# Exact steady-state profile for benchmarking +psi_exact = gardner_steady_state_psi(y_coords, psi_0=-3.0, psi_L=-0.5, L=1.0, alpha=2.0) +``` + +### Haverkamp + +A rational-function model where retention ($\alpha$, $\beta$) and +conductivity ($A$, $B$) have **independent** parameters, giving extra +flexibility when fitting laboratory data. Used in the +Vauclin (1979) water-table recharge benchmark. + +$$\theta(\psi) = \theta_r + \frac{\alpha\,(\theta_s - \theta_r)}{\alpha + |\psi|^{\beta}}, +\qquad +K(\psi) = K_s\,\frac{A}{A + |\psi|^B}$$ + +```python +from underworld3.utilities.retention_curves import ( + haverkamp_K, + haverkamp_theta, + haverkamp_C, +) + +# Vauclin (1979) benchmark parameters (CGS, ψ in cm) +K_expr = haverkamp_K(psi_sym, Ks=9.44e-5, A=1.175e6, B=4.74) +theta_expr = haverkamp_theta( + psi_sym, theta_r=0.075, theta_s=0.287, alpha=1.611e6, beta=3.96 +) +``` + +### Choosing a Retention Model + +| Model | Strengths | Typical use | +|-------|-----------|-------------| +| Van Genuchten--Mualem | Widely validated, coupled $K$--$\theta$ | General-purpose simulations | +| Gardner exponential | Admits analytical solutions | Verification benchmarks | +| Haverkamp | Independent $K$ and $\theta$ params | Lab data fitting, Vauclin benchmark | + +## Setting Up a Richards Solver + +### Mixed Form (Recommended) + +The **mixed form** discretises the storage term as +$(\theta(\psi^{n+1}) - \theta(\psi^n))/\Delta t$, which is exactly +mass-conservative. This is the preferred approach. + +```python +richards = uw.systems.Richards(mesh, psi_Field=psi, v_Field=v, order=1, theta=0.5) + +# Constitutive model (permeability + gravity) +richards.constitutive_model = uw.constitutive_models.DarcyFlowModel +richards.constitutive_model.Parameters.permeability = van_genuchten_K( + psi.sym[0], Ks=1e-4, alpha=3.35, n=2.0 +) +richards.constitutive_model.Parameters.s = sympy.Matrix([0, -1]).T + +# Mixed form: provide θ(ψ) directly +richards.water_content = van_genuchten_theta( + psi.sym[0], theta_r=0.045, theta_s=0.43, alpha=3.35, n=2.0 +) + +# Source term +richards.f = 0.0 +``` + +When `water_content` is set, the solver computes the Jacobian +$\partial\theta/\partial\psi = C(\psi)$ automatically via PETSc's +finite-difference colouring. You do **not** need to provide $C(\psi)$ +separately. + +### Head-Based Form (Backward Compatible) + +The head-based form discretises the storage as +$C(\psi)(\psi^{n+1} - \psi^n)/\Delta t$. This is simpler but not +mass-conservative when $C(\psi)$ varies sharply. + +```python +from underworld3.utilities.retention_curves import van_genuchten_C + +richards.capacity = van_genuchten_C( + psi.sym[0], theta_r=0.045, theta_s=0.43, alpha=3.35, n=2.0 +) +``` + +If both `water_content` and `capacity` are set, the mixed form takes precedence. + +## Time Stepping + +All transient porous flow solvers use BDF (Backward Differentiation Formula) +time integration with automatic order ramping: + +```python +# First call: BDF-1 (backward Euler) +richards.solve(timestep=dt) + +# Second call onwards: BDF-2 (if order=2 was requested) +richards.solve(timestep=dt) +``` + +The solver automatically: +- Initialises time-derivative history on the first solve call +- Ramps BDF order from 1 up to the requested `order` +- Tracks variable timesteps for correct BDF coefficients + +### Timestep Estimation + +`TransientDarcy` and `Richards` provide a diffusive CFL estimate: + +```python +dt = richards.estimate_dt() +``` + +For the Richards equation with strongly nonlinear retention curves, +you may need to use a smaller timestep than this estimate, especially +near wetting fronts. + +## Convergence Tips + +The Richards equation with Van Genuchten curves is a **stiff nonlinear problem**. +Here are practical strategies for reliable convergence: + +### 1. Use Backtracking Line Search + +```python +richards.petsc_options["snes_linesearch_type"] = "bt" +``` + +The backtracking line search (default is `basic`) helps SNES find a +descent direction when the initial Newton step overshoots. + +### 2. Increase SNES Iterations + +```python +richards.petsc_options["snes_max_it"] = 50 # default is 20 +``` + +Nonlinear problems near saturation may need more iterations. + +### 3. Start From a Smooth Initial Condition + +A linear profile between boundary values is a good starting guess: + +```python +y = mesh.X[1] +psi_init = psi_bottom + (psi_top - psi_bottom) * y +psi.array = uw.function.evaluate(psi_init, psi.coords) +``` + +Abrupt initial conditions (e.g., step functions) cause convergence +difficulties. + +### 4. Use Small Timesteps Initially + +Start with small $\Delta t$ and increase gradually, especially when +wetting fronts are developing: + +```python +dt = 0.001 +for step in range(n_steps): + richards.solve(timestep=dt) + dt = min(dt * 1.2, dt_max) # gradual increase +``` + +### 5. Monitor Convergence + +```python +richards.petsc_options["snes_monitor"] = None +richards.petsc_options["snes_converged_reason"] = None +``` + +## Boundary Conditions + +Boundary conditions follow the standard Underworld3 pattern: + +```python +# Fixed head / pressure head (Dirichlet) +richards.add_dirichlet_bc([0.0], "Top") # saturated surface +richards.add_dirichlet_bc([-5.0], "Bottom") # deep water table + +# Natural (Neumann) boundary conditions are set via richards.f +# and the constitutive model's flux term +``` + +For the Richards equation, typical boundary conditions are: +- **Saturated surface**: $\psi = 0$ (water table at the surface) +- **Deep dry condition**: $\psi = \psi_{\mathrm{init}}$ (initial pressure head) +- **No-flow boundaries**: Natural BC (the default on boundaries without Dirichlet conditions) + +## Tutorials + +For worked examples with complete code: + +- [Tutorial 16 — Richards Equation: Groundwater](../beginner/tutorials/16-Richards-Equation-Groundwater.ipynb): + Steady-state drainage with Gardner curves, comparison to analytical solution. +- [Tutorial 17 — Richards: Transient Wetting Front](../beginner/tutorials/17-Richards-Transient-Wetting-Front.ipynb): + Transient infiltration with Van Genuchten curves, wetting front propagation. + +## API Reference + +- {class}`~underworld3.systems.solvers.SNES_Darcy` — Steady-state Darcy +- {class}`~underworld3.systems.solvers.SNES_TransientDarcy` — Transient Darcy +- {class}`~underworld3.systems.solvers.SNES_Richards` — Richards equation +- {mod}`underworld3.utilities.retention_curves` — Retention curve functions diff --git a/docs/beginner/parameters.md b/docs/beginner/parameters.md index 1d18e301..563791dc 100644 --- a/docs/beginner/parameters.md +++ b/docs/beginner/parameters.md @@ -16,16 +16,25 @@ This makes scripts portable between interactive development and HPC batch execut ## Basic Usage +The recommended pattern is to define default values as **named constants** before +the `uw.Params` block. This separates "what are the defaults" (easy to find and +edit in a notebook) from "how are they validated and overridden" (the `uw.Params` +machinery). + ```python import underworld3 as uw -# Define parameters with defaults +# --- Default values (edit these in a notebook) --- +RESOLUTION = 0.05 # cell size for mesh +DIFFUSIVITY = 1.0 # material property +MAX_STEPS = 100 # solver iterations + params = uw.Params( - uw_resolution = 0.05, # Cell size for mesh - uw_diffusivity = 1.0, # Material property - uw_max_steps = 100, # Integer parameter - uw_verbose = True, # Boolean flag - uw_solver = "mumps", # String option + uw_resolution = RESOLUTION, + uw_diffusivity = DIFFUSIVITY, + uw_max_steps = MAX_STEPS, + uw_verbose = True, # Boolean flag + uw_solver = "mumps", # String option ) # Use in your model @@ -203,22 +212,30 @@ Example: ```python import underworld3 as uw +# --- Default values (edit these in a notebook) --- +CELL_SIZE = 50.0 # km – target cell size +DEPTH = 660.0 # km – model depth +VISCOSITY = 1e21 # Pa·s – reference viscosity +DENSITY_DIFF = 50.0 # kg/m³ – density contrast +MAX_ITERATIONS = 50 +TOLERANCE = 1e-6 + # Define all configurable parameters at the top params = uw.Params( # Mesh parameters - uw_cell_size = uw.Param(50.0, units="km", + uw_cell_size = uw.Param(CELL_SIZE, units="km", bounds=(10, 200), description="Target cell size"), - uw_depth = uw.Param(660.0, units="km", + uw_depth = uw.Param(DEPTH, units="km", description="Model depth"), # Physical properties - uw_viscosity = uw.Param(1e21, units="Pa*s"), - uw_density_diff = uw.Param(50.0, units="kg/m^3"), + uw_viscosity = uw.Param(VISCOSITY, units="Pa*s"), + uw_density_diff = uw.Param(DENSITY_DIFF, units="kg/m^3"), # Solver settings - uw_max_iterations = 50, - uw_tolerance = 1e-6, + uw_max_iterations = MAX_ITERATIONS, + uw_tolerance = TOLERANCE, ) # Show help (useful at script start) diff --git a/docs/beginner/tutorials/16-Richards-Equation-Groundwater.ipynb b/docs/beginner/tutorials/16-Richards-Equation-Groundwater.ipynb new file mode 100644 index 00000000..c7892f84 --- /dev/null +++ b/docs/beginner/tutorials/16-Richards-Equation-Groundwater.ipynb @@ -0,0 +1,679 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebook 16: Richards Equation — Groundwater Flow\n", + "\n", + "This notebook introduces the Richards equation for variably-saturated\n", + "porous media flow. We solve a steady-state drainage problem in a\n", + "vertical soil column and validate the numerical solution against an\n", + "exact analytical benchmark.\n", + "\n", + "## Key Concepts\n", + "\n", + "- Richards equation — nonlinear PDE for unsaturated flow\n", + "- Gardner exponential conductivity model\n", + "- Analytical steady-state solution with gravity\n", + "- Darcy velocity field" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Richards Equation\n", + "\n", + "Water movement in unsaturated soil is governed by the Richards\n", + "equation (Richards, 1931). Three equivalent forms exist:\n", + "\n", + "| Form | Storage term | Flux term | Notes |\n", + "|------|-------------|-----------|-------|\n", + "| Head-based ($\\psi$) | $C(\\psi)\\,\\partial\\psi/\\partial t$ | $\\nabla\\cdot[K(\\psi)(\\nabla\\psi - \\mathbf{s})]$ | Simple, but poor mass balance |\n", + "| Moisture-based ($\\theta$) | $\\partial\\theta/\\partial t$ | $\\nabla\\cdot[D(\\theta)\\nabla\\theta]$ | Conservative, but $D(\\theta)$ singular at saturation |\n", + "| **Mixed** | $\\partial\\theta/\\partial t$ | $\\nabla\\cdot[K(\\psi)(\\nabla\\psi - \\mathbf{s})]$ | Conservative and well-behaved |\n", + "\n", + "The **mixed form** (Celia et al., 1990) is generally preferred because\n", + "writing the storage as $\\partial\\theta/\\partial t$ guarantees mass\n", + "conservation in the discrete system — the head-based form\n", + "$C(\\psi)\\,\\partial\\psi/\\partial t$ introduces balance errors because the\n", + "discrete chain rule $C(\\psi)\\Delta\\psi \\neq \\Delta\\theta$ when $C$ varies\n", + "sharply across a timestep.\n", + "\n", + "$$\\frac{\\partial \\theta}{\\partial t}\n", + " - \\nabla\\cdot\\bigl[K(\\psi)\\,(\\nabla\\psi - \\mathbf{s})\\bigr] = f$$\n", + "\n", + "where\n", + "- $\\psi$ is the **pressure head** (negative in unsaturated soil),\n", + "- $\\theta(\\psi)$ is the **volumetric water content**,\n", + "- $K(\\psi)$ is the **hydraulic conductivity** (decreases as soil dries out),\n", + "- $\\mathbf{s} = [0, -1]^T$ represents **gravity** (pointing downward),\n", + "- $f$ is any source/sink.\n", + "\n", + "The Underworld solver uses this mixed form when `water_content` is set\n", + "— discretising the storage term as\n", + "$(\\theta(\\psi^{n+1}) - \\theta(\\psi^n))/\\Delta t$.\n", + "The Jacobian $\\partial\\theta/\\partial\\psi = C(\\psi)$ is computed\n", + "automatically by PETSc. For steady-state problems (where\n", + "$\\partial/\\partial t = 0$) the forms are all identical." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gardner Exponential Model\n", + "\n", + "The **Gardner (1958)** model uses an exponential relationship for\n", + "hydraulic conductivity:\n", + "\n", + "$$K(\\psi) = K_s\\,e^{\\alpha\\psi}, \\qquad \\psi < 0$$\n", + "\n", + "This is simpler than the Van Genuchten model and, crucially,\n", + "admits an **exact analytical solution** for the steady-state\n", + "Richards equation with gravity.\n", + "\n", + "The substitution $u = e^{\\alpha\\psi}$ linearises the ODE, giving\n", + "the exact pressure head profile:\n", + "\n", + "$$\\psi(y) = \\frac{1}{\\alpha}\\,\\ln\\!\\Bigl[\n", + " \\bigl(u_0 - q^*\\bigr)\\,e^{-\\alpha y} + q^*\n", + "\\Bigr]$$\n", + "\n", + "where $u_0 = e^{\\alpha\\psi_0}$, $u_L = e^{\\alpha\\psi_L}$, and\n", + "$q^* = q/K_s = (u_L - u_0\\,e^{-\\alpha L})/(1 - e^{-\\alpha L})$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:05.573720Z", + "iopub.status.busy": "2026-02-24T08:58:05.573578Z", + "iopub.status.idle": "2026-02-24T08:58:12.073192Z", + "shell.execute_reply": "2026-02-24T08:58:12.072718Z", + "shell.execute_reply.started": "2026-02-24T08:58:05.573690Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sympy\n", + "import underworld3 as uw\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from underworld3.utilities.retention_curves import (\n", + " gardner_K,\n", + " gardner_theta,\n", + " gardner_steady_state_psi,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Configurable parameters\n", + "\n", + "Default values are defined as named constants below. From the\n", + "command line, override them with PETSc-style flags:\n", + "\n", + "```bash\n", + "python script.py -uw_Ks \"5e-5 m/s\" -uw_alpha \"2.0 1/m\"\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.074293Z", + "iopub.status.busy": "2026-02-24T08:58:12.074021Z", + "iopub.status.idle": "2026-02-24T08:58:12.076863Z", + "shell.execute_reply": "2026-02-24T08:58:12.076598Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.074281Z" + } + }, + "outputs": [], + "source": [ + "# --- Default values (edit these in a notebook) ---\n", + "COLUMN_HEIGHT = 1.0 # m — soil column height\n", + "COLUMN_WIDTH = 0.1 # m — narrow (≈ 1-D)\n", + "RES = 32 # — vertical elements\n", + "KS = 1e-4 # m/s — saturated hydraulic conductivity\n", + "ALPHA_G = 3.5 # 1/m — Gardner sorptive number\n", + "THETA_R = 0.05 # — residual water content\n", + "THETA_S = 0.40 # — saturated water content\n", + "PSI_TOP = -0.5 # m — pressure head at top\n", + "PSI_BOTTOM = -3.0 # m — pressure head at bottom" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.077264Z", + "iopub.status.busy": "2026-02-24T08:58:12.077186Z", + "iopub.status.idle": "2026-02-24T08:58:12.087031Z", + "shell.execute_reply": "2026-02-24T08:58:12.086377Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.077255Z" + } + }, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\mathrm{K_s} = 1.00 \\times 10^{-04} \\; \\mathrm{meter / second}$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Named expressions for display\n", + "Ks = uw.expression(r\"K_s\", uw.quantity(KS, \"m/s\"), \"saturated conductivity\")\n", + "alpha_g = uw.expression(r\"\\alpha\", uw.quantity(ALPHA_G, \"1/m\"), \"Gardner sorptive number\")\n", + "theta_r = uw.expression(r\"\\theta_r\", THETA_R, \"residual water content\")\n", + "theta_s = uw.expression(r\"\\theta_s\", THETA_S, \"saturated water content\")\n", + "\n", + "Ks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retention Curves\n", + "\n", + "Let’s visualise how hydraulic conductivity and water content\n", + "change with pressure head for these Gardner parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.087748Z", + "iopub.status.busy": "2026-02-24T08:58:12.087662Z", + "iopub.status.idle": "2026-02-24T08:58:12.508149Z", + "shell.execute_reply": "2026-02-24T08:58:12.507784Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.087739Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAmOBJREFUeJzt3Qd4U9X7B/Bv94IWSgerlL2hLXsqiExFRBAERVRQEBAQFzhQcOBAZCO4EJUpAg4U8KcyBJll71lGoQPo3s3/eU9J/2mblrZJmvX9PE8g9ya5ufckzbnvPee8x0Gj0WhAREREREREREbnaPxNEhERERERERGDbiIiIiIiIiITYks3ERERERERkYkw6CYiIiIiIiIyEQbdRERERERERCbCoJuIiIiIiIjIRBh0ExEREREREZkIg24iIiIiIiIiE2HQTURERERERGQiDLqJ7li6dCkcHBywb98+vWXy4IMPombNmkYrr4sXL6r3k/c1Fzmep556yqL2ydSfrxyjKVy7dg3vvPMODh48WOAxWS/vbYzPqKj3ISKydP3794eHhwdu375d6HMef/xxuLi44MaNG8XaprXUXTt37lS/30Ude3HqAUv2wQcfYP369bB1ZV0XL1y40OK/31Q0Bt1ElKtKlSrYtWsXHnjgAZZKKSrgadOm6a2AR44cqcq1NNatW4e33nqrWO9DRGTpRowYgdTUVCxfvlzv43Fxcep3Ty50BwYGwpZI0C2/3yUNuvPXA5bMnoLusqyLGXRbPwbdRBYuOTm5zN7Lzc0N7dq1g7+/f5m9pz2oXr26KtfSCAsLQ506dYy+T0RE5tC7d29UrVoVX3/9td7HV6xYgZSUFBWc2zspB2Hv9UBWVhbS0tLMvRtEBmHQTVRK3bp1Q8OGDaHRaPKsl+W6devmaS2WK6KDBg1C+fLl4ePjg8GDB+P69esFtindx8qVK4cjR46gR48e6vnyPmLLli3o16+fCuDc3d3Ve4waNQoxMTEFtqGvG3xxujgX1kXv5MmTGDJkiGp1kMC8Ro0aePLJJ+9aCcrj06dPR6NGjdQ+V6pUCV27dlVX+7WkxWPKlCmoVasWXF1dUa1aNYwdO7ZAS4Ack7R8/PHHH2jRooXqnijlr+/E7b///kPHjh3Ve8rJnWw/IyOjwPPkWKVcitOV7+rVq3juuecQFBSk9lO2O3DgQNX98Z9//kHr1q3V855++mm1Xd1t5y/7hx9+GMHBwcjOzi7w3m3btlXHp29finqf7777Tt3X16Iun4F01ZTvIRGROTk5OWH48OHYv3+/quvy++abb1SvKwnOxdGjR1XdV7FiRfWbHhoaim+//fau71OSulCWx40bp967QYMGqn5p1aqVqkukTv/kk09UHSX183333YezZ88W2O6ff/6p6mtvb294enqqOuh///tfnvd95ZVX1H3Zlvb3W37Xdeu4n376SQXZcqzSklpYnSR15EsvvYTatWurejkgIAB9+vRR9XVh5P3lHESCWK0XXnhB7Ycco1ZsbCwcHR0xb9683Hpa3kvKXl7v6+uL9u3bY8OGDQXKMSkpSX0+2uPr0qVL7uNy3iPnLXIeI/WolIMcY2ZmZoHzkI8//hjvvfeeeo4c399//13ocUldKvsq+yefXYUKFdSF7p9//jnPc2Sbct6gLS85j7ly5Uqebcn+Nm3aFHv37kXnzp3VZyll/OGHH+bW2Xer84UMVXzooYdUWclnKZ/p6tWr9Q57k2N7/vnn4efnp86THnnkkTz1tXz+x44dw9atW3Pfy5jDHalsOJfR+xBZDamMdCsArfzB9YQJE9SJgFSq999/f+7633//HefOncPcuXNzr1TL4/IDOmPGDNSvXx+//fabCrz1SU9PVz/UUjFNnjw5d19km1LJSVdlqfSkYpo1axY6deqkTlwkqDKFQ4cOqfeQykCCt3r16iEyMlJVZrKvUnnpI/stJ03bt2/HxIkT1YmKrJOTmIiICHTo0EGVqQSgUoYSGEsFd/jwYbz99tsqeJSb7vZlX6Til3KRCwBffvmlag2RCxD33HOPes7x48fViY9USFKhSYUp3bIK68pYHBJwSwUrgfvrr7+O5s2bq5OSTZs24datWypIlpM1qXzffPPN3AsucmKhzzPPPKO+O3/99Vee746cLO3Zsyf3u5NfUe8jJxCvvvoqFixYoL4nup/D4sWL1ThKuVBARGRu8hsoQYxcNP3ss89y18vvt/wGym+8BOenTp1SdYX8vsnvogQk33//vQpA5YKn/OYZy6+//orw8HC1XxLUvPbaa+o3Vi4QnD9/HvPnz1dd3ydNmoQBAwaobsXa4F32SQI4+V2XgFPqY/nd7dmzp6onpE6SuvvmzZsqOJTAWi4siMaNG+fuw4EDB3DixAn1+y7BppeXl959TUhIUPWynAfIfsrF2sTERGzbtk3VzxJY6iP1zcyZM1UZa+sJuVgggapc2NdeFJA6Wepnbf0kF9Bl319++WV1YVzqfnmdBIdSJ8mxC6mzpa6Xi+va7vByEUIbcLdp00YF81OnTlUt9/J8CazlOGQ7uuTzlvMl2V/Zhpx7FEa+D/IZyPmAnKdIQC9lqZvDRYLaJUuWqIsrcnFDHpN9lABanivnOFqyr5JXQM435HxEuvfLOYrUoXKsd6vzJYju1auX+lw+//xzdc62cuVKdd4nvRfzX0CR74ZsQ85TLl++rD6HJ554Qp0jCHl/ucgv25HzGVHYuRdZMA0RKd98841E1UXegoODc0srKytLU7t2bU2/fv3ylGDv3r01derU0WRnZ6vlRYsWqddu2LAhz/OeffZZtV7eV2v48OFq3ddff13kpyLbzsjI0Fy6dKnAtmUbuvup9fbbb6vn6pLnyfO1Lly4UGCf7rvvPk2FChU0UVFRJfqmLFu2TG3riy++KPQ5f/zxh3rOxx9/nGf9qlWr1PolS5bk2Vd3d3d1zFopKSkaX19fzahRo3LXDR48WOPh4aG5fv167rrMzExNw4YN1TblGLVkWcolv/zl8swzz2hcXFw0x48fL/RY9u7dW6DsCit7+ewCAwM1Q4cOzfO8V199VePq6qqJiYkpdF/u9j7y+hs3bhQoy61btxa670REZe3ee+/V+Pn5adLT03PXvfTSS+r36vTp02r5scce07i5uWkiIiIK1LOenp6a27dvF1p3laQulOXKlStrEhMTc9etX79erQ8NDc2tz8Xs2bPV+sOHD6vlpKQkVQ/17ds3zzblHCEkJETTpk2b3HWffPJJgXpIS/bVyclJc+rUKb2P6dYD06dPV9vZsmWLpiRkX6WOkNeLK1euqO289tprqt5MTU3NPT+pWrVqoduROlXqsREjRmjCwsLyPObl5ZVnX7Wkni5XrlyeOlzMnDlT7cOxY8fyfJZyHqX73SjMtm3b1PPfeOONQp9z4sQJ9ZwxY8bkWb979261/vXXX8/zvZR18piuxo0ba3r27FmsuljON6RcpIx0Pfjgg5oqVaqo74bueWf+/ZJzIlkfGRmZu65JkyZq38h6sXs5UT7Lli1T3Yry3+Sqsi65WitXTOXquLTcalujpfvzmDFjcq+AyxVP6SYurde6hg4dWmjZy1X0/KKiojB69GjVvdnZ2VldSZcuykKujJuCXJGV7kzSNb6k47ylxV+6VEmLRmG0V3HzX/V99NFH1RV+3a55QrqOSdd2Ldm+XAm/dOlS7jopb2lV0E3AIy0mhfUsKO6xyJV76SZvDPL5yVVsae2QlhNtDwvpIi4tJdKaUxpyJV988cUXueukdaZZs2a5PQGIiCyBtErK8ChtF2DplSOtldLjSduqKXWE/J5LvadL6gypn0qboFIf+Y3XbVnW/t5Ljy3d7uja9dp6R4ZLSSuwtIjLMWhv0hVZWjvl/EG6XBeH9KKSOq04dZI8T7enVHFIzy9p4ZZWaiGt29IVW1pWpfV6x44dar08nn/ba9asUV3mpYu99hzkq6++Kvb5h5wrSRlLa7FuOWmHEci5hi45ZypODz4pCyHD0gqj7Zqe/1xDWt7l88x/rlG5cmX1WP7PRvdcozAy9EB6rUlLudA9Vun+Lz0RpAdH/mPN/16iOO9H1oNBN1E+8gMsY7ny36RbT34SUEq3LOk+JKRrryzrBprSDVlfBlb5US+sUtR2x9KSylvGeEuQJt3ppIKQ7mHSVVs32YqxSddpCQYL6yZdlOjoaFW5ysWJwkjZSOWdP6CXExwpH3lcl75gVLpY6R6/vEZf2RZW3sU9ltKUQVHkOyLj5KTLmZAuiFIZS3e10pLvmVxckG6N8rlJV33p3i8Xh4iILIm2u6y2W/HGjRtVl3HdBGrye67thq1LO1Qmfx1hCBl7q0u6KBe1Xn6/hXZaMzkeCRJ1bx999JHqpi1BeXHoO1Zj10kSTMu5g1wIkOBauoNL3dqyZUu1fOHCBXXTDbrl3EMuvkvXcrkwIhc75GKCth4rDimnX375pUAZNWnSRD2ePz9NScpCLqwXVcdrvyeFfZdKc65RGO33Qbri5z9WaZDRd6z530/bddxU53ZkHhzTTWQAOWGQq9sytlh+YOXkQVqw5cqx7o+pBMj56UukJvQlO5NEMjKeWcYoy/tp6UvmIq2/+hKc5f+RLw452ZDKLH+ikeKQQFqumssFg8ICbykbuforlaZu4C0nKVI+2kQlJSHb1Fe2+tZJxaavrPJXwLJvpSmDosg4PrmSLt8ZGb8v/0vlLxdXDCG5BqTFXBLcSK8L+S5qr7gTEVkKuUAtCTqlZ45ccJTx3dIrTHo66f6ey2P5aZNM6Y7DNWVdWBTtPshY7cJmqSju1Gd3S3ZqjDpJeg7IWGYZ/y0X8GXMsnb95s2b1Vhy7bKWBNqyftWqVXn2sSQZxaWcpAX3/fff1/t4/pwjJSkLucgsdXxhgbo2qJXvUv6LFfJdKup7VFLabckYcBnzro8k6yP7w5ZuIgONHz9eVeJylVuyieZvVZTuVJL0RDeLpihJYi9t5ZM/cYa0aOYnCcSkK7r2aquQbmPSklqak6J7771XdSsr6YmKdBmTK+D5M6Hr0lbqUqHrWrt2rboKr1vpF5eUt5xI6B6/VMhysqCvrKQ1WJd0Z5SENPmPRbqn5e8SZuiVaWnV3r17t7o4IS0AckFFLnIU5W7vI60VknhIWlh++OEH1Z2usGQ8RETmJK3a8vssmbOlpfuxxx5Tvb20pA6Q3+T8My/IMDB5XlFTMRqzLiyKdLmWi5uSBE5fLzm5aVvHjdWCKXXS6dOnc4dolYRc7JXedLNnz1aBavfu3dV6admWRHKSYVsuCusGwXIOIsegGwjLa/NnLy+qRViSl0kDgiRQ01dGpU30qe2evmjRokKfI635+s41pLVeuseX5lyjsM9SAmoZHiENJYV9H+TiUmnejy3f1o0t3UQGknFVMm5LxhXJuO+QkJA8j0umS8nOKv/LFV75MZaTi5JU/JKJVCoqyegqrcDSAi1BmozHyk+6F0tmUDl5kXFaEvhKFlDdKUJKQpshXbJwyvtLpnA5iZGLCBL0F1Z5SAuGtN7KOHQJViUYllZvCTKlC7/sn1T2kt1Vsq/Gx8erkxdt9nKZXmPYsGEl3l/JJCr7JpWslIOcmEm3f31j6mT7csVfnicXF+SkScZA5x9KINlQ5fOVcdGSvVzGSMsFFmlJlky22s9HLlJIoCvHJ+Pe5CSiqBMJKSN5vfwvLQb5x5vpU5z3kdZu+R7ICZK2OxsRkaWRAERaPyUAlLot/9zcUhdoxwLL77TUffLbJzOAyPRP+oZ9maouLIz8Bksrt1w0lW7kcgFesq1LDy4JvOR/bUAodYeYM2eOer50OZYgraRBmMwIIheSJQeI1MsSSEtAJuOiJbiV8iqMXNiV+k7OIaT1Wjv/t9S/EtjJRWtpTNClncpM6hM5Psmw/e6776qW5TNnzuR5rhyjZASX7cvjcmxyjFKPyjmLXBSW7cs6+Uwki7icE8kwvdJ0mZccAFKXSxZ0OTeRfZXjkAsIUv/LlGjyXjLlp3xO0vNOAnVt9nLJF/Diiy+W+H2Lqovl3EjeQ85vpF6Xbvny3ZAAXzKlS0NGSUm5ynA0+dxlCjPpyaH9PpGVMHcmNyJLoc0iKRkp9XnggQf0ZkIVS5cuVa9duXKl3sclQ+iAAQNU5s7y5cur+zt37tSbbVUyf+ojmbO7d++uXl+xYkXNo48+qjK66svAvXHjRpVxVbKRSob1+fPnlzp7ufa95f0qVaqkMp/WqFFD89RTT+VmOi2MZBefOnWqpl69eup18nrJhi7HrvscyZwq+yIZwiWz5/PPP6+5detWgX2VzyA/yeaZP6Pnv//+q2nXrp3KeisZaV955RWVCT1/1ti0tDSVMTwoKEiVlWzn4MGDBcpFXL58WWUxl+3Jfkpm10GDBuXJFL5ixQqVtVQe1/1c9JW9lmQwl8c6duyo93F9+1LY++gelxx7r1699G6TiMhSzJkzR/2OSXZofY4cOaIyg/v4+Kh6RDKC56+jCqu7ilsXyvLYsWP1blMyjuv6+++/1fo1a9bkWS8zREgdJZnM5be5WrVqajn/86ZMmaLqD0dHR7Ud2V5RdVxh9YDUkRMmTFD1sbxfQECAev3Jkyc1xS1zyVKuS84xZP3PP/9c4DUffvihpmbNmqpuadSokZqZRF9ZSh0q9Zlkl5fHdOvn6Ohozfjx4zW1atVS+yxl1bJlS5V5XJs5vrByL4pkA//ss880TZs2Vd8R+a60b99e88svv+R5zkcffaSpX7++em/JnP/EE0+oul2X7K9kCs9PXzb8ouriQ4cOqXME+VzkcTl3kPOfzz///K7nndrvmPa7IS5evKjp0aOHOgfMP5sOWQcH+cfcgT+RtZNs45KYRK6cmmq+bKLikhYGyYYqrUGSLZWIiIiIzIfdy4lKSboDSzchSZK2bt061Q2bATeZk3SPlylGXnrpJTW9mnasGxERERGZD1u6iUpJWrVlPJQkJJGM5TIW+G5JsIhMqUuXLvj333/RokULfPvtt2qsORERERGZF4NuIiIiIiIiIhPhlGFEREREREREJsKgm4iIiIiIiMhEGHQTERERERERmQizlxtJdnY2rl27hvLly8PBwcFYmyUiIpKJcJGQkICqVavC0ZHXy1k/ExGRNdXPDLqNRALuoKAgY22OiIiogMuXL6N69eosmRJg/UxEROaunxl0G4m0cGsLXKaQMrTVPDo6Gv7+/mzRYDkZjN8nlpWx8TtV9uUUHx+vLuxq6xoqPtbPZY+/ESwnfqfMg397lls/M+g2Em2Xcgm4jRF0p6amqu2wGyHLyVD8PrGsjI3fKfOVE4cvlb7MWD+XHf5GsJz4nTIP/u1Zbv3MgWEGWrBgARo3bozWrVsbuikiIiIiIiKyMQy6DTR27FgcP34ce/fuNc4nQkRERERERDaDQTcRERERERGRiTDoJiIiIiIiIjIRBt1EREREREREJsKgO5/k5GQEBwfj5ZdfNlWZExERERERkZ1g0J3P+++/j7Zt25rn0yAiIiIiIiKbwqBbx5kzZ3Dy5En06dPHfJ8IERGRlVq4cCFq1aoFd3d3tGzZEtu3by/W6/799184OzsjNDS0wGNr165VU3O6ubmp/9etW2eCPSciIjIdqwm6t23bhr59+6Jq1apq8vH169cbrbLXki7lM2bMMOJeExER2YdVq1Zh4sSJeOONNxAeHo7OnTujd+/eiIiIKPJ1cXFxePLJJ9GtW7cCj+3atQuDBw/GsGHDcOjQIfX/oEGDsHv3bhMeCRERkZ0G3UlJSQgJCcH8+fNLXdlLIN60adMCt2vXrmHDhg2oX7++uhERERlKo9Hg0s1UuynIWbNmYcSIERg5ciQaNWqE2bNnIygoCIsWLSrydaNGjcLQoUPRvn37Ao/JNrp3744pU6agYcOG6n8JzmU9ERFRaWRla1DWnGElJICWW3EqeyEV8qZNm1Rlr2293r9/f6Gv/++//7By5UqsWbMGiYmJyMjIgLe3N6ZOnar3+WlpaeqmFR8fr/7Pzs5WN0PI6+VkzdDt2DqWE8uJ3yn+7VmquJQMvLb2MLaficGGMRVRN7C8Qduz9PogPT1d1bGTJ0/Os75Hjx7YuXNnoa/75ptvcO7cOXz//fd477339LZ0v/jii3nW9ezZs8igu7D6OSUlBS4uLuq+o6Ojui91vW7ZOjk5qW7ucjxSD2vJOnksNTVVbVu2pd2G/K/7fkLWS6882Y4uV1dXtV15X13SdV72Q3e9vF6en5WVhczMzALrZZ08plXaY8q/3hjHpK2f8++jNR+TKT4neUz7fZJ1tnBMpvqc5Hm6f3u2cEym+JzkObJN+d9WjskUn9Pb6w5hw6GrGNulLp7uWNOgY5LvpE0F3aao7HVJYK4NzpcuXYqjR48WGnBrnz9t2rQC66Ojo1WlbAj50kh3O/kwtT8sxHLi98n0+LfHcjKGo5GJeHPjBVxPSIezI7Dz5GV4O/gZtM2EhARYspiYGHUiFBgYmGe9LF+/fr3QPCpSb8tQMDkR0kdeW5JtFlU/S6Auw8+EtJrfe++92Lp1q8rlotsjrlWrVvjtt99w5cqV3PX33HOPar2XXnW3b9/OXS85YKQ1/+uvv85z4vjoo4+iXLly6qKCrqefflpd2JcL/Londc888wwuX76MjRs35q6vWLGi6kp/4sQJNcROq3r16njggQewb9++PI0JpT2m1atX49atW0Y/pv79+6vehn/88YfNHJMtfk7Wckyenp749ttvbeqYTPU5yW/kQw89hAMHDtjMMVU38ufkcPovDHJJQvS/B/Dxv4YdU3HjPgeNbvhvJeSKgyRSefjhh9WydA+vVq2aSsTSoUOH3Od98MEH6g/01KlTJdq+NuieOXNmia6ky4clX0ppITf0xF+Cd39/fwbdLCeD8fvEsjI2fqcKKxcNvthxAZ9uPo3MbA2CKnpgWs8auKdpTYN/y6WOkZMRuSBraB1jCtp6WC5063YTlxlBvvvuuzwnQ0IC9Hbt2qkeaqNHj1br3nnnHZWv5eDBg3laE6QeHzJkSO66H374Qb2usBOdwupnCdS1ZWdIS7fUz35+fmzpvktLt5R7pUqV2NJ9l5ZuuWAl3ye2dN+9pVt+Z7R/e4V994S9t3THxsaqHFhy3xaOyRSf09DFO7D/0m182L8J+jSvatAxyW9d5cqV71o/20RLt5YUii4pjPzriuOpp56663PkiyK3BQsWqJv2CyAfmDFap2W/jbUtW8ZyYjnxO8W/PUsQm5iGSasPYevpaLX8YPMqeO/hJkiNv2WU33JLrwvkRFhOZPK3QEdFRRVoqda23EuLheRgGTduXJ4uyXJStHnzZtx3333qRKa428xfP+fn4eGhbvmfq4+2RVzfenmNbEf3M8m/3but19eyL9srbL22W3z+kz59SnNM+hhyTPJZymcs6/TtpzUekyk+J3l+/u+TtR+TPsY4JvlO6fvbs+ZjKmp9aY9JykmOpbDnWuMxmeJzupmiQQacEFCxfJ79Lc0x5b+YUBjLrsVNVNkb09ixY3H8+HHs3bvXpO9DRESWaee5GPSes10F3G7OjpjxSDPMGxIGb/eCJwy2Sk6EpDvfli1b8qyXZd0eaFrSGnDkyBHVqq29SYt3gwYN1P22bduq50mref5tSkCub5tERETFEZuU03Lt66U/iDcFZ1ur7GUMkZYs9+vXz6Tvnb+lm4iI7Cf76Zz/ncG8v85Aeq/VDSiH+UPD0LByTvcyKxy9ZZBJkyapKb1kHJ0Ey0uWLFFjerXdxyXz+NWrV7Fs2TLViiGzh+gKCAhQrRK66ydMmKDG4H300UeqPpeZRv7880/s2LGjzI+PiIhsYyjY7ZSc1mkG3XrIYPWzZ8/mLl+4cEFdDff19UWNGjXuWtmbsqVbbtKf38fHx6TvRUREluF6XComrAzH7gs31fKgVtXxzkNN4OlqE9eyS0Xm05axhNOnT0dkZKQKniVBTnBwsHpc1t1tzu78pEVbZhZ588038dZbb6FOnToqmZm2JZyIiKgk4lMzcqcMq+jJlu4CZOxX165dc5clyBbDhw9Xic/uVtmbClu6iYjsy98no/DSmkO4mZQOL1cnfPBIM/QLrWbu3bIIY8aMUTd9pK4uiiRSk1t+AwcOVDciIiJjdS0v5+oEV5lipIxYzSX5Ll263LWrXlGVvamwpZuIyD6kZ2Zj5uZTWLLtvFpuUtUb84e2QC0/L3PvGhERERWDXDAXFTzKNgy2mqDbUrGlm4jI9l2+mYxxK8Jx6HLOHM1PdaiJKX0aws3Zydy7RkRERMXEoNtKsaWbiMi2bTwSidfWHkZCaia83Z3x8cAQ9Gpa2dy7RURERKUNuj3Z0k1ERGR2qRlZeO+34/j+v5zkXy1qVMDcIWGoXtHT3LtGREREhgTd7gy6rQq7lxMR2Z6zUYkYt/wATl5PUMvPd6mDSd3rw8Wp7JKuEBERkXGxe7mVYvdyIiLbsnb/Fby14SiS07NQycsVswaH4t76/ubeLSIiIjJS0F2R3cuJiIjKXlJapgq2fzpwVS13qFMJsweHIsDbnR8HERGRDU0Z5sPu5daF3cuJiKzfich4jF1+AOejk+DoAEy8vz7Gdq0LJ1kgIiIim3Art6XbpUzfl1OGGYjdy4mIrJdGo8H3uyPw7q/H1Tzcgd5umPtYGNrWrmTuXSMiIiIj45huIiKiMhSXkoHJaw/j96PX1fJ9DQMw89EQ+Hq58nMgIiKyQbFJaer/Ch7MXk5ERGRSBy/fVtnJr9xKgYuTA17r1RAjOtWCgwO7kxMREdmilPQspGZkq/sMuomIiEwkO1uDr3ZcwEd/nERmtgZBvh6YN6QFQoMqsMyJiIjsoJXb1dkRni5lOwUox3QbiInUiIisZxzXS6sP4u9T0Wr5gWZVMGNAM3i7l20yFSIiIjLfeG5fT5cy79nGoNtATKRGRGT5/jsfiwkrw3EjPk1d4X67b2MMbVOD3cmJiIjsLej2KvvcLQy6iYjIZmVlazD/r7OY87/TyNYAdfy9MH9oCzSq4m3uXSMiIqIyxKCbiIjIyG7Ep2LiyoPYdT5WLQ9sWR3T+zWBpyuvNxMREdlr0F3Rky3dREREBvvnVBReWn0IsUnp8HR1wnsPN8UjLaqzZImIiOxU7J2guxK7lxMREZVeRlY2Zm4+hcVbz6tl6UY+f2gY6viXY7ESERHZsZiEnOzllcq7lfl7s4+dgZi9nIjIMly+mYzxK8MRHnFbLQ9rF4w3HmgEdxcnc+8aERERWUhLt185di+3OsxeTkRkfn8cjcSrPx5GfGomyrs74+MBzdG7WRVz7xYRERFZiJjEnJZuP3YvJyIiKr7UjCx8sPEElu26pJZDgypg3pAwBPl6shiJiIgoV2yitqVbupfn3C8r7F5ORERW6Xx0IsYtD8fxyHi1POre2ni5RwO4ODmae9eIiIjIgmg0GkTfaemuJN3LMxh0ExERFWld+BW8se4oktOz4Ovlik8HhaBrgwCWGhERERWQmJaJ9Mxsdb+SlxsSbieiLLGlW7cwnJ3RtGlTdb9Vq1b48ssvy/TDICKioiWnZ+LtDcewZv8Vtdyuti/mPBaGQG93Fh0RERHpFXOna7mXqxM8XJ2QgLLFoFtHhQoVcPDgwTL+CIiIqDhOXo9X3cnPRiXC0QEY360eXrivHpxkgYiIiOhuSdTMMF2YYNBNREQWPw5r+Z4ITP/lONIysxFQ3k21brevU8ncu0ZERERWIFY7ntsMmcuF1WSb2bZtG/r27YuqVavCwcEB69evL/CchQsXolatWnB3d0fLli2xffv2Er1HfHy8el2nTp2wdetWI+49ERGVRnxqBsatCFfjtyXg7tLAH79P6MyAm4iIiIotOk/m8rJnNS3dSUlJCAkJwdNPP40BAwYUeHzVqlWYOHGiCrw7duyIxYsXo3fv3jh+/Dhq1KihniMBdVpazlUOXZs3b1bB/MWLF9X/R48exQMPPIAjR47A29u7TI6PiIjyOnT5Nl5YEY6Im8lwdnTAq70aYGSn2nBkd3IiIiIqRUs3u5ffhQTQcivMrFmzMGLECIwcOVItz549G5s2bcKiRYswY8YMtW7//v1FvocE3EKSqTVu3BinT59WCdX0keBdN4CXVnKRnZ2tboaQ10t3SkO3Y+tYTiwnfqds829Ptv31vxfx8aZTyMjSoHpFD8x9LFTNwQ3I+2pgb+VkLfWBXPj+5JNPEBkZiSZNmqi6uHPnznqfu2PHDrz22ms4efIkkpOTERwcjFGjRuHFF1/Mfc7SpUvVxfb8UlJSVK82IiKiEo3pNlP3cqtp6S5Kenq6CqgnT56cZ32PHj2wc+fOYm3j1q1b8PT0hJubG65cuaJayGvXrl3o8yWQnzZtWoH10dHRSE1NhaEnV3FxcepkzdHRakYAlDmWE8uJ3ynb+9uLS8nE9M0X8e+FOLXctW4FvH5/MMq7pSMqKgr2Wk4JCWWdZ7XkitPjTJeXlxfGjRuH5s2bq/sShEvQLfefe+653OdJj7NTp07leS0DbiIiKolYbfdyJlIrvZiYGGRlZSEwMDDPelm+fv16sbZx4sQJVdnLiZGMGZ8zZw58fX0Lff6UKVMwadKkPC3dQUFB8Pf3N7hLupyoyT7Ithh0s5wMxe8Ty8pavlN7LtzEi6uPITIuFa7OjnijT0M80baGei97LydrCDKL0+NMV1hYmLpp1axZEz/99JPKx6IbdEsZVq5cuYyOgoiIbLmlu5IXx3QbLP+JmbQuFPdkrUOHDmoMd3FJi7jcFixYoG4S9As5sTLGSajst7G2ZctYTiwnfqes/28vK1uDhX+fxWd/nob0HK/t54V5Q8PQpKoPrJ2xysnS6wJj9DgLDw9Xz33vvffyrE9MTFRdz6WeDQ0NxbvvvpsnWM+Pw7/Mj8O/WE78TvFvz1Ln6a7k5WKW4V820b3cz88PTk5OBVq1pSti/tZvYxs7dqy6SUu3j4/1nyASEZWlqPhUTFx1EDvPxarlR8Kq4d2Hm8LLzSaqJ7thSI+z6tWrq6FZmZmZeOedd3JbykXDhg3VuO5mzZqpelZ6oUnX9UOHDqFevXp6t8fhX+bH4V8sJ36n+LdnaaLj7wz/TUtEVFR6mQ//somzGldXV5WZfMuWLejfv3/uelnu16+fSd87f0s3EREVz7bT0Zi0+qC6+uzh4qSC7YEtq7P47KzHmXQnl9bs//77T7WU161bF0OGDFGPtWvXTt20JOBu0aIF5s2bh7lz5+rdHod/mR+HNbGc+J3i354lScvIQmJ6TqzWILgKyrs5lfnwL6sJuqVCPnv2bO7yhQsXcPDgQTXuWhK0yPjqYcOGqWzj7du3x5IlSxAREYHRo0ebdL/Y0k1EVDIZWdmYteU0Fv1zTi03rFwe84e2QN2AcixKO+xxVqtWLfW/tGbfuHFDtXZrg+785OSodevWOHPmzF2Hf+l7LYd/lR0O/2I58TtlHvzbK+hWSs54bhcnB1TwdM29IFyWw7+sJujet28funbtmrusTWI2fPhw1fVs8ODBiI2NxfTp09VUJTLt18aNG9U4MFNiSzcRUfFdvZ2C8SvCsf/SLbX8eNsaeOvBxnB3cWIxWjFj9TiTEyHd6Tj1PS4X3CVAJyIiKmkSNQm2pS4pa1YTdHfp0uWuBTRmzBh1K0ts6SYiKp7Nx67jlR8PIy4lA+XdnPHhgOZ4oHkVFp+NuFuPM+n2ffXqVSxbtiz3orX0VJNx20KmDJs5cyZeeOGF3G3K1JzSvVzGb8uYbulSLkG3vJaIiKgk04VVKmeeObqtKui2VGzpJiIqWlpmFmZsPImlOy+q5ZDqPpg3pAVqVPJk0dmQu/U4k3UShOuO+5VAXIaLOTs7o06dOvjwww/V9J1at2/fVtOHSbd1SVYqWcu3bduGNm3amOUYiYjI+kTfaen2K2ee6cIEg24DsaWbiKhwF2KS8MKKAzh6NV4tP9u5Fl7p2VDNw022p6geZzIUTJe0aOu2auvz2WefqRsREVFpRSfkBN0B5Rl0ExGRjdlw8Cpe/+kIktKzUNHTBZ8OCsF9DU07jSMRERFR/ulJhT+DbuvF7uVERHmlpGfhnZ+PYdW+y2q5TS1fzHksFFV8PFhUREREZJbu5WzptmLsXk5E9P9O30jA2B8O4ExUImR65hfuq4fx99WFsxO7kxMREVHZi4rPCbr9yxdvTm1T4JhuIiIymMwusWrvZbzzyzGkZmSrLlxzBoeiQ10/li4RERGZv6Xbm2O6iYjISiWkZuD1dUfxy6Fravme+v6YNSjErFlCiYiIiDQaTW5LN7uXWzGO6SYie3bkShzGrTiAS7HJcHJ0wCs9G+C5zrXh6Ohg7l0jIiIiO5eYlomUjCx1n4nUrBjHdBORvV45/ubfi/jwj5PIyNKgWgUPzB0ShpbBFc29a0RERER5pgsr5+YMT1fzjazmmG4iIiqR28npePWXc9h+Pk4t92wSiI8HhMDH04UlSURERBYj6k7Qbc5WbsGgm4iIim3fxZt4YUU4IuNS4erkgDceaIwn2wfDQVKVExEREVmQKAbdtoFjuonIHmRna7Bo6znM2nIaWdkaVK/ghkVPtESz6uxOTkRERJbdvTyALd3WjWO6icjWRSWkYtKqQ9hxNkYt9wutivEdAlCrqo+5d42IiIioyHMYwe7lRERksXacicHEVQcRk5gGDxcnTOvXBAPCqiI6Otrcu0ZERERUpOjc6cLcYU4c001ERAVkZmVj9p9nsOCfs9BogAaB5TF/aBjqBZZHdnY2S4yIiIgsXnQiu5cTEZEFunY7BRNWhmPvxVtqeUibGni7b2O4uziZe9eIiIiIii3qTks3u5cTEZHF+PP4Dbz84yHcTs5Qc1rOeKQZ+oZUNfduEREREZV6THeAN6cMIyIiM0vLzMJHv5/C1/9eUMvNqvmo7uTBlbzMvWtEREREJZaemY1byRnqvn85Bt1WjVOGEZG1uxSbhHHLw3HkapxaHtGpFl7r1RCuzo7m3jUiIiKiUpEksMLZ0QEVPV1hTkykZiBOGUZE1uznQ9fw+k9HkJiWiQqeLpg5MAT3Nw40924RERERGSTqzhzdfuXc4OjoAHNi0E1EZIdS0rMw/ddjWLHnslpuXbMi5jwWhqoVPMy9a0REREQGuxGfM5470MzjuQWDbiIiO3PmRgLGLj+A0zcS4eAAjOtaFxO61YOzE7uTExERka0F3e7m3hUG3bouXLiAZ555Bjdu3ICTkxP+++8/eHkxiRAR2QaNRoM1+65g6s9HkZqRrbpbzR4cik71/My9a0RERERGdT0uJ+iu7MOg26I89dRTeO+999C5c2fcvHkTbm7m74pARGQMMmb7jXVHsOHgNbXcuZ4fZg0KNfu8lURERESmcJ0t3Zbn2LFjcHFxUQG38PX1NfcuEREZxdGrcRi3/AAuxibDydEBk7rXx/P31jF7UhEiIiIiU3cvr2wB3cutZgDftm3b0LdvX1StWhUODg5Yv359gecsXLgQtWrVgru7O1q2bInt27cXe/tnzpxBuXLl8NBDD6FFixb44IMPjHwERERl35186b8X8MjCnSrgrurjjlXPtcPYrnUZcBMREZFNu87u5SWXlJSEkJAQPP300xgwYECBx1etWoWJEyeqwLtjx45YvHgxevfujePHj6NGjRrqORKIp6XlpI7XtXnzZmRkZKgg/eDBgwgICECvXr3QunVrdO/evVQfMhGROcUlZ+CVHw9h8/Ebavn+RoGY+WhzVDDzPJVEREREZSEqPifuYyK1EpAAWm6FmTVrFkaMGIGRI0eq5dmzZ2PTpk1YtGgRZsyYodbt37+/0NdXr15dBdlBQUFquU+fPioALyzoluBdN4CPj49X/2dnZ6ubIeT10kJl6HZsHcuJ5cTvlH4HIm5h/MqDuHY7Fa5ODpjcuyGGtw9WvYSM8bvCv72yLyfWB0RERMWXlJaJhLRMdZ+J1IwkPT1dBdSTJ0/Os75Hjx7YuXNnsbYhAbdkLb916xZ8fHxUd/ZRo0YV+nwJ5KdNm1ZgfXR0NFJTc8YPGHJyFRcXp07WHB2tZgRAmWM5sZz4ncr3N6HR4Pt9N7B451VkaYDqPm54r08tNAz0VL9N/Nuz3t+ohIQEo+0XERGRvSRRK+fmrG7mZv49MIKYmBhkZWUhMDAwz3pZvn79erG24ezsrMZx33PPPeoESQL2Bx98sNDnT5kyBZMmTcrT0i2t5P7+/vD29jb4RE1apGRbDLpZTobi98k+yiomMQ2vrjmMbWdi1HLf5lXw3sNNUN7dxejvZc3lVJaMWU6Sq4SIiIiK58ad8dyB3pYxS4tNBN1acnKjS4Ln/OsM6cKuS6YTk9uCBQvUTYJ+ISdWxjgJlf021rZsGcuJ5cTvFLDzbAwmrDqI6IQ0uLs4YtpDTTCoVVCJfv/4t2fZ5WQtdYHkVfnkk08QGRmJJk2aqKFe2llB8tuxYwdee+01nDx5EsnJyQgODlY9zF588cU8z1u7di3eeustnDt3DnXq1MH777+P/v37l9ERERGRNbd0V7aAObqFddTid+Hn5wcnJ6cCrdpRUVEFWr+NbezYsSpZ2969e036PkRE+WVmZWPW5lN4/KvdKuCuF1AOP4/rhMGta5g04CbSR5vQ9I033kB4eLgKtuVCdkREhN7ne3l5Ydy4cWo414kTJ/Dmm2+q25IlS3Kfs2vXLgwePBjDhg3DoUOH1P+DBg3C7t27+SEQEZFVzNFtM0G3q6uryky+ZcuWPOtluUOHDiZ9b2nlbty4sRoTTkRUViLjUjD0i92Y+9dZaDTAY62DVMBdP7A8PwQyC92Epo0aNVKt3DLsShKa6hMWFoYhQ4aoFvGaNWviiSeeQM+ePfNM9ynbkISmMqSrYcOG6v9u3bqp9URERHfrXm4Jc3RbVdCdmJiosonLTVy4cEHd115Bl/HVX375Jb7++mt1xVy6p8ljo0ePNul+saWbiMraXydvoM+c7dhz8Sa8XJ0w57FQfDigOTxcnfhhkFkTmko+lNImNJXWcXnuvffem6elO/82JTAv7jaJiMg+Xbew7uVWM6Z737596Nq1a+6yNonZ8OHDsXTpUtX9LDY2FtOnT1djyZo2bYqNGzeqMWKmlH9MNxGRqaRnZuPjP07iyx0X1HLTat6YP6QFavp5sdDJahOaypSdkl0/MzMT77zzTu7Un0JeW9JtckpP8+O0giwnfqf4t2du1++0dPuXcy0w7aY5pvS0mqC7S5cuqnCKMmbMGHUrS9LSLTfJXi5TjRERmUJEbDJeWHEAh67EqeWnOtTElD4N4ebM1m2y7oSm0p1cerP9999/aurPunXrqm7npd0mp/Q0P07pyXLid4p/e+Z27Xay+t81K0Xl+TL3lJ5WE3RbKrZ0E5Gp/Xr4GqasPYKEtEz4eLjgk4HN0aNJZRY82URC01q1aqn/mzVrhhs3bqjWbm3QXbly5RJvk1N6mh+nFWQ58TvFvz1zysrW4GZyprrfKLgKAvJ1MTfHlJ4Mug3Elm4iMpXUjCxM//U4lu/OyV3RMrgi5g4JQ7UKHix0stiEprrTeclyv379ir0daXWQ7uFa7du3V9vQnUZs8+bNRSZJ1U7pmR+n9CxbnNKT5cTvlHnwbw+ISUxVgbejAxDg7a43sC7rKT0ZdBMRWaCzUYkYt/wATl5PgPSkff7eOnixe324OFlN/kuyM5JrRab0atWqlQqWZeov3YSm0gJ99epVLFu2LLenWI0aNVRWcu283TNnzsQLL7yQu80JEybgnnvuwUcffaSC9w0bNuDPP/9UzyUiItLn6u2U3OnCnC3kvIlBt4HYvZyIjO3H/Vfw1vqjSMnIgl85V8waFIp76vuzoMmi3S2hqazTnbNbuvdJIC6zkTg7O6NOnTr48MMPMWrUqNznSIv2ypUr1fzdb731lnqOzAfetm1bsxwjERFZvsg7SdSqWlDPQAbdBmL3ciIylsS0TExdfxQ/hV9Vyx3rVsJng0MRUN4yprsgupuiEprKTCO6pEVbt1W7MAMHDlQ3IiKi4rh2p6W7ioVMFyYYdBMRWYBj1+LwwvJwnI9JUmOQJnWvj+e71IWTLBARERFRsVy7zZZuIiLKlzjqu/8u4b3fTqh5uOWqrCRLa13Tl+VEREREVEKRcTkt3VXZ0m07OKabiEorLiUDr/14GH8cy5kSqVvDAMx8NAQVvVxZqERERESGdC/nmG7bwTHdRFQaByJuqe7kkmHTxckBk3s3wjMda6opLIiIiIiodK5pE6n5MJEaEZFdys7W4Ivt5/HJplPIzNaghq8n5g8NQ/PqFcy9a0RERERWLS0zC9EJaep+1QpMpEZEZHdiE9Pw0ppD+OdUtFp+oHkVzHikGbzdXcy9a0RERERW70ZcTsDt5uwIXwsarsfs5QbimG4iKo5d52IxYWU4ohLSVEXwdt8mGNImiN3JiYiIiIzk2p0kapKY1pKG7DHoNhDHdBNRUbKyNZj7vzOY99cZZGuAugHlVHfyhpW9WXBEREREpshcbkFJ1ASDbiIiE7kel6pat3dfuKmWB7WqjnceagJPV/70EhEREZlqju4qFpRETfDMj4jIBP4+FYWXVh/CzaR0eLk64f3+zfBwWDWWNREREZGJpwuzpCRqgkE3EZERZWRlY+amU1i87bxablzFW3Unr+1fjuVMREREVCZBN1u6iYhs0uWbyXhhRTgOXr6tloe3D8aUPo3g7uJk7l0jIiIisnmRd+bolkRqloQt3URERvD7kUi8uvYwElIz4e3ujI8HhqBX08osWyIiIqIywpZuG8Upw4jsW2pGFt777Ti+/y9CLYfVqIB5Q8JQvaKnuXeNiIiIyG7Ep2YgPjVT3Wf3chvDKcOI7Ne56ESMWx6OE5Hxann0vXXwUo/6cHFyNPeuEREREdmVKzdzxnNX9HRBOTfL6tBtWXtDRGQlfjpwBW+uP4rk9CxU8nLFp4NC0KVBgLl3i4iIiMguXbmVrP4P8rW83oYMuomISiApLRNTNxzD2gNX1HL72pUw+7FQBHpbVsIOIiIiInty5VZOS3f1ipaVuVywD+Qdp06dQmhoaO7Nw8MD69evN++nQ0QWRbqR952/QwXcjg7ApO718f3Itgy4iYiIiCwm6PaEpWFL9x0NGjTAwYMH1f3ExETUrFkT3bt3N+dnQ0QWQqPR4IfdEZj+63GkZ2Yj0NsNcx8LQ9valcy9a0RERESE/+9ebokt3QYF3RkZGbh+/TqSk5Ph7+8PX19f2IKff/4Z3bp1g5eXl7l3hYjMLC4lA1N+OoyNR66r5fsaBmDmoyHw9XI1964RERERkS12L5dW4MWLF6NLly7w8fFRLcKNGzdWQXdwcDCeffZZ7N271+g7um3bNvTt2xdVq1aFg4OD3q7fCxcuRK1ateDu7o6WLVti+/btpXqv1atXY/DgwUbYayKyZgcv38YDc7ergNvZ0QFvPtAIXz7ZigE3ERERkcW2dHvCqoPuzz77TAXZX3zxBe677z789NNPqku2jIfetWsX3n77bWRmZqpu2b169cKZM2eMtqNJSUkICQnB/Pnz9T6+atUqTJw4EW+88QbCw8PRuXNn9O7dGxEROXPnCgnEmzZtWuB27dq13OfEx8fj33//RZ8+fYy270RkXbKzNfhi23kMXLRTXTUN8vXAj893wMjOteEog7mJiIiIyKJ6JsbfmaO7WgUr716+c+dO/P3332jWrJnex9u0aYNnnnkGn3/+Ob766its3boV9erVM8qOSgAtt8LMmjULI0aMwMiRI9Xy7NmzsWnTJixatAgzZsxQ6/bv33/X99mwYQN69uypWsuJyP7cTsnElO/24+9T0Wq5T7PKmPFIc/h4uJh714iIiIhIj6t3upbL8D8vC5ujW5Roj9asWVOs57m5uWHMmDEoK+np6Sqgnjx5cp71PXr0UBcKStq1/Lnnnrvr89LS0tRNt4VcZGdnq5sh5PWSuMnQ7dg6lhPLydj+OxeDCauOIzoxA67OjnjrgUYY2iZIDWnh3yP/9sz5G8XvHxERkXUmUROlvgyQkpKiTiY8PXP6zF+6dAnr1q1Do0aNVEtxWYqJiUFWVhYCAwPzrJdlSfRWXHFxcdizZw/Wrl171+dK6/m0adMKrI+OjkZqaioMPbmSfZHydXTkrG4sJ8Pw+3R3WdkaLN0Tia92RyJbAwRXdMN7fWqjnr+7+psmfqfM/beXkJDAryEREdFdkqgFWeB4boOC7n79+uGRRx7B6NGjcfv2bbRt2xYuLi4qAJau3s8//zzKmrRG6ZITnfzriiKJ4W7cuFGs506ZMgWTJk1S49vlJkH/2bNnVUI5b29vGHqiJvst22LQzXIyFL9PRYuKT8XLqw9h1/mbarlPI1/MGBiG8h7MTs7vlOX87XHIk+lJPS6zstztM5XnyMV1W6mfXV1dbeZYiMh+XbHgzOUGBd0HDhxQidXEjz/+qFqVJYGZtBJPnTq1TINuPz8/ODk5FWjVjoqKKtD6bSzShV5uL730krpJ93IJ2qXiMkblJSdqxtqWLWM5sZwMsfV0NCatOojYpHR4ujrh3X5N0LGaiwq4+bfHvz1L+o3i99F05AK9nD9IA0JxniuBt/Q8KMlFfUsm3y2Z+UWCbyIia3XZVruXy9zc5cuXV/c3b96sWr3lh7tdu3aqq3lZkopCMpNv2bIF/fv3z10vy9Iib0oLFixQN7lCTkTWISMrG59uPo3Pt55Tyw0rl8eCx1ugViVPdbGOiOyHNuAOCAhQQ+aKCqYl6JZZWpydnW0i6JYLCDKDS2RkJGrUqGETx0RE9t3SXc1Cg+5SX3qvW7eumiv78uXLKku4JC0TcsJqaPfqwuYHl+nJ5CYuXLig7munBJOu3l9++SW+/vprnDhxAi+++KJ6TLq/m9LYsWNx/Phxk8xNTkSmSbQxePGu3IB7WLtgrB/bEXX8y7G4iQy0cOFC1Woq3eHlYvj27dsLfa5MOypTjGqHZbVv316dT+haunSpCgTz3wzNnaIlF8y1AXelSpXg4eGh9t1ebnKRQcpfGlLkYgIRkTXSaDSIiE1S92v42tiYbulCPnToUBXcduvWTVWW2lbvsLAwGNu+ffvQtWvX3GUJssXw4cNVpTx48GDExsZi+vTp6oqtzL+9ceNGBAcHw5TY0k1kPf44eh2v/nhIzeNY3t0ZHw9ojt7Nqph7t4hswqpVqzBx4kQVeHfs2BGLFy9WU33KhWlpRc1v27ZtKuj+4IMPUKFCBXzzzTfo27cvdu/enec8QgLyU6dOmWSMu3YMtzYprD3SdiuXCxCSm4eIyNrEJqUjKT0L0lmnuq0lUhs4cCA6deqkAtyQkJDc9RKA63bxNpYuXbqoqxhFkWnKynKqMm1Lt9y0Y7qJyPKkZmRhxsYT+HZXztCX0KAKmDckDEEWejWUyBpJEtURI0Zg5MiRann27Nmq5XrRokVqxo/85HFdEnxv2LABv/zyS56gW1q2K1eubNJ9t+du1fZ87ERkGy7F5oznruztDncXJ9hE9/LXX39dTaslpBKUilE3wUubNm3QsGFD4+4lEVEpnY9OxCMLd+YG3KPuqY01o9sz4CYyovT0dOzfvz93qJmWLO/cubNY29AmKPP19S0wvEx6rVWvXh0PPvigStpKRESkFXHTsruWl6qlW1q2pdKTbOHSDUwSld1///0qk7c9YvdyIsu1Pvwq3lh3RHU58vVyxaeDQtC1QYC5d4vI5sh0odI9Of+MIbKcf2aRwnz66adISkrCoEGDctfJRXwZQtasWTPVo2zOnDmq6/qhQ4dQr149vdtJS0tTNy15nTaol5suWZZedNpbcWifV9znWzrtsesrn9LSlquxtmerWE4sK36njONizP8H3cX53THm315xt1HioFvGXMlO7tixQ3UBk+myrl69qsZlPfTQQyoglym87AW7lxNZnuT0TLy94RjW7L+iltvW8sWcx8JQ2cc440CJqHhdleV8oTjdl1esWIF33nlHdS+XpGZaMiOK3LQk4G7RogXmzZuHuXPn6t2WdGWfNm1agfXR0dEFErDJmG45YZIkYsVJJCbHo52txFK6ZUtZyO3GjRuqEUQSypZkuJsct5SB5MUx1phu2V5cXJwqL053x3Lid6rs2Ovf3ulrN9X/fm7ZxZqFxpjlJD20TDamWyqazp07q9vHH3+ssoVLAP7FF19g1KhRaNu2rQrAhwwZgmrVqsGWsaWbyLKcvB6PccvDcTYqUSXUGH9fPYzvVg9OjpZxgkxki+Riu/SAy9+qLSc/+Vu/9SVgk7Hga9asUUFjUeTkqHXr1jhz5kyhz5kyZUpuslVtS3dQUFBulnRdEoTLCZNMASa34rKUhGMy5O/HH39UvQHKlSunpm99//331fj64pLjlnKV7O3GSlAnJ7Ryrihlbk8n/iXFcmJZ8TtlHFFJOTPSNK4RkOfCbVn87RX3d7PUidR0NWrUSN1effVVVcFKAP7zzz+rx15++WXYMrZ0E1kGuVq5Ys9lTPvlGNIysxFQ3k21brevU8ncu0ZkFxmwZYqwLVu25EmmKssyDK2oFu5nnnlG/f/AAw8U6+9cpguV7uaFkeFu+oa8yYlV/pMrWdadiqw47699nrlbumWqUmn4kP+l9V9Iw4cE4J999lmxt6M9dn3lYwhTbNMWsZxYVvxOGe7SzZw5umv6lSv2b46x/vaK+3qjBN265OqCXLGWGxFRWYhPzcCUn47gt8ORarlLA398+mgIKpWzz1wTROYgrcvDhg1Dq1at1DSiS5YsQUREBEaPHp3bAi3D0ZYtW6aWJdB+8skn1Tht6UKubSWXubK13aOlm7g8JuO3pcVaupRL0C29zOzdzJkzcd999+UG3EJabWR8PRGRvUhKy0RMYk4ejxqVbCiRWv5uWYcPH1at2/kHkUv3ciIiUzt85bbqTh5xMxnOjg54pWcDPNu5NhzZnZyoTA0ePFiNC54+fbpKutq0aVNs3LhRZR4Xsk6CcC2Zx1vGE2t7jGkNHz5ctdaK27dv47nnnlMBuQTiMmOKzO8tM6XYM0kUJ70KJfDWlZKSwulLiciuRNzMmS6sgqcLfDwsY+iPUYPuP/74Q12h1ndFVZrrtYlGbB3HdBOZh3Tz/GrHBXz0x0lkZGlQrYIH5g0NQ4saFfmREJnJmDFj1E0fbSCt9c8//9x1e9JNuiRdpe3FgQMHVIAtyWxlaJ9uYriuXbuadd+IiMwxR3ewBU8XZlDQPW7cODz66KOYOnXqXZOk2DKO6SYqe7eS0vHKj4fw54mcDJW9mlTGRwOaw8fTcq9wElkaCdCkBTk5OVl1S84/P7a9k1Z43QYEGbcnScek3GS9dky3JJCT9TJXue40YrJOHsu/XpKwybZ0pzXTbqO4Tp8+rZL3HDlypEAvQ8nwTkRkd3N0V/KCTQbd0qVcxm/Zc8BNRGVvz4WbmLAyHJFxqXB1csRbDzbCE+2CzZ7UiMgaJCYm4ocfflDjqffs2ZMn8KtevTp69OihunNLhnB7J1Ojbt26NXdZurb37dsXmzdvVvOEa917773o0qULVq9ejXPncjLoCnmujLf+8ssv1XRlWo8//jjq1q2rMoxLQK67jeKS8e2SQ0e2oyVd90+ePIkBAwbkdt+Xm7xH8+bNsXz5cgNKg4jIMl2y9ZbugQMHqq5hderUMe4eERHpkZWtwcK/z+KzP08jWwPU9vNS3cmbVC3+fLRE9ky6act0UjVr1lQtopMnT1bTekrisps3b+Lo0aPYvn07unfvrpKXydzPksDMXnXq1EklhMufoVYuTPTq1StPS7cYNGhQgZZuMXLkyAIt3UJ3WjPtNkoyRZsE3rrZ1OWz7dOnDxo3boxbt26pRHaS2Vy2LWPjiYhsOeiuYcFJ1AwKuufPn6+6l0sFLVN35J+zcvz48cbYPyIiRCWk4sVVB/Hv2VhVGo+EVcO7DzeFl5vRJ2Agslk7d+7E33//Xeh0W5KcTKbv+vzzz/HVV1+pVl57Drr1zd0tQa6c78j6/L1rZNo0fQpbr29as+KSrOWSzPbDDz/EkCFDVCu2TNUqvRe0+y5J7V577TU8/fTTaNKkSanfi4jIkl2IyeleLo0xlqzUZ6zyA79p0yZ1hVxavHUrH7lvL0E3E6kRmdb2M9Eq4I5JTIeHi5MKtge2rM5iJyqhNWvWFOt5EgwWlgyNLIMM7ZPEdK+88greffddFYRLd/igoCD1ePny5dV47/Xr16ueiZ988gkefPBBc+82EZFRpWZk4ertnDm6a9lq0P3mm2+qaUGke5qhk4pbMyZSIzKNzKxszNpyGou2noP0zGxYuTzmDw1D3YDyLHIiA8m45JCQEOZlsfIp2uSmz5kzZ1QvBZk3XXok6o7dJyKyFRdjc1q5ZaowXy/9vYqsPuiWxBzyY2/PATcRmYZctRy/Ihz7L91Sy4+3rYG3HmwMd5eSjXskIv0eeeQRNeWUZC2X4Ds0NFSNVe7WrRuLzAZI6/fu3bvh6emJzp07o3///ubeJSIio7sQnZTbym3pCXVLHXQPHz4cq1atwuuvv27cPSIiu7b52HW88uNhxKVkoLybMz4c0BwPNK9i7t0isikJCQk4deqUysItN5n3ee7cuSqB2q+//govL8vupkdFW7ZsGYuIiGzeeSsZz21Q0C1zVH788cdqXLdMRZE/kZpMhUFEVFxpmVmYsfEklu68qJZDqvtg3pAWFp+NksgayfzcDRs2VDdtF2WZ1kqmm5JWUknQRUREZMnO67R022zQLQk6ZM5KIdOM6LL05n0isiwXY5IwbsUBHL0ar5af7VwLr/RsCFdnDl8hMgWZKkymnZJu5dru5VKnywVzmXaKQTcREVm6CzGJ6v9a/jYcdMu0I8Ts5USG2nDwKt5YdxSJaZmo6OmCTweF4L6GgSxYIhM6ffo0Dh8+rG7SvXzt2rW4ePGimt4qIyMDTzzxBFq3bq16snXt2pWfBRERWfB0YeVgU0F3REQEatSoUeznX716VV1Nt2XMXk5UOinpWZj2yzGs3HtZLbep6Ys5Q0JRxceDRUpkYnXr1lU3SaimFR8fry6oS9ItmY/6u+++w/Hjx5GcnMzPg4iILMqtpHTcSs5Q92v6edpW0C1XvR966CE8++yzaNOmjd7nxMXFYfXq1ZgzZw5GjRqFF154wVj7SkQ24vSNBIxbfgCnbyRCRqO80LUuxnerB2cndicnKgs+Pj6qS7n2Ji3a5cqVw8aNG1GnTh388MMPuflbiIiILM2FO9OFVfFxh6drqTtvl5kS7eGJEyfwwQcfoFevXipxWqtWrVC1alW4u7vj1q1b6or4sWPH1PpPPvkEvXv3Nt2eE5HVkdazVXsv451fjiE1Ixv+5d0wZ3AoOtT1M/euEdmVb7/9Njdz+S+//KK6lgvJWr5mzZrc5zk5cZo+IiKyPOetKIlaiYNuX19fzJw5E++99566Gr59+3ZVUctcn5KQ5fHHH0fPnj3RtGlT0+0xEVmlhNQMvL7uKH45dE0td67nh88Gh8KvnJu5d43I7jz88MPqppWYmIjIyEg1JEzmdiYiIrKKJGp+Nhh0a0nLtowD0x0LZgs+++wzfPnll6o17v7771dd5JmJnchwR67Eqezkl2KT4eTogJd7NMCoe2rD0ZEzHRCVlaLyskjX8nr16tldXhYiIrJO56LuJFHzt/wkaoIDKO+Q+Unnz5+P/fv3q+nQ5P///vvPvJ8OkZWTC1jf/HsBjyz6VwXc1Sp4YPWodni+Sx0G3ERlTPKySE6WPXv2FPocycvyxRdfqB5rP/30U5nuHxERUXGdiUpQ/9cPtI6g2/JHnZehzMxMpKamqvsyZUpAQIC5d4nIat1OTscrPx7GluM31HKPxoH4eGBzVPB0NfeuEdkl5mUhIiJbkJ6ZjYuxOTNr1A2wjqDbalq6t23bhr59+6rEbdLle/369QWes3DhQtSqVUt1f2/ZsqUac15c/v7+ePnll1XXO3kP6V4uGVyJqOT2XbyJPnO2q4Db1ckR7/RtjMXDWjLgJjIjbV6Wa9euYdGiRahfvz5iYmJw5swZ9bjkZZFeXv/++y8ToVoRGQon5z4yFl/G6UtvBSIiW3YxNglZ2RqUc3NGZW93WAOraelOSkpCSEgInn76aQwYMKDA46tWrcLEiRNV4N2xY0csXrxYnTRIRnXtGDYJxNPS0gq8dvPmzfDw8MCvv/6qEsPJfXmtBPr33HNPmRwfkS3IztZg0dZzmLXltPoxrFnJE/OHtkDTaj7m3jUisvG8LPbo9ddfV9nmJRu9jMuXOdanTZuGWbNmmXvXiIhM5syNxNxWbmvJv2U1QbcEwUVNQSYVzIgRIzBy5Ei1PHv2bGzatEldzZ8xY4ZaJ1fwCyOVVt26dVVLgHjggQfUmO7Cgm4J3nUD+Pj4ePV/dna2uhlCXi9jYQ3djq1jOVlWOUUnpOGlNYew42ysWu4XWhXv9muirkJay3eZ3ymWk6V+n4yxjYSEBBWQyQVmaeGWubobNGiATp06qYvZcp+sx969e/HRRx+p/1u0aKHWjRo1CkuXLmXQTUQ27WxUTtBdz0q6lhscdMu45+vXryM5OVl1z9YGrGUtPT1dBdSTJ0/Os75Hjx7YuXNnsbYRFBSknitjumUO8n/++QfPPfdcoc+XQF5OXvQlZNOOCzfk5Eq6h8nJmqOj1YwAKHMsJ8sppz0R8Xjnjwu4mZwJN2cHvNK1Bh5oXAnJcTeRM+LGOvA7xXKy1O+TBMyGevLJJxEeHq4CM6mzpe5+9dVXcenSJbz11lt48MEHVW8xZiy3DjJU4L777ssNuIV8rnJBhYjIHpKo1bXloFvm8vzhhx+wYsUKlQFVt7W3evXqKtCVYFWypJYVqWCysrIQGBiYZ70sy0WB4mjXrh369OmDsLAwdXLUrVs3PPTQQ4U+f8qUKZg0aZLK8io3ef+zZ8+qCs/b29vgEzXpKiHbYtDNcjKUKb9PmVnZmPO/s1i49Rw0mpwMkvMeC0W9wPKwRvzbYzlZ6vdJuoQbSoZSyXjt0NDQ3HVvvPEGfvnlFzg7O+P9999HmzZtsGPHDjVGmCyXnHvJ5yaBt66UlBTVg4GIyC5augNtNOiWeaylUq5Zs6YKSKVlWa6Iyxjomzdv4ujRoyp5Wffu3VUQO2/evALzfppS/j790rpQkn7+cmxyKw43Nzd1e+mll9RNupdLRScnVsYIbGS/jbUtW8ZyMl85RcalYPyKcOy9eEstD2kThKkPNoGHqxOsGb9TLCdL/D4Z429XLkRLfhR9JPeJ5EL54IMPMGHCBPz8888Gvx+ZzoEDB1SALecf0ltBtwdi165dWfREZLMys7JxPjqnLqsXUN42g27pfv3333+jWbNmeh+XK+TPPPMMPv/8c3z11VfYunVrmQTdfn5+cHJyKtCqHRUVVaD129gWLFigbtLSTWQv/jx+Ay//eAi3kzPUmO0PHmmGh0Kqmnu3iKgIEkxLHb169WqVmFQfyWAugTflTCMqF+9lyJncF3KuIYGtkPVyXy6sSE8BGeomj8st/315XC6cSAu1vC7/fdm+PKe4Tp8+rXo/HDlyJM96aRCRZLL5yTmK7AsRkbWLuJmM9KxsuLs4oloFD1iLEl06l2Rj2oBbuqnduJEz/25+0gI8ZsyY3KRmpubq6qoyk2/ZsiXPelnu0KGDSd977NixKkO6JDIhsod5Eaf/chwjl+1TAXezaj749YVODLiJrCToloRpUl/26tVLXSDXdoHXkqFjciGboLrZ//7776oo/ve//6mb9vxHHhMyfam2/peLGYcOHVL3v/vuO5w8eVLd//LLL3H+/Hl1Xy7SX716NTcBrHb8tXZ7xSW96wICAlQCWO1NzoXkPbUzvEjyWWkFl4Swy5Yt40dKRDbVtbxuQDk4OlpH5nKDEqnJVCPStUnGqskVcxkjJuO5ZSy0KchYchkzrXXhwgUcPHhQJW+TbnEyvnrYsGFo1aoV2rdvjyVLliAiIgKjR4+GKbGlm+zFpdgkvLAiHIev5MwB+0zHWnitdwO4ObP1hMhaSCu2TCslY4Gla7LU402bNlUBnARykghUsl8TVFZ3aekWuuc2cq4jLdRC5sXWXrQYNGhQbmuynI9o70sDhLYVWy7Ua18r5y3a+/JeJSEXRuTz0h1GJ8PjJDdN48aN1bIM+ZOLKzL9KRGRrTijDbr9rWc8t0FBt2RSPXXqlLqqKzcZXzR37lw1llumI/Hy8jLqju7bty/POCWprMTw4cPVCcLgwYMRGxuL6dOnIzIyUp1EbNy4EcHBwTAlqUDlph3TTWSLfjl0DVN+OoLEtExU8HTBzIEhuL+xaYduEJFpSKLTVatWqW7PUndLV2WpwySQk2zYEoAT8nT31t7XdjfXLmuDZiEtzXe7Lz0B9d0vSddyIZ+TXCD58MMPMWTIECxfvlyNw5cEt0Ky5kswLr0biIhsyYnInGmaG1YxLHG11QTdMn66YcOG6iYBr3a6LOnW9O6776qKwJi6dOmSe8W5MNKlXW5EZBypGVmY9stxrNgToZZbBVfE3CFhqGpFY2iISD8JBuVCudzIuki+GmlweOWVV9Q5lwTh0kVdpj/VtnKbengdEZE5nLqeM11Yg8rWk0RNlDodqmQtl6vh0s1KfvRlGjEJumWM0tdffw17Id3LpStXWU6RRlQWztxIQL/5/6qAW3ovjutaFyufa8eAm4gKJfN8y3RjkuRLxo7LjCaF+emnn9RsJ9qpNmVo2KZNmwo8b+3ataqelZZh+X/dunX8BADV4CHD6GS+delhWKdOndxykaC7sKS3RETW3Bh0PiYnc3mjyt72EXRLdzRJwiJXUmWs9VtvvaW6dMu4JOnm/cQTT2DOnDkq27ktYyI1sjXSo2T13st4aP6/OHUjAX7l3PDdM23xcs8GcHbiFHZEpJ90WZ84caKa+zs8PBydO3dWybwkMNRHxhpL0C1Dwfbv36+GkPXt21e9VmvXrl0quJQx0jKUTf6XsdO7d+/mx1CEY8eOMegmIptMopaVrYGPhwsCvf9/iI5Ndy/XZsuUhGpaMiZMgmxJ0iIn7pK9UzJ7y1VYIrJ8Mmb7zXVHsP7gNbXcuZ4fZg0KhX956/phI6KyJz3dRowYkTtzyezZs1XL9aJFizBjxowCz5fH8yd527BhA3755ReEhYXlPkcC8ylTpqhl+V+mI5X1kmmd9JMcO0REttq1vGHl8nlm3rDpoFuShknGcu2tefPmKFeunLpiLV2cpLu5sPX5q5m9nGzF0atxKjv5hZgkODk6YFL3+nj+3jpWNR0DEZmHJGWT1urJkyfnWS9D0Hbu3Fmsbcj0ZZKkVWYl0W3pfvHFF/M8r2fPngUCdl0y/7XcdBsEtNuXW/73lEYC7a04tM8r7vMtnfbY9ZVPaWnL1Vjbs1UsJ5YVv1OlTKJWubxBvy/G/Nsr7jZKHXR/++23uZnL5ar0xYsX1XrJWi7zeWtpp8ywVcxeTtZOfnSW7bqE9387gfSsbFT1cVfJ0lrV/P8TXyKiosh803KRXRJ86ZJlSbxaHJ9++imSkpJU93EteW1Jtymt6tOmTSuwXvLOSMZvXRkZGeqEKTMzU92K83upbUywtlaWwshxSxnI0EDdbOyGkO1JBnUpL0dHDktiOfE7VVZs/W/vSESs+r+KpwZRUVEWUU5ysdikQbfMTSk33Xm0ZaouSbDm6elZ2s0SURmKS87Aq2sPYdOxG2r5/kaBmPloc1Tw/P8pboiIiit/IKo7j3RRpKv4O++8o7qX55+yrKTblC7o2mlFtS3dktVbm7BNlwThcsIkU3aVZNouYwWnlkCOW046K1WqpBLgGYOc0MpnJGVuiyf+xsJyYlnxO1Uy528dVf+3qS8JvSvAEv72ivu7WaKgW5Kh1KhRQ+9j0rW8Xr16edZdvXpVBeG2jN3LyVrtv3QL41eE4+rtFLg4OWBK70Z4umNNm2m9IaKyI3N8S8+2/C3Q0hKRv6VaXwI2GQsuveTuv//+PI9Vrly5xNuULOe6c2BryYlV/pMrWZbfPO3tbnQDflv5rdQeu77yMXS7xt6mLWI5saz4nSqe2MQ0RCfkDB1qUNnb4N8WY/3tFff1JXoXmRbr2WefxZ49ewp9jjTVf/HFFyqTuUwHYuuYvZysTXa2Bov+OYdBi3epgDu4kid+er4jnulUy2ZOIomo7Of8linCtmzZkme9LBc1X7S0cD/11FNYvnw5HnjggQKPyzRi+be5efNmzkFNRGSnSdSCK3nCy63UnbXNpkR7fOLECZVdtFevXqprVatWrVC1alXVrH7r1i2VqVymqZD1n3zyiZoqhIgsR0xiGiatPoRtp6PVct+Qqvigf1OUd7edrpJEZB7SpVum9JJzAAmWlyxZonrIjR49Orfbt/SAW7ZsWW7A/eSTT6rpRdu1a5fbou3h4aGStYoJEybgnnvuwUcffYR+/fqp7ud//vknduzYYdR9t5WkaKVhz8dORNbj2LV4q5yfu1RBt2QUnTlzJt577z2VpXz79u0qgVpKSorqWvb444+rrKLSyk1ElmXnuVi8uPqQ6prj7uKId/o2weDWQWzdJiKjkPm0JRnX9OnTVY4XOReQc4Xg4GD1uKzTnbN78eLFKomXNiGp1vDhw7F06VJ1X1rJV65ciTfffBNvvfWWmh1FuqO3bdvWKPusHZstU5tKsG+vmeftIfEtEVm3o9fi1P9Nq9lB0C0WLlyIMWPGqPm5defoJiLLlJmVjSW7ruGbPZGQBo16AeUwf2gLNKhc3ty7RkQ2Rs4P5KaPNpDW+ueff4q1zYEDB6qbKUigWaFChdwsuJIItqhhNtIqLBcKJPmYLQzHkWRCktVdjrskieSIiMzV0t2kWk5PKGtT4l/YV155BWFhYarrWGGki5gkP7EHTKRGlux6XCrGrziAPRdvqeXBrYLwzkNN4OHKFg0iIqE9XynO9DPaeV21CdhsgRyLJMm1leMhItuTnJ6Jc9GJ6n7TqnYSdL///vsYMGAAwsPD9WYPlfUy7kq3C5kt4zzdZKn+OnkDL60+hFvJGfB0ccT7/Zuhf4vq5t4tIiKLIsFmlSpV1FRlMm93UbTzWcv0WraSlVuS4NnKsRCRbToRGa96awZ6u8G/fMHZKWwy6J44cSL27t2rAm/pGqbbHUkSnMi47r59+xp7P4momNIzs/HxHyfx5Y4LarlpVW9M7R6EVg2qsgyJiIroan63cc0SdMs4cEkgy0CViKhsHL16p2u5lbZyi1Jd2vzyyy+RlJSEF154IXedZCuXMVevvvqqykhKRGUvIjYZj36+MzfgfqpDTawZ3Q41Krrz4yAiIiIiq3P06p0kalWtM4maKFXWDMnwKXNwy7zdzZs3x/79+1V2UblJCzgRlb3fDkdi8trDSEjLhI+HCz4e2Bw9m1RWLTNERERERNboqJUnUStV0D1y5Ei0bNlSJVOTFm9p3a5WrZqaMzM0NNQ0e0lEhUrNyMK7vx7HD7tz8ii0DK6IuUPCUK2CfU5/Q0RERES2IS0zC2duJKj7Te0p6D59+jTWrFmDhISE3CkzZC5OmbNbupxL4O3l5QV7wezlZE5noxIxbvkBnLye82M0pksdvNi9PlycmBSHiIiIiKzbycgEZGZrUMHTBVV93O0n6N62bZv6/8yZM6pb+YEDB9T/b7/9Nm7fvq0Si9SvXx/Hjx+HPWD2cjKXH/dfwVvrjyIlIwt+5Vwxa1Ao7qnvzw+EiIiIiGzCoSu31f8h1StY9dSGpRrTLerVq6dujz32WO66CxcuYN++fWraMCIyjaS0TBVs/xR+VS13rFsJnw0KRYC39V79IyIiIiLK7+DlO0F3UAVYs1IH3frUqlVL3R599FFjbpaI7jh2LQ4vLA/H+ZgkODoAk7rXx/Nd6sJJFoiIiIiIbDDoDmPQTUSmptFo8P1/l/DubyfUPNyVvd1VsrQ2tXxZ+ERERERkc+JSMnA+Okndb17depOoCWZb0jFz5kw0adJEJYb7/vvvzfepEOX7wRnzwwG8teGYCri7NQzAxgmdGXATERERkc06ciVnfu4gXw9UKucGa2bU7uXW7MiRI1i+fLlKCie6deuGBx98EBUqWPf4AbJu4RG38MKKcFy5lQIXJwe81qshRnSqZdWJJIiIiIiI7ubg5Vvq/9CgirB2bOm+48SJE+jQoQPc3d3VTaY+++OPP8z76ZDdys7WYPHWc3j0810q4JYrfD+O7oCRnWsz4CYiIiIim3fwck5Ld4iVdy23qqBbpirr27cvqlatqoKO9evXF3jOwoULVSI3CZpbtmyp5g4vLulS/vfff6tpz+T2119/4erVnOzQRGUpNjENz3y7FzN+P6nmJXygeRX8Nr6z1WdtJCIiIiIqbj4jbRK1UBs4B7aa7uVJSUkICQnB008/jQEDBhR4fNWqVZg4caIKvDt27IjFixejd+/ear7wGjVqqOdIIJ6WllbgtZs3b0bjxo0xfvx43HffffDx8UHr1q3h7Gw1xUM2Yte5WExcFY4b8Wlwc3bE232bYEibILZuExEREZHduHIrBTGJaXB2dECTqtbf0m01UaUE0HIrzKxZszBixAiMHDlSLc+ePRubNm3CokWLMGPGDLVOO167MKNGjVI3IdupW7duoc+V4F03gI+Pj1f/Z2dnq5sh5PVydcfQ7dg6WyqnrGwN5v99FvP+OotsDVDH3wvzhoShYeXy6hjlVlq2VE6mxrJiOVnq94l/v0REZE/2X8oZz92kmg88XJ1g7awm6C5Kenq6CqgnT56cZ32PHj2wc+fOYm8nKioKAQEBOHXqFPbs2YPPP/+80OdKID9t2rQC66Ojo5GamgpDT67i4uLUyZqjo9WMAChztlJO0YnpePuPCzhwJVEtP9i4El7qGgQPxxRERaUYvH1bKaeywLJiOVnq9ykhIcFo+0VERGTp9l68qf5vFWz9SdRsJuiOiYlBVlYWAgMD86yX5evXrxd7Ow8//LAaz+3l5YVvvvmmyO7lU6ZMwaRJk/K0dAcFBcHf3x/e3t4w9ERNxq3Lthgk2XY5bT0djZdWn8TN5Ax4ujrhvX5N8HBYNaO+hy2UU1lhWbGcLPX7JLlKiIiI7K2lu3VNBt0WJ/80StK6UJKplUrSKu7m5qZuCxYsUDcJ+oWcWBkjsJH9Nta2bJm1llNGVjZmbjqFxdvOq+XGVbwxf2gYavuXM8n7WWs5mQPLiuVkid8n/u0SEZG9iEvJwKkbOT28Wgb7whbYREu3n58fnJycCrRqS3fx/K3fROZ2+Waymntbm5FxePtgTOnTCO4u1j9ehYiIiIjIEAcibkHSGdWs5An/8m42UZg20ezl6uqqMpNv2bIlz3pZlrm3TWns2LEqQ/revXtN+j5kG34/Eok+c7ergNvb3RmfP9EC0/o1ZcBNRERERARg/8VbNtXKbVUt3YmJiTh79mzu8oULF3Dw4EH4+vqqKcFkfPWwYcPQqlUrtG/fHkuWLEFERARGjx5t1v0mEqkZWXj/txP47r9LajmsRgXMfSwMQb6eLCAiIiIiojv2XbppU+O5rSro3rdvH7p27Zq7rE1iNnz4cCxduhSDBw9GbGwspk+fjsjISDRt2hQbN25EcHCwSfcr/5huovzORydi7PJwnIjMmVZu1L218XKPBnBxsomOJkRERERERpGWmZU7BLMVg+6y16VLl7vOVTxmzBh1K0vSvVxukr3cx8f6J24n4/rpwBW8uf4oktOzUMnLFZ8OCkGXBgEsZiIiIiKifA5G3EZqRjb8yrmhjokSDJuD1bR0Wyq2dJM+SWmZmLrhGNYeuKKW29euhNmPhSLQm9P+EBERERHps+t8rPq/XW3fEs1CZekYdBuILd2Un3QjH7f8AM5FJ8HRAZjQrT7G3VcXTrJARERERER67TqXE3S3r1MJtoRBN5GRyPCHH3ZHYPqvx5GemY1AbzfMeSwM7Wrb1o8GEREREZEpEg+H3xnPLb1EbQkzORmhe3njxo3RunVr43wiZJXiUzMwbnm4Gr8tAXfXBv7YOL4zA24isisLFy5ErVq14O7urqby3L59e6HPlaSnQ4cORYMGDeDo6IiJEycWeI4kSpXuhflvqampJj4SIiIyx/zc6ZnZCCjvhlp+Xjb1ATDoNhDn6aZDl2/jgbnb8duRSDg7OuCNPo3w1fDWqFTOjYVDRHZj1apVKnB+4403EB4ejs6dO6N3795q+k590tLS4O/vr54fEhJS6Ha9vb1VgK57k6CeiIhsy386XcttaTy3YPdyolLKztbgqx0X8NEfJ5GZrUH1ih6YNyQMYTVsZ05BIqLimjVrFkaMGIGRI0eq5dmzZ2PTpk1YtGgRZsyYUeD5NWvWxJw5c9T9r7/+utDtyolX5cqV+UEQEdm4ndqg28a6lgsG3QZi9nL7dDMpHS+vOYS/Tkap5T7NKmPGI83h4+Fi7l0jIipz6enp2L9/PyZPnpxnfY8ePbBz506Dtp2YmIjg4GBkZWUhNDQU7777LsLCwgp9vrSgy01LpvQU2dnZ6mYIeb3k7zB0O7aO5cRy4neKf3ulGaoZnjue29ekv7PG/I0q7jYYdBuI2cvtz+7zsZiw8iCux6fC1dkRUx9sjMfb1rC5bjBERMUVExOjguLAwMA862X5+vXrpS7Ihg0bqnHdzZo1U8GztIx37NgRhw4dQr169fS+RlrVp02bVmB9dHS0wWPB5eQqLi5OnazJOHRiOfH7VDb4t2f75fTP2VvIytYgqIIb3DITERWVaBXllJCQUKznMegmKib5IVjw91nM/vM0sjVAbX8vzB/SAo2rerMMiYjudAXXJSc0hlyQbNeunbppScDdokULzJs3D3PnztX7milTpmDSpEm5yxKsBwUFqfHjMj7c0BM1OR7ZlrWd0JYllhPLid8p/u2V1OGdOb1HuzasjICAAKv5jSpujhEG3UTFEBWfiomrDuaONRnQojqm92sCLzf+CRER+fn5wcnJqUCrdlRUVIHWb0PIyZHMFnLmzJlCn+Pm5qZu+l5rjEBZTtSMtS1bxnJiOfE7xb+94tJoNNh+Nkbdv7dB2VzUNNZvVHFfzxqD6C62no5G7znbVcDt6eqETx8NwaeDQhhwExHd4erqqqYI27JlS54ykeUOHToY9cTs4MGDqFKlCsueiMhGXIxNxuWbKXBxcrDZ6XbZTGcgJlKzXRlZ2fh082l8vvWcWm5YuTzmD22BugHlzL1rREQWR7p0Dxs2DK1atUL79u2xZMkSNV3Y6NGjc7t9X716FcuWLct9jQTQ2mRpMuZaliWAb9y4sVovY7Ole7mM35Zu4tKlXJ4jdS8REdmG7Wei1f+tgn1ttlHLNo+qDDGRmm26cisZ41eE40BEThbFJ9rVwJsPNIa7i5O5d42IyCINHjwYsbGxmD59uppLu2nTpti4caPKPC5kXf45u3WzkEv28+XLl6vnX7x4Ua27ffs2nnvuOdVt3cfHRz1/27ZtaNOmTRkfHRERmco/p3KC7s71/Wy2kBl0E+Wz6dh1vLLmEOJTM1He3RkfD2iO3s3YlZGI6G7GjBmjbvpIFnJ93cWL8tlnn6kbERHZpuT0TPx7Zzx3t4bGywFiaRh0E92RmpGFGRtP4Ntdl9RySFAFzB8ShiBfT5YREREREZGR7TgTg7TMbFSv6IH6gbY7hJNBNxGACzFJGLf8AI5di1fl8dw9tfFyjwZqHm4iIiIiIjK+/53ImSrs/kaBBk0xaekYdJPd23DwKl7/6QiS0rNQ0dMFswaFomtD084PSERERERkz7KzNfjfyf8Pum0Zg24DMXu5dY8heefnY1i974pablPLF3MfC0Nln+JNck9ERERERKVz6MptxCSmobybszoPt2UMug3E7OXW6dT1BIxdfgBnoxIhPVnG31cP47vVg5Oj7XZrISIiIiKyFFuO31D/31Pf3+aHdDLoJrsimXJX7r2sWrglaUNAeTfMfiwUHerY7hQFRERERESWdk7++9Hr6n6PJrbdtVww6Ca7kZCagSk/HcGvhyPV8r31/fHpoBD4lXMz964REREREdmNk9cTVCJjaeHuZuPjuQWDbrILh6/cxrjl4Yi4mQxnRwe80rMBnu1cG47sTk5EREREVKZ+P/L/jWDl3Gw/JLXtzvOF6N+/PypWrIiBAwcWeOzXX39FgwYNUK9ePXz55Zdm2T8ybteVr3ZcwIBFO1XAXa2CB1aPbo9R99ZhwE1EREREZIbz89/uBN19mlW2i/K3y6B7/PjxWLZsWYH1mZmZmDRpEv766y8cOHAAH330EW7evGmWfSTD3UpKx7PL9uHdX48jI0uDXk0qY+P4zmhRoyKLl4iIiIjIDM5EJeJcdBJcneyja7ndBt1du3ZF+fLlC6zfs2cPmjRpgmrVqqnH+/Tpg02bNpllH8kwey/eRJ+52/HniSj1B/1uvyZY9EQL+Hi6sGiJiIiIiMzkl0PX1P+d6/nB290+zs0tLujetm0b+vbti6pVq8LBwQHr168v8JyFCxeiVq1acHd3R8uWLbF9+3ajvPe1a9dUwK1VvXp1XL161SjbprKRla3B/L/O4LEl/yEyLhW1/bywbmwHDGtfU32fiIiIiIjIfF3L14XnxFf9wv4/7rJ1FjdqPSkpCSEhIXj66acxYMCAAo+vWrUKEydOVIF3x44dsXjxYvTu3RvHjx9HjRo11HMkEE9LSyvw2s2bN6tgvqgvQX4M1KxHVEIqJq06hB1nY9Ry/7BqePfhpnaRnIGIiIiIyNLtv3QLV26lwMvVCd3tpGu5sLhoRAJouRVm1qxZGDFiBEaOHKmWZ8+erbqAL1q0CDNmzFDr9u/fX6r3llZu3ZbtK1euoG3btnqfK0G9bmAfHx+v/s/OzlY3Q8jr5QKAoduxdbrltP1MDCatPoTYpHR4uDhh2kONMaBFNXXRxN7Lkd8nlhW/U9b/t2fvv2NERGQb1t1p5e7VtAo8XJ1gLywu6C5Kenq6CqgnT56cZ32PHj2wc+dOg7ffpk0bHD16VAXe3t7e2LhxI6ZOnar3uRLgT5s2rcD66OhopKamGnxyFRcXp07WHB0tbgSAxZByunnrNhb9exXf7bsB6adQp5I73nugNmr5uqrPgvh9Kul3in97LCdL/D4lJCQYbb+IiIjMIT0zG78ezsla/kgL++labnVBd0xMDLKyshAYmLcrgixfv3692Nvp2bOnyk4uXdll3Pa6devQunVrODs749NPP1WJ1uRk6dVXX0WlSpX0bmPKlCkq07luS3dQUBD8/f1VwG4IeW9poZVtMegu3JWbSXj9z9M4HJmkloe0CcJbDzSCu4v9XDUrDn6fWFb8Tln/357kMCEiIrJm/ztxA3EpGQj0dkO72vpjLFtlVUF3YeOspRWhJGOvi8pI/tBDD6nb3bi5uanbggUL1E0uBgg5sTJGoCzHY6xt2aItx2/g5TWH1B+ujNn+aEBzPNC8irl3y2Lx+8Sy4nfKuv/2WBcQEZG1W7H3svp/QIvqcHK0rwTHVhV0+/n5wcnJqUCrdlRUVIHW77IyduxYdZOWbh8fH7Psgz1Jy8zCh7+fxDf/XlTLjQI9sWhYa9T0K2fuXSMiIiIiIj0u30zG9jM5Qz8Htw6yuzKyqmZUV1dXlZl8y5YtedbLcocOHcyyT9LK3bhxY9U9nUzrYkwSBizamRtwj+hUE0sGNUANX08WPRERERGRhVqz/wpkoqgOdSohuJIX7I3FtXQnJibi7NmzucsXLlzAwYMH4evrq6YEk3HUw4YNQ6tWrdC+fXssWbIEERERGD16tFn2ly3dZePnQ9fw+k9HkJiWiQqeLvj00RB0beCvejkQEREREZFlysrWYM2+nK7lj7XJmeLZ3lhc0L1v3z6VyExLm6xs+PDhWLp0KQYPHozY2FhMnz4dkZGRaNq0qcoyHhwcbJb9zT+mm4wrJT0L0345hpV3xoC0qemLOUNCUcXHg1PoEBERERFZuD9P3EBkXCoqerqgR2P7mZvbooPuLl26qMRoRRkzZoy6WQK2dJvO6RsJGLf8AE7fSITkyRvXtS4mdKsHZyerGhVBRERERGS3lt4ZGiqt3PY6y5DFBd3Whi3dxicXXVbvu4y3fz6G1Ixs+Jd3w+zBoehY188E70ZERERERKZw6noCdp2PVdnKn2hnnp7JloBBt4HY0m1cCakZeGPdUTWGW3Su54dZg0JV4E1ERERERNZj6c6cVu6eTQJRrYIH7BWDbrIYR6/Gqe7kF2OT1dWwl3rUx+h76sDRzubxIyIiIiKydrGJaVgXfkXdf6pDLdgzBt0GYvdy43Qnl6tgMzaeRHpWtroKNndIKFoG+xph60REREREVNa+3XlRDRVtXt0HrWtWtOsPgEG3gdi93DC3k9Pxyo+HseX4DbXcvXEgPhnYHBU8XQ39aIiIiIiIyAxkmt9vd11S95+/tw4cJCuyHWPQTWaz/9JNvLA8HNfiUuHq5IjX+zTE8A417f6PkoiIiIjImq3cE4G4lAzU9vNCjyaVYe8495IRupc3btwYrVu3Ns4nYgeyszVY8PdZDFr8nwq4a1byxE9jOuCpjrUYcBMRWbGFCxeiVq1acHd3R8uWLbF9+/ZCnxsZGYmhQ4eiQYMGcHR0xMSJE/U+b+3ataqedXNzU/+vW7fOhEdARESGSs3IwpJt59X9UffWVrma7B2DbiN0Lz9+/Dj27t1rnE/ExkUnpGH4N3vwyaZTyMrWoF9oVfw6vjOaVvMx964REZEBVq1apQLnN954A+Hh4ejcuTN69+6NiIgIvc9PS0uDv7+/en5ISIje5+zatQuDBw/GsGHDcOjQIfX/oEGDsHv3bn5WREQW6vv/LiEqIU3laXo4rJq5d8ciMOimMvPv2Rj0mbsd28/EwN3FER8PaK7m3y7nxlEORETWbtasWRgxYgRGjhyJRo0aYfbs2QgKCsKiRYv0Pr9mzZqYM2cOnnzySfj46L/wKtvo3r07pkyZgoYNG6r/u3XrptYTEZHlSUrLxKJ/zqn7L9xXF27OTubeJYvAoJtMLjMrG59uPoUnvtqtWrrrB5bDz+M6YVDrIHYnJyKyAenp6di/fz969OiRZ70s79y5s9TblZbu/Nvs2bOnQdskIiLT+XbXRcQmpaOGrycGtKzOor6DTYxkUpFxKZiw4iD2XLyploe0CcLUB5vAw5VXvYiIbEVMTAyysrIQGBiYZ70sX79+vdTbldeWdJvSbV1uWvHx8er/7OxsdTOEvF6muTR0O7aO5cRy4nfKPv/2bial57Zyj7+vLpwccvbJlsupuNtg0G0gztNduD+P38DLPx7C7eQM1YX8g0ea4aGQqoYWORERWaj8U8LISY2h08SUdJszZszAtGnTCqyPjo5GamqqwSdXcXFxah8k+RuxnPh9Khv827OOcvr0nwgkpGainp8H2ld1RlRUFGy9nBISEor1PAbdBuI83QWlZ2bjoz9O4qsdF9Rys2o+mDckDDX9vAwtbiIiskB+fn5wcnIq0AItJ1z5W6pLonLlyiXepoz7njRpUp6WbhlbLknbvL29YeiJmgT8si0G3SwnQ/H7xLKype/U+ZgkrDsco+5PfagpqlT2gz2Uk7u7e7Gex6CbjOpSbBJeWBGOw1fi1PIzHWvhtd4NmESBiMiGubq6qinCtmzZgv79++eul+V+/fqVervt27dX23jxxRdz123evBkdOnQo9DUytZjc8pMTK2OchMqJmrG2ZctYTiwnfqfs529PWozf/+0EMrM1uK9hADrXD4C9lJNjMV/PoJuM5tfD1zBl7REkpGXCx8MFMx8NQffGpW/hICIi6yGtyzKlV6tWrVSwvGTJEjVd2OjRo3NboK9evYply5blvubgwYPq/8TERNX9W5YlgJf5uMWECRNwzz334KOPPlLB+4YNG/Dnn39ix44dZjpKIiLKb9Ox6/j7VDRcnBzwxgONWEB6MOgmg6VmZGH6r8exfHfOXKytgitizpAwNTcfERHZB5lPOzY2FtOnT0dkZCSaNm2KjRs3Ijg4WD0u6/LP2R0WFpZ7X7KfL1++XD3/4sWLap20aK9cuRJvvvkm3nrrLdSpU0fNB962bdsyPjoiIipsirBpvxxX90fdUwd1/MuxoPRg0E0GORuVgHHLw3HyegIkr82YLnXw4v314ezEbndERPZmzJgx6qbP0qVL9XZJvJuBAweqGxERWZ6Zm08hMi4VQb4eGHdfXXPvjsVi0G0ge81eLidKa/ZfwdsbjiElIwt+5dwwe3AoOtWz3KQJRERERERkHHsu3MTSnTk9k97t1xTuLpwSuDAMug1kj9nLE9My8ea6I1h/8Jpa7lTXD7MGhyCgfPGy9xERERERkfVKSc/Cqz8egnRYGtSqOro0sPzkaebEoJtK5Ni1ONWd/EJMEpwcHTCpe308f28dODoaNg8rERERERFZB8nndDE2GVV83PHmgznJL6lwDLqp2N3Jv/vvEt779QTSs7LVH9jcIWFoXdOXJUhEREREZCc2HonEij0RKp/TJwND4O3uYu5dsngMuumu4pIz8OraQ9h07IZavr9RgPoDq+jlytIjIiIiIrITEbHJmLz2sLo/+t46zOdUTHaZYrp///6oWLGi3myoRT1mj/ZfuoU+c7ergFvm3pv6YGN88WQrBtxERERERHYkOT0Tz323D/GpmQgNqqCGmVLx2GXQPX78eCxbtqzEj9mT7GwNPt96DoMW78LV2ykIruSJtc93wDOdasFB+pIQEREREZHdDDWdvPaImibYr5wrFj3RAi6cIrjY7DLo7tq1K8qXL1/ix+xFTGIanlq6Fx/+fhJZ2Rr0DamKX1/ohObVK5h714iIiIiIqIzN+d8Z/HzoGpwdHbBgaAtU8fHgZ2DNQfe2bdvQt29fVK1aVbWorl+/vsBzFi5ciFq1asHd3R0tW7bE9u3bzbKvtmjnuRj0mbMd205Hw83ZER8+0gxzHwtFeSZIICIiIiKyO2v3X8HsP8+o+9P7NUXb2pXMvUtWx+ISqSUlJSEkJARPP/00BgwYUODxVatWYeLEiSrw7tixIxYvXozevXvj+PHjqFGjhnqOBOJpaWkFXrt582YVzFNB0qItV7Dm/XVGzbdXL6Ac5g9tgQaV7bvVn4iIiIjIXm05fgOv3kmc9nyXOhjaNifeIisPuiWAllthZs2ahREjRmDkyJFqefbs2di0aRMWLVqEGTNmqHX79+83+X5KUK8b2MfHx6v/s7Oz1c0Q8noZN2HodorrelwqJq46iD0Xb6nlR1tWx9t9G8HT1bnM9sEayslasZxYVvxOWf/fHn/niIiorO04E4OxPxxQjXP9w6rhlR4N+CHYStBdlPT0dBVQT548Oc/6Hj16YOfOnWW6LxLgT5s2rcD66OhopKamGnxyFRcXp07WHB1NOwLg3wtxmL7pAuJSs+Dp4ojXugWjZ0NfJN6+iURYtrIsJ2vGcmJZ8Ttl/X97CQkJRtsvIiKiu/nnVBRGfbcf6VnZ6NkkEJ8MbA5HRyZTtougOyYmBllZWQgMDMyzXpavX79e7O307NkTBw4cUF3Zq1evjnXr1qF169Z3fUzXlClTMGnSpDwt3UFBQfD394e3t7fBJ2oynl22ZapgMj0zGzM3n8aXOy6o5SZVvdXY7Vp+XrAWZVFOtoDlxLLid8r6//YkhwkREVFZ2HTsOl5YHq4C7m4NAzB3SBicmancfoJurfxTVkkrQkmmsZLu6KV5TJebm5u6LViwQN3kYoCQEytjBIByPMbaVn6XbyZj3IpwHLp8Wy0/1aEmpvRpCDdnJ1gbU5aTLWE5saz4nbLuvz3+xhERUVn4btdFvP3zMWRrgN5NK2POY2FwdeZ5tl0F3X5+fnBycirQqh0VFVWg9busjB07Vt2kpdvHxweWbuORSLy29jASUjPh7e6MTx4NQc8mlc29W0REREREZCbSC/aDjSewdOdFtTykTRDe7deULdxGYlWXLVxdXVVm8i1btuRZL8sdOnQwyz5JK3fjxo31dkG3JKkZWXhz/RGM+eGACrhb1KiAjRM6M+AmIiIiIrJjklR5yBf/5Qbck7rXxwf9mzHgtuWW7sTERJw9ezZ3+cKFCzh48CB8fX3VlGAyjnrYsGFo1aoV2rdvjyVLliAiIgKjR482y/5aQ0v32ahEjFt+ACevJ+Sm+5c/JheOzSAiIiIislu7zsXihRUHEJOYjvJuzvh0UAh6sBes7Qfd+/btQ9euXXOXtcnKhg8fjqVLl2Lw4MGIjY3F9OnTERkZiaZNm2Ljxo0IDg42y/7mH9NtaX7cfwVvrT+KlIwsVPJyxazBobi3vr+5d4uIiIiIiMzYC/azLafxxfbzavx2w8rl8fkTLVHTipIqWxOLC7q7dOmiEqMVZcyYMepmCSy1pTspLRNvbTiKnw5cVcsd6lTC7MGhCPBmBlwiIiIiInu1+3ysyvF0MTZZLQ9oUR3vPdwUHq7Wl1TZWlhc0G1tLLGl+/i1eIxbcQDno5Mg0+m9eH99jOlaF06cW4+IiIiIyC5FJ6Thsz9PY/nuCLUc6O2G9x9uhvsbmychtT1h0G1DLd3SQ+D73RF499fjKgNhZW93zHksFG1rVzLrfhERERERkXkkp2fiy+0XsHjrOSSlZ+VmJ5/cuxF8PFz4sZQBBt02Ii4lA5PXHsbvR3OmU7uvYQBmPhoCXy9Xc+8aERERERGZIdhevfcyFvxzTrVyi+bVffBGn0ZslCtjDLptoHt5eMQtvLAiHFdupcDFyQGv9WqIEZ1qwcHBwWz7REREREREZS8mMQ3f/xeBZf9dwu3kDLUuyNcDr/ZsiAeaVYEjh5yWOQbdVty9PDtbgy93nMfHf5xCZrZG/THNH9ICIUEVynQ/iIiIiIjIfCQu2HkuFt/9ewF/n72thpqK4EqeGNm5Nga1qg43ZyZKMxcG3VYqNjENL605hH9ORavlB5pXwYxHmsHbneMyiIiIiIjswZkbCfjtSCTWHriCyzdTcteHVPfBqHvroGeTykymbAEYdFuh/87HYsLKcNyIT4ObsyOm9m2MoW1qsDs5EREREZENy8rW4MjVOPx5/AZ+PxqJc9FJuY+Vc3NG9/oV8GSnegitUZGxgQVh0G1FY7rlj2zeX2cw939n1CT2dfy9sODxFmhY2dvk701ERERERGU/O5EE1rsvxGLHmRjVhVwSKGu5OjmiUz0/PNi8Cno2DkTC7VgEBFRgwG1hGHRbyZjuG/GpmLjyIHadj1XLA1tWx/R+TeDpyo+QiIiIiMgWAmzpyXriejyOX4vHgUu3sD/iVm4yNK3y7s7oVNcPvZpWRteGAbnDS7Ozs5Fgpn2nojFiswL/nIrCS6sPITYpHZ6uTni/f1P0D6tu7t0iIiLKY+HChfjkk08QGRmJJk2aYPbs2ejcuXOhpbR161ZMmjQJx44dQ9WqVfHqq69i9OjRuY8vXboUTz/9dIHXpaSkwN3dnaVPRFab9OxGQiouxiTjUmwSTt9IxInIeJy8Ho9b+QJsIcNJQ6pXQMe6fuhc3w/Nq/nA2cnRLPtOpcOg24JlZGVj1h+nsHjbebXcuIo35g8NQ23/cubeNSIiojxWrVqFiRMnqsC7Y8eOWLx4MXr37o3jx4+jRo0aBUrrwoUL6NOnD5599ll8//33+PfffzFmzBj4+/tjwIABuc/z9vbGqVOn8ryWATcRWXJrdXxqpuqlmnNLy71/7XYqIm4m4VJsMtLuZBfPz8nRAbX9vNCoireakahVcEV139WZQbY1Y9BtoWO6r8Wl4fm1uxF++bZafrJ9MF7v0wjuLkz1T0RElmfWrFkYMWIERo4cqZallXvTpk1YtGgRZsyYUeD5n3/+uQrG5XmiUaNG2LdvH2bOnJkn6HZwcEDlypXL8EiIyN6D5vSsbKSkZyH5zk3uJ6VnqrHUcckZ6v/bKemq2/ftO+u0yzJHdmqG/oBal7OjA6pX9EBwJS/U9s8JsqWBrW5AOZ7v2yAG3RY4pvuPo9fx2toTSEjLUmM2PhnYHL2aVjHKtomIiIwtPT0d+/fvx+TJk/Os79GjB3bu3Kn3Nbt27VKP6+rZsye++uorZGRkwMUlZ4xiYmIigoOD1cXt0NBQvPvuuwgLCyvzD1HmvE1Ky1AtWG4pGXB0+P9WJw00hb5OU/hDd15bxGNFvLjo1xX1fkU+aJT3k3GlMYnpyHZLhYOjQxGvvNu+FvW60pd56fbF+J+xlFPsrVQkOibB0cHBaJ9xUa8sfXkX9X5Fl092NpCt0dy53bmfnXNfkgTLZ5mlfUyt16j1uc/VaJCZlY3bcXEodyVDvZPsT85rcraVnqVRPUQzMrPV/7nLd27pmbrL/39fWptzgurM3OA6OSNLvb+hfDxcEOjthkBvd3WrLP/7uCPY1xM1K3mhagV3dhG3Iwy6LcwHG09gyZ3u5KFBPpg3pAWCfD3NvVtERESFiomJUUFxYGBgnvWyfP36db2vkfX6np+Zmam2V6VKFTRs2FCN627WrJm6uD1nzhzVdf3QoUOoV6+e3u2mpaWpm5a8TrteghzZvnB2dlbBvbSk578vFxGcnJzUTXv/1yPX8erqcGTBERo4wBlZufddkIVMnfsZyAnIXZCd774THKCBs859J2Qjs8D9bDhBo+47IlttWXtfnpeVex9qH+R10Lkv4YK8yglZap/kvuxvts79LLUl7X0eEz8nfvd0/56c7tx3d9KoVmd3Vxd4uTjA28MF3p7uqODugAoebvDxcoO3G1BB1nm5oZyLBn7enqji4wlHTaa6eOjo6Kh+f3Tvu7q6qksVkp8i537OxUs3Nzf1OyW/R/ruy++XPF9+b+WW/75sQ56vfa5c0JD3Le3vnva+PK7vOAoeU85xGPOYMvMdhzGOKTU1VW1f3t/QY5L/i4ODAyxMjTsB9hMtA7HquXYMuImIyGrIiY4uOTnKv+5uz9dd365dOzzxxBMICQlRCdlWr16N+vXrY968eYVuU7qyS88z7S0oKEit//XXXxEVFaX+195fv349Nm/erO7Ltv/55x91/4cffsCOHTvU/W+++QZ79uxRwfuDbidQxTEniH/E/Sj8HHPmxx3kfgg+Dqnq/hMe4fBEhgqy5b78L8tyX8jz5PlCXi/bEbJd2b4IdryNnm6n1f06TrG4z/Wcut/IOQqdXS+q+82dI9HOJULdb+FyVd1UmblEqMfEPa4X1WukNGUbdZ1i1X3ZtryHNEL3dTuBak7x6r7sS4Bqdc05poqOqXByyDmm8g4ZcHfIOSb5v7xjzjFJLqeKTjnHJPcDnHKOSYafVndKUNuXbrS1nOPQy+00XJwc0MDlJrq5nVP3m7pE4163i+p+mOt1dHCNgKuTA1q7XlU3uS/r5DE3Jwd0cbuIZi7R6v79bufQ0OWmut/b7TTquMTBzdkBfd1PINglQd0f4H4UVV2S4e7siMHuh+DvnKbuy75XdM5COec7x+cC+LpkqfseLo4IcElTz5f71V2S1XY8XRxRyzUBD7mfVPfrucajt/tpeLo6orHbTdzvfk7db+4Wja7uF+Hl6ohWbtfRye2yut/W7aq6yX1Z18rtBrxcHNHV/RJC3GJQztUJ3d3Po4nbLZR3c0If9zNo4Bav7st71nFLVPdlX4LdUuDt5qT2sapburov+x7olgVf95xjkv8D3XOOydvdCVXd09XzfdydUNM9BQPdj6r7dd0T0c/9pLrfyCMBD3icQQUPZzTzuI0eHufV/RYesejmcQkVPZzR1uMG7vG4rO538LimbhU9ndU6eUzuy3PlNXK/p8d5hHreRkA5FzzocQah5RJR3ccN/T1PItQ7FbUruWOQ5zG08M1EgwBPDPE4jJb+DmhWxUvte5sqLmhV1UPdb1fdE52qu6n7nWr7oFsNFwz1PIweDSrioVrOeLzccQwM8ceQeo54osIZPNO2CkY0csRwv4uYeE91jGmiwYgqVzG1R0282DQLY4KjMfvhuni9eQZebRiP1cObYFpYGt5vmYYdL7TAtOZJeK9VFtY/0xRPVb6G5+un4qM+NdA85TC6VIjF0OY+yDj+F6qkX0FTX2DP72twK+K0mrZLhp8ePXpU/Y589tlnOH36tLr/8ccfq5wWV69eVfflf1mW+/K4PE+eL/fl9bIduR8eHo4lS5ao+/KbJL9Ncl9+q+Q3S+7Lb5j2N03+l984Q3735L68p7y33DfXMa1evdqox/TFF1/k7ruhxxQdHV2M2hFw0BTVP4eKTdu9PC4uTiV9KS35OA5fuY1AlzQEBASoKy2kn1xZki89y6loLKfiY1mxnCz1+2SsOsZU5Mq/p6cn1qxZg/79++eunzBhAg4ePKiylOd3zz33qG7i0nqttW7dOgwaNAjJycm53cvzk8RrV65cwe+//17slm4JvOWzqFSpUqlbRxwcHJGckoJbt28jMCAgtwu8buuIPK+w1pGMIlp83N2LbvGRx0zV4mOKVix5vpS7lLd238uyFctaWuZk/a1bt1ChQgW137ZwTKb6nGQfr127pmY5kPW2cEym+JxkGxIESk8heb4tHFOmiVq65W9Pelfp+y0vyTHJ8ypWrHjX+pndyy2MfEmaVfNRJwdERETWQE5GWrZsiS1btuQJumW5X79+el/Tvn17/PLLL3nWSUtFq1atCg245WRLgnjpbl4YORmSm771ciKlPXHSrtN3Xzc7uu79cl6eSE5KhKuLM9zd/n87sqzl4uypd/3/33eCq6tLgftyIqg9brmvpXtfd98Lu1/SY9K97+HhUar7Uq5ygqu9L7eEhITcE3Xteu3x6d63lmMq7L4hxyQn7XLep/1u2sIx6btvjGPSlpP8Pch+2cIxFXbf0GPSBo3a59rCMZnic8r/XSrtMUngXRxsRiUiIiKDyXzbX375Jb7++mucOHECL774IiIiInLn3Z4yZQqefPLJ3OfL+kuXLqnXyfPldZJE7eWXX859zrRp01QG9PPnz6tgW7Kjy/+6c3kTERFZOrZ0W+iUYURERNZk8ODBiI2NxfTp0xEZGYmmTZti48aNKvO4kHUShGvVqlVLPS7BudSj0m107ty5eaYLu337Np577jmVdE2610t39G3btqFNmzZmOUYiIqLS4JhuIzHmeDuOK2U5GRO/TywrY+N3quzLydLHdFsy1s9lj78RLCd+p8yDf3uWWz+zezkRERERERGRiTDoJiIiIiIiIjIRBt1EREREREREJsKgm4iIiIiIiMhEGHQTERERERERmQiDbiIiIiIiIiITYdBNREREREREZCLOptqwvdFoNLlztRlj7riEhAS4u7sbPHecLWM5sZz4neLfnr38RmnrFm1dQ8XH+rnssX5mOfE7ZR7827Pc+plBt5HIByeCgoKMtUkiIqICdY2Pjw9LpQRYPxMRkbnrZwcNL5sb7YrJtWvXUL58eTg4OBh8xUSC98uXL8Pb29s4O2iDWE4sJ36n+LdnL79RUlVLhV61alX2gCoh1s9lj/Uzy4nfKfPg357l1s9s6TYSKeTq1avDmORLwKCb5cTvU9nj3x7LyRK/T2zhLh3Wz+bD31KWE79T/NuzZN5lWD9zwDARERERERGRiTDoJiIiIiIiIjIRBt0WyM3NDW+//bb6n1hO/D7xb8/S8DeK5WSv+N1nOfH7xL89S8bfKMstJyZSIyIiIiIiIjIRtnQTERERERERmQiDbiIiIiIiIiITYdBNREREREREZCIMui1czZo14eDgkOc2efJkc++WxUpLS0NoaKgqp4MHD5p7dyzOQw89hBo1asDd3R1VqlTBsGHDcO3aNXPvlsW5ePEiRowYgVq1asHDwwN16tRRCTfS09PNvWsW5/3330eHDh3g6emJChUqmHt3LMrChQvVd0j+3lq2bInt27ebe5fIiFg/lwzr57tjHX13rJ+Lj/WzZdXPDLqtwPTp0xEZGZl7e/PNN829Sxbr1VdfRdWqVc29Gxara9euWL16NU6dOoW1a9fi3LlzGDhwoLl3y+KcPHkS2dnZWLx4MY4dO4bPPvsMn3/+OV5//XVz75rFkQsRjz76KJ5//nlz74pFWbVqFSZOnIg33ngD4eHh6Ny5M3r37o2IiAhz7xoZEevn4mP9fHeso++O9XPxsX62sPpZQxYtODhY89lnn5l7N6zCxo0bNQ0bNtQcO3ZMI1/t8PBwc++SxduwYYPGwcFBk56ebu5dsXgff/yxplatWubeDYv1zTffaHx8fMy9GxajTZs2mtGjR+dZJ79PkydPNts+kXGxfi4+1s+lwzq6eFg/F431s2XUz2zptgIfffQRKlWqpLpNS1cRdnEt6MaNG3j22Wfx3XffqW6udHc3b97EDz/8oLoGu7i4sMjuIi4uDr6+viwnuiv5jd6/fz969OiRZ70s79y5kyVoQ1g/3x3r59JhHV18rJ/JGupnBt0WbsKECVi5ciX+/vtvjBs3DrNnz8aYMWPMvVsWRaPR4KmnnsLo0aPRqlUrc++OxXvttdfg5eWlLuRIV5oNGzaYe5csnnTDnzdvnvqOEd1NTEwMsrKyEBgYmGe9LF+/fp0FaCNYP98d6+eSYx1dMqyfyVrqZwbdZvDOO+8USI6W/7Zv3z713BdffBH33nsvmjdvjpEjR6pxpV999RViY2Nh64pbThIMxcfHY8qUKbBHJfk+iVdeeUWNYdm8eTOcnJzw5JNPqhMje1DSshKSaK5Xr15q3LL8DdqD0pQTFSTlpEv+zvKvI8vC+tm45WTv9bNgHW2achKsn1k/W1P97CB9zE36DqT3Kovc7pYVVTLq5Xf16lVUr14d//33H9q2bWvTpVvccnrsscfwyy+/5PljkatYElA+/vjj+Pbbb2HLDPk+XblyBUFBQapLTfv27WHrSlpWUqFLYhv5W1u6dCkcHe3jOmVpvlNSPpKY5Pbt27B30n1NhrmsWbMG/fv3z9MyKrMqbN261az7R4Vj/Vw8rJ+Lj3W0acqJ9XPxykmwfraM+tnZZFumQvn5+albaUgLpZDpnmxdcctp7ty5eO+993KX5Ye4Z8+eKjuhrV+YMPT7pL3mJlO52IOSlJVc4JKAW6aS+Oabb+wm4Db0O0WAq6ur+t5s2bIlT6Uuy/369WMRWTDWz8YtJ3uvnwXraOOXE+tn1s/WWD8z6LZgu3btUi3acuLv4+ODvXv3qu7m2nkcKUf+sihXrpz6X+ZWll4BlGPPnj3q1qlTJ1SsWBHnz5/H1KlTVTnZQyt3SciJYZcuXdR3a+bMmYiOjs59rHLlymbdN0sjeQEk4Y/8Lz1M5EqxqFu3bu7foj2aNGkShg0bpvJMyN/XkiVLVBkxL4BtYP1cPKyfi491dPGwfi4+1s8WVj+bNDc6GWT//v2atm3bqml43N3dNQ0aNNC8/fbbmqSkJJZsES5cuMApw/Q4fPiwpmvXrhpfX1+Nm5ubpmbNmmrKhCtXrvD7pGd6Dfl51HejvIYPH663nP7++2+7L6oFCxaoaaVcXV01LVq00GzdutXuy8RWsH4uHdbPhWMdXTysn4uP9bNl1c8c001ERERERERkIvYzSJGIiIiIiIiojDHoJiIiIiIiIjIRBt1EREREREREJsKgm4iIiIiIiMhEGHQTERERERERmQiDbiIiIiIiIiITYdBNREREREREZCIMuomIiIiIiIhMhEE3ERERERERkYkw6CYiIiIiIiIyEQbdRGRyXbp0wcSJE81S0qZ879jYWAQEBODixYsGbWfgwIGYNWuW0faLiIioOFg/F431MxkLg26iMvDUU0/BwcFB3VxcXFC7dm28/PLLSEpKYvlbsRkzZqBv376oWbOmQduZOnUq3n//fcTHxxtt34iI6O5YP9sm1s9kaRh0E5WRXr16ITIyEufPn8d7772HhQsXqsBbn/T0dIv7XCxxn8wpJSUFX331FUaOHGnwtpo3b64C9x9++MEo+0ZERMXH+tm2sH4mS8Sgm6iMuLm5oXLlyggKCsLQoUPx+OOPY/369bndu8aNG4dJkybBz88P3bt3V+s1Gg0+/vhj1TLu4eGBkJAQ/Pjjj7nblPvNmjVTj1WqVAn3339/but5UY8JCfJmz56dZx9DQ0PxzjvvGLRPhcnOzsarr74KX19fVQ7a99G623b/+OMPdOrUCRUqVFDH8+CDD+LcuXN5tiHH9+STT6JcuXKoUqUKPv3007vul3wG3t7e6v3Pnj2reiNcvXpV7a+Xl5d6X31+//13ODs7o3379rnrpMxeeOEF1Z29YsWKCAwMxJIlS9R+Pf300yhfvjzq1KmjXpvfQw89hBUrVtx1f4mIyLhYP7N+Zv1Mpsagm8hMJLDMyMjIXf72229VEPfvv/9i8eLFat2bb76Jb775BosWLcKxY8fw4osv4oknnsDWrVtVq/mQIUPwzDPP4MSJE/jnn3/wyCOPqOCxqMdKoqT7dLdtSRC7e/duFVxPnz4dW7ZsyX38btuVwFUuAOzduxf/+9//4OjoiP79+6vgWOuVV17B33//jXXr1mHz5s3quPfv31/kfh08eFAF+BJsHz58WAX01apVw+nTp5GcnKwe02fbtm1o1aqV3uOUixR79uxRAfjzzz+PRx99FB06dMCBAwfQs2dPDBs2TG1bV5s2bdRr0tLSitxfIiIyLdbPrJ91sX4mo9AQkckNHz5c069fv9zl3bt3aypVqqQZNGiQWr733ns1oaGheV6TmJiocXd31+zcuTPP+hEjRmiGDBmi2b9/v0TQmosXLxZ4v6Ie0woODtZ89tlnedaFhIRo3n777VLvU2FkW506dcqzrnXr1prXXnut1NuNiopSx3jkyBG1nJCQoHF1ddWsXLky9zmxsbEaDw8PzYQJEwrdt4cfflgzbtw4dX/q1Kmabt26qfuyHX9//0JfJ5/nM888U+RxZmZmary8vDTDhg3LXRcZGan2e9euXXlee+jQobt+ZkREZFysn1k/s36msuBsnNCdiO7m119/Vd2eMzMzVQt3v379MG/evNzH87eaHj9+HKmpqbndunXHVoeFhakW2G7duqku5NJ62qNHD5VlU7o1F/VYSZR0n+42blmXdP+Oiooq9nalK/lbb72F//77DzExMbkt3BEREWjatKl6XJ6v291burI3aNDgri3d0lVdHDp0KLdlW9sCXtSYMXd39yKP08nJSbWcy+egJV3OhfbYdVtWRP4WcCIiMi3Wz6yfBetnMiUG3URlpGvXrqrrtGQvr1q1qvpfl3S91qUNKn/77TfV3Tn/+DMJ6KR79s6dO1VXagng33jjDdV9u1atWkU+JqR7dv7u5rrd3UuzT0XJf7zSnVu7veJsV7KEy3j4L774QpWfvEaCbW2Ct5J2nRcJCQlqui9tUCxB94ABA9R96QouY9wLI13Ib926Vazj1F0ny7rHrHXz5k31v7+/f4mPg4iISo/1M+tnwfqZTIljuonKiASwdevWRXBwcIHATJ/GjRurgFNacuV1ujcJPrUVRMeOHTFt2jSEh4fD1dVVjWe+22Pa4E7GfmvJdFUXLlwweJ9K427blfmwZWy6jPuWFvxGjRoVCHjluVKu0hKuJc+RsdmF0R6/JFCJi4tTAbgE2tHR0Wosef6Wd13SAi8t9MZy9OhRVK9eXQXzRERUdlg/F471M+tnMg62dBNZKAkEZUoxSSgmraKSuVsCY2m9lm7qDRs2VAnFpOt4QECAasWWYFECUrlf2GNa9913H5YuXapakKXbuXTdltZzQ/Zp+PDhJjlWSTwm3bQlE7h0S5fgfPLkyXm2Ic8bMWKESqYmz5VuYtK6Ly36hZFWdU9PT8yaNUt1MZegXbq5S9I5SZxSVNAt3fanTJmiAvuSdtvXZ/v27erzIiIiy8b6mfUzUUkx6CayYO+++64KmmfMmKHm95bpslq0aIHXX39dTXMlGbRl2i8JUKUFXabI6t27t2oVLuwxLQkYZZsSbPr4+Kj3ultL9932yVTHKoHzypUrMX78eNWlXMZpz507V03RpeuTTz5BYmKimn5LTopeeukl1YJdVOvGmjVrVJbxL7/8Uq2TMpLpvaZOnZrb1Uwf6ZIuY95Xr16NUaNGGXTsEuhLL4RNmzYZtB0iIiobrJ9ZPxOVhINkUyvRK4iIbJDMnS5++OGHIoNtXRs3blQt9NI1vKgW9btZsGABNmzYoMbfExEREetnsi0c001EBODUqVNo3bp1sQNu0adPH9XKffXqVYPKULq162ayJyIiohysn8kWsKWbiOyeTOMmY8Ile7okaiMiIiLzY/1MtoJBNxEREREREZGJsHs5ERERERERkYkw6CYiIiIiIiIyEQbdRERERERERCbCoJuIiIiIiIjIRBh0ExEREREREZkIg24iIiIiIiIiE2HQTURERERERGQiDLqJiIiIiIiITIRBNxEREREREZGJMOgmIiIiIiIiMhEG3UREREREREQwjf8DAlKYE5/iojcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psi_range = np.linspace(-5, 0, 200)\n", + "\n", + "K_vals = KS * np.exp(ALPHA_G * psi_range)\n", + "K_vals[psi_range >= 0] = KS\n", + "\n", + "theta_vals = THETA_R + (THETA_S - THETA_R) * np.exp(ALPHA_G * psi_range)\n", + "theta_vals[psi_range >= 0] = THETA_S\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))\n", + "\n", + "ax1.semilogy(psi_range, K_vals)\n", + "ax1.set_xlabel(r\"Pressure head $\\psi$ (m)\")\n", + "ax1.set_ylabel(r\"$K(\\psi)$ (m/s)\")\n", + "ax1.set_title(\"Hydraulic conductivity\")\n", + "ax1.grid(True, alpha=0.3)\n", + "\n", + "ax2.plot(psi_range, theta_vals)\n", + "ax2.set_xlabel(r\"Pressure head $\\psi$ (m)\")\n", + "ax2.set_ylabel(r\"$\\theta(\\psi)$\")\n", + "ax2.set_title(\"Volumetric water content\")\n", + "ax2.axhline(THETA_S, color=\"grey\", ls=\"--\", lw=0.8, label=r\"$\\theta_s$\")\n", + "ax2.axhline(THETA_R, color=\"grey\", ls=\":\", lw=0.8, label=r\"$\\theta_r$\")\n", + "ax2.legend()\n", + "ax2.grid(True, alpha=0.3)\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analytical Solution\n", + "\n", + "For a column of height $L$ with boundary conditions\n", + "$\\psi(0) = \\psi_\\text{bottom}$ and $\\psi(L) = \\psi_\\text{top}$,\n", + "the exact steady-state profile is given by\n", + "`gardner_steady_state_psi`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.508663Z", + "iopub.status.busy": "2026-02-24T08:58:12.508567Z", + "iopub.status.idle": "2026-02-24T08:58:12.588064Z", + "shell.execute_reply": "2026-02-24T08:58:12.587348Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.508653Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_exact = np.linspace(0, COLUMN_HEIGHT, 200)\n", + "psi_exact = gardner_steady_state_psi(\n", + " y_exact,\n", + " psi_0=PSI_BOTTOM,\n", + " psi_L=PSI_TOP,\n", + " L=COLUMN_HEIGHT,\n", + " alpha=ALPHA_G,\n", + ")\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 6))\n", + "ax.plot(psi_exact, y_exact, \"b-\", lw=2, label=\"Analytical\")\n", + "ax.set_xlabel(r\"Pressure head $\\psi$ (m)\")\n", + "ax.set_ylabel(\"Height $y$ (m)\")\n", + "ax.set_title(\"Exact steady-state profile\")\n", + "ax.grid(True, alpha=0.3)\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical Solution with Richards Solver\n", + "\n", + "We solve the same problem numerically using `uw.systems.Richards`,\n", + "stepping forward in time until the transient terms die out and\n", + "we reach steady state." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.593981Z", + "iopub.status.busy": "2026-02-24T08:58:12.593676Z", + "iopub.status.idle": "2026-02-24T08:58:12.838854Z", + "shell.execute_reply": "2026-02-24T08:58:12.838122Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.593949Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Structured box element resolution 4 32\n" + ] + } + ], + "source": [ + "mesh = uw.meshing.StructuredQuadBox(\n", + " elementRes=(4, RES),\n", + " minCoords=(0.0, 0.0),\n", + " maxCoords=(COLUMN_WIDTH, COLUMN_HEIGHT),\n", + " qdegree=3,\n", + ")\n", + "\n", + "psi_var = uw.discretisation.MeshVariable(r\"\\psi\", mesh, 1, degree=2)\n", + "v_soln = uw.discretisation.MeshVariable(\"v\", mesh, mesh.dim, degree=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.839864Z", + "iopub.status.busy": "2026-02-24T08:58:12.839556Z", + "iopub.status.idle": "2026-02-24T08:58:12.860738Z", + "shell.execute_reply": "2026-02-24T08:58:12.860473Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.839852Z" + } + }, + "outputs": [], + "source": [ + "richards = uw.systems.Richards(mesh, psi_var, v_soln, order=2, theta=0.5, degree=3)\n", + "richards.petsc_options.delValue(\"ksp_monitor\")\n", + "richards.petsc_options[\"snes_rtol\"] = 1.0e-6\n", + "\n", + "psi_sym = psi_var.sym[0]\n", + "\n", + "# Constitutive model: Gardner K(ψ) with gravity\n", + "richards.constitutive_model = uw.constitutive_models.DarcyFlowModel\n", + "richards.constitutive_model.Parameters.permeability = gardner_K(\n", + " psi_sym, Ks=KS, alpha=ALPHA_G\n", + ")\n", + "richards.constitutive_model.Parameters.s = sympy.Matrix([0, -1]).T\n", + "\n", + "# Mixed form: θ(ψ) for mass-conservative storage term\n", + "richards.water_content = gardner_theta(\n", + " psi_sym,\n", + " theta_r=THETA_R,\n", + " theta_s=THETA_S,\n", + " alpha=ALPHA_G,\n", + ")\n", + "\n", + "richards.f = 0.0\n", + "\n", + "# Boundary conditions\n", + "richards.add_dirichlet_bc([PSI_TOP], \"Top\")\n", + "richards.add_dirichlet_bc([PSI_BOTTOM], \"Bottom\")\n", + "\n", + "# Velocity projector settings\n", + "richards._v_projector.petsc_options[\"snes_rtol\"] = 1.0e-6\n", + "richards._v_projector.smoothing = 1.0e-3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.861731Z", + "iopub.status.busy": "2026-02-24T08:58:12.861634Z", + "iopub.status.idle": "2026-02-24T08:58:12.867820Z", + "shell.execute_reply": "2026-02-24T08:58:12.867134Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.861722Z" + } + }, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\kappa = Piecewise((0.0001, {\\psi}(N.x, N.y) >= 0), (0.0001*exp(3.5*{\\psi}(N.x, N.y)), True))$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Inspect the solver expressions\n", + "richards.constitutive_model.Parameters.permeability" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:12.868793Z", + "iopub.status.busy": "2026-02-24T08:58:12.868456Z", + "iopub.status.idle": "2026-02-24T08:58:21.192358Z", + "shell.execute_reply": "2026-02-24T08:58:21.191855Z", + "shell.execute_reply.started": "2026-02-24T08:58:12.868635Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converged after 25 steps (dt = 1000.0 s)\n" + ] + } + ], + "source": [ + "# Initial guess: linear profile from bottom to top\n", + "y = mesh.X[1]\n", + "psi_init = PSI_BOTTOM + (PSI_TOP - PSI_BOTTOM) * y / COLUMN_HEIGHT\n", + "psi_var.array = uw.function.evaluate(psi_init, psi_var.coords)\n", + "\n", + "# Step towards steady state\n", + "dt = 0.1 * COLUMN_HEIGHT / KS # a few diffusive time scales\n", + "\n", + "for step in range(25):\n", + " richards.solve(timestep=dt)\n", + "\n", + "print(f\"Converged after 25 steps (dt = {dt:.1f} s)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison\n", + "\n", + "Sample the numerical solution along a vertical profile and\n", + "compare with the exact analytical solution." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:21.193049Z", + "iopub.status.busy": "2026-02-24T08:58:21.192951Z", + "iopub.status.idle": "2026-02-24T08:58:21.378893Z", + "shell.execute_reply": "2026-02-24T08:58:21.378129Z", + "shell.execute_reply.started": "2026-02-24T08:58:21.193038Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max absolute error: 5.4541e-02 m\n" + ] + } + ], + "source": [ + "n_sample = 100\n", + "sample_y = np.linspace(0.02, COLUMN_HEIGHT - 0.02, n_sample)\n", + "sample_x = np.full_like(sample_y, COLUMN_WIDTH / 2)\n", + "sample_pts = np.column_stack([sample_x, sample_y])\n", + "\n", + "psi_numerical = uw.function.evaluate(psi_var.sym[0], sample_pts).squeeze()\n", + "psi_analytical = gardner_steady_state_psi(\n", + " sample_y, PSI_BOTTOM, PSI_TOP, COLUMN_HEIGHT, ALPHA_G\n", + ")\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 6), sharey=True)\n", + "\n", + "# Pressure head profile\n", + "ax1.plot(psi_analytical, sample_y, \"b-\", lw=2, label=\"Analytical\")\n", + "ax1.plot(psi_numerical, sample_y, \"ro\", ms=3, label=\"Numerical\")\n", + "ax1.set_xlabel(r\"Pressure head $\\psi$ (m)\")\n", + "ax1.set_ylabel(\"Height $y$ (m)\")\n", + "ax1.set_title(r\"$\\psi(y)$ profile\")\n", + "ax1.legend()\n", + "ax1.grid(True, alpha=0.3)\n", + "\n", + "# Error\n", + "error = psi_numerical - psi_analytical\n", + "ax2.plot(error, sample_y, \"k-\", lw=1)\n", + "ax2.axvline(0, color=\"grey\", ls=\"--\", lw=0.5)\n", + "ax2.set_xlabel(\"Error (m)\")\n", + "ax2.set_title(\"Numerical − Analytical\")\n", + "ax2.grid(True, alpha=0.3)\n", + "\n", + "fig.suptitle(\n", + " f\"Gardner model: $K_s$ = {KS:.0e} m/s, \"\n", + " rf\"$\\alpha$ = {ALPHA_G} /m\",\n", + " fontsize=12,\n", + ")\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"Max absolute error: {np.max(np.abs(error)):.4e} m\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Darcy Velocity\n", + "\n", + "The Richards solver also computes the Darcy flux\n", + "$\\mathbf{q} = -K(\\psi)(\\nabla\\psi - \\mathbf{s})$.\n", + "At steady state the vertical component should be constant\n", + "(uniform flux through the column)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T08:58:21.379648Z", + "iopub.status.busy": "2026-02-24T08:58:21.379307Z", + "iopub.status.idle": "2026-02-24T08:58:21.456018Z", + "shell.execute_reply": "2026-02-24T08:58:21.455068Z", + "shell.execute_reply.started": "2026-02-24T08:58:21.379637Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc4AAAImCAYAAADaGWrCAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAeiRJREFUeJzt3Qd8E3UbB/Cnu6XQQhcUKLTsvfeSISAgsgQUlb0EZIkK4gIVnCxZsoeoyBQBGbJkj7L3pozSRWnLammb9/M8vBeTNB3pyiX5ff2cCZdrcvnf5Z77bzuNRqMhAAAAyBD7jG0GAAAACJwAAAAmQo4TAADABAicAAAAJkDgBAAAMAECJwAAgAkQOAEAAEyAwAkAAGACBE4AAAATIHBmoyVLlpCdnZ12cXV1pUKFClGzZs1o8uTJFB4enp0fZ/HpdPPmzVx7/19//ZWmTZuWI5/38OFD8vHxod9//92kvwsMDKRXX32VzKF3797y+RnBafnFF1+kuc3u3btlu9WrV5Mt4nONvz+fe9Zu9uzZufY9Dxw4IOce/8YMNWnShEaOHEnmgMCZAxYvXkwHDx6k7du306xZs6hatWr07bffUvny5emff/7JiY8EHe3atZP09/f3z5XAOWHCBCpcuDB1794dxwGs3uxcDpz8+zIWOL/88kvZl0uXLlFuQ+DMAZUqVaJ69epR48aNqUuXLjR16lQ6ffo0ubu7U+fOnSksLCxbPufp06eEoYZT8vX1lfR3cXGhnPbgwQP6+eefaejQoZLjANuSlJRE8fHx5t4Nm/TSSy9R2bJl6ccff8z1z0bgzCXFihWTAxwXFycXWsWxY8fojTfekGIzNzc3eXzzzTfp1q1bRosft23bRn379pXgkCdPHu2PlnNU9evXp7x588rCudyFCxdq78wcHR3p9u3bKfaL38vb25uePXtmdL85l8afe/Xq1RSvffTRR+Ts7EyRkZHadZyjbtGiBXl4eMj+NWzYkHbs2JGhNFq0aBFVrVpViri9vLyoU6dOdOHChRTbHT58mNq3by/7zduWLFlSr8jGsKi2adOmtGnTJklT3aJ0vukoXbo0tW7dOsVnPHr0iDw9PSUgpoU/KzExMUVu8/r163JcOSfKAbxgwYKSLidPnkzxHlu2bKEaNWrI8S9Xrpykg6GzZ89Shw4dqECBAvKd+fguXbo0Q0XgSjEqP6YlNjaWBgwYIOnK59Arr7xCly9fJlPweTR69GipouDvwxe3EydOpNiOz/vXXntNjjN/n+rVq9Mff/yR4SLRH374gaZMmUJBQUGyr3zuHzp0KFOfExERQUOGDKEKFSrIe/n5+VHz5s1p7969Rj/7u+++o6+++ko+m4/trl27Unwu/y1v+9tvv6V4bdmyZfLa0aNH0/yud+/epYEDB1JAQID8zvhcev311/VuvENCQujtt9+WfeZ94VItvs4kJydnKs3SO2/5+nTu3Dnas2eP9nekFPnzsX///ffl3OTfDqc5f8aff/6Z4rvx3w0bNoyWL18u+8zXCv7tb9y4UbsNF9F+8MEH8pz3Wfk83fP4nXfekWsfX1dzFc+OAtlj8eLFPNOM5ujRo0Zff/TokcbBwUHTokUL7bpVq1ZpPvvsM826des0e/bs0fz++++al156SePr66uJiIhI8d5FihTRDBw4UPP3339rVq9erUlMTNR8+umn8lrnzp3l/bZt26aZMmWKrGdhYWEaFxcXzfjx4/X2JyoqSuPm5qb54IMPUv1OvA/Ozs4p/pY/t3DhwvKZiuXLl2vs7Ow0HTt21Kxdu1bz119/aV599VX5zv/880+K73Ljxg3tukmTJsm6N998U7Np0ybNsmXLNCVKlNB4enpqLl++rN1uy5YtGicnJ02VKlU0S5Ys0ezcuVOzaNEizRtvvJHq+587d07TsGFDTaFChTQHDx7ULmz69Omyz7qfwWbNmiXvwX+blubNm2vq1KmTYn3ZsmU1pUqVkjTh47pmzRrN+++/r9m1a5d2m+LFi2uKFi2qqVChgnzfrVu3arp27Sqfy3+juHjxoiZfvnyakiVLynacPpxOvN23336bZroy/kxer/vZvXr1ks9XJCcna5o1aybnyddffy3n0Oeffy7HgP+Wn6dF+YyAgABNhw4d5Nj/8ssvkgYeHh6aa9euabflY8bnVOPGjTUrV66UY9q7d2/5e/4OaeHvxtsFBgZqXnnlFc369etlqVy5sqZAgQKahw8fmvw5nL7vvvuu/PZ2796t2bhxo6Zfv34ae3t7vTRTPpt/g5xW/PvjdOL1ymu671u9enU57wzVrl1blrTcuXNH4+/vr/Hx8ZHfMv9++Dv07dtXc+HCBdkmPDxc9oWvFXPnzpXvN2zYMNkP/j6ZSbP0ztvjx4/LOcHfTfkd8TrG78Ppy3/Lac/7M2bMGEnHpUuX6n0/ZX/4t/PHH39oNm/erGnatKnG0dFRe67cvn1b895778m2fD1RPi8mJkb7PocPH5bXN2zYoMlNCJy5GDhZwYIFNeXLl0/1dQ5IHGDd3d3lom743j179tTb/vr16xKY3nrrrTT3jS+Ufn5+mvj4eO06vujySW14oTXEwZEv8ElJSdp1fKLz/vAFkj1+/Fjj5eWlad++vd7f8t9UrVpVL7gYXuCjo6MlgLdt21bvb0NCQuRC3qNHD+06Dh68PH36NNX9NRZA2rVrpxcoFLGxsRKURowYobeegxlfHNOTJ08ezeDBg/XWRUZGyudPmzYtzb/l/XF1ddXcunVLu46/F6fjoEGDtOv4poDTgdNDV5s2beTzlQtfVgIn34jxNrrnHOMgakrgrFGjhgRhxc2bN+VGp3///tp15cqVkwvv8+fP9d6Db7I4WOieZ4aUIMAXff6tKI4cOSLrf/vttyx/Dr8v/w3f4Hbq1CnFZ/P5l5CQYHS/dAOncjxOnDiRYj8NA4khDpCcbufPn091m7Fjx8p7cfDQxUGTbwYvXbpkUppl9LytWLGi3NynR0lHvgnh46CLP4evhfz7U9y/f1+uR5MnT9au+/77742e0wo+DvxdP/roI01uQlFtLjOsk+QiQS7yLFWqlBSn8sLFKI8fPzZaTMl1prq4ARLXs6RXpDhixAhp1btq1Sr5NxflzJkzRxrSpNe6sk+fPnTnzh29hk3cAIqL49q0aaOtxOf6vl69eknRpbLw53CRHxdL8XcyhhvycH0tt/TUxUVUXGSmFPVyseG1a9eoX79+UuyWHfLlyyffj4s5lf3buXMnnT9/XoqS0sINFp48eSLFZLq4iIqLj7///nspGuOiSt2iM11crMXF+Ar+XmXKlNErquf94eIyTg9dnF78+Zx+WaUUN7711lt663v06GHS+/D2unW9xYsXpwYNGmjfn4v8L168qP0c3XOlbdu2FBoamqHGHnzeOjg4aP9dpUoVeVTSzdTPmTt3rhSXc/rzb9DJyUnOO2O/QS765dfTw1UufG5wA0HFTz/9JNUs6TUk+/vvv6U1PhdjpobPCy5erlOnTorzgq8z/LopaWbKeZsavr5w9Qxfw5R05CojY+nI349/fwouFub0MqymSgu/f/78+aVYOzchcOYivjBHRUVJ/YHuhWbmzJnUv39/2rp1Kx05ckSCDP+4OJgY0m0pqtTPsKJFi6b52Vy3w42VlB8x1yVw3Ud6wYFxcOTP5WDJoqOjacOGDdSzZ0/tD1Gpd+E6GD6ZdRduUcw/ZA6sxnCaGPtujNNKeT2j39VU7733ntSRrFixQv7Nx4M/g+sU06IcH8MgzoGDL7pcd8r1YXxB5uM5fPjwFHUxXJ9oiOuWdI89f//U0kZ5Pav4PfhCZ7g/fHNkCmPb8zplH5XzZMyYMSnOE65nZLp15qkx3E+lIZiSbqZ8DgeJd999l+rWrUtr1qyRej/+DfINX0Z+g6nhfRo0aJDUwfFNFp+/XL/Kv/X0Gq7xtumd56aeF+mlmSnnrTFr166lbt26UZEiReiXX36RGzpOR25HYawNRUbO/Yzg35+pf5NVjrn6aTaOG6hw7pAbq7CYmBgJYJ9//jmNHTtWux03+EktyBi23OQTm3GO0DBHYoh/AF27dqXjx49LcOCcTcuWLdPdbw6OXAk/Y8YMuQDwhYD3kXNqCu7HqNxRc4tWY/iO0hjlB8S5AEP37t3Tvrfud81OnNvnmwO+qeBHvingJvC6d+dp7bexY8U5LaVxFueU+YLJjR0SEhIkd2MK/pzU0oYp6aMEcMNWnhkNRJwb44ut7gXt/v37Ju2rse15nfKeyr6OGzdOWpgbwy0ls8qUz+GLPP8muQRGV2rBwpTW0xyQv/nmG2nwxcGD03jw4MHp/h2f6+md5xk9L0yRlfP2l19+kUY8K1eu1EujnG51zDfymfmuWYEcZy7h1m9898utzfgulCktOw3vPhcsWCABNiNatWolF3jDH70x3EqViwW55RsXu/Kdd0YvAhwk+YfPrQS5WJNby3ELUAUXz3CRCRdx1qpVy+jCLQON4ffiFpj8w9PFFw6lmJJxoOeiJL4ImfpjTO9OlouyucsQFzVzenLr0vTw9ylRooQUH6eF9/uTTz6hypUry02Lqfj7czooF0Td1pncGlG5UVGK3Pl76OIbgfRwsRlTct0KvkkyBZ8futURXOzGxfjKzSIHK27JfOrUqVTPE93iu8wy5XP4N2D4G+Q0zI4icM4R8s0q9zfkwMOtwXWL5lPDN3BcvJ1WsTWfF/x7MzynlFa7yjHNrNTOW5dUfkv8mfyb0L2m8E2TsVa1GWWYKzbEvwm+LnGRdW5CjjMHcNcBpT6F6xW5aToXc/IFed26ddqcE3fZ4NEvuE6B75j4wsfNvPmOj4NQRvDffPzxx9LlhE8urlfh4Mw/KM5pcM5JwZ/PdaFcp8p9Sg3rFNPCQZIDHI+AxN1a5s2bp/c612lwbpMDD+fAuMiW6yu4yIkvXvyYWnDn7/rpp5/K9+DiX/4OnPPhfedcFOfIFZwr5IsPB4tRo0bJRYhvSriY2/Cir4t//FyUxPtQs2ZNsre3l4ungnPe/OPji5XSvD8jOCBwfZThRZeLwPmCyRdvvphw4OP1uiULGcXfn0sm+EL42WefSV0Uf1cuweAiNT7erHbt2hIw+AaNzz3uusLn2759+zJ0A8bn4ocffihVCpw2+/fvl+4CpuDznW/Q+MaDS1R43/kYcs5Pwd2xODBwkSCfg1y0x+cM14PxBVqph8+qjH4Oj97Evx/eV+4+w8Fq4sSJknvidMwqvinjYmCmVHekhz+fzys+Jvy74POXS3u46xJ39+HfI5//HCS57pK359winxMcpDmny4HPFBk9bytXriyjZHHOkm8c+fjyOk5H/o3xDTn//vk6wenKNw9XrlwxMdX++yw2ffp0ubZwUTuf48pNj9KdJqs3CSbL1aZIVk5pRacs3BSeW7JyCzTubsHNx401O+/SpYs0C+fWndxc/OzZs9LikVs+ZrTFLndT4Cbu3Eozb9680orNWNN+buXI72PYEjQj5s2bJ3/LLWB1m4Tr4ibs3IKVW4Zyq0BuLs//5m4yht/FsKXcggULpJsJpxt3Q+FuDca6g3CTdG5Ryttwa1Nu5Thq1Kg03//Bgwea119/XZM/f35phWfs1P/iiy9k/aFDhzKcJjt27JC/4RaKCu7+w83yuVUnt47m48Hfa+rUqXqtGvkYc9oY4vPFsNXimTNnpMUyf2dOH26pbOz4creaVq1aSRcQ7qbAzfm5+0p6rWoZt87l1pycRtxat2XLltJVw5RWtdwVYfjw4fLZfGy4K8ixY8dSbH/q1ClNt27d5PfB5wl3FeKuPdytIi1KC1FubWnI2H5m5HO4pTl3m+BzlX8/3DKYu2sYplFan22sVa0u7nqRVmt6Y7g7Bh8P3mfed+7+xd+Fzy8Ft8jmVufe3t6yDXcn4f3TbTGc0TTL6Hl78+ZNOcf4esV/r5tG33zzjXxXPvb8fefPny/vb/h7438PHTo0xf4YXvfYuHHj5Ltzi1vD8/idd96R1sK5zY7/l7uhGsyJc4Vc18m54ooVK+Jg6OBcVkY6phvi1olcVJ2R4nKwPZxj4879XFqiNEyCrOMBO7ghFI/MlpGqleyEwGkjuGn5jRs3pH6VL/Lr16839y6p5sfHNxFcFMrF0Fy02bFjR5Peg4vPuHiSi6Oyu8UvWC6u++Y6Xi5q5eoE7iLDddKQPbgqh4uL+caEW4TnJtRx2gi+sHNFPXdJMbVVpzXjui6uH+EWilzHZWrQZNxtgeup+cYEgRMUXL+nDCnH9akImtmL24hwQ8XcDpoMOU4AAAAToDsKAACACRA4AQAATGDzdZw8FiN3ouV+QZhPEQDAdmk0Ghkxilvrcl/v1Nh84OSgmd5QdQAAYDtu376dZkM/mw+cyggUnFDcSstYjpRHveHRftK6A4GMQ5rmDKQr0tRSJKv0usrd0zgjld6wjzYfOJXiWQ6aqQVOHguRX1PTAbZkSFOkq6XAuWqb6WqXzhje6ttjAAAAFUPgBAAAMAECJwAAgAkQOAEAAEyAwAkAAGACBE4AAABLDZz//vsvtW/fXkZt4ObAGZn6as+ePVSzZk2ZhZxnI8fMHwAAYDOB8/HjxzLh68yZMzO0PU/j1LZtW5kqi+eb5HnveJLmNWvW5Pi+AgCAbVLVAAht2rSRJaM4d1msWDGaNm2a/JvnvTt27Bj98MMP1KVLlxzcUwAAsFWqCpymOnjwILVq1UpvXevWrWnhwoX0/PlzcnJySvE38fHxsugOsaSMZMGLIV7HA/8aew0yB2maM5CuSFNLkazS62pG98eiA+f9+/epYMGCeuv434mJiRQZGUn+/v4p/mby5Mk0YcKEFOt53EQeAspYQsbExMhBVuPQUJYIaYp0tRQ4V20rXePi4qw/cBobU5APhLH1inHjxtHo0aNTDOrLgw2nNlYtv5faBiO2ZEhTpKulwLlqW+nq6upq/YGzUKFCkuvUFR4eTo6OjuTt7W30b1xcXGQxxAcvtQPIBzit18F0SNOcgXRFmloKOxVeVzO6L+rZ40yoX78+bd++XW/dtm3bqFatWkbrNwEAALJKVYHz0aNHdPLkSVmU7ib8PCQkRFvM2rNnT+32gwcPplu3bknR64ULF2jRokXSMGjMmDFm+w4AAGDdVFVUy11JmjVrpv23UhfZq1cvWrJkCYWGhmqDKAsKCqLNmzfTqFGjaNasWTJwwowZM9AVBQAAbCNwNm3aVNu4xxgOnoZeeuklOn78eA7vGQAAgAqLaiHnRD+NpkaLGtGiE4soKTkJSQ0AYA05Tsg5i08upv2391NcQhz1qdYHSQ0AkEnIcdqAZE0yzT46W54PrT001T6uAACQPgROG7Dt2ja6Fn2NPF086a3Kb5l7dwAALBoCpw2YdXSWPPau1pvcnd3NvTsAABYNgdPKPUt8Rpsub5Lnzg7OUmwLAACZh8Bp5VwcXGhAjQHy/PsD31OH3zvQg6cPzL1bAAAWC4HTynFDoLmvzqV5r86TILrx8kaq8XMNOnr3qLl3DQDAIiFw2kjwHFBzAB3qf4hKFihJt2JuUcNFDWnmkZlpDjgBAAApIXDakGqFqlHwwGDqXL4zPU9+Tu/9/R61WdGGrkRdMfeuAQBYDAROG+Pp6kmru66mqa2nSmOhrde2UqU5lejzXZ/T0+dPzb17AACqh8Bpo0W3I+uNpLPvnqXWJVtTQlICTfx3IlWcXZE2X9ls7t0DAFA1BE4bVtq7NP391t+0qusqKpKvCN14eIPa/dqOOq3sRLce3jL37gEAqBICp43j3OfrFV6ni8Mu0gcNPiBHe0daf3E9lZ9Vnr7Z943kRgEA4D8InCDyOuel71p+RycGnaDGxRrT08SnNG7HOKo6tyrturELqQQA8H8InKCnkl8l2tN7Dy3ruIz83P3oYuRFar6sOb299m26/+g+UgsAbB4CJxgtvn2n6jt0cehFGlJrCNmRHa04s4LKzixLPx3+iRKTE5FqAGCzEDghVQXcCtCsdrPoyIAjVLtwbYqNj6XhW4ZTnfl1aPX51aj/BACbhMAJ6apVuBYd7HeQ5rSbQ/ld89OJ+yeo66quFDA1gD7a/hEGUAAAm4LACRniYO9Ag2sNpkvDLtHHjT4m/7z+FP44nL478B2VmVmGmi1tRr+d+U1mYwEAsGYInGASbjD0dYuvKWRUCK3vvp7alW5H9nb2tPvmbuqxtgcVnVKURm8dTecjziNlAcAqIXBCpnB/zw7lOtDGHhvp5oib9MVLX1CARwBFPY2iqYemyihEjRY1osUnFtPDZw+RygBgNRA4IcsCPAPo86af040RN2hTj03UsVxHcrBzoP2391PfDX3J73s/GUx+4fGFFPkkEikOABYNgROytR60bem2tK77Oro96jZ93fxr6RfKM7FsubqF+v/Vnwr9UIhaLm9JS84todC4UKQ+AFgcO42NT8gYGxtLnp6eFBMTQx4eHileT05OpvDwcPLz8yN7e9xnZMalyEu05sIaWY6HHteu5/6hDYs1pC7lu8jCOVfIPJyr2Q9palvpGptOPFAgcCJw5qrr0ddpzfk1tPL0SgoOD9Z7rU6ROtogWtKrZO7umBVQ68XIkiFNbStdYxE4syeh1HqALZmSpgmuCbT+0nrJie69tZc0pNGbdJsDKA9AX86nnFn311LgXEWaWopklV5XETizKaHUeoAtmbE05XFweVYWDqI8qHySJkm7fQXfCtogWtmvsgwJCBlLV8j+cxWsN10ROLMpodR6gC1ZemnKLW83XNogQXT7te3SuEhRyquUNojW9K+JIGpCukL2n6tgXemKwJlNCaXWA2zJTElT7gO68fJGCaLcMld3ZKLinsWpc/nOEkTrFa0nAzHYMpyrSFNLkazS6yoCZzYllFoPsCXLbJo+SnhEm69sliC66fImevz8sfa1wvkKU/eK3emtym9RDf8aNpkTxbmKNLUUyRYeONWzxwAZmGy7W8VutPL1lRTxQYT0F327ytvk4eJB9+LuyYhFtebXonKzytGE3RMw+DwA5AgETrBIbk5uMkLR8k7LKXxMOP35xp+S43RzdKPLUZfpiz1fyODztefXpqkHp2KwBQDINgicYPFcHF3otbKv0e+v/05hY8IkmLYp1UaG/Tt27xiN3jaaikwpQi8ve5kWnViEsXMBIEsQOMGq5HPJJ8W3m9/aTPfev0cz28ykBgENpI/ojhs7qN+GflTwh4LU5Y8u9PeVvykp+b9uLwAAGYHACVY9BdrQOkNpf9/9dH34dZrUfBJV9K1ICUkJtPbCWmr7a1sqOaMkff3v1yjKBYAMQ+AEmxBUIIjGNR5HZ949Q6cGn6KRdUdSftf8dCvmFn2y6xMqNq0Yvf7H69JvNFmTbO7dBQAVQ+AEm8LdVKoUrEJTX5lK90bfo6Udl0pRbmJyonRzafVLKyrzUxn6dt+3FP443Ny7CwAqhMAJNt0yt2fVnlKUe3rwaRpae6h0bbkWfY3G7hhLRacUpe6ru8sQgDY+iRAA6EDgBCCiygUr08y2MyUXuvC1hTJTCw/198e5P6j5subSN/THAz9S1JMopBeAjUPgBNDh7uxOfav3pcP9D9PxgcdpUM1BMvAC9w0ds32MdGt5e+3bL2ZzQS4UwCYhcAKkorp/dZr76lzJhf786s9UvVB1ik+KpxVnVlCTJU2o0pxKNOPwDIp+Go00BLAhCJwAGegbOrDmQAoeGExH+h+hftX7UR6nPHQ+4jyN2DKCCk8pTL3X96ZDdw4hFwpgAxA4AUxokVu7SG1a8NoCyYXOajtL5gflGVuWnlpK9RfWp+o/V6e5x+ZSXHwc0hXASiFwAmSCp6snDak9RPqEHuh7gHpV7UWujq50KuwUvbvpXcmFvrvxXToddhrpC2BlEDgBspgLrR9Qn5Z0XEJ3R9+lqa2nUlnvsjIF2tzguVR1blVqsLABLT+1XG8uUQCwXAicANnEy82LRtYbSReGXqCdPXdS1wpdydHekQ7eOUg91/eUFrljto3BdGcAFg6BEyAHcqHNgprRH13/oJCRIfRVs6+omGcxevD0Af148EeZ7uyVX16hLVe3YHg/AAuEwAmQg/zz+dP4JuNlkPm/3vyL2pZuS3ZkR1uvbaU2K9pQxdkVac7ROfQ44TGOA4CFQOAEyAUO9g70aplXaVOPTXR1+FUaVW8U5XPORxcjL9KQzUOo6NSi9NH2jygkJgTHA0DlEDgBclmJAiVoSuspdGf0HZr+ynQqWaCkTK793YHvqMT0EjI+7oHbB9AnFEClEDgBzIQHlB9edzhdGnaJNryxgZoHNackTZKMj9twUUOqu6Au/XrmV5k/FADUA4ETQAXFuO3LtqcdPXdIv9C+1fqSi4MLHb13lN5a+xYFTQ+iSXsnUeSTSHPvKgAgcAKoC88VurDDQgoZFUITm06kQnkL0b24ezR+53gKmBpAA/8aSOfCz5l7NwFsGnKcACrk5+5Hn770Kd0aeYuWd1pONfxryAAK84/Pl8HlWy1vRZuvbEZ3FgAzQOAEUDFnB2d6u8rbdGzAMdrbZy91Kd+F7O3safv17dTu13ZUflZ5mnVkloxUBAC5A4ETwEIGVWhUrBGt7raarg2/RmPqjyFPF0+ZJ3TY38Oo6JSi9OE/H9LtuNvm3lUAq4fACWBhAvMH0vetvpfuLDPbzKTSXqUpJj5GRiWq91s96rqqK+0L2YfuLAA5BIETwELldc5LQ+sMpYvDLtLGNzfSyyVeljrPtRfXUuPFjan2/NoyuDy6swBkLwROAAvHdZ7tyrSjrW9tpV1dd1H/6v1lirPg0GAZXL74tOL05Z4v6W7sXXPvKoBVQOAEsCLlvMrRz6/+TLdH3aZJzSdR4XyF6f6j+/TZ7s9kWD8eG3fE3yPor0t/UWx8rLl3F8Ai2Wk0Gg3ZsNjYWPL09KSYmBjy8PBI8XpycjKFh4eTn58f2dvjPiM7IE1zL12fJz2n1edX08yjM+ng7YOkof9+7g52DlS3aF16OehlKeatV7QeOTk45dDeWSacq7aVrrHpxAOFY67uFQDkKg6Eb1Z+Uxae1mzXjV3SleWf6//QtehrMiYuLxP/nSh1pi8Vf0mCKC8VfStKa14A0IfACWBDE213qdBFFnYj+gbtuLFDgig/8pB+m65skoXxqEUtglpQyxItqUWJFlTUo6iZvwGAOiBwAtiooAJB1L9Af+pfo7+0xj0ddlqCKOdI997aK3WjK86skIWV9S4rgZSDaNPAphKIAWwRAicASMvcaoWqyTKmwRgZ3o/rRDmQ/nPjHzp27xhdiroky+xjs2Uy7ur+1SWQ8qwujYs1Jndnd6Qk2AQ0DkLjoFyn1oYBli4n0zX6aTTtubWHdlzfQTtv7qTzEef1Xneyd5LGRUog5UZHPFygpcO5alvpGovGQQCQXQq4FaCO5TrKwkLjQmnnjZ1SN8pLSEwI7Q3ZK8sXe74gdyd3aly8sTaQck6Wc7UA1gBFtQBgMv98/vRWlbdk4R5t16Ova4MoB1RuaLTl6hZZGNeHNgtsJkGUg2kZ7zJosQsWC4ETALKEu6yU9Copy8CaA6Wh0dnws9pi3T0390hXmDUX1sjCiuQrIo2Mmgc2R4tdsDgInACQrbhIlifk5mVU/VEyCAM3LlJyo/tv76e7cXdp2allsjDOgSpBlHOm3nm8cVRAtRA4ASDHB2GoH1Bflk+afEJPnz+V4KnUkXJQ5enReJkbPFda7HKdqFKsy3WlPDgDgFogcAJArnJzctOOTsQePnsoxblKID0XcY5O3D8hC0+V5mjvKC12eSCGobWHIjcKZofACQBmld81P3Uo10EWxgMvcBBVAunNhzdlflFeph+eLoPX86ANDvYOOHJgFmgfDgCqwkP99ajcgxa8toBujLhB14Zfo3mvzpM6U25kNHjTYKq7oC4dvnPY3LsKNgqBEwBUrUSBEjSg5gAKHhhM01pPIw8XD5lrtP7C+tR/Q3+KeBxh7l0EG4PACQAWges6R9QbQZeGXaJeVXvJFGkLTyyksjPL0uyjsykpOcncuwg2QnWBc/bs2RQUFESurq5Us2ZN2rt3b5rbr1ixgqpWrUp58uQhf39/6tOnD0VFReXa/gJA7hflLum4hPb12Setb6OfRdPQzUNp8MbBMhgDgE0FzpUrV9LIkSNp/PjxdOLECWrcuDG1adOGQkJCjG6/b98+6tmzJ/Xr14/OnTtHq1atoqNHj1L//v1zfd8BIHc1LNaQjg04RtNfmS59RxecWEDf7f8OhwFsq1XtlClTJAgqgW/atGm0detWmjNnDk2ePDnF9ocOHaLAwEAaPny4/JtzqoMGDaLvvkv9xxMfHy+L7qC+yqDDvBjidXwXa+w1yBykac6wxXTlPp/Dag8j0hCN2DqCxu4YS4H5A6lrha7Z8v62mKa5IVml6ZrR/VFN4ExISKDg4GAaO3as3vpWrVrRgQMHjP5NgwYNJHe6efNmyZnyaPurV6+mdu3apfo5HIAnTJiQYn1ERAQ9e/bMaELGxMTIQVbTKP6WDGmKdM1u3QK70elKp2nh2YXUa30vck90p1qFamX5fXGu5oxklV5X4+LiLCtwRkZGUlJSEhUsWFBvPf/7/v37qQZOruPs3r27BL3ExER67bXX6Keffkr1c8aNG0ejR4/Wy3EGBASQr68veXh4GD3APBYnv66mA2zJkKZI15wwp8McCosPo41XNlLf7X3pQN8D0iI3K3Cu5oxklV5XuW2NRQVOBSemLr4jMVynOH/+vBTTfvbZZ9S6dWsKDQ2lDz74gAYPHkwLFy40+jcuLi6yGOKDl9oB5M9P63UwHdI0Z9hyuvJ3/u313+ilJS/R8dDj1P739hI8eUq0rLDlNM1JdipM14zui2r22MfHhxwcHFLkLrn41TAXqlvs2rBhQwmWVapUkeDJrXIXLVokQRQAbAuPafvXm39RUY+idDHyInX+ozMlJCWYe7fAyqgmcDo7O0v3k+3bt+ut539zkawxT548SXGHwMGXoVk6gG0qnK8wbeqxifI556PdN3fTwL8G4noA1hk4Gdc9LliwQHKMFy5coFGjRklXFC56VeonufuJon379rR27VppdXv9+nXav3+/FN3WqVOHChcubMZvAgDmxMPzreq6ihzsHGjpqaU05eAUHBDINqqq4+RGPjx4wcSJE6WotVKlStJitnjx4vI6r9Pt09m7d29pBTVz5kx6//33KX/+/NS8eXP69ttvzfgtAEANePaVqoWqSn0nDxb/foP3zb1LYCXsNDZepsmtaj09PaVpdGqtarme1c/PT1WV2JYMaYp0zQ1j/xlL3+7/lvI45aHD/Q9TJb9KJr8HztWckazS62p68UChnj0GAMgmq86tkqDJFndYnKmgCWARRbUAAFnBBWhcLNvnzz7y7zH1x1C3it2QqJCtEDgBwOLFxsfS8lPLac6xOXQu4pysaxHUgr55+Rtz7xpYIQROALBYp8NO05yjc2j56eX0+PljWcd1mu9UeYcmt5hMDvYvuqcBZCcETgCwKPGJ8bTmwhqZg3P/7f3a9eV8ytGQWkOoZ9We5OnqadZ9BOuGwAkAFuHmw5s0L3geLTi+gCKeRGgnt+5YrqMEzKaBTVMdnhMgOyFwAoBqJWuSaevVrTT72GzadHkTaXj+sP+PDjSo5iDqX6O/PAfITQicAKA6kU8iadGJRTT32Fy68fCG3qAGnLtsX7a95DYBzAFnHgCopivJ4buHpe7yj3N/UHzSiwnn87vmp95Ve9PgWoOprE9Zc+8mAAInAJjX44TH9OuZX6U49uT9k9r1Nf1r0pDaQ+iNSm9IS1kAtUCOEwDMIuZZDM04PIOmHJpCD589lHWujq4SKLk4tnaR2jgyoEoInACQq8WxHCQ5YE47PE0bMEsWKEnv1nqXelfrTd55vHFEQNUQOAEgVwJm9LNomn5oOk0/PJ1i4mNkfQXfCvRZk8/o9QqvY7ACsBgInACQox48fUBTD06lGUdmyNB4rKJvRfr8pc+pS4UuZG+HuSbAsiBwAkCO4cEKRm8dTXEJcfLvyn6V6bOXPqPO5TsjYILFQuAEgBzBo/wM2jhInlctWFUCJo/ygxwmWDoETgDIdotPLNYGzffrv0/ftfwOAROsBgInAGSrX07/Qv029JPnw+sMp+9bfo8xZMGqoFYeALINj/jTa30vGVN2cM3BNO2VaQiaYHUQOAEgW6y7sI56rOkhA7P3rdaXZrWbhaAJVgmBEwCybOPljdR9dXdK0iTR21Xepnnt56FOE6wWAicAZAlP+9Xljy70PPk5da/YnRZ3WIzBDMCqIXACQKbtuL6DOq7sSAlJCdI3c3mn5ZjuC6weAicAZMrRu0epw+8d6FniM2pfpj391uU3cnJwQmqC1UPgBACTXX1wldr92o4eP39MLUu0pFVdV5GzgzNSEmwCAicAmCT8cTi98ssrFPEkgqoXqk5ruq0hF0cXpCLYDAROAMiwRwmPJKd5LfoaBeYPpM1vbaZ8LvmQgmBTEDgBIMN4wPZj946Rt5s3bXlrCxXKWwipBzYHgRMAMiwpOUkeGxZrSGV9yiLlwCYhcAJAhr3f4H2yIzvacGkDnQ0/i5QDm4TACQAZVsG3gkw+zb7e+zVSDmwSAicAmOSTxp/I48qzK+lS5CWkHtgcBE4AMEnVQlVlwAOeAWXyvslIPbA5CJwAYLJPm3yqnXvzevR1pCDYFAROADBZ7SK1qXXJ1jIbyjf7vkEKgk1B4ASATPmkyYu6ziUnl1BITAhSEWwGAicAZEqjYo2oaWBTmU7s+/3fIxXBZiBwAkCW6zrnH59PoXGhSEmwCQicAJBpzQKbUYOABhSfFE8/HPgBKQk2AYETADLNzs5Om+ucGzyXIh5HIDXB6iFwAkCWcOvamv416cnzJ/TrmV+RmmD1EDgBIMu5znI+5eR5YnIiUhOsHgInAGTZg6cP5NHLzQupCVYPgRMAsgyBE2wJAicAZFvgLOBWAKkJVg+BEwCy5HnSc7r58KY8D/AIQGqC1UPgBIAsuRR1SUYPyuecjwLzByI1weohcAJAlpwOOy2PVQpWkRa2ANYOgRMAsiVwVvarjJQEm4DACQBZcib8jDxWLojACbYBgRMAsiXHWbVgVaQk2AQETgDItOin0XQn9o48r+RXCSkJNgGBEwAy7dCdQ/JY3LM4ebp6IiXBJiBwAoDJYuNj6cPtH1KH3zvIv+sWrYtUBJvhaO4dAADLkZScREtOLqGPd35M4Y/DZd0rpV6hKa2mmHvXAHINAicAZMi+kH00YssIOh56XP5dxrsMTW09ldqWbosUBJuCwAkAaboYeZEm7JlAv5/9Xf7t6eJJn7/0OQ2tM5ScHZyRemBzEDgBIIWoJ1G08txKWnpqKR25e0TW2ZEdDagxgL5s/iX5ufsh1cBmIXACgEhISqC/r/xNy04vo78u/SXjzzIHOwcpjp3YbCJVK1QNqQU2D4ETwIZpNBoKDg2mZaeW0W9nf6PIJ5Ha16oXqk49q/akHpV7IIcJoAOBE8AG8aAFK06vkNzl+Yjz2vWF8haityu/LQETQ+gBGIfACWAjHic8pnUX10nu8p/r/5CGNLLe1dGVOpXrJMHy5RIvk6M9LgsAacEvBMCKJWuSac/NPZKzXH1+NT1KeKR9rXGxxtSrai96vcLrGPUHwAQInABW6FLkJVp+erksITEh2vUlC5SUnOU7Vd6hoAJBZt1HAEuFwAlgJR48fUBLzy2ldRvX0eG7h7Xrud9l94rdJWA2CGiAyaYBsgiBE8DCi2J3XN9B84/Ppz8v/SldSpQuJK1LtZai2PZl2pObk5u5dxXAaiBwAlhoq1geM3bhiYV08+FN7fqK3hWpT40+9FaVt6SFLABkPwROAAuRmJxImy5vogUnFtDmK5slt6kUxb5d5W3qU7UPFXEoQn5+fmRvj4mPAHIKAieAyl17cE1ylpzDDH0UqtcqlofA61KhC+VxykPJyckUHv5ixhIAyDkInAAqnb5rw6UNNOvoLNpxY4d2vW8eX6m37F+jP5X1KWvWfQSwVQicACoS8yyGFp1YRDOOzNDWXfLg6q1KtpJg+VrZ1zAjCYCZIXACqMDVB1dpxuEZtPjkYu0gBV5uXjSwxkAaVGsQBeYPNPcuAsD/IXACmHGA9V03d9G0Q9No4+WN2iHwKvhWoJF1R0rLWK67BAB1QeAEyGXPEp/Rr2d+lYB5JvyMdj1P3cUBk8eLtbOzw3EBUCkEToBcEhoXSnOOzaG5x+ZSxJMIWcc5yt5Ve9PwusPR2AfAQiBwAuSw4HvBNP3wdPr97O/ayaEDPAJoWJ1h0p2kgFsBHAMAC6K6XtKzZ8+moKAgcnV1pZo1a9LevXvT3D4+Pp7Gjx9PxYsXJxcXFypZsiQtWrQo1/YXILXBCtacX0ONFzemWvNryWDrHDQbBjSkVV1X0fUR1+nDhh8iaAJYIFXlOFeuXEkjR46U4NmwYUP6+eefqU2bNnT+/HkqVqyY0b/p1q0bhYWF0cKFC6lUqVLSATwxMTHX9x2APXz2kBYeX0g/HfmJbsXcknU8vyUPsj6i7giqXaQ2EgrAwqkqcE6ZMoX69etH/fv3l39PmzaNtm7dSnPmzKHJkyen2H7Lli20Z88eun79Onl5ecm6wEA024fcF/00Whr7TDs8jWLjY2WdTx4fGlRzEA2pPYQK5yuMwwJgJVQTOBMSEig4OJjGjh2rt75Vq1Z04MABo3+zYcMGqlWrFn333Xe0fPlycnd3p9dee42+/PJLcnNzS7VolxdFbOyLixwPV8aLIV7H3QaMvQaZY01pygGT6y+nH5muDZgVfCrQyHojqUelHtpZSXLju1pTuqoF0tS20jU5g/ujmsAZGRlJSUlJVLBgQb31/O/79+8b/RvOae7bt0/qQ9etWyfvMWTIEHrw4EGq9Zycc50wYUKK9REREfTs2TOjCRkTEyMHGQNnZw9rSNOH8Q9p3ul5tODsAopLiJN15b3K0+iao6ltUFuyt7OnuOg44v9yizWkq9ogTW0rXePi4iwrcCoM+69xwqbWp40Tn19bsWIFeXp6aot7X3/9dZo1a5bRXOe4ceNo9OjRejnOgIAA8vX1JQ8Pj1Q/g19X0wG2ZJacplIke3iaDImn5DAr+1WmT5t8Sp3KdZKAaS6WnK5qhTS1rXR1dXXN+cD5/PlzyQ0+efJEEkCpZ8wMHx8fcnBwSJG75MY+hrlQhb+/PxUpUkQbNFn58uUl2N65c4dKly6d4m+45S0vhvjgpXYA+QCn9TqYzhLTdF/IPmr3azttwKxSsAp9/tLn1LFcR7MGTEtPV7VDmtpOutpncF9M3uNHjx5Ja9emTZtKwOLGOBUqVJDAyV1CBgwYQEePHjV5h52dnaX7yfbt2/XW878bNGhg9G+45e29e/dknxSXL1+WL1+0aFGT9wEgNQlJCdR/Q38JmpX8KtGabmvoxKAT1Ll8Z9UETQDIHSb94qdOnSqBcv78+dS8eXNau3YtnTx5ki5dukQHDx6kzz//XLqCtGzZkl555RW6cuWKSTvDRagLFiyQ+skLFy7QqFGjKCQkhAYPHqwtZu3Zs6d2+x49epC3tzf16dNHuqz8+++/9MEHH1Dfvn1TbRwEkBncYvZS1CXyc/ejfX32IWAC2DCTimq5deuuXbuocuXKRl+vU6eOBC3uPsLBj7uKGCsuTU337t0pKiqKJk6cSKGhoVSpUiXavHmz5GQZr+NAqsibN6/kSN977z1pXctBlPt1fvXVV6Z8LYA03Y29SxP3TJTn3738HXm6/lc1AAC2x07DFYI2jBsHcZEzt/BKrXEQ17P6+fmpqizekllamvZY04N+O/sb1S9an/b13afaollLS1dLgDS1rXSNTSceZEvjIO6+cfr0aUkAw/4v3J8SwNLtublHgiZPJj2z7UzVBk0AyD2ZDpw8ag/XN3LfSWOtpbhPJoCljzc77O9h8pxHAKrhX8PcuwQAKpDp2+dhw4ZR165dpd5RGXVHWRA0wRrMPjqbzoafJS83L/qqOerNASCLgZOLZ7kVbGp9LAEsWdijMPp016fyfFLzSeSdx9vcuwQAlh44eXSe3bt3Z+/eAKjEuB3jpM8mF8/2r/Fi0gEAgCzVcc6cOVOKanm+TO6e4uTkpPf68OHDkcJgkQ7dOUSLTy6W5zPbzCQHewdz7xIAWEPg/PXXX2XKLx5ogHOeuuPJ8nMETrBESclJNGzziwZBvav1pvoB9c29SwBgLYHzk08+kYEKeBowNfXDAciKhScWUnBoMHm4eNA3Lb5BYgJACvZZmT+TR/pB0ARrMnnfiwnTJzSdQAXzouEbAGRj4OzVqxetXLkys38OoEp5nPLIo6tjxqYXAgDbk+miWu6r+d1330k9Z5UqVVI0DuJ5MQEszYAaA2jU1lE059gcGfQgtblgAcB2ZTpwnjlzhqpXry7Pz549q/caLjZgqXpV7SVdUU6HnZbWtWgcBADZFjh5lhQAa1PArQC9UekNWnJyCc0+NhuBEwBSQHNYAANDag2Rx9/P/k63Y24jfQAg84FTdy7MjLh7965J2wOoQe0italpYFMZ5H3qoanm3h0AsOTAWbt2bRowYAAdOXIk1W14HrP58+fLJNRr167Njn0EyHUfNfxIHucFz6MHTx/gCABA5uo4L1y4QJMmTaJXXnlFWtHWqlWLChcuTK6urhQdHU3nz5+nc+fOyfrvv/+e2rRpY8rbA6hG65KtqWrBqnQq7BTNPDKTPnvpM3PvEgBYYo7Ty8uLfvjhB7p37x7NmTOHypQpI/NxXrlyRV5/6623KDg4mPbv34+gCRaNW4Yruc6fjvxET54/MfcuAYAlt6rlHGbnzp1lAbBWXSt2pfE7x9ONhzdo0YlFNKzOizFsAcC2oVUtQCoc7R1pTIMx8vzHgz9KYyEAAAROgDT0qdaHfPP40s2HNyXXCQCAwAmQBjcnNxpRd4Q8H7RxEDVc1JDWnF8j048BgG3KdOC8fRsdw8E2jK4/mvpX709O9k504PYBen3V61Tqp1I07dA0io2PNffuAYClBM5y5crRp59+So8fP87ePQJQYa5z/mvz6dbIW/RJ40/I281bim55MPiAqQH0/tb36dbDW+beTQDIJZkOnNu3b6dt27ZR6dKlafHixdm7VwAq5J/Pn75s/iWFjAqhue3mUjmfcpLjnHJoCpWcUZK6r+5OB28fJI1GY+5dBQA1Bs4GDRrQ4cOH6ZtvvqHPPvtMZkrZvXt39u4dgErn7BxUaxCdG3KONvXYRC2CWlCSJon+OPcHNVjUQIpxP97xMZ26fwpBFMAKZblxUM+ePeny5cvUvn17ateuHXXq1ImuXr2aPXsHoGL2dvbUtnRb+qfnP3Ry0EnqXa23BNXr0ddp8r7JVO3nalRhdgX6YvcXdCHigrl3FwDU1KqWi6ZatWpFAwcOpA0bNsg4te+//z7FxcVlx9sDqF7VQlVpcYfFFD4mnH7v8jt1KteJXBxc6GLkRZqwZ4IE0Kpzq9KkvZPo2oNr5t5dAMgCO00mK2Tmzp1LR48elYXHsHVwcKAqVapQvXr1qFq1arRixQrJia5bt07GrlWr2NhY8vT0lMHpPTw8UryenJxM4eHh5OfnR/b26L2THWwlTbn+88+Lf9LKcytp27Vt9Dz5ufa1mv41Zd7PbhW7UTHPYtnyebaSrrkJaWpb6RqbTjzIcuAMCAiQIKksHBxdXFz0tuEB4X/99Vc6e/YsqRUCZ+5T648mJ0U/jaZ1F9dJEN1xfYfUiSrqF61P3St2lyH+CucrnOnPsMV0zWlIU9tK19icDpwZERYWJrOnJCWpt7M4AmfuU+uPJrdEPI6gNRfWSBDdc3MPaejFT9CO7KhJ8SYSRLtU6EJ+7n4mva+tp2tOQJraVrrGZjBw5ugec6Ls3LkzJz8CwOL4uvvS4FqDaVevXXR39F2a8coMahDQQALonlt7aMjmIeT/oz+1XN6SFhxfgPlAAVQmR3OclgA5ztyn1rtNcwuJCaFV51ZJTvTovaN6g823KtlKcqIdynYgT1dPo3+PdM1+SFPbStfYDOY4MzWtGABkP24k9H6D92XhlrfcL5SDKE+mvfnKZlmcHZyl32jdInWpVuFaVLNwTSqUtxAOB0AuQo4TrWpznVrvNtXqUuQlCaC/n/2dLkSm7A9aJF8RCaA1C9WkknlKUovyLahQPgTT7IBz1bbSNTanGweFhIRIy1o7Ozu99fx2PAB8sWLZ08Q+pyFw5j61/mjUjn9bZ8PP0q6bu+jYvWMUHBosAysojYt0BXgESDCt5f8iV8rdX7huFUyDc9W20jU2p4tqg4KCKDQ0VL64rgcPHshram5JC2CJ+Ca1csHKsigeJTyik/dPSiDl5fDtw3Tt4TW6HXtblvUX1+sVBUvxrn9N7aN3Hm8zfRsAy+WYlbtfw9wme/ToEbm6umZ1vwAgA/I656VGxRrJotzFu3m60anwU9pcKT9ejrosjY94WXthrfbvA/MHSgCtXqg6lfEuQ6W9S1Mpr1LyvgCQTYFz9OjR8shBk6cVy5Mnj/Y1zmXywO88chAAmEc+l3zSH5QXRcyzGDpx/wQF3wumY6HH5PHKgysyPRov3K9UFzc4Ku31IohqHxFUATIXOE+cOKHNcZ45c4acnZ21r/HzqlWr0pgxY0x9WwDIQdyFpWlgU1kUD589pOOhxyWIngk/I4H06oOrFPkkku4/ui/L3pC9Kd4LQRVsncmBc9euXfLYp08fmj59epoVqACgXvld81PzoOay6OKAygH0StQVbTBFUAXIhjpOTF4NYL0BlRsP8WIIQRUgiwMg7NixQxZukMANE3QtWrQI6QtgZRBUAbIQOCdMmEATJ06UWVH8/f2NtrAFANuRW0FVaaSE1r9gcYGT5+NcsmQJvfPOO9m7RwBgU0GVp1zjAKobTDMaVP3z+htt+YugCqoMnAkJCdSgQYPs3RsAsDkF3ApQ7SK1ZTE1qIY+CpUlo0GVn5f0Kol+qmCewNm/f3+ZpJr7cgIAqCWocnFw1NOoNINqUY+iVM6nHJX3KS+PynMuFka1E2Rr4FQGP2DcGGjevHn0zz//UJUqVcjJyUlv2ylTppjy1gAAORZUtYH1/0H1TuwdWf65/o/e33m6eOoFUh5NydfOl7x8vMjZ/r8+62DbHDMz+IFCGSHo7NmzeutxxwYAag6qFyMvysKzzSjPr0Vfo5j4GDp897AsupzsnaS4t7xveSrnXe7Fo085KutdVkZqAtvimJnBDwAALDmo1g+oL4uu+MR4yZUqwVQeI148Pk18Ko/GpnUzLPZVHlHsa70wkTUAABG5OLpQRb+KsuhWSd0Pu08Jrgl0+cFlmcZNN6ca9jgszWJfzpnWLlxbJh6vV7QelShQAiVythw4des7DYtpeXaUUqVKUYcOHcjLyysr+wcAYFb2dvYyJVtggUBqVbKVScW+h+4ckuUn+km298njIwG0XpF6VLdoXapTpA55uGDYUkuT6YmsmzVrRsePH5cZUcqWLSuDvl+5coUcHByoXLlydOnSJQmi+/btowoVKpBaYSLr3KfWSWwtHdJVPWmqFPvy4PmH7xymQ3cPyYD6CUkJetvZkR1V8K3wIpj+f+GiXgd7B7JmybY6kbWSm+Qxa5UP4A/t168fNWrUiAYMGEA9evSgUaNG0datWzP7MQAAFl3s+0alN7TBlCcd54ZHSk70xsMbdC7inCwLTyyU7XguVM6Jcq6UAynnTP3c/cz8jSBbcpxFihSh7du3p8hNnjt3jlq1akV3796VHCk/j4yMJLVCjjP3qfVu09IhXS0vTcMehWkDKT8euXuEHiU8SrEd140q9aS8VCtUjZwdLLd7TLKt5jj5jfmLGwbOiIgI+XCWP39+GWEIAABSKpi3IL1W9jVZWFJyEp2POK/NkXIRLzdIuh59XZbfzv4m27k4uFAN/xp6wZTrYdEVMHdkqai2b9++9OOPP1Lt2rXlgB05ckQmse7YsaNsw/8uU6ZMdu4vAIDV4rrNygUryzKg5gBZF/Msho7eO/pfML1zSAZxOHjnoCz0/y6n3P1Ft+ERjwvMxb6goqLaR48eSf3lsmXLKDExUdY5OjpSr169aOrUqeTu7k4nT57UGyhBjVBUm/vUWkxj6ZCutpGmfMnmVrtSvPv/hkdcd5qY/OI6rNsauLJfZb2GRzwSEq83t2QVpqspRbWZDpy6AfT69etyMEuWLEl581rWHQ4CZ+5T64/G0iFdbTdNnz5/Kq12leJdfuS+pYa4bynnRpWGRzwIBM9ck9uSbbWOU8GBkseqBQAA83BzcqOGxRrKorgbe1evBe+xe8ekb+m2a9tkUbrDcLFwo4BG1Lh4Y2pUrJGMhATZPMj7l19+KcWwqQ2AoMAg7wAA5lPEowh19uhMnct3ln8/T3qu16/0wO0D0tf0dNhpWWYfmy3bFfcsLgG0cbEXgZRHP1JD8a5FD/L+/Plz7fPUoGUXAIC6ODk4SUtcXt6t/a6s4wnC94Xs0y4n7p+gWzG36NaZW7TizArZxsvNixoGNJQgyktN/5rST9WWZbmO09KhjjP3qbV+w9IhXZGmWRUXHyfFuxxEeR7Tg7cPygD3ulwdXWWABi7e5UDaIKABebp6WsW5mit1nHv37qWff/5ZGgetWrVKBkVYvnw5BQUFyehBAABgOXiKtJdLvCyLUrzLuVDdXGnEkwj699a/sjA3Rzfa3Xu3BFNbkelQv2bNGmrdujW5ubnJCEHx8fGyPi4ujiZNmpSd+wgAAGYq3uWAOLr+aFrbfS2FjQmjC0Mv0EvFX9JuYzj+ri3IdOD86quvaO7cuTR//nxycnLSrm/QoIEEUgAAsC7cf3TIpiG059Ye+TfXdx4beMymcptZKqrl2U+aNGmSYj2XCz98+DCr+wUAACrBgyv8eOBH+mLPF/Qs8ZkUz37V/CsaXnc4Odrb3rTOmf7G/v7+dPXqVQoMDNRbz9OIlShRIjv2DQAAzIwHVui/ob/UdbKWJVrS3FfnysDztirTRbWDBg2iESNG0OHDh6X7yb1792jFihUyVu2QIUOydy8BACBXPXn+hD7Y9gHVnl9bgiZ3S1nacSltfXurTQfNLOU4P/zwQ2myyxNaP3v2TIptXVxcJHAOGzYse/cSAAByzY7rO2jgxoEyIwvjOUWntZ4ms7lAFrujfP311zR+/Hg6f/689MvhKcYsbaxaAAB44cHTB/T+tvdpyckl8m8efm9Ouzn0aplXkURZCZzKXJu6lKnDOHgqr6fVeRQAANSDx8FZdX4Vvff3exT+OFzGsB1aeyhNajFJ+nZCFgMnT06d1pB6fAD49aSkJFPfGgAAchnPosJdTP66/Jf8u7xPeVrw2gIZEQiyKXDu2rVLL0i2bduWFixYIKMGAQCAZUjWJNPcY3Np7D9jKS4hjpzsnejjxh/TuEbjbH4s2mwPnC+99N+IEczBwYHq1auHLigAABbiQsQF6v9Xf5khhdUvWp/mt59PFf0qmnvXLILt9VwFALBRYY/CJJc5ad8kGSovr3Ne+qbFNzJbCqYOyzgETgAAK/Xw2UPac3MP7byxk3be3Elnw89qX2tbuq20mC3mWcys+2izgTM759+cPXs2ff/99xQaGkoVK1akadOmUePGjdP9u/3790sxcqVKlejkyZPZtj8AAJY0aMH+kP0SKHfc2EHBocFSl6mrWqFq9GGDD6VvJuZOzqXA2bnzi9nEFTz4weDBg8nd3V1v/dq1a03emZUrV9LIkSMleDZs2FCmLGvTpo30Ey1WLPW7Ih6IoWfPntSiRQsKCwsz+XMBACwRT/t15O4RbaA8eOdgitlKyniXoeaBzalFiRbUNLAp+eTxMdv+2mzg5Ek+db399tvZtjNTpkyhfv36Uf/+/eXfnNvcunUrzZkzhyZPnpzm8H89evSQhkrr169P8zN4+jNlCjSm9DvlPqi8GOJ13HrY2GuQOUjTnIF0tf405dzjqfunpNiVl7239tLj54/1timSrwg1D2ouwbJZYDMK8AzQfw8VfJdklaWrIqP7Y3LgXLx4MeWEhIQECg4OprFjx+qtb9WqFR04cCDN/bl27Rr98ssvMtVZejgAT5gwIcX6iIgIyT0bS0jO0fJBVtNM5ZYMaYp0tRTmPle56PVkxEk6fP8wHb1/lILDgik2QX8QmgKuBahR4UbUsEhDalykMQV5BP1XBBtPFB4eTmqTrNLrKs8nbVGNgyIjI2XQhIIF9cdC5H/fv3/f6N9cuXJFAu3evXvJ0TFjX2XcuHE0evRovRxnQEAA+fr6Gh3tiA8wn4T8upoOsCVDmiJdLUVun6v3H92n/bf3SzcRfuTB1XlKL13cErZJ8SbUIrCF5CgrF6xscS1ik1V6XXV1dbWswKkwrKxWRiIyxEGWi2c596gM+ZcRPBA9L4b44KV2APnz03odTIc0zRlIV8tJUy525f6UHCB52ReyTzuoumHRa8NiDalRQCN5rFKwilXMgWmnwutqRvdFNanv4+MjdZSGuUsuZjDMhSpZ6mPHjtGJEye0s7Eo5eac+9y2bRs1b9481/YfACAtT58/paP3jkqrVyVXGf0sWm8bHiOWc5ANAxrK0qhYI+kugtav6qKawOns7Ew1a9ak7du3U6dOnbTr+d8dOnRIsT0Xq545c0ZvHbfG3blzJ61evZqCgoJyZb8BAIzhwdI5OHJOkgNl8L1gep78XG8bN0c3qle03otAWayhjODj6arfABPURzWBk3Hd4zvvvEO1atWi+vXr07x58ygkJES6uyj1k3fv3qVly5ZJlpr7bOry8/OTMmrD9QAAOYlLui5FXZLc5L7b++TxyoMrKbYrlLeQNifJj9yn0snBCQfHwqgqcHbv3p2ioqJo4sSJMgACB8DNmzdT8eLF5XVex4EUAMCc4hPj6di9Y9q6Sc5ZRj2NSrFdRd+K2twkP5YoUALFrlbATsO3SjaMW9Vy31RuGp1aq1quZ+XcrJoqsS0Z0hTpamnnqn1eezp095C2fpLrKg0HGnB1dKU6Repoc5Rc7FrArYDZ9l3NklV6XU0vHqgyxwkAoKZxXj/e8TFtv7qdrj68muJ1P3c/bSMezlHW8K9Bzg7OZtlXyF0InAAARgz/ezgtP71c++9yPuW0XUI4WJbyKoViVxuFwAkAYID7U/565ld5Pr3pdHqz5pvkm9cX6QRCPYXLAAAq8e2+bylJk0StSraibmW7kXceb3PvEqgIAicAgI67sXdpyakl8nx8o/FIG0gBgRMAQMcf5/6QFrMOdg7SzcRw9hEABE4AAB1tS7el0l6lpah23M5xVPfXuvTjwR9lphIAhsAJAKCjrE9ZOj/0PC3tuJRKFihJUc+i6MN/PqQS00vQ1INTZcxZsG0InAAABnj2kZ5Ve9K5d8/R1JemUlD+IAp7HEajt42mkjNK0ozDM+hZYsr5e8E2IHACAKSCx5F9o9wbdGHIBZrffj4V9yxOoY9CacSWEVRqRimafXS2DL8HtgWBEwAgAwG0f43+dPm9yzS33VwK8Aigu3F3aejmoVT6p9I099jcFEPwgfVC4AQAyCAeUm9QrUF05b0rNKvtLCqcrzDdjr1N7256VwLo/OD59DxJf+owsD4InAAAJnJxdKEhtYfQteHXaMYrM2S6sJCYEBq4cSCVnVmWFp1YhABqxRA4AQAyiWdEea/ue3R9+HWa2noqFXQvSDce3qB+G/pJDnTE3yNo85XN6MpiZRA4AQCyyM3JjUbWG0nXR1ynH1r+QL55fOlWzC2acWQGtfu1HRX4tgC9vOxl+n7/93Q67LRMfA2WC/NxYj7OXKfWufgsHdJVPWn6OOExbbm6hbZe2yoLF+Pq8s/rL+Pgti7ZmlqWbEk+eXzIliSr9BqA+TgBAMzE3dmdulToIgvnLi9FXaKtV18E0d03d0uXlqWnlspiR3ZUq3AtbSCtV7SetOIF9cK0YgAAOcjOzk7m8uRlRL0RMnDCvpB92kB6JvwMHb13VJav935NHi4e1CywmQTT8j7lqbxveZn7E5NkqwcCJwBALjcoernEy7J8T9/Tvbh7tO3aNgmi269tp6inUfTnpT9l0V6o7R0leFbwrfAimPqUl+c8PGAepzw4frkMgRMAwIy4L2jvar1lSUpOouOhx2nXzV10PuK8LBciL9CjhEd0MfKiLLq4mLd4/uLagKoNrL7lKb9rfrN9J2uHwAkAoBIO9g5Uu0htWRRcR8qjFEkQjbigDab8yLnTmw9vysLdXgwbIHEANQyo3GWGi48h8xA4AQBUjINcUY+isnADIl0RjyMkiBoGVA603ACJl503dur9TQHXAhJAK/hU0AusAZ4BZG+nnhauaobACQBgoXzdfWVpUryJ3vrY+Fgp1tXmUiNfPF6Pvk7Rz6Jlgm5edHFdKTdgMiz2LelVUupY4T9IDQAAK8Mtc+sUqSOLLp5L9HLU5f9yqf8PqLyOJ+rm+lVedDnZO1EZ7zIpin3LeJeRgR9sEQInAICN4EBXtVBVWXTxwPScG1WKepXAyo8cUM9FnJPFsGFSiQIljNajcuC2ZgicAAA2jgdc4K4tvHQs11G7PlmTTLdjbusF0/P/z6Vyke+16GuybLy8Ue/9iuQrkqIetXLByuTl5kXWAIETAACM4sZC3N2Flzal2+i19A17HKbNleoGVm6QxI2TePnn+j9678fFuzwyUp3CdahsnrLUxKcJOds7W1zqI3ACAIDJLX0L5S0kS7OgZnqvPXz2UK+VrxJYucsM16XysuzUMm2DpNqFa1P9ovUloPJSMG9B1R8NBE4AAMg2+V3zU/2A+rLoinoSRYfvHqZDdw7RwTsH6fCdwxSXEEd7bu2RRRGUP0gCqBJMuT5WbcMNInACAECO887jTW1Lt5WFZ0e5H3afHtg/kGAqgfTuYToXfk7mM+Xlt7O/aYcorOlfU5sj5YBaxKOIWY8YAicAAJil/rSCbwWqVLAS9avRT9bFPIuRwe51c6U8OtL+2/tlUXBjo81vbabA/IFmOXIInAAAoAqerp4y+H2LoBbSWpcbF80Lnkcn7p/Q247rScMfhyNwAgCA7QqNC6UdN3bIEIH8aDj5t7uTO70U+BI1D2wuLXw5t2ouyHECAECui4mPoQMXD8hMMBwoufWt4YhF3MCIc5+88ChIapngG4ETAABy3NPnT6Wecsf1HRIog0ODZYAF3ZGIavjXoOZBzSVQNirWiNyd3VV5ZBA4AQAg2yUmJ9LRu0clSPLCg8onJCXobVPWu+yLHGWJFtQ0sKnFjCyEwAkAAFmm0WjobPhZbaDcc3OP9NM0HIqPg2Sz4s2oSr4qVK1ENbK3t7ypzBA4AQAgU65HX9cWvXKjnognEXqvcw6yWWAzba6ytFdpGXWI+3GGh4dbbKojcAIAQIaEPQrTtnrlhYfR08VD6DUu1lgbKKsVqmaVk2MjcAIAgFE8IMG/t/7VBkouitXFE1zXLVJXGyh5ZB+1DY+XExA4AQBAPEt8Jo14lOLXY/eOUZImSS91qhWqpu0i0rh4Y8rrnNfmUg+BEwDARiUlJ0m3ECVQcncRDp66SnmV0gZKngnFJ48P2ToETgAAG2n1ypNP88TUPBsJ11XuvrlbBiLQ5Z/XX4pdOVByn8pinsXMts9qhcAJAGChuF8kj9mqLNx4Rx4f6z8qC/etNDYNGLd8VQYeKOdTTlq+QuoQOAEAVJQrjI2P/S8QKgHw/wEx/Il+cORJo03FgZInj1Ya9FQvVJ0c7B1y5PtYKwROAIAcxLm8yCeRRnOExoJjfFK8Se/PLVv93P20S0H3gvqPeV88KosttHrNaQicAAAmepzw2HiO0EgxadSTKNKQxqT3z+ec779AyIEvj34A1A2KnIO0xr6SaobACQA2j1uSRjyOkJFvONjxcyUg3n5wm2KTY7W5Rl6ePH9iUppxYPN285ZAZ5gj1M0V8jpfd18ZSADUC4ETAKyy0YyxQKj9t8F6wzFVM8LV0VUv56cXCA2KSTlooh7ReiBwAoBF1ROmCIL87yf/refFsIuFqXWFvnl85ZH7LObR5KFAv0AqlLeQdj0HRJ5YGa1PbRMCJwCYpeN91NMovWCXWiDk9Q+ePjD5MxzsHKTYUwl2/JzrCuVRJzgq//Z08UwRCJXByP38/CxyFg/IGQicAJBlPCExBzejuUEjRaSZaTCj1BPqBjtt8Pv/o+5raDQDOQWBEwCM9ifkPoIZCYJKIDQc0zQjOBAqgc5YINQNkDxFFeoJQQ0QOAFsqGO9brBLq8EMPzc2ykx6CrgWSDU3aLjeO4+31CsCWBqctQAWGggfJTzSC3b3H92nm+E36YndE4p8mrIhDbc0NZWHi0eGgqDSkMbJwSlHvi+AmiBwAqgsIHLH+RvRN2SS4Nuxt7WNZQwDoeEsFhnBU0AZNpYxWmf4/0Y1Lo4uOfI9ASwZAidALuPAx0GRFyVA3ox58fxWzC2TAqKbo5tejs/D3oMCvAOku4Sx3KGbk1uOfjcAW4DACZDNuKGMBMWHN/4LjjEvAiUv6Y06w61Hi3oUpcD8gTKlk4wmk0oRqbuzu/bv0HUCIHcgcAKYiFubanOKOgFSec51j2mxIzsqnK+wBMagAkEU6Bn43/P8gRI0MRA3gHohcAIY4KLSK1FXJAgaFqXy84yMSsOjzATlfxEIJSjqPOdcJOoOASwXAifYLB7C7WLkRboQcUEeL0ZdlEcOkOl1zudiUmNBkZ9zYERdIoD1QuAEqx/ajXOJEhg5SEb+P0hGXpQh31LDo86ULFDSaFFqcc/ienWLAGBbEDjBauZHvBR1SRsUlSDJRa5pTQzMQbCcTzkq71NeHpWFc5QYwBsAjEHgBIvq48id/HWDIxevclEr93dMjYuDC5X1KZsiQJbxLoN5DwHAZAicoDrPk57T9ejrKYpWeUmrYQ530dDNNSpBkuscMcYpAGQXBE4wm5hnMXQl+kqK+serD66mOk4q93EsUaDEi+Do/V+Q5IXHPgUAyGkInJDjxat34+7+13L1/8v58PN0/8n9VP8uj1OeFDnHst5lqbR3aXJ1dMVRAwCzQeCEbBGfGC85RcPcIzfYSWtAAP+8/kaLV4t4FJHcJQCA2iBwgsmePn9Kx+4do/2399OhO4fofMR5qZNMbT5GBzsHKuVVisr7lpfiVW6UU9C+INUrXY+88njhCACARUHghHSFPQqTILk/ZL88Hg89Ts+Tn6fYLp9zvhfB8f/1j8pzrpPUHUJOGVOV+0oCAFgaBE7Qk6xJlhykEiR54dyksSHlGgY0pAYBDahaoWoSILnYFX0fAcDaIXDaOB444MjdI9ogefD2wRRdPnhQ8kp+lSRQNizWUB55BB0ESQCwRQicNtjKddfNXfTnxT8lUJ68fzJF3aS7kzvVLVr3RaAMaEj1itYjT1dPs+0zAICaIHDaCJ4D8pfTv9CMwzPoXMQ5vdcCPAKkyFXJUVYpWIUc7XFqAAAYg6ujlQuJCaFZR2bR/OPzKfpZtDZH2aNyD2oe1FyCZYBngLl3EwDAYiBwWmlx7L6QfTTjyAxad2GdtiiWp7x6r8571Kd6H7RoBQDIJNX1MJ89ezYFBQWRq6sr1axZk/bu3ZvqtmvXrqWWLVuSr68veXh4UP369Wnr1q1ky4MQLD25lGrOq0lNljSh1edXS9DknOX67uvpyntXaFT9UQiaAADWkuNcuXIljRw5UoJnw4YN6eeff6Y2bdrQ+fPnqVixYim2//fffyVwTpo0ifLnz0+LFy+m9u3b0+HDh6l69epkK0LjQmnOsTk099hcingSIet4WLq3K79Nw+sOp8oFK5t7FwEArIadhsv1VKJu3bpUo0YNmjNnjnZd+fLlqWPHjjR58uQMvUfFihWpe/fu9Nlnn2Vo+9jYWPL09KSYmBjJtRpSOuv7+fmRvb26MujcjWT64en0x7k/tIOiF/UoSkNrD6UBNQaodtBzNaepJUO6Ik0tRbJKrwHpxQPV5TgTEhIoODiYxo4dq7e+VatWdODAgQwfjLi4OPLySn0Yt/j4eFl0E0r5W16MvSffWxh7zRwSkhJozYU19NORn+jw3cPa9Y0CGtGwOsOoU7lO2haxatlntaeptUC6Ik0tRbJKrwEZ3R/VBM7IyEhKSkqiggUL6q3nf9+/n/osGrp+/PFHevz4MXXr1i3VbTjnOmHChBTrIyIi6NmzZ0YTku8++CCb884o8mkkLb+wnJaeW0phT8JknbO9M3Uo1YH6VepHVX2ryroHkQ9I7dSSptYG6Yo0tRTJKr0GcMbLogKnwnA0Gk7YjIxQ89tvv9EXX3xBf/75p2T/UzNu3DgaPXq0Xo4zICBA28DI2AHmz+fXzXGAec7KSfsmSQ4zPileO9zd4JqDaWCNgVQwr/6NhiUwd5paK6Qr0tRSJKv0GsCNUi0qcPr4+JCDg0OK3CWXgxvmQo01KurXrx+tWrWKXn755TS3dXFxkcUQH7zUDiAf4LRezwlcZzk/eD59tvszinwSKetqF65NI+qOoK4Vu+oNmm6JzJGmtgDpijS1FHYqvAZkdF9UEzidnZ2l+8n27dupU6dO2vX87w4dOqSZ0+zbt688tmvXjqzBlqtb6P1t78tg64wHUP+x1Y/UplQbjA8LAGBmqgmcjItQ33nnHapVq5b0yZw3bx6FhITQ4MGDtcWsd+/epWXLlsm/OVj27NmTpk+fTvXq1dPmVt3c3KRllKU5F36OxmwfI4GTebt504SmE2hgzYHk5OBk7t0DAAC1BU7uRhIVFUUTJ06k0NBQqlSpEm3evJmKFy8ur/M6DqQK7ueZmJhIQ4cOlUXRq1cvWrJkCVmSiXsm0oQ9E2RaLyd7J+l/+UmTTzBYAQCAyqiqH6c5qKEf562HtyhweqA871y+M3338ndU0qskWSu19uGydEhXpKmlSFbpNcDi+nHasrUX1spjk+JNaE23NebeHQAASIN6Qr0NW31htTy+Xv51c+8KAACkA4HTzO7G3qUDtw9oi2kBAEDdEDjNbN3FdfJYv2h9KuJRxNy7AwAA6UDgNDOe+ot1rdDV3LsCAAAZgMBpRmGPwujfW//KcxTTAgBYBgROM1p/cT1pSCND6RXP/6KvKgAAqBsCpxnx9GDs9QpoTQsAYCkQOM2EZz3ZdXOXPOc5NAEAwDIgcJoJj0fLM6DwAO6lvUubazcAAMBECJxmsuHyBnl8rcxr5toFAADIBAROM0hKTqLNVzbL89fKInACAFgSBE4zSNIkSR0nK+VVyhy7AAAAmYTAaQbODs5UKG8heX479rY5dgEAADIJgdNMinkWk8eQmP/mFwUAAPVD4DQTZcADBE4AAMuCwGkmxTyKaSexBgAAy4HAaeaiWtRxAgBYFgROMwfOWzHIcQIAWBIETjNB4yAAAMuEwGnmwBn+OJyePn9qrt0AAAATIXCaiZebF+VxyiPP78TeMdduAACAiRA4zcTOzo6Ke6JLCgCApUHgNCPUcwIAWB4ETjNysHeQx/uP7ptzNwAAwAQInGay6fImmSHFjuyoeVBzc+0GAACYCIHTDKKeRFH/v/rL81H1RlHdonXNsRsAAJAJCJxm8N7f70nxbDmfcvRV86/MsQsAAJBJCJy57JfTv9BvZ38jBzsHWtpxKbk5ueX2LgAAQBYgcOaiA7cPUL8N/eT5+MbjqU6ROrn58QAAkA0QOHPJjegb1PH3jpSQlEAdy3Wkz5t+nlsfDQAA2QiBMxfEPIuhV397lSKeRFD1QtXpl06/kL0dkh4AwBLh6p3DEpMT6Y01b9D5iPNUOF9h2vDmBnJ3ds/pjwUAgByCwJnDRm8dTVuubiE3Rzfa8MYGKupRNKc/EgAAchACZw6adWQW/XTkJ3n+S+dfqGbhmjn5cQAAkAsQOHPI1qtbacSWEfJ8covJ1Ll855z6KAAAyEUInDngQsQF6ra6GyVpkqh3td70UcOPcuJjAADADBA4c8CoraMoNj6WmhRvQj+/+rNMIQYAANYBgTObnQs/R1uvbZXB2xd3WEzODs7Z/REAAGBGCJzZbNqhafLYqXwnKlGgRHa/PQAAmBkCZzaKeBxBy08v1856AgAA1geBM5sHcI9PiqfahWtTw4CG2fnWAACgEgic2ejovaPy2KlcJzQIAgCwUgic2ehU2Cl5rFqoana+LQAAqAgCZzZ5lviMLkVekudVCyJwAgBYKwTObMKDuPOAB15uXjKYOwAAWCcEzmxyOuy0PFYpWAX1mwAAVgyBM5sDJ4ppAQCsGwJnDuQ4AQDAeiFwZgONRqNtUXv07lE6cPsAPU96nh1vDQAAKuNo7h2wFq6OrvI4N3iuLHmd88og780Dm1PzoObSRcXeDvcpAACWDoEzG/DsJ0f6H6H1F9fTzps7adeNXRT1NIo2X9ksC+PWtk0Dm1KLoBYSSMt6l0UjIgAAC4TAmU388/nTu7XflSVZkyx1njtv7JRlz6099ODpA1p7Ya0ssn1efwmgyhKYPzC7dgUAAHIQAmcO4CLZaoWqyTK6/mip7wwODaYd13dIjnR/yH4KfRRKK86skIXxTCpctBvoGShBmANrobyF5HlB94Lk5OCUE7sKAAAmQuDMBRz06hWtJ8v4JuNllKGDtw9KbnTHjR105O4Ruh59XZbU+OTx0Qum2ud5/eXfyvN8Lvly4ysBANgsBE4zNSRqFtRMli/pS4qLj6O9IXslgN6Luye50fuP7lNoXCiFPQ6jxOREinwSKcuZ8DNpvre7k7s2uGoDq5GA6+vui8ZKAACZgMCpApxLbFu6rSyGuL406kmUXjDVPn8UKv9Wnj9KeESPnz+ma9HXZEmLg50DFcxbUBtcjeVeledKi2EAAEDgtIj6Us4d8pLe4AocOJXgqhdYH+uv4wm3eVxdzt3ykp78rvn1g6m7QXHx/5/zdtzCGADAmiHHaUW472gpr1KypIUbK0U8idDPvRrkZJV1PDH3w2cPZbkYeTHN93VxcJFAml49rG8e32z+5gAAuQeB00YbK/EMLunN4sIjInHANFYsbLgu+lm0BNlbMbdkSYsd2ZGXqxcV8SiiF1BTBNx8/nIzAACgJgickCoudi3gVkCW8r7l00wpbinMATRF7tUgJxv2KEyKiaOeRclyOvzFGL+p4cCZXjExP3KrY4zMBAC5AYETsgU3IOJBHNIbyCEpOUnqWM+FnKN4p3gKfxKuXyerE3C5oRPX2159cFWWNE9ke0fp75peMTGP4MTBGHWxAJBZCJyQqxzsHcjP3Y/Im8jPz4/s7VMfv5e76RgrJtYNrvzI9bXcZedu3F1ZKDSdfbBzkIZMvHBuWvvctYD+o5v+v5V1zg7O2Z8wAGAxEDhB1d10eCntXTrdxk7c3zW9YmJ+TEhKeFFU/DRKFoo2fb/cHN2MB9VUAq5ucPZw8UCRMoCFQ+AEq2jsVNSjqCzpNXZ6mvhUGjxFP41+8fjsxaOxdYavxcTHyPvwezyNe5qhrjzGGkZ5unqmDKouqQdc3eDs5uSW6XQCgOyBwAk2g+s18zjlkSW9FsWp1c/Gxsf+F0yVAGssCBt5jRtQaehFS2VeMoO7/KQWVDn4OiY6UlHfolKXaxiAPV08pagcALIGgRMggzjoKK2MM4MDZ8yzmBRBNUWgjTf+Go8ixV1+uFial8zgomLJuTq6SV1tTi5O9k4Z39bBCUXYYDEQOAFyseWxa15XGerQVFzMHJcQl3qx8tNoeX7/4X16qnkqxcq6r3ELZcY5Zl7UiFtGZylY22d/8He0c6TYJ7Hk+NSRXJ1ctTcEaJVt2xA4ASwAX6g5t8hLMc9iRrdJTk6m8PBwo62VuQGVBNP/B1zO/XJDKWV5nvxc79+5sXAjLV3cMpqXJ8+fkNqZkps258ItyBHksx8CJ4AN4KJQHiSCF7XgOmNzBGxjS1r7EZ8YL3XTunh7XpScvFpxYzTDInG15ORjnsaQyzMXbU7ekurfETgBwCz4QsmLmmffUXLx3j7elKhJzPkgnpz199DFAZ/rxXlRO3s7+4zXiaeS4x9cazDVKVInx/cVgRMAIB0c4PlirfbuQFwXzsXd2ZXbzulcvi5u/MZVCLxkFk/NiMAJAAAZxvWZXBzLizu5qzonHxYWRgV8CmRrTr6yX+Vc2X/kOAEAwCxB3tnBmVzt1VtUn5rUBwoFAACAFBA4AQAATIDACQAAYMmBc/bs2RQUFESurq5Us2ZN2rt3b5rb79mzR7bj7UuUKEFz587NtX0FAADbo6rAuXLlSho5ciSNHz+eTpw4QY0bN6Y2bdpQSEiI0e1v3LhBbdu2le14+48//piGDx9Oa9asyfV9BwAA22Cn4Y4/KlG3bl2qUaMGzZkzR7uufPny1LFjR5o8eXKK7T/66CPasGEDXbhwQbtu8ODBdOrUKTp48KDRz4iPj5dFERsbSwEBARQdHU0eHh5Gm01HRESQr69vmpMuQ8YhTXMG0hVpaimSVXpd5XhQoEABiomJMRoPVNcdJSEhgYKDg2ns2LF661u1akUHDhww+jccHPl1Xa1bt6aFCxfS8+fPycnJKcXfcACeMGFCivV8EJ89e2b0AHMi8v2Fmg6wJUOaIl0tBc5V20rXuLi4DG2nmsAZGRlJSUlJVLCg/swR/O/79+8b/Rteb2z7xMREeT9/f/8UfzNu3DgaPXp0ihwn3/mkluPk/kZquzOyZEhTpKulwLlqW+nq6upqWYFTYTiSP9+RpDW6v7Htja1XuLi4yGKID15qB5DfK63XwXRI05yBdEWaWgo7FV5XM7ovqtljHx8fcnBwSJG75AGWDXOVikKFChnd3tHRkby9vXN0fwEAwDapJnA6OztLt5Lt27frred/N2jQwOjf1K9fP8X227Zto1q1ahmt3wQAALCawMm47nHBggW0aNEiaSk7atQo6YrCLWWV+smePXtqt+f1t27dkr/j7fnvuGHQmDFjzPgtAADAmqmqjrN79+4UFRVFEydOpNDQUKpUqRJt3ryZihcvLq/zOt0+nTxQAr/OAXbWrFlUuHBhmjFjBnXp0sWM3wIAAKyZqvpxmgO3qvX09Ey1344yka2fn5+qKrEtGdIU6WopcK7aVrrGphMPFOrZYwAAAAuAwAkAAGACBE4AAABLbRxkDkoVL5dtp1YWz8Mw8YgSaiqLt2RIU6SrpcC5alvpGvv/OJBe0x+bD5zK2IQ87B4AAEBcXJw0EkqNzbeq5Tufe/fuUb58+YwO06eMZXv79u00W1lBxiFNcwbSFWlqKWJVel3lnCYHTe7amFZO2OZznJw4RYsWTTdB+eCq6QBbA6Qp0tVS4Fy1nXT1TCOnqVBP4TIAAIAFQOAEAAAwAQJnOngKss8//9zoVGSQOUjTnIF0RZpaChcLv67afOMgAAAAUyDHCQAAYAIETgAAABMgcAIAAJgAgRMAAMAECJwAAAAmsPnAOXv2bAoKCpLBhmvWrEl79+5NM8H27Nkj2/H2JUqUoLlz55qS3jbDlHTdvXu3DHdouFy8eDFX91nN/v33X2rfvr0MBcZps379+nT/Budq9qcrztX0TZ48mWrXri3DmPJE1R07dqRLly5Z1flq04Fz5cqVNHLkSBo/fjydOHGCGjduTG3atKGQkBCj29+4cYPatm0r2/H2H3/8MQ0fPpzWrFmT6/tuTemq4B9XaGiodildunSu7bPaPX78mKpWrUozZ87M0PY4V3MmXRU4V9MOgEOHDqVDhw7R9u3bKTExkVq1aiVpbTXnq8aG1alTRzN48GC9deXKldOMHTvW6PYffvihvK5r0KBBmnr16uXoflp7uu7atYvn8NFER0fn0h5aNk6rdevWpbkNztWcSVecq6YLDw+XtN2zZ4/VnK82m+NMSEig4OBguRPSxf8+cOCA0b85ePBgiu1bt25Nx44do+fPn+fo/lpzuiqqV69O/v7+1KJFC9q1a1cO76l1w7mas3CuZlxMTIw8enl5Wc35arOBMzIykpKSkqhgwYJ66/nf9+/fN/o3vN7Y9lwUwe8HmUtXDpbz5s2TYpm1a9dS2bJlJXhy/RNkDs7VnIFz1TSckR89ejQ1atSIKlWqZDXnq81PK2Y4BycfaGPzcqa1vbH1ts6UdOVAyYuifv36Mk/fDz/8QE2aNMnxfbVWOFezH85V0wwbNoxOnz5N+/bts6rz1WZznD4+PuTg4JAiFxQeHp7izkdRqFAho9s7OjqSt7d3ju6vNaerMfXq1aMrV67kwB7aBpyruQfnqnHvvfcebdiwQapd0pvz2NLOV5sNnM7OztL0mVt96eJ/N2jQwOjfcE7IcPtt27ZRrVq1yMnJKUf315rT1RhuWcfFYpA5OFdzD85VSpFT5JwmV7vs3LlTuqVZ3fmqsWG///67xsnJSbNw4ULN+fPnNSNHjtS4u7trbt68Ka9zK9B33nlHu/3169c1efLk0YwaNUq257/jv1+9erUZv4Xlp+vUqVOlNePly5c1Z8+eldf51FyzZo0Zv4W6xMXFaU6cOCELp82UKVPk+a1bt+R1nKu5k644V9P37rvvajw9PTW7d+/WhIaGapcnT55ot7H089WmAyebNWuWpnjx4hpnZ2dNjRo19JpM9+rVS/PSSy/pbc8nQ/Xq1WX7wMBAzZw5c8yw19aVrt9++62mZMmSGldXV02BAgU0jRo10mzatMlMe65OSjcIw4XTkuFczZ10xbmaPmPpycvixYu121j6+Yr5OAEAAExgs3WcAAAAmYHACQAAYAIETgAAABMgcAIAAJgAgRMAAMAECJwAAAAmQOAEAAAwAQInAFgMnjGnffv2VLhwYRn8e/369Wb9PJ7y6qOPPqLKlSuTu7u7bNezZ0+6d+9elj53xIgRMnSli4sLVatWLd3tb968KftnbFm1apV2u+PHj1PLli0pf/78MgbswIED6dGjRyZ/9h9//CGv5cmTh4oXL07ff/99im3i4+NlMnt+nd+rZMmStGjRIu3rTZs2Nbq/7dq1o5yyZMkSo5/57Nkzk94HgRMALMbjx4+patWqNHPmTFV83pMnTyQYffrpp/LI47NevnyZXnvttTTfly/WHOxSwwPw9O3bl7p3756h/QwICKDQ0FC9ZcKECRLM27RpI9twMH/55ZepVKlSdPjwYdqyZQudO3eOevfubdJn//333/TWW2/R4MGD6ezZszR79myaMmVKijTq1q0b7dixgxYuXEiXLl2i3377jcqVK6d9ndNKd3/5vXiCiK5du1JO8vDwSJFWrq6upr2JuYcuAlATHgZsxIgRqn0/NUhOTtYMGDBAhkfkSwiP7WqO78mfzWMc64qPj9d88MEHmsKFC8vYp3Xq1JFh9VITGRmp8fX11dy4cSNTn2fMkSNHZFtlvNvU3mv8+PHpvtfnn3+uqVq1qiYzqlWrpunbt6/23z///LPGz89Pk5SUpF2njNF75cqVDH/2m2++qXn99df11vEYvkWLFpVzg/39998yXm1UVFSG95ffI1++fJpHjx5p1/H78TCHQUFBMiRnlSpVNKtWrdJkFg/7x/uVVchxgipx8RjfHac2WzzfsfMdfmZxMdHIkSNTrOe74C+//JJyC9/tK8VFPAsET73GRWlcpJWcnExqxDkVLvLauHGj3K2nNUFxbuvTpw/t37+ffv/9d5kHknMvr7zySqpT1E2ePFnOtcDAwGw7nj/++KMcTy4OTQvn0GJjYyknBAcH08mTJ6lfv356Rac8e5G9/X+XfTc3N3nMyHyZuu/japBD4/e5c+cO3bp1S/7N04nxzCbfffcdFSlShMqUKUNjxoyhp0+fpvq+nDN94403JJes+OSTT2jx4sU0Z84cyR2PGjWK3n77bdqzZw9lFhdNc/ExT3X26quvyuw2pkLgBFXiHzxPSaT8EHVxUOH6lRo1amTqvRMSElJ9zcvLi/Lly0e5iS/sHIC46I6LwZo1ayb1TPyjTkxMzPT7pvU9s+LatWsy5RtPE8fzKPKciWrA+8XFgVyn17hxY6lT44t1o0aN5OJriC/ifLHu379/tnw+3+jwzcSpU6eoR48eUiSYFr5wr1ixgnICf6/y5cvrTeXXvHlzmfOS6yP53IiOjqaPP/5YXuPzL6Nat24tN5hcDMvfmYump02bpvc+169fl2DMxa/r1q2T11evXk1Dhw41+p5HjhyRbXWPBReTcxEw/975M0uUKCE3Jhw4f/7550ylCxcV800fB3Y+V/gGoGHDhqbP/ZvlPCtADnj+/LmmYMGCmi+++EJv/ePHj6U456effspwUQ4XIw4dOlSmLPL29tYUK1YsxcwNSlGdYZEjF2t98803MnsLz9oQEBCg+eqrr7TFUQ0bNpSiHy8vL027du00V69eTfHZaRVh8iwRHTp0SLF+x44dsl/z58/Xrkvv8wy/Z5MmTdL9DkuXLpX3evbsmd7nd+7cWW/aJ9391U03ngHH2Pfk9Vz0pouL/bj4j4WHh8vx/frrr7WvHzp0SKaS2rp1a6rpdeHCBU3Tpk01Li4u8vmffvqpxs7OTnPs2DHNH3/8Iet4CjvdxdHRUdOtWzf5ez7Oqc3eoSyVK1eW75I/f34p2uQiTi4+5Nf4HCtRooRm8+bNKfZt586dkr48wwena6VKlWR7Tl8+Hrr7xO/F39Xe3l67LruKann6Lj5HfvjhhxSvrVixQtLdwcFB9nXMmDHyb/4NZfSzk5OTNR9++KF8N34fLrLn3yl/p8OHD8s2LVu2lNcfPnyo/TueJpCPle70YoqBAwdKehkr8jY8npxuXASvSO948u8kNfzb4O/43nvvaUyBwAmqxXVVPL2QUm/ClixZIhfNBw8eyL8//vhjTbly5TRbtmzRXLt2Teow+HWeokjBF/W8efPK+128eFFz8uRJTf369aWeTpkrMDEx0WgA4AsEXxj4czlI7d27VxvMeK5AvhjwPKJcV9S+fXu56OrWIWU2cDL+Qbdp00b77/Q+z/B7cpBJ7zsoF1kOOoqIiAi5qHIgMMQXwokTJ0p9FqcbB8DMBE7GU8fxRfDo0aMyL2apUqXSTCv+TnzTxBd7/h58UfTw8JCL99OnT2UeWH7O23Gdne7C+8oSEhIkXXjhGwOewk75Ny+1a9eWi/OXX34p6cyPHNz4OPDn8XR5PN8kB0K+iVPw+/L+c5DkOWU5WPPcnhyoT58+LTcIfN4p+8PvxcGK0/ncuXNG6xgzGziXLVsm6aocG2Pu378vac43BPz9dI9/Rj87MTFRc+fOHalX5hsJ/k5hYWHyWs+ePeVGTRfPs8nbcLrq4nTk4zht2jS99Xwjxdvzb9nweIaEhGi30z1+xpbbt2+nmV79+/fXvPLKKxpTIHCCavFJzz8c3Qs456K4cQLjHz3f1R44cEDv7/r166fdRrmoc0MJXakFNN31sbGxEoR1c31p4QsV7++ZM2fS/ZyMBM7u3btrypcvn+HPM/Y9M/IdOBDoBmi+gHGuSveGRRcHRCWnqchM4GRDhgzRlClTRvPWW29JjoMDYGpatWql6d27t/bf/N05B16hQgX596VLl2Tdv//+q8kITnfdxjPK9+BgqhscOJBykFUaB3EQ5ucHDx7UBs2OHTtKEFy+fLkmODhYXlcmbjeGX1eCTVrbZSZw8nfo0qVLhrblCaO5EVV0dHSWPvudd96Rm1EF59Ld3NwkOCvWr18vQdowx6nc7HJDLWPnLt8I5BQ+x2vVqqXp06ePSX+njsoJgFTqI7iOhus4uN6P67D27t1L27Ztk9fPnz8v/a+4MY0urr+pXr263jpuqGCqCxcuSEOIFi1aGH2d94e7IRw6dIgiIyO1jXlCQkKypcEMX1+5kYkpn2f4PdP7DmzAgAFUu3Ztunv3rjTk4PpApdFSTvvhhx9k37lf4LFjx1LtFnD79m057twwjBu9KPj4FytWTNKAG6BwNwnuR8kNdPgc4HTiunLuZ9m2bdsUdZzGPq9KlSp623CdN/d5ZDdu3JCGJSw8PFzqoF9//XWpo+NGN1xfxg1wuF6VvxfXX7dq1Uq2KVCggN7nKJ/NXVoMXb16VRqxcJ0k74PynStUqCDvz8eKj+myZcuoTp06en/HfU83b96caoMk/k3lzZuXtm/fTh988AF98803eg2Z0vvsyMhIqa/kBnac/ny+cL2yboMdruPlRnbcWIu7xfDf8GdxNxelQZJufWzHjh21aazgdOc6am4QxOc6pyk3pjpw4IDsf69evchUvC/16tWj0qVLy3vNmDFDvt+sWbNMeh8ETlB9I6Fhw4bJic0/UL5oKUFACRybNm2SC74u7nCtS7elXkYZ/sANcWtM7j83f/586fjO+8MXy+xqlMNBLygoyKTPM/ye6X0HxgGG+yryRZgbYZw5c4b++uuvLO07B5EXGSv9wQIMcSMS7l/I34UbgukGLV3cgppbHXODkfr16+u1HmWfffYZDR8+XIIZB873339fWnnyhZ6/k2HQZD4+PtJAxhB/joKDOQcQpfHL6NGjta/xPvNncEMTBTdgUfBFmQPGTz/9JAMBcN9J3eP58OFDefT19U2xD9xIRjcQKTeCHLi5BTCnJfeNNAy6fJPJvwUO1sZwgP/8888lMPKNKTeyeeedd0z6bLZ06VIJanyM+Xjs3r1bL4Argfm9996TmzkOityv86uvviJd3LCIGxEpN8OGOPj6+flJ62c+VzjAc6NApVGTqTjNedAHPqaenp7y3fhGQ3ffMyTH8sAA2YCLerjebs6cOVKvNmHCBJOLcowVl3LjhWHDhqW5LRcbcnGTsWJOLlYyLBbkukPDvn5ZbRy0aNGiDH+esc9K6zvomj17tqZ06dLSuIiLRNOSkaJabrzBda2KmJgY2Q/dolquG+OiQE6DyZMnS39KrnszZsOGDVLMp1uUy/Xa/P35UWlQxg2flOJTbqST2vux77//PkVRpLE0NFbsbHicuZiSiz2N4eLeIkWKaH788Ue99QsWLJBzGiwPcpyganznyiOY8B1mTEyM3ignWSnK4TtnzgFwFxDelruh6PZvU4rSeDi1Dz/8UHIuXAwXEREh/cm4CIrvoufNmyddM7iocOzYsZn6jlyUynfASUlJFBYWJv0k+Q6bu6Nw7olxMV9mPi+t76Dbx4+LODktOTfLOc+s4q4P3Oyfc8m871zEzKPC6OJcGB9TzpnxMeCuOLxP3KXDEA8BxznBcePGSS6G+97xd2KcW2bcLYa7eHCxLneB4OI/7hebGs6J8vtxrtOwGNUUnMs9evSodjg+Pq+4qwbn+ji3xP/mNOfuIbq42iG1nCGonLkjN0B6uPEPn6rGckJcuT99+nRN2bJlpSUh51pat26t2bNnT5q5CG5IUq9ePckFpdcdhbtucK6D35+7skyaNEle2759uzTe4Vwvd4Ph1n+ZyXEqzea5JSbv/8svvyw5Td3WuRn5vNQ+K63vYNjAw1jXlMzkODmHyV1AuLUk5wK5Ra9u4yAezYe/L+eaFTzSDrfw5dyvMdzwhnNo3FiHR6757rvvpLuILt4H/ixuaKQ7Ak1q+ByYO3duqt8jIzlOzjlyIyXd1qN8DvKx5GPFjZ+U7lMKzjlz2igNjMCy2PH/zB28AcD8uJEV54o4B2gJOMfJgw1s3bpVu+7XX3+VHOmkSZNo0KBB6b4HN6LhnDZ3vjcsccgoHpeWSzuUHHBGcJ39n3/+mWrdHqgbimoBbNyDBw/kAs6tT3Nr8PTswEPqKcW0Cm5Zy8WjGR0NiBsN8agx3EqVG15lBgfNN99806S/4WJnbjQElgk5TgAbx/W9XM/H9ZCc+7IU3HqUx0Ll+lkF1z136dJF6ocBcgoCJwBYPO7jyrlHbvBjKUXNYLkQOAEAAEyA2VEAAABMgMAJAABgAgROAAAAEyBwAgAAmACBEwAAwAQInAAAACZA4AQAADABAicAAIAJEDgBAABMgMAJAABgAgROAAAAyrj/AYwYmsQdH0smAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vy_numerical = uw.function.evaluate(v_soln.sym[0, 1], sample_pts).squeeze()\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 6))\n", + "ax.plot(vy_numerical, sample_y, \"g-\", lw=1.5)\n", + "ax.set_xlabel(r\"Vertical Darcy flux $q_y$ (m/s)\")\n", + "ax.set_ylabel(\"Height $y$ (m)\")\n", + "ax.set_title(\"Darcy velocity (should be nearly constant)\")\n", + "ax.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Try It Yourself\n", + "\n", + "Experiment with different parameters to build intuition:\n", + "\n", + "```python\n", + "# Larger α → sharper transition near saturation\n", + "ALPHA_G = 5.0\n", + "\n", + "# Wetter bottom boundary\n", + "PSI_BOTTOM = -1.0\n", + "\n", + "# Higher resolution\n", + "RES = 64\n", + "```\n", + "\n", + "- What happens as $\\alpha \\to 0$? (Hint: the profile should approach linear.)\n", + "- What if the top boundary is fully saturated ($\\psi_\\text{top} = 0$)?\n", + "- The Van Genuchten model is also available — try replacing\n", + " `gardner_K` with `van_genuchten_K` (no analytical solution,\n", + " but the solver still works).\n", + "- Can you compute mass conservation by integrating $\\theta(\\psi)$\n", + " over the column?\n", + "\n", + "## References\n", + "\n", + "Celia, M. A., Bouloutas, E. T. & Zarba, R. L. (1990). A general\n", + "mass-conservative numerical solution for the unsaturated flow equation.\n", + "*Water Resources Research*, 26(7), 1483–1496.\n", + "doi:[10.1029/WR026i007p01483](https://doi.org/10.1029/WR026i007p01483)\n", + "\n", + "Gardner, W. R. (1958). Some steady-state solutions of the unsaturated\n", + "moisture flow equation with application to evaporation from a water table.\n", + "*Soil Science*, 85(4), 228–232.\n", + "\n", + "Mualem, Y. (1976). A new model for predicting the hydraulic conductivity\n", + "of unsaturated porous media. *Water Resources Research*, 12(3), 513–522.\n", + "doi:[10.1029/WR012i003p00513](https://doi.org/10.1029/WR012i003p00513)\n", + "\n", + "Richards, L. A. (1931). Capillary conduction of liquids through porous\n", + "mediums. *Physics*, 1(5), 318–333.\n", + "doi:[10.1063/1.1745010](https://doi.org/10.1063/1.1745010)\n", + "\n", + "Van Genuchten, M. Th. (1980). A closed-form equation for predicting the\n", + "hydraulic conductivity of unsaturated soils. *Soil Science Society of\n", + "America Journal*, 44(5), 892–898.\n", + "doi:[10.2136/sssaj1980.03615995004400050002x](https://doi.org/10.2136/sssaj1980.03615995004400050002x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/beginner/tutorials/17-Richards-Transient-Wetting-Front.ipynb b/docs/beginner/tutorials/17-Richards-Transient-Wetting-Front.ipynb new file mode 100644 index 00000000..97b69137 --- /dev/null +++ b/docs/beginner/tutorials/17-Richards-Transient-Wetting-Front.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-0", + "metadata": {}, + "source": [ + "# Notebook 17: Richards Equation — Transient Wetting Front\n", + "\n", + "This notebook solves a **transient** Richards equation problem\n", + "and validates the numerical solution against an exact analytical\n", + "benchmark. A wetting front propagates downward through an\n", + "initially dry soil column after a wet boundary condition is\n", + "applied at the top.\n", + "\n", + "## Key Concepts\n", + "\n", + "- Time-dependent Richards equation with the mixed form\n", + "- Gardner exponential model — linearisation trick\n", + "- Ogata–Banks advection–diffusion solution\n", + "- Wetting-front dynamics and mass conservation" + ] + }, + { + "cell_type": "markdown", + "id": "cell-1", + "metadata": {}, + "source": [ + "## Why a Transient Benchmark?\n", + "\n", + "[Notebook 16](16-Richards-Equation-Groundwater.ipynb) validated\n", + "the Richards solver at steady state, where the time derivative\n", + "vanishes and all formulations agree. A transient test is needed\n", + "to verify that the **mixed form** storage term\n", + "$\\partial\\theta/\\partial t$ is discretised correctly.\n", + "\n", + "### The Gardner Linearisation\n", + "\n", + "The substitution $u = \\exp(\\alpha\\psi)$ transforms the nonlinear\n", + "Richards equation with Gardner conductivity into a **linear**\n", + "advection–diffusion equation:\n", + "\n", + "$$\\frac{\\partial u}{\\partial t}\n", + " = D\\,\\frac{\\partial^2 u}{\\partial z^2}\n", + " + V\\,\\frac{\\partial u}{\\partial z}$$\n", + "\n", + "where $z = L - y$ is depth from the top,\n", + "$D = K_s / (\\alpha\\,\\Delta\\theta)$,\n", + "$V = K_s / \\Delta\\theta$, and\n", + "$\\Delta\\theta = \\theta_s - \\theta_r$.\n", + "\n", + "### Ogata–Banks Solution\n", + "\n", + "For a step change at the top ($z = 0$) from $u_{\\rm dry}$ to\n", + "$u_{\\rm wet}$ with a semi-infinite column, the\n", + "**Ogata–Banks (1961)** solution is:\n", + "\n", + "$$u(z,t) = u_{\\rm dry}\n", + " + (u_{\\rm wet} - u_{\\rm dry})\\,H(z,t)$$\n", + "\n", + "where\n", + "\n", + "$$H(z,t) = \\tfrac{1}{2}\\,\\operatorname{erfc}\\!\\left(\n", + " \\frac{z - Vt}{2\\sqrt{Dt}}\\right)\n", + " + \\tfrac{1}{2}\\,\\exp\\!\\left(\\frac{Vz}{D}\\right)\\,\n", + " \\operatorname{erfc}\\!\\left(\\frac{z + Vt}{2\\sqrt{Dt}}\\right)$$\n", + "\n", + "Converting back: $\\psi(y,t) = \\ln(u)/\\alpha$.\n", + "\n", + "The approximation is valid while the wetting front has not\n", + "yet reached the bottom boundary." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cell-3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T09:22:11.232839Z", + "iopub.status.busy": "2026-02-24T09:22:11.232279Z", + "iopub.status.idle": "2026-02-24T09:22:15.257488Z", + "shell.execute_reply": "2026-02-24T09:22:15.256902Z", + "shell.execute_reply.started": "2026-02-24T09:22:11.232819Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sympy\n", + "import underworld3 as uw\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from underworld3.utilities.retention_curves import (\n", + " gardner_K,\n", + " gardner_theta,\n", + " gardner_transient_psi,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-4", + "metadata": {}, + "source": [ + "### Configurable parameters\n", + "\n", + "Default values are defined as named constants below. From the\n", + "command line, override them with PETSc-style flags:\n", + "\n", + "```bash\n", + "python script.py -uw_res 64 -uw_alpha \"4.0 1/m\"\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T09:22:15.258545Z", + "iopub.status.busy": "2026-02-24T09:22:15.258091Z", + "iopub.status.idle": "2026-02-24T09:22:15.268344Z", + "shell.execute_reply": "2026-02-24T09:22:15.267546Z", + "shell.execute_reply.started": "2026-02-24T09:22:15.258524Z" + } + }, + "outputs": [], + "source": [ + "# --- Default values (edit these in a notebook) ---\n", + "COLUMN_HEIGHT = 3.0 # m — tall column so the front stays away from the bottom\n", + "COLUMN_WIDTH = 0.1 # m — narrow (effectively 1-D)\n", + "RES = 64 # — vertical elements\n", + "KS = 1.0 # m/s — saturated hydraulic conductivity (dimensionless-friendly)\n", + "ALPHA_G = 4.0 # 1/m — Gardner sorptive number\n", + "THETA_R = 0.05 # — residual water content\n", + "THETA_S = 0.40 # — saturated water content\n", + "PSI_DRY = -2.0 # m — initial (dry) pressure head\n", + "PSI_WET = -0.1 # m — wet boundary at top\n", + "DT = 0.005 # s — timestep (accuracy is time-dominated)\n", + "SNAPSHOTS = [0.05, 0.15, 0.30] # s — times to compare" + ] + }, + { + "cell_type": "markdown", + "id": "cell-6", + "metadata": {}, + "source": [ + "## Analytical Wetting Front\n", + "\n", + "Before running the solver, let's visualise what the\n", + "analytical solution predicts at the snapshot times." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T09:22:15.269856Z", + "iopub.status.busy": "2026-02-24T09:22:15.269698Z", + "iopub.status.idle": "2026-02-24T09:22:15.801131Z", + "shell.execute_reply": "2026-02-24T09:22:15.799427Z", + "shell.execute_reply.started": "2026-02-24T09:22:15.269839Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y_exact = np.linspace(0, COLUMN_HEIGHT, 500)\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 6), sharey=True)\n", + "\n", + "for t_snap in SNAPSHOTS:\n", + " psi_exact = gardner_transient_psi(\n", + " y_exact, t_snap,\n", + " psi_dry=PSI_DRY, psi_wet=PSI_WET,\n", + " L=COLUMN_HEIGHT, Ks=KS, alpha=ALPHA_G,\n", + " theta_r=THETA_R, theta_s=THETA_S,\n", + " )\n", + " theta_exact = THETA_R + (THETA_S - THETA_R) * np.exp(ALPHA_G * np.clip(psi_exact, None, 0))\n", + "\n", + " ax1.plot(psi_exact, y_exact, lw=2, label=f\"$t = {t_snap}$ s\")\n", + " ax2.plot(theta_exact, y_exact, lw=2, label=f\"$t = {t_snap}$ s\")\n", + "\n", + "# Initial condition\n", + "ax1.axvline(PSI_DRY, color=\"grey\", ls=\":\", lw=0.8, label=\"initial\")\n", + "ax2.axvline(\n", + " THETA_R + (THETA_S - THETA_R) * np.exp(ALPHA_G * PSI_DRY),\n", + " color=\"grey\", ls=\":\", lw=0.8, label=\"initial\",\n", + ")\n", + "\n", + "ax1.set_xlabel(r\"Pressure head $\\psi$ (m)\")\n", + "ax1.set_ylabel(\"Height $y$ (m)\")\n", + "ax1.set_title(r\"$\\psi(y, t)$\")\n", + "ax1.legend()\n", + "ax1.grid(True, alpha=0.3)\n", + "\n", + "ax2.set_xlabel(r\"Water content $\\theta$\")\n", + "ax2.set_title(r\"$\\theta(y, t)$\")\n", + "ax2.legend()\n", + "ax2.grid(True, alpha=0.3)\n", + "\n", + "fig.suptitle(\"Analytical wetting front (Gardner / Ogata–Banks)\", fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-8", + "metadata": {}, + "source": [ + "## Set Up the Richards Solver\n", + "\n", + "We create a vertical column mesh and configure the Richards\n", + "solver with Gardner constitutive curves. The `water_content`\n", + "property activates the mixed (mass-conservative) form.\n", + "\n", + "**Solver note:** The Gardner exponential creates steep\n", + "nonlinearity in dry regions where $K$ and $\\theta$ are\n", + "very small. The standard Newton method with backtracking\n", + "linesearch can overshoot into unphysical states.\n", + "A **trust-region** SNES (`newtontr`) constrains the\n", + "Newton step size and converges reliably." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cell-9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T09:22:15.802505Z", + "iopub.status.busy": "2026-02-24T09:22:15.802089Z", + "iopub.status.idle": "2026-02-24T09:22:16.009513Z", + "shell.execute_reply": "2026-02-24T09:22:16.007830Z", + "shell.execute_reply.started": "2026-02-24T09:22:15.802479Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Structured box element resolution 4 64\n" + ] + } + ], + "source": [ + "mesh = uw.meshing.StructuredQuadBox(\n", + " elementRes=(4, RES),\n", + " minCoords=(0.0, 0.0),\n", + " maxCoords=(COLUMN_WIDTH, COLUMN_HEIGHT),\n", + " qdegree=3,\n", + ")\n", + "\n", + "psi_var = uw.discretisation.MeshVariable(r\"\\psi\", mesh, 1, degree=2)\n", + "v_soln = uw.discretisation.MeshVariable(\"v\", mesh, mesh.dim, degree=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-10", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T09:22:16.011114Z", + "iopub.status.busy": "2026-02-24T09:22:16.010927Z", + "iopub.status.idle": "2026-02-24T09:22:16.087474Z", + "shell.execute_reply": "2026-02-24T09:22:16.082901Z", + "shell.execute_reply.started": "2026-02-24T09:22:16.011096Z" + } + }, + "outputs": [], + "source": [ + "richards = uw.systems.Richards(mesh, psi_var, v_soln, order=1, theta=0.5, degree=3)\n", + "richards.petsc_options.delValue(\"ksp_monitor\")\n", + "richards.petsc_options[\"snes_rtol\"] = 1.0e-6\n", + "richards.petsc_options[\"snes_max_it\"] = 50\n", + "\n", + "# Trust-region Newton method — robust for the steep Gardner nonlinearity\n", + "richards.petsc_options[\"snes_type\"] = \"newtontr\"\n", + "\n", + "psi_sym = psi_var.sym[0]\n", + "\n", + "# Constitutive model: Gardner K(ψ) with gravity\n", + "richards.constitutive_model = uw.constitutive_models.DarcyFlowModel\n", + "richards.constitutive_model.Parameters.permeability = gardner_K(\n", + " psi_sym, Ks=KS, alpha=ALPHA_G\n", + ")\n", + "richards.constitutive_model.Parameters.s = sympy.Matrix([0, -1]).T\n", + "\n", + "# Mixed form: θ(ψ) for mass-conservative storage\n", + "richards.water_content = gardner_theta(\n", + " psi_sym,\n", + " theta_r=THETA_R,\n", + " theta_s=THETA_S,\n", + " alpha=ALPHA_G,\n", + ")\n", + "\n", + "richards.f = 0.0\n", + "\n", + "# Boundary conditions\n", + "richards.add_dirichlet_bc([PSI_WET], \"Top\")\n", + "richards.add_dirichlet_bc([PSI_DRY], \"Bottom\")\n", + "\n", + "# Velocity projector\n", + "richards._v_projector.petsc_options[\"snes_rtol\"] = 1.0e-6\n", + "richards._v_projector.smoothing = 1.0e-3" + ] + }, + { + "cell_type": "markdown", + "id": "cell-11", + "metadata": {}, + "source": [ + "## Initial Condition and Timestepping\n", + "\n", + "We initialise with a smooth profile that interpolates between\n", + "the wet top and the dry interior (helps the first SNES iteration\n", + "converge). Then we step forward in time, saving snapshots at\n", + "the analytical comparison times." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cell-12", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-24T09:22:16.095786Z", + "iopub.status.busy": "2026-02-24T09:22:16.092667Z", + "iopub.status.idle": "2026-02-24T09:22:20.237314Z", + "shell.execute_reply": "2026-02-24T09:22:20.234410Z", + "shell.execute_reply.started": "2026-02-24T09:22:16.095751Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[0]PETSC ERROR: --------------------- Error Message --------------------------------------------------------------\n", + "[0]PETSC ERROR: Object is in wrong state\n", + "[0]PETSC ERROR: Must call SNESSetFunction() or SNESSetDM() before SNESComputeFunction(), likely called from SNESSolve().\n", + "[0]PETSC ERROR: WARNING! There are unused option(s) set! Could be the program crashed before usage or a spelling mistake, etc!\n", + "[0]PETSC ERROR: Option left: name:-dm_plex_hash_location (no value) source: code\n", + "[0]PETSC ERROR: Option left: name:-options_left value: 0 source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_5_mg_levels_ksp_converged_maxits (no value) source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_5_mg_levels_ksp_max_it value: 3 source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_5_pc_mg_type value: additive source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_ksp_rtol value: 0.001 source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_ksp_type value: gmres source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_mg_levels_ksp_converged_maxits (no value) source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_mg_levels_ksp_max_it value: 3 source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_pc_gamg_agg_nsmooths value: 2 source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_pc_gamg_repartition value: true source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_pc_gamg_type value: agg source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_pc_mg_type value: additive source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_pc_type value: gamg source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_snes_rtol value: 1e-06 source: code\n", + "[0]PETSC ERROR: Option left: name:-Solver_6_snes_type value: newtonls source: code\n", + "[0]PETSC ERROR: See https://petsc.org/release/faq/ for trouble shooting.\n", + "[0]PETSC ERROR: PETSc Release Version 3.24.3, unknown\n", + "[0]PETSC ERROR: /Users/lmoresi/+Underworld/underworld3-pixi/.pixi/envs/amr-dev/lib/python3.12/site-packages/ipykernel_launcher.py with 1 MPI process(es) and PETSC_ARCH petsc-4-uw on Lyrebird.local by lmoresi Tue Feb 24 20:22:11 2026\n", + "[0]PETSC ERROR: Configure options: --with-petsc-arch=petsc-4-uw --download-bison --download-eigen --download-metis --download-mmg --download-mumps --download-parmetis --download-parmmg --download-pragmatic --download-ptscotch=/Users/lmoresi/+Underworld/underworld3-pixi/petsc-custom/patches/scotch-7.0.10-c23-fix.tar.gz --download-scalapack --download-slepc --with-debugging=0 --with-hdf5=1 --with-pragmatic=1 --with-x=0 --with-mpi-dir=/Users/lmoresi/+Underworld/underworld3-pixi/.pixi/envs/amr --with-hdf5-dir=/Users/lmoresi/+Underworld/underworld3-pixi/.pixi/envs/amr --download-hdf5=0 --download-mpich=0 --download-mpi4py=0 --with-petsc4py=0\n", + "[0]PETSC ERROR: #1 SNESComputeFunction() at /Users/lmoresi/+Underworld/underworld3-pixi/petsc-custom/petsc/src/snes/interface/snes.c:2486\n", + "[0]PETSC ERROR: #2 SNESSolve_NEWTONTR() at /Users/lmoresi/+Underworld/underworld3-pixi/petsc-custom/petsc/src/snes/impls/tr/tr.c:537\n", + "[0]PETSC ERROR: #3 SNESSolve() at /Users/lmoresi/+Underworld/underworld3-pixi/petsc-custom/petsc/src/snes/interface/snes.c:4905\n" + ] + }, + { + "ename": "Error", + "evalue": "error code 73", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 26\u001b[39m\n\u001b[32m 23\u001b[39m n_steps = \u001b[38;5;28mint\u001b[39m(np.ceil(t_end / DT))\n\u001b[32m 25\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m step \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_steps):\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m \u001b[43mrichards\u001b[49m\u001b[43m.\u001b[49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimestep\u001b[49m\u001b[43m=\u001b[49m\u001b[43mDT\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 27\u001b[39m t_now += DT\n\u001b[32m 29\u001b[39m \u001b[38;5;66;03m# Check if we've passed a snapshot time\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/+Underworld/underworld3-pixi/.pixi/envs/amr-dev/lib/python3.12/site-packages/underworld3/timing.py:310\u001b[39m, in \u001b[36mroutine_timer_decorator..timed\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 308\u001b[39m event.begin()\n\u001b[32m 309\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m310\u001b[39m result = \u001b[43mroutine\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 311\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n\u001b[32m 312\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/+Underworld/underworld3-pixi/.pixi/envs/amr-dev/lib/python3.12/site-packages/underworld3/systems/solvers.py:825\u001b[39m, in \u001b[36mSNES_TransientDarcy.solve\u001b[39m\u001b[34m(self, zero_init_guess, timestep, _force_setup, verbose)\u001b[39m\n\u001b[32m 822\u001b[39m \u001b[38;5;28mself\u001b[39m.DFDt.update_pre_solve(timestep, verbose=verbose)\n\u001b[32m 824\u001b[39m \u001b[38;5;66;03m# Solve PDE (bypass SNES_Darcy.solve to avoid double setup/projection)\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m825\u001b[39m \u001b[43mSNES_Scalar\u001b[49m\u001b[43m.\u001b[49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mzero_init_guess\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_force_setup\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 827\u001b[39m \u001b[38;5;66;03m# Invalidate cached data views\u001b[39;00m\n\u001b[32m 828\u001b[39m target_var = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m.u, \u001b[33m\"\u001b[39m\u001b[33m_base_var\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28mself\u001b[39m.u)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/+Underworld/underworld3-pixi/.pixi/envs/amr-dev/lib/python3.12/site-packages/underworld3/timing.py:310\u001b[39m, in \u001b[36mroutine_timer_decorator..timed\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 308\u001b[39m event.begin()\n\u001b[32m 309\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m310\u001b[39m result = \u001b[43mroutine\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 311\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n\u001b[32m 312\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32msrc/underworld3/cython/petsc_generic_snes_solvers.pyx:1660\u001b[39m, in \u001b[36munderworld3.cython.generic_solvers.SNES_Scalar.solve\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32mpetsc4py/PETSc/SNES.pyx:1738\u001b[39m, in \u001b[36mpetsc4py.PETSc.SNES.solve\u001b[39m\u001b[34m()\u001b[39m\n", + "\u001b[31mError\u001b[39m: error code 73" + ] + } + ], + "source": [ + "# Initial condition: dry everywhere except a smooth transition\n", + "# near the top boundary to ease the first nonlinear solve.\n", + "y = mesh.X[1]\n", + "transition_width = 0.1 * COLUMN_HEIGHT\n", + "blend = sympy.Min(sympy.Max((COLUMN_HEIGHT - y) / transition_width, 0), 1)\n", + "psi_init = PSI_WET + (PSI_DRY - PSI_WET) * blend\n", + "\n", + "psi_var.array = uw.function.evaluate(psi_init, psi_var.coords)\n", + "\n", + "# IMPORTANT: the solver's time-derivative history was initialised at\n", + "# construction time (when psi_var was still zero). Re-sync it now\n", + "# so that ψ^n = the initial condition we just set.\n", + "richards.DuDt.initiate_history_fn()\n", + "\n", + "# Timestepping — collect snapshots\n", + "t_now = 0.0\n", + "snapshot_times = sorted(SNAPSHOTS)\n", + "snapshots = {} # {t: psi_data}\n", + "next_snap_idx = 0\n", + "\n", + "# Total time to run\n", + "t_end = snapshot_times[-1]\n", + "n_steps = int(np.ceil(t_end / DT))\n", + "\n", + "for step in range(n_steps):\n", + " richards.solve(timestep=DT)\n", + " t_now += DT\n", + "\n", + " # Check if we've passed a snapshot time\n", + " if next_snap_idx < len(snapshot_times) and t_now >= snapshot_times[next_snap_idx] - 1e-12:\n", + " t_snap = snapshot_times[next_snap_idx]\n", + " snapshots[t_snap] = np.array(psi_var.data)\n", + " next_snap_idx += 1\n", + "\n", + "print(f\"Completed {n_steps} steps, t = {t_now:.4f} s\")\n", + "print(f\"Snapshots saved at t = {list(snapshots.keys())}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-13", + "metadata": {}, + "source": [ + "## Comparison with Analytical Solution\n", + "\n", + "We sample each snapshot along a vertical profile and compare\n", + "with the Ogata–Banks solution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-14", + "metadata": { + "execution": { + "iopub.status.busy": "2026-02-24T09:22:20.237733Z", + "iopub.status.idle": "2026-02-24T09:22:20.237979Z", + "shell.execute_reply": "2026-02-24T09:22:20.237856Z", + "shell.execute_reply.started": "2026-02-24T09:22:20.237846Z" + } + }, + "outputs": [], + "source": [ + "n_sample = 200\n", + "sample_y = np.linspace(0.05, COLUMN_HEIGHT - 0.05, n_sample)\n", + "sample_x = np.full_like(sample_y, COLUMN_WIDTH / 2)\n", + "sample_pts = np.column_stack([sample_x, sample_y])\n", + "\n", + "fig, axes = plt.subplots(1, len(snapshots), figsize=(5 * len(snapshots), 6), sharey=True)\n", + "if len(snapshots) == 1:\n", + " axes = [axes]\n", + "\n", + "max_errors = []\n", + "\n", + "for ax, (t_snap, psi_snap) in zip(axes, sorted(snapshots.items())):\n", + " # Restore snapshot and evaluate\n", + " psi_var.data[...] = psi_snap\n", + " psi_numerical = uw.function.evaluate(psi_var.sym[0], sample_pts).squeeze()\n", + "\n", + " psi_analytical = gardner_transient_psi(\n", + " sample_y, t_snap,\n", + " psi_dry=PSI_DRY, psi_wet=PSI_WET,\n", + " L=COLUMN_HEIGHT, Ks=KS, alpha=ALPHA_G,\n", + " theta_r=THETA_R, theta_s=THETA_S,\n", + " )\n", + "\n", + " error = np.abs(psi_numerical - psi_analytical)\n", + " max_err = error.max()\n", + " max_errors.append(max_err)\n", + "\n", + " ax.plot(psi_analytical, sample_y, \"b-\", lw=2, label=\"Analytical\")\n", + " ax.plot(psi_numerical, sample_y, \"ro\", ms=2, label=\"Numerical\")\n", + " ax.set_xlabel(r\"$\\psi$ (m)\")\n", + " ax.set_title(f\"$t = {t_snap}$ s\\nmax err = {max_err:.3e}\")\n", + " ax.legend(fontsize=9)\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "axes[0].set_ylabel(\"Height $y$ (m)\")\n", + "fig.suptitle(\"Transient wetting front: numerical vs analytical\", fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "for t_snap, err in zip(sorted(snapshots.keys()), max_errors):\n", + " print(f\" t = {t_snap:.2f} s : max |error| = {err:.4e} m\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-15", + "metadata": {}, + "source": [ + "## Darcy Velocity Field\n", + "\n", + "The downward velocity should be highest at the wetting front\n", + "where the pressure gradient is steepest." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-16", + "metadata": { + "execution": { + "iopub.status.busy": "2026-02-24T09:22:20.238715Z", + "iopub.status.idle": "2026-02-24T09:22:20.239232Z", + "shell.execute_reply": "2026-02-24T09:22:20.238832Z", + "shell.execute_reply.started": "2026-02-24T09:22:20.238822Z" + } + }, + "outputs": [], + "source": [ + "# Use the final snapshot\n", + "t_final = sorted(snapshots.keys())[-1]\n", + "psi_var.data[...] = snapshots[t_final]\n", + "richards.solve(timestep=DT) # recompute velocity\n", + "\n", + "vy_numerical = uw.function.evaluate(v_soln.sym[0, 1], sample_pts).squeeze()\n", + "\n", + "# Analytical Darcy velocity: q_y = K(ψ) (∂ψ/∂y + 1)\n", + "# Compute from the analytical ψ profile\n", + "psi_anal = gardner_transient_psi(\n", + " sample_y, t_final,\n", + " psi_dry=PSI_DRY, psi_wet=PSI_WET,\n", + " L=COLUMN_HEIGHT, Ks=KS, alpha=ALPHA_G,\n", + " theta_r=THETA_R, theta_s=THETA_S,\n", + ")\n", + "K_anal = KS * np.exp(ALPHA_G * np.clip(psi_anal, None, 0))\n", + "dpsi_dy = np.gradient(psi_anal, sample_y)\n", + "vy_analytical = K_anal * (dpsi_dy + 1)\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 6))\n", + "ax.plot(vy_analytical, sample_y, \"b-\", lw=2, label=\"Analytical\")\n", + "ax.plot(vy_numerical, sample_y, \"ro\", ms=2, label=\"Numerical\")\n", + "ax.set_xlabel(r\"Vertical Darcy flux $q_y$ (m/s)\")\n", + "ax.set_ylabel(\"Height $y$ (m)\")\n", + "ax.set_title(f\"Darcy velocity at $t = {t_final}$ s\")\n", + "ax.legend()\n", + "ax.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-17", + "metadata": {}, + "source": [ + "## Try It Yourself\n", + "\n", + "Experiment with different parameters to build intuition:\n", + "\n", + "```python\n", + "# Larger α → sharper wetting front\n", + "ALPHA_G = 6.0\n", + "\n", + "# Smaller timestep for better accuracy (error is time-dominated)\n", + "DT = 0.002\n", + "\n", + "# Wetter initial condition\n", + "PSI_DRY = -1.0\n", + "\n", + "# Higher resolution (spatial error is already small at RES=64)\n", + "RES = 128\n", + "```\n", + "\n", + "- How does the front speed change with $\\alpha$?\n", + "- What happens when the front reaches the bottom boundary?\n", + " (The semi-infinite analytical solution breaks down.)\n", + "- Try computing total water content\n", + " $\\int_0^L \\theta(\\psi(y))\\,dy$ at each snapshot to check\n", + " mass conservation.\n", + "\n", + "## References\n", + "\n", + "Celia, M. A., Bouloutas, E. T. & Zarba, R. L. (1990). A general\n", + "mass-conservative numerical solution for the unsaturated flow equation.\n", + "*Water Resources Research*, 26(7), 1483–1496.\n", + "doi:[10.1029/WR026i007p01483](https://doi.org/10.1029/WR026i007p01483)\n", + "\n", + "Gardner, W. R. (1958). Some steady-state solutions of the unsaturated\n", + "moisture flow equation with application to evaporation from a water table.\n", + "*Soil Science*, 85(4), 228–232.\n", + "\n", + "Ogata, A. & Banks, R. B. (1961). A solution of the differential\n", + "equation of longitudinal dispersion in porous media.\n", + "*US Geological Survey Professional Paper* 411-A.\n", + "\n", + "Richards, L. A. (1931). Capillary conduction of liquids through porous\n", + "mediums. *Physics*, 1(5), 318–333.\n", + "doi:[10.1063/1.1745010](https://doi.org/10.1063/1.1745010)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-18", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/beginner/tutorials/Notebook_Index.ipynb b/docs/beginner/tutorials/Notebook_Index.ipynb index 71c47d21..07b04e3c 100644 --- a/docs/beginner/tutorials/Notebook_Index.ipynb +++ b/docs/beginner/tutorials/Notebook_Index.ipynb @@ -22,7 +22,7 @@ }, "tags": [] }, - "source": "#### Notebook 1 - Meshes\n\n\ud83d\udd17 [**Meshes**](1-Meshes.ipynb): Introduces the mesh discretisation that we use in `Underworld3` and how you can build one of the pre-defined meshes. This notebook also show you how to use the `pyvista` visualisation tools for `Underworld3` objects. The mesh holds information on the mesh geometry, boundaries and coordinate systems." + "source": "#### Notebook 1 - Meshes\n\n🔗 [**Meshes**](1-Meshes.ipynb): Introduces the mesh discretisation that we use in `Underworld3` and how you can build one of the pre-defined meshes. This notebook also show you how to use the `pyvista` visualisation tools for `Underworld3` objects. The mesh holds information on the mesh geometry, boundaries and coordinate systems." }, { "cell_type": "markdown", @@ -34,67 +34,43 @@ }, "tags": [] }, - "source": "#### Notebook 2 - Mesh Variables\n\n\ud83d\udd17 [**Variables**](2-Variables.ipynb): Introduces the concept of `MeshVariables` in `Underworld3`. These are both data containers and `sympy` symbolic objects. We show you how to inspect a `meshVariable`, set the data values in the `MeshVariable` and visualise them." + "source": "#### Notebook 2 - Mesh Variables\n\n🔗 [**Variables**](2-Variables.ipynb): Introduces the concept of `MeshVariables` in `Underworld3`. These are both data containers and `sympy` symbolic objects. We show you how to inspect a `meshVariable`, set the data values in the `MeshVariable` and visualise them." }, { "cell_type": "markdown", "id": "26b5da69-1292-4988-93e4-591bcf607b32", "metadata": {}, - "source": "#### Notebook 3 - Symbols and sympy\n\n\ud83d\udd17 [**Symbols**](3-Symbolic_Forms.ipynb): `meshVariables` are `sympy` objects that can be composed with other symbolic objects and evaluated numerically when required. They can also be differentiated. Most importantly, `sympy` can manipulate expressions, simplify them and cancel terms." + "source": "#### Notebook 3 - Symbols and sympy\n\n🔗 [**Symbols**](3-Symbolic_Forms.ipynb): `meshVariables` are `sympy` objects that can be composed with other symbolic objects and evaluated numerically when required. They can also be differentiated. Most importantly, `sympy` can manipulate expressions, simplify them and cancel terms." }, { "cell_type": "markdown", "id": "6d091b23-709b-435c-ade1-9822ad09d567", "metadata": {}, - "source": "#### Notebook 4 - Example: Diffusion Equation\n\n\ud83d\udd17 [**Diffusion Solver**](4-Solvers-i-Poisson.ipynb): Introduces the various solver templates that are available in Underworld, starting with a steady-state diffusion problem. The template requires you to set some constitutive properties and define the unknowns. These are handled through subsitution into symbolic forms and the template equation can be inspected before you need to supply concrete expressions.\n\n#### Notebook 5 - Poisson Equation Validation\n\n\ud83d\udd17 [**Poisson Validation**](5-Solvers-i-Poisson-Validation.ipynb): Demonstrates how to validate the Poisson solver against known analytical solutions. We solve three progressively complex diffusion problems with linear, quadratic, and sinusoidal profiles, comparing numerical results against exact solutions." + "source": "#### Notebook 4 - Example: Diffusion Equation\n\n🔗 [**Diffusion Solver**](4-Solvers-i-Poisson.ipynb): Introduces the various solver templates that are available in Underworld, starting with a steady-state diffusion problem. The template requires you to set some constitutive properties and define the unknowns. These are handled through subsitution into symbolic forms and the template equation can be inspected before you need to supply concrete expressions.\n\n#### Notebook 5 - Poisson Equation Validation\n\n🔗 [**Poisson Validation**](5-Solvers-i-Poisson-Validation.ipynb): Demonstrates how to validate the Poisson solver against known analytical solutions. We solve three progressively complex diffusion problems with linear, quadratic, and sinusoidal profiles, comparing numerical results against exact solutions." }, { "cell_type": "markdown", "id": "eff58d66-8892-4af6-92b0-c18ee9cd2ad2", "metadata": {}, - "source": "#### Notebook 6 - Example: Stokes Equation\n\n\ud83d\udd17 [**Stokes Solver**](6-Solvers-ii-Stokes.ipynb): Stokes equation is a more complicated system of equations to solve. This complexity is mostly hidden when you set the problem up. There are some interesting ways to constrain boundary values which are demonstrated using an annulus mesh (curved, free-slip boundaries) and a $\\delta$ function buoyancy source." + "source": "#### Notebook 6 - Example: Stokes Equation\n\n🔗 [**Stokes Solver**](6-Solvers-ii-Stokes.ipynb): Stokes equation is a more complicated system of equations to solve. This complexity is mostly hidden when you set the problem up. There are some interesting ways to constrain boundary values which are demonstrated using an annulus mesh (curved, free-slip boundaries) and a $\\delta$ function buoyancy source." }, { "cell_type": "markdown", "id": "0a400f96-5908-4b60-ba0d-ef188c5a66cd", "metadata": {}, - "source": "#### Notebook 7 - Example: Time Dependence\n\n\ud83d\udd17 [**Timestepping**](7-Timestepping-simple.ipynb): Simple advection-diffusion problem. A step (or a top-hat function) moves left to right with constant velocity and diffusion occurs at the same time. This has an analytic solution so we can see the effect of changing timesteps and grid resolution very easily.\n\n#### Notebook 8 - Coupled Timestepping \n\n\ud83d\udd17 [**Coupled Timestepping**](8-Timestepping-coupled.ipynb): *Coupled* Stokes flow plus thermal advection-diffusion gives a simple convection solver. The timestepping loop is written by hand because usually you will want to do some analysis or output some checkpoints." + "source": "#### Notebook 7 - Example: Time Dependence\n\n🔗 [**Timestepping**](7-Timestepping-simple.ipynb): Simple advection-diffusion problem. A step (or a top-hat function) moves left to right with constant velocity and diffusion occurs at the same time. This has an analytic solution so we can see the effect of changing timesteps and grid resolution very easily.\n\n#### Notebook 8 - Coupled Timestepping \n\n🔗 [**Coupled Timestepping**](8-Timestepping-coupled.ipynb): *Coupled* Stokes flow plus thermal advection-diffusion gives a simple convection solver. The timestepping loop is written by hand because usually you will want to do some analysis or output some checkpoints." }, { "cell_type": "markdown", "id": "3b784a04-823e-4a88-9b18-a57f763dbf56", "metadata": {}, - "source": "#### Notebook 9 - Example: Navier-Stokes Equation\n\n\ud83d\udd17 [**Unsteady flow**](9-Unsteady_Flow.ipynb): Using a passive swarm to track the pattern of flow developing in a pipe after an impulsive application of a boundary condition at the inflow. Particles need to be added to the passive swarm close to the inflow at each timestep." + "source": "#### Notebook 9 - Example: Navier-Stokes Equation\n\n🔗 [**Unsteady flow**](9-Unsteady_Flow.ipynb): Using a passive swarm to track the pattern of flow developing in a pipe after an impulsive application of a boundary condition at the inflow. Particles need to be added to the passive swarm close to the inflow at each timestep." }, { "cell_type": "markdown", "id": "42f43817-0e0b-458b-9c5b-34799fb60487", "metadata": {}, - "source": [ - "#### Notebook 10 - Lagrangian Swarm Variables\n", - "\n", - "\ud83d\udd17 [**Swarm Variables**](10-Particle_Swarms.ipynb): Exploring how they work for specifying material properties with a swarm used to determine element viscosity. We learn how to use swarm variables in expressions generally and for boundary conditions.\n", - "\n", - "#### Notebook 11 - Multi-Material Constitutive Models\n", - "\n", - "\ud83d\udd17 [**Multi-Material SolCx**](11-Multi-Material_SolCx.ipynb): Demonstrates the multi-material constitutive model system by recreating the classic SolCx benchmark using IndexSwarmVariable to track different materials. Shows level-set weighted flux averaging and validation against piecewise viscosity solutions.\n", - "\n", - "#### Notebook 12 - Working with Physical Units\n", - "\n", - "\ud83d\udd17 [**Units System**](12-Units_System.ipynb): Introduces physical units in Underworld3 using the Pint library. Shows how to create physical quantities (temperatures, velocities, viscosities), convert between units, work with unit-aware arrays and coordinates, and leverage automatic unit tracking through derivatives.\n", - "\n", - "#### Notebook 13 - Non-Dimensional Scaling\n", - "\n", - "\ud83d\udd17 [**Non-Dimensional Scaling**](13-Scaling-problems-with-physical-units.ipynb): Demonstrates the non-dimensional scaling system for better numerical conditioning. Shows how to set reference quantities, solve Poisson and Stokes equations with automatic ND scaling, and validate that dimensional and non-dimensional solutions match perfectly.\n", - "\n", - "#### Notebook 14 - Time-Dependent Advection-Diffusion\n", - "\n", - "\ud83d\udd17 [**Timestepping with Units**](14-Timestepping-with-physical-units.ipynb): Time-dependent advection-diffusion with physical units. Tests numerical solutions against analytical solutions for advection and diffusion of temperature steps.\n", - "\n", - "#### Notebook 15 - Thermal Convection\n", - "\n", - "\ud83d\udd17 [**Rayleigh-B\u00e9nard Convection**](15-Thermal-convection-with-units.ipynb): Complete thermal convection example with physical units. Demonstrates coupled Stokes-temperature systems with buoyancy forcing in an annulus geometry, Rayleigh number computation, and time-stepping visualization." - ] + "source": "#### Notebook 10 - Lagrangian Swarm Variables\n\n🔗 [**Swarm Variables**](10-Particle_Swarms.ipynb): Exploring how they work for specifying material properties with a swarm used to determine element viscosity. We learn how to use swarm variables in expressions generally and for boundary conditions.\n\n#### Notebook 11 - Multi-Material Constitutive Models\n\n🔗 [**Multi-Material SolCx**](11-Multi-Material_SolCx.ipynb): Demonstrates the multi-material constitutive model system by recreating the classic SolCx benchmark using IndexSwarmVariable to track different materials. Shows level-set weighted flux averaging and validation against piecewise viscosity solutions.\n\n#### Notebook 12 - Working with Physical Units\n\n🔗 [**Units System**](12-Units_System.ipynb): Introduces physical units in Underworld3 using the Pint library. Shows how to create physical quantities (temperatures, velocities, viscosities), convert between units, work with unit-aware arrays and coordinates, and leverage automatic unit tracking through derivatives.\n\n#### Notebook 13 - Non-Dimensional Scaling\n\n🔗 [**Non-Dimensional Scaling**](13-Scaling-problems-with-physical-units.ipynb): Demonstrates the non-dimensional scaling system for better numerical conditioning. Shows how to set reference quantities, solve Poisson and Stokes equations with automatic ND scaling, and validate that dimensional and non-dimensional solutions match perfectly.\n\n#### Notebook 14 - Time-Dependent Advection-Diffusion\n\n🔗 [**Timestepping with Units**](14-Timestepping-with-physical-units.ipynb): Time-dependent advection-diffusion with physical units. Tests numerical solutions against analytical solutions for advection and diffusion of temperature steps.\n\n#### Notebook 15 - Thermal Convection\n\n🔗 [**Rayleigh-Bénard Convection**](15-Thermal-convection-with-units.ipynb): Complete thermal convection example with physical units. Demonstrates coupled Stokes-temperature systems with buoyancy forcing in an annulus geometry, Rayleigh number computation, and time-stepping visualization.\n\n#### Notebook 16 - Richards Equation (Groundwater)\n\n🔗 [**Richards Equation**](16-Richards-Equation-Groundwater.ipynb): Introduces the Richards equation for variably-saturated porous media flow. Solves a steady-state drainage problem in a vertical soil column using the Gardner exponential conductivity model and validates against an exact analytical solution.\n\n#### Notebook 17 - Richards Equation — Transient Wetting Front\n\n🔗 [**Transient Wetting Front**](17-Richards-Transient-Wetting-Front.ipynb): Solves a transient Richards equation problem where a wetting front propagates downward through a dry soil column. Validates the numerical solution against the Ogata–Banks analytical benchmark for the Gardner model." }, { "cell_type": "markdown", diff --git a/docs/developer/guides/notebook-style-guide.md b/docs/developer/guides/notebook-style-guide.md index 4fae3e3c..9deddc05 100644 --- a/docs/developer/guides/notebook-style-guide.md +++ b/docs/developer/guides/notebook-style-guide.md @@ -71,17 +71,21 @@ print("Success!") # Unnecessary import numpy as np ``` -3. **Concept Sections** +3. **Parameters Cell** (see [Parameters and Configuration](#parameters-and-configuration) below) + - Named constants for defaults, then `uw.Params` block + - Markdown cell above explaining CLI override syntax + +4. **Concept Sections** - Markdown header (##) for each major concept - Brief explanation in markdown - Code cells demonstrating the concept - Minimal output cells (let Jupyter display) -4. **Summary** (markdown) +5. **Summary** (markdown) - Key takeaways in bullet points - When to use what -5. **Try It Yourself** (markdown) +6. **Try It Yourself** (markdown) - Optional exercises in code fences - Encourage exploration @@ -110,6 +114,79 @@ mesh.units mesh.view() ``` +## Parameters and Configuration + +Every notebook or example script that accepts tuneable settings should use +`uw.Params`. The standard pattern has two parts: + +1. **Named constants** — plain Python variables holding the default values. + These are the first thing a notebook user sees and edits. +2. **`uw.Params` block** — wraps the constants with units, bounds, + descriptions, and CLI override support. + +### Standard Pattern + +A markdown cell introduces the parameters and shows CLI usage: + +~~~markdown +### Configurable parameters + +Default values are defined as named constants below. From the command +line, override them with PETSc-style flags: + +```bash +python script.py -uw_viscosity "5e20 Pa*s" -uw_cell_size 25km +``` +~~~ + +Followed by the code cell: + +```python +# --- Default values (edit these in a notebook) --- +VISCOSITY = 1e21 # Pa·s – reference viscosity +CELL_SIZE = 50.0 # km – target cell size +DEPTH = 660.0 # km – model depth +MAX_STEPS = 100 # solver iterations + +params = uw.Params( + uw_viscosity = uw.Param(VISCOSITY, units="Pa*s", description="reference viscosity"), + uw_cell_size = uw.Param(CELL_SIZE, units="km", description="target cell size"), + uw_depth = uw.Param(DEPTH, units="km", description="model depth"), + uw_max_steps = MAX_STEPS, +) +``` + +### Why Named Constants + +- **Visibility**: The reader sees the default values at a glance without + having to parse the `uw.Param(...)` wrapper. +- **Editability**: In a notebook, changing a default is a single number + edit at the top of the cell — no need to find it inside a function call. +- **Separation of concerns**: The constants say *what* the defaults are; + the `uw.Params` block says *how* they are validated and overridden. + +### Naming Conventions + +- Named constants: `UPPER_CASE` with a brief inline comment showing + units and purpose. +- Parameter names: `uw_` prefix to avoid PETSc option collisions. +- Add a `description=` string for any parameter that will appear in + `params.cli_help()`. + +### What Not To Do + +```python +# Avoid: inline literals with no named constant +params = uw.Params( + uw_viscosity = uw.Param(1e21, units="Pa*s"), # hard to scan +) + +# Avoid: parameters scattered through the notebook +viscosity = 1e21 # defined in cell 3 +# ... 20 cells later ... +params.uw_viscosity = viscosity # reader has lost context +``` + ## What to Avoid - ❌ Excessive congratulation ("Great job!", "Excellent!") diff --git a/docs/examples/WIP/Benchmark/Ex_Richards_Tracy_Benchmark.py b/docs/examples/WIP/Benchmark/Ex_Richards_Tracy_Benchmark.py new file mode 100644 index 00000000..d424a50d --- /dev/null +++ b/docs/examples/WIP/Benchmark/Ex_Richards_Tracy_Benchmark.py @@ -0,0 +1,475 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.16.4 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] +# # Tracy (2006) 2D Richards Equation Benchmark +# +# Validates the Underworld Richards solver against the **closed-form analytical +# solution** of Tracy (2006) for 2D steady-state and transient flow in +# unsaturated porous media with Gardner (exponential) soil properties. +# +# The benchmark uses a square domain $L \times L$ with the Gardner conductivity +# $K(\psi) = K_s \exp(\alpha\,\psi)$ and moisture content +# $\theta(\psi) = \theta_r + (\theta_s - \theta_r)\exp(\alpha\,\psi)$. +# +# Two boundary condition cases are tested: +# +# 1. **Specified head** — Dirichlet on all four boundaries ($\psi = h_r$ on +# bottom, left, right; spatially varying on top) +# 2. **No-flux** — zero-flux on lateral boundaries, Dirichlet on top/bottom +# ($\psi = h_r$ at bottom; spatially varying at top) +# +# The top boundary carries a spatially varying wetting profile that drives +# infiltration into an initially dry column ($\psi = h_r$). +# +# ### Reference +# +# Tracy, F. T. (2006). Clean two- and three-dimensional analytical solutions of +# Richards' equation for testing numerical solvers. *Water Resources Research*, 42(8). +# https://doi.org/10.1029/2005WR004638 + +# %% +import nest_asyncio + +nest_asyncio.apply() + +import underworld3 as uw +import numpy as np +import sympy +from math import sqrt, sin, cos, exp, sinh, pi, log + + +# %% [markdown] +# ## Analytical solution (Tracy 2006) +# +# The Tracy solution applies the Kirchhoff transform $u = \exp(\alpha\psi)$ to +# linearise the Richards equation. With Gardner properties, the transformed PDE +# is linear and has exact Fourier series solutions on a square domain. +# +# The key parameter grouping is $\alpha L$ — the ratio of domain size to the +# Gardner capillary length. The gwassess package uses $\alpha L = 5.0$ and +# $\alpha h_r = -5.0$; we adopt the same dimensionless combination with +# rescaled dimensional parameters for fast convergence. + + +# %% +def tracy_specified_head(x, y, t, alpha, hr, L, theta_r, theta_s, Ks): + """Analytical pressure head — specified head BCs on all boundaries. + + Tracy (2006), equations (15)–(17). + + BCs: psi = hr on bottom (y=0), left (x=0), right (x=L). + psi = (1/alpha)*log(exp(alpha*hr) + h0*sin(pi*x/L)) on top (y=L). + IC: psi = hr everywhere at t=0. + """ + h0 = 1 - exp(alpha * hr) + c = alpha * (theta_s - theta_r) / Ks + + beta = sqrt(alpha**2 / 4 + (pi / L) ** 2) + hss = ( + h0 + * sin(pi * x / L) + * exp((alpha / 2) * (L - y)) + * sinh(beta * y) + / sinh(beta * L) + ) + + phi = 0.0 + for k in range(1, 200): + lambdak = k * pi / L + gamma = (beta**2 + lambdak**2) / c + phi += ((-1) ** k) * (lambdak / gamma) * sin(lambdak * y) * exp(-gamma * t) + phi *= ((2 * h0) / (L * c)) * sin(pi * x / L) * exp(alpha * (L - y) / 2) + + hBar = hss + phi + return (1 / alpha) * log(exp(alpha * hr) + hBar) + + +def tracy_no_flux(x, y, t, alpha, hr, L, theta_r, theta_s, Ks): + """Analytical pressure head — no-flux lateral, specified head top/bottom. + + Tracy (2006), equations (18)–(20). + + BCs: psi = hr on bottom (y=0). + Zero flux on left (x=0) and right (x=L). + psi = (1/alpha)*log(exp(alpha*hr) + (h0/2)*(1-cos(2*pi*x/L))) on top (y=L). + IC: psi = hr everywhere at t=0. + """ + h0 = 1 - exp(alpha * hr) + c = alpha * (theta_s - theta_r) / Ks + + beta = sqrt(alpha**2 / 4 + (2 * pi / L) ** 2) + hss = (h0 / 2) * exp((alpha / 2) * (L - y)) * ( + sinh(alpha * y / 2) / sinh(alpha * L / 2) + - cos(2 * pi * x / L) * sinh(beta * y) / sinh(beta * L) + ) + + phi = 0.0 + for k in range(1, 200): + lambdak = k * pi / L + gamma1 = (lambdak**2 + alpha**2 / 4) / c + gamma2 = ((2 * pi / L) ** 2 + lambdak**2 + alpha**2 / 4) / c + phi += ((-1) ** k) * lambdak * ( + (1 / gamma1) * exp(-gamma1 * t) + - (1 / gamma2) * cos(2 * pi * x / L) * exp(-gamma2 * t) + ) * sin(lambdak * y) + phi *= (h0 / (L * c)) * exp(alpha * (L - y) / 2) + + hBar = hss + phi + return (1 / alpha) * log(exp(alpha * hr) + hBar) + + +def tracy_solution_on_grid(sample_pts, t, alpha, hr, L, theta_r, theta_s, Ks, bc_type): + """Evaluate Tracy solution at an array of (x, y) sample points.""" + func = tracy_specified_head if bc_type == "specified_head" else tracy_no_flux + return np.array( + [func(p[0], p[1], t, alpha, hr, L, theta_r, theta_s, Ks) for p in sample_pts] + ) + + +# %% [markdown] +# ### Configurable parameters +# +# Default values are defined as named constants below. From the command line, +# override them with PETSc-style flags: +# +# ```bash +# python Ex_Richards_Tracy_Benchmark.py -uw_res 48 -uw_bc_type no_flux +# ``` +# +# The default parameters give $\alpha L = 5$ and $\alpha h_r = -5$, matching +# the dimensionless grouping used in the gwassess benchmark suite. + +# %% +# --- Default values (edit these in a notebook) --- +RES = 32 # elements per side +ALPHA = 5.0 # 1/m – Gardner sorptive number +HR = -1.0 # m – reference pressure head (dry end) +L = 1.0 # m – domain size (square L×L) +THETA_R = 0.15 # – residual water content +THETA_S = 0.45 # – saturated water content +KS = 1.0 # m/s – saturated hydraulic conductivity +DT = 0.05 # s – timestep +N_STEPS = 40 # – number of timesteps to reach steady state +BC_TYPE = "no_flux" # – boundary condition type + +params = uw.Params( + uw_res = RES, + uw_alpha = uw.Param(ALPHA, units="1/m", description="Gardner sorptive number"), + uw_hr = uw.Param(HR, units="m", description="reference pressure head"), + uw_L = uw.Param(L, units="m", description="domain size"), + uw_theta_r = THETA_R, + uw_theta_s = THETA_S, + uw_Ks = uw.Param(KS, units="m/s", description="saturated conductivity"), + uw_dt = uw.Param(DT, units="s", description="timestep"), + uw_n_steps = N_STEPS, + uw_bc_type = BC_TYPE, +) + +res = int(params.uw_res) +alpha = float(params.uw_alpha) +hr = float(params.uw_hr) +L_dom = float(params.uw_L) +theta_r = float(params.uw_theta_r) +theta_s = float(params.uw_theta_s) +Ks = float(params.uw_Ks) +dt = float(params.uw_dt) +n_steps = int(params.uw_n_steps) +bc_type = str(params.uw_bc_type) + +# Derived parameters +c_time = alpha * (theta_s - theta_r) / Ks # characteristic time scale +h0 = 1 - np.exp(alpha * hr) # driving amplitude + +print(f"alpha*L = {alpha * L_dom:.1f}, alpha*hr = {alpha * hr:.1f}") +print(f"c (time scale) = {c_time:.2f} s, h0 = {h0:.4f}") +print(f"Total time = {n_steps * dt:.1f} s ({n_steps * dt / c_time:.1f} × c)") + +# %% [markdown] +# ## Mesh and variables + +# %% +mesh = uw.meshing.StructuredQuadBox( + elementRes=(res, res), + minCoords=(0.0, 0.0), + maxCoords=(L_dom, L_dom), + qdegree=3, +) + +psi = uw.discretisation.MeshVariable(r"\psi", mesh, 1, degree=2) +v_soln = uw.discretisation.MeshVariable("v", mesh, mesh.dim, degree=1) + +# %% [markdown] +# ## Solver setup +# +# The Tracy benchmark uses the Gardner exponential model, which we take +# from the retention curves module. + +# %% +from underworld3.utilities.retention_curves import gardner_K, gardner_theta + +psi_sym = psi.sym[0] + +richards = uw.systems.Richards(mesh, psi, v_soln, order=1, theta=0.5) +richards.petsc_options.delValue("ksp_monitor") +richards.petsc_options["snes_rtol"] = 1.0e-6 +richards.petsc_options["snes_max_it"] = 30 + +richards.constitutive_model = uw.constitutive_models.DarcyFlowModel +richards.constitutive_model.Parameters.permeability = gardner_K(psi_sym, Ks=Ks, alpha=alpha) +richards.constitutive_model.Parameters.s = sympy.Matrix([0, -1]).T + +# Mixed form — mass-conservative +richards.water_content = gardner_theta(psi_sym, theta_r=theta_r, theta_s=theta_s, alpha=alpha) +richards.f = 0.0 + +richards._v_projector.petsc_options["snes_rtol"] = 1.0e-6 +richards._v_projector.smoothing = 1.0e-6 + +# %% [markdown] +# ## Boundary conditions +# +# The Tracy analytical solution has $\psi = h_r$ (dry state) on the bottom and +# lateral boundaries, but a **spatially varying** wetting profile on the top +# boundary. +# +# For the **no-flux** case: +# - Bottom ($y=0$): $\psi = h_r$ +# - Left, Right ($x=0, L$): zero flux (natural BC — no Dirichlet) +# - Top ($y=L$): $\psi(x) = \frac{1}{\alpha}\ln\!\left[e^{\alpha h_r} +# + \frac{h_0}{2}\left(1 - \cos\frac{2\pi x}{L}\right)\right]$ +# +# For the **specified-head** case: +# - Bottom, Left, Right: $\psi = h_r$ +# - Top: $\psi(x) = \frac{1}{\alpha}\ln\!\left[e^{\alpha h_r} +# + h_0 \sin\frac{\pi x}{L}\right]$ +# +# where $h_0 = 1 - e^{\alpha h_r}$. + +# %% +x_sym = mesh.X[0] +h0_sym = 1 - sympy.exp(alpha * hr) + +if bc_type == "no_flux": + psi_top = (1 / alpha) * sympy.log( + sympy.exp(alpha * hr) + (h0_sym / 2) * (1 - sympy.cos(2 * sympy.pi * x_sym / L_dom)) + ) +elif bc_type == "specified_head": + psi_top = (1 / alpha) * sympy.log( + sympy.exp(alpha * hr) + h0_sym * sympy.sin(sympy.pi * x_sym / L_dom) + ) +else: + raise ValueError(f"Unknown bc_type: {bc_type!r}. Use 'no_flux' or 'specified_head'.") + +richards.add_dirichlet_bc([psi_top], "Top") +richards.add_dirichlet_bc([hr], "Bottom") + +if bc_type == "specified_head": + richards.add_dirichlet_bc([hr], "Left") + richards.add_dirichlet_bc([hr], "Right") + +# %% [markdown] +# ## Initial condition +# +# Start from the uniform dry state $\psi = h_r$ everywhere. The transient +# solution evolves from this initial condition towards steady state driven +# by the wetting profile on the top boundary. + +# %% +psi.array[:, 0, 0] = hr + +# %% [markdown] +# ## Time stepping +# +# We step forward in time until the solution approaches steady state. The +# Tracy analytical solution gives us the exact transient profile at each +# time level. + +# %% +time = 0.0 + +for step in range(n_steps): + richards.solve(timestep=dt) + time += dt + + if step % 10 == 0 or step == n_steps - 1: + # Sample interior points to check convergence + n_sample = 20 + sx = np.linspace(0.1 * L_dom, 0.9 * L_dom, n_sample) + sy = np.linspace(0.1 * L_dom, 0.9 * L_dom, n_sample) + xx, yy = np.meshgrid(sx, sy) + sample_pts = np.column_stack([xx.ravel(), yy.ravel()]) + + psi_num = uw.function.evaluate(psi.sym[0], sample_pts).squeeze() + psi_exact = tracy_solution_on_grid( + sample_pts, time, alpha, hr, L_dom, theta_r, theta_s, Ks, bc_type + ) + max_err = np.max(np.abs(psi_num - psi_exact)) + l2_err = np.sqrt(np.mean((psi_num - psi_exact) ** 2)) + + print( + f"Step {step:3d}, t = {time:8.3f} s | " + f"max |err| = {max_err:.4e}, L2 err = {l2_err:.4e}" + ) + +# %% [markdown] +# ## Final comparison against analytical solution + +# %% +# Dense grid for final comparison +n_final = 40 +sx = np.linspace(0.05 * L_dom, 0.95 * L_dom, n_final) +sy = np.linspace(0.05 * L_dom, 0.95 * L_dom, n_final) +xx, yy = np.meshgrid(sx, sy) +sample_pts = np.column_stack([xx.ravel(), yy.ravel()]) + +psi_numerical = uw.function.evaluate(psi.sym[0], sample_pts).squeeze() +psi_analytical = tracy_solution_on_grid( + sample_pts, time, alpha, hr, L_dom, theta_r, theta_s, Ks, bc_type +) + +max_error = np.max(np.abs(psi_numerical - psi_analytical)) +l2_error = np.sqrt(np.mean((psi_numerical - psi_analytical) ** 2)) +rel_error = l2_error / np.sqrt(np.mean(psi_analytical**2)) + +print(f"\nFinal comparison at t = {time:.3f} s ({bc_type} BCs, {res}×{res} mesh)") +print(f" Max absolute error: {max_error:.4e}") +print(f" L2 error: {l2_error:.4e}") +print(f" Relative L2 error: {rel_error:.4e}") + +# %% [markdown] +# ## Visualisation + +# %% +if uw.is_notebook(): + import pyvista as pv + import underworld3.visualisation as vis + + pv_mesh = vis.mesh_to_pv_mesh(mesh) + pv_mesh.point_data["psi_numerical"] = vis.scalar_fn_to_pv_points(pv_mesh, psi.sym[0]) + + # Evaluate analytical on pv mesh vertices + pv_coords = np.array(pv_mesh.points[:, :2]) + pv_mesh.point_data["psi_analytical"] = tracy_solution_on_grid( + pv_coords, time, alpha, hr, L_dom, theta_r, theta_s, Ks, bc_type + ) + pv_mesh.point_data["error"] = ( + pv_mesh.point_data["psi_numerical"] - pv_mesh.point_data["psi_analytical"] + ) + + pl = pv.Plotter(shape=(1, 3), window_size=(1200, 400)) + + pl.subplot(0, 0) + pl.add_mesh( + pv_mesh.copy(), + scalars="psi_numerical", + cmap="Blues_r", + show_edges=False, + scalar_bar_args={"title": "Numerical"}, + ) + pl.add_text(f"Numerical psi", font_size=10) + pl.view_xy() + + pl.subplot(0, 1) + pl.add_mesh( + pv_mesh.copy(), + scalars="psi_analytical", + cmap="Blues_r", + show_edges=False, + scalar_bar_args={"title": "Analytical"}, + ) + pl.add_text(f"Analytical psi (Tracy)", font_size=10) + pl.view_xy() + + pl.subplot(0, 2) + pl.add_mesh( + pv_mesh.copy(), + scalars="error", + cmap="RdBu_r", + show_edges=False, + scalar_bar_args={"title": "Error"}, + ) + pl.add_text(f"Error", font_size=10) + pl.view_xy() + + pl.show() + +# %% [markdown] +# ## Vertical profile comparison + +# %% +if uw.is_notebook(): + import matplotlib.pyplot as plt + + # Profile at x = L/2 + n_profile = 100 + y_profile = np.linspace(0.02 * L_dom, 0.98 * L_dom, n_profile) + x_profile = np.full_like(y_profile, 0.5 * L_dom) + profile_pts = np.column_stack([x_profile, y_profile]) + + psi_profile_num = uw.function.evaluate(psi.sym[0], profile_pts).squeeze() + psi_profile_exact = tracy_solution_on_grid( + profile_pts, time, alpha, hr, L_dom, theta_r, theta_s, Ks, bc_type + ) + + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + + ax1.plot(psi_profile_exact, y_profile, "k-", label="Tracy analytical", linewidth=2) + ax1.plot(psi_profile_num, y_profile, "ro", label="UW3 numerical", markersize=4) + ax1.set_xlabel(r"Pressure head $\psi$ [m]") + ax1.set_ylabel("y [m]") + ax1.set_title(f"Vertical profile at x = L/2 (t = {time:.2f} s)") + ax1.legend() + ax1.grid(True, alpha=0.3) + + ax2.plot(psi_profile_num - psi_profile_exact, y_profile, "b-", linewidth=1.5) + ax2.set_xlabel(r"Error $\psi_{num} - \psi_{exact}$ [m]") + ax2.set_ylabel("y [m]") + ax2.set_title("Error profile") + ax2.axvline(0, color="k", linestyle="--", alpha=0.3) + ax2.grid(True, alpha=0.3) + + fig.tight_layout() + plt.show() + +# %% [markdown] +# ## Quantitative assessment +# +# For a production-quality benchmark, the error should decrease with mesh +# refinement. Run at multiple resolutions to check convergence: +# +# ```bash +# python Ex_Richards_Tracy_Benchmark.py -uw_res 16 +# python Ex_Richards_Tracy_Benchmark.py -uw_res 32 +# python Ex_Richards_Tracy_Benchmark.py -uw_res 64 +# ``` +# +# With degree-2 elements, we expect roughly 4th-order convergence +# (halving the element size should reduce the error by ~16×). + +# %% +print(f"\nBenchmark: Tracy (2006) 2D Richards equation") +print(f"BC type: {bc_type}") +print(f"Resolution: {res}×{res}") +print(f"Parameters: alpha={alpha}, hr={hr}, L={L_dom}, Ks={Ks}") +print(f" alpha*L={alpha*L_dom:.1f}, alpha*hr={alpha*hr:.1f}, c={c_time:.2f}") +print(f"Time: t={time:.3f} s ({n_steps} steps × dt={dt})") +print(f"Max error: {max_error:.4e}") +print(f"L2 error: {l2_error:.4e}") +print(f"Rel L2 err: {rel_error:.4e}") + +if max_error < 0.05: + print("\nPASSED: Max error < 0.05") +else: + print(f"\nFAILED: Max error = {max_error:.4e} (threshold 0.05)") diff --git a/docs/examples/WIP/Benchmark/Ex_VP_Spiegelman_Benchmark.py b/docs/examples/WIP/Benchmark/Ex_VP_Spiegelman_Benchmark.py index adfc966a..199828ed 100644 --- a/docs/examples/WIP/Benchmark/Ex_VP_Spiegelman_Benchmark.py +++ b/docs/examples/WIP/Benchmark/Ex_VP_Spiegelman_Benchmark.py @@ -715,6 +715,7 @@ def plastic_viscosity(alpha): pl2.show(cpos="xy") -# %% +# %% language="sh" +# python --version # %% diff --git a/src/underworld3/__init__.py b/src/underworld3/__init__.py index 25b76b20..ad4b80e6 100644 --- a/src/underworld3/__init__.py +++ b/src/underworld3/__init__.py @@ -221,6 +221,7 @@ def view(): from .constitutive_models import MultiMaterialConstitutiveModel from .function import quantity, expression, with_units, expand, unwrap from .coordinates import uwdiff # Differentiation helper for UWCoordinates +from .utilities import retention_curves # Unit utilities (top-level convenience for user code) from .function.unit_conversion import _extract_value diff --git a/src/underworld3/systems/__init__.py b/src/underworld3/systems/__init__.py index 4ca16007..fa0160ba 100644 --- a/src/underworld3/systems/__init__.py +++ b/src/underworld3/systems/__init__.py @@ -23,6 +23,10 @@ Navier-Stokes equations with inertia. Diffusion : class Pure diffusion (no advection). +TransientDarcy : class + Transient groundwater flow with constant storage. +Richards : class + Richards equation for variably-saturated flow. Time Derivative Schemes ----------------------- @@ -61,6 +65,10 @@ # import diffusion-only solver from .solvers import SNES_Diffusion as Diffusion +# Transient Darcy and Richards solvers +from .solvers import SNES_TransientDarcy as TransientDarcy +from .solvers import SNES_Richards as Richards + # These are now implemented the same way using the ddt module from .solvers import SNES_NavierStokes as NavierStokesSwarm from .solvers import SNES_NavierStokes as NavierStokesSLCN diff --git a/src/underworld3/systems/solvers.py b/src/underworld3/systems/solvers.py index 25c85b16..5847e0ae 100644 --- a/src/underworld3/systems/solvers.py +++ b/src/underworld3/systems/solvers.py @@ -11,6 +11,10 @@ Poisson/diffusion equation: :math:`\nabla \cdot (k \nabla T) = f` SNES_Darcy Darcy flow: pressure-driven flow through porous media +SNES_TransientDarcy + Transient groundwater flow with constant storage +SNES_Richards + Richards equation for variably-saturated porous media flow Vector Equations ---------------- @@ -548,6 +552,453 @@ def solve( # super()._setup_terms() +class SNES_TransientDarcy(SNES_Darcy): + r""" + Transient Darcy flow solver for time-dependent groundwater problems. + + Solves the transient groundwater flow equation: + + .. math:: + + S_s \frac{\partial h}{\partial t} + - \nabla \cdot \left[ K (\nabla h - \mathbf{s}) \right] = f + + where :math:`S_s` is the specific storage (constant), :math:`K` is the + hydraulic conductivity, :math:`\mathbf{s}` is the body force (gravity), + and :math:`f` is a source/sink term. + + Inherits velocity projection from :class:`SNES_Darcy`. + + Parameters + ---------- + mesh : Mesh + The computational mesh. + h_Field : MeshVariable, optional + Mesh variable for hydraulic head. + v_Field : MeshVariable, optional + Mesh variable for Darcy velocity. + order : int, default=1 + Time integration order (BDF/Adams-Moulton history depth). + theta : float, default=0.5 + Implicit time weighting (0=explicit, 0.5=Crank-Nicolson, 1=implicit). + degree : int, default=2 + Polynomial degree for finite element discretization. + verbose : bool, default=False + Enable verbose output. + DuDt : optional + Time derivative operator for the unknown. + DFDt : optional + Time derivative operator for the flux. + + Attributes + ---------- + storage : sympy.Expr + Specific storage :math:`S_s` (default 1). + delta_t : UWexpression + Current timestep. + + See Also + -------- + SNES_Darcy : Steady-state parent solver. + SNES_Richards : Nonlinear extension for unsaturated flow. + """ + + @timing.routine_timer_decorator + def __init__( + self, + mesh: uw.discretisation.Mesh, + h_Field: Optional[uw.discretisation.MeshVariable] = None, + v_Field: Optional[uw.discretisation.MeshVariable] = None, + order: int = 1, + theta: float = 0.5, + degree: int = 2, + verbose=False, + DuDt=None, + DFDt=None, + ): + super().__init__(mesh, h_Field, v_Field, degree, verbose, DuDt=DuDt, DFDt=DFDt) + + self.theta = theta + self._delta_t = expression(R"\Delta t", 0, "Physically motivated timestep") + self._storage = sympy.sympify(1) + self.is_setup = False + + if DuDt is None: + self.Unknowns.DuDt = Eulerian_DDt( + self.mesh, + h_Field, + vtype=uw.VarType.SCALAR, + degree=h_Field.degree, + continuous=h_Field.continuous, + varsymbol=h_Field.symbol, + verbose=verbose, + order=order, + smoothing=0.0, + ) + else: + if order is not None and DuDt.order < order: + raise RuntimeError( + f"DuDt supplied is order {DuDt.order} but order requested is {order}" + ) + self.Unknowns.DuDt = DuDt + + if DFDt is None: + self.Unknowns.DFDt = Symbolic_DDt( + sympy.Matrix([[0] * self.mesh.dim]), + varsymbol=rf"{{F[ {self.u.symbol} ] }}", + theta=theta, + order=order, + ) + else: + self.Unknowns.DFDt = DFDt + + # --- Properties --- + + @property + def storage(self): + """Specific storage coefficient :math:`S_s`.""" + return self._storage + + @storage.setter + def storage(self, value): + self.is_setup = False + self._storage = sympy.sympify(value) + + @property + def delta_t(self): + """Current timestep.""" + return self._delta_t + + @delta_t.setter + def delta_t(self, value): + self.is_setup = False + if hasattr(value, "value"): + self._delta_t.sym = value.value + elif hasattr(value, "magnitude"): + self._delta_t.sym = value.magnitude + else: + self._delta_t.sym = value + + @property + def DuDt(self): + return self.Unknowns.DuDt + + @property + def DFDt(self): + return self.Unknowns.DFDt + + # --- Template expressions (override Darcy's steady-state Templates) --- + + @property + def F0(self): + """Pointwise storage + source: :math:`S_s \\dot{h} / \\Delta t - f`.""" + f0 = expression( + r"f_0(h)", + -self.f + self.storage * self.DuDt.bdf() / self.delta_t, + "Transient Darcy storage + source term", + ) + self._f0 = f0 + return f0 + + @property + def F1(self): + """Pointwise flux: Adams-Moulton time-weighted Darcy flux.""" + F1_val = expression( + r"\mathbf{F}_1(h)", + self.DFDt.adams_moulton_flux(), + "Transient Darcy flux (time-weighted)", + ) + self._f1 = F1_val + return F1_val + + # --- Timestep estimation --- + + @timing.routine_timer_decorator + def estimate_dt(self): + r""" + Estimate a stable timestep based on diffusive CFL. + + Returns + ------- + float or pint.Quantity + Diffusive timestep :math:`\delta t = (\Delta x)^2 / K_{\max}`. + """ + from mpi4py import MPI + + K = self.constitutive_model.K + + if isinstance(K, sympy.Expr) or hasattr(K, "sym"): + K_sym = K.sym if hasattr(K, "sym") else K + if uw.function.fn_is_constant_expr(K_sym): + diffusivity = uw.function.evaluate( + K_sym, np.zeros((1, self.mesh.dim)) + ) + else: + diffusivity = uw.function.evaluate( + sympy.sympify(K_sym), self.mesh._centroids, self.mesh.N + ) + diffusivity = diffusivity.max() + else: + diffusivity = K + + if hasattr(diffusivity, "units") and diffusivity.units is not None: + diffusivity = uw.non_dimensionalise(diffusivity) + elif hasattr(diffusivity, "magnitude"): + diffusivity = diffusivity.magnitude + + diffusivity = float(np.asarray(diffusivity).max()) + + comm = uw.mpi.comm + diffusivity_glob = comm.allreduce(diffusivity, op=MPI.MAX) + + min_dx = self.mesh.get_min_radius() + + if diffusivity_glob != 0.0: + dt_diff = (min_dx**2) / diffusivity_glob + else: + dt_diff = np.inf + + return _apply_unit_aware_scaling(np.squeeze(dt_diff), self.u, self.mesh) + + # --- Solve --- + + @timing.routine_timer_decorator + def solve( + self, + zero_init_guess: bool = True, + timestep=None, + _force_setup: bool = False, + verbose=False, + ): + r""" + Solve the transient Darcy system for one timestep. + + Parameters + ---------- + zero_init_guess : bool, optional + Start from zero initial guess (default True). + timestep : float, optional + Timestep size. Updates ``self.delta_t`` if provided. + _force_setup : bool, optional + Force re-setup of solver. + verbose : bool, optional + Print solver progress. + """ + if timestep is not None and timestep != self.delta_t: + self.delta_t = timestep + + if not self.constitutive_model._solver_is_setup: + self.is_setup = False + self.DFDt.psi_fn = self.constitutive_model.flux.T + + if not self.is_setup: + self._setup_pointwise_functions(verbose) + self._setup_discretisation(verbose) + self._setup_solver(verbose) + + # Pre-solve: update history terms + self.DuDt.update_pre_solve(timestep, verbose=verbose) + self.DFDt.update_pre_solve(timestep, verbose=verbose) + + # Solve PDE (bypass SNES_Darcy.solve to avoid double setup/projection) + SNES_Scalar.solve(self, zero_init_guess, _force_setup) + + # Invalidate cached data views + target_var = getattr(self.u, "_base_var", self.u) + if hasattr(target_var, "_canonical_data"): + target_var._canonical_data = None + + # Post-solve: shift history + self.DuDt.update_post_solve(timestep, verbose=verbose) + self.DFDt.update_post_solve(timestep, verbose=verbose) + + # Velocity projection (inherited from Darcy) + self._v_projector.uw_function = self.darcy_flux + self._v_projector.solve(zero_init_guess) + + self.is_setup = True + self.constitutive_model._solver_is_setup = True + + return + + +class SNES_Richards(SNES_TransientDarcy): + r""" + Richards equation solver for variably-saturated porous media flow. + + Two formulations are supported: + + **Mixed form** (mass-conservative, preferred) — set ``water_content``: + + .. math:: + + \frac{\partial \theta}{\partial t} + - \nabla \cdot \left[ K(\psi) (\nabla \psi - \mathbf{s}) \right] = f + + discretised as :math:`(\theta(\psi^{n+1}) - \theta(\psi^n)) / \Delta t`, + which is exactly conservative by construction (Celia et al., 1990). + + **Head-based form** (backward compatible) — set ``capacity``: + + .. math:: + + C(\psi) \frac{\partial \psi}{\partial t} + - \nabla \cdot \left[ K(\psi) (\nabla \psi - \mathbf{s}) \right] = f + + where :math:`C(\psi) = d\theta/d\psi` is the specific moisture capacity. + + Parameters + ---------- + mesh : Mesh + The computational mesh. + psi_Field : MeshVariable, optional + Mesh variable for pressure head :math:`\psi`. + v_Field : MeshVariable, optional + Mesh variable for Darcy velocity. + order : int, default=1 + Time integration order. + theta : float, default=0.5 + Implicit time weighting. + degree : int, default=2 + Polynomial degree. + verbose : bool, default=False + Enable verbose output. + DuDt : optional + Time derivative operator for the unknown. + DFDt : optional + Time derivative operator for the flux. + + Attributes + ---------- + water_content : sympy.Expr or None + Water content function :math:`\theta(\psi)` for the mixed form. + When set, the storage term uses + :math:`(\theta(\psi^{n+1}) - \theta(\psi^n)) / \Delta t`. + Takes precedence over ``capacity`` if both are set. + capacity : sympy.Expr + Specific moisture capacity :math:`C(\psi)` for the head-based form. + Used only when ``water_content`` is None. + psi : MeshVariable + Alias for ``self.u`` (pressure head). + + See Also + -------- + SNES_TransientDarcy : Linear parent solver. + underworld3.utilities.retention_curves : Van Genuchten and Gardner functions. + + Examples + -------- + Mixed form (preferred): + + >>> from underworld3.utilities.retention_curves import ( + ... van_genuchten_theta, van_genuchten_K, + ... ) + >>> richards = uw.systems.Richards(mesh, psi_Field=psi, v_Field=v) + >>> richards.constitutive_model = uw.constitutive_models.DarcyFlowModel + >>> richards.constitutive_model.Parameters.permeability = van_genuchten_K( + ... psi.sym[0], Ks=1e-4, alpha=3.35, n=2.0, + ... ) + >>> richards.water_content = van_genuchten_theta( + ... psi.sym[0], theta_r=0.045, theta_s=0.43, alpha=3.35, n=2.0, + ... ) + + Head-based form (backward compatible): + + >>> from underworld3.utilities.retention_curves import van_genuchten_C + >>> richards.capacity = van_genuchten_C( + ... psi.sym[0], theta_r=0.045, theta_s=0.43, alpha=3.35, n=2.0, + ... ) + """ + + @timing.routine_timer_decorator + def __init__( + self, + mesh: uw.discretisation.Mesh, + psi_Field: Optional[uw.discretisation.MeshVariable] = None, + v_Field: Optional[uw.discretisation.MeshVariable] = None, + order: int = 1, + theta: float = 0.5, + degree: int = 2, + verbose=False, + DuDt=None, + DFDt=None, + ): + super().__init__( + mesh, psi_Field, v_Field, order, theta, degree, verbose, DuDt, DFDt + ) + self._capacity = sympy.sympify(1) + self._water_content = None # None → head-based form; set → mixed form + + @property + def water_content(self): + r"""Water content function :math:`\theta(\psi)` for the mixed form. + + When set, the storage term uses + :math:`(\theta(\psi^{n+1}) - \theta(\psi^n)) / \Delta t` + instead of :math:`C(\psi) \cdot (\psi^{n+1} - \psi^n) / \Delta t`, + giving exact mass conservation (Celia et al., 1990). + + The expression should be a SymPy function of ``psi.sym[0]``. + The Jacobian :math:`\partial\theta/\partial\psi = C(\psi)` is + computed automatically by PETSc (finite-difference colouring), + so there is no need to provide :math:`C(\psi)` separately. + """ + return self._water_content + + @water_content.setter + def water_content(self, value): + self.is_setup = False + self._water_content = sympy.sympify(value) if value is not None else None + + @property + def capacity(self): + r"""Specific moisture capacity :math:`C(\psi) = d\theta/d\psi`. + + Used only when ``water_content`` is None (head-based form). + Typically a nonlinear SymPy expression depending on ``psi.sym[0]``. + """ + return self._capacity + + @capacity.setter + def capacity(self, value): + self.is_setup = False + self._capacity = sympy.sympify(value) + + @property + def psi(self): + """Alias for ``self.u`` (pressure head).""" + return self.u + + @property + def F0(self): + r"""Pointwise storage + source term. + + Mixed form: :math:`(\theta(\psi^{n+1}) - \theta(\psi^n)) / \Delta t - f` + + Head-based form: :math:`C(\psi) (\psi^{n+1} - \psi^n) / \Delta t - f` + """ + if self._water_content is not None: + # Mixed (mass-conservative) form: + # θ(ψ^{n+1}) is self._water_content (already in terms of psi.sym[0]) + # θ(ψ^n) is water_content with psi.sym[0] → psi_star[0].sym[0] + psi_sym = self.psi.sym[0] + psi_star_sym = self.DuDt.psi_star[0].sym[0] + theta_new = self._water_content + theta_old = self._water_content.subs(psi_sym, psi_star_sym) + storage_term = sympy.Matrix([[theta_new - theta_old]]) / self.delta_t + else: + # Head-based form (backward compatible) + storage_term = self.capacity * self.DuDt.bdf() / self.delta_t + + f0 = expression( + r"f_0(\psi)", + -self.f + storage_term, + "Richards storage + source term", + ) + self._f0 = f0 + return f0 + + ## -------------------------------- ## Stokes saddle point solver plus ## ancilliary functions - note that @@ -2393,7 +2844,7 @@ def F0(self): """Pointwise source term including time derivative.""" f0 = expression( r"f_0 \left( \mathbf{u} \right)", - -self.f + sympy.simplify(self.DuDt.bdf()) / self.delta_t, + -self.f + self.DuDt.bdf() / self.delta_t, "Diffusion pointwise force term: f_0(u)", ) @@ -2595,16 +3046,14 @@ def solve( super().solve(zero_init_guess, _force_setup) + # Invalidate cached data views - PETSc may have replaced underlying buffers + target_var = getattr(self.u, "_base_var", self.u) + if hasattr(target_var, "_canonical_data"): + target_var._canonical_data = None + self.DuDt.update_post_solve(timestep, evalf=evalf, verbose=verbose) self.DFDt.update_post_solve(timestep, evalf=evalf, verbose=verbose) - # if isinstance(self.DFDt, Eulerian_DDt): - # for i in range(order): - # ### have to substitute the unknown history term into the symbolic flux term - # self.DFDt.psi_star[i].subs({self.DuDt.psi_fn:self.DuDt.psi_star[i]}) - - # self._flux_star = self._flux.copy() - self.is_setup = True self.constitutive_model._solver_is_setup = True diff --git a/src/underworld3/utilities/__init__.py b/src/underworld3/utilities/__init__.py index eec5de72..495301e3 100644 --- a/src/underworld3/utilities/__init__.py +++ b/src/underworld3/utilities/__init__.py @@ -81,3 +81,5 @@ def _append_petsc_path(): ones_with_units, full_with_units, ) + +from . import retention_curves diff --git a/src/underworld3/utilities/_params.py b/src/underworld3/utilities/_params.py index 877c7bad..950c8eb1 100644 --- a/src/underworld3/utilities/_params.py +++ b/src/underworld3/utilities/_params.py @@ -14,30 +14,31 @@ - Python: params.uw_mesh_resolution - CLI: -uw_mesh_resolution 0.025 -Example usage: - # Define parameters at top of notebook/script +Recommended pattern: + Define default values as named constants BEFORE the Params block. + This makes defaults easy to find and adjust in a notebook, while + the Params block provides CLI override, units, and descriptions. + + # --- Default values (edit these in a notebook) --- + ETA_0 = 1e21 # Pa·s – reference viscosity + CELL_SIZE = 50.0 # km – mesh cell size + MAX_STEPS = 100 # solver iterations + params = uw.Params( - uw_mesh_resolution = 0.05, # Cell size for mesh - uw_diffusivity = 1.0, # Material property - uw_hot_temp = 100.0, # Boundary temperature + uw_viscosity = uw.Param(ETA_0, units="Pa*s", description="reference viscosity"), + uw_cell_size = uw.Param(CELL_SIZE, units="km", description="mesh cell size"), + uw_max_steps = MAX_STEPS, ) # Use in code: - mesh = uw.meshing.Box(cellSize=params.uw_mesh_resolution) + mesh = uw.meshing.Box(cellSize=params.uw_cell_size) # Override in notebook - just assign: - params.uw_mesh_resolution = 0.025 + params.uw_cell_size = uw.quantity(25, "km") # Override from command line (flag matches Python name): - # python script.py -uw_mesh_resolution 0.025 - # mpirun -np 4 python script.py -uw_diffusivity 2.0 - - # With units support: - params = uw.Params( - uw_cell_size = uw.Param(0.5, units="km", description="Mesh cell size"), - uw_viscosity = uw.Param(1e21, units="Pa*s"), - ) - # CLI: python script.py -uw_cell_size 500m -uw_viscosity "1e22 Pa*s" + # python script.py -uw_cell_size 25km -uw_viscosity "1e22 Pa*s" + # mpirun -np 4 python script.py -uw_cell_size 10km """ from enum import Enum diff --git a/src/underworld3/utilities/retention_curves.py b/src/underworld3/utilities/retention_curves.py new file mode 100644 index 00000000..af5cc813 --- /dev/null +++ b/src/underworld3/utilities/retention_curves.py @@ -0,0 +1,672 @@ +r""" +Retention curve functions for variably-saturated porous media flow. + +Provides retention curve functions that return SymPy expressions +suitable for use with the Richards equation solver: + +- **Van Genuchten--Mualem** model: general-purpose, widely used. +- **Gardner exponential** model: simpler, admits exact analytical + solutions for steady-state Richards equation with gravity. +- **Haverkamp** model: rational-function form with independent + parameters for retention and conductivity; used in the Vauclin + (1979) water-table recharge benchmark. + +All functions accept a SymPy symbol or expression for pressure head +(typically ``psi_field.sym[0]``) and return SymPy expressions that +can be assigned directly to solver properties. + +References +---------- +Van Genuchten, M. Th. (1980). A closed-form equation for predicting +the hydraulic conductivity of unsaturated soils. +*Soil Science Society of America Journal*, 44(5), 892--898. + +Mualem, Y. (1976). A new model for predicting the hydraulic +conductivity of unsaturated porous media. +*Water Resources Research*, 12(3), 513--522. + +Gardner, W. R. (1958). Some steady-state solutions of the +unsaturated moisture flow equation with application to evaporation +from a water table. *Soil Science*, 85(4), 228--232. + +Haverkamp, R. et al. (1977). A comparison of numerical simulation +models for one-dimensional infiltration. +*Soil Science Society of America Journal*, 41(2), 285--294. + +Examples +-------- +>>> import sympy +>>> from underworld3.utilities.retention_curves import ( +... van_genuchten_Se, van_genuchten_K, van_genuchten_C, +... ) +>>> psi = sympy.Symbol("psi") +>>> Se = van_genuchten_Se(psi, alpha=3.35, n=2.0) +>>> K = van_genuchten_K(psi, Ks=1e-4, alpha=3.35, n=2.0) +>>> C = van_genuchten_C(psi, theta_r=0.045, theta_s=0.43, alpha=3.35, n=2.0) + +Gardner model with analytical steady-state solution: + +>>> from underworld3.utilities.retention_curves import ( +... gardner_K, gardner_C, gardner_steady_state_psi, +... ) +>>> K = gardner_K(psi, Ks=1e-4, alpha=1.0) +>>> C = gardner_C(psi, theta_r=0.05, theta_s=0.4, alpha=1.0) + +Haverkamp model (Vauclin benchmark parameters): + +>>> from underworld3.utilities.retention_curves import ( +... haverkamp_theta, haverkamp_K, haverkamp_C, +... ) +>>> theta = haverkamp_theta(psi, theta_r=0.075, theta_s=0.287, +... alpha=1.611e6, beta=3.96) +>>> K = haverkamp_K(psi, Ks=9.44e-5, A=1.175e6, B=4.74) +""" + +import sympy + + +def van_genuchten_Se(psi, alpha, n, m=None): + r"""Effective saturation (Van Genuchten model). + + .. math:: + + S_e(\psi) = \begin{cases} + \left[1 + (\alpha |\psi|)^n\right]^{-m} & \psi < 0 \\ + 1 & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head (negative in unsaturated zone). + alpha : float + Inverse of the air-entry pressure [1/length]. + n : float + Pore-size distribution parameter (n > 1). + m : float, optional + Van Genuchten parameter. Default: ``1 - 1/n``. + + Returns + ------- + sympy.Piecewise + Effective saturation expression. + """ + if m is None: + m = 1 - 1 / sympy.Rational(n) if isinstance(n, int) else 1 - 1 / n + + alpha = sympy.sympify(alpha) + n = sympy.sympify(n) + m = sympy.sympify(m) + + Se_unsat = (1 + (alpha * (-psi)) ** n) ** (-m) + return sympy.Piecewise((sympy.S.One, psi >= 0), (Se_unsat, True)) + + +def van_genuchten_theta(psi, theta_r, theta_s, alpha, n, m=None): + r"""Volumetric water content (Van Genuchten model). + + .. math:: + + \theta(\psi) = \theta_r + (\theta_s - \theta_r)\, S_e(\psi) + + Parameters + ---------- + psi : sympy expression + Pressure head. + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + alpha : float + Inverse of the air-entry pressure [1/length]. + n : float + Pore-size distribution parameter. + m : float, optional + Default: ``1 - 1/n``. + + Returns + ------- + sympy.Expr + Water content expression. + """ + theta_r = sympy.sympify(theta_r) + theta_s = sympy.sympify(theta_s) + Se = van_genuchten_Se(psi, alpha, n, m) + return theta_r + (theta_s - theta_r) * Se + + +def van_genuchten_K(psi, Ks, alpha, n, m=None): + r"""Hydraulic conductivity (Van Genuchten–Mualem model). + + .. math:: + + K(\psi) = \begin{cases} + K_s \, S_e^{1/2} + \left[1 - \left(1 - S_e^{1/m}\right)^m\right]^2 + & \psi < 0 \\ + K_s & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head. + Ks : float + Saturated hydraulic conductivity. + alpha : float + Inverse of the air-entry pressure [1/length]. + n : float + Pore-size distribution parameter. + m : float, optional + Default: ``1 - 1/n``. + + Returns + ------- + sympy.Piecewise + Hydraulic conductivity expression. + """ + if m is None: + m = 1 - 1 / sympy.Rational(n) if isinstance(n, int) else 1 - 1 / n + + Ks = sympy.sympify(Ks) + m = sympy.sympify(m) + + Se = van_genuchten_Se(psi, alpha, n, m) + # For the unsaturated branch, extract the unsaturated Se expression + alpha_s = sympy.sympify(alpha) + n_s = sympy.sympify(n) + Se_expr = (1 + (alpha_s * (-psi)) ** n_s) ** (-m) + + K_unsat = Ks * Se_expr ** sympy.Rational(1, 2) * ( + 1 - (1 - Se_expr ** (1 / m)) ** m + ) ** 2 + + return sympy.Piecewise((Ks, psi >= 0), (K_unsat, True)) + + +def van_genuchten_C(psi, theta_r, theta_s, alpha, n, m=None, Ss=0.0): + r"""Specific moisture capacity (Van Genuchten model). + + .. math:: + + C(\psi) = \frac{d\theta}{d\psi} = \begin{cases} + \alpha\, m\, n\, (\theta_s - \theta_r)\, + (\alpha |\psi|)^{n-1}\, + \left[1 + (\alpha |\psi|)^n\right]^{-(m+1)} + & \psi < 0 \\ + S_s & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head. + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + alpha : float + Inverse of the air-entry pressure [1/length]. + n : float + Pore-size distribution parameter. + m : float, optional + Default: ``1 - 1/n``. + Ss : float, optional + Specific storage for the saturated zone (default 0). + Set to a small positive value (e.g. 1e-4) to avoid + a singular mass matrix when the domain is fully saturated. + + Returns + ------- + sympy.Piecewise + Specific moisture capacity expression. + """ + if m is None: + m = 1 - 1 / sympy.Rational(n) if isinstance(n, int) else 1 - 1 / n + + alpha = sympy.sympify(alpha) + n = sympy.sympify(n) + m = sympy.sympify(m) + theta_r = sympy.sympify(theta_r) + theta_s = sympy.sympify(theta_s) + Ss = sympy.sympify(Ss) + + C_unsat = ( + alpha + * m + * n + * (theta_s - theta_r) + * (alpha * (-psi)) ** (n - 1) + * (1 + (alpha * (-psi)) ** n) ** (-(m + 1)) + ) + + return sympy.Piecewise((Ss, psi >= 0), (C_unsat, True)) + + +# ===================================================================== +# Gardner exponential model +# ===================================================================== + + +def gardner_K(psi, Ks, alpha): + r"""Hydraulic conductivity (Gardner exponential model). + + .. math:: + + K(\psi) = \begin{cases} + K_s \exp(\alpha\,\psi) & \psi < 0 \\ + K_s & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head (negative in unsaturated zone). + Ks : float + Saturated hydraulic conductivity. + alpha : float + Sorptive number [1/length]. Larger values give a + sharper transition near saturation. + + Returns + ------- + sympy.Piecewise + Hydraulic conductivity expression. + """ + Ks = sympy.sympify(Ks) + alpha = sympy.sympify(alpha) + + K_unsat = Ks * sympy.exp(alpha * psi) + return sympy.Piecewise((Ks, psi >= 0), (K_unsat, True)) + + +def gardner_theta(psi, theta_r, theta_s, alpha): + r"""Volumetric water content (Gardner exponential model). + + .. math:: + + \theta(\psi) = \begin{cases} + \theta_r + (\theta_s - \theta_r)\,\exp(\alpha\,\psi) + & \psi < 0 \\ + \theta_s & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head. + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + alpha : float + Sorptive number [1/length]. + + Returns + ------- + sympy.Piecewise + Water content expression. + """ + theta_r = sympy.sympify(theta_r) + theta_s = sympy.sympify(theta_s) + alpha = sympy.sympify(alpha) + + theta_unsat = theta_r + (theta_s - theta_r) * sympy.exp(alpha * psi) + return sympy.Piecewise((theta_s, psi >= 0), (theta_unsat, True)) + + +def gardner_C(psi, theta_r, theta_s, alpha, Ss=0.0): + r"""Specific moisture capacity (Gardner exponential model). + + .. math:: + + C(\psi) = \frac{d\theta}{d\psi} = \begin{cases} + \alpha\,(\theta_s - \theta_r)\,\exp(\alpha\,\psi) + & \psi < 0 \\ + S_s & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head. + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + alpha : float + Sorptive number [1/length]. + Ss : float, optional + Specific storage for the saturated zone (default 0). + + Returns + ------- + sympy.Piecewise + Specific moisture capacity expression. + """ + theta_r = sympy.sympify(theta_r) + theta_s = sympy.sympify(theta_s) + alpha = sympy.sympify(alpha) + Ss = sympy.sympify(Ss) + + C_unsat = alpha * (theta_s - theta_r) * sympy.exp(alpha * psi) + return sympy.Piecewise((Ss, psi >= 0), (C_unsat, True)) + + +def gardner_steady_state_psi(y, psi_0, psi_L, L, alpha): + r"""Analytical steady-state pressure head for Gardner model with gravity. + + For a 1D vertical column of height *L* with the Gardner conductivity + model, steady-state Richards equation with gravity reduces to + + .. math:: + + K(\psi)\left(\frac{d\psi}{dy} + 1\right) = q = \text{const} + + The substitution :math:`u = \exp(\alpha\psi)` linearises the ODE. + The exact solution with boundary conditions + :math:`\psi(0)=\psi_0` (bottom) and :math:`\psi(L)=\psi_L` (top) is + + .. math:: + + \psi(y) = \frac{1}{\alpha}\,\ln\!\Bigl[ + \bigl(u_0 - q^*\bigr)\,e^{-\alpha y} + q^* + \Bigr] + + where :math:`u_0 = e^{\alpha\psi_0}`, + :math:`u_L = e^{\alpha\psi_L}`, and + + .. math:: + + q^* \equiv \frac{q}{K_s} + = \frac{u_L - u_0\,e^{-\alpha L}}{1 - e^{-\alpha L}} + + Parameters + ---------- + y : float or array + Vertical coordinate (0 = bottom, *L* = top). + psi_0 : float + Pressure head at the bottom boundary. + psi_L : float + Pressure head at the top boundary. + L : float + Column height. + alpha : float + Gardner sorptive number [1/length]. + + Returns + ------- + float or array + Exact pressure head profile :math:`\psi(y)`. + + Notes + ----- + This is a *numpy* function (not sympy) intended for comparing + numerical solutions against the analytical benchmark. + """ + import numpy as np + + u_0 = np.exp(alpha * psi_0) + u_L = np.exp(alpha * psi_L) + + # Normalised steady-state flux q* = q / Ks + q_star = (u_L - u_0 * np.exp(-alpha * L)) / (1.0 - np.exp(-alpha * L)) + + return (1.0 / alpha) * np.log((u_0 - q_star) * np.exp(-alpha * y) + q_star) + + +def gardner_transient_psi(y, t, psi_dry, psi_wet, L, Ks, alpha, theta_r, theta_s): + r"""Analytical transient wetting-front solution for Gardner model. + + Applies the **Ogata–Banks** (1961) solution to Richards equation + with Gardner conductivity in a vertical column of height *L*. + + The substitution :math:`u = \exp(\alpha\psi)` transforms the + nonlinear Richards equation into linear advection–diffusion: + + .. math:: + + \frac{\partial u}{\partial t} + = D\,\frac{\partial^2 u}{\partial z^2} + + V\,\frac{\partial u}{\partial z} + + where :math:`z = L - y` (depth from the top), + :math:`D = K_s / (\alpha\,\Delta\theta)`, + :math:`V = K_s / \Delta\theta`, and + :math:`\Delta\theta = \theta_s - \theta_r`. + + With a **step change** at the top (:math:`z = 0`) from dry to wet + and a semi-infinite column approximation, the Ogata–Banks solution + gives + + .. math:: + + u(z, t) = u_{\rm dry} + + (u_{\rm wet} - u_{\rm dry})\,H(z, t) + + where + + .. math:: + + H(z, t) = \tfrac{1}{2}\,\operatorname{erfc}\!\left( + \frac{z - Vt}{2\sqrt{Dt}}\right) + + \tfrac{1}{2}\,\exp\!\left(\frac{Vz}{D}\right)\, + \operatorname{erfc}\!\left(\frac{z + Vt}{2\sqrt{Dt}}\right) + + Finally, :math:`\psi(y, t) = \ln(u) / \alpha`. + + Parameters + ---------- + y : float or array + Vertical coordinate (0 = bottom, *L* = top). + t : float + Time since the wet boundary was applied (must be > 0). + psi_dry : float + Initial (dry) pressure head throughout the column. + psi_wet : float + Pressure head imposed at the top boundary. + L : float + Column height. + Ks : float + Saturated hydraulic conductivity. + alpha : float + Gardner sorptive number [1/length]. + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + + Returns + ------- + float or array + Pressure head profile :math:`\psi(y, t)`. + + Notes + ----- + This is a *numpy* function (not sympy) intended for comparing + numerical solutions against the analytical benchmark. + + The semi-infinite approximation is excellent when the wetting + front has not yet reached the bottom boundary. + + References + ---------- + Ogata, A. and Banks, R. B. (1961). A solution of the differential + equation of longitudinal dispersion in porous media. + *US Geological Survey Professional Paper* 411-A. + """ + import numpy as np + from scipy.special import erfc + + delta_theta = theta_s - theta_r + D = Ks / (alpha * delta_theta) + V = Ks / delta_theta + + u_dry = np.exp(alpha * psi_dry) + u_wet = np.exp(alpha * psi_wet) + + # Depth from the top (z = 0 at top, z = L at bottom) + z = L - np.asarray(y, dtype=float) + + sqrt_Dt = np.sqrt(D * t) + + # Ogata-Banks solution + H = ( + 0.5 * erfc((z - V * t) / (2.0 * sqrt_Dt)) + + 0.5 * np.exp(V * z / D) * erfc((z + V * t) / (2.0 * sqrt_Dt)) + ) + + u = u_dry + (u_wet - u_dry) * H + + return (1.0 / alpha) * np.log(np.maximum(u, 1e-30)) + + +# ===================================================================== +# Haverkamp model +# ===================================================================== + + +def haverkamp_theta(psi, theta_r, theta_s, alpha, beta): + r"""Volumetric water content (Haverkamp model). + + .. math:: + + \theta(\psi) = \begin{cases} + \theta_r + \dfrac{\alpha\,(\theta_s - \theta_r)} + {\alpha + |\psi|^{\beta}} + & \psi < 0 \\[6pt] + \theta_s & \psi \ge 0 + \end{cases} + + Unlike Van Genuchten, the retention and conductivity curves have + **independent** parameters, which gives extra flexibility when + fitting laboratory data. + + Parameters + ---------- + psi : sympy expression + Pressure head (negative in unsaturated zone). + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + alpha : float + Retention shape parameter (dimensionless or [length]^beta, + depending on convention). + beta : float + Retention exponent. + + Returns + ------- + sympy.Piecewise + Water content expression. + + References + ---------- + Haverkamp, R. et al. (1977). A comparison of numerical simulation + models for one-dimensional infiltration. + *Soil Science Society of America Journal*, 41(2), 285--294. + """ + theta_r = sympy.sympify(theta_r) + theta_s = sympy.sympify(theta_s) + alpha = sympy.sympify(alpha) + beta = sympy.sympify(beta) + + theta_unsat = theta_r + alpha * (theta_s - theta_r) / (alpha + (-psi) ** beta) + return sympy.Piecewise((theta_s, psi >= 0), (theta_unsat, True)) + + +def haverkamp_K(psi, Ks, A, B): + r"""Hydraulic conductivity (Haverkamp model). + + .. math:: + + K(\psi) = \begin{cases} + K_s\,\dfrac{A}{A + |\psi|^B} & \psi < 0 \\[6pt] + K_s & \psi \ge 0 + \end{cases} + + The conductivity parameters *A* and *B* are independent of the + retention parameters *alpha* and *beta*. + + Parameters + ---------- + psi : sympy expression + Pressure head (negative in unsaturated zone). + Ks : float + Saturated hydraulic conductivity. + A : float + Conductivity shape parameter. + B : float + Conductivity exponent. + + Returns + ------- + sympy.Piecewise + Hydraulic conductivity expression. + + References + ---------- + Haverkamp, R. et al. (1977). A comparison of numerical simulation + models for one-dimensional infiltration. + *Soil Science Society of America Journal*, 41(2), 285--294. + """ + Ks = sympy.sympify(Ks) + A = sympy.sympify(A) + B = sympy.sympify(B) + + K_unsat = Ks * A / (A + (-psi) ** B) + return sympy.Piecewise((Ks, psi >= 0), (K_unsat, True)) + + +def haverkamp_C(psi, theta_r, theta_s, alpha, beta, Ss=0.0): + r"""Specific moisture capacity (Haverkamp model). + + .. math:: + + C(\psi) = \frac{d\theta}{d\psi} = \begin{cases} + \dfrac{\alpha\,\beta\,(\theta_s - \theta_r)\,|\psi|^{\beta - 1}} + {\bigl(\alpha + |\psi|^{\beta}\bigr)^2} + & \psi < 0 \\[6pt] + S_s & \psi \ge 0 + \end{cases} + + Parameters + ---------- + psi : sympy expression + Pressure head. + theta_r : float + Residual water content. + theta_s : float + Saturated water content. + alpha : float + Retention shape parameter. + beta : float + Retention exponent. + Ss : float, optional + Specific storage for the saturated zone (default 0). + + Returns + ------- + sympy.Piecewise + Specific moisture capacity expression. + + References + ---------- + Haverkamp, R. et al. (1977). A comparison of numerical simulation + models for one-dimensional infiltration. + *Soil Science Society of America Journal*, 41(2), 285--294. + """ + theta_r = sympy.sympify(theta_r) + theta_s = sympy.sympify(theta_s) + alpha = sympy.sympify(alpha) + beta = sympy.sympify(beta) + Ss = sympy.sympify(Ss) + + abs_psi = -psi # psi < 0, so |psi| = -psi + C_unsat = ( + alpha * beta * (theta_s - theta_r) * abs_psi ** (beta - 1) + / (alpha + abs_psi ** beta) ** 2 + ) + + return sympy.Piecewise((Ss, psi >= 0), (C_unsat, True)) diff --git a/tests/test_1005_TransientDarcyCartesian.py b/tests/test_1005_TransientDarcyCartesian.py new file mode 100644 index 00000000..d7ca122f --- /dev/null +++ b/tests/test_1005_TransientDarcyCartesian.py @@ -0,0 +1,116 @@ +# %% +# Test transient Darcy flow solver against analytical diffusion solution. +# +# A 1D vertical column with constant K and constant S_s reduces to +# simple diffusion: S_s dh/dt = K d²h/dy² +# With step-change BC at the top (h=1) and fixed h=0 at the bottom, +# the analytical solution is an error-function diffusion profile. + +import underworld3 as uw +import numpy as np +import sympy as sp +import pytest + +# Physics solver tests +pytestmark = pytest.mark.level_3 + + +@pytest.fixture(autouse=True) +def reset_model_state(): + """Reset model state before each test.""" + uw.reset_default_model() + uw.use_strict_units(False) + uw.use_nondimensional_scaling(False) + yield + uw.reset_default_model() + uw.use_strict_units(False) + uw.use_nondimensional_scaling(False) + + +# Domain parameters +res = 32 +minX, maxX = 0.0, 0.1 # narrow to make it effectively 1D +minY, maxY = 0.0, 1.0 + +# Physical parameters +K_val = 1.0 # hydraulic conductivity +Ss_val = 1.0 # specific storage → diffusivity D = K/Ss = 1 + +t_start = 0.005 # small offset so erf profile is resolved +t_end = 0.02 + + +def create_mesh(): + return uw.meshing.StructuredQuadBox( + elementRes=(4, res), + minCoords=(minX, minY), + maxCoords=(maxX, maxY), + qdegree=3, + ) + + +# Analytical solution: step-change diffusion in a semi-infinite column +# h(y,t) = erfc(y / (2 sqrt(D t))) where D = K/Ss +# with h(0,t) = 1, h(inf,t) = 0 +y_sym, t_sym = sp.symbols("y t", positive=True) +D_val = K_val / Ss_val +h_analytic = sp.erfc(y_sym / (2 * sp.sqrt(D_val * t_sym))) + + +def test_transient_darcy_diffusion(): + """Transient Darcy with constant K and S_s should match 1D diffusion.""" + mesh = create_mesh() + + h_soln = uw.discretisation.MeshVariable("h", mesh, 1, degree=2) + v_soln = uw.discretisation.MeshVariable("v", mesh, mesh.dim, degree=1) + + darcy = uw.systems.TransientDarcy( + mesh, h_soln, v_soln, order=1, theta=0.5, + ) + darcy.petsc_options.delValue("ksp_monitor") + darcy.petsc_options["snes_rtol"] = 1.0e-6 + + darcy.constitutive_model = uw.constitutive_models.DarcyFlowModel + darcy.constitutive_model.Parameters.permeability = K_val + darcy.constitutive_model.Parameters.s = sp.Matrix([0, 0]).T # no gravity + darcy.storage = Ss_val + darcy.f = 0.0 + + # BCs: h=1 at bottom (y=0), h=0 at top (y=1) + darcy.add_dirichlet_bc([1.0], "Bottom") + darcy.add_dirichlet_bc([0.0], "Top") + + darcy._v_projector.petsc_options["snes_rtol"] = 1.0e-6 + darcy._v_projector.smoothing = 1.0e-6 + + # Initial condition: analytical profile at t_start + h_init = h_analytic.subs(t_sym, t_start) + h_init_fn = h_init.subs(y_sym, mesh.X[1]) + h_soln.array = uw.function.evaluate(h_init_fn, h_soln.coords) + + # Time-step + dt = darcy.estimate_dt() + # Cap dt so we take a few steps + dt = min(dt, (t_end - t_start) / 4) + model_time = t_start + + while model_time < t_end: + if model_time + dt > t_end: + dt = t_end - model_time + darcy.solve(timestep=dt) + model_time += dt + + # Compare along a vertical profile at x = midpoint + n_sample = 50 + sample_y = np.linspace(0.05, 0.95, n_sample) + sample_x = np.full_like(sample_y, 0.5 * (minX + maxX)) + sample_pts = np.column_stack([sample_x, sample_y]) + + h_numerical = uw.function.evaluate(h_soln.sym[0], sample_pts).squeeze() + + h_exact_fn = h_analytic.subs(t_sym, t_end).subs(y_sym, mesh.X[1]) + h_exact = uw.function.evaluate(h_exact_fn, sample_pts).squeeze() + + assert np.allclose(h_numerical, h_exact, atol=0.1), ( + f"Max error: {np.max(np.abs(h_numerical - h_exact)):.4f}" + ) diff --git a/tests/test_1006_RichardsCartesian.py b/tests/test_1006_RichardsCartesian.py new file mode 100644 index 00000000..9d126c45 --- /dev/null +++ b/tests/test_1006_RichardsCartesian.py @@ -0,0 +1,267 @@ +# %% +# Tests for the Richards equation solver. +# +# Test 1: Steady-state drainage with constant K (linear profile). +# Test 2: Transient infiltration with Van Genuchten retention curves. + +import underworld3 as uw +import numpy as np +import sympy as sp +import pytest + +# Physics solver tests +pytestmark = pytest.mark.level_3 + + +@pytest.fixture(autouse=True) +def reset_model_state(): + """Reset model state before each test.""" + uw.reset_default_model() + uw.use_strict_units(False) + uw.use_nondimensional_scaling(False) + yield + uw.reset_default_model() + uw.use_strict_units(False) + uw.use_nondimensional_scaling(False) + + +# --- Domain --- +res = 32 +minX, maxX = 0.0, 0.1 # narrow → effectively 1D +minY, maxY = 0.0, 1.0 + + +def create_mesh(): + return uw.meshing.StructuredQuadBox( + elementRes=(4, res), + minCoords=(minX, minY), + maxCoords=(maxX, maxY), + qdegree=3, + ) + + +def test_richards_steady_constant_K(): + """Richards with constant K and C=1 should give a linear pressure head profile. + + With constant K and gravity s=[0,-1], the steady-state solution of + -∇·[K(∇ψ - s)] = 0 + in 1D (y-direction) with ψ(0)=-5, ψ(1)=0 is: + ψ(y) = -5(1 - y) (linear) + + We use TransientDarcy stepping with small dt to approach steady state, + since Richards inherits from TransientDarcy. + """ + mesh = create_mesh() + + psi = uw.discretisation.MeshVariable("psi", mesh, 1, degree=2) + v_soln = uw.discretisation.MeshVariable("v", mesh, mesh.dim, degree=1) + + richards = uw.systems.Richards(mesh, psi, v_soln, order=1, theta=0.5) + richards.petsc_options.delValue("ksp_monitor") + richards.petsc_options["snes_rtol"] = 1.0e-6 + + K_val = 1.0 + richards.constitutive_model = uw.constitutive_models.DarcyFlowModel + richards.constitutive_model.Parameters.permeability = K_val + richards.constitutive_model.Parameters.s = sp.Matrix([0, -1]).T + richards.capacity = 1 # constant → behaves like TransientDarcy + richards.f = 0.0 + + # BCs: ψ = 0 at top (y=1), ψ = -5 at bottom (y=0) + richards.add_dirichlet_bc([0.0], "Top") + richards.add_dirichlet_bc([-5.0], "Bottom") + + richards._v_projector.petsc_options["snes_rtol"] = 1.0e-6 + richards._v_projector.smoothing = 1.0e-6 + + # Initial guess: linear profile + y = mesh.X[1] + psi_init = -5.0 * (1.0 - y) + psi.array = uw.function.evaluate(psi_init, psi.coords) + + # Step towards steady state with a few large timesteps + dt = 0.1 + for _ in range(10): + richards.solve(timestep=dt) + + # Check along vertical profile + n_sample = 50 + sample_y = np.linspace(0.05, 0.95, n_sample) + sample_x = np.full_like(sample_y, 0.5 * (minX + maxX)) + sample_pts = np.column_stack([sample_x, sample_y]) + + psi_numerical = uw.function.evaluate(psi.sym[0], sample_pts).squeeze() + psi_exact = -5.0 * (1.0 - sample_y) + + assert np.allclose(psi_numerical, psi_exact, atol=0.1), ( + f"Max error: {np.max(np.abs(psi_numerical - psi_exact)):.4f}" + ) + + +def test_richards_transient_infiltration(): + """Richards equation with Van Genuchten curves — basic sanity check. + + Uses a mild initial condition (ψ = -2) with saturated top (ψ = 0) + and fixed bottom (ψ = -2). After several timesteps the wetting + front should propagate downward, making the upper column wetter + (less negative ψ) than the initial state. + + Note: Richards with VG curves is a stiff nonlinear problem. + We use moderate conditions to ensure reliable SNES convergence. + """ + from underworld3.utilities.retention_curves import ( + van_genuchten_K, + van_genuchten_theta, + ) + + mesh = create_mesh() + + psi = uw.discretisation.MeshVariable("psi", mesh, 1, degree=2) + v_soln = uw.discretisation.MeshVariable("v", mesh, mesh.dim, degree=1) + + richards = uw.systems.Richards(mesh, psi, v_soln, order=1, theta=0.5) + richards.petsc_options.delValue("ksp_monitor") + richards.petsc_options["snes_rtol"] = 1.0e-6 + richards.petsc_options["snes_max_it"] = 50 + richards.petsc_options["snes_linesearch_type"] = "bt" + + # Loam-like Van Genuchten parameters (less stiff than sand) + alpha_vg = 1.0 + n_vg = 1.5 + theta_r = 0.08 + theta_s = 0.43 + Ks = 1.0 + + psi_sym = psi.sym[0] + + richards.constitutive_model = uw.constitutive_models.DarcyFlowModel + richards.constitutive_model.Parameters.permeability = van_genuchten_K( + psi_sym, Ks=Ks, alpha=alpha_vg, n=n_vg + ) + richards.constitutive_model.Parameters.s = sp.Matrix([0, -1]).T + + # Mixed form: θ(ψ) for mass-conservative storage term + richards.water_content = van_genuchten_theta( + psi_sym, theta_r=theta_r, theta_s=theta_s, + alpha=alpha_vg, n=n_vg, + ) + richards.f = 0.0 + + # BCs: saturated at top, moderately dry at bottom + richards.add_dirichlet_bc([0.0], "Top") + richards.add_dirichlet_bc([-2.0], "Bottom") + + richards._v_projector.petsc_options["snes_rtol"] = 1.0e-6 + richards._v_projector.smoothing = 1.0e-6 + + # Initial condition: linear profile from -2 at bottom to 0 at top + # (smooth start helps SNES converge) + y = mesh.X[1] + psi_init = -2.0 * (1.0 - y) + psi.array = uw.function.evaluate(psi_init, psi.coords) + + # Run a few timesteps with small dt + dt = 0.005 + n_steps = 5 + for step in range(n_steps): + richards.solve(timestep=dt) + + # Basic sanity checks along a vertical profile + n_sample = 20 + sample_y = np.linspace(0.1, 0.9, n_sample) + sample_x = np.full_like(sample_y, 0.5 * (minX + maxX)) + sample_pts = np.column_stack([sample_x, sample_y]) + + psi_vals = uw.function.evaluate(psi.sym[0], sample_pts).squeeze() + + # 1. Solution should be bounded (no blow-up) + assert np.all(np.isfinite(psi_vals)), "Solution should be finite" + assert np.all(psi_vals >= -5.0), "ψ should not overshoot far below BCs" + assert np.all(psi_vals <= 1.0), "ψ should not overshoot far above BCs" + + # 2. Near the top should be wetter (less negative) than near the bottom + assert psi_vals[-1] >= psi_vals[0], ( + "Pressure head should increase towards the wetted top" + ) + + +def test_richards_gardner_analytical(): + """Richards with Gardner model — validate against exact analytical solution. + + The Gardner exponential conductivity K(ψ) = Ks·exp(α·ψ) admits an + exact steady-state solution for 1D vertical drainage with gravity. + This test converges the solver to steady state and compares against + the analytical profile. + """ + from underworld3.utilities.retention_curves import ( + gardner_K, + gardner_theta, + gardner_steady_state_psi, + ) + + mesh = create_mesh() + + psi = uw.discretisation.MeshVariable("psi", mesh, 1, degree=2) + v_soln = uw.discretisation.MeshVariable("v", mesh, mesh.dim, degree=1) + + richards = uw.systems.Richards(mesh, psi, v_soln, order=1, theta=0.5) + richards.petsc_options.delValue("ksp_monitor") + richards.petsc_options["snes_rtol"] = 1.0e-6 + + # Gardner parameters + Ks = 1.0 + alpha_g = 2.0 + psi_bottom = -3.0 + psi_top = -0.5 + + psi_sym = psi.sym[0] + + richards.constitutive_model = uw.constitutive_models.DarcyFlowModel + richards.constitutive_model.Parameters.permeability = gardner_K( + psi_sym, Ks=Ks, alpha=alpha_g + ) + richards.constitutive_model.Parameters.s = sp.Matrix([0, -1]).T + + # Mixed form: θ(ψ) for mass-conservative storage term + richards.water_content = gardner_theta( + psi_sym, theta_r=0.05, theta_s=0.4, alpha=alpha_g, + ) + richards.f = 0.0 + + # BCs + richards.add_dirichlet_bc([psi_top], "Top") + richards.add_dirichlet_bc([psi_bottom], "Bottom") + + richards._v_projector.petsc_options["snes_rtol"] = 1.0e-6 + richards._v_projector.smoothing = 1.0e-6 + + # Initial guess: linear profile (close enough for SNES) + y = mesh.X[1] + psi_init = psi_bottom + (psi_top - psi_bottom) * y + psi.array = uw.function.evaluate(psi_init, psi.coords) + + # Step towards steady state + dt = 0.1 + for _ in range(20): + richards.solve(timestep=dt) + + # Compare along vertical profile + n_sample = 50 + sample_y = np.linspace(0.05, 0.95, n_sample) + sample_x = np.full_like(sample_y, 0.5 * (minX + maxX)) + sample_pts = np.column_stack([sample_x, sample_y]) + + psi_numerical = uw.function.evaluate(psi.sym[0], sample_pts).squeeze() + psi_exact = gardner_steady_state_psi( + sample_y, psi_0=psi_bottom, psi_L=psi_top, + L=maxY - minY, alpha=alpha_g, + ) + + max_err = np.max(np.abs(psi_numerical - psi_exact)) + assert np.allclose(psi_numerical, psi_exact, atol=0.05), ( + f"Gardner analytical benchmark failed: max error = {max_err:.4f}" + ) + + +if uw.is_notebook(): + test_richards_steady_constant_K()