From 6b10c1fdc7b686641fd2f0518f7a2bbfaf5c23d7 Mon Sep 17 00:00:00 2001
From: thanojo <86444011+thanojo@users.noreply.github.com>
Date: Thu, 4 Jun 2026 23:24:46 +0800
Subject: [PATCH 1/6] feat(eim): implement variational effective-index method
 for 2D FDTD #156

---
 src/gsim/meep/eim.py | 281 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 281 insertions(+)
 create mode 100644 src/gsim/meep/eim.py

diff --git a/src/gsim/meep/eim.py b/src/gsim/meep/eim.py
new file mode 100644
index 00000000..0cfe21f7
--- /dev/null
+++ b/src/gsim/meep/eim.py
@@ -0,0 +1,281 @@
+"""Variational effective-index method (varEIM) for 2D FDTD.
+
+Computes a spatially-varying effective permittivity from a 3D layer stack,
+weighted by the vertical slab-mode intensity, so that a 2D (z-collapsed)
+simulation reproduces the vertical confinement that bulk-index substitution
+ignores.
+
+The effective permittivity at a lateral point ``(x, y)`` relative to a fixed
+reference point ``r`` is (Hammer & Ivanova 2009):
+
+    eps_eff(x, y) = n_eff^2(r)
+                    + integral[ (eps(x,y,z) - eps(r,z)) * |Phi_r(z)|^2 dz ]
+                      / integral[ |Phi_r(z)|^2 dz ]
+
+where ``n_eff(r)`` and ``Phi_r(z)`` are the effective index and field profile of
+the fundamental TE vertical slab mode at the reference point. In the core region
+the perturbation vanishes (``eps_eff = n_eff^2``); in the cladding it is
+``n_eff^2`` reduced by a mode-weighted average, giving the physically correct
+(reduced) lateral index contrast.
+
+This implementation is TE-only and uses a single reference mode, so it is valid
+only where the vertical mode profile is consistent across the device (strips,
+rings, MMIs). It breaks down for mode-converting transitions (e.g.
+strip-to-slot).
+
+Reference:
+    H. J. W. M. Hammer and O. V. Ivanova, "Effective index approximations of
+    photonic crystal slabs: a 2-to-1-D assessment," Opt. Quant. Electron. 41,
+    267 (2009).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from gsim.common.cross_section import _layer_shapely_polys
+from gsim.common.stack.materials import resolve_material_at_wavelength
+
+if TYPE_CHECKING:
+    import gdsfactory as gf
+
+    from gsim.common.stack import LayerStack
+
+logger = logging.getLogger(__name__)
+
+
+def build_eps_z(
+    component: gf.Component,
+    layer_stack: LayerStack,
+    x: float,
+    y: float,
+    wavelength_um: float,
+    *,
+    nz: int = 400,
+    z_range: tuple[float, float] | None = None,
+    background_material: str = "air",
+) -> tuple[np.ndarray, np.ndarray]:
+    """Build the 1D vertical permittivity profile eps(z) at lateral point (x, y).
+
+    Samples the layer stack along z at a fixed ``(x, y)``: dielectrics provide
+    the background (cladding/box/substrate), patterned layers override the
+    background wherever their polygons cover the point. Where two patterned
+    layers overlap in z (e.g. core and slab), the higher-permittivity material
+    wins, matching gsim's "highest-index = core" convention.
+
+    Args:
+        component: gdsfactory Component (may contain references).
+        layer_stack: LayerStack describing layers and dielectrics.
+        x: Lateral X coordinate of the vertical cut (um).
+        y: Lateral Y coordinate of the vertical cut (um).
+        wavelength_um: Wavelength for material index lookup (um).
+        nz: Number of z samples (cell centers).
+        z_range: (zmin, zmax) for the cut. Defaults to ``layer_stack.get_z_range()``.
+        background_material: Material name for z samples not covered by any
+            dielectric or layer (typically the top air region).
+
+    Returns:
+        (z_grid, eps_z): the z sample coordinates (um) and permittivity at each.
+    """
+    from shapely.geometry import Point
+    from shapely.ops import unary_union
+
+    # get_polygons(merge=True) mutates, which is disabled on locked cached
+    # cells; work on an unlocked copy.
+    if getattr(component, "locked", False):
+        component = component.copy()
+
+    z_lo, z_hi = z_range if z_range is not None else layer_stack.get_z_range()
+    dz = (z_hi - z_lo) / nz
+    z_grid = z_lo + (np.arange(nz) + 0.5) * dz
+
+    eps_cache: dict[str, float] = {}
+
+    def eps_of(material: str) -> float:
+        if material not in eps_cache:
+            resolved = resolve_material_at_wavelength(material, wavelength_um)
+            eps = None if resolved is None else resolved.permittivity_scalar
+            eps_cache[material] = float(eps) if eps is not None else 1.0
+        return eps_cache[material]
+
+    # Background pass: fill from dielectrics, fall back to background_material.
+    eps_z = np.full(nz, eps_of(background_material), dtype=float)
+    for d in sorted(layer_stack.dielectrics, key=lambda d: d["zmin"]):
+        band = (z_grid >= d["zmin"]) & (z_grid < d["zmax"])
+        eps_z[band] = eps_of(d["material"])
+
+    # Coverage pass: patterned layers override the background where they cover
+    # (x, y); on overlapping z bands the higher-permittivity layer wins.
+    pt = Point(x, y)
+    dbu = getattr(getattr(component, "kcl", None), "dbu", 0.001)
+    for layer in layer_stack.layers.values():
+        gds_layer = getattr(layer, "gds_layer", None)
+        if gds_layer is None:
+            continue
+        gds_layer_tuple = (int(gds_layer[0]), int(gds_layer[1]))
+        polys = _layer_shapely_polys(component, gds_layer_tuple, dbu)
+        if not polys:
+            continue
+        if not unary_union(polys).covers(pt):
+            continue
+        eps_layer = eps_of(layer.material)
+        band = (z_grid >= layer.zmin) & (z_grid < layer.zmax)
+        eps_z[band] = np.maximum(eps_z[band], eps_layer)
+
+    return z_grid, eps_z
+
+
+def solve_slab_mode(
+    z_grid: np.ndarray,
+    eps_z: np.ndarray,
+    wavelength_um: float,
+) -> tuple[float, np.ndarray]:
+    """Solve the fundamental TE vertical slab mode of a 1D permittivity profile.
+
+    Solves the 1D Helmholtz eigenproblem on a uniform z grid::
+
+        d^2 Phi / dz^2 + k0^2 eps(z) Phi = k0^2 n_eff^2 Phi
+
+    with Dirichlet boundaries (Phi -> 0 at the domain edges). The largest
+    eigenvalue is ``n_eff^2`` and its eigenvector is the field profile ``Phi``.
+
+    Args:
+        z_grid: Uniform z sample coordinates (um).
+        eps_z: Permittivity at each z sample.
+        wavelength_um: Wavelength (um).
+
+    Returns:
+        (n_eff, Phi): effective index and the (L2-normalized) field profile,
+        sampled on ``z_grid``.
+    """
+    from scipy.linalg import eigh_tridiagonal
+
+    dz = float(z_grid[1] - z_grid[0])
+    k0 = 2.0 * np.pi / wavelength_um
+
+    # A = (1/k0^2) D2 + diag(eps), with D2 the standard 2nd-derivative stencil.
+    off = (1.0 / k0**2) * (1.0 / dz**2) * np.ones(len(z_grid) - 1)
+    diag = (1.0 / k0**2) * (-2.0 / dz**2) + eps_z
+
+    # Fundamental mode = largest eigenvalue (= n_eff^2).
+    n = len(z_grid)
+    eigvals, eigvecs = eigh_tridiagonal(
+        diag, off, select="i", select_range=(n - 1, n - 1)
+    )
+    n_eff = float(np.sqrt(eigvals[-1]))
+
+    phi = eigvecs[:, -1]
+    phi = phi / np.sqrt(np.trapezoid(phi**2, z_grid))
+    return n_eff, phi
+
+
+def _cladding_eps(layer_stack, z_value: float, wavelength_um: float) -> float:
+    """Permittivity of the background dielectric covering ``z_value``.
+
+    This is the physical cladding the guiding layer is embedded in (e.g. the
+    oxide around an SOI strip), used as the floor for the variational result.
+    """
+    for d in layer_stack.dielectrics:
+        if d["zmin"] <= z_value < d["zmax"]:
+            resolved = resolve_material_at_wavelength(d["material"], wavelength_um)
+            if resolved is not None and resolved.permittivity_scalar is not None:
+                return float(resolved.permittivity_scalar)
+    return 1.0
+
+
+def variational_effective_permittivity(
+    xy: tuple[float, float],
+    reference_xy: tuple[float, float],
+    sim,
+    wavelength: float = 1.55,
+    *,
+    nz: int = 400,
+    eps_floor: float | None = None,
+) -> float:
+    """Variational effective permittivity at ``xy`` relative to ``reference_xy``.
+
+    Implements the Hammer & Ivanova formula by solving the vertical slab mode at
+    ``reference_xy`` and weighting the local permittivity difference by the mode
+    intensity. Geometry (component + layer stack) is taken from ``sim``.
+
+    Args:
+        xy: (x, y) location where the effective permittivity is evaluated.
+        reference_xy: (x, y) reference point for the slab mode. Must lie in a
+            single-mode guiding region; the same reference is used for every
+            ``xy`` to keep the perturbation consistent.
+        sim: A ``gsim.meep.Simulation`` carrying ``sim.geometry.component`` and
+            ``sim.geometry.stack``.
+        wavelength: Wavelength in um.
+        nz: Number of z samples for the profiles and slab solve.
+        eps_floor: Lower floor on the returned permittivity. For points whose
+            vertical column cannot support the reference mode (e.g. pure
+            cladding under a strongly confined strip mode) the raw variational
+            value can drop near zero or negative. ``None`` (default) clamps to
+            the physical cladding permittivity at the guiding plane (e.g. oxide)
+            so evanescent behaviour in gaps stays physical; pass a float to
+            override.
+
+    Returns:
+        Effective permittivity at ``xy`` (square it back for index:
+        ``n = sqrt(eps)``).
+    """
+    component = sim.geometry.component
+    layer_stack = sim.geometry.stack
+
+    z_grid, eps_reference = build_eps_z(
+        component, layer_stack, reference_xy[0], reference_xy[1], wavelength, nz=nz
+    )
+    n_eff, phi = solve_slab_mode(z_grid, eps_reference, wavelength)
+
+    z_grid, eps_local = build_eps_z(
+        component, layer_stack, xy[0], xy[1], wavelength, nz=nz
+    )
+
+    intensity = np.abs(phi) ** 2
+    weighted_shift = np.trapezoid((eps_local - eps_reference) * intensity, z_grid)
+    mode_power = np.trapezoid(intensity, z_grid)
+    eps = n_eff**2 + weighted_shift / mode_power
+
+    if eps_floor is None:
+        z_guiding = float(z_grid[np.argmax(intensity)])
+        eps_floor = _cladding_eps(layer_stack, z_guiding, wavelength)
+    return max(float(eps), eps_floor)
+
+
+def fit_medium(
+    eps_eff_values: float | list[float],
+    wavelengths: float | list[float],
+) -> float:
+    """Convert effective permittivity to a constant effective index (stub).
+
+    Single-wavelength, zero-dispersion placeholder: returns ``sqrt(eps_eff)`` so
+    the value can be dropped straight into ``sim.materials``. The dispersive fit
+    (eps_eff(lambda) -> Sellmeier -> Lorentzian poles via
+    ``gsim.meep.materials.sellmeier_to_lorentzian_poles``) replaces this later.
+
+    Args:
+        eps_eff_values: One effective permittivity, or a list (only length 1 is
+            supported until dispersive fitting lands).
+        wavelengths: The matching wavelength(s) in um.
+
+    Returns:
+        Constant effective refractive index ``n = sqrt(eps_eff)``.
+    """
+    # TODO(#156): fit eps_eff(lambda) to a dispersive MEEP-compatible model.
+    eps_list = (
+        [eps_eff_values]
+        if isinstance(eps_eff_values, (int, float))
+        else list(eps_eff_values)
+    )
+    wl_list = (
+        [wavelengths] if isinstance(wavelengths, (int, float)) else list(wavelengths)
+    )
+    if len(eps_list) != 1 or len(wl_list) != 1:
+        raise NotImplementedError(
+            "Dispersive fitting is not implemented yet; pass a single "
+            "(eps_eff, wavelength) pair (zero-dispersion stub)."
+        )
+    return float(np.sqrt(eps_list[0]))

From 03a922ec92e0b583134e09293e116f73c2cb1ada Mon Sep 17 00:00:00 2001
From: thanojo <86444011+thanojo@users.noreply.github.com>
Date: Thu, 4 Jun 2026 23:26:43 +0800
Subject: [PATCH 2/6] feat(eim): add 2D veim version of ybranch meep simulation
 #156

---
 nbs/meep_ybranch_veim.ipynb | 313 ++++++++++++++++++++++++++++++++++++
 nbs/meep_ybranch_veim.py    | 171 ++++++++++++++++++++
 2 files changed, 484 insertions(+)
 create mode 100644 nbs/meep_ybranch_veim.ipynb
 create mode 100644 nbs/meep_ybranch_veim.py

diff --git a/nbs/meep_ybranch_veim.ipynb b/nbs/meep_ybranch_veim.ipynb
new file mode 100644
index 00000000..96b7eab4
--- /dev/null
+++ b/nbs/meep_ybranch_veim.ipynb
@@ -0,0 +1,313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb4740a1",
+   "metadata": {},
+   "source": [
+    "# MEEP Y-branch: 3D and 2D variational EIM\n",
+    "\n",
+    "[MEEP](https://meep.readthedocs.io/) is an open-source FDTD electromagnetic\n",
+    "simulator. This notebook reproduces the 3D S-parameter simulation of the\n",
+    "photonic Y-branch from the [MEEP example](./meep_ybranch.py), then repeats it\n",
+    "as a fast **2D variational effective-index (varEIM)** simulation and compares\n",
+    "the two.\n",
+    "\n",
+    "**Requirements:**\n",
+    "\n",
+    "- UBC PDK: `uv pip install ubcpdk`\n",
+    "- [GDSFactory+](https://gdsfactory.com) account for cloud simulation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e570be48",
+   "metadata": {},
+   "source": [
+    "### Load a pcell from UBC PDK"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3226d60e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzAAAAJoCAYAAAC5ogQ1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAMTgAADE4Bf3eMIwAANENJREFUeJzt3VuS4zbWLlCowwNDD8RPNRGdgdSTB9I1kX76B6ITWW7ZKlniRbxsbGCtCJiuvErAR4pfUsq83G63WwEAAEjgX9E3AAAAYCkFBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADS+G3uAy6Xyzm3BAAAGN5t5s9UugIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBrdFZjr9Vp64b60ybq0ybq0ybq0ybq0ybq0ybq053K73W6TH3C5nHdrAACAod2m60l/V2AAAIB+KTAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpdFdgrtdr6YX70ibr0ibr0ibr0ibr0ibr0ibr0p7L7Xa7TX7A5XLerQEAAIZ2m64n/V2BAQAA+qXAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkMZv0Teg1Gv0LQAAAD7x4zpggQm64wAAQL4LEZ5CBgAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAGgoMAACQhgIDAACkocAAAABpKDAAAEAaCgwAAJCGAgMAAKTxW/QNAAAAzldrLT9+/Hj7vkfvPi6CAgMAAEwWm6myc7bL7Xa7TX7A5XLsLajXUn5cd/ty1+v15+iB+9Im69Im69Im69Im69Im65JjXW7fv5cW/PuPP375939+//2X9339+/FjHt//6vNffczzx9/f/+pzv+xVcGbqyc8PmPT1IYeOej3+exjmQAZkQAZkQAZkQAaGzcDt+/ddx/1r7rVd+3Vrrf94+9fbHt//+O/n9099nXfb569/397n+PH/N6/XXD9RYOJ3KsMcyIAMyIAMyIAMyMCxhWTv0rFXGflkW2fKyNKy8urjlny/v/79379LjALjIOYgJgMyIAMyIAMyIANDZaDFMtJq6akLrsCsLT3vvs/U530VmPvXVmAa2IkMcyADMiADMiADMiAD55WTUctIq1dg6kS5ebwCc19jBcYB0wFTBmRABmRABmRABlJlYIRy0krpqQe/BmbJlZnHKzAKTAM7oGEOZEAGZEAGZEAGZGBbSRm1vJx1v+v/SspUWXn3/ndf5/HzXw1XYO47g99C5gDpQVIGZEAGZEAGZKCZDLiSkr/01BW/XWzL13cFpoEd1jAHMiADMiADMiADo2Rg6ZWUVk7Ks2xbuN914W8X2/L1f5YYTyGL35ENcyADMiADMiADMtBbBlxRaX+b9QpM9Xdg4ndwwxzIgAzIgAzIgAxkzsCRV1SiT8qzbEe439XfgbmG7+yGOZABGZABGZABGciWgZbKiu1Ypaf6OzAKTPQB0DAHMiADMiADMtB2BjKWlSy30/0um67A3DPq78A0cKAwzIEMyIAMyIAMyICy0kYp6H2brexVr4FxBcYDpAdIGZABGZABGRgzAxmvrPR6Uu5+F1dgFu+8Ckz4wdMwBzIgAzIgAzIQU1iiT7Zt25iHbHmo/g6MKzAeNJw4yIAMyIAMyECfGej5CktvJ+Xud1l1BcbfgWngAGOYAxmQARmQARmQgb0LS/TJtG2OeciWl+o1MK7AeMD0gCkDMiADMiADOTMw8hWW3k7K3e+yeB78HRgFJvzga5gDGZABGZABGXCFpYWT/1G32cpe9XdgXIHxoOHEQQZkQAZkQAbay8DjiWXGk8zo7ajzNcL9rv4OjAITfYA2zIEMyIAMyIAMvC4tLZws2vY/D9nyVv0WMgXGg4YTBxmQARmQARlo5ypL9MlhL9tR53OE+11dgVFgIg7YhjmQARmQARkYNQNKSxsnwbZ5S091BUaBiT6QG+ZABmRABmSg9wxkPEnMvh11vke439XfgVFgzjhwG+ZABmRABmRgpAw8nkhGn+zZmoe5HGTLaQ3+OzCXr/+UCZfLpRyqXkv5cT32ewAA3bt9//7Lvy/fvv18m23MPGRbB5b79x9/vHz7jx8/yh5m6sl8xTn8pySuwIT/lMowBzIgAzIgA1kz4EpLGz+Rb2W7ZURnOeWoxzyTarafKDANLL5hDmRABmRABmRg+cmNp4cN9bQoJaTh42NVYOIXwTAHMiADMiADMtBkBpSWPreujCQfVYGJXwTDHMiADMiADMhAExl49xQf2zzzoJwMMKoCE78IhjmQARmQARmQgbAMKCt5t15XMuixsyow8YtgmAMZkAEZkAEZOD0DrrDk2Copjo9FgTm2uRnmQAZkQAZkQAbazYCnh7VRSpSU+H0h9aiuwMQvgmEOZEAGZEAGZOCwDCgtbZSUV2vxeBXMMAdFgYlpboY5kAEZkAEZkIH4DCgtbZaV6FwYncxBdQUmfhEMcyADMiADMiADmzOgtLRRUpQVx7OiwORqboY5kAEZkAEZkIFzM/B80mx7bmmRd8e8cvYcuAIjdA48MiADMiADMpAtA0qLp4FFZ9AocXOgwAigHVAGZEAGZEAGMmRAafGalegMGqWNOVBgGlgEwxzIgAzIgAzIgNLSwGtX5NCxKEUGqhfxxy+CYQ5kQAZkQAZk4JcMeEG+167YJxwXiwJzTnMzzIEMyIAMyIAM7FtavEDfrzC2TzmuFldgFBgHAgcCGZABGZCBVjKwpKQoMX47WHROjdLOHHgKWQOLYJgDGZABGZCBwTKglPgjkdEZNBLPQfUamPhFMMyBDMiADMjAIBlwJcXfX4nOoNHBHFQFJn4RDHMgAzIgAzLQcQb2ekH+aOXHbwiLz67R6BxUBSZ+EQxzIAMyIAMy0FkG/BYxf+E+OoNGx3NQFZj4RTDMgQzIgAzIQCcZGPFKydatv8MSn1sj2RxUBSZ+EQxzIAMyIAMykDgDZ5aWXsrR4/0wzIEMlHVzoMDYaew0MiADMiADMrCluESXgSxbpcV+5lhb9pkDBWafibxe+/nDmO5L/BpYl/j5ti7xc2td2jwme23Ln3PwtS5LnxbW+pWW1jLmvliXMpcDBSZ+ZzPMgQzIgAzIQOsZaOnpW63cjne3q/XCYpiD9BmoXgMTvwiGOZABGZABGWgwAxnKQiu3Q2mJz6sx0BxUBSZ+EQxzIAMyIAMy0EgGWioHrW6VlvicGoPPQVVg4hfBMAcyIAMyIAPBGchWWs6+vUqLfTR6HzXK33OgwAiEHUIGZEAGZGDMDLw6Mc+0Pfp2Ky3xGTXMQXk1BwqMYDg4yIAMyIAMjJWBzKXl6K3SEp9PwxyUuTlQYITEgUIGZEAGZKD/DCgtSkt0Bg1zUPaaAwVGmBxQZEAGZEAG+szACKVl6/27/79hDmQgUQaqF/HHL4JhDmRABmRABg4oLtHlotWt4mJ/c8xNnoGqwMQvgjHmHBy08xnmQAbGzMCr12/YKi3RuTTMQTliDhQYwVoUkpFPto+67yPN6av7es/V81j6/uePi76PhjkIyoDS8r60udJiv3Rs7jQD1RWY+EVoeTyfUI4+Bxm+bktjrnhsnR/5jF9jI2QOlBYvyLfvOf4MnYGqwMQvQqtjyUnn1E/Hn9/+6ifsrz5uzdc/+/PX7jBH3v6t87/H+h/5tT55/wil0Bh2DpQWpSU6g4Y5KK3MgQLTwCK0OraeQM79/9RJ/dKvf+Tnz83DkqdAHX37t8x/KwXm04KnwHy2Fka6OfCaFr9FLDqDhjloLgPVFZj4RRi5wCz9/Ij3b91Jzrp9n87/2vuw5WAxdfVoa8Hb6zYa5qChDHhBvt8iFp1Bwxw0nYEaU2B+K3CGes39/ec+P/r+bfHjuu39az8OErh9//7X/1++ffv5b9s/5+E+P1/zARBBgcnq64Q50wnjkbf1XXl4/J5bv//U579ai8yFBgaltLwvaff5UVqAJsxdosl66am7MfX0nBZeA3Pk+7dm5ezXwEy9BmfL06xe3c695+LT9fH0sW3rYoTOgde2TP+RyfvbDHMgAzJQlpxD7HFcnusnCkyiME6dwL57AfvUyeXzaxfeff6ar//ubVs//9XX+WTuPnmR+tznv/rc5/+fW4ut67/2/q9ZnyXv33r7DHNwcga8tsUL8h13HHdkoGyfAwXGjhS2IznpzHEQs07xa2CkngOlxQvyozNomIPuMlBdgYlfhFGHE+PYuZ8ac+u05vMNczBoBvzdlvm/2xK9RoY5kIGkGagKTPwijDqc6La/PtYofh2MVHOgtCgt0Rk0zMEQGagKTPwiGOZABmRABlJnwAvyvSA/OoOGORgqA1WBiV8EwxzIgAzIQLoMeG2LF+RHZ9AwB8NmoCow8YtgmAMZkAEZSJEBpcUL8qMzaJgDGSgKjBCc12oNcyADMpA1A17b4rUt0Rk0zIEMlMPPVf0dGDuaHU0GZEAGUmdAaVFaojNomAMZKK/nQIGxc9g5ZEAGZEAG/llc7v9v+/qpc4Y5kAEZKFFzoMAInwOQDMiADIyeAa9t8YL86Awa5kAGigIT1dwMcyADMiADOTKgtHhBfnQGDXMgA+WzOXAFxs5j55EBGZCBkTLgtS1e2xKdQcMcyEDZNgcKjJ3ITiQDMiADvWdAaZkvLV7bEp9TwxzIQFFgIpqbYQ5kQAZkoJ0MeEG+0hKdQcMcyEDZfw5cgbFj2bFkQAZkoKcMeG2LF+RHZ9AwBzJQjp0DBcZOZieTARmQgd5Ly+hXYjxFLD6jhjmQgbLfHCgwdig7lAzIgAxkzYByorREZ9AwBzJQzp8DBcaOZ8eTARmQgUwZUFq8ID86g4Y5kIESOwcKjJ3QTigDMiADI5SWXp9G5ili8fk0zIEMlHPnQIGx09npZEAGZKDFDPRcOvba+tXH8Tk1zIEMlPPnQIGx49nxZEAGZKCVDCgtXpAfnUHDHMhAggzUY/4cypzZj8h6xw1zIAMyIAPtXmnJekXH1RbHFccVGZCBosAoMA4EDgQyIANxGYgsE1lKjOLiGOUYJQMyUF7PgSswdg47hwzIgAz0XlqybJUW+6LjsQzIQJmfAwXGjmJHkQEZkIGRSktrt+fxdtkX7YsyIAMyUBSYs5ubYQ5kQAZGz0DLJaG126e4xOfVMAcykDAD1Yv44xfBMAcyIAPJM9BSKWh9q7TE59UwBzKQPANVgYlfBMMcyIAMJMyA0uK1LdEZNMyBDAyagarAxC+CYQ5kQAYSZOD5RebZr7icdfu9tiU+u4Y5kIHOMlAVmPhFMMyBDMhAoxnopaycvVVc4rNrmAMZ6DgDVYGJXwTDHMiADDSSgTVXWJQapSU6r4Y5kIFBM1AVmF0m8nrt57eauS/xa2Bd4ud7lHXp9QrL17qc8TSyM660ZM+Y+xI/79Ylfo6ty3Xf+VFg4gNqmAMZkIGMpaW30rP2fh9dXAxzIAMyIAPl9RwoMHYOO4cMyEDfGVjztDBbL8iPzqthDmRABsrcHCgwQuJAIQMy0FcGziorvZShufvhakt8pg1zIAMyUBSY45qbYQ5kQAaiC0sLpSDb9nnelBb7sWO5DMhAwxmoXsQfvwiGOZABGdhQWFo56c++VVrsh47FMiADSTJQFZj4RTDMgQzIwMKy0ltpiN4qLvY9x18ZkIGEGagKTPwiGOZABmRgorC0fvIffTv2uP2GOZABGZCBRBmoCkz8IhjmQAaGy4ArK3FXWpSW+Pwb5kAGZKBsmQMFRoAcRGRABmIKSy+lINPtNMyBDMiADHSQgeoKTPwiGOZABrrKQI9lJdtWcYnfDwxzIAMyUI6aAwVGuBxgZEAG9isqI5aEFm+PYQ5kQAZkoOMMVFdg4hfBMAcy0HwGRi8rrW4Vl/h9wzAHMiAD5ew5UGCEzoFHBmRguqQoK21dgVFaHLMcs2RABgbPQHUFJn4RDHMgA6dmQEnJt1VaHCcdJ2VABmRAgTmouRl5fpq+94i+v4aSElUqlBb7n+OPDMiADJQz58AVGIHr5aAT/bQfpaaN9fZ0rzaumOyxH0UfUwxzIAMyIAONZqB6Cln8Ihib56DVk1YnYtvWU0lpI8dL8q20OJZ7LJMBGZCBosDkbG7GuXOQ6SfuI5eZpYUk03raKi3R+5VhDmRABobNQHUFJn4RjI/mIPNJb9Yi80kRybg+tsdcgRm9yBvmQAZkQAbKPnOgwNiZsu5M2U+K353gz93f6BE9b7a55kFhiT9WGuZABmSguwxUV2DiF8FYNQevTqZ7OblWHtpYB9ttV2CUFsd1j2syIAMyUBSYPM3NOHYOeiorn5ab6Nthax6mSrdjoMcBGZABGZCBcvQcuAIjZFkONEt/4mtrHuTgvCuF0ccFwxzIgAzIwIAZqJ5CFr8IxuwcKClK2j0HtvFPb3TMctyWARmQARkoCsw/ZW1uxjFzMHeFxRUYJ/fKzbFPWzTMgQzIgAzIQGllDlyBaWARjE3lZZSteWhjHXrdusriWOyxSAZkQAbSZKB6Cln8Ihhv52DpSbuT+zZOgm1zzcPzvmOYAxmQARmQgRQZqApM/CIYm8rLKFvz0cY6ZN0qLI61HmtkQAZkoJsMVAUmfhGMf8zB2pN1J/dtnCTbtjUPrrA4vnp8kQEZkIEuM1AVmPhFMP6aA2VESYs+6c+6VVgcSz2WyIAMyMAwGagKTPwiGP84Cfv05C36JNLWPLjC4pjmmC4DMiADMlAUmEzNzVg/B8qHkqb8ucLi2OnxQwZkQAZkoLgCo8C0fCB49XSXPZ4+4wqIKyA95MDTweKPUYY5kAEZkIGGM1A9hSx+EQYY707KbJW00XOgrMQfnwxzIAMyIAPJMlAVmPhF6HicVVqUojZOxm2VlehjjmEOZEAGZGCADFQFZpeJrLXu8jHZhystStro23cjet80zIEMyIAMyEA3GagKzC4TOVVOvt53H+ELfsBo4QpI9Pe3HXMeFJX4449hDmRABmRgwAzUgQrMY5GYGo8nJfd/v3v/8/vefczj18o2flnYmY+zVdJ6y8HSfcMwBzIgAzIgAzJQFJijCszPE5P//loqHk9a/vqYh3Ly7v2PHzd3MvTq87JsWy8prd8+2xzzoKg4+XDyIQMyIAMykCADdbArMPftV4FZUkaWlpUl5WRJyWlhqwy0sQ7WRUkJf4AwzIEMyIAMyECLGagDFpj7/y8pI0vLSu9XYFrfKl1trEP0dm4ccVwxzIEMyIAMyIAMlHPnYNQC83UF5tXTw57LiCsw8SeltkraknKioDiBcAIhAzIgAzIwSAbqwAVm6RUYr4Fpv0S4AtPH+iknDTwoGOZABmRABmSg9QzUgQvM/W3P4/Hk6vF1M++u2Ny3z7+F7NXbX72/ta0y0MY6ZF2XT8YR+7thDmRABmRABmSg0wzUgQvMvVxMnYy1XjZsc53ct7rdcxx2sDLMgQzIgAzIgAzIQBm8wDy+7d3J3YgvvFcG+i8ZSocHACcBMiADMiADMpA2A3WwArPk78A8bl2ByXVyH307ztga5kAGZEAGZEAGZGDoDNTBCsx9u/QKzIjbkcpApq0C08AB0zAHMiADMiADMnALn4MRC8z9/79OCF1h6WM7UukyzIEMyIAMyIAMyMDQGaiDFpipvwMz+nakMpBpq8A0cMA0zIEMyIAMyIAM3MLnYNQCs/cVmOv12sRJ7qjbd6Wrx3XpYXytS/RtcF+sS3R27C/xc2tdHJNbHh4ry/v5GbXAeA3M+jJgG1/Sog+mhjmQARmQARmQARko0XMwcoHZ8wqMbfzJ/SjrYJgDGZABGZABGZCBoTNQBy4wj2+LPiltaTtSGci0VWAaOGAa5kAGZEAGZEAGbuFzMFqBWft3YGxzzMNIpcswBzIgAzIgAzIgA0NnoA5WYO5bV2CUgawlbe8RfhAyzIEMyIAMyIAMyEBRYCYLzF8lxhWY7k7uo29H1q1C5IHDyYMMyIAMyIAMpMlAHfAKzM8b6O/AzJ7MRp9U2+ZcF1eBGjiwG+ZABmRABmSg5wzUgQuMKzD9bLOc3Nt+XnrCD5aGOZABGZABGZCBWxNzMHKBeXybk0tloPUcjF7SlJwGHjAMcyADMiADMlAamIORC4wrMP1sRz+5t11Wck49uBrmQAZkQAZkQAZuh8zByAXm8W1OApWB1nOgpB17JceDjBMNGZABGZABGUiSgTpYgfF3YPo8eW799tnmmAfFpoEHJcMcyIAMyIAMlDYLzOV/JeWty+VS9lZrffn2//z+++7fqyeXb9/++v/b9++TH/f1fttj5sE8x+Rr6b4BAJykXkv5cd39y87Uk/mKk7W5jThauAIS/f1tx5wHV2zijz+GOZABGZCBATNQB3oK2Rl3fPTx7oTOVkkbJQeKTfxxyDAHMiADMtB5BqoCE78InY4zy4yy1MbJu+26chO9jxrmQAZkQAZkIGUGqgITvwgDDFdmlLR7DmyVmujjkWEOZEAGZCB5BqoCE78IA469r8y4AqMc9FSOXKmJP0YZ5kAGZEAGGs5AVWDiF2HwoXwoaS2Uhta3Sk38scowBzIgAzJQ2pgDBaaBRTD+cZL26cld9EmmrXmIKDNeT+M46nFEBmRABobKQHUFJn4RjL/mQBlR0pRAV2gcEz0uyIAMyIAMFAXmvOZm7DMHa6+ouALjyocrYNNXahybHJ9lQAZkQAa6yUB1BSZ+EYxdSkzvW/PRxjpk3So0jrUea2RABmSgmwxUBSZ+EYy3c7D0pN3JfRsnyba55sEVGsdfjz8yIAMykDIDVYGJXwRjcg6UEyWthZP93rcKjWOxxyIZkAEZSJOBqsDEL4KxucQoOW2cBNv2NQ+P+5VhDmRABmRABkorc6DANLAIxuIC08JJXQsnk7bmISp/Co1jtscsGZABGSjRc6DACGGWMXUS7+ReqVHqlJnoY5RhDmRABmSgKDAZm5txfIkZdauktbEOtu+vzLg64zHAY6AMyIAMlDPmwBUYQct2sHl1Mt/Lyf3ciL59tuZhyX6nzMQfJw1zIAMy0HUGqhfxxy+C8dEcZD+pX/vT6yUF54wRPW+2ueZBmXGM9xgnAzIgA0WBabu5GefNQeaT66wndUpPG/lpZbt2v8ucfcMcyIAMyEBpZw5cgWlgEYyP5yBTeRn5xO2T4hO9Xrb2h+j9xjAHMiADMlBez4ECY+foYedo9aR35NKydS2VnPj8rsn3Hl/HvhK//xnmQAZkIEUGqtfAxC+CscscRP8k/933No6ZA1dw2igxR+5H9h3HDxmQARmQgaLAHN/cjJw/yd9jRN9fY/n6R5+k97I9ej7tX/ZrxzUZkAEZKAqMAuNA4EAgA8pNC+VHmXEsciySARmQgfLpHHgKmfA4gMiADHhaWotXYFyZcWxybJIBGZCBosC4AuNA4EAgA/s+JTH6ysToW08zc0xzTJMBGRgwA9WL+OMXwTAHMpAyA6OXmtbu7+PtMcyBDMiADHScgarAxC+CYQ5koKsMjFxqWtkqNPH7gWEOZEAGylFzoMAIlwOMDMiAUtPDFZip2ynjjnMyIAMy0FEGqisw8YtgmAMZGC4Dr67StHCy3+vWVZn4zBvmQAZkoOw1BwqMMDmgyIAMtJOBTKWm9du35vYb5kAGZEAGEmWgugLz4eTdHkYDC7n4NkffBsMcyPSaDLhS47UyjhkeN2RABmSgjFxgHkpH3VI+jrx9W77fY6l6VbB6KTBbi+MJ+UpZcM9cu7m5WTJvWz//qNu/ZN3nPnf6a7RyhSb6++99P1yRiT4+GOZABmSgLJuD8QrM8x3/5HsdeVJ62/l79VZg9rg/ZxdQ4/38vMr70uL37usdVRyX3v5Pb9/St+V+2lmWrTLjuOXYLQMy0HAGqgIzcYIx9741JyKfniQd8bXmbvvU/V/z+Vtv/9oTvE/u39G374jbP/UxS7K55f17j6krEXvP9dG3f82xYOnt++x+nFVmeilLc/dDmTljXzLMgQzIQFk+BwrMJycgR5887XHyP3Vy+ukJ2NrPP6MgrLl9e63PlnVfO19r5nRpQfr0/WfOmQKz59y7QrNfCbv/v2EOZEAGZKDEzcF4BWbqNTD7Pq1j2+3c8n0+PcEtjZ8A7/X9T8jXoqscn9zW287zc8a8fPL9Pn3fmffl3dosmfO5+3fs7d/rCk0vV2A+vd/KzJnHC8McyIAMlNEKzIsTi58FZssJ6K9vu173nsi9r768e/vcU5AUmP3X7LMC82fGlpz4TuV3abk68iR6ydduucD8evv/3vfXlOXo+3D+083O3n6ty9lPPztq7P/4Ejfcl/g1sC7x821dyvb5GaPAlBcF5tXJ4JoT0KODu/fVl3fv27OguAKzfI3OugKzNWdH/TDh04+L3ke37F8t3Y99nm6WvfTsfftdlTk3q4Y5kIGBM1AVmAOegrTHScdZJ6NTBWTrFZg1J+qf3Mcl3+/M9budcPsjC+oZ83PGiX/U+n4yr+cXmFGu0By9VWZic2uYAxnoPAN16ALz9LbFT6FpucBseQrY89d4/PeWz997fuaK0ZKnQE19zJYT3C3zv+T2L8ne3Odvef+R8/PuY9Z837mvf/Ttn8rnktu3ZP7jxqurMy2Uhda39/83zIEMyIAMlH3mYKwCc/wdN16dsE39e8/R3glff7c/w23s+fa3NTKXmLNvt6sy8Xk1zIEMdJSBqsDEL0I3Y+kVmjO/f6aR4fZnuI093/52R+Yyc/bWVZn4vBrmQAaSZ6AqMPGL0NWIfApM9pPT7LffMAd/ZkCZUWbsC46HMiAD5cg5UGAEzEFGBmRABkYqM63dnsfbZV+0L8qADMhAUWDObm6GOZABGZCBdstM9PdfevuUGccRxxEZkIFy+nm8F/Hb8ex4MiADMvD+QSJBmYjeKjOOIY4hMiADRYE5o7kZ5kAGZEAG2n2aWdbS5KqM44rjigzIQDn8PN4VGDuaHU0GZEAG1j94HFgyspYXZcaxxLFEBmSg/DoHCoydwk4hAzIgAy1moKfScWSZiV4nwxzIgAyUs+dAgRE6Bx4ZkAEZaD0DyozXykRn0DAHMlDamQMFpoFFMMyBDMiADBxaZka5kuP1Mo4ljiUyMEQGqtfAxC+CYQ5kQAZk4KMMjFRO1m49xcxxxXFFBrrNQFVg4hfBMAcyIAMysCkDr64+2Coz9ivHVhnoNANVgYlfBMMcyIAMyMBhZUap8cJ/+5djrAx0loGqwMQvgmEOZEAGZOCQDCgvXitj33J8lYEOM1AVmPhFMMyBDMiADByaAVdivPDfPuY4KwMdZaAqMPGLYJgDGZABGTgtA8qMF/7b3xxzZSB5BqoCE78IhjmQARmQgdMz4DUyfouZ/c6xVwaSZqAqMPGLYJgDGZABGQjNgDIzX2Zk1HFKBmSgtDIHCkwDi2CYAxmQARloJgNe+O+F/9EZNMyBDBQF5szmZpgDGZABGegjA14r47Uy0Rk0zIEMlFPP4+fMfsThC6bA2CkcGGVABmRAmdm89RQz+5FjqQyUs+dAgRE6Bx4ZkAEZkIH1V2W2nPT3ulVmHEscS2SgKDD5mpthDmRABmRgjAwoM174H51BwxwMm4HqKWTxi2CYAxmQARlInQFXZLzwPzqDhjkYKgNVgYlfBMMcyIAMyEAXGfD0Mk8vi86gYQ6GyEBVYOIXwTAHMiADMtBdBpQZZSY6g4Y56DYDVYGJXwTDHMiADMhAtxnwWhkv/I/OoGEOustAVWDiF8EwBzIgAzIwRAaUGS/8j86gYQ66yEBVYOIXwTAHMiADMjBcBrzw3wv/ozNomIO0GagKTPwiGOZABmRABobNgNfKeK1MdAYNc5AuA1WBiV8EwxzIgAzIgAwoM/5IpuOA44AM3BSYgOZmmAMZkAEZkIGtGfBaGWXGccRxRAaKKzAKjAOBA4EMyIAMZMyA18p44X90Bg1z0FwGqqeQxS+CYQ5kQAZkQAYWFpmvcf+37eurVYY5kIHOM1AVmPhFMMyBDMiADMjAigwoM/Mv/Fdm7FOOqx1noCow8YtgmAMZkAEZkIEPM6DM+C1mjh+OH8NloCow8YtgmAMZkAEZkIGNGRj1hf9L76+rMvYxx9mOMlAVmPhFMMyBDMiADMjAjhkYrcSs3Soz9jfH3OQZqApM/CIY5kAGZEAGZOCADIx4RWbt1mtl7HuOvwkzUBWY+EUwzIEMyIAMyMDBGeixzOx1f1yVsf85BifLQFVg4hehxXHUH/r8+rr3EX0fjbj1ffV+mYjfP/f6nmfdvhZvU5LRY5nZa6vMxOfTMAcl6Jg+Z/YjDg9v1IOZB9Ft8/B4gvx8ojx3Uvzqcx+/xtT75r73q9s4dx+WZGOP+7fm+y/9GkfkPPu+sXXOWh973aeor9PjmuwwXp2w2yoz0bk0zEEJOqYrMCdPeLqxdR6WnphPlYy1t2nJ56wtHGtu/5L3r5m3uZJ19vpm3zeWZi/rUGC6H9lKzNm315WZ+Iwa5qDs/Zj0fByc8Vvhn+q1lB/X92/7+v+7r7fd//34OY8f8/y+x6/3/LVeff7z5y79+lPvH2n97vP8uH5T74++fWfdhsfvv/Zj1uR37efP7X9rvZrfrfvPmv3zXf6WrMES7+Zrye37dP2mvvfSz5/L19TnT71/yfG5cZdv335ub9+//7X9eluL28fbHPH9n28DMAhPIVv4E853PzF/9f9LrxCs/Un9J7dvriEfdQVmyW1ae1u33P9PPn/NOm/9/nt87Cef/+kVtLmn7s29bcvnL3mK4dp87Ln/zN3XNVco577nlqztsU9+enza84rp1PvXXhlteHh6mSsz0Rk0zEFZ+jiwxzHPFZiG7fkTweef6Gf3/BPWT39C3Ortb92S2/ruY5bez6nPn7tidrYt3/P5asvWr3d35lW7d1dQtlwV2/O2DODx6kJLV2ZauR2uzMBYunsK2fV6/TmaPIH95L78iPv+mz2ciH4tybWu/Nwl7z/yJO7NU7v+ui9TT/1KcpK1el0azt+qfX/q9h1VOPa8L0fO7x73/+Hzf2Zs7c2du39Bx7dWHl8en2IWWSIeb09kWfl///d/i8vM4/y1qJWM7cF9adO1l4x5CtlJTyH79JLbUS9y3+vS39FPF1ryOUuejrPni/rXvr+19fnktqx5ytPWz1+6Hns+hezTefz0KVRb1vnop5At+dgtX3fr+gz6FLLeXvgfvX2cL8McyEBJ9xSyf0UXqBT2+Gnf0T8xnPr6LVyNOdPzT5DfvWj+3fujb18L9szMJ1/rPkev5ubr36/G1Pefm9/n9djT2VdLWry9z19z7fdwfJv1dVWh9ad1tbS9z9n9Cs3zVRqgbd09hWyVd0+TePUbgtY84G59Csa7B/t3t+/567+7/a9++9Grr7/2Ns59/icnWWteQ/LqqVxzv31ozW8nmrv9U3P67vYf+duR5tZ3yfpv+S1Zc/k7w9RtX7v/PL9/7f55RMl4vm3vfkviq9v37nYtPb7MreOS499UvrYe3wZ31mtljvq60dt3cwk0ZtinkBnmQAbazkBPx4ae7ouRbg78kUx/byY6g0bHc1BjnkKmwEQvfGvj3esLpl7HYlifRAfFU/ahXu6L0d0cKDPby4zXzsTn2CjtzIEC08AiGOZABuIz0ENZVvzj18A47IX/fmHA6yJomIMhM1BdgYlfBMMcyIAMyIAMDJYBpWS/32qm0MTn2SjnzoECI3R2OhmQARmQARlQZvorNfZr+3W3GaiuwMQvgmEOZEAGZEAGZODta2U8fcwVGvuHY2RRYE5+cWv259Ub5kAGZEAGZODkDHjhvys0jjuOO+Xkc2u/hUzoHHhkQAZkQAZkYNcic/+37f5PN/O0M8erVMerqsDEL4JhDmRABmRABmRAmWmgnCk0jkUpjkVVgYlfBMMcyIAMyIAMyMCqDLgyo9TYZwY+blYFJn4RDHMgAzIgAzIgAx9lwGtlYq/Q+G1njl1Fgflb1uZmmAMZkAEZkAEZiMmAMtPG084UG8fAkvQ83ov4hdcDuAzIgAzIgAyEZUCZaeMXHig1joNFgWm/uRnmQAZkQAZkQAbayoAy03ap8TS0+H0k3aiuwMQvgmEOZEAGZEAGZOCUDCgzbW4VG8fAosDENTfDHMiADMiADMhA+xnwW8ziS4tyE78fpB3VFZj4RTDMgQzIgAzIgAyEZUCZybt15WbQY2dVYOIXwTAHMiADMiADMtBEBt69PsM2zzwsGdE5M8q2OVBghMhOJAMyIAMyIAMyoMy0UD6UHMeiosCc39wMcyADMiADMiADfWbAlZkc272unK0Z0dnMNmqtk+97HC8/zhWY+EU0zIEMyIAMyIAM5MqAMtNGWWllu2VEZzli1DfF5NXbX35sUIG5fP2nTLhcLuVQ9VrKj+ux3wMA6N7t+/df/n359u3n22xj5iHbOmTz7z/++OXf//n991/e9/Xvx495fP+rz3/1Mc8ff3//q8/98uPHj7KHmXoyX3EOb3+eQhbevg1zIAMyIAMy0FsGXJlp44qI7TFPt6u1/uPt9ysk9/c//vv5/VNfZ8n3u//78arM1NPRVu+/c/1EgYk/yBrmQAZkQAZkQAbOKzROqnO9Bibb9oz7XWfKyNKy8urjnt8/+Xn//bvEKDAeyDyQyYAMyIAMyIAMnHR1poWTXtux5+GIKzC3laVnzfe7//urwDwWnd32UVdgPAA4CZABGZABGZABGVBmWj8p72Xb0xWY29zX/1+BeXybAuMBxwOODMiADMiADMjAiRl4PAFt4WTYdox5aO01MHXhFR4FxgOUBygZkAEZkAEZkIGGy4xS096ViJHvd33xd1qey8a797/7Omu/vgLTwIHKMAcyIAMyIAMyIANrSk30ybJtH/Owd57qwte2bP36CowDpgdNGZABGZABGZCB5IWmhZPhVrajzkcL97uueG3Lp1//Z4nxGpj4g5BhDmRABmRABmRABrZkQJlpo0SMXnrqSVdg/B0YB0wPmjIgAzIgAzIgA50XmhZOlrOelGfZjnC/q78Dcw0/uBjmQAZkQAZkQAZk4IwMjFpmbPsqPdXfgVFgPGh60JQBGZABGZCBMTPwXGhaODnda9vb/XG/y8srMPcs+zswDRxQDHMgAzIgAzIgAzKg1LRRCnrfZit71WtgXIHxAOkBUgZkQAZkQAZkoLcrNVlup/tdVs+DKzAKjActD1oyIAMyIAMyIANDlBrbPspe9XdgXIFx0PbALQMyIAMyIAMy0Fupif7+7nc5bB78HRgFxoOWBy0ZkAEZkAEZkIFTS82o5aLVbbb1qF4D4wqMg7YHbhmQARmQARmQgbMzcHSpyXZS7n6XVVdgfv77v3//MUu/hcxBzAOZDMiADMiADMiADIRkwBUbpacsvAJz/zXK96eU7ZbBGbMfcfiO4gqMBygPUDIgAzIgAzIgA92VG1dgSrfb6u/AeApZ9MHIMAcyIAMyIAMyIANnlhvb3GWv+i1kCowHDQ8aMiADMiADMiADo5abbCfvc9ve7k9xBeZFqBWY8IOKYQ5kQAZkQAZkQAYylJxey0G2+1VdgXEFJvqAYZgDGZABGZABGZCBHotORDnIVkbKh1dgfpaY/72I//623dbYi/jjdzTDHMiADMiADMiADMhAvtJzVhnKVnpq8N+BufzvN429dblcyqHqtZQf192+3PV6/Tl64L60ybq0ybq0ybq0ybq0ybrkWJfb9+9ldP/+44+Xb//x48cuX3+mnpTuCgwAAHCCg87j5wrMv3b/jgAAAAdRYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACCN30oL6jX6FgAAAAlcbrfbbfIDLpfzbg0AADC023Q98RQyAAAgD6+BAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAII3uCsz1ei29cF/aZF3aZF3aZF3aZF3aZF3aZF3ac7ndbrfJD7hczrs1AADA0G7T9aS/KzAAAEC/FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0uisw1+u19MJ9aZN1aZN1aZN1aZN1aZN1aZN1ac/ldrvdJj/gcjnv1gAAAEO7TdeT/q7AAAAA/VJgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0fou+AUz/rvGefvc4AABspcA05KusvCowSgwAAPzJU8gasrWovPr8x7fdy9D9bcoRAADZuAIzmFflRZEBACALV2AaplgAAMCvXIFp0OOVEQAA4G8KTGNcdQEAgPc8hazj8uIKDgAAvXEFpjFzv0lszee7mgMAQG8ut9vtNvkBl8t5t4ZNFBYAALKbqSeeQgYAAOThNTAAAEAankIGAAA0w1PIAACAbngKGQAAkMbpv0bZ3yZpl7UBAKB1/g7MRr2c9PdyPwAA6JunkAEAAGkoMAAAQBoKDAAAkIYCAwAApOFF/Bt58TsAAJzncpv5U5eXy+W8WwMAAAztNl1PPIUMAADIw2tgAACANBQYAAAgDQUGAABIQ4EBAADSUGAAAIA0FBgAACANBQYAAEhDgQEAANJQYAAAgDQUGAAAIA0FBgAASEOBAQAA0lBgAACANBQYAAAgjd/mPuB2u51zSwAAAGa4AgMAAKShwAAAAGkoMAAAQBoKDAAAkIYCAwAApKHAAAAAaSgwAABAyeL/A+qfxzTykWs+AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from ubcpdk import PDK, cells\n",
+    "\n",
+    "PDK.activate()\n",
+    "\n",
+    "c = cells.ebeam_y_1550()\n",
+    "c"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e277ab5a",
+   "metadata": {},
+   "source": [
+    "### Configure and run the 3D simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "feb125d7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Stack validation: PASSED\n",
+      "Warnings:\n",
+      "  - Stopping: energy_decay (dt=20.0, decay_by=0.01, cap=2000.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from gsim import meep\n",
+    "from gsim.common.stack import get_stack\n",
+    "\n",
+    "stack = get_stack()  # auto-detects active PDK\n",
+    "\n",
+    "sim = meep.Simulation()\n",
+    "\n",
+    "sim.geometry(component=c, stack=stack, z_crop=\"auto\")\n",
+    "sim.materials = {\"si\": 3.47, \"SiO2\": 1.44}\n",
+    "sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
+    "sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
+    "sim.domain(pml=1.0, margin=0.5)\n",
+    "sim.solver(resolution=20, simplify_tol=0.01, save_animation=True, verbose_interval=5.0)\n",
+    "sim.solver.stop_when_energy_decayed()\n",
+    "\n",
+    "print(sim.validate_config())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14530eb5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.plot_2d(slices=\"xyz\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8963ede",
+   "metadata": {},
+   "source": [
+    "### Run 3D simulation on cloud"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5bdc5cae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run on GDSFactory+ cloud\n",
+    "result = sim.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21a5b5a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result.plot_interactive()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d30805de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result.plot_interactive(phase=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9458d977",
+   "metadata": {},
+   "source": [
+    "## 2D variational effective-index simulation\n",
+    "\n",
+    "A 2D FDTD (`sim.solver.is_3d = False`) collapses the z-dimension and is\n",
+    "10-100x faster. Instead of substituting bulk indices, varEIM derives the\n",
+    "in-plane permittivity from the vertical slab mode of the 3D stack\n",
+    "(Hammer & Ivanova 2009):\n",
+    "\n",
+    "$$\\varepsilon_\\mathrm{eff}(x,y) = n_\\mathrm{eff}^2(\\mathbf{r}) +\n",
+    "  \\frac{\\int dz\\,[\\varepsilon(x,y,z) - \\varepsilon(\\mathbf{r},z)]\\,\n",
+    "  |\\Phi_\\mathbf{r}(z)|^2}{\\int dz\\,|\\Phi_\\mathbf{r}(z)|^2}$$\n",
+    "\n",
+    "A Y-branch is a good candidate: it splits power by adiabatic mode evolution\n",
+    "along a propagating taper, which varEIM (accurate for propagation) captures\n",
+    "well."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f547aff1",
+   "metadata": {},
+   "source": [
+    "### Effective indices from the vertical slab mode\n",
+    "\n",
+    "Evaluate at a core point on the input waveguide and a cladding point beside\n",
+    "it, both referenced to the same slab mode. The core returns the slab effective\n",
+    "index; the cladding is clamped to the physical oxide permittivity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a351fb4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "from gsim.meep.eim import fit_medium, variational_effective_permittivity\n",
+    "\n",
+    "eim_sim = meep.Simulation()\n",
+    "eim_sim.geometry(component=c, stack=stack)\n",
+    "\n",
+    "core_point = (-7.0, 0.0)  # on the o1 input waveguide\n",
+    "background_point = (-7.0, 1.25)  # cladding beside the input waveguide\n",
+    "\n",
+    "eps_core = variational_effective_permittivity(core_point, core_point, eim_sim, 1.55)\n",
+    "eps_background = variational_effective_permittivity(\n",
+    "    background_point, core_point, eim_sim, 1.55\n",
+    ")\n",
+    "n_core = fit_medium(eps_core, 1.55)\n",
+    "n_background = fit_medium(eps_background, 1.55)\n",
+    "\n",
+    "print(f\"n_core       = {n_core:.4f}  (bulk Si   = 3.47)\")\n",
+    "print(f\"n_background = {n_background:.4f}  (bulk SiO2 = 1.44)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8cc19db",
+   "metadata": {},
+   "source": [
+    "### Configure and run the 2D simulation\n",
+    "\n",
+    "Same source, monitors, domain and solver settings as the 3D run, but\n",
+    "`is_3d=False` and the varEIM material indices."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4de546a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eim_sim.materials = {\"si\": n_core, \"SiO2\": n_background}\n",
+    "eim_sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
+    "eim_sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
+    "eim_sim.domain(pml=1.0, margin=0.5)\n",
+    "eim_sim.solver(resolution=20, simplify_tol=0.01, is_3d=False)\n",
+    "eim_sim.solver.stop_when_energy_decayed()\n",
+    "\n",
+    "print(eim_sim.validate_config())\n",
+    "eim_sim.plot_2d(slices=\"z\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "371f4fde",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result_eim = eim_sim.run()\n",
+    "result_eim.plot_interactive()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7196a264",
+   "metadata": {},
+   "source": [
+    "### Compare 2D varEIM vs 3D\n",
+    "\n",
+    "Overlay the transmission into the two output arms (`S21`, `S31`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32821a62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6, 4))\n",
+    "for key, color in [(\"S21\", \"C0\"), (\"S31\", \"C1\")]:\n",
+    "    if key in result_eim.s_params:\n",
+    "        ax.plot(\n",
+    "            result_eim.wavelengths,\n",
+    "            np.abs(result_eim.s_params[key]),\n",
+    "            color + \"-\",\n",
+    "            label=f\"{key} 2D varEIM\",\n",
+    "        )\n",
+    "    if key in result.s_params:\n",
+    "        ax.plot(\n",
+    "            result.wavelengths,\n",
+    "            np.abs(result.s_params[key]),\n",
+    "            color + \"--\",\n",
+    "            label=f\"{key} 3D\",\n",
+    "        )\n",
+    "ax.set_xlabel(\"wavelength (um)\")\n",
+    "ax.set_ylabel(\"|S| magnitude\")\n",
+    "ax.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "gsim (3.12.12)",
+   "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/nbs/meep_ybranch_veim.py b/nbs/meep_ybranch_veim.py
new file mode 100644
index 00000000..03493381
--- /dev/null
+++ b/nbs/meep_ybranch_veim.py
@@ -0,0 +1,171 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.2
+#   kernelspec:
+#     display_name: gsim
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# # MEEP Y-branch: 3D and 2D variational EIM
+#
+# [MEEP](https://meep.readthedocs.io/) is an open-source FDTD electromagnetic
+# simulator. This notebook reproduces the 3D S-parameter simulation of the
+# photonic Y-branch from the [MEEP example](./meep_ybranch.py), then repeats it
+# as a fast **2D variational effective-index (varEIM)** simulation and compares
+# the two.
+#
+# **Requirements:**
+#
+# - UBC PDK: `uv pip install ubcpdk`
+# - [GDSFactory+](https://gdsfactory.com) account for cloud simulation
+
+# %% [markdown]
+# ### Load a pcell from UBC PDK
+
+# %%
+from ubcpdk import PDK, cells
+
+PDK.activate()
+
+c = cells.ebeam_y_1550()
+c
+
+# %% [markdown]
+# ### Configure and run the 3D simulation
+
+# %%
+from gsim import meep
+from gsim.common.stack import get_stack
+
+stack = get_stack()  # auto-detects active PDK
+
+sim = meep.Simulation()
+
+sim.geometry(component=c, stack=stack, z_crop="auto")
+sim.materials = {"si": 3.47, "SiO2": 1.44}
+sim.source(port="o1", wavelength=1.55, wavelength_span=0.01)
+sim.monitors = ["o1", "o2", "o3"]
+sim.domain(pml=1.0, margin=0.5)
+sim.solver(resolution=20, simplify_tol=0.01, save_animation=True, verbose_interval=5.0)
+sim.solver.stop_when_energy_decayed()
+
+print(sim.validate_config())
+
+# %%
+sim.plot_2d(slices="xyz")
+
+# %% [markdown]
+# ### Run 3D simulation on cloud
+
+# %%
+# Run on GDSFactory+ cloud
+result = sim.run()
+
+# %%
+result.plot_interactive()
+
+# %%
+result.plot_interactive(phase=True)
+
+# %% [markdown]
+# ## 2D variational effective-index simulation
+#
+# A 2D FDTD (`sim.solver.is_3d = False`) collapses the z-dimension and is
+# 10-100x faster. Instead of substituting bulk indices, varEIM derives the
+# in-plane permittivity from the vertical slab mode of the 3D stack
+# (Hammer & Ivanova 2009):
+#
+# $$\varepsilon_\mathrm{eff}(x,y) = n_\mathrm{eff}^2(\mathbf{r}) +
+#   \frac{\int dz\,[\varepsilon(x,y,z) - \varepsilon(\mathbf{r},z)]\,
+#   |\Phi_\mathbf{r}(z)|^2}{\int dz\,|\Phi_\mathbf{r}(z)|^2}$$
+#
+# A Y-branch is a good candidate: it splits power by adiabatic mode evolution
+# along a propagating taper, which varEIM (accurate for propagation) captures
+# well.
+
+# %% [markdown]
+# ### Effective indices from the vertical slab mode
+#
+# Evaluate at a core point on the input waveguide and a cladding point beside
+# it, both referenced to the same slab mode. The core returns the slab effective
+# index; the cladding is clamped to the physical oxide permittivity.
+
+# %%
+import numpy as np
+
+from gsim.meep.eim import fit_medium, variational_effective_permittivity
+
+eim_sim = meep.Simulation()
+eim_sim.geometry(component=c, stack=stack)
+
+core_point = (-7.0, 0.0)  # on the o1 input waveguide
+background_point = (-7.0, 1.25)  # cladding beside the input waveguide
+
+eps_core = variational_effective_permittivity(core_point, core_point, eim_sim, 1.55)
+eps_background = variational_effective_permittivity(
+    background_point, core_point, eim_sim, 1.55
+)
+n_core = fit_medium(eps_core, 1.55)
+n_background = fit_medium(eps_background, 1.55)
+
+print(f"n_core       = {n_core:.4f}  (bulk Si   = 3.47)")
+print(f"n_background = {n_background:.4f}  (bulk SiO2 = 1.44)")
+
+# %% [markdown]
+# ### Configure and run the 2D simulation
+#
+# Same source, monitors, domain and solver settings as the 3D run, but
+# `is_3d=False` and the varEIM material indices.
+
+# %%
+eim_sim.materials = {"si": n_core, "SiO2": n_background}
+eim_sim.source(port="o1", wavelength=1.55, wavelength_span=0.01)
+eim_sim.monitors = ["o1", "o2", "o3"]
+eim_sim.domain(pml=1.0, margin=0.5)
+eim_sim.solver(resolution=20, simplify_tol=0.01, is_3d=False)
+eim_sim.solver.stop_when_energy_decayed()
+
+print(eim_sim.validate_config())
+eim_sim.plot_2d(slices="z")
+
+# %%
+result_eim = eim_sim.run()
+result_eim.plot_interactive()
+result_eim.show_animation()
+
+# %% [markdown]
+# ### Compare 2D varEIM vs 3D
+#
+# Overlay the transmission into the two output arms (`S21`, `S31`).
+
+# %%
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots(figsize=(6, 4))
+for key, color in [("S21", "C0"), ("S31", "C1")]:
+    if key in result_eim.s_params:
+        ax.plot(
+            result_eim.wavelengths,
+            np.abs(result_eim.s_params[key]),
+            color + "-",
+            label=f"{key} 2D varEIM",
+        )
+    if key in result.s_params:
+        ax.plot(
+            result.wavelengths,
+            np.abs(result.s_params[key]),
+            color + "--",
+            label=f"{key} 3D",
+        )
+ax.set_xlabel("wavelength (um)")
+ax.set_ylabel("|S| magnitude")
+ax.legend()
+plt.tight_layout()
+plt.show()

From b998fb61b7cf177065e5289678b271a5aa1373c1 Mon Sep 17 00:00:00 2001
From: thanojo <86444011+thanojo@users.noreply.github.com>
Date: Thu, 4 Jun 2026 23:43:39 +0800
Subject: [PATCH 3/6] docs(eim): add ybranch veim to docs nav with 2D run
 outputs #156

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 mkdocs.yml                  |    1 +
 nbs/meep_ybranch_veim.ipynb | 1002 ++++++++++++++++++++++++++++++++++-
 2 files changed, 991 insertions(+), 12 deletions(-)

diff --git a/mkdocs.yml b/mkdocs.yml
index e14f553c..0363a469 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -21,6 +21,7 @@ nav:
   - Directional Coupler: nbs/meep_dc.md
   - Crossing: nbs/meep_crossing.md
   - 2D FDTD: nbs/meep_2d.md
+  - 2D varEIM (Y-Branch): nbs/meep_ybranch_veim.md
   - 2D Grating Coupler: nbs/meep_2d_xz_gc.md
 - FEM for RF:
   - CPW (Lumped Ports): nbs/palace_cpw_lumped.md
diff --git a/nbs/meep_ybranch_veim.ipynb b/nbs/meep_ybranch_veim.ipynb
index 96b7eab4..87bcc68d 100644
--- a/nbs/meep_ybranch_veim.ipynb
+++ b/nbs/meep_ybranch_veim.ipynb
@@ -98,10 +98,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "14530eb5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "sim.plot_2d(slices=\"xyz\")"
    ]
@@ -180,10 +191,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "5a351fb4",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "n_core       = 2.8527  (bulk Si   = 3.47)\n",
+      "n_background = 1.4440  (bulk SiO2 = 1.44)\n"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -219,10 +239,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "a4de546a",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Stack validation: PASSED\n",
+      "Warnings:\n",
+      "  - Stopping: energy_decay (dt=20.0, decay_by=0.01, cap=2000.0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "eim_sim.materials = {\"si\": n_core, \"SiO2\": n_background}\n",
     "eim_sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
@@ -237,13 +277,940 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "371f4fde",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  meep-62bae0df  completed  1m 48s\n",
+      "Extracting results.tar.gz...\n",
+      "Downloaded 4 files to /Users/nath/Workspaces/gsim/nbs/sim-data-meep-62bae0df\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.plotly.v1+json": {
+       "config": {
+        "plotlyServerURL": "https://plot.ly"
+       },
+       "data": [
+        {
+         "mode": "lines+markers",
+         "name": "S21",
+         "type": "scatter",
+         "visible": true,
+         "x": [
+          1.555016,
+          1.55401,
+          1.553006,
+          1.552003,
+          1.551001,
+          1.55,
+          1.549001,
+          1.548003,
+          1.547006,
+          1.54601,
+          1.545016
+         ],
+         "y": [
+          -3.53596863237486,
+          -3.5364123459832335,
+          -3.536386244555278,
+          -3.5358772823868168,
+          -3.534898592801073,
+          -3.53345033456009,
+          -3.531519699128143,
+          -3.5291070081421614,
+          -3.526225698740495,
+          -3.5228762373500153,
+          -3.519033116395345
+         ]
+        },
+        {
+         "mode": "lines+markers",
+         "name": "S31",
+         "type": "scatter",
+         "visible": true,
+         "x": [
+          1.555016,
+          1.55401,
+          1.553006,
+          1.552003,
+          1.551001,
+          1.55,
+          1.549001,
+          1.548003,
+          1.547006,
+          1.54601,
+          1.545016
+         ],
+         "y": [
+          -3.4999209522433663,
+          -3.5005837745276853,
+          -3.500778731884731,
+          -3.500492795925231,
+          -3.49971301842015,
+          -3.498478513855231,
+          -3.49675050217931,
+          -3.494542265870972,
+          -3.4918541711893947,
+          -3.488699642921257,
+          -3.485053241762914
+         ]
+        },
+        {
+         "mode": "lines+markers",
+         "name": "S11",
+         "type": "scatter",
+         "visible": "legendonly",
+         "x": [
+          1.555016,
+          1.55401,
+          1.553006,
+          1.552003,
+          1.551001,
+          1.55,
+          1.549001,
+          1.548003,
+          1.547006,
+          1.54601,
+          1.545016
+         ],
+         "y": [
+          -34.99941100618131,
+          -35.53527453794005,
+          -36.09917438886688,
+          -36.69451979377543,
+          -37.323475718472125,
+          -37.99052127484691,
+          -38.69961571727492,
+          -39.45627076326528,
+          -40.26725208779692,
+          -41.140008132679185,
+          -42.08381699661737
+         ]
+        }
+       ],
+       "layout": {
+        "height": 400,
+        "legend": {
+         "bgcolor": "rgba(245,245,245,0.9)",
+         "bordercolor": "#888",
+         "borderwidth": 1,
+         "entrywidth": 70,
+         "entrywidthmode": "pixels",
+         "groupclick": "toggleitem",
+         "itemclick": "toggle",
+         "itemdoubleclick": "toggleothers",
+         "itemsizing": "constant"
+        },
+        "margin": {
+         "b": 40,
+         "l": 60,
+         "r": 10,
+         "t": 40
+        },
+        "template": {
+         "data": {
+          "bar": [
+           {
+            "error_x": {
+             "color": "#2a3f5f"
+            },
+            "error_y": {
+             "color": "#2a3f5f"
+            },
+            "marker": {
+             "line": {
+              "color": "#E5ECF6",
+              "width": 0.5
+             },
+             "pattern": {
+              "fillmode": "overlay",
+              "size": 10,
+              "solidity": 0.2
+             }
+            },
+            "type": "bar"
+           }
+          ],
+          "barpolar": [
+           {
+            "marker": {
+             "line": {
+              "color": "#E5ECF6",
+              "width": 0.5
+             },
+             "pattern": {
+              "fillmode": "overlay",
+              "size": 10,
+              "solidity": 0.2
+             }
+            },
+            "type": "barpolar"
+           }
+          ],
+          "carpet": [
+           {
+            "aaxis": {
+             "endlinecolor": "#2a3f5f",
+             "gridcolor": "white",
+             "linecolor": "white",
+             "minorgridcolor": "white",
+             "startlinecolor": "#2a3f5f"
+            },
+            "baxis": {
+             "endlinecolor": "#2a3f5f",
+             "gridcolor": "white",
+             "linecolor": "white",
+             "minorgridcolor": "white",
+             "startlinecolor": "#2a3f5f"
+            },
+            "type": "carpet"
+           }
+          ],
+          "choropleth": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "type": "choropleth"
+           }
+          ],
+          "contour": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "contour"
+           }
+          ],
+          "contourcarpet": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "type": "contourcarpet"
+           }
+          ],
+          "heatmap": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "heatmap"
+           }
+          ],
+          "histogram": [
+           {
+            "marker": {
+             "pattern": {
+              "fillmode": "overlay",
+              "size": 10,
+              "solidity": 0.2
+             }
+            },
+            "type": "histogram"
+           }
+          ],
+          "histogram2d": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "histogram2d"
+           }
+          ],
+          "histogram2dcontour": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "histogram2dcontour"
+           }
+          ],
+          "mesh3d": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "type": "mesh3d"
+           }
+          ],
+          "parcoords": [
+           {
+            "line": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "parcoords"
+           }
+          ],
+          "pie": [
+           {
+            "automargin": true,
+            "type": "pie"
+           }
+          ],
+          "scatter": [
+           {
+            "fillpattern": {
+             "fillmode": "overlay",
+             "size": 10,
+             "solidity": 0.2
+            },
+            "type": "scatter"
+           }
+          ],
+          "scatter3d": [
+           {
+            "line": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatter3d"
+           }
+          ],
+          "scattercarpet": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattercarpet"
+           }
+          ],
+          "scattergeo": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattergeo"
+           }
+          ],
+          "scattergl": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattergl"
+           }
+          ],
+          "scattermap": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattermap"
+           }
+          ],
+          "scattermapbox": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattermapbox"
+           }
+          ],
+          "scatterpolar": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatterpolar"
+           }
+          ],
+          "scatterpolargl": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatterpolargl"
+           }
+          ],
+          "scatterternary": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatterternary"
+           }
+          ],
+          "surface": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "surface"
+           }
+          ],
+          "table": [
+           {
+            "cells": {
+             "fill": {
+              "color": "#EBF0F8"
+             },
+             "line": {
+              "color": "white"
+             }
+            },
+            "header": {
+             "fill": {
+              "color": "#C8D4E3"
+             },
+             "line": {
+              "color": "white"
+             }
+            },
+            "type": "table"
+           }
+          ]
+         },
+         "layout": {
+          "annotationdefaults": {
+           "arrowcolor": "#2a3f5f",
+           "arrowhead": 0,
+           "arrowwidth": 1
+          },
+          "autotypenumbers": "strict",
+          "coloraxis": {
+           "colorbar": {
+            "outlinewidth": 0,
+            "ticks": ""
+           }
+          },
+          "colorscale": {
+           "diverging": [
+            [
+             0,
+             "#8e0152"
+            ],
+            [
+             0.1,
+             "#c51b7d"
+            ],
+            [
+             0.2,
+             "#de77ae"
+            ],
+            [
+             0.3,
+             "#f1b6da"
+            ],
+            [
+             0.4,
+             "#fde0ef"
+            ],
+            [
+             0.5,
+             "#f7f7f7"
+            ],
+            [
+             0.6,
+             "#e6f5d0"
+            ],
+            [
+             0.7,
+             "#b8e186"
+            ],
+            [
+             0.8,
+             "#7fbc41"
+            ],
+            [
+             0.9,
+             "#4d9221"
+            ],
+            [
+             1,
+             "#276419"
+            ]
+           ],
+           "sequential": [
+            [
+             0,
+             "#0d0887"
+            ],
+            [
+             0.1111111111111111,
+             "#46039f"
+            ],
+            [
+             0.2222222222222222,
+             "#7201a8"
+            ],
+            [
+             0.3333333333333333,
+             "#9c179e"
+            ],
+            [
+             0.4444444444444444,
+             "#bd3786"
+            ],
+            [
+             0.5555555555555556,
+             "#d8576b"
+            ],
+            [
+             0.6666666666666666,
+             "#ed7953"
+            ],
+            [
+             0.7777777777777778,
+             "#fb9f3a"
+            ],
+            [
+             0.8888888888888888,
+             "#fdca26"
+            ],
+            [
+             1,
+             "#f0f921"
+            ]
+           ],
+           "sequentialminus": [
+            [
+             0,
+             "#0d0887"
+            ],
+            [
+             0.1111111111111111,
+             "#46039f"
+            ],
+            [
+             0.2222222222222222,
+             "#7201a8"
+            ],
+            [
+             0.3333333333333333,
+             "#9c179e"
+            ],
+            [
+             0.4444444444444444,
+             "#bd3786"
+            ],
+            [
+             0.5555555555555556,
+             "#d8576b"
+            ],
+            [
+             0.6666666666666666,
+             "#ed7953"
+            ],
+            [
+             0.7777777777777778,
+             "#fb9f3a"
+            ],
+            [
+             0.8888888888888888,
+             "#fdca26"
+            ],
+            [
+             1,
+             "#f0f921"
+            ]
+           ]
+          },
+          "colorway": [
+           "#636efa",
+           "#EF553B",
+           "#00cc96",
+           "#ab63fa",
+           "#FFA15A",
+           "#19d3f3",
+           "#FF6692",
+           "#B6E880",
+           "#FF97FF",
+           "#FECB52"
+          ],
+          "font": {
+           "color": "#2a3f5f"
+          },
+          "geo": {
+           "bgcolor": "white",
+           "lakecolor": "white",
+           "landcolor": "#E5ECF6",
+           "showlakes": true,
+           "showland": true,
+           "subunitcolor": "white"
+          },
+          "hoverlabel": {
+           "align": "left"
+          },
+          "hovermode": "closest",
+          "mapbox": {
+           "style": "light"
+          },
+          "paper_bgcolor": "white",
+          "plot_bgcolor": "#E5ECF6",
+          "polar": {
+           "angularaxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           },
+           "bgcolor": "#E5ECF6",
+           "radialaxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           }
+          },
+          "scene": {
+           "xaxis": {
+            "backgroundcolor": "#E5ECF6",
+            "gridcolor": "white",
+            "gridwidth": 2,
+            "linecolor": "white",
+            "showbackground": true,
+            "ticks": "",
+            "zerolinecolor": "white"
+           },
+           "yaxis": {
+            "backgroundcolor": "#E5ECF6",
+            "gridcolor": "white",
+            "gridwidth": 2,
+            "linecolor": "white",
+            "showbackground": true,
+            "ticks": "",
+            "zerolinecolor": "white"
+           },
+           "zaxis": {
+            "backgroundcolor": "#E5ECF6",
+            "gridcolor": "white",
+            "gridwidth": 2,
+            "linecolor": "white",
+            "showbackground": true,
+            "ticks": "",
+            "zerolinecolor": "white"
+           }
+          },
+          "shapedefaults": {
+           "line": {
+            "color": "#2a3f5f"
+           }
+          },
+          "ternary": {
+           "aaxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           },
+           "baxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           },
+           "bgcolor": "#E5ECF6",
+           "caxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           }
+          },
+          "title": {
+           "x": 0.05
+          },
+          "xaxis": {
+           "automargin": true,
+           "gridcolor": "white",
+           "linecolor": "white",
+           "ticks": "",
+           "title": {
+            "standoff": 15
+           },
+           "zerolinecolor": "white",
+           "zerolinewidth": 2
+          },
+          "yaxis": {
+           "automargin": true,
+           "gridcolor": "white",
+           "linecolor": "white",
+           "ticks": "",
+           "title": {
+            "standoff": 15
+           },
+           "zerolinecolor": "white",
+           "zerolinewidth": 2
+          }
+         }
+        },
+        "width": 700,
+        "xaxis": {
+         "title": {
+          "text": "Wavelength (µm)"
+         }
+        },
+        "yaxis": {
+         "title": {
+          "text": "|S| (dB)"
+         }
+        }
+       }
+      }
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "result_eim = eim_sim.run()\n",
-    "result_eim.plot_interactive()"
+    "result_eim.plot_interactive()\n",
+    "result_eim.show_animation()"
    ]
   },
   {
@@ -258,10 +1225,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "32821a62",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -291,7 +1269,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "gsim (3.12.12)",
+   "display_name": "gsim",
    "language": "python",
    "name": "python3"
   },

From ae1e6f4ea1debea51b7e789901fd0e86a734d7c2 Mon Sep 17 00:00:00 2001
From: thanojo <86444011+thanojo@users.noreply.github.com>
Date: Tue, 16 Jun 2026 00:02:16 +0200
Subject: [PATCH 4/6] rerun after main merge, and update materials to use
 `Material` class #156

---
 nbs/meep_ybranch_veim.ipynb | 1299 ++++++++++++++++++++++++++++++-----
 1 file changed, 1121 insertions(+), 178 deletions(-)

diff --git a/nbs/meep_ybranch_veim.ipynb b/nbs/meep_ybranch_veim.ipynb
index 87bcc68d..cb8c6504 100644
--- a/nbs/meep_ybranch_veim.ipynb
+++ b/nbs/meep_ybranch_veim.ipynb
@@ -29,13 +29,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 12,
    "id": "3226d60e",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 13,
    "id": "feb125d7",
    "metadata": {},
    "outputs": [
@@ -80,13 +80,17 @@
    "source": [
     "from gsim import meep\n",
     "from gsim.common.stack import get_stack\n",
+    "from gsim.meep.models.api import Material\n",
     "\n",
     "stack = get_stack()  # auto-detects active PDK\n",
     "\n",
     "sim = meep.Simulation()\n",
     "\n",
     "sim.geometry(component=c, stack=stack, z_crop=\"auto\")\n",
-    "sim.materials = {\"si\": 3.47, \"SiO2\": 1.44}\n",
+    "sim.materials = {\n",
+    "    \"si\": Material(refractive_index=3.47),\n",
+    "    \"SiO2\": Material(refractive_index=1.44)\n",
+    "}\n",
     "sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
     "sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
     "sim.domain(pml=1.0, margin=0.5)\n",
@@ -98,13 +102,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 14,
    "id": "14530eb5",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 4 Axes>"
       ]
@@ -127,169 +131,958 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "5bdc5cae",
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run on GDSFactory+ cloud\n",
-    "result = sim.run()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "21a5b5a8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result.plot_interactive()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d30805de",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result.plot_interactive(phase=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9458d977",
-   "metadata": {},
-   "source": [
-    "## 2D variational effective-index simulation\n",
-    "\n",
-    "A 2D FDTD (`sim.solver.is_3d = False`) collapses the z-dimension and is\n",
-    "10-100x faster. Instead of substituting bulk indices, varEIM derives the\n",
-    "in-plane permittivity from the vertical slab mode of the 3D stack\n",
-    "(Hammer & Ivanova 2009):\n",
-    "\n",
-    "$$\\varepsilon_\\mathrm{eff}(x,y) = n_\\mathrm{eff}^2(\\mathbf{r}) +\n",
-    "  \\frac{\\int dz\\,[\\varepsilon(x,y,z) - \\varepsilon(\\mathbf{r},z)]\\,\n",
-    "  |\\Phi_\\mathbf{r}(z)|^2}{\\int dz\\,|\\Phi_\\mathbf{r}(z)|^2}$$\n",
-    "\n",
-    "A Y-branch is a good candidate: it splits power by adiabatic mode evolution\n",
-    "along a propagating taper, which varEIM (accurate for propagation) captures\n",
-    "well."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f547aff1",
-   "metadata": {},
-   "source": [
-    "### Effective indices from the vertical slab mode\n",
-    "\n",
-    "Evaluate at a core point on the input waveguide and a cladding point beside\n",
-    "it, both referenced to the same slab mode. The core returns the slab effective\n",
-    "index; the cladding is clamped to the physical oxide permittivity."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "5a351fb4",
-   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "n_core       = 2.8527  (bulk Si   = 3.47)\n",
-      "n_background = 1.4440  (bulk SiO2 = 1.44)\n"
+      "  meep-d7104144  completed  3m 34s\n",
+      "Extracting results.tar.gz...\n",
+      "Downloaded 247 files to /Users/nath/Workspaces/gsim/nbs/sim-data-meep-d7104144\n"
      ]
     }
    ],
    "source": [
-    "import numpy as np\n",
-    "\n",
-    "from gsim.meep.eim import fit_medium, variational_effective_permittivity\n",
-    "\n",
-    "eim_sim = meep.Simulation()\n",
-    "eim_sim.geometry(component=c, stack=stack)\n",
-    "\n",
-    "core_point = (-7.0, 0.0)  # on the o1 input waveguide\n",
-    "background_point = (-7.0, 1.25)  # cladding beside the input waveguide\n",
-    "\n",
-    "eps_core = variational_effective_permittivity(core_point, core_point, eim_sim, 1.55)\n",
-    "eps_background = variational_effective_permittivity(\n",
-    "    background_point, core_point, eim_sim, 1.55\n",
-    ")\n",
-    "n_core = fit_medium(eps_core, 1.55)\n",
-    "n_background = fit_medium(eps_background, 1.55)\n",
-    "\n",
-    "print(f\"n_core       = {n_core:.4f}  (bulk Si   = 3.47)\")\n",
-    "print(f\"n_background = {n_background:.4f}  (bulk SiO2 = 1.44)\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a8cc19db",
-   "metadata": {},
-   "source": [
-    "### Configure and run the 2D simulation\n",
-    "\n",
-    "Same source, monitors, domain and solver settings as the 3D run, but\n",
-    "`is_3d=False` and the varEIM material indices."
+    "# Run on GDSFactory+ cloud\n",
+    "result = sim.run()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "id": "a4de546a",
+   "execution_count": 16,
+   "id": "21a5b5a8",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Stack validation: PASSED\n",
-      "Warnings:\n",
-      "  - Stopping: energy_decay (dt=20.0, decay_by=0.01, cap=2000.0)\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
+      "application/vnd.plotly.v1+json": {
+       "config": {
+        "plotlyServerURL": "https://plot.ly"
+       },
+       "data": [
+        {
+         "mode": "lines+markers",
+         "name": "S21",
+         "type": "scatter",
+         "visible": true,
+         "x": [
+          1.555016,
+          1.55401,
+          1.553006,
+          1.552003,
+          1.551001,
+          1.55,
+          1.549001,
+          1.548003,
+          1.547006,
+          1.54601,
+          1.545016
+         ],
+         "y": [
+          -3.309411546828478,
+          -3.310924653941363,
+          -3.3124253061879316,
+          -3.313900776405714,
+          -3.315338328949819,
+          -3.3167506697659337,
+          -3.3181123328367343,
+          -3.319423294289383,
+          -3.320683531131688,
+          -3.3218802889013683,
+          -3.3230135413315782
+         ]
+        },
+        {
+         "mode": "lines+markers",
+         "name": "S31",
+         "type": "scatter",
+         "visible": true,
+         "x": [
+          1.555016,
+          1.55401,
+          1.553006,
+          1.552003,
+          1.551001,
+          1.55,
+          1.549001,
+          1.548003,
+          1.547006,
+          1.54601,
+          1.545016
+         ],
+         "y": [
+          -3.336904707768768,
+          -3.3393156212085517,
+          -3.3416761582976524,
+          -3.3439735129941113,
+          -3.346220403046324,
+          -3.3483912465610075,
+          -3.3504859863629974,
+          -3.3525045672498903,
+          -3.354421375693132,
+          -3.3562363441997762,
+          -3.357936623514986
+         ]
+        },
+        {
+         "mode": "lines+markers",
+         "name": "S11",
+         "type": "scatter",
+         "visible": "legendonly",
+         "x": [
+          1.555016,
+          1.55401,
+          1.553006,
+          1.552003,
+          1.551001,
+          1.55,
+          1.549001,
+          1.548003,
+          1.547006,
+          1.54601,
+          1.545016
+         ],
+         "y": [
+          -28.23994717757289,
+          -28.684223854758663,
+          -29.14224715315178,
+          -29.61131610172594,
+          -30.08911324907103,
+          -30.57181855825889,
+          -31.05621897462401,
+          -31.538688733398104,
+          -32.01552756945461,
+          -32.48343684925573,
+          -32.940151091059434
+         ]
+        }
+       ],
+       "layout": {
+        "height": 400,
+        "legend": {
+         "bgcolor": "rgba(245,245,245,0.9)",
+         "bordercolor": "#888",
+         "borderwidth": 1,
+         "entrywidth": 70,
+         "entrywidthmode": "pixels",
+         "groupclick": "toggleitem",
+         "itemclick": "toggle",
+         "itemdoubleclick": "toggleothers",
+         "itemsizing": "constant"
+        },
+        "margin": {
+         "b": 40,
+         "l": 60,
+         "r": 10,
+         "t": 40
+        },
+        "template": {
+         "data": {
+          "bar": [
+           {
+            "error_x": {
+             "color": "#2a3f5f"
+            },
+            "error_y": {
+             "color": "#2a3f5f"
+            },
+            "marker": {
+             "line": {
+              "color": "#E5ECF6",
+              "width": 0.5
+             },
+             "pattern": {
+              "fillmode": "overlay",
+              "size": 10,
+              "solidity": 0.2
+             }
+            },
+            "type": "bar"
+           }
+          ],
+          "barpolar": [
+           {
+            "marker": {
+             "line": {
+              "color": "#E5ECF6",
+              "width": 0.5
+             },
+             "pattern": {
+              "fillmode": "overlay",
+              "size": 10,
+              "solidity": 0.2
+             }
+            },
+            "type": "barpolar"
+           }
+          ],
+          "carpet": [
+           {
+            "aaxis": {
+             "endlinecolor": "#2a3f5f",
+             "gridcolor": "white",
+             "linecolor": "white",
+             "minorgridcolor": "white",
+             "startlinecolor": "#2a3f5f"
+            },
+            "baxis": {
+             "endlinecolor": "#2a3f5f",
+             "gridcolor": "white",
+             "linecolor": "white",
+             "minorgridcolor": "white",
+             "startlinecolor": "#2a3f5f"
+            },
+            "type": "carpet"
+           }
+          ],
+          "choropleth": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "type": "choropleth"
+           }
+          ],
+          "contour": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "contour"
+           }
+          ],
+          "contourcarpet": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "type": "contourcarpet"
+           }
+          ],
+          "heatmap": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "heatmap"
+           }
+          ],
+          "histogram": [
+           {
+            "marker": {
+             "pattern": {
+              "fillmode": "overlay",
+              "size": 10,
+              "solidity": 0.2
+             }
+            },
+            "type": "histogram"
+           }
+          ],
+          "histogram2d": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "histogram2d"
+           }
+          ],
+          "histogram2dcontour": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "histogram2dcontour"
+           }
+          ],
+          "mesh3d": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "type": "mesh3d"
+           }
+          ],
+          "parcoords": [
+           {
+            "line": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "parcoords"
+           }
+          ],
+          "pie": [
+           {
+            "automargin": true,
+            "type": "pie"
+           }
+          ],
+          "scatter": [
+           {
+            "fillpattern": {
+             "fillmode": "overlay",
+             "size": 10,
+             "solidity": 0.2
+            },
+            "type": "scatter"
+           }
+          ],
+          "scatter3d": [
+           {
+            "line": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatter3d"
+           }
+          ],
+          "scattercarpet": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattercarpet"
+           }
+          ],
+          "scattergeo": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattergeo"
+           }
+          ],
+          "scattergl": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattergl"
+           }
+          ],
+          "scattermap": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattermap"
+           }
+          ],
+          "scattermapbox": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scattermapbox"
+           }
+          ],
+          "scatterpolar": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatterpolar"
+           }
+          ],
+          "scatterpolargl": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatterpolargl"
+           }
+          ],
+          "scatterternary": [
+           {
+            "marker": {
+             "colorbar": {
+              "outlinewidth": 0,
+              "ticks": ""
+             }
+            },
+            "type": "scatterternary"
+           }
+          ],
+          "surface": [
+           {
+            "colorbar": {
+             "outlinewidth": 0,
+             "ticks": ""
+            },
+            "colorscale": [
+             [
+              0,
+              "#0d0887"
+             ],
+             [
+              0.1111111111111111,
+              "#46039f"
+             ],
+             [
+              0.2222222222222222,
+              "#7201a8"
+             ],
+             [
+              0.3333333333333333,
+              "#9c179e"
+             ],
+             [
+              0.4444444444444444,
+              "#bd3786"
+             ],
+             [
+              0.5555555555555556,
+              "#d8576b"
+             ],
+             [
+              0.6666666666666666,
+              "#ed7953"
+             ],
+             [
+              0.7777777777777778,
+              "#fb9f3a"
+             ],
+             [
+              0.8888888888888888,
+              "#fdca26"
+             ],
+             [
+              1,
+              "#f0f921"
+             ]
+            ],
+            "type": "surface"
+           }
+          ],
+          "table": [
+           {
+            "cells": {
+             "fill": {
+              "color": "#EBF0F8"
+             },
+             "line": {
+              "color": "white"
+             }
+            },
+            "header": {
+             "fill": {
+              "color": "#C8D4E3"
+             },
+             "line": {
+              "color": "white"
+             }
+            },
+            "type": "table"
+           }
+          ]
+         },
+         "layout": {
+          "annotationdefaults": {
+           "arrowcolor": "#2a3f5f",
+           "arrowhead": 0,
+           "arrowwidth": 1
+          },
+          "autotypenumbers": "strict",
+          "coloraxis": {
+           "colorbar": {
+            "outlinewidth": 0,
+            "ticks": ""
+           }
+          },
+          "colorscale": {
+           "diverging": [
+            [
+             0,
+             "#8e0152"
+            ],
+            [
+             0.1,
+             "#c51b7d"
+            ],
+            [
+             0.2,
+             "#de77ae"
+            ],
+            [
+             0.3,
+             "#f1b6da"
+            ],
+            [
+             0.4,
+             "#fde0ef"
+            ],
+            [
+             0.5,
+             "#f7f7f7"
+            ],
+            [
+             0.6,
+             "#e6f5d0"
+            ],
+            [
+             0.7,
+             "#b8e186"
+            ],
+            [
+             0.8,
+             "#7fbc41"
+            ],
+            [
+             0.9,
+             "#4d9221"
+            ],
+            [
+             1,
+             "#276419"
+            ]
+           ],
+           "sequential": [
+            [
+             0,
+             "#0d0887"
+            ],
+            [
+             0.1111111111111111,
+             "#46039f"
+            ],
+            [
+             0.2222222222222222,
+             "#7201a8"
+            ],
+            [
+             0.3333333333333333,
+             "#9c179e"
+            ],
+            [
+             0.4444444444444444,
+             "#bd3786"
+            ],
+            [
+             0.5555555555555556,
+             "#d8576b"
+            ],
+            [
+             0.6666666666666666,
+             "#ed7953"
+            ],
+            [
+             0.7777777777777778,
+             "#fb9f3a"
+            ],
+            [
+             0.8888888888888888,
+             "#fdca26"
+            ],
+            [
+             1,
+             "#f0f921"
+            ]
+           ],
+           "sequentialminus": [
+            [
+             0,
+             "#0d0887"
+            ],
+            [
+             0.1111111111111111,
+             "#46039f"
+            ],
+            [
+             0.2222222222222222,
+             "#7201a8"
+            ],
+            [
+             0.3333333333333333,
+             "#9c179e"
+            ],
+            [
+             0.4444444444444444,
+             "#bd3786"
+            ],
+            [
+             0.5555555555555556,
+             "#d8576b"
+            ],
+            [
+             0.6666666666666666,
+             "#ed7953"
+            ],
+            [
+             0.7777777777777778,
+             "#fb9f3a"
+            ],
+            [
+             0.8888888888888888,
+             "#fdca26"
+            ],
+            [
+             1,
+             "#f0f921"
+            ]
+           ]
+          },
+          "colorway": [
+           "#636efa",
+           "#EF553B",
+           "#00cc96",
+           "#ab63fa",
+           "#FFA15A",
+           "#19d3f3",
+           "#FF6692",
+           "#B6E880",
+           "#FF97FF",
+           "#FECB52"
+          ],
+          "font": {
+           "color": "#2a3f5f"
+          },
+          "geo": {
+           "bgcolor": "white",
+           "lakecolor": "white",
+           "landcolor": "#E5ECF6",
+           "showlakes": true,
+           "showland": true,
+           "subunitcolor": "white"
+          },
+          "hoverlabel": {
+           "align": "left"
+          },
+          "hovermode": "closest",
+          "mapbox": {
+           "style": "light"
+          },
+          "paper_bgcolor": "white",
+          "plot_bgcolor": "#E5ECF6",
+          "polar": {
+           "angularaxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           },
+           "bgcolor": "#E5ECF6",
+           "radialaxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           }
+          },
+          "scene": {
+           "xaxis": {
+            "backgroundcolor": "#E5ECF6",
+            "gridcolor": "white",
+            "gridwidth": 2,
+            "linecolor": "white",
+            "showbackground": true,
+            "ticks": "",
+            "zerolinecolor": "white"
+           },
+           "yaxis": {
+            "backgroundcolor": "#E5ECF6",
+            "gridcolor": "white",
+            "gridwidth": 2,
+            "linecolor": "white",
+            "showbackground": true,
+            "ticks": "",
+            "zerolinecolor": "white"
+           },
+           "zaxis": {
+            "backgroundcolor": "#E5ECF6",
+            "gridcolor": "white",
+            "gridwidth": 2,
+            "linecolor": "white",
+            "showbackground": true,
+            "ticks": "",
+            "zerolinecolor": "white"
+           }
+          },
+          "shapedefaults": {
+           "line": {
+            "color": "#2a3f5f"
+           }
+          },
+          "ternary": {
+           "aaxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           },
+           "baxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           },
+           "bgcolor": "#E5ECF6",
+           "caxis": {
+            "gridcolor": "white",
+            "linecolor": "white",
+            "ticks": ""
+           }
+          },
+          "title": {
+           "x": 0.05
+          },
+          "xaxis": {
+           "automargin": true,
+           "gridcolor": "white",
+           "linecolor": "white",
+           "ticks": "",
+           "title": {
+            "standoff": 15
+           },
+           "zerolinecolor": "white",
+           "zerolinewidth": 2
+          },
+          "yaxis": {
+           "automargin": true,
+           "gridcolor": "white",
+           "linecolor": "white",
+           "ticks": "",
+           "title": {
+            "standoff": 15
+           },
+           "zerolinecolor": "white",
+           "zerolinewidth": 2
+          }
+         }
+        },
+        "width": 700,
+        "xaxis": {
+         "title": {
+          "text": "Wavelength (µm)"
+         }
+        },
+        "yaxis": {
+         "title": {
+          "text": "|S| (dB)"
+         }
+        }
+       }
+      }
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
-    "eim_sim.materials = {\"si\": n_core, \"SiO2\": n_background}\n",
-    "eim_sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
-    "eim_sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
-    "eim_sim.domain(pml=1.0, margin=0.5)\n",
-    "eim_sim.solver(resolution=20, simplify_tol=0.01, is_3d=False)\n",
-    "eim_sim.solver.stop_when_energy_decayed()\n",
-    "\n",
-    "print(eim_sim.validate_config())\n",
-    "eim_sim.plot_2d(slices=\"z\")"
+    "result.plot_interactive()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "371f4fde",
+   "execution_count": 17,
+   "id": "d30805de",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  meep-62bae0df  completed  1m 48s\n",
-      "Extracting results.tar.gz...\n",
-      "Downloaded 4 files to /Users/nath/Workspaces/gsim/nbs/sim-data-meep-62bae0df\n"
-     ]
-    },
     {
      "data": {
       "application/vnd.plotly.v1+json": {
@@ -316,17 +1109,17 @@
           1.545016
          ],
          "y": [
-          -3.53596863237486,
-          -3.5364123459832335,
-          -3.536386244555278,
-          -3.5358772823868168,
-          -3.534898592801073,
-          -3.53345033456009,
-          -3.531519699128143,
-          -3.5291070081421614,
-          -3.526225698740495,
-          -3.5228762373500153,
-          -3.519033116395345
+          140.2578,
+          149.63290000000003,
+          159.0079,
+          168.3828,
+          177.7578,
+          -172.86719999999997,
+          -163.492,
+          -154.11660000000003,
+          -144.7409,
+          -135.365,
+          -125.9887
          ]
         },
         {
@@ -348,17 +1141,17 @@
           1.545016
          ],
          "y": [
-          -3.4999209522433663,
-          -3.5005837745276853,
-          -3.500778731884731,
-          -3.500492795925231,
-          -3.49971301842015,
-          -3.498478513855231,
-          -3.49675050217931,
-          -3.494542265870972,
-          -3.4918541711893947,
-          -3.488699642921257,
-          -3.485053241762914
+          136.3479,
+          145.7304,
+          155.113,
+          164.49570000000003,
+          173.8787,
+          -176.738,
+          -167.3544,
+          -157.9705,
+          -148.5862,
+          -139.2014,
+          -129.8161
          ]
         },
         {
@@ -380,17 +1173,17 @@
           1.545016
          ],
          "y": [
-          -34.99941100618131,
-          -35.53527453794005,
-          -36.09917438886688,
-          -36.69451979377543,
-          -37.323475718472125,
-          -37.99052127484691,
-          -38.69961571727492,
-          -39.45627076326528,
-          -40.26725208779692,
-          -41.140008132679185,
-          -42.08381699661737
+          -132.8587,
+          -131.1002,
+          -129.5172,
+          -128.118,
+          -126.9084,
+          -125.89079999999998,
+          -125.0631,
+          -124.4172,
+          -123.93880000000001,
+          -123.6061,
+          -123.39019999999998
          ]
         }
        ],
@@ -1197,7 +1990,7 @@
         },
         "yaxis": {
          "title": {
-          "text": "|S| (dB)"
+          "text": "Phase (deg)"
          }
         }
        }
@@ -1207,6 +2000,148 @@
      "output_type": "display_data"
     }
    ],
+   "source": [
+    "result.plot_interactive(phase=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9458d977",
+   "metadata": {},
+   "source": [
+    "## 2D variational effective-index simulation\n",
+    "\n",
+    "A 2D FDTD (`sim.solver.is_3d = False`) collapses the z-dimension and is\n",
+    "10-100x faster. Instead of substituting bulk indices, varEIM derives the\n",
+    "in-plane permittivity from the vertical slab mode of the 3D stack\n",
+    "(Hammer & Ivanova 2009):\n",
+    "\n",
+    "$$\\varepsilon_\\mathrm{eff}(x,y) = n_\\mathrm{eff}^2(\\mathbf{r}) +\n",
+    "  \\frac{\\int dz\\,[\\varepsilon(x,y,z) - \\varepsilon(\\mathbf{r},z)]\\,\n",
+    "  |\\Phi_\\mathbf{r}(z)|^2}{\\int dz\\,|\\Phi_\\mathbf{r}(z)|^2}$$\n",
+    "\n",
+    "A Y-branch is a good candidate: it splits power by adiabatic mode evolution\n",
+    "along a propagating taper, which varEIM (accurate for propagation) captures\n",
+    "well."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f547aff1",
+   "metadata": {},
+   "source": [
+    "### Effective indices from the vertical slab mode\n",
+    "\n",
+    "Evaluate at a core point on the input waveguide and a cladding point beside\n",
+    "it, both referenced to the same slab mode. The core returns the slab effective\n",
+    "index; the cladding is clamped to the physical oxide permittivity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "5a351fb4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "n_core       = 2.8527  (bulk Si   = 3.47)\n",
+      "n_background = 1.4440  (bulk SiO2 = 1.44)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "from gsim.meep.eim import fit_medium, variational_effective_permittivity\n",
+    "\n",
+    "eim_sim = meep.Simulation()\n",
+    "eim_sim.geometry(component=c, stack=stack)\n",
+    "\n",
+    "core_point = (-7.0, 0.0)  # on the o1 input waveguide\n",
+    "background_point = (-7.0, 1.25)  # cladding beside the input waveguide\n",
+    "\n",
+    "eps_core = variational_effective_permittivity(core_point, core_point, eim_sim, 1.55)\n",
+    "eps_background = variational_effective_permittivity(\n",
+    "    background_point, core_point, eim_sim, 1.55\n",
+    ")\n",
+    "n_core = fit_medium(eps_core, 1.55)\n",
+    "n_background = fit_medium(eps_background, 1.55)\n",
+    "\n",
+    "print(f\"n_core       = {n_core:.4f}  (bulk Si   = 3.47)\")\n",
+    "print(f\"n_background = {n_background:.4f}  (bulk SiO2 = 1.44)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8cc19db",
+   "metadata": {},
+   "source": [
+    "### Configure and run the 2D simulation\n",
+    "\n",
+    "Same source, monitors, domain and solver settings as the 3D run, but\n",
+    "`is_3d=False` and the varEIM material indices."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "a4de546a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Stack validation: PASSED\n",
+      "Warnings:\n",
+      "  - Stopping: energy_decay (dt=20.0, decay_by=0.01, cap=2000.0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "eim_sim.materials = {\n",
+    "    \"si\": Material(refractive_index=n_core),\n",
+    "    \"SiO2\": Material(refractive_index=n_background)\n",
+    "}\n",
+    "eim_sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
+    "eim_sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
+    "eim_sim.domain(pml=1.0, margin=0.5)\n",
+    "eim_sim.solver(resolution=25, simplify_tol=0.01, is_3d=False)\n",
+    "eim_sim.solver.stop_when_energy_decayed()\n",
+    "\n",
+    "print(eim_sim.validate_config())\n",
+    "eim_sim.plot_2d(slices=\"z\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "371f4fde",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  meep-8adf2e70  completed  0m 17s\n",
+      "Extracting results.tar.gz...\n",
+      "Downloaded 4 files to /Users/nath/Workspaces/gsim/nbs/sim-data-meep-8adf2e70\n"
+     ]
+    }
+   ],
    "source": [
     "result_eim = eim_sim.run()\n",
     "result_eim.plot_interactive()\n",
@@ -1225,13 +2160,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 36,
    "id": "32821a62",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAGGCAYAAACNCg6xAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAa0ZJREFUeJzt3Qd4FNX6BvA3vUAgQAqhJPQaeomAUgQE5KoIooIUFUGRonD/KlguohS9iKDABVEpUgSlCNKVJr1JUYGQ0EILnRQIqfN/vrOZzW6yCRtI2M3m/T3PmOzO2dnJENmXc75zxknTNA1EREREdE/O925CRERERAxORERERLnAHiciIiIiKzE4EREREVmJwYmIiIjISgxORERERFZicCIiIiKyEoMTERERkZVcrW1IuZeWloaLFy/Cx8cHTk5OvIRERER2SNYCj4uLQ5kyZeDsnHOfEoNTPpLQVL58+fx8CyIiIsoj586dQ7ly5XJsw+CUj6SnSf+DKFasWH6+FREREd2n2NhY1dGhf27nhMEpH+nDcxKaGJyIiIjsmzVlNSwOJyIiIrISgxMRERGRlRiciIiIiKzEGiciIrI7qampSE5OtvVpkINwc3ODi4tLnhyLwYmIiOxqPZ3o6GjcunXL1qdCDsbX1xelS5d+4HUVGZyIiMhu6KEpICAA3t7eXDyY8iSM37lzB1euXFGPg4KCHuh4DE5ERGQ3w3N6aCpVqpStT4cciJeXl/oq4Ul+vx5k2M4uisOnTZuGChUqwNPTE2FhYdi7d2+O7eV/rEGDBqnU6OHhgWrVqmHNmjVmbS5cuIBevXqp//nkgtWpUwf79+837r98+TJefvlltby6/KumY8eOiIiIMDtG69at1b92TLc33ngjj396IiISek2T/J1MlNf036sHrZ2zeY/T4sWLMXz4cMyYMUOFpsmTJ6NDhw4IDw9XqTCzpKQktG/fXu1bsmQJypYti7Nnz6qxS93NmzfRokULtGnTBmvXroW/v78KRSVKlDB223Xp0kUVi61YsUItTvnll1+iXbt2OHr0KIoUKWI8Vv/+/fHJJ58YH/N/aCKi/MV7e5I9/17ZPDhJYJFw8sorr6jHEqBWr16NWbNmYcSIEVnay/M3btzAzp07VfAR0ltl6vPPP1dLp8+ePdv4XMWKFY3fS4javXs3/v77b9SuXVs9N336dFU09uOPP+K1114zC0ryPBEREZFNh+qk9+jAgQOqp0cndyWWx7t27bL4mpUrV6JZs2ZqqC4wMBChoaEYN26cGhs3bdO4cWN0795d9Uw1aNAA3377rXF/YmKi+ipDg6bvK8N+27dvN3u/BQsWwM/PT73PyJEjVYFZduS4cr8b0y1fpKYAfy0BUjlVl4iIqNAEp2vXrqnAIwHIlDyWmRWWnDp1Sg3Ryeukrumjjz7CxIkTMWbMGLM20oNUtWpVrF+/HgMHDsTQoUMxd+5ctb9GjRoIDg5WQUiG9STASS/V+fPncenSJeNxevbsifnz52Pz5s2q7bx581TdVHbGjx+P4sWLGzfp9coXfy8FlvYDvm4I7P0WSE7In/chIqJ7unr1qvqckc8V+Qe4jFJIycmOHTvUfhklGTJkCKpXr65qbqWdfCbFxMSYHUeea9SokTpG/fr17/m+1hz3zJkzZnW6chNbGWmRzofMdb0P05w5c7LUEMtm2qEhdchSVmP6OLtaY/l5ZJ+0yW82H6rLrbS0NNWLNHPmTFUVL79kUgg+YcIEjBo1ythGepykJ0pIj5MMy8kwYN++fdUQ37Jly9CvXz+ULFlSHUd6uTp16qTqn3QDBgwwfi/F5VKM3rZtW5w8eRKVK1fOcm4SrqReK/PdlvOclgoU8QdiooA1/wds/S/Q7E2gcT/As1jevx8REWWrW7du6h/g8o/zSpUqqclHGzduxPXr19X+ixcvqu2LL75ArVq1VF2ufPjLc9IRYOrVV1/Fnj17cOTIkXte8dwc9/fff1eBSUZN/vrrL3z11VeoV68efv31V/W59rBommYcIZL6Yqlnzk0dknymLlq0CJMmTTLOlLt79y4WLlyoguPDYNPgJENgElrkl8yUPM6urkjCS+YVQGvWrKl6qOQX193dXbWRXyJT0mbp0qXGxxK4Dh06pJK5vE4KyKU4XQJXdmS/iIyMtBic5F8JsuW7+j2B2s8CB+cDO74CYs4Bv38MbJ8ENB0AhA0EinAqLxFRfpNZ3tu2bcOWLVvQqlUr9VxISAiaNm1qbCOlHqafP/L5MXbsWDWCkZKSAldXw0fx119/bezBsiY4WXtcITPM9c9VCXdPPfWUCkzSgSCdAZam5zdv3hyPPfaYGpHRXb16Vc1Gl2DYsmVLNRIjIUwCkEysevzxx9UkL31yl1wXmaglI0QffvihCm0bNmwwhqTc1hA3bNhQna90frz00kvqOfleQpNpLbPDDtVJyJEAI38AOuktksdSx2SJzJaT4CLtdCdOnFBhSY6nt8mcYqWN/DJnJkNq+qw7Wa7gmWeeyfZ8JWjlxeJZecLNC2jaHxh6EOgyHfCrBtyNAf6YAEwOBdaNBGIu2PosiYgefPHCpJSHvpmOPuSkaNGiavvll1+M9bPWkH+0S4+LabjJC9YeV+p633rrLdVLJbXGlkgwkd4d02uxePFiFZwkUOlT+z/99FMcPnxYXQMZGrQ0XCaTvT777DMcO3YMdevWfaCfUXrlTCd/yaQxfYLZw2DzoToZ2pLhM+npkYQuSfX27dvGi9CnTx+15IDUDwkZR546dar6A5exXQk8MiQn47q6YcOGqaQszz///PNqXSgZ2pNN9/PPP6vAJClVErAcT8ZSn3jiCbVfEq10/T355JMqqUv6l+NKwn7QP/Q85eJm6IGq+yJwfBWwbSJw6RCw+3+G+qd6LwKPDgNKZe0hIyKydwnJqaj1n/UP/X2PftIB3u73/oiUgCL1OjI7XMpBpEdEep5efPHFbD8rpL5XwoZpOUheyO1xpd5XSNgx7SHTyefn22+/rSZN6UFp4cKF6NGjh3FITUKMTnqypNesSZMmiI+PV4FSJ8v6yFJCmUOeaRsh7yPLCOVEetSkNEZCn5BaMgl40rtVKILTCy+8oLr+/vOf/6jhNimIW7dunbFgPCoqSiVj0/FNKfiWECO/lBKqJPS89957xjbyh7Z8+XJ1YeUPS7rvJJDp3XpCisAltMmwoPQgSUCTQnOd9F7JmLAe5OR9ZRxbuhrtklyjWk8DNZ8CTm4Ctn0JnN0OHJwHHFoA1OoCPDYcKF3H1mdKRORQ5LOhc+fOashOlrqRD/7//ve/+O6777L0vkjtq7SVcpKPP/44z87hfo6r9yRlV1cknQvSmSCzyyXQnD59Ws14/+abb4xtpLdK3k96nGSylT4aJJ/dpiUzlspgpFD9zz//NHtOr1vKiZyX/KwSWOVnkO+l9OdhsXlwEoMHD1abJZYSpAzjyS9nTv71r3+pLTvSQ2XaS5WZBKWtW7eiwJH/Aaq0NWxRe4DtXwIn1gH/LDNsVTsYAlTwI7Y+UyKie/Jyc1G9P7Z439yQ2WDSoyKb/CNc1gOUCUumwSkuLk7dpUICg/zjXl+L8EHd73Fl2EzkVBskHQ7yWTllyhTV21SnTh21CelUkNmDskm4kkAjgUkeS+2wKdOFpXXSKVKlShXcD+np0nOD3H3kYbKL4ET5JDgM6LkYiP7LUDj+z3IgYr1hC2lhCFCV2xrCFhGRHZLeEGuGzOyN9LZIzY9pj5AECplAJGsNmk67fxD3e1zpGZJhNQlNMvM8O1L3K0N/MhIkwalPnz7GfcePH1czB6V2SZ9Bbnprs/wkQVHCmfx+yM//MBW830bKPRmee24W0OYDYMdk4NCPwNkdhi2oHvDYv4EaTxmG+4iIyGoSHGSxZekBkfIR6fWR8CBDdfpkIwk3MuQlSwHI2oCmCyRLL40+o00mPkltkJStJCQkGCckSQjTJz+Zsva4+nnKcaWtLM8jZShS/yt36sjphrfSUyT1v9KLJj1UPXr0MO6TGmE5L+mNkmUQ5LhSY2UtGWaztGajzMgzLdGxRM5Z7zF7kBv23g8Gp8JECsSfngK0GgHsmgYcmA1cOgz81McwK0+KyOt0NxScExHRPUlxsyxVI+sKyaQimWUmvS9SLP7++++rNlLHI2szicxDU1I3pN82TIb3TEtE9J4g0zamrD2u0O/QIbcRkxnmskSATJiyZqhMhutkopRMjgo2WStJwpnUGcnPKb1XUhgva0o9/fTTVv3mSMizNEtdapCtWaZAZg/agpNm7ZxLyjX5pZDlDvTpoXbn9nVgzwxg7zeGpQxE8fJA86FAw96GJQ+IiB4SWchQPvBl+CivhrKIrPn9ys3nNcdmCjNZJPPxD4C3/wbajQaKBBgW01z7DjC5jmFmnh6oiIiIiMGJZDpIMeDRt4G3jwCdJwK+wcDtq8DG0cCkOsDGT4Hb13ipiIio0GOPE2WQobkmrwFD/gSe/Qbwqw4kxgDbvgAmhQJr3wNizvOKERFRocXgRFlJcbisOP7mbuCF+UCZBkBKgqEe6qv6wIpBwLVIXjkiIip0GJwoh98OZ8NK5P03A72XAxUeA9KSDTcXntoY+KmvYVYeERFRIcHgRPcmC2RWfhx4eRXQ7zegWidZgQM4+gvwTUtg/nPA2V28kkRE5PAYnCh3yjcFei4C3tgBhD4HODkDkb8BszsCszoBEb/Lqma8qkRE5JAYnOj+lA4FnvseGLwfaPQy4OIORO0EFnQz9ELJ7V3SUnl1iYjIoTA40YOvRv7UV8Bbh4FmgwE3byD6CPDzy8C0poZ6qBTzmz0SEREVVAxOlDeKlQE6jAWG/QO0eg/w9AWuRxpm4H3dANjzDZB0h1ebiBzO1atXMXDgQHU7ErnZrtwuRG48u2PHDmOb119/HZUrV4aXl5e6VYncx05ukmtq6NChaNSokTpG/fr17/m+N27cwJAhQ1C9enV1XHl/OYasfq07c+aMuhGuvsm99GrXro1BgwYhIiICtjJnzhyz89I30xW9X375ZXWfPNPH0kbui5eZ/DyyT9rkNwYnylveJYE27wPD/gbafwoUDQRizwNr3wUm1QY2fAjcOMWrTkQOo1u3bjh48CDmzp2LEydOYOXKlWjdurW6sa5OAtHs2bPVjWnXr1+vbnArN+hNTTUvaZCbBb/wwgtWve/FixfVJveHkxvsShhZt24d+vXrl6Xt77//ru4Bd/jwYYwbN06dR7169bBx40Y8TJqmISUlRX0vtzaRczLdzp49m+Pr5T6AixYtUjdBNr2VysKFC83uo5ev5F51lD9iYmKkSlp9LbSSEjRt73eaNqmOpo0qlrH90EXTjq3StJRkW58hEdmJhIQE7ejRo+prQXHz5k319/yWLVty9brDhw+r10VGRmbZN2rUKK1evXr3dT4//fST5u7uriUnG/5uPX36tHqfgwcPmrVLTU3VWrdurYWEhGgpKSkWj9WsWTPt3XffNXvuypUrmqurq7Z161b1+IcfftAaNWqkFS1aVAsMDNR69OihXb582dh+8+bN6v3XrFmjNWzYUHNzc1PPzZ49WytevHiOP0vfvn21Z555Jsvj0NBQbf78+cbnFyxYoNWtW1ftkzb38/uVm89r9jhR/nLzBJr0A4YeBF78Eagid+h2Ak5uAhb1BL6qC2z9LxAXzT8JIipwihYtqrZffvkFiYmJVr3m9u3bqvdJbjYrPSh5Sb9Jraura47tnJ2d8dZbb6kengMHDlhs89JLL6neHekl0i1evBhlypTBY489ph4nJyfj008/VT1Zcg1kaNDScNmIESPw2WefqZ6uunXrPtDPKL1ycv10s2bNwiuvvIKHhcGJHtJvmgtQ40mg11JDiGrxFuBdCoi9AGweaxjG+6kPcGorlzMgogzyoZ10++FvVi6rIgFFhshkmM7X1xctWrTA+++/jyNHjmRp+7///c8YtNauXYvffvsN7u7uefanfe3aNRViBgwYYFX7GjVqqK8Sdix5/vnn1VDg9u3bjc8tXLgQPXr0UPVEeojp1KkTKlWqhEceeQRff/21+tni4+PNjvXJJ5+gffv2qs6rZMmSxpCnXw99k2PdS69evdQ5SeiTTWrJ5LmHJedISpQfSlYE2n8CtPkAOLoC2Pc9cG634XvZSlU19FLV6wF4+fLPgKgwS74DjCvz8N/3/YuAexGra5w6d+6Mbdu2Yffu3So4/Pe//8V3331n1vsiPTgSHqSWR+qSJJjIh75pQfT9io2NVedQq1YtfPzxx1a9Ru9J0kNQZlLELnVYCxYsUD1Mp0+fxq5du/DNN98Y20hvlbyf9DjdvHkTaWlp6vmoqCh1LrrGjRtnOb4Uqv/5559mz0mR+73IecnPKoFVfgb53s/PDw8Le5zIdlw9gLrPA/3WGxbUbPwq4F4UuB4BrBsBTKxhmJV3wfx/LCIieyPhR0LRRx99hJ07d6rANGrUKLM2xYsXR9WqVdGyZUssWbJEzapbvnz5A793XFwcOnbsqIKIHM/Nzc2q18mwmZAhw+xI2JNzlSE56W2qU6eO2vQhR5k9KEODEq727dtn/HmSksyXoSlSpIjF4cIqVaqYbWXLlrXq3KWnS+/pk+8fJvY4kf0sqPmvSYaeqCOLgX2zgCv/GNaBOph+o+HG/YDQboC7t63PlogeFlkbTnp/bPG+D0B6W6TmJzvSUyKbtXVROfU0SXiRJQxkNp+1vVfSMyTDahKaGjRokG07WTZBhv5ktp4Epz59+hj3SfCTmYNSu6TXau3fvx8PgwRFCWfSWyY//8PE4ET2xcMHaPKaISSd2wPs+84wfHfxILByMLDhA6D+S4beKb+qtj5bIspvMoxk5ZCZLUhw6N69u+r1kKJn6fWR8CBDdRI6xKlTp1RRtQx7yTDT+fPnVdiQYaknn3zSeKzIyEhVGxQdHa2m2x86dMgYwizVQklokmPeuXMH8+fPV49lE/I+Li4uZucpx5W2snTB5MmTsXfvXqxevdqsXWbSUyRrKUlPmvRQ9ejRw7hPpv/LeU2ZMkWtrSTHlRora0lwlHPKLCAgQPVG5UTOWe8xy+n88wODE9nvX5bBjxi2jp8BB+cB+2cDt84Cu/9n2Cq2NASsGp0BF+u6pomI8pIUNIeFhWHSpEk4efKkGtKS3pf+/furInEhvUBS/yRhReqAAgMD1XCdDOlJSNC99tpr2Lp1q/Gx3hMktUUVKlTI8t5SH7Rnzx71vQxzmcr8mnbtZEYz4O3tjZCQELRp0wYzZ87M8rrshusk4Mk5B5uslSThTIbL5OeU3quGDRuq2q2nn37aqmsnIS8oKCjL81IDJouI3osMEdqCk6xJYJN3LgTkl0LGtPXpofSApOjw5EZDMXnEekAzFCGiaGmgYR/DPfOKWzc+TkT2RxYylA98GT7Ki4JpImt/v3Lzec3icCo4pOu2anug5yLDvfEe+zdQxB+Ijwb++C8wORT4sScQudEQsoiIiPIYgxMVTL7BQNv/AMOOAs/NAkIeNfRAha8G5ncFpjQEdnwN3Llh6zMlIiIHwuBEBZuru2Gm3SurgTf3AE1fBzyKATdPA799ZFjSYNnrwLm9XFiTiIgcIzhNmzZNFbHJmKMU2Umlf05u3bql7oQsRWUyBbNatWpYs2aNWZsLFy6olURLlSqlZi7IuhOm0yQvX76s1tmQpeOlWE6mNma+U7SMh8r7yDGkAFAWOZPXkZ0KqAE8+V/g38eBp74CStcFUhOBI4uA79sDMx4zFJgnmq9oS0REVGCCk0zRHD58uFooTGYIyN2aZU2GK1euWGwv6zbIImOyRLwsyhUeHo5vv/3WbNEsmbUgy97LImCyguvRo0cxceJElChRQu2XeniZXilTRFesWKHuai2zDGTWgSzopRs2bBh+/fVX/Pzzz2qmgyw937Vr14dwVeiByNRlKRR//Q/gtY1AvZ6Aqydw+S9g1duGXqjV/wdcMUxlJSIiKjCz6qSHqUmTJpg6dapxUS6ZyjlkyBB1U8DMZsyYgQkTJqiFt7JbHVVeJ8vYy/RPS06cOIHq1aurNSdq165tfF+Z/jhu3Dg1JVQq62WqpSz49dxzz6k28p41a9ZUS87LPXnuhbPq7IjUOh1aCOyfBdw4mfF8cHPD7V1qPmVYyZyIbD7rSUYgrLn1BlFuyNpY0ulSoGfVSe+R3OdGX19CnZCzs3os4cQSWRm1WbNmaghN1sIIDQ1VYSc1NdWsjdwXRxYlkzUyZC0M6ZXS6Su1ml44eV8Z9tNvZijnJetxmJ6b3BBR1rDI7tzkuPoCZKYLkZEd8C4JNB8MDN4P9F4O1PgX4OQCRO0ElvYDvqwF/D4auHnW1mdKVGjp/xiWRRqJ8pr+e2XtLWnscgFMuZOzBB4JQKbksfTuWCLDa5s2bVILckldk6y0+uabb6qQo98XSNpMnz5dDQHKwlxy/5yhQ4eqFU779u1rDEAjR45UNyuUlVFl8TJZzVUW3hKymqm0l7tdZz43SyudivHjx2P06NF5dHUo35Y0qPy4YYu9CByYC/w5F4i7BGz/Etg+Caj6hKEXqko7wPnhrkhLVJjJCtDyd65eqiH1p9ndgJbIWjKwJqFJfq/k9+tBVxovcCuHy5Ca9CLJiqfywzdq1EgVgsvwnR6cpI30OElPlJAeJxmWk2E+CU6SNpctW4Z+/fqhZMmS6jjSs9SpUyfj3aLvhwQxCWs66XHS799DdqhYGaDNSKDl/wHha4H93wOnthgW15RNljyo1wMIfQ7wr2brsyUqFPQVo7OrcyW6XxKarFmR3K6Dk5+fnwotmWeqyePsfjiZSSfBxzQxSt2R9ALJ0J/0EkkbubePKWmzdOlS42MJXHIfIBnPlNdJPZPUW0ngEvL+8rzM4DPtdcrp3GSoTzYqYOR2LbWeNmzXIg11UIcWALeigK2fGzaZoVenOxDaFSheztZnTOSwpIdJ/g6XfyDLSAJRXsicGwpscJKQIwFm48aNapab3lskjwcPHmzxNTJbTgq2pZ1+E0Ap9pb/0fSbIEobmW1nStrIzLnMpBhMyFIEslyBfoNCOS+50HIusgyBkGNGRUWpGityUH5VgI7jgLYfAUdXAn8vAU5uAqKPGDZZG0oKyus8B9TqAhQpZeszJnJI8iH3sG/eSmQVzcYWLVqkeXh4aHPmzNGOHj2qDRgwQPP19dWio6PV/t69e2sjRowwto+KitJ8fHy0wYMHa+Hh4dqqVau0gIAAbcyYMcY2e/fu1VxdXbWxY8dqERER2oIFCzRvb29t/vz5xjY//fSTtnnzZu3kyZPaL7/8ooWEhGhdu3Y1O7c33nhDCw4O1jZt2qTt379fa9asmdqsFRMTI+N+6isVYPHXNG3vd5o2q5OmjSqWsY0uqWnzn9O0Q4s07W6src+SiIjuU24+r20enMSUKVNUQHF3d9eaNm2q7d6927ivVatWWt++fc3a79y5UwsLC1OBq1KlSiogpaSkmLX59ddftdDQUNWmRo0a2syZM832f/XVV1q5cuU0Nzc39d4ffvihlpiYaNYmISFBe/PNN7USJUqo4PXss89qly5dsvrnYnByQLfOadr2rzRt+qPmIerTQE37qa+mHVulacl3bX2WRESUC7n5vLb5Ok6OjOs4ObirJwxDeX8tMV8byrM4UPNpw3Behcc4M4+IyIE+rxmc7OQPggow+bfHpUOGAPX3UsPSBrqigUDtrobC8rINpfLVlmdKREQWMDjZCQanQigtFTi709AT9c8vwN1bGftKVDT0QsnyBnJfPSIisgsMTnaCwamQS0kyzMj762cgfA2QbLIacmAdoE43ILSbYb0oIiKyGQYnO8HgREZJtw2LbMpwXuTvQJrJ+jTlHzH0RNV+Fijix4tGRPSQMTjZCQYnyvaGw8dWGkLUGbk3Yvr8DLl3XuU2hqG8Gp0BT9bFERE9DAxOdoLBie79S3IR+Ge5YTjv4sGM5109gWodDCFK7p3nZn4nbyIiyjsMTnaCwYly5fpJQy+UhKjrERnPexQDaj6VvrxBS8ClwN1ikojIrjE42QkGJ7rv5Q3k9i768gaxFzL2FfFPX97gOaBcEy5vQESUBxic7ASDEz2wtDTg3G5DiJIhvYQbGft8Qwyz8mSNqEDzm1oTEZH1GJzsBIMT5anUZODUFsNQ3vHVQFJ8xr6AWukz87oCJSvywhMR5QKDk51gcKJ8k3QHOLHOMJQXsQFITcrY51cNqNIeqNoeCGkOuHrwD4KIKAcMTnaCwYkeioRbwLFfDauVn94GaKkZ+9yKAJVaAVXaGYIUF9skIsqCwclOMDiRTUKUDOdF/gZE/A7ER5vv96+RHqKeAIKbAa7u/EMiokIvljf5tQ8MTmT72Xl/GYbyZLXyc3vNe6PciwKVWmf0RhUvZ8uzJSKyGQYnO8HgRHYl4SZwcrMhREX8Bty+Yr5fCsyNvVGPAC5utjpTIqKHisHJTjA4kV0vcyBrRUmAkmG98/sALS1jv7sPULl1RpF5sTK2PFsionzF4GQnGJyoQN0/7+SmjN6oO9fM9weGZvRGlW/K3igicigMTnaCwYkKbG/UpUMmvVH7M25ErN8CRmqjJERJmCoWZMuzJSJ6YAxOdoLBiRzC7evpvVESpH4H7lw331+6TvqQ3hOG28DwXnpEVMAwONkJBidyOGmpwMVD6TP1fgMu/GneG+VZHKjUJqM3yifQlmdLRGQVBic7weBEDu/2NSByY0ZvlMzcMxVUz6Q3qjHg7GKrMyUiyhaDk51gcKJC1xslPVB6b9TFg+b7PX2Byo+n90a1BYoG2OpMiYjMMDjZCQYnKtTir5j0Rm0E7t4y3x9U3xCiKrYEyjYE3IvY6kyJqJCL5crh9oHBiShdagpw4UBGb9Slw+aXxskFCKwNlA8zLHcgReYlKgBOTryERJTvGJzsBIMTUTbiLhtqotStYPYAsReytikSkBGiJFCVqQ+4efGSElGeY3CyEwxORFaKOW+4l56sYC5fpUcqLdm8jbMbEFQXKNcUKJ8epnh/PSJ6yJ/XzrAD06ZNQ4UKFeDp6YmwsDDs3bs3x/a3bt3CoEGDEBQUBA8PD1SrVg1r1qwxa3PhwgX06tULpUqVgpeXF+rUqYP9+2UhP4P4+HgMHjwY5cqVU/tr1aqFGTNmmB2jdevWcHJyMtveeOONPP7piUgFoNCuQMfxQP+NwMjzwKvrgfafAjX+BRQNNAQpGe7bMx1Y8iowqTYwsSbwUx9g1zTg3D4gJZEXk4jylStsbPHixRg+fLgKLRKaJk+ejA4dOiA8PBwBAVln3SQlJaF9+/Zq35IlS1C2bFmcPXsWvr6+xjY3b95EixYt0KZNG6xduxb+/v6IiIhAiRIljG3kPTdt2oT58+er0LZhwwa8+eabKFOmDJ5++mlju/79++OTTz4xPvb29s7X60FEANw8DTcalk1oGnDrrCEcnd9rGN6L/huIuwgcXWHYhIuHYUhPDe9Jz1QY4FOal5SI8oyTpsnfSLYjYalJkyaYOnWqepyWloby5ctjyJAhGDFiRJb2ErAmTJiA48ePw83N8t3b5XU7duzAtm3bsn3f0NBQvPDCC/joo4+MzzVq1AidOnXCmDFjjD1O9evXV2HufnCojigfJd02LHkgIUoPVJlXNRfFg9NDVHq9lKx07mL57w4iKpxiC8qsOuk9kh4c6Tnq0qWL8fm+ffuq4bgVK9L/FWniySefRMmSJdXrZL/0JvXs2RPvvfceXFwMi+vJsJv0Wp0/fx5bt25VvVLSmyS9R7oBAwbg4MGD+OWXX1Qv05YtW1RP0+rVq9GyZUtjcPrnn38gl6h06dJ46qmnVNCytteJwYnoIZK/ym6cSq+Vkl6pvcCVo4CWZt7O1cuw/IFedC6Bqogf/6iICrHYXAQnmw7VXbt2DampqQgMNL8tgzyWHiVLTp06pYbYXnrpJVXXFBkZqUJRcnIyRo0aZWwzffp0NRz3/vvvY9++fRg6dCjc3d1VKBNTpkxR4UlqnFxdXeHs7Ixvv/3WGJqEBLKQkBAVrI4cOaLCmQwhLlu2zOK5JSYmqs30D4KIHhJZuqBUZcNWv0f6/5RxhrooCVF68bmsJ3V2h2HTlaiYHqLSw1RALa5yTkT2WeOUWzKUJ/VNM2fOVD1MMrwmheAyfKcHJ2nTuHFjjBs3Tj1u0KAB/v77bzXMZxqcdu/ejZUrV6pw9Mcff6iCcwlJ7dq1U20kWOmkuFyK0du2bYuTJ0+icuXKWc5t/PjxGD169EO6EkR0Tx4+QKXWhk2kpQHXI9KD1B5DkLp6HLh52rAdWWRo517U0CslIUpm8cntYrxL8oITkW2Dk5+fnwo/ly9fNnteHsvQmCUSXqS2SR+WEzVr1kR0dLQa+pNeJWkjw3WmpM3SpUvV9wkJCaonavny5ejcubN6rm7dujh06BC++OILY3CyVI8lpJfLUnAaOXKk6uUy7XGSei0ishPOzoB/dcPWsLfhObm/3vkDGcN75/cDSXHA6T8Mm86vWkaIkh4p/2qAV8aEEyIqHGwanCTkSI/Rxo0bjTVO0lskj2WpAEtkttzChQtVOxleEydOnFBhSY6nt5EhNVPSRnqWhAzryaa/XidhTI6bHQlWQt7LElkaQTYiKkAk/FRtZ9j0e+5JL5RxeG8vcD0SuHbCsB2ab75Ip4QwCVWmX32CuOo5kYOy+VCd9NDI8JkMrTVt2lTNYLt9+zZeeeUVtb9Pnz6quFuGwcTAgQPVDLy33npLzbyTZQZkSE5qmHTDhg1D8+bN1fPPP/+8WhdKhvZkE1L41apVK7zzzjtqDScJVFJE/sMPP+DLL79UbWQ4TgKaFKPLWlBS4yTHlRoo6Z0iIgflnH77F9kaG/4ewu3rhmE9CVFyI2MJULLa+e0rhu1Mphm87j6AX9VMoaq64TYyLjb/a5eICvJyBEKCkNQoyXCbTP//+uuvjcNiMrNN1lmaM2eOsf2uXbtUiJEeIAlV/fr1M5tVJ1atWqWGziRYVaxYUQU001l18l6yX9ZvunHjhgpPUtMkx5WFLs+dO6cW0JTaKAlyMuT27LPP4sMPP7xnxb2Os+qIHJgUnkuAuio9UeEZX2+cBrRUy69xcQdKVjYM80mQUoGqKlCqKuDONeKIbKXALEfg6BiciAqhlCTDsgimYepqOHAtAkhJyOZFToBveZMwZTL0x6J0onxXYJYjICJyOK7uQEANw2ZK6idjzqX3UoVn1EzJ9wk3gFtRhi3yN/PXFfFPD1TSS1UtI1QVK8s6KiIbYI9TPmKPExFZ5fa19DBl2ksldVTns3+NLJkgw3zGUJXeWyVrUrGOiihX2ONERFSQyMrlslVoYf58Ynx6z1SEyZDfCcNQYFK84ZYzsplydgNKVjIPU1JXVSzIMAuQoYrogbDHKR+xx4mI8q2OShbszNxLJQEr+U4OL3QCigYYbnwsSyYUDTR81R+rr6UNw4Myu5DIHn/3U+4CntZN0rIWe5yIiBy9jkpfyDNzHZUsk5B5yO/mGSD+smG2n3yV7dLh7I/v5JweqkoDRdPDlFnASg9c3n6GRUWJ7pesmyaL0N6+arJdS99MH6d/TYwBQp8DnvsetsLicCIiRyEhRmbnyValXdYPqDvXgbhLQFy0yddo88eyLpXcGFk9vnSP93O1LmB5lWTAKiw0DUiMNQ87Zl9NwtAd2a5nvRH3vcjrbIjBiYioMJChNxmmky2oXvbtJGDJB1uWgCVfL5sErKtAWoqhh0u2HN/bLWMYMLvhQRWwSnCmoD1KTrh3ALptsi81KffvIX/2MkSsNj9Db6b+vfH59MeevrAlBiciIjIPWHqYyUlqMhB/BYiPziZgpX8vH6ppyYalGGTLiSwQahqiXD0BN2/AzRNw9QLcZEt/znSf8XF6G2Nb/bFn4Q1kEoQlyKQkGv7MUhPTHycZvr9zIyPwZA5A+vcyESG33ItmhB4VgiwEIOP+UoCLGwoKBiciIso9+aArXtaw5UQ+oOPTg5TFkJX+nKxlJR/o+npWeU2FKU/LoSpLALvPsAYtPaAkWQgpmTbjc+mBxhhsMj9n+joLz93r2LkdBssp1Oohp4hp+LEUhPwceiV8BiciIsrHTxn3jLqrnCTfzQhYEqjuxhhmT8kwkWyy6rr+vXos++4YXpfdPhlK1EkbtXL7zcL9py3Dpq4ehuDr4pE+RJa5N8g0HKWHIo9ihbfXLhMGJyIisj3pxSkRYtjyivTQGIPU/QSwzO0s7dNDWnJGwbxLejBRAcU9I6SYPadvFp4zBhtLz5kcM/NzElLNjp35dW4MP3mAwYmIiByTCgxSO5O3a/5kW0sk62RxeQaHx+BERET0oLhgaKHBlcuIiIiIrMTgRERERGQlBiciIiIiKzE4EREREVmJwYmIiIjISgxORERERFZicCIiIiLKz+A0b948tGjRAmXKlMHZs2fVc5MnT8aKFSvu53BEREREjhmcpk+fjuHDh+PJJ5/ErVu3kJoqq6UCvr6+KjwREREROapcB6cpU6bg22+/xQcffAAXFxfj840bN8Zff/2V1+dHREREVHCD0+nTp9GgQYMsz3t4eOD27dt5dV5EREREBT84VaxYEYcOHcry/Lp161CzZs28Oi8iIiKign+TX6lvGjRoEO7evQtN07B37178+OOPGD9+PL777rv8OUsiIiKighicXnvtNXh5eeHDDz/EnTt30LNnTzW77quvvsKLL76YP2dJREREVFCXI3jppZcQERGB+Ph4REdH4/z58+jXr999n8S0adNQoUIFeHp6IiwsTPVi5URm80mvV1BQkKqtqlatGtasWWPW5sKFC+jVqxdKlSqlgl6dOnWwf/9+434598GDB6NcuXJqf61atTBjxgyzY0ivmryPHKNo0aLo1q0bLl++fN8/JxERERWyHidT3t7eansQixcvVsN/ElokNMmSBh06dEB4eDgCAgKytE9KSkL79u3VviVLlqBs2bJqLSlZDkF38+ZNtc5UmzZtsHbtWvj7+6ugV6JECWMbec9NmzZh/vz5KrRt2LABb775puo9e/rpp1WbYcOGYfXq1fj5559RvHhxFbS6du2KHTt2PNDPTERERAWTkyaFSvcgs+icnJysOuCff/6ZqxOQsNSkSRNMnTpVPU5LS0P58uUxZMgQjBgxIkt7CVgTJkzA8ePH4ebmZvGY8joJN9u2bcv2fUNDQ/HCCy/go48+Mj7XqFEjdOrUCWPGjEFMTIwKXAsXLsRzzz2n9st7SgH8rl278Mgjj9zzZ4uNjVWBS45VrFgxq64HERERPVy5+by2aqiuS5cueOaZZ9QmvUEnT55UQ2StW7dWmwyxyXOyLzek9+jAgQNo165dxgk5O6vHEk4sWblyJZo1a6aG0AIDA1UAGjdunHEhTr2NrCvVvXt31TMlwU/WnjLVvHlz1U6G9CQ7bt68GSdOnMATTzyh9st5JScnm51bjRo1EBwcnO25JSYmqotvuhEREVEhG6obNWqUWXH40KFD8emnn2Zpc+7cuVy9+bVr11TgkQBkSh5L744lp06dUkNsUmcldU2RkZFqiE1Cjn6e0kZf4fz999/Hvn371Dm7u7ujb9++xoU8BwwYoGqcXF1dVWCTcNWyZUu1X2q3pL3pEKB+brLPEplZOHr06FxdAyIiInLgGiep9zEtstZJIbb08syaNQv5SYbypBdp5syZauVyGV6TXiMZvtODk7SRc5GeKCE9Tn///bca5jMNTrt371a9TiEhIfjjjz9UL5bUOJn2MuXGyJEjVVjTSY+TDDsSERFRIQ1OMgNN6oeqVq1q9rw8J0N2ueHn56fCT+aZavK4dOnSFl8jM+mktsn0di9SdyS9QDL0J71E0kZmyZmSNkuXLlXfJyQkqJ6o5cuXo3Pnzuq5unXrqoU9v/jiCxWc5P3leDKDz7TXKadzk+FL2YiIiMgx5Xo5grfffhsDBw5UQ18yI002KeSW3hqZhZYbEnKkx2jjxo3G56S3SB5LHZMlMltOhueknU5qkyQsyfH0NjIrz5S0kZ4lIcN6ssnwnCkJY/px5bwkoJmemxwzKioq23MjIiIiB6fdh8WLF2vNmzfXSpQooTb5Xp67H4sWLdI8PDy0OXPmaEePHtUGDBig+fr6atHR0Wp/7969tREjRhjbR0VFaT4+PtrgwYO18PBwbdWqVVpAQIA2ZswYY5u9e/dqrq6u2tixY7WIiAhtwYIFmre3tzZ//nxjm1atWmm1a9fWNm/erJ06dUqbPXu25unpqf3vf/8ztnnjjTe04OBgbdOmTdr+/fu1Zs2aqc1aMTExMmNRfSUiIiL7lJvP6/sKTnltypQpKqC4u7trTZs21Xbv3m0WcPr27WvWfufOnVpYWJgKXJUqVVIBKSUlxazNr7/+qoWGhqo2NWrU0GbOnGm2/9KlS9rLL7+slSlTRgWm6tWraxMnTtTS0tKMbRISErQ333xThUMJXs8++6x6nbUYnIiIiOxfbj6vrVrHie4P13EiIiJyrM/rXBeHS11QTothmq6nRERERORIch2cZCaaKSmyPnjwIObOncs1jIiIiMih5dlQndyaRO47t2LFirw4nEPgUB0REVEhvOWKNeTebaZT94mIiIgcTZ4EJ1lQ8uuvv0bZsmXz4nBEREREjlHjVKJECbPicBnpi4uLg7e3t1oMk4iIiMhR5To4TZo0ySw4ySw7f39/hIWFqVBFRERE5KhyHZwef/xxdeNaS0sSyO1IgoOD8+rciIiIiAp2jVPFihVx9erVLM9fv35d7SMiIiJyVLkOTtmtXhAfHw9PT8+8OCciIiKigj1UN3z4cPVVhuj+85//qGJw09XC9+zZg/r16+fPWRIREREVpOAkq4PrPU5//fUX3N3djfvk+3r16uH//u//8ucsiYiIiApScNq8ebP6+sorr+Crr76658qaRERERCjss+pmz56dP2dCRERE5AjBqWvXrpgzZ47qZZLvc7Js2bK8OjciIiKighec5MZ3+rpN8j0RERFRYeSkZbe+AD3Uuy0TERGR/X9e58lNfomIiIgKg1wHp8uXL6N3794oU6YMXF1d4eLiYrYREREROapcz6p7+eWX1T3pPvroIwQFBVm8Zx0RERGRI8p1cNq+fTu2bdvGVcKJiIio0Mn1UF358uWzvV8dERERkSPLdXCaPHkyRowYgTNnzuTPGRERERE5ylDdCy+8gDt37qBy5crqRr9ubm5m+2/cuJGX50dERERUcIOT9DgRERERFUa5Dk59+/bNnzMhIiIicrQaJ1ld09IWFxeHpKSk+zqJadOmoUKFCvD09ERYWBj27t2bY/tbt25h0KBBajkEDw8PVKtWDWvWrDFrc+HCBfTq1QulSpWCl5cX6tSpg/379xv3yzIKlrYJEyYY28g5Zd7/2Wef3dfPSERERIWwx8nX1zfHtZvKlSun1noaNWoUnJ3vncsWL16M4cOHY8aMGSo0yVBghw4dEB4ejoCAgCztJZy1b99e7VuyZAnKli2Ls2fPqvPS3bx5Ey1atECbNm2wdu1a+Pv7IyIiAiVKlDC2uXTpktlxpV2/fv3QrVs3s+c/+eQT9O/f3/jYx8fnnj8TEREROaZcB6c5c+bggw8+UOGoadOm6jnpIZo7dy4+/PBDXL16FV988YXqCXr//ffvebwvv/xSBZNXXnlFPZYAtXr1asyaNUvN3stMnpcC9J07dxoL06VnyNTnn3+ulk2YPXu28bmKFSuatSldurTZ4xUrVqigValSJbPnJShlbktERESFU65v8tu2bVu8/vrreP75582e/+mnn/DNN99g48aNmDdvHsaOHYvjx4/neCzpPZKZedJz1KVLF7M6KhmOkzCT2ZNPPomSJUuq18l+6U3q2bMn3nvvPeMtX2rVqqV6rc6fP4+tW7eqXqk333zTrOco821kpKdMwp8cSyeB7O7du0hOTkZwcLDaN2zYMHWrGWvwJr9ERET2Lzef17nucZKeHukVyqxBgwbYtWuX+v7RRx9Vt2W5l2vXriE1NRWBgYFmz8vj7ELXqVOnsGnTJrz00kuqrikyMlKFIgk3Mjyot5k+fboaApRer3379mHo0KFwd3e3WNwugUl6lrp27Wr2vLymYcOGKqjJzz1y5Eg1xCe9ZJYkJiaqzfQPgoiIiBxHroOTDIF9//33WYqk5TnZJ65fv25WT5SX0tLSVH3TzJkzVQ9To0aNVCG4FHXrwUnaNG7cGOPGjTOGur///lsFPkvBSYb/JIhJcbopCV66unXrquAlvW3jx49XQ5GZyfOjR4/Oh5+aiIiICmRwkvql7t27q2LqJk2aqOdktpr0EMmQm5AeHlko8178/PxU+JGhMlPyOLu6IplJJ7VN+rCcqFmzJqKjo9XQn4QbaSPDdaakzdKlS7McT+67J4XoUqR+L1K8npKSolZNr169epb90iNlGrakx0kPk0RERFQIlyN4+umnVdCQWiMp0patU6dOKjj961//Um0GDhyY7XCWKQk50mMkdVE66S2Sx82aNbP4GpktJ8Nz0k534sQJFZbkeHobOUdT0iYkJCTL8aSnTM6hXr169zzfQ4cOqZmClmb7CemFkrFR042IiIgciGZjixYt0jw8PLQ5c+ZoR48e1QYMGKD5+vpq0dHRan/v3r21ESNGGNtHRUVpPj4+2uDBg7Xw8HBt1apVWkBAgDZmzBhjm71792qurq7a2LFjtYiICG3BggWat7e3Nn/+fLP3jomJUc9Pnz49y3nt3LlTmzRpknbo0CHt5MmT6rX+/v5anz59rP7Z5PhyieUrERER2afcfF7neqhOJ/erkwLwzIteSi1QbsiQnixh8J///EcNt9WvXx/r1q0zFozLe5iuByVDX+vXr1ez2+S9ZMbcW2+9pWbV6WQIcfny5WroTNZhkqUIZH0oqWMytWjRIgmO6NGjh8XeI9n/8ccfq4JvOYa8p+lQHBERERUuuV6OQEKOrLkkNU6WyCw5MuByBERERI71eZ3rGqe3335brbG0Z88edSsT6R2S6fxVq1bFypUrH+S8iYiIiOxarofqZA0lWXhSpvvLEJoUXMstUCShyXT8zp0758+ZEhEREdlYrnucbt++bZxVJms1ydCdkJvo/vnnn3l/hkREREQFNTjJ+kX6VH+Zwi+3WZEFKGVxSVkSgIiIiMhR5XqoTmawyW1HhKzU3bFjRyxYsECtoSQ3ACYiIiJyVLmeVWdpWQJZ/FJugisrgVMGzqojIiIq5Df5zczb21vdCJeIiIjI0eU6OEkHldyTbvPmzbhy5YrZrU/EsmXL8vL8iIiIiApucJJ1nKQgvE2bNmp1bycnp/w5MyIiIqKCHpzmzZunepXkJr9EREREhUmulyOQ4qlKlSrlz9kQEREROVJwkpvejh49GgkJCflzRkRERESOMlT3/PPP48cff1Srh1eoUAFubm5m+7l6OBERETmqXAenvn374sCBA+jVqxeLw4mIiKhQyXVwWr16NdavX49HH300f86IiIiIyFFqnMqXL3/PVTWJiIiIHFGug9PEiRPx7rvv4syZM/lzRkRERESOMlQntU1yf7rKlSur261kLg6/ceNGXp4fERERUcENTpMnT86fMyEiIiJyxFl1RERERIVRrmuciIiIiAorBiciIiIiKzE4EREREVmJwYmIiIjISgxORERERHk5q+6PP/7A/ZCbAAcHB9/Xa4mIiIgKZHC6nyUInJyc8Pbbb2Po0KH3c15EREREBXOo7vTp07neTp06ZXVomjZtmuqd8vT0RFhYGPbu3Ztj+1u3bmHQoEEICgqCh4cHqlWrhjVr1pi1uXDhglrlvFSpUvDy8kKdOnWwf/9+s2BnaZswYYLZKugvvfSSujefr68v+vXrh/j4eKt+JiIiInI8uV4AM68tXrwYw4cPx4wZM1RokpXJO3TogPDwcAQEBGRpn5SUhPbt26t9S5YsQdmyZXH27FkVbHQ3b95EixYt0KZNG6xduxb+/v6IiIhAiRIljG0uXbpkdlxpJ8GoW7duxuckNEm73377DcnJyXjllVcwYMAALFy4MN+uBxEREdkvJ03TNGsapqSkIDU1VfXw6C5fvqwCz+3bt/HUU0/hsccey/UJSFhq0qQJpk6dqh6npaWhfPnyGDJkCEaMGJGlvbyf9AodP348y33ydPK6HTt2YNu2bVafR5cuXRAXF4eNGzeqx8eOHUOtWrWwb98+NG7cWD23bt06PPnkkzh//jzKlClzz2PGxsaiePHiiImJUb1WREREZH9y83lt9ay6/v37mw29SciQwCPDbOvXr8fjjz+eZbjsXqT36MCBA2jXrl3GCTk7q8e7du2y+JqVK1eiWbNmaqguMDAQoaGhGDdunAp1pm0k7HTv3l31TDVo0ADffvtttuchAXD16tWqx0kn7y+9WHpoEnJecn579uzJ1c9JREREjsHq4CQ9OKbDWD/88IMKKzIEdvjwYTXcZlofZI1r166pY0gAMiWPo6OjLb5GaqdkiE5eJ0Hto48+wsSJEzFmzBizNtOnT0fVqlVVqBs4cKAKfXPnzrV4THnex8cHXbt2NT4n7595qNDV1RUlS5bM9twSExNVajXdiIiIqBAGJym2liCikyEtCVLStaXPvPvnn3+Q32QoTwLNzJkz0ahRI7zwwgv44IMP1BCeaZuGDRuqnijpbZK6JOkxM21jatasWaqeSYrTH8T48ePV9dA3GXIkIiKiQhicJFQkJCQYH+/evVvVJ5nuz+2MMz8/P7i4uKihMlPyuHTp0hZfIzPpZBadvE5Xs2ZN1QskQ396G6lPMiVtoqKishxP6qCkEP21114ze17e/8qVK1nqvGSmXXbnNnLkSDU+qm/nzp275zUgIiIiBwxO9evXx7x584xhQ8KN1DXpTp48aVXBtCl3d3fVa6QXZOu9RfJY6pgskdlykZGRqp3uxIkTKizJ8fQ2EoZMSZuQkJAsx/v+++/VOdSrV8/seXl/WfZAarB0mzZtUu9rGhhNSeG8FJWZbkRERORANCtt2bJF8/Ly0ipVqqS+vvrqq2b7Bw4cqPXp00fLrUWLFmkeHh7anDlztKNHj2oDBgzQfH19tejoaLW/d+/e2ogRI4zto6KiNB8fH23w4MFaeHi4tmrVKi0gIEAbM2aMsc3evXs1V1dXbezYsVpERIS2YMECzdvbW5s/f77Ze8fExKjnp0+fbvHcOnbsqDVo0EDbs2ePtn37dq1q1apajx49rP7Z5PhyieUrERER2afcfF5bHZyEBJvJkyersJOammq275tvvtEOHjyY+7PVNG3KlClacHCw5u7urjVt2lTbvXu3cV+rVq20vn37mrXfuXOnFhYWpgKXBDkJSCkpKWZtfv31Vy00NFS1qVGjhjZz5sws7yvnLCHw1q1bFs/r+vXrKigVLVpUK1asmPbKK69ocXFxVv9cDE5ERET2Lzef11av40S5x3WciIiICuk6TkRERESFnVW3XKlYsaK6j1tu8Sa/+SPmTjI+/vUfvN6qEmqUZgE6ERGRXQWnOXPm3NfB5ca9lPe+334Kyw9eUNuTdUpjaNuqDFBEREQPAWucCmCNU3h0HL7eFIE1f12CXqHWKdQQoGoGsQeKiIgovz6vGZwKcHE4AxQREdGDY3AqZLPqGKCIiIjuH4NTIV2OgAGKiIgo9xicCvk6Ticux+HrjRFYzRooIiKie2JwshO2XgDTUoDqWNtQRF6rDIvIiYiIBIOTnbB1cNIxQBEREWWPwclO2Etw0jFAERERZcXgZCfsLTjpGKCIiIgyMDjZCXsNTroIqYHaFIlVRy6yBoqIiAqtWC6AaR/sPTjlFKA61A5UReS1yxS39ekRERHlKwYnO1FQgpOOAYqIiAqjWPY42YeCFpx0DFBERFSYxDI42YeCGpxMA9SUTZH4lUN4RETkwGIZnOxDQQ9OusgrspAmAxQRETkmBic74SjBKacA9UStQLzVjkXkRERUcDE42QlHC046BigiInIkDE52wlGDk44BioiIHAGDk51w9OBkGqCkiHzlYfMhPFkHKrQs14EiIiL7xuBkJwpLcNIxQBERUUHE4GQnCltwyilAtZcicvZAERGRHWJwshOFNTjpIq/EY8qmCLMA1bRiSbzaogLa1yoNF2cnW58iERERGJzsRGEPTqYBauqmCKw6cgkpaYYEVdbXC32bh+CFJsEo7uVm61MkIqJCLJYLYNoHBidz0TF3MW/3GSzcE4Wbd5LVc97uLujWsBxeblEBlf2L2uTPiYiICrfYXAQnZ9iBadOmoUKFCvD09ERYWBj27t2bY/tbt25h0KBBCAoKgoeHB6pVq4Y1a9aYtblw4QJ69eqFUqVKwcvLC3Xq1MH+/fvN2hw7dgxPP/20ulhFihRBkyZNEBUVZdzfunVrODk5mW1vvPFGHv/0hUfp4p54p0MN7BrZFp93q4PqgT64k5SKebvPou3Ereg7ay+2nrgKTR/XIyIisjOutj6BxYsXY/jw4ZgxY4YKTZMnT0aHDh0QHh6OgICALO2TkpLQvn17tW/JkiUoW7Yszp49C19fX2ObmzdvokWLFmjTpg3Wrl0Lf39/REREoESJEsY2J0+exKOPPop+/fph9OjRKmH+888/KryZ6t+/Pz755BPjY29v73y7FoWFp5uLGqJ7vnF57Dp5HbN2nMHG45dVaJKtsn8RvNyiIro1LAtvd5v/ihIRERk5aTb+572EJenpmTp1qnqclpaG8uXLY8iQIRgxYkSW9hKwJkyYgOPHj8PNzXJtjLxux44d2LZtW7bv++KLL6rXz5s3L9s20uNUv359FebuB4fqrHf2+m3M2XkGP+8/j/jEFPVcMU9XvNg0GH2ahaBcCQZWIiIq5EN10nt04MABtGvXLuOEnJ3V4127dll8zcqVK9GsWTM1VBcYGIjQ0FCMGzcOqampZm0aN26M7t27q56pBg0a4NtvvzXul3C2evVqNcQnvVvSRgLcL7/8kuX9FixYAD8/P/U+I0eOxJ07d7L9eRITE9XFN93IOiGlimDUU7Wxa+TjGPVULYSU8kbs3RTM/OMUWv53MwbOP4C9p29wGI+IiGzKpsHp2rVrKvBIADIlj6Ojoy2+5tSpU2qITl4ndU0fffQRJk6ciDFjxpi1mT59OqpWrYr169dj4MCBGDp0KObOnav2X7lyBfHx8fjss8/QsWNHbNiwAc8++yy6du2KrVu3Go/Ts2dPzJ8/H5s3b1ahSXqnpG4qO+PHj1eJVd+k54xyx8fTDa+0qIjN/26N7/s2RosqpSAT8db+HY3nv9mFf03ZjiUHziMxJSMoExERFYqhuosXL6oapZ07d6peJN27776rAsyePXuyvEZ6ie7evYvTp0/DxcVFPffll1+q4btLly6px+7u7qrHSY6rk+C0b98+1ZOlv2+PHj2wcOFCYxspFJci8R9//NHi+W7atAlt27ZFZGQkKleubLHHSTad9DhJeCrsyxE8qPDoOMzZeRrL/ryAxJQ09ZxfUXe8FBaClx4JRoCPeV0aERGRQw7VyRCYhJ/Lly+bPS+PS5cubfE1MpNOwpMemkTNmjVVD5UM/eltatWqZfY6aaPPmJP3dXV1zbGNJTKcJyQ4WSIz/OSCm2704KqX9sH4rnWxe2RbvNuxOkoX88S1+CR8tTECLT7bhOGLD+Gv8zG81ERElO9sGpykZ6hRo0bYuHGjWf2RPDbtgTIls+UkuEg73YkTJ1RYkuPpbWRWnilpExISYnxfKUjPqY0lhw4dUl/lvejhK1HEHW+2roJt77XBlB4N0DDYF8mpGpYdvICnpm7Hc9N3Ys1fl5CSmvG7QURElKc0G1u0aJHm4eGhzZkzRzt69Kg2YMAAzdfXV4uOjlb7e/furY0YMcLYPioqSvPx8dEGDx6shYeHa6tWrdICAgK0MWPGGNvs3btXc3V11caOHatFRERoCxYs0Ly9vbX58+cb2yxbtkxzc3PTZs6cqdpMmTJFc3Fx0bZt26b2R0ZGap988om2f/9+7fTp09qKFSu0SpUqaS1btrT6Z4uJiZFhUPWV8sehqJvaWz/+qVUeuVoLeW+V2pqP36hN3xKp3bydyMtORER5+nlt8+AkJLQEBwdr7u7uWtOmTbXdu3cb97Vq1Urr27evWfudO3dqYWFhKnBJmJGAlJKSYtbm119/1UJDQ1WbGjVqqICU2ffff69VqVJF8/T01OrVq6f98ssvZgFNQlLJkiXVMaTdO++8k6sQxOD08ETHJGhfrD+uNfhkgzFA1fhwrTZy2RHtRHTsQzwTIiIqaHLzeW3zdZwcGddxevjuJqeqmwrP3nEGxy5lLAfxWFU/vNqiIlpV84czby5MREQmeK86O8HgZDvy74Hdp25g9o7T+O3YZej/PKjkVwR9m1fAc43KoYgHVyUnIiIwONkLBif7cO7GHczdeQaL951DXPqq5D4ernihSXkVosqX5KrkRESFWWwuliPgUJ2d/EFQ/pNbuSw9cF7d2uX0tdvqORm1a1czEK8+WhFhFUuqGzkTEVHhEsvgZB8YnOxTWpqmbiY8a8dpbIu4Zny+ZlAxvNKiAp6uV0bdiJiIiAqHWAYn+8DgZP8iLsdh9s4zWPbnedxNNqz/VKqIO3qGBaPXIyEILMZVyYmIHF0sg5N9YHAqOG7dScKifefww84zuBhzVz3n5uKEtjUCVSF5q+r+cHOx6XqxRESUTxic7ASDU8Ejq46v/+eymo23/+xN4/Nyb7xn6pdFt4blUKsM69WIiBwJg5OdYHAq2GQdKCkm/+XQBXVvPF2toGLo1qgcnqlfBn5FPWx6jkRE9OAYnOwEg5NjSE5Nw9bwq1j653n8fuyyuj+ecHV2QpsaAaoX6vEaAXB35VAeEVFBxOBkJxicHM/N20n49chFLDlwHkfOxxifL+HtpobypB6qdpliXNaAiKgAYXCyEwxOju3E5Tg1lLf84AVciUs0Pl890EcFqGcalEGAD2flERHZOwYnO8HgVHgKyrdFXlMhasPRy0hKMSxr4OLspO6NJ0N5bWsGcG0oIiI7xeBkJxicCp+YO8lY9ZdhKO9g1C3j88W93PBUvSA816g86pUrzqE8IiI7wuBkJxicCreTV+ONQ3mX0teGEpX9i6gA9WyDsihdnEN5RES2xuBkJxicSKSmadh50jCUt+6faOMK5XKfvEerylBeWXSoXZpDeURENsLgZCcYnCizuLvJWPPXJTWUt+9MxgKbPh6u+JcayiuHhsElOJRHRPQQMTjZCQYnysmZa7fVPfKW/nkBF24lGJ+v6FdE9UI927Acyvp68SISEeUzBic7weBE1khL07D79HXVC7X2r2gkJKeq552cgOaVS6lZeR1DS8Pb3ZUXlIgoHzA42QkGJ8qt+MQUrP3rklqlfPepG8bni7i7oHPdIBWimlYsyaE8IqI8xOBkJxic6EGcu3EHy/68oEJU1I07xueDS3qja0PDDYfLl/TmRSYiekAMTnaCwYnygqZpqpBcZuWt/uuS6pXShVUsqQrKn6wThCIeHMojIrofDE52gsGJ8tqdpBSs/ycaSw9cwI6T16AZ7jcMLzcXdKpTGl0blENYpZJwc+ENh4mIrMXgZCcYnCg/XbyVoBbXlKLy09dum61S3rZGAJ6oHYiW1fxZVE5EdA8MTnaCwYke1lDen1G3VICS3qgbt5OM+zxcnfFYVT88Uau0ul9eqaIe/EMhIsqEwclOMDiRLVYpP3D2Jjb8E61uOGxaVC4rlTcKKaFClPRGhZQqwj8gIiIwONkNBieydU9U+OU4bPjnMjYcjcbfF2LN9lcP9FEBSoJUaNliXOKAiAqt2NhYFC9eHDExMShWrFiObe2ignTatGmoUKECPD09ERYWhr179+bY/tatWxg0aBCCgoLg4eGBatWqYc2aNWZtLly4gF69eqFUqVLw8vJCnTp1sH//frM2x44dw9NPP60uVpEiRdCkSRNERUUZ99+9e1e9jxyjaNGi6NatGy5fvpzHPz1R/nByckKN0sUwtG1VrBryGHaMeByjn66NFlVKwcXZSYWqKZsi8dTU7Wj+2SaMWvE3dkReQ3Kq4V56RESUlZMm/yy1ocWLF6NPnz6YMWOGCk2TJ0/Gzz//jPDwcAQEBGRpn5SUhBYtWqh977//PsqWLYuzZ8/C19cX9erVU21u3ryJBg0aoE2bNhg4cCD8/f0RERGBypUrq02cPHkSTZs2Rb9+/dCjRw+VMP/55x888sgjxveV165evRpz5sxR4Wrw4MFwdnbGjh07rPrZ2ONE9urWnSRsDr+ieqO2hF81rlYuinm64nFVXF4arar5c5kDInJ4sbnocbJ5cJKwJD09U6dOVY/T0tJQvnx5DBkyBCNGjMjSXgLWhAkTcPz4cbi5uVk8prxOws22bduyfd8XX3xRvX7evHkW98vFk8C1cOFCPPfcc+o5ec+aNWti165dKmDdC4MTFQR3k1NVT5OEqN+PXcZ1k+Jyd1dnPFpFissD0bZmIPx9WFxORI6nwAzVSe/RgQMH0K5du4wTcnZWjyWcWLJy5Uo0a9ZMDaEFBgYiNDQU48aNQ2pqqlmbxo0bo3v37qr3SHqfvv32W+N+CWfSkyRDfB06dFBtJMD98ssvxjZyXsnJyWbnVqNGDQQHB2d7bkQFkaebiwpFnz9XF3s/aIef32iG/o9VREgpbySlpGHT8SsYsewvNB33O56bvhMz/zhptvwBEVFhYtPgdO3aNRV4JACZksfR0dEWX3Pq1CksWbJEvU7qmj766CNMnDgRY8aMMWszffp0VK1aFevXr1dDbkOHDsXcuXPV/itXriA+Ph6fffYZOnbsiA0bNuDZZ59F165dsXXrVtVG3t/d3V0NAVp7bomJiSq1mm5EBYnUPjWpUBIfdK6FLf/XGhuGtcT/PVENdcsVV4tt7j97E+PWHEebL7ag/ZdbMWH9cRw+d0sVohMRFQYF7h4N0lskPUQzZ86Ei4sLGjVqpArBZfhu1KhRxjbS4yQ9UUJ6nP7++281zNe3b1+1XzzzzDMYNmyY+r5+/frYuXOnatOqVav7Orfx48dj9OjRefazEtm6uLxaoI/aBj9eVS24KUN5MqS3+9R1RFyJV9u0zSdRupgn2tcKVLP0wiqWUkN8RESOyKbByc/PT4WfzDPV5HHp0qUtvkZm0kltkrxOJ3VH0gskQ3/SSyRtatWqZfY6abN06VLj+7q6ulpss337dvW9vL8cT2bwmfY65XRuI0eOxPDhw42PpcdJ6rWIHEEZXy/0aVZBbTF3kg3F5UejVXF5dOxdzNt9Vm0+enF5rdJoVd0fRXkPPSJyIDYNThJypMdo48aN6NKli3pOeoPkscxgs0Rm1EnBtrSTeihx4sQJFZbkeHobmZVnStqEhIQY31cK0nNqI+clAU3ORZYhENJeliuQGitLZGkE2YgcXXFvN3RpUFZtUly+6+R1FaJ+O3oZ1+KTsOLQRbW5uzir5Q9khp6sXB7g42nrUyciejCajS1atEjz8PDQ5syZox09elQbMGCA5uvrq0VHR6v9vXv31kaMGGFsHxUVpfn4+GiDBw/WwsPDtVWrVmkBAQHamDFjjG327t2rubq6amPHjtUiIiK0BQsWaN7e3tr8+fONbZYtW6a5ublpM2fOVG2mTJmiubi4aNu2bTO2eeONN7Tg4GBt06ZN2v79+7VmzZqpzVoxMTFS+KG+EhUGKalp2v4z17Vxq49qrf67SQt5b5VxqzBilfbstO3a9C2R2skrcbY+VSKi+/q8tvlyBEKWIpAaJRluk1qjr7/+Ws1yE61bt1aLY8paSjqZ1Sa1SYcOHVLrOMlaTO+9957Z8N2qVavU0Jms31SxYkU1hNa/f3+z9501a5aqSzp//jyqV6+u6pOk7sl0Acx///vf+PHHH1Xht8zA+9///pftUF1mXI6ACjP5qyXySry69YvcAubw+Riz/VUCiqplDmStqPrBvvBwzfj/l4joYSpQ6zg5MgYnogzRMXfxmyouj1ZDeylpmtnNiBsGl8AjlUrhkUolGaSI6KFicLITDE5ElsUkJGNL+BVVEyUz9KQuypQEqQbBvulBqhTql/dV600REeUHBic7weBEdG/S6X3y6m0VoAzbDVyLTzRrI8sbNGSQIqJ8wuBkJxiciB4sSO05fUN9vRqXNUg1KJ/RIyW9U+yRIqL7xeBkJxiciPImSJ26pvdI5RykwtJrpKReikGKiKzF4GQnGJyI8idIyb3y9BAl25XMQcrFWRWY68XmDFJElBMGJzvB4ERkR0FKDe2VVGGqYQh7pIgoA4OTnWBwIrJNkDpz/Y5Jsfl1XI61HKTC9CAVXAJe7py1R1RYxXIdJ/vA4ERkX0Fqz6nr2GUhSLm5OKX3SBmKzRmkiAqXWAYn+8DgRGSfQeqsWY/UDXWT4sxBql65jCDVKIQ9UkSOLJbByT4wOBEVjCAVdUMPUjfUqubZBSkZ2gurWAp1yhZHiSKGm4oTUcHH4GQnGJyICnaQ2iNB6tR1XIoxD1IiqLgnagUVQ60yxdTXmkHFEFzSG87OTjY5byK6fwxOdoLBicgxgtS5GwnGob39Z2+qYGVJEXcXFaBMw1T10j5cU4rIzjE42QkGJyLHFHc3Gcej43D0YqxhuxSL8MtxSEpJy9JWOqAq+xc1C1PyvV9RD5ucOxFlxeBkJxiciAqPlNQ0tcK5HqT0rzdum9/AWBfg45ElTFUoVQQuHOojeugYnOwEgxNR4SbDfLIYZ+Ywdeb6bWha1vZebi6oEeRjFqZqlPaBt7urLU6fqNCI5aw6+8DgRESW3E5MMQz1pYepY5dicTw6FneTsw71OTkBFf2KmIWp2kHF4O/jASfZSUQPjMHJTjA4EZG1UtMMt44xDVPyfeYbGuv8irobgpRJMboELFcXZ150olxicLITDE5E9KCuxN3FsUtxhiCVPtR36mo80iwM9Xm4OquhPdOZfTWCiqGoB4f6iHLC4GQnGJyIKD8kJKWqWXymYUq+v5OUarF9uRJeKF/C2/C1pOFrufTHgcU8WZBOhV5sLmqc+M8QIqICRm5ILPfWk02Xlqbh7I07ZmFKvsoq6OdvJqjNElkVvYyvBCkvlPP1RvmSGaFKQpZ/UQ8u6klkwkmTaR+UL9jjRES2JsshnLwaj/M37+D8DUOAOiff30zAxVsJSLE05mfC3cUZZVUPVUag0r+XkCXBikXqVNCxx4mIiJSSRdxRskhJNKlQ0mJB+uXYuzh3wxCkDNsdY7CSW80kpaaponXZLJG6KkOw8kb5TOFKeqxKFXFnsCKHwqE6IqJCShbblGE62cKyWdRTwpMeqEx7qy6oYJWAxJQ0nLp6W22WeLo5Zwz9GUNVxlBgCW83BisqUBiciIjI8geEi7MKN7IBpbLsT5ZgdUuC1R2T3qqMkCX1VbI2VeSVeLVZ4u3ukjH0ZxKqAop5oLiXG4p5uamvHq4u/FMiu8DgRERE98XNxRnBpbzVZoncu0/qqCz1WMnjy7GJaibgicvxasuJDAlKgNK3Ypm+L+bpmu1+CWesw7I/mqYhITkV8XdTEHs3BfGJKeo+kHHyvXouOf05w+O4RMO+hsElMKx9NZudN4MTERHlC3dXZ1TwK6I2S+4mp5oEq4weK6m5un47EbEJhg9PmcIkQ4Jy+xrZcsvV2SkjYJmGqxzClmG/G3w8XTmr0ILk1DRDmMkccNLDjb7pjy23TVF1dvcT2G2JwYmIiGzC080FlfyLqi07ssxCXGIKYhOSEZOQbPyqvr+b8X1MguU2MmtQtuu3k9SWW3JXGx8PVxT3NgQpS0FL/+ruot8Cx0m9Th5JT5fha8bx1DOZ9pvu01+r7zB9TrXX9xuPa75ff6np8TLamj8nPX5xmXt2pNcn/XHmfbHpYcjS7YHul9zXWhZp9UkPqobNLf05VxT1dFXXXn9sGDou5MFp2rRpmDBhAqKjo1GvXj1MmTIFTZs2zbb9rVu38MEHH2DZsmW4ceMGQkJCMHnyZDz55JPGNhcuXMB7772HtWvX4s6dO6hSpQpmz56Nxo0bq/0vv/wy5s6da3bcDh06YN26dcbHFSpUwNmzZ83ajB8/HiNGjMjDn56IiLLjnN5bJFv5+xwKMgathBSToJURsGItBjFDOJDeLgkLsgGW18IqzLzcXIzhRgUfPexkCULynJtJEMoIRwVtKNXmwWnx4sUYPnw4ZsyYgbCwMBWAJMCEh4cjICAgS/ukpCS0b99e7VuyZAnKli2rwo2vb8ZCcDdv3kSLFi3Qpk0bFZz8/f0RERGBEiVKmB2rY8eOKkzpPDw8srzfJ598gv79+xsf+/j45OFPT0RE+UU+jL3d5YPZFUHFvXL9+sSUVLOwJcHK2Jt1J2vQSkk1DDtp6aHN8NXwWL7RB6UMz2mGr+n7TZdUNNtvciz94FmPn/6+6cdDTvvTv6aflVpMVQ80euhRgUYPPCYBKHMYKuLhavNhs0IZnL788ksVTF555RX1WALU6tWrMWvWLIs9O/K89DLt3LkTbm5uxp4hU59//jnKly9vFooqVqyY5VgSlEqXLp3j+UlQulcbIiJyPDKTz99Htqz/qKbCy6ZRUXqPDhw4gHbt2mWckLOzerxr1y6Lr1m5ciWaNWuGQYMGITAwEKGhoRg3bhxSU1PN2siQXPfu3VXPVIMGDfDtt99mOdaWLVvU/urVq2PgwIG4fv16ljafffYZSpUqpY4hw4kpKdJda1liYqJafdR0IyIiIsdh0+B07do1FXgkAJmSx1LvZMmpU6fUEJ28bs2aNfjoo48wceJEjBkzxqzN9OnTUbVqVaxfv16FoqFDh5rVNMkw3Q8//ICNGzeqHqqtW7eiU6dOZgFMXrNo0SJs3rwZr7/+ugpo7777brY/j9Q/yU0C9U16vYiIiMhx2PRedRcvXlQ1SjLsJr1IOgknEmT27NmT5TXVqlXD3bt3cfr0abi4uBiH+6Q36NKlS+qxu7u76nGS45qGoH379mXbkyVhq3Llyvj999/Rtm1bi21kmFACVHx8vMV6KOlxkk0nPU4Snqy52zIRERHZ/73qbNrj5Ofnp8LP5cuXzZ6Xx9nVFQUFBanwpIcmUbNmTdVDJUN/eptatWqZvU7aREVFZXsulSpVUucTGRmZbRspXpehujNnzljcL2FKLrjpRkRERI7DpsFJeoYaNWqkhst0aWlp6rFpD5QpmS0n4Uba6U6cOKHCkhxPbyOz8kxJG1m2IDvnz59XNU5ynOwcOnRI1WBZmu1HREREjs/m8whlKQIp3Jb6o2PHjql6pNu3bxtn2fXp0wcjR440tpf9MqvurbfeUmFIZuBJ7ZEUi+uGDRuG3bt3q+clZC1cuBAzZ840tpGhtnfeeUe1kd4jCWrPPPOMWutJlkIQMqQnSyMcPnxYDeMtWLBAHbdXr15ZljUgIiKiQkKzA1OmTNGCg4M1d3d3rWnTptru3buN+1q1aqX17dvXrP3OnTu1sLAwzcPDQ6tUqZI2duxYLSUlxazNr7/+qoWGhqo2NWrU0GbOnGncd+fOHe2JJ57Q/P39NTc3Ny0kJETr37+/Fh0dbWxz4MAB9R7FixfXPD09tZo1a2rjxo3T7t69a/XPFRMTo5bMkK9ERERkn3LzeW3T4nBHl5tiMyIiIrKNAlMcTkRERFSQMDgRERERWYnBiYiIiMhKDE5EREREBeUmv45Mr7vnPeuIiIjsl/45bc18OQanfBQXF6e+8p51REREBeNzW2bX5YTLEeQjWd1c7sfn4+MDJycnFGb6ffvOnTvHpRl4jQss/h7zOjsK/i6bk54mCU1lypRRdwjJCXuc8pFc/HLlyuXnWxQ4vIcfr7Ej4O8xr7Oj4O9yhnv1NOlYHE5ERERkJQYnIiIiIisxONFD4eHhgVGjRqmvxGtcUPH3mNfZUfB3+f6xOJyIiIjISuxxIiIiIrISgxMRERGRlRiciIiIiKzE4EQ5+uOPP/DUU0+pRcFkEc9ffvklx/ZbtmxR7TJv0dHRFtt/9tlnav/bb7+dZd+uXbvw+OOPo0iRImqtkZYtWyIhIcEh/8RsdZ2lfe/evVG6dGl1nRs2bIilS5fCEeXHNf7444+z7K9Ro4bZce7evYtBgwahVKlSKFq0KLp164bLly/DUdniOt+4cQNDhgxB9erV4eXlheDgYAwdOhQxMTFwRLb6XTZdLLJTp05Wvbcj4gKYlKPbt2+jXr16ePXVV9G1a1err1Z4eLjZCuEBAQFZ2uzbtw/ffPMN6tatazE0dezYESNHjsSUKVPg6uqKw4cP33NF14LKVte5T58+uHXrFlauXAk/Pz8sXLgQzz//PPbv348GDRrAkeTXNa5duzZ+//1342P5XTU1bNgwrF69Gj///LNaYG/w4MHq/Xfs2AFHZIvrLHdokO2LL75ArVq1cPbsWbzxxhvquSVLlsDR2Op3WTd58uTCfTcMjchK8uuyfPnyHNts3rxZtbt582aO7eLi4rSqVatqv/32m9aqVSvtrbfeMtsfFhamffjhh4Xyz+ZhXuciRYpoP/zwg9lzJUuW1L799lvNkeXVNR41apRWr169bPffunVLc3Nz037++Wfjc8eOHVPH3bVrl+boHtZ1tuSnn37S3N3dteTkZM2RPexrfPDgQa1s2bLapUuXrHpvR+SY/3wnm6tfvz6CgoLQvn17i/+ylqGLzp07o127dln2XblyBXv27FH/GmrevDkCAwPRqlUrbN++/SGdfeG4zkKu7+LFi9VQh9xbcdGiRWpoqXXr1g/h7B3jGkdERKghk0qVKuGll15CVFSUcd+BAweQnJxsdv1l+EOGkqRXlfLmOlsiw3TSu5Jdr0lh9KDX+M6dO+jZsyemTZumhvcLKwYnylPyP+WMGTNUnYxscmNf+RD+888/jW3kw1kejx8/3uIxTp06ZRxz79+/P9atW6dqb9q2bav+x6a8uc7ip59+Uh/sUn8jC+K9/vrrWL58OapUqVLoL7M11zgsLAxz5sxRv6PTp0/H6dOn8dhjj6mbhQqpIXF3d4evr6/Z9ZR/DGRXj1bY5MV1zuzatWv49NNPMWDAgIf4kzj+NZZh5+bNm+OZZ55BoWbrLi8qOO63W7Zly5Zar1691PdRUVFaQECAdvjwYeP+zENIO3bsUO81cuRIs+PUqVNHGzFihOboHtZ1FoMHD9aaNm2q/f7779qhQ4e0jz/+WCtevLh25MgRzZHlxTW2RIZCihUrpn333Xfq8YIFC9RwUWZNmjTR3n33Xc3RPazrbComJkb9Tnfs2FFLSkrSHN3DusYrVqzQqlSpoob/H/S9Czr2OFG+a9q0KSIjI41DFzIUJz1I0oUu29atW/H111+r71NTU9W/joQUeZqqWbPmPbvnC7PcXueTJ09i6tSpmDVrlurNk2JTuS1O48aNVVc85XyNLZGepWrVqhnbyHBGUlKSKsA3JbPqCvNQR15fZ530jsikEh8fH9Vz6ubm9hDOtnBc402bNqm/M3x9fY1/pwiZJVrYhvYZnCjfHTp0yBiG5AP6r7/+Us/pm3xQy3i6fO/i4oIKFSqocXaZAWLqxIkTCAkJ4Z9YHl1nqVcQmWcqyj6pd6Kcr7El8fHx6sNFb9OoUSP14b1x40ZjG/m9ln8ANGvWjJc4j66ziI2NxRNPPKGGRmWWqKenJ69vHl7jESNG4MiRI2Z/p4hJkyZh9uzZhepas2qOciT/85j+q0TGveV/mJIlS6oCV1ku4MKFC/jhhx+M01QrVqyoprVKkfF3332n/qWyYcMGtV/+JRgaGmr2HrJ+kNTY6M/LNNd33nlH9X5IL4gUNM6dOxfHjx93yKnFtrrOUqQstUxS1yTTuGWfrMny22+/YdWqVXA0eX2Nxf/93/+p9XQk0MvUd/mdleDZo0cPtV+WH+jXrx+GDx+u3keKlWW9IQlNjzzyCByRLa6zHprkHwPz589Xj2UT/v7+qq0jscU1lh5SS72kwcHB6tiFiq3HCsm+6dNYM299+/ZV++Wr1M7oPv/8c61y5cqap6enmtbeunVrbdOmTTm+h6XaGzF+/HitXLlymre3t9asWTNt27ZtmqOy1XU+ceKE1rVrV1UPJde5bt26WZYncBT5cY1feOEFLSgoSNUxyRRteRwZGWnWJiEhQXvzzTe1EiVKqGv87LPPqqncjsoW1zm795Tt9OnTmqOx1e9yZiikNU5O8h9bhzciIiKigoA1TkRERERWYnAiIiIishKDExEREZGVGJyIiIiIrMTgRERERGQlBiciIiIiKzE4EREREVmJwYmIiIjISgxOROTQ5BY+cisZe/Dxxx+rWwjdj969e2PcuHHIb3JPMrktDBFZxuBERGTnge3w4cNYs2YNhg4divwm9yyTe0OeOnUq39+LqCBicCIisnNTpkxB9+7dUbRo0Xx/Lz8/P3To0AHTp0/P9/ciKogYnIgoT6xatQq+vr5ITU1Vj+Vu7dLrIkM/utdeew29evVS31+/fl3deb1s2bLw9vZGnTp18OOPPxrbzpw5E2XKlEFaWprZ+zzzzDN49dVXjY9XrFiBhg0bwtPTE5UqVcLo0aORkpKS7XmeO3cOzz//vDpXuZu8HO/MmTPG/S+//DK6dOmCL774AkFBQShVqhQGDRqE5ORkY5tLly6hc+fO8PLyUneGX7hwISpUqKDuQi/ke/Hss8+qa6A/1s2bN089V7x4cbz44ouIi4vL9nzlei5ZskTduf5ePVryM82ZM0d9Lz+TtPnpp5/w2GOPqXNt0qQJTpw4gX379qFx48YqiHXq1AlXr141O46816JFi7I9J6LCjMGJiPKEfDhLADh48KB6vHXrVtV7sWXLFmMbea5169bq+7t376JRo0ZYvXo1/v77bwwYMEDV8ezdu1ftlx4WCVebN282vv7GjRtYt24dXnrpJfV427Zt6NOnD9566y0cPXoU33zzjQoOY8eOtXiOEn6kN8XHx0e9dseOHSo8dOzYEUlJScZ28p4nT55UX2XYSo6pBxIh73nx4kX1sy1dulSFvCtXrhj3SzARs2fPViFLfyzkuBJ4JGjKJtfks88+y/a6HjlyBDExMSro3I9Ro0bhww8/xJ9//glXV1f07NkT7777Lr766it1DSIjI/Gf//zH7DVNmzbF+fPnzQIlEaXTiIjySMOGDbUJEyao77t06aKNHTtWc3d31+Li4rTz589r8lfOiRMnsn19586dtX//+9/Gx88884z26quvGh9/8803WpkyZbTU1FT1uG3bttq4cePMjjFv3jwtKCjI+Fjec/ny5cZ91atX19LS0oz7ExMTNS8vL239+vXqcd++fbWQkBAtJSXF2KZ79+7aCy+8oL4/duyYOua+ffuM+yMiItRzkyZNsvi+ulGjRmne3t5abGys8bl33nlHCwsLy/aayDFcXFzMzjm74xcvXlybPXu2+v706dOqzXfffWfc/+OPP6rnNm7caHxu/Pjx6pqYiomJUe22bNmS7XkRFVbscSKiPNOqVSvVCyOf69Kb0bVrV9SsWRPbt29XPSsy9Fa1alXjENSnn36qhuhkyEx6ftavX4+oqCjj8aRnSXp0EhMT1eMFCxaooS1nZ2dj0fQnn3yiXqtv/fv3V708d+7cyXJ+0l56WKTHSW8v7y29X9ITpKtduzZcXFyMj2XITu9RCg8PVz03Mjyoq1KlCkqUKGHVNZIhOnl/S8e2JCEhAR4eHmrY7X7UrVvX+H1gYKD6Ktfc9LnM7y/DesLSNSQq7FxtfQJE5DhkGG7WrFkqoLi5uaFGjRrqOQlTN2/eVMFKN2HCBDVcJHVB8kFepEgRvP3222ZDZlJrIyFMhvOkPkfC2KRJk4z74+PjVU2TBLTMpOYpM2kvw4MSwDLz9/c3fi/nbkpCS+Zaq/uV22PLcKcEGLku7u7uZq8zdDxlMK3DsvR+evjK/Fzm95ch0czXhIgMGJyIKM/rnCTc6CFJgpPU8Ehw+ve//21sK/VFUpitF4vLh7cULteqVcss/EgokqAjPUXVq1c36+mR76UHSHp8rCHtFy9ejICAABQrVuy+fkY5Byk+l1ouCWFCzk1+PlMSTvRC+Qehr/skNVyma0BJqJGeNV1ERESe9RBJzZmcv/S8EZE5DtURUZ6R4SoZGpKgoxeBt2zZUhUmSygy7XGSIbvffvsNO3fuxLFjx/D666/j8uXLWY4pw3XS4yQ9WXpRuE6Kmn/44QfV6/TPP/+o48hsMCmGtkReLz04Etik9+r06dOqN0zWR5JiaGtIL1q7du1UMbsUskuAku9leMt0OE2G5DZu3Ijo6OgsoSo3JCBJ4JPhTlOPP/44pk6dqt5///79eOONN7L0Zt0vuTb6TDwiMsfgRER5SsKR9LTowUlqiKQXqXTp0qq3RifhRgKBzHKTtrJflgHITAKCHEN6lmRGmCl5rcxM27BhgxrKe+SRR1RvV0hIiMVzk2UP/vjjDwQHBxvrr/r166dqnHLTAyVhTWqDJBTKkgNSVyV1S6bDgxMnTlTBsHz58mjQoAEehCzjkHl4UY4vx5aAI9dFFq6Uny8vSPiUn4mIsnKSCnELzxMRkZWkt0pCzO+//462bdvm+XWTAnEJnTLM2KxZs3z9c1m7dq0aUpVlEKQInojM8f8KIqJc2rRpkyo0l6J2qTOSdZFkaE56oPKDDJlJL9e1a9fy/c/q9u3bav0phiYiy9jjRESUS7JsgvTKyP3cZIiuefPmanZgdkOEROQ4GJyIiIiIrMTicCIiIiIrMTgRERERWYnBiYiIiMhKDE5EREREVmJwIiIiIrISgxMRERGRlRiciIiIiKzE4ERERERkJQYnIiIiIljn/wEcTadWrTWJegAAAABJRU5ErkJggg==",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 600x400 with 1 Axes>"
       ]
@@ -1248,28 +2183,36 @@
     "    if key in result_eim.s_params:\n",
     "        ax.plot(\n",
     "            result_eim.wavelengths,\n",
-    "            np.abs(result_eim.s_params[key]),\n",
+    "            np.abs(result_eim.s_params[key])**2,\n",
     "            color + \"-\",\n",
     "            label=f\"{key} 2D varEIM\",\n",
     "        )\n",
     "    if key in result.s_params:\n",
     "        ax.plot(\n",
     "            result.wavelengths,\n",
-    "            np.abs(result.s_params[key]),\n",
+    "            np.abs(result.s_params[key])**2,\n",
     "            color + \"--\",\n",
     "            label=f\"{key} 3D\",\n",
     "        )\n",
     "ax.set_xlabel(\"wavelength (um)\")\n",
-    "ax.set_ylabel(\"|S| magnitude\")\n",
+    "ax.set_ylabel(\"|S|^2\")\n",
     "ax.legend()\n",
     "plt.tight_layout()\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fcb47864",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "gsim",
+   "display_name": "gsim (3.12.12)",
    "language": "python",
    "name": "python3"
   },

From e83ac92914c5abacf293adf06b37d5263a00261b Mon Sep 17 00:00:00 2001
From: thanojo <86444011+thanojo@users.noreply.github.com>
Date: Tue, 16 Jun 2026 00:03:57 +0200
Subject: [PATCH 5/6] Update python equivalent script accordingly #156

---
 nbs/meep_ybranch_veim.py | 56 +++++++++++++++++++---------------------
 1 file changed, 27 insertions(+), 29 deletions(-)

diff --git a/nbs/meep_ybranch_veim.py b/nbs/meep_ybranch_veim.py
index 03493381..0ca2c589 100644
--- a/nbs/meep_ybranch_veim.py
+++ b/nbs/meep_ybranch_veim.py
@@ -1,28 +1,14 @@
-# ---
-# jupyter:
-#   jupytext:
-#     text_representation:
-#       extension: .py
-#       format_name: percent
-#       format_version: '1.3'
-#       jupytext_version: 1.19.2
-#   kernelspec:
-#     display_name: gsim
-#     language: python
-#     name: python3
-# ---
-
 # %% [markdown]
 # # MEEP Y-branch: 3D and 2D variational EIM
-#
+# 
 # [MEEP](https://meep.readthedocs.io/) is an open-source FDTD electromagnetic
 # simulator. This notebook reproduces the 3D S-parameter simulation of the
 # photonic Y-branch from the [MEEP example](./meep_ybranch.py), then repeats it
 # as a fast **2D variational effective-index (varEIM)** simulation and compares
 # the two.
-#
+# 
 # **Requirements:**
-#
+# 
 # - UBC PDK: `uv pip install ubcpdk`
 # - [GDSFactory+](https://gdsfactory.com) account for cloud simulation
 
@@ -43,13 +29,17 @@
 # %%
 from gsim import meep
 from gsim.common.stack import get_stack
+from gsim.meep.models.api import Material
 
 stack = get_stack()  # auto-detects active PDK
 
 sim = meep.Simulation()
 
 sim.geometry(component=c, stack=stack, z_crop="auto")
-sim.materials = {"si": 3.47, "SiO2": 1.44}
+sim.materials = {
+    "si": Material(refractive_index=3.47),
+    "SiO2": Material(refractive_index=1.44)
+}
 sim.source(port="o1", wavelength=1.55, wavelength_span=0.01)
 sim.monitors = ["o1", "o2", "o3"]
 sim.domain(pml=1.0, margin=0.5)
@@ -76,23 +66,23 @@
 
 # %% [markdown]
 # ## 2D variational effective-index simulation
-#
+# 
 # A 2D FDTD (`sim.solver.is_3d = False`) collapses the z-dimension and is
 # 10-100x faster. Instead of substituting bulk indices, varEIM derives the
 # in-plane permittivity from the vertical slab mode of the 3D stack
 # (Hammer & Ivanova 2009):
-#
+# 
 # $$\varepsilon_\mathrm{eff}(x,y) = n_\mathrm{eff}^2(\mathbf{r}) +
 #   \frac{\int dz\,[\varepsilon(x,y,z) - \varepsilon(\mathbf{r},z)]\,
 #   |\Phi_\mathbf{r}(z)|^2}{\int dz\,|\Phi_\mathbf{r}(z)|^2}$$
-#
+# 
 # A Y-branch is a good candidate: it splits power by adiabatic mode evolution
 # along a propagating taper, which varEIM (accurate for propagation) captures
 # well.
 
 # %% [markdown]
 # ### Effective indices from the vertical slab mode
-#
+# 
 # Evaluate at a core point on the input waveguide and a cladding point beside
 # it, both referenced to the same slab mode. The core returns the slab effective
 # index; the cladding is clamped to the physical oxide permittivity.
@@ -120,16 +110,19 @@
 
 # %% [markdown]
 # ### Configure and run the 2D simulation
-#
+# 
 # Same source, monitors, domain and solver settings as the 3D run, but
 # `is_3d=False` and the varEIM material indices.
 
 # %%
-eim_sim.materials = {"si": n_core, "SiO2": n_background}
+eim_sim.materials = {
+    "si": Material(refractive_index=n_core),
+    "SiO2": Material(refractive_index=n_background)
+}
 eim_sim.source(port="o1", wavelength=1.55, wavelength_span=0.01)
 eim_sim.monitors = ["o1", "o2", "o3"]
 eim_sim.domain(pml=1.0, margin=0.5)
-eim_sim.solver(resolution=20, simplify_tol=0.01, is_3d=False)
+eim_sim.solver(resolution=25, simplify_tol=0.01, is_3d=False)
 eim_sim.solver.stop_when_energy_decayed()
 
 print(eim_sim.validate_config())
@@ -142,7 +135,7 @@
 
 # %% [markdown]
 # ### Compare 2D varEIM vs 3D
-#
+# 
 # Overlay the transmission into the two output arms (`S21`, `S31`).
 
 # %%
@@ -153,19 +146,24 @@
     if key in result_eim.s_params:
         ax.plot(
             result_eim.wavelengths,
-            np.abs(result_eim.s_params[key]),
+            np.abs(result_eim.s_params[key])**2,
             color + "-",
             label=f"{key} 2D varEIM",
         )
     if key in result.s_params:
         ax.plot(
             result.wavelengths,
-            np.abs(result.s_params[key]),
+            np.abs(result.s_params[key])**2,
             color + "--",
             label=f"{key} 3D",
         )
 ax.set_xlabel("wavelength (um)")
-ax.set_ylabel("|S| magnitude")
+ax.set_ylabel("|S|^2")
 ax.legend()
 plt.tight_layout()
 plt.show()
+
+# %%
+
+
+

From dd9c1327ad9117eab7972d54a7e7f223662c2688 Mon Sep 17 00:00:00 2001
From: thanojo <86444011+thanojo@users.noreply.github.com>
Date: Tue, 16 Jun 2026 09:23:05 +0200
Subject: [PATCH 6/6] Refactor markdown comments and fix formatting #156

---
 nbs/meep_ybranch_veim.ipynb | 12 +++++------
 nbs/meep_ybranch_veim.py    | 43 +++++++++++++++++++++++--------------
 2 files changed, 33 insertions(+), 22 deletions(-)

diff --git a/nbs/meep_ybranch_veim.ipynb b/nbs/meep_ybranch_veim.ipynb
index cb8c6504..53650840 100644
--- a/nbs/meep_ybranch_veim.ipynb
+++ b/nbs/meep_ybranch_veim.ipynb
@@ -89,7 +89,7 @@
     "sim.geometry(component=c, stack=stack, z_crop=\"auto\")\n",
     "sim.materials = {\n",
     "    \"si\": Material(refractive_index=3.47),\n",
-    "    \"SiO2\": Material(refractive_index=1.44)\n",
+    "    \"SiO2\": Material(refractive_index=1.44),\n",
     "}\n",
     "sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
     "sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
@@ -223,7 +223,7 @@
           -3.3504859863629974,
           -3.3525045672498903,
           -3.354421375693132,
-          -3.3562363441997762,
+          -3.356236344199776,
           -3.357936623514986
          ]
         },
@@ -1181,7 +1181,7 @@
           -125.89079999999998,
           -125.0631,
           -124.4172,
-          -123.93880000000001,
+          -123.9388,
           -123.6061,
           -123.39019999999998
          ]
@@ -2114,7 +2114,7 @@
    "source": [
     "eim_sim.materials = {\n",
     "    \"si\": Material(refractive_index=n_core),\n",
-    "    \"SiO2\": Material(refractive_index=n_background)\n",
+    "    \"SiO2\": Material(refractive_index=n_background),\n",
     "}\n",
     "eim_sim.source(port=\"o1\", wavelength=1.55, wavelength_span=0.01)\n",
     "eim_sim.monitors = [\"o1\", \"o2\", \"o3\"]\n",
@@ -2183,14 +2183,14 @@
     "    if key in result_eim.s_params:\n",
     "        ax.plot(\n",
     "            result_eim.wavelengths,\n",
-    "            np.abs(result_eim.s_params[key])**2,\n",
+    "            np.abs(result_eim.s_params[key]) ** 2,\n",
     "            color + \"-\",\n",
     "            label=f\"{key} 2D varEIM\",\n",
     "        )\n",
     "    if key in result.s_params:\n",
     "        ax.plot(\n",
     "            result.wavelengths,\n",
-    "            np.abs(result.s_params[key])**2,\n",
+    "            np.abs(result.s_params[key]) ** 2,\n",
     "            color + \"--\",\n",
     "            label=f\"{key} 3D\",\n",
     "        )\n",
diff --git a/nbs/meep_ybranch_veim.py b/nbs/meep_ybranch_veim.py
index 0ca2c589..6d3269bd 100644
--- a/nbs/meep_ybranch_veim.py
+++ b/nbs/meep_ybranch_veim.py
@@ -1,14 +1,28 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.2
+#   kernelspec:
+#     display_name: gsim (3.12.12)
+#     language: python
+#     name: python3
+# ---
+
 # %% [markdown]
 # # MEEP Y-branch: 3D and 2D variational EIM
-# 
+#
 # [MEEP](https://meep.readthedocs.io/) is an open-source FDTD electromagnetic
 # simulator. This notebook reproduces the 3D S-parameter simulation of the
 # photonic Y-branch from the [MEEP example](./meep_ybranch.py), then repeats it
 # as a fast **2D variational effective-index (varEIM)** simulation and compares
 # the two.
-# 
+#
 # **Requirements:**
-# 
+#
 # - UBC PDK: `uv pip install ubcpdk`
 # - [GDSFactory+](https://gdsfactory.com) account for cloud simulation
 
@@ -38,7 +52,7 @@
 sim.geometry(component=c, stack=stack, z_crop="auto")
 sim.materials = {
     "si": Material(refractive_index=3.47),
-    "SiO2": Material(refractive_index=1.44)
+    "SiO2": Material(refractive_index=1.44),
 }
 sim.source(port="o1", wavelength=1.55, wavelength_span=0.01)
 sim.monitors = ["o1", "o2", "o3"]
@@ -66,23 +80,23 @@
 
 # %% [markdown]
 # ## 2D variational effective-index simulation
-# 
+#
 # A 2D FDTD (`sim.solver.is_3d = False`) collapses the z-dimension and is
 # 10-100x faster. Instead of substituting bulk indices, varEIM derives the
 # in-plane permittivity from the vertical slab mode of the 3D stack
 # (Hammer & Ivanova 2009):
-# 
+#
 # $$\varepsilon_\mathrm{eff}(x,y) = n_\mathrm{eff}^2(\mathbf{r}) +
 #   \frac{\int dz\,[\varepsilon(x,y,z) - \varepsilon(\mathbf{r},z)]\,
 #   |\Phi_\mathbf{r}(z)|^2}{\int dz\,|\Phi_\mathbf{r}(z)|^2}$$
-# 
+#
 # A Y-branch is a good candidate: it splits power by adiabatic mode evolution
 # along a propagating taper, which varEIM (accurate for propagation) captures
 # well.
 
 # %% [markdown]
 # ### Effective indices from the vertical slab mode
-# 
+#
 # Evaluate at a core point on the input waveguide and a cladding point beside
 # it, both referenced to the same slab mode. The core returns the slab effective
 # index; the cladding is clamped to the physical oxide permittivity.
@@ -110,14 +124,14 @@
 
 # %% [markdown]
 # ### Configure and run the 2D simulation
-# 
+#
 # Same source, monitors, domain and solver settings as the 3D run, but
 # `is_3d=False` and the varEIM material indices.
 
 # %%
 eim_sim.materials = {
     "si": Material(refractive_index=n_core),
-    "SiO2": Material(refractive_index=n_background)
+    "SiO2": Material(refractive_index=n_background),
 }
 eim_sim.source(port="o1", wavelength=1.55, wavelength_span=0.01)
 eim_sim.monitors = ["o1", "o2", "o3"]
@@ -135,7 +149,7 @@
 
 # %% [markdown]
 # ### Compare 2D varEIM vs 3D
-# 
+#
 # Overlay the transmission into the two output arms (`S21`, `S31`).
 
 # %%
@@ -146,14 +160,14 @@
     if key in result_eim.s_params:
         ax.plot(
             result_eim.wavelengths,
-            np.abs(result_eim.s_params[key])**2,
+            np.abs(result_eim.s_params[key]) ** 2,
             color + "-",
             label=f"{key} 2D varEIM",
         )
     if key in result.s_params:
         ax.plot(
             result.wavelengths,
-            np.abs(result.s_params[key])**2,
+            np.abs(result.s_params[key]) ** 2,
             color + "--",
             label=f"{key} 3D",
         )
@@ -164,6 +178,3 @@
 plt.show()
 
 # %%
-
-
-