ex2-large-area-small-range-tunable.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"GZHYzPWq2fhU"},"source":["# Example 2: tunable part with large area and tiny $\\varepsilon_r$ range\n","\n","In this example, we consider the whole design region under modulation where the dielectric constant can be varied only a little. The goal is to design a compact 1-to-3 optical switch."]},{"cell_type":"code","source":["from google.colab import drive\n","drive.mount('/content/gdrive')\n","%cd /content/gdrive/MyDrive/research/meta-learnt-optical-switch"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"iiasZCnkaDHl","executionInfo":{"status":"ok","timestamp":1679764452014,"user_tz":420,"elapsed":29200,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"5e2ec7b7-26de-4987-e854-b3a17066b16f"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/gdrive\n","/content/gdrive/MyDrive/research/meta-learnt-optical-switch\n"]}]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"gaASFZyQzMQg","outputId":"0f7354b1-61b7-488b-acc1-a66603a76c7b","executionInfo":{"status":"ok","timestamp":1679764461338,"user_tz":420,"elapsed":9330,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting git+https://github.com/fancompute/ceviche.git\n","  Cloning https://github.com/fancompute/ceviche.git to /tmp/pip-req-build-vjf6983d\n","  Running command git clone --filter=blob:none --quiet https://github.com/fancompute/ceviche.git /tmp/pip-req-build-vjf6983d\n","  Resolved https://github.com/fancompute/ceviche.git to commit dcb8587c46e8e64b281004c3dee02a8ecd139721\n","  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: numpy>=1.16.2 in /usr/local/lib/python3.8/dist-packages (from ceviche==0.1.3) (1.22.4)\n","Requirement already satisfied: scipy>=1.2.1 in /usr/local/lib/python3.8/dist-packages (from ceviche==0.1.3) (1.7.3)\n","Requirement already satisfied: matplotlib>=3.0.3 in /usr/local/lib/python3.8/dist-packages (from ceviche==0.1.3) (3.5.3)\n","Requirement already satisfied: autograd>=1.3 in /usr/local/lib/python3.8/dist-packages (from ceviche==0.1.3) (1.5)\n","Collecting pyMKL>=0.0.3\n","  Downloading pyMKL-0.0.3.tar.gz (5.6 kB)\n","  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: future>=0.15.2 in /usr/local/lib/python3.8/dist-packages (from autograd>=1.3->ceviche==0.1.3) (0.16.0)\n","Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (4.38.0)\n","Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (8.4.0)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (0.11.0)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (1.4.4)\n","Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (2.8.2)\n","Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (3.0.9)\n","Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.0.3->ceviche==0.1.3) (23.0)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.7->matplotlib>=3.0.3->ceviche==0.1.3) (1.15.0)\n","Building wheels for collected packages: ceviche, pyMKL\n","  Building wheel for ceviche (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for ceviche: filename=ceviche-0.1.3-py3-none-any.whl size=32597 sha256=c1aebfb70dce4fad4085f1477f66834ada126641caa541928783bde2984f55be\n","  Stored in directory: /tmp/pip-ephem-wheel-cache-ga99ocff/wheels/a5/b4/1f/0c75dd0e0440bc090abe88f3cf5075526cb16c7e30236c728c\n","  Building wheel for pyMKL (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for pyMKL: filename=pyMKL-0.0.3-py3-none-any.whl size=6748 sha256=bf1b061ce7378a254ea45c9906bf987394081de9270d0f287ed1375ff47fe96d\n","  Stored in directory: /root/.cache/pip/wheels/33/cb/ef/d42f20635ef9ffcf573867587df75861aaf48dfc0cec04da47\n","Successfully built ceviche pyMKL\n","Installing collected packages: pyMKL, ceviche\n","Successfully installed ceviche-0.1.3 pyMKL-0.0.3\n"]}],"source":["!pip install git+https://github.com/fancompute/ceviche.git"]},{"cell_type":"code","execution_count":3,"metadata":{"id":"lKkwWHYpzXX2","executionInfo":{"status":"ok","timestamp":1679764462170,"user_tz":420,"elapsed":836,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["import sys, os\n","sys.path.append('/Users/beicheng/Downloads/ceviche-master-original')\n","\n","import numpy as np\n","import autograd.numpy as npa\n","import pickle\n","\n","import copy\n","\n","import matplotlib as mpl\n","mpl.rcParams['figure.dpi']=100\n","\n","import matplotlib.pylab as plt\n","\n","from autograd.scipy.signal import convolve as conv\n","from skimage.draw import disk\n","from tqdm import tqdm\n","\n","import ceviche\n","from ceviche import fdfd_ez, jacobian\n","from ceviche.optimizers import adam_optimize\n","from ceviche.modes import insert_mode\n","\n","import collections\n","# Create a container for our slice coords to be used for sources and probes\n","Slice = collections.namedtuple('Slice', 'x y')"]},{"cell_type":"code","execution_count":4,"metadata":{"id":"bnldrZj_zbyX","executionInfo":{"status":"ok","timestamp":1679764462171,"user_tz":420,"elapsed":7,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["# Projection that drives rho towards a \"binarized\" design with values either 0 or 1 \n","def operator_proj(rho, eta=0.5, beta=100, N=1):\n","    \"\"\"Density projection\n","    eta     : Center of the projection between 0 and 1\n","    beta    : Strength of the projection\n","    N       : Number of times to apply the projection\n","    \"\"\"\n","    for i in range(N):\n","        rho =  npa.divide(npa.tanh(beta * eta) + npa.tanh(beta * (rho - eta)), \n","                          npa.tanh(beta * eta) + npa.tanh(beta * (1 - eta)))\n","    \n","    return rho\n","\n","# Blurring filter that results in smooth features of the structure\n","# First we define a function to create the kernel\n","def _create_blur_kernel(radius):\n","    \"\"\"Helper function used below for creating the conv kernel\"\"\"\n","#     rr, cc = circle(radius, radius, radius+1)\n","    rr, cc = disk((radius, radius), radius+1)\n","    kernel = np.zeros((2*radius+1, 2*radius+1), dtype=np.float)\n","    kernel[rr, cc] = 1\n","    return  kernel/kernel.sum()\n","\n","# Then we define the function to apply the operation\n","def operator_blur(rho, radius=2, N=1):\n","    \"\"\"Blur operator implemented via two-dimensional convolution\n","    radius    : Radius of the circle for the conv kernel filter\n","    N         : Number of times to apply the filter\n","    \n","    Note that depending on the radius, the kernel is not always a\n","    perfect circle due to \"pixelation\" / stair casing\n","    \"\"\"\n","    \n","    kernel = _create_blur_kernel(radius)\n","    \n","    for i in range(N):\n","        # For whatever reason HIPS autograd doesn't support 'same' mode, so we need to manually crop the output\n","        rho = conv(rho, kernel, mode='full')[radius:-radius,radius:-radius]\n","    \n","    return rho"]},{"cell_type":"code","execution_count":5,"metadata":{"id":"cK18zVc_0BWN","executionInfo":{"status":"ok","timestamp":1679764462171,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["directory = 'ex2/'\n","if not os.path.exists(directory):\n","    os.makedirs(directory)\n","\n","EPS_MIN_ROD = 0.9\n","EPS_MAX_ROD = 1.1"]},{"cell_type":"code","execution_count":6,"metadata":{"id":"jVVV8mDW0KlU","executionInfo":{"status":"ok","timestamp":1679764462172,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["# Angular frequency of the source in 1/s\n","omega=2*np.pi*200e12\n","# Spatial resolution in meters\n","dl=40e-9\n","# Number of pixels in x-direction\n","Nx=120\n","# Number of pixels in y-direction\n","Ny=120\n","# Number of pixels in the PMLs in each direction\n","Npml=20\n","# Minimum value of the relative permittivity\n","epsr_min=1.0\n","# Maximum value of the relative permittivity\n","epsr_max=12.0\n","# Radius of the smoothening features\n","blur_radius=5\n","# Number of times to apply the blur\n","N_blur=1\n","# Strength of the binarizing projection\n","# beta=500.0\n","beta=5.0\n","# Middle point of the binarizing projection\n","eta=0.5\n","# Number of times to apply the blur\n","N_proj=1\n","# Space between the PMLs and the design region (in pixels)\n","space=10\n","# Width of the waveguide (in pixels)\n","wg_width=11\n","# Length in pixels of the source/probe slices on each side of the center point\n","space_slice=2\n","\n","# Number of epochs in the optimization \n","Nsteps=50\n","# Step size for the Adam optimizer\n","step_size=2e-4"]},{"cell_type":"code","execution_count":7,"metadata":{"id":"3LP5S-K-0SPB","executionInfo":{"status":"ok","timestamp":1679764462320,"user_tz":420,"elapsed":154,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["### locations of the 3 output waveguides, in units of pixels\n","output_offs = [-18,0,18]\n","def init_domain(Nx, Ny, Npml, space=10, wg_width=10, space_slice=5, offset=0):\n","    \"\"\"Initializes the domain and design region\n","\n","    space       : The space between the PML and the structure\n","    wg_width    : The feed and probe waveguide width\n","    space_slice : The added space for the probe and source slices\n","    \"\"\"\n","    rho = np.zeros((Nx, Ny))  \n","    bg_rho = np.zeros((Nx, Ny))  \n","    design_region = np.zeros((Nx, Ny))\n","    \n","    # Input waveguide\n","    bg_rho[0:int(Npml+space),Ny//2-wg_width//2:Ny//2+wg_width//2+0] = 1\n","\n","    # Input probe slice\n","    input_slice = Slice(x=np.array(Npml+0), \n","        y=np.arange(Ny//2-wg_width//2-space_slice, Ny//2+wg_width//2+space_slice+0))\n","    \n","    # Output waveguide \n","    for off in output_offs: ### now putting all 3 waveguides there\n","        bg_rho[int(Nx-Npml-space)::,Ny//2-wg_width//2-off:Ny//2+wg_width//2+0-off] = 1\n","    \n","    # Output probe slice\n","    output_slice = Slice(x=np.array(Nx-Npml-1), \n","                        y=np.arange(Ny//2-wg_width//2-space_slice-offset, Ny//2+wg_width//2+space_slice+0-offset))\n","    \n","    design_region[Npml+space:Nx-Npml-space, Npml+space:Ny-Npml-space] = 1\n","    \n","    # Const init\n","    rho[Npml+space:Nx-Npml-space, Npml+space:Ny-Npml-space] = 0.5\n","    # Random init\n","    # rho = design_region * np.random.rand(Nx, Ny)\n","\n","    return rho, bg_rho, design_region, input_slice, output_slice\n","\n","\n","def viz_sim(epsr, source, slices=[], wantabs = False, ax_to_use=None):\n","    \"\"\"Solve and visualize a simulation with permittivity 'epsr'\n","    \"\"\"\n","    simulation = fdfd_ez(omega, dl, epsr, [Npml, Npml])\n","    Hx, Hy, Ez = simulation.solve(source)\n","    \n","    if ax_to_use is None:\n","        fig, ax = plt.subplots(1, 2, constrained_layout=True, figsize=(6,3))\n","    else:\n","        assert len(ax_to_use)>=2, \"viz_sim needs at least two axes for plotting\"\n","        ax = ax_to_use\n","    if wantabs:\n","        ceviche.viz.abs(Ez, outline=epsr, ax=ax[0], cbar=False)\n","    else:\n","        ceviche.viz.real(Ez, outline=epsr, ax=ax[0], cbar=False)\n","    for sl in slices:\n","        ax[0].plot(sl.x*np.ones(len(sl.y)), sl.y, 'b-')\n","    ceviche.viz.abs(epsr, ax=ax[1], cmap='Greys');\n","    \n","    return (simulation, ax)\n","\n","def viz_abs(val, outline=None, ax=None, cbar=False, cmap='magma', outline_alpha=0.5, outline_val=None): ### copied from ceviche and customized for paper\n","    if ax is None:\n","        fig, ax = plt.subplots(1, 1, constrained_layout=True)      \n","    vmax = np.abs(val).max()\n","    h = ax.imshow(np.abs(val.T), cmap=cmap, origin='lower', vmin=0, vmax=vmax)  \n","    if outline_val is None and outline is not None: outline_val = 0.5*(outline.min()+outline.max())\n","    if outline is not None:\n","        ax.contour(outline.T, [outline_val], colors='yellow', alpha=outline_alpha)\n","    ax.set_ylabel('y (µm)')\n","    ax.set_xlabel(r'x (µm)')\n","    ax.set_xticks([0,40,80,119])\n","    ax.set_yticks([0,40,80,119])\n","    ax.set_xticklabels([0,1.6,3.2,4.8])\n","    ax.set_yticklabels([0,1.6,3.2,4.8])\n","    if cbar:\n","        plt.colorbar(h, ax=ax)\n","    return \n","\n","def viz_sim_for_paper(epsr, source, slices=[], wantabs = False, ax_to_use=None, different_outline = None):\n","    \"\"\"Solve and visualize a simulation with permittivity 'epsr'\n","    \"\"\"\n","    simulation = fdfd_ez(omega, dl, epsr, [Npml, Npml])\n","    Hx, Hy, Ez = simulation.solve(source)\n","    if different_outline is None:\n","        different_outline = epsr\n","    \n","    if ax_to_use is None:\n","        fig, ax = plt.subplots(1, 2, constrained_layout=True, figsize=(6,3))\n","    else:\n","        assert len(ax_to_use)>=2, \"viz_sim needs at least two axes for plotting\"\n","        ax = ax_to_use\n","    if wantabs:\n","        viz_abs(Ez, outline=different_outline, ax=ax[0], cbar=False)\n","    else:\n","        print(\"Go copy viz.real here too\")\n","    for sl in slices:\n","        ax[0].plot(sl.x*np.ones(len(sl.y)), sl.y, 'b-')\n","    viz_abs(epsr, outline=different_outline, ax=ax[1], cmap='Greys');\n","    \n","    return (simulation, ax)\n","\n","def mask_combine_rho(rho, bg_rho, design_region):\n","    \"\"\"Utility function for combining the design region rho and the background rho\n","    \"\"\"\n","    return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","\n","def mode_overlap(E1, E2):\n","    \"\"\"Defines an overlap integral between the sim field and desired field\n","    \"\"\"\n","    return npa.abs(npa.sum(npa.conj(E1)*E2))\n","def field_mag_int(E, mask):\n","    \"\"\"\n","    Computes the integral of |E|^2 over a given mask\n","\n","    Args:\n","        E: matrix containing field values\n","        mask: matrix where all entries are zero except the entries over which\n","        you would like to integrate\n","    \"\"\"\n","    return npa.abs(npa.sum(npa.multiply(npa.multiply(npa.conj(E), E), mask)))*1e6"]},{"cell_type":"code","execution_count":8,"metadata":{"id":"ZuU6Qucg0XP5","executionInfo":{"status":"ok","timestamp":1679764462320,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def cylinders(coor_list,r_list,eps_list,domain_x=10,domain_y=10,Nx=100,Ny=100,edge_sharpness = 5e0):\n","    xs = npa.linspace(-domain_x,domain_x,Nx)\n","    ys = npa.linspace(-domain_y,domain_y,Ny)\n","    ys, xs = npa.meshgrid(ys,xs)\n","    dist = npa.zeros([Nx,Ny])\n","    mask = np.zeros([Nx, Ny])\n","    for i, coor in enumerate(coor_list):\n","        x = coor[0]\n","        y = coor[1]\n","        r = r_list[i]\n","        eps = eps_list[i]\n","        dist += (1-npa.tanh(((xs-x)**2 + (ys-y)**2 - r**2)*edge_sharpness))/2*eps\n","        mask += (1-npa.tanh(((xs-x)**2 + (ys-y)**2 - r**2)*edge_sharpness))/2\n","    return dist,mask\n","\n","def epsr_parameterization(rho, bg_rho, design_region, radius=2, N_blur=1, beta=100, eta=0.5, N_proj=1, rods=None):\n","    \"\"\"Defines the parameterization steps for constructing rho\n","    \"\"\"\n","    # Combine rho and bg_rho; Note: this is so the subsequent blur sees the waveguides\n","    rho = mask_combine_rho(rho, bg_rho, design_region)\n","    \n","    # rho = operator_blur(rho, radius=radius, N=N_blur)\n","    rho = operator_proj(rho, beta=beta, eta=eta, N=N_proj)\n","    \n","    # Final masking undoes the blurring of the waveguides\n","    rho = mask_combine_rho(rho, bg_rho, design_region)\n","\n","    ### for cylinders\n","    rods = rods.reshape([Nx,Ny])\n","    rods = operator_proj(rods, beta=beta, eta=eta, N=N_proj)\n","    rho = mask_combine_rho(rho*(EPS_MIN_ROD + (EPS_MAX_ROD-EPS_MIN_ROD) * rods), bg_rho, design_region)\n","    return (epsr_min + (epsr_max-epsr_min) * rho)"]},{"cell_type":"code","execution_count":9,"metadata":{"id":"HKIh8Vv30Yxz","executionInfo":{"status":"ok","timestamp":1679764462321,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def sample_task(task_offset):\n","    global offset\n","    offset = task_offset\n","    global rho, bg_rho, design_region, input_slice, output_slice\n","    rho, bg_rho, design_region, input_slice, output_slice = \\\n","        init_domain(Nx, Ny, Npml, space=space, wg_width=wg_width, space_slice=space_slice, offset=offset)\n","    global epsr_init, source, mask_source, probe, mask_probe, mask_probe_unwanted, simulation, Ez, E0\n","    epsr_init = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                  radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj, rods=rods)\n","    source = insert_mode(omega, dl, input_slice.x, input_slice.y, epsr_init, m=1)\n","    mask_source = np.zeros_like(source,dtype=np.float)\n","    mask_source[source!=0]=1\n","    probe = insert_mode(omega, dl, output_slice.x, output_slice.y, epsr_init, m=1) ### differ in location\n","    mask_probe = np.zeros_like(probe,dtype=np.float)\n","    mask_probe[probe!=0]=1\n","    mask_probe_unwanted = 1-mask_probe\n","    mask_probe_unwanted[:output_slice.x,:] = 0\n","    mask_probe_unwanted[output_slice.x+1:,:] = 0\n","    source = np.abs(source)\n","    source /= source.max()\n","    probe = np.abs(probe)\n","    probe /= probe.max()"]},{"cell_type":"code","execution_count":9,"metadata":{"id":"UaeTuPAbICi-","executionInfo":{"status":"ok","timestamp":1679764462321,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":[]},{"cell_type":"code","execution_count":10,"metadata":{"id":"RYXfYmuc0aa1","executionInfo":{"status":"ok","timestamp":1679764462321,"user_tz":420,"elapsed":5,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["offset = 0\n","rho, bg_rho, design_region, input_slice, output_slice = \\\n","    init_domain(Nx, Ny, Npml, space=space, wg_width=wg_width, space_slice=space_slice, offset=offset)"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":492},"id":"TW0JRLgG0b5q","outputId":"6293f501-f2e6-4eb0-d68e-93717dd2d1fa","executionInfo":{"status":"ok","timestamp":1679764463405,"user_tz":420,"elapsed":1089,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-7-d26a2201a1c0>:104: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-11-43a20be1a6f0>:8: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-11-43a20be1a6f0>:13: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 600x300 with 2 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["rho_next = rho.flatten()\n","rods = np.ones_like(rho)*0.5\n","epsr_init = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                  radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj, rods = rods)\n","source = insert_mode(omega, dl, input_slice.x, input_slice.y, epsr_init, m=1)\n","source = np.abs(source)\n","source /= source.max()\n","mask_source = np.zeros_like(source,dtype=np.float)\n","mask_source[source!=0]=1\n","probe = insert_mode(omega, dl, output_slice.x, output_slice.y, epsr_init, m=1) ### differ in location\n","probe = np.abs(probe)\n","probe /= probe.max()\n","mask_probe = np.zeros_like(probe,dtype=np.float)\n","mask_probe[probe!=0]=1\n","### get normalization factor (field overlap before optimizing)\n","simulation, ax = viz_sim(epsr_init, source, slices=[input_slice, output_slice])\n","_, _, Ez = simulation.solve(source)\n","E0 = mode_overlap(Ez,probe)\n","E00 = field_mag_int(Ez, mask_probe)"]},{"cell_type":"code","execution_count":12,"metadata":{"id":"HphnDnEbOI5x","executionInfo":{"status":"ok","timestamp":1679764463406,"user_tz":420,"elapsed":12,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["wvgmask = (epsr_init>10).astype(int) ### for contour plot later"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"Sf4cREAH0dQk","executionInfo":{"status":"ok","timestamp":1679764463406,"user_tz":420,"elapsed":11,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def regularize_rho(rho, REG_SYMM = 1e5): ### shape (Nx, Ny), to maximize\n","    reg = 0\n","    ### for symmetry heuristic\n","    # reg -= npa.sum(npa.square(rho-rho[:,::-1])) / len(rho.flatten()) * REG_SYMM\n","    ### pushing rho away from eta\n","    reg -= npa.sum(npa.exp(-npa.square(rho.flatten()-eta)/0.01)) / len(rho.flatten()) * REG_BINARIZATION  ### will be changed globally\n","    return reg\n","\n","def objective(rho):\n","    rho = rho.reshape((Nx, Ny))\n","    epsr = epsr_parameterization(rho, bg_rho, design_region, \\\n","                             radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj, rods=rods_dict[offset])\n","    simulation.eps_r = epsr\n","    _, _, Ez = simulation.solve(source)\n","    ### feel free to try mode_overlap and field_mag_int in different combinations\n","    return mode_overlap(Ez, probe) / E0 - field_mag_int(Ez, mask_probe_unwanted) / E00  +\\\n","            regularize_rho(rho)\n","objective_jac = jacobian(objective, mode='reverse')\n","\n","def objective_all(rho): ### pooling all tasks\n","    res = 0\n","    ### simple sum\n","    # for offset in task_offsets:\n","    #     sample_task(offset)\n","    #     res += objective(rho)\n","    # return res / len(task_offsets)\n","    ### softmin\n","    for offset in task_offsets:\n","        sample_task(offset)\n","        res += npa.exp(-objective(rho))\n","    return -npa.log(res) / len(task_offsets)\n","objective_all_jac = jacobian(objective_all, mode='reverse')\n","\n","def regularize_rod(rods, slope=10, left=EPS_MIN_ROD, right=EPS_MAX_ROD): ### objective to maximize\n","    return npa.sum(- npa.exp((left-rods)*slope) - npa.exp((rods-right)*slope))\n","\n","def objective_rod(rods):\n","    epsr = epsr_parameterization(rho_next.reshape((Nx, Ny)), bg_rho, design_region, \\\n","                             radius=blur_radius, N_blur=N_blur, beta=beta, eta=eta, N_proj=N_proj, rods=rods.flatten())\n","    simulation.eps_r = epsr\n","    _, _, Ez = simulation.solve(source)\n","    return mode_overlap(Ez, probe) / E0 - field_mag_int(Ez, mask_probe_unwanted) / E00 ### now we no longer regularize, since it will be projected\n","objective_jac_rod = jacobian(objective_rod, mode='reverse')\n"]},{"cell_type":"code","execution_count":14,"metadata":{"id":"4VG1ZGYW0efJ","executionInfo":{"status":"ok","timestamp":1679764463406,"user_tz":420,"elapsed":10,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["task_offsets = output_offs\n","losses = {}\n","losses_short = {} ### 1 pt for each epoch\n","losses_rods = {}\n","rods_dict = {}\n","for task_offset in task_offsets:\n","    losses[task_offset] = []\n","    losses_short[task_offset] = []\n","    losses_rods[task_offset] = []\n","    rods_dict[task_offset] = np.ones([Nx,Ny]).flatten()*0.5\n","task_ids = []\n","REG_BINARIZATION=0\n","Nsteps_inner = 2\n","Nsteps_outer = 2"]},{"cell_type":"code","execution_count":15,"metadata":{"id":"Ii8bgV3Y0fm3","executionInfo":{"status":"ok","timestamp":1679764463406,"user_tz":420,"elapsed":10,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["def train_a_while(reptile_stepsize, nepochs):\n","    global rho_next\n","    for i_outer in tqdm(range(nepochs)):\n","        for task_offset in task_offsets:\n","            sample_task(task_offset)\n","            # Maximize the objective function using an ADAM optimizer\n","            (rods_new, loss_rods) = adam_optimize(objective_rod, rods_dict[task_offset], objective_jac_rod,\n","                                Nsteps=Nsteps_inner, direction='max', step_size=step_size*200,verbose=False) ### give it a boost, as informed by losss curve\n","            rods_dict[task_offset] = rods_new.flatten()\n","            losses_rods[task_offset]+=loss_rods\n","            losses_short[task_offset].append(loss_rods[-1])\n","\n","        (rho_new, loss) = adam_optimize(objective_all, rho_next, objective_all_jac,\n","                             Nsteps=Nsteps_outer, direction='max', step_size=step_size,verbose=False)\n","        rho_next += (rho_new.flatten()-rho_next)*reptile_stepsize\n","        losses[0]+=loss\n","def check_structure(rho, beta_scaling = 1, fname = None, offsets = [0]): ## set beta_scaling to 100 to fully binarize\n","    rho = rho.reshape((Nx, Ny))\n","    for io, offset in enumerate(offsets):\n","        sample_task(offset)\n","        epsr = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                radius=blur_radius, N_blur=N_blur, beta=beta*beta_scaling, eta=eta, N_proj=N_proj, rods=rods_dict[offset])\n","        if fname is not None:\n","            fig, ax = plt.subplots(1,2,figsize=[7,3])\n","            viz_sim(epsr, source, slices=[input_slice, output_slice],wantabs=True, ax_to_use = ax);\n","            fig.savefig(directory+f'{fname}_{io}.png')\n","        else:\n","            viz_sim(epsr, source, slices=[input_slice, output_slice],wantabs=True);\n","        if fname is not None:\n","            plt.close('all')\n","def check_structure_for_paper(rho, beta_scaling = 1, fname = None, offsets = [0]): ## modified version for paper plot\n","    rho = rho.reshape((Nx, Ny))\n","    for io, offset in enumerate(offsets):\n","        sample_task(offset)\n","        epsr = epsr_parameterization(rho, bg_rho, design_region, \\\n","                                radius=blur_radius, N_blur=N_blur, beta=beta*beta_scaling, eta=eta, N_proj=N_proj, rods=rods_dict[offset])\n","        if fname is not None:\n","            fig, ax = plt.subplots(1,2,figsize=[6,2.5])\n","            viz_sim_for_paper(epsr, source, slices=[input_slice, output_slice],wantabs=True, ax_to_use = ax, different_outline=wvgmask);\n","            fig.savefig(directory+f'{fname}_{io}.png', bbox_inches='tight', dpi=400, transparent=True)\n","        else:\n","            viz_sim_for_paper(epsr, source, slices=[input_slice, output_slice],wantabs=True);\n","        if fname is not None:\n","            plt.close('all')\n","def check_loss(nepochs,every=1,fname=None):\n","    fig,axs = plt.subplots(1,2, figsize=[7,2])\n","    for offset in task_offsets:\n","        tmp = -np.array(losses[offset]) ### was objective function, now loss function\n","        axs[0].plot(tmp[-nepochs::every],label=f'task {offset}')\n","    axs[0].legend()\n","    axs[0].set_title('losses')\n","    for offset in task_offsets:\n","        tmp = -np.array(losses_rods[offset]) ### was objective function, now loss function\n","        axs[1].plot(tmp[-nepochs::every],label=f'task {offset}')\n","    axs[1].legend()\n","    axs[1].set_title('losses rods')\n","    plt.tight_layout()\n","    if fname is None:\n","        plt.show()\n","    else:\n","        fig.savefig(directory+fname+'.png')\n","\n","def saveall():\n","    np.array(rho_next).dump(directory+'rho_next.pkl')\n","    with open(directory+'rods_dict.pkl', 'wb') as handle:\n","        pickle.dump(rods_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)\n","    np.array(losses[0]).dump(directory+'losses.pkl')\n","    for offset in task_offsets:\n","        np.array(losses_rods[offset]).dump(directory+f'losses_rods_{offset}.pkl')\n","def loadall():\n","    rho_next = np.load(directory+'rho_next.pkl',allow_pickle=True)\n","    with open(directory+'rods_dict.pkl', 'rb') as handle:\n","        rods_dict = pickle.load(handle)\n","    losses = [np.load(directory+'losses.pkl',allow_pickle=True)]\n","    losses_rods = {}\n","    for offset in task_offsets:\n","        losses_rods[offset] = np.load(directory+f'losses_rods_{offset}.pkl',allow_pickle=True)\n","    return rho_next, rods_dict, losses, losses_rods"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"brFignV60lDK","outputId":"154ecb47-2ee7-4219-9c7c-0e4b13ac5167","executionInfo":{"status":"ok","timestamp":1679767823814,"user_tz":420,"elapsed":3360418,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[{"output_type":"stream","name":"stderr","text":["\r  0%|          | 0/20 [00:00<?, ?it/s]<ipython-input-7-d26a2201a1c0>:104: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-9-97639221a84f>:11: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-9-97639221a84f>:14: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n","100%|██████████| 20/20 [01:29<00:00,  4.49s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.08s/it]\n","100%|██████████| 20/20 [01:22<00:00,  4.12s/it]\n","100%|██████████| 20/20 [01:23<00:00,  4.16s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.09s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.09s/it]\n","100%|██████████| 20/20 [01:23<00:00,  4.18s/it]\n","100%|██████████| 20/20 [01:23<00:00,  4.18s/it]\n","100%|██████████| 20/20 [01:24<00:00,  4.23s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.10s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n","100%|██████████| 20/20 [01:20<00:00,  4.01s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n","100%|██████████| 20/20 [01:20<00:00,  4.01s/it]\n","100%|██████████| 20/20 [01:19<00:00,  3.97s/it]\n","100%|██████████| 20/20 [01:20<00:00,  4.04s/it]\n","100%|██████████| 20/20 [01:20<00:00,  4.02s/it]\n","100%|██████████| 20/20 [01:23<00:00,  4.18s/it]\n","100%|██████████| 20/20 [01:24<00:00,  4.24s/it]\n","100%|██████████| 20/20 [01:23<00:00,  4.18s/it]\n","100%|██████████| 20/20 [01:23<00:00,  4.20s/it]\n","100%|██████████| 20/20 [01:22<00:00,  4.13s/it]\n","100%|██████████| 20/20 [01:24<00:00,  4.24s/it]\n","100%|██████████| 20/20 [01:26<00:00,  4.31s/it]\n","100%|██████████| 20/20 [01:22<00:00,  4.15s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n","100%|██████████| 20/20 [01:22<00:00,  4.12s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n","100%|██████████| 20/20 [01:21<00:00,  4.06s/it]\n","100%|██████████| 20/20 [01:22<00:00,  4.10s/it]\n","100%|██████████| 20/20 [01:20<00:00,  4.03s/it]\n","100%|██████████| 20/20 [01:18<00:00,  3.94s/it]\n","100%|██████████| 20/20 [01:19<00:00,  3.96s/it]\n","100%|██████████| 20/20 [01:18<00:00,  3.90s/it]\n","100%|██████████| 20/20 [01:19<00:00,  3.96s/it]\n","100%|██████████| 20/20 [01:19<00:00,  3.95s/it]\n","100%|██████████| 20/20 [01:18<00:00,  3.91s/it]\n","100%|██████████| 20/20 [01:20<00:00,  4.01s/it]\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x200 with 2 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["for i in range(1,41):\n","    train_a_while(0.5,20)\n","    check_structure(rho_next, offsets = task_offsets, fname=f'struct_0.5_{20*i}')\n","    check_loss(1000, fname=f'loss_0.5_{100*i}')\n","    EPS_MIN_ROD += 0.002\n","    EPS_MAX_ROD -= 0.002"]},{"cell_type":"code","execution_count":17,"metadata":{"id":"jeTFDNEF9Tur","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1679767825496,"user_tz":420,"elapsed":1685,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"bbc3dc4e-49f1-41ec-e054-1355fd740e48"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["(array([ 0.0000,  0.0000,  0.0000, ...,  0.0000,  0.0000,  0.0000]),\n"," {-18: array([ 0.5000,  0.5000,  0.5000, ...,  0.5000,  0.5000,  0.5000]),\n","  0: array([ 0.5000,  0.5000,  0.5000, ...,  0.5000,  0.5000,  0.5000]),\n","  18: array([ 0.5000,  0.5000,  0.5000, ...,  0.5000,  0.5000,  0.5000])},\n"," [array([-0.8656, -0.8491, -0.3070, ...,  0.5790,  0.5801,  0.5774])],\n"," {-18: array([-5.9987, -3.0726, -1.5369, ...,  2.8363,  2.8360,  2.8362]),\n","  0: array([-5.9757, -2.8057, -1.2302, ...,  2.8485,  2.8531,  2.8531]),\n","  18: array([-5.9987, -3.0776, -1.5477, ...,  2.8273,  2.8270,  2.8271])})"]},"metadata":{},"execution_count":17}],"source":["saveall()\n","loadall()\n"]},{"cell_type":"code","execution_count":18,"metadata":{"id":"LvGxpY6F0pna","colab":{"base_uri":"https://localhost:8080/","height":0},"executionInfo":{"status":"ok","timestamp":1679767825724,"user_tz":420,"elapsed":232,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"b3ba4228-feea-4acb-bf68-e3e248b82ff2"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 700x200 with 2 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAArIAAAC+CAYAAADJJOzSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8RUlEQVR4nO3deZxU1Z3//9enlt43loYGEUFFRHFBHBVNDNEwuOBXRhOdyTczQRkxEX+OieSbkMR1zPIbszGjyYwZx0wyIxq/SUzUCGoMjgqimCDGDSVAi+xbN73Wdr5/nFvdRdPd0E03VdX9fj4e91Fd955776lb1Z/61LnnnmvOOURERERE8k0o2xUQEREREekNJbIiIiIikpeUyIqIiIhIXlIiKyIiIiJ5SYmsiIiIiOQlJbIiIiIikpeUyIqIiIhIXlIiKyIiIiJ5SYmsiIiIiOQlJbKSt8xsjpk5MxuX7bqIiPQHxbne07EbHJTIioiIiEheUiIrIiIiInlJiayIiIjkDDMLmVlRtush+UGJrAwoZnaDmb1pZq1mttnM7jOzqg5lJpjZL8xsq5m1mNkmM3vYzCozyswwsxfNbK+ZNZjZu2b2zQ7bKTSzO83s/WB/H5jZP5lZYYdyB92WiEhPDKRYF/RjvdfM/reZvQm0AhcFy6aY2VNmVh9s83dmdk4n2zjZzJ4zs+bgdX6dTnIcMzvTzJaa2c6g7Hoz+4+D1VFyVyTbFRDpK2Z2B3A78CzwI2Ai8HngL8zsPOdc3MwKgKVAIfAvwFbgKGAWUAXUmdnJwBPAGuA2fFA9HjgvY18h4DfAR4D7gbeBU4AvACcAs4NyB92WiEhPDNBYdwFwFXAvsBPYEGzzBaAe+CcgDlwPLDOzjznnVgb7rgF+j89pvg00AvOA5g7HbQTwNLAjKLcXGAdccYh1lFzknNOkKS8nYA7g8IGoGh84lwKhjDLzgzLXBM9PD55/spvt3hyUGd5Nmc8ASeAjHeZfH6x77qFuS5MmTZq6mjLjXPB8wMW6YL0kcFKH+b8KXuuxGfNG4RPb5zPmfT/YxlkZ86rxiWrmsZsdPD8z2++rpr6b1LVABopPAAXAD5xzqYz5P8YHvUuD53XB40wzK+liW3uDx8uD1ojOfArfMvGOmQ1PT8BzwfKP92BbIiKHaqDGuuedc2+ln5hZGPhL4DHn3J/T851zW4CHgI+YWUUw+xLgZefcKxnldgD/3WEf6TrOMrNoL+ooOUhfrDJQHBM8vps50zkXA/6cXu6cWw98D/h7YGfQV2p+Zp8x4BHgJeDfgW1Bn7KrOgTnCcDJ+FNUmdPaYPmIHmxLRORQDdRYt77D82qgpOPrDLyNz1+ODp4fA7zXSbmO6z4P/ALfLWOnmf3azK7p2NdX8ou+TGXQcc7dApwKfBMoBv4ZeNPMxgTLm4Hz8S0fPwvKPgI8E7QSgP/feQOY0cX0wx5sS0Skz+VZrGs+eJHD47xPAtPwfXGPAv4DeM3Myvp7/9JPst23QZOm3k7s30f2b4K/L+5QpgB/Oun/drOdc4N17+6mzFeDMp8Inj8JbAKsF/Xeb1uaNGnS1NXEgX1kB1ysC8rc22FeGH/R1iOdlP8Rvk9tRfD8XWBFJ+Xuyzx2Xez700GZv8/2e62pd5NaZGWgeBaIATeZmWXMnwtU4oMxZlZhZh1H63gDSOGv7sXMhnay/dXBY/oU1M/xv+av61jQzIrNrLQH2xIROVSDItY555L4EQYut4xbzJrZSHzy+aJzrj6Y/VvgHDM7K6NcNfC/O9R3SIdjdlh1lNyg4bdkQHDO7TCzb+H7Pi0xs9/gh6S5AXgV+K+g6AXAvWb2KL6PVwT4W/yv+18EZW4zs/PxXwgb8X3AbsC3SrwYlPkZfqiYfzWzj+P7hoWBE4P5M4FVh7gtEZFDMshi3dfx3RdeNLMfAgn8aAmFwP/JKPdPwWtbYmaLaB9+ayO+i0PaZ4EbzOxXwDqgHJ+g1+OTYclH2W4S1qSptxMdTrkF8+bjLwSI4cdN/CFQlbF8PPAA8D6+T9Yu/NW3F2aUuQB4DPgQP/TLh/irZCd02H8UH0z/BLQAuwkCOu2nvA5pW5o0adLU2dRZnAvmD5hYRyddCzKWTQGWAPvwCepzwLROyp0CLAte6yZ8Enwt+3fLmBLUaWPwOrYBjwNTs/0+a+r9ZMGbKyIiIiKSV9RHVkRERETykhJZEREREclLSmRFREREJC8pkRURERGRvKREVkRERETykhJZEREREclLA+6GCMFdO0bjx5wTEcmmcmCzy5NxDhU/RSSHHFL8HHCJLD4Ib8p2JUREAmPwg8PnA8VPEcklB42fAzGR3QfwwQcfUFFRke26iMggVV9fz9FHHw351bqp+CkiWdeT+DkQE1kAKioqFIhFRHpB8VNE8oUu9hIRERGRvDRgW2R7xDlo2A6RAigeku3aiIjkjW0NdTTGWhhaXEZVcWm2qyMig4xaZAF+MRe+ewK8/ki2ayIikle+uPhyLn/8E/zzb76c7aqIyCCkFlmAiqP8454NWa2GSGeSySTxeDzb1ZAOotEo4XA429XIuqJUCwDRREOWayKyv1QqRSwWy3Y1pBN9GT+VyAKU1/jHxh3ZrYdIBuccW7duZe/evdmuinShqqqKmpoa/PCrg1sqP4bKlUEiFouxfv16UqlUtqsiXeir+KlEFsDSPSwUiCV3pJPYESNGUFJSomQphzjnaGpqYvv27QCMGjUqyzXKnhD+c5kn93yQQcA5x5YtWwiHwxx99NGEQupFmUv6On4qkQUIAjEKxJIjkslkWxI7bNiwbFdHOlFcXAzA9u3bGTFixODtZhD8wEqhli/JDYlEgqamJkaPHk1JSUm2qyOd6Mv4qZ8p0BaI1SIruSLdJ1ZBOLel35/B3IfZ0JkCyS3JZBKAgoKCLNdEutNX8VOJLKAWWclV6k6Q2/T+tEVPnFOLrOQW/X/mtr56f5TIQnuLrAKxiEiPpFtknc5oiUgWKJHdjwKxSK654447OP3007NdDTkItciK5J7BED+VyEJGi6wSWZHDMX36dG6++eZsV6NT3/jGNzj33HMpKSmhqqqq0zKvvvoqF154IVVVVQwZMoSZM2fy+uuvH9mKBszsDjNzHaZ3DrLOp8zsHTNrMbM3zOySfq+nWmRF+oTiZ+8okQXQxQoiA14sFuNTn/oUn//85ztd3tDQwEUXXcTYsWNZuXIlL774IuXl5cycOTObF3O9CYzKmD7SVUEzOxdYDDwATAEeAx4zs8n9WUElsiIDXy7HTyWyoBZZkT4wZ84cnn/+eRYtWoSZYWZs2LCBZDLJ3LlzGT9+PMXFxUycOJFFixbtt+6yZcs466yzKC0tpaqqivPOO4+NGzd2up9169Zx7LHHcuONN/Zo7NI777yTL3zhC5xyyimdLn/nnXfYvXs3d911FxMnTuTkk0/m9ttvZ9u2bV3W5QhIOOe2Zkw7uyn7D8AS59w9zrm3nXO3An8AbuzPCrZf7KX4KdJbip+9p3FkQTdEkJznnKM5nszKvouj4UO6unTRokWsXbuWyZMnc9dddwFQXV1NKpVizJgxPProowwbNozly5czb948Ro0axVVXXUUikWD27Nlcd911LF68mFgsxiuvvNLpPtesWcPMmTOZO3cud999d5++zokTJzJs2DAeeOABvvrVr5JMJnnggQeYNGkS48aN69N99cAEM9sMtAArgIXOudouyk4Dvtdh3lJgdlcbN7NCoDBjVnlPK2i6IYLkOMVPb6DGTyWygIbfklzXHE9y0m1Ls7Lvt+6aSUnBwUNFZWUlBQUFlJSUUFNT0zY/HA5z5513tj0fP348K1as4Oc//zlXXXUV9fX11NXVMWvWLI477jgAJk2adMD2ly9fzqxZs/ja177GLbfc0gevbH/l5eUsW7aM2bNn84//+I8ATJgwgaVLlxKJZCVUrgTmAO/iuxXcDrxgZpOdc/s6KV8DbOswb1swvysLg+32mroWSK5T/BzY8VNdC0A3RBDpZ/fddx9Tp06lurqasrIy7r//fmprfcPi0KFDmTNnDjNnzuSyyy5j0aJFbNmyZb/1a2trmTFjBrfddttBg/DnPvc5ysrK2qZD1dzczNy5cznvvPN4+eWXeemll5g8eTKXXnopzc3NPX/Rh8k595Rz7lHn3Brn3FLgEqAKuKoPd/MtoDJjGtPjLVg6kdWoBSL9QfGze2qRBdQiK7muOBrmrbtmZm3fh+Phhx9mwYIFfPe732XatGmUl5dzzz33sHLlyrYyDz74IDfddBNLlizhkUce4etf/zrPPPMM55xzDuBPsY0ePZrFixdz7bXXUlFR0eX+7rrrLhYsWNDjej700ENs2LCBFStWtN2b/aGHHmLIkCH8+te/5q//+q97vM2+5Jzba2ZrgeO7KLIVGNlh3shgflfbbAVa0897M0B5SF0LJMcpfg7s+KlEFtQiKznPzA7p9FS2FRQUtN0eMu2ll17i3HPP5YYbbmibt27dugPWnTJlClOmTGHhwoVMmzaNhx56qC0QFxcX88QTT3DJJZcwc+ZMnn76acrLO+/OOWLECEaMGNHjujc1NREKhfZL5tLPU6nstzaaWRlwHPCzLoqsAC4EfpAxb0Ywvz9r1r+bFzlMip8DO36qawGgFlmRvjFu3DhWrlzJhg0b2LlzJ6lUigkTJrBq1SqWLl3K2rVrufXWW3n11Vfb1lm/fj0LFy5kxYoVbNy4kaeffpr33nvvgH5epaWlPPnkk0QiES6++GIaGhp6VLfa2lpWr15NbW0tyWSS1atXs3r16rbtzJgxgz179jB//nzefvtt3nzzTa655hoikQgf//jHD//g9JCZfcfMPmZm44KhtX4FJPFDbGFmPzWzb2Wssgi4yMxuMbMTzewO4Ezg3n6tZxA/U+paIHJYFD97R4ksqEVWpI8sWLCAcDjMSSedRHV1NbW1tVx//fVcccUVXH311Zx99tns2rVrv9aFkpIS3nnnHa688kpOOOEE5s2bx/z587n++usP2H5ZWRlPPfUUzjkuvfRSGhsbD7lut912G1OmTOH222+noaGhrQVj1apVAJx44ok8/vjjrFmzhmnTpvHRj36UzZs3s2TJEkaNGnX4B6fnxuCT1neBnwO7gHOcczuC5WPxF4EB4JxbDnwamAe8DnwSmO2c+1N/VrI9eip+ihwOxc/esYHWr8nMKoC6urq6bvuB7Gf1Ynjsc3DchfC3v+zX+okcipaWFtavX8/48eMpKirKdnWkC929T/X19VRWVgJUOufqs1LBHupN/Pziv8/gmehWZibG8p25T/ZvBUUOgeJnfuir+KkWWVCLrIhIr2n4LRHJHiWygPrIioj0TkiJrIhkkRJZUIusiEivqSFARLJHiSygQCwi0jvp4XZSaggQkSzo90TWzOab2QYzazGzlWZ2Vjdl55iZ6zC19Hcd1SIrItI7huKniGRPvyayZnY18D3gTuAM/JAwS82su9F26/FDyqSnY/qzjvtRi6yISI+Y+siKSBb1d4vsF4EfO+cedM69BXwOaAKu7WYd55zbmjFt6+c6ZrTIiohIj6Tjp/JYEcmCfktkzawAmAo8m57nnEsFz6d1s2qZmW00sw/M7NdmdnJ/1bFdOhDrzjQiIj0RQn1kRSR7+rNFdjgQBjq2qG4DarpY5118a+3lwGfw9VtuZmO62omZFZpZRXoCOr+BcHdMF3uJiPSGuhaISDbl1KgFzrkVzrmfOudWO+eeB64AdgAH3mut3UKgLmPa1PM962IFkVx1xx13cPrpp2e7GtIlxU+RXDUY4md/JrI7gSQwssP8kcDWQ9mAcy4O/BE4vpti3wIqM6YuW2+7pBZZkT4xffp0br755mxXg5aWFubPn8+wYcMoKyvjyiuvZNu2/u9uPxiFgq8RtciKHB7Fz97pt0TWORcDXgMuTM8zs1DwfMWhbMPMwsApwJZu9tPqnKtPT8C+ntdWLQoiA8kXvvAFHn/8cR599FGef/55Nm/ezBVXXJHtag1I6XFklciKDAz5Fj/7u2vB94DrzOyzZjYJ+BFQCjwIYGY/NbNvpQub2W1m9pdmdqyZnQH8F374rX/v11qqRVbksM2ZM4fnn3+eRYsWYWaYGRs2bCCZTDJ37lzGjx9PcXExEydOZNGiRfutu2zZMs466yxKS0upqqrivPPOY+PGjZ3uZ926dRx77LHceOONuE7+Z+vq6njggQf43ve+xwUXXMDUqVN58MEHWb58OS+//HK/vPbBrK2PrMKnSK8pfvZepD837px7xMyqgbvwF3itBi7KGFJrLJA5VMAQ4MdB2T34Ft1zg6G7+pFaZCXHOQfxpuzsO1pySEPULVq0iLVr1zJ58mTuuusuAKqrq0mlUowZM4ZHH32UYcOGsXz5cubNm8eoUaO46qqrSCQSzJ49m+uuu47FixcTi8V45ZVX2lr6Mq1Zs4aZM2cyd+5c7r777k7r8dprrxGPx/nEJz7RNu/EE09k7NixrFixgnPOOaeXB0I6pRvKSK5T/AQGbvzs10QWwDl3L3BvF8umd3j+BeAL/V2nA6hFVnJdvAm+OTo7+/7qZigoPWixyspKCgoKKCkpoaamfWCScDjMnXfe2fZ8/PjxrFixgp///OdcddVV1NfXU1dXx6xZszjuuOMAmDRp0gHbX758ObNmzeJrX/sat9xyS5f12Lp1KwUFBVRVVe03f+TIkWzdekjd86UHQrpFreQ6xc8BHT9zatSC7FGLgkh/uu+++5g6dSrV1dWUlZVx//33U1tbC8DQoUOZM2cOM2fO5LLLLmPRokVs2bJ/t/ja2lpmzJjBbbfd1m0QlmxQ/BTpT4qf3ev3Ftm8oBZZyXXREv/LPlv7PgwPP/wwCxYs4Lvf/S7Tpk2jvLyce+65h5UrV7aVefDBB7nppptYsmQJjzzyCF//+td55pln2k5jVVdXM3r0aBYvXsy1115LRUVFl/urqakhFouxd+/e/VoVtm3btl9Lh/QNjVogOU/xc0DHT7XIAmpRkJxn5k9PZWPqwS2cCwoKSCaT+8176aWXOPfcc7nhhhuYMmUKxx9/POvWrTtg3SlTprBw4UKWL1/O5MmTeeihh9qWFRcX88QTT1BUVMTMmTPZt6/rwUmmTp1KNBrld7/7Xdu8d999l9raWqZN6+6mgtIbukOt5DzFzwEdP5XIglpkRfrIuHHjWLlyJRs2bGDnzp2kUikmTJjAqlWrWLp0KWvXruXWW2/l1VdfbVtn/fr1LFy4kBUrVrBx40aefvpp3nvvvQP6eZWWlvLkk08SiUS4+OKLaWho6LQOlZWVzJ07ly9+8Yv8/ve/57XXXuOaa65h2rRpOXmhQv5Ti6xIX1D87B0lsoBaZEX6xoIFCwiHw5x00klUV1dTW1vL9ddfzxVXXMHVV1/N2Wefza5du7jhhhva1ikpKeGdd97hyiuv5IQTTmDevHnMnz+f668/8IZ+ZWVlPPXUUzjnuPTSS2lsbOy0Ht///veZNWsWV155Jeeffz41NTX88pe/7LfXPZh1dnW0iPSc4mfvWGfjiOUzM6sA6urq6rrtB7Kf956B//4k1JwKn3uhX+sncihaWlpYv34948ePp6ioKNvVkS509z7V19dTWVkJUBncrKVHzGwh/jbdJwLNwHLgy865d7tZZw7BON0ZWp1zh/Qh6k38/ObPPsPi1Ov8RWs5/zFv+SGtI9KfFD/zQ1/FT7XIAmqRFZEc9DHgPuAcYAYQBZ42s4ON5VMPjMqYjunPSprip4hkkUYtAOWxIpJznHMXZT4PWlu3A1OB/+l+VXfEBnz0dx5XH1kRyQ61yAIUD/GPdR9ktx4iIl2rDB53H6RcmZltNLMPzOzXZnZyf1ZKfWRFJJuUyAKUB3f8aO16SAoRkWwx3+z5A+Al59yfuin6LnAtcDnwGXyMX25mY7rYbqGZVaQnoLzHdQu+RlID7HoLEckP6loAEAr7R5fKbj1ERDp3HzAZ+Eh3hZxzK4AV6edmthx4G7geuLWTVRYCtx9OxdItss6UyIrIkacWWQBLHwansWRFJKeY2b3ALODjzrlNPVnXORcH/ggc30WRb+G7LKSnTltuu69f0EdWoVNEskAtspCRyOKjsfp8iUiWmW/q/Bfgr4Dpzrn1vdhGGDgF+G1ny51zrUBrRvme1zN9taxaZEUkC5TIwv6Jq0uihmoRyQH3AZ/G93fdZ2bpG53XOeeaAczsp8CHzrmFwfPbgJeB94Eq4Ev44bf+vb8qaW139hIROfKUyAJYuP1v9ZMVkdzw+eBxWYf51wA/Cf4eC2QGrSHAj4EaYA/wGnCuc+6t/qpkWx9ZpbIikgVqeoQOXQuUyIrkkjvuuIPTTz8929U44pxz1sX0k4wy051zczKef8E5d4xzrtA5V+Ocu9Q598f+rKeZvkZEctVgiJ+KQKBEVqSPTJ8+nZtvvjnb1eD+++9n+vTpVFRUYGbs3bv3gDJr167l8ssvZ/jw4VRUVPCRj3yE3//+90e+snkuFPSRTalFVuSwKH72jhJZUCIrMsA0NTVx0UUX8dWvfrXLMrNmzSKRSPDcc8/x2muvcdpppzFr1iy2bj1iN8UaENQiKzKw5Fv8VAQCJbIifWDOnDk8//zzLFq0CDPDzNiwYQPJZJK5c+cyfvx4iouLmThxIosWLdpv3WXLlnHWWWdRWlpKVVUV5513Hhs3bux0P+vWrePYY4/lxhtvxHUx5tPNN9/MV77yFc4555xOl+/cuZP33nuPr3zlK5x66qlMmDCBb3/72zQ1NfGnP3V3vwHpqL2PrIj0luJn7+liL1AiKznPOUdzojkr+y6OFB/SsEyLFi1i7dq1TJ48mbvuuguA6upqUqkUY8aM4dFHH2XYsGEsX76cefPmMWrUKK666ioSiQSzZ8/muuuuY/HixcRiMV555ZVO97lmzRpmzpzJ3Llzufvuu3v9moYNG8bEiRP56U9/yhlnnEFhYSH/9m//xogRI5g6dWqvtzsY6WIvyXWKn95AjZ9KZOHAcWRFckxzopmzHzo7K/te+emVlERLDlqusrKSgoICSkpKqKmpaZsfDoe58847256PHz+eFStW8POf/5yrrrqK+vp66urqmDVrFscddxwAkyZNOmD7y5cvZ9asWXzta1/jlltuOazXZGY8++yzzJ49m/LyckKhECNGjGDJkiUMGTLksLY92Gj4Lcl1ip8DO36qawF0GEdWLbIife2+++5j6tSpVFdXU1ZWxv33309tbS0AQ4cOZc6cOcycOZPLLruMRYsWsWXLlv3Wr62tZcaMGdx2222HHYTBt9DMnz+fESNG8MILL/DKK68we/ZsLrvssgP2Ld0LqUVWpF8pfnZPLbIQJLKGv0WtElnJPcWRYlZ+emXW9n04Hn74YRYsWMB3v/tdpk2bRnl5Offccw8rV7a/ngcffJCbbrqJJUuW8Mgjj/D1r3+dZ555pq2PVnV1NaNHj2bx4sVce+21VFRUHFadnnvuOZ544gn27NnTtq0f/vCHPPPMM/znf/4nX/nKVw5r+4NJOBiHW5FTcpXi58COn0pk0yzk7+qlRFZykJkd0umpbCsoKCCZTO4376WXXuLcc8/lhhtuaJu3bt26A9adMmUKU6ZMYeHChUybNo2HHnqoLRAXFxfzxBNPcMkllzBz5kyefvppysvLe13PpqYmAEKh/U9KhUIhUinFgJ6IhPzXiIbfklyl+Dmw46e6FqSl+8mmkt2XE5EujRs3jpUrV7JhwwZ27txJKpViwoQJrFq1iqVLl7J27VpuvfVWXn311bZ11q9fz8KFC1mxYgUbN27k6aef5r333jugn1dpaSlPPvkkkUiEiy++mIaGhi7rsXXrVlavXs37778PwBtvvMHq1avZvXs3ANOmTWPIkCF89rOf5fXXX2ft2rV86UtfYv369Vx66aX9cGQGrkjwZZY8+PUsItINxc/eUSKbFgpuU6sWWZFeW7BgAeFwmJNOOonq6mpqa2u5/vrrueKKK7j66qs5++yz2bVr136tCyUlJbzzzjtceeWVnHDCCcybN4/58+dz/fXXH7D9srIynnrqKZxzXHrppTQ2NnZaj3/9139lypQpXHfddQCcf/75TJkyhd/85jcADB8+nCVLltDQ0MAFF1zAmWeeyYsvvsivf/1rTjvttH44MgNXxNQiK9IXFD97x7oaRyxfmVkFUFdXV9ezfiDfGAXxJviHNTDkmH6rn8ihaGlpYf369YwfP56ioqJsV0e60N37VF9fT2VlJUClc64+KxXsod7Ez0d/+w3u2vEwY2LGU9et6d8KihwCxc/80Ffxs99bZM1svpltMLMWM1tpZmcdpPynzOydoPwbZnZJf9fR7zg4FGqRFRE5ZJFwFICUuhaISBb0ayJrZlcD3wPuBM4AXgeWmtmILsqfCywGHgCmAI8Bj5nZ5P6sp9950LUg1nW/ERER2V80SGST6logIlnQ3y2yXwR+7Jx70Dn3FvA5oAm4tovy/wAscc7d45x72zl3K/AH4MZ+rmd7d4I9G/p9VyIiA0UkXADoYi8RyY5+S2TNrACYCjybnuecSwXPp3Wx2rTM8oGl3ZTHzArNrCI9Ab0bU6IwWC2V6NXqIiKDUVvXgizXQ0QGp/5skR0OhIFtHeZvA2oOLA7B/J6UB1gI1GVMm3pcU9DwW5KTBtrFmAON3h+IRtItsjoWklv0/5nb+ur9GQjDb30LqMyYxvRqK8Gg3kpkJRdEo76VKz3wtOSm9PuTfr8Go2jQtUAtspIrwmF/zUssFstyTaQ7fRU/+/POXjuBJDCyw/yRwNYu1tnaw/I451qB1vRzs1521GpLZNW1QLIvHA5TVVXF9u3bAT9WYK8/29LnnHM0NTWxfft2qqqq2r44B6NouBBQH1nJHZFIhJKSEnbs2EE0Gj3gDlSSXX0dP/stkXXOxczsNeBC/OgDmFkoeH5vF6utCJb/IGPejGB+/1IiKzmmpsb3qEkns5J7qqqq2t6nwSoaDboWZLkeImlmxqhRo1i/fj0bN27MdnWkC30VP/uzRRb80Fv/aWargFeAm4FS4EEAM/sp8KFzbmFQfhHwvJndAjwJ/DVwJjCvn+vZfmcvJbKSI9LBeMSIEcTj8WxXRzqIRqODuiU2Ld0iq3FkJZcUFBQwYcIEdS/IUX0ZP/s1kXXOPWJm1cBd+Au2VgMXOefSF3SNJaNrlXNuuZl9Grgb+CbwHjDbOfen/qwnoD6ykrPC4bASJslZ6RZZNQFIrgmFQrqz1yDQ7x1HnHP3OueOcc4VOufOds6tzFg23Tk3p0P5R51zE4Pyk51zv+3vOgLqWiAiOScf7oxYEPGJgjMjkVRDgIgcWeoBnZZOZJ0CsYhkX77cGbEgUtj2d2tCDQEicmQpkU1LJ7KJ1u7LiYgcGXlxZ8SCaHsiG0uqL7eIHFlKZNPKgkaOXeuyWw8RGfTy6c6I6a4FAK1KZEXkCFMim1Yx2j/GG7NbDxGRPLozYlFheyIbS6prgYgcWUpk04K705DQUB0iMmgc9p0RI+ECQsGtJhtjzX1aORGRg+nvcWTzR/qChaT6yIpI1uXNnRFDkSiFztFsRmOzzmiJyJGlFtk0tciKSI5wzsWA9J0Rgf3ujNjVnQ5XZJYP9P+dEUMRCoIW2YbWhn7dlYhIR2qRTVOLrIjklvy4M2IoQmG6a0GrWmRF5MhSIpsWLfGP9ZuzWw8REfLozogWbktkm9RHVkSOMCWyaSMm+cf6DyGVgpB6XYhIdjnn7gXu7WLZ9E7mPQo82s/V2l8oTIHPY2lW1wIROcKUraUVVbb/HVMwFhE5JGZtiWyLElkROcKUyKZFisCCw9Fan926iIjkkWg6kY2pj6yIHFlKZNPMoOIo//f2t7NbFxGRPFLg/LBdLbqhjIgcYUpkM4082T/W9fjmNiIig1Yk+CqJJZTIisiRpUQ2U9VY/7hpVXbrISKSRwqd/yppjjVluSYiMtgokc10wkz/+OdlEAwnIyIi3SshDEBDXNcXiMiRpUQ209hpEC2F+k2w7rls10ZEJC+UBiM5NqprgYgcYUpkMxWUwhl/5/9+/GZo2JHV6oiI5INyogA0JpXIisiRpUS2o+lfhsqjoa4W7v8Y7FoHjbuyXSsRkZxVFvK3+G5J6c5eInJkKZHtqHgI/M1iCBf4u3z9yxlwz7Hwxv/Nds1ERHJSWaQIgGZaslwTERlslMh2puYUuGbJ/vN+MReeuzs79RERyWHlBRUAxGjNck1EZLBRItuVMVPh//sDjDipfd7/3AM/+yvQEDMiIm0qC6sAaLFYdisiIoOOEtnuDDsOblgBt++Fc+b7eeuegx+c4seabanXMF0iMuiNqqgBoDEcpzUez3JtRGQwUSJ7KMzgom/Cp/4TQhFo2gn/fiF8+2h4YAbsWJvtGoqIZM24IWOIOEfK4I1ttdmujogMIkpke+Lk2b67wajT2udtehV+dC4s+zYk1D9MRAafaOkwxsQTALz64TtZro2IDCZKZHtqyDEw73mY/SMoqvLzUnFY9i344TR4/3d+nrociMhgUXEUJ8d8/9iXdItvETmClMj2hhmc/mn4ykbff/Z/3euH7dq9Dv7rCrijEu6sgmfvhKbd2a6tiEj/qjyaac1+6K039j7HnqaGLFdIRAaLfktkzWyomf23mdWb2V4ze8DMyg6yzjIzcx2mf+2vOvYJMzjjb32Xg6lzAGtf9uL34PuT4dk7dJcwERm4ymv4RMxRnUiQiuzmgsWf4sm3X8t2rURkEDDXT6fAzewpYBRwPRAFHgRedc59upt1lgFrgdsyZjc55+p7sN8KoK6uro6KioreVP3wbHvTdzN4+3GoOgb2bvTzQ1HfiptKwNBjYcrfQvnII18/ETki6uvrqaysBKjsSQzLpsOKnz/7K/6w6SX+vmY08VCybXaVO53PT7mOvzn1o5hZNxsQEfF6Ej/7JZE1s0nAW8BfOOdWBfMuAn4LjHHObe5ivWXAaufczYex7+wmsplSKXj7N7D8n+HDDq0TkSI4+a9g6jVw9Fm+ZVdEBoxBl8guvxee/hrvDTmGz5SPpin84X6LC5PHceVxf8MXz72Cwmi07yotIgNOLiSy1wLfdc4NyZgXAVqATznnftXFesuAk/Hn57cCjwP/6Jzr8g4EZlYIFGbMKgc25UQim+YcbFwOy/8F1j514PLqE2HsObDtLTjxEjjlU1A55sjXU0T6TG8TWTMbB9wKXADUAJuB/wK+4Zzr8o4DQfz8WIfZ/+ac+1wP9t37RLalDu47G/ZtgYIyfnfC5Tywbxtvs564JTALvmsSVUyqOJ8QYS4+7nw+c9oFhMO6XENE2uVCIvtV4LPOuYkd5m8HbnfO/aiL9eYBG/GB+1Tg/wdecc5d0c2+7gBu7zg/pxLZTPFmCBfAh3+AVQ/Am7+CRCf3Jx97rm+xnXQZFJZD6z6oGHXk6ysivXIYiexFwNXAYuB9YDLwY+BnzrkF3ay3jGx3zdqyBn5zI2x5fb/ZHxSWct/QY1la0EgilNhvWSgxjEkVH+PvTr2ciyacTiikpFZksOu3RNbMvg18+SDFJgFX0ItEtpP9XQD8DjjeObeuizK53yLbnea98KdfwJpH4IOVfvSD5r1AJ+9L9SSYNAsmXgyjz1B3BJEc1pddC8zsS8DnnXPHdlNmGbnQNSuVgrceg9cehPX/s9+iJjOWlpbwWHkpfygqOmDVUKIaXAEV4VGcXj2VT578cT56zCQltyKDTH8mstXAsIMU+zPwGXrRtaCT/ZUCDcBFzrmlh7hO7vSR7a29tfDWr/206dXOy5SPglGn+64Kx8+AYz8G4z4CI0+BcOSIVldEDtTHiezd+Dh4ZjdllpFrXbMSMQhH/RmotUv8Lb63rPYXvQKNZvy+pJilpSUsLy4mFjrwx3lhophR0ROZctTHwDlqyqq5+pQLGFZafvj1E5GclAtdC9IXe53pnHstmPeXwBK6udirk+2cB7wInOacW3OI6+R/IpupfjOs+z0UV/nuBe88Ae8/B/HGzssXVcKYv4CG7b6v2oSZvv/t0WfDsONBLRsiR0RfJbJmdjzwGrDAOffjbsrlR9eslnr/A337W/4H+dY3oPZl6je/xvKiKC8UF7G8uJixiThvFBYS7+TMU8Q5xsUKOCY0gokVJzJl9Cls3/U+x9ZM4qTjziU05BifQItIXsp6Igttw2+NBD5H+/Bbq9LDb5nZUfhuA3/nnHvFzI4DPo0f2WAXPhB/H9jknOt4AUN3+x1YiWxn4s2w8SWf4K57DoZP8PNqX4bWbt7vgnJ/e92NL8KQ8TD6dN+qWzMZak6D0uGwZz2UDIeiAXrsRLqy5XV47hvgUv6HIwanXgUjToLG7f4xUniwrbTpGIgPtWuWc67tHq9BnHweWOac+/uevJy865oVb4bNf4RNq6BhG5QMY9/m11m1/Q1eT+3h1aIoa4oOfvyHJJNMjMU5JhHh2MgQIq27CIWLOb6omklDx1NYPgqqjoayGtjxDpQMg7KRUF7T/mghH0sLyiAUPgIvXkQy5UoiOxS4F7gMSAG/AG5yzjUEy8cB64GPO+eWmdnR+CtzJwOlwAfAr4C782oc2WxKJWHrGp/QblrlT+EdP8O3eGx6FZKth76tyrEw8iTfils9EfZtg5a9/u+hx8KwCVA2wvfTTQTb7cGXvEi/SiV9MlQ6Yv+uNrFGeHQO7P0ACkqhtNovH30G/O7O7rc56nT4219BydBDqkIniewhdc1Kj0xgZqOBZcDLwBznXOqQdhwYUF2zknHYvZ7U3lqscgx/XL+KFze8wLr69/kzu9gUTZA4hGsGws5xbDzOcbE4oxJJNkUjjIvHGR+Pc3Q8wdHxBEOcEXJJHGCY/4FfVuPf95KhsHu9P/NVMsx/fkqG+fnRYti3NSgXLCse4m9lHin0y4oq/Y+kaImucRDpRk4kstmSs4E425IJfypv8x99y1NBqQ+4m/8IW/8Eu/9MpxeYdSdS5IN38x7AfCvHkHE+Ca4a6xPfHe/CiEl+OLGK0VARPLbWw651vlzlUT7YpwO7cwry0q5pNzTu9J+VaMYFQo27YMW9PkkorfataKXVPll46suw/U2wcPvnKxw9cDznnjj6HPjsbw75B9vhdC0IWmJ/j+9S8BnnXPIgq3S2jUHTNas53kpTLEY4FOK5da+zasMKNuz+EztiG9lre2mJxIkkIyTCiYNuqziVojkUwpxjZDLJ0fEENYkkoxMJRiSTbI6EqUqmGJFMMiqRoDqZpDqZpNDBPjOKnOOgnRpCUX/WK1IM9ZsgWuoT3KJK/1ktqvA/umKN7clvYbk/qxYp8OuHC/yPsFDUfyYLK/z/R9Nu34pcFKxTWO4/+6Gof+z4d7jAd/eINQTrlPnYno7BsSa/fbVMDxopl6KueQ8lhWUUhArabmSSTCX5wbPfoTG2j6HloxhWXsPQsmEMLx/Owyvv58Xd/0MxBZRQTHGohOJQGYWRUooKyhlRNoZbLzrYCal2SmTzMBBnXawJtr/tk9JRp8HOd/1pt53v+793rfN3KTt2OuzZAHs20uPEtzvREp/gxpuh/kMorPQJSNnIYBrhk+5k3J/6K632LSWlw31XiPef9QE7vawkWBYthg0v+i+DshHtLSjFQ6Fpp0/uS0f4ssVD2xOluk0+oS4bcWDi0rrPn3IcSMl2KtV5/+lYk2/Jz/yhAf6H0ZbV/piXjfTHN71825v+vaocExzboGUqlYDfB6fuK0b7ZcVD/PTOE37kjvKa9h88RZU+OV32zfb9Fg/1ywG2/enwXvOIk/z733HeNU8FXQuAeIu/+HL3n+G4jx9W14JDXS9IYpfh+7t+FmhLYp1zWzPKqGtWDySSKf6weQPPb1jNWzve48PGWvbEtxAmSooEzW47LlzXPt7tYShLwrCkY0gqybBkjIZQCAeUpxzDkwmGJFNUpFKUplJ8GIlQnkpRmfLzKlIpylMpilOObZEwBc5RlnKUB8uKnCMJ7AmHKE05ip2jzyORhXxynWhuuzCPgjLfABIt8X/vrfXziyt9El1Q6ifMf0cUVfj/7cz1mnb5GF9UGSTmJX4/0SL/HRMp8svS24oW+zN+9R+2rxMN5heU+vnxlvZEP1rs9xMp8vEhWuxjV7TE7yNSDMmY70JXPCRYp6R9vYbtvhtRUZXffqQomAr92c5Q1NcjWuynSJH/sbH9LX8MMpdFi31DTmu9j1vp1xMtBudwH7yCFZYFP0BK2rYX3/U+u3e+R3lFDUVFlYQKyvyyUIQ1q35KYyhKeekQKoqrqCiupLCwnM2bXue5DS8QKaiivKicysJKyosrKSkq57E3fkpDCkqj5RRHyymJFFMULeGDuvdZ07qBKAUUWJQCohSGCikKFfCsbWz7KEQcFKegyIXYEenRSaH9HBNzPHHdocdsJbIDNBDnlETMtyTsXu//+Ued6gdE31vrT9vu3QB1H/p/5GOn+4vT6jf7eQ1bfTIDPqls2pXNV7K/SLEP3pkKynzrdVGVD2bgWzFKhvv6F1X6Voy1S3yLSVlGglY8xL/uLauD041B4l1cFSRwv/UJZGm13356Py7pb3NcPMQniun5RZWw633/o6O4ygfI4iFBa04VvPYT/wVSNjI4rVnpH+s2wfrn/WspG9He8lMyDN78pf8BUxycOk3XOxnzfbDbXu8wv355DWx4Yf9jFIr6L4XSav/D50gb91H/3rTua/9sjT0Xrvyxf+21L/vP2aZX/eu45Dv9Pi7zYSSyc/DXFBzAOWdBmXGoa1afq29u4Y9b1/H2jlqcc1QVlfHuzg1s2reFLY2bqYvvoim5F0eCiJXQ6naTCtVhoYO39PYVc+AyMteQg6KUUegggiPkwJwRxj+PuhQRHGEcEeencDA/hO9uEQFCzvl1HIToOM8FZdv3sSccYm8oRKGDQpei0EFBkE/sCodImFGcchQ7n3wXOkeThdgTDhF2BPP8sqiD7eEwzSHfol2U8uULnKMpZGyJRCgMtlGU8vMLnWNTNELMrO15eh2A96PR9nWCqTDl2B4JszcUoiA9L2O9dwsKMKA4PT/YV2PI2BCNtm2nKBW8XhzvRaM0h9rrkK67A1YXFba9nqKM/a2PRtgeiVCYSlEczC8OyrxdWLDf+12USlHgHPXh3GoRP6e5hX0ho9FC1IdDtAQNGTe3jCQWLqQp0UijaybmWom7OEXhCr58w8pD3r4S2UEciPNCMuFbQ0uG+1Nj8WY/wkLdh/6xcacfZaFlLzTu8H3LGrb5+U07fb/fpl1+WdMuP79xh9/2UVN9mcad7fNTcag4yidajTv8qbfM1uSS4T6R6/nZW+nO0OP8+xZr6LDA4ISLoHm3P+4t9T4BTTTDZf/sE894k28FjRT5v0/5JIyf7s8StNb7Fp/GHf49Pfvz+3c5cM4n4Vnusz3oblE7SCWTKWrrdrFhz3biyRRHVw7n/d1b2FS/jR2Nu9nRtJtdLXvAhRlSVM7ult3UxfbSnGigJdVAa6qRAismZGFiqUbiNJKiBRdqBoxQqhRnrbhQC2a9bxGTgaMsCS0hSHRoih/XGsEBLaEkMXPEzRE336J6cnwYMVqJkyBuSWKkiIXinMlESqKltCSbiCWbibkYcRdnQnQs00+5mt2NO9jXUkdjSz3NsTpShLj0E19k+LDRkGjFxZuJNdXR2rSPoooRFFSO6JPXqERWgVjSnPMtdJn9u1IpnyQ37/HD/xSU+HKt9X5e025/OuuoM3yS3bTLTy11/mYVxVX+oremXb6fZmudf4zt8xfHlVa3b6dlr18n0QLHX9i+veY9wfb2+H6cx37MP2/a5RO79N+jT/d1zNxWS52v6+QrfZLXHLyW5j2+TMlwGHt2e31b9kJrg19+0uW+X1zrvqAewfKykfsnl+kEM94EJ17qW28bdwTL9/r9R4rh1Kt90ti0018QGNvn91tzKgwd7493IubLxxr8cR4ybmB1y+iCElk5XM659v6JyRS7mhuob22gIdbE0MIaGlqbqWvdx97WOpriLTS2xkmSpKIoTHM8RkMsTkssTmM8RnM8TkHEKIxCayJBSzxOSyJOazJBKpWkKGpYKEVrIkEs6ad4MgmWpDgaIpFKEEslSKSSJJJJEi5JebSCsmg5LYlWWpN+iqf8XZSHFg0jEgoTS7UQS7WQSMWIp+KEiFJgVSRScRKpVhIuRsLFcKQoj1ZRHCkmlmollmwlnoqTSMXBEgwvOgqgbX4sFSOeaqUwHKW6aAyxjP3HU3GSLk5lwRDKCyr8slQr8fQ2XYzxFSeQSCWCercQT8ZIJFsoiJQxpvwoWpOttCRbiCVaSSRbiKVaGV81kcJIlOZEC62JVuLxJuLJJixcwukjT6Uh3kxzvJnWRAuxRCPxRCvjhp3AiNKhNMaaaUo00xJrojXWgIWLmDnho9S3NtLQ2sy+WCONsQZi8WbOOfpMjh4ynD3NDextbmJfrJmmeDORUJi/OvlMzEI0xZI0tLSyt6WJ5kQrY6uGMqK8dL/PTzLliCdTFEVzqzX3UCiRVSAWkSxTIisi0js9iZ8aHV9ERERE8pISWRERERHJS5GDF8lP9fV5cSZPRAaofI5B+Vx3Ecl/PYlBA7GP7FHApmzXQ0QkMMY592G2K3EoFD9FJMccNH4OxETWgNHAvh6sVo4P3mN6uJ4cSMey7+hY9o1sHsdyYLPLk0Cr+Jl1OpZ9R8eyb+R8/BxwXQuCF9yj1g9rHwpoX75cXZyrdCz7jo5l38jyccyr903xM7t0LPuOjmXfyIf4qYu9RERERCQvKZEVERERkbykRNZrBe4MHuXw6Fj2HR3LvqHj2L90fPuOjmXf0bHsGzl/HAfcxV4iIiIiMjioRVZERERE8pISWRERERHJS0pkRURERCQvKZEVERERkbykRBYws/lmtsHMWsxspZmdle065RIzu8PMXIfpnYzlRWZ2n5ntMrMGM/uFmY3ssI2xZvakmTWZ2XYzu8fMBtwNOToys/PN7HEz2xwct9kdlpuZ3WVmW8ys2cyeNbMJHcoMNbP/NrN6M9trZg+YWVmHMqea2QvBZ/gDM/s/R+DlHTGHcBx/0slndEmHMoP+OPYHxc/uKX72nuJn3xjo8XPQJ7JmdjXwPfzwEmcArwNLzWxEViuWe94ERmVMH8lY9n3gMuBTwMfwt7j8ZXqhmYWBJ4EC4Fzgs8Ac4K4jUO9sK8V/puZ3sfz/ADcBnwPOBhrxn7+ijDL/DZwMzABmAecD96cXmlkF8DSwEZgKfAm4w8zm9ekrya6DHUeAJez/Gf2bDst1HPuY4uchU/zsHcXPvjGw46dzblBPwErg3oznIfwtGr+S7brlygTcAazuYlklEAM+mTHvRMAB5wTPLwaSwMiMMp8D6oCCbL++I3gcHTA747kBW4AFHY5nC/DXwfNJwXpnZpS5CEgBo4Pnnwd2Zx5L4NvAO9l+zUfiOAbzfgI81s06Oo79814ofh78GCl+9s1xVPzsh+MYzMvr+DmoW2TNrAD/y+HZ9DznXCp4Pi1b9cpRE4LTEn8OTi+MDeZPBaLsfwzfAWppP4bTgDecc9sytrcUqMD/whusxgM17H/s6vDJQeax2+ucW5Wx3rP4AHJ2Rpn/cc7FMsosBSaa2ZB+qnsumh6cdn3XzH5kZsMyluk49jHFzx5R/Ox7ip99K2/j56BOZIHhQBjY1mH+Nvw/iHgr8aeyLsL/6hoPvGBm5fjjFHPO7e2wTuYxrKHzYwyD+zinX3t3n78aYHvmQudcAv/LV8e33RLg74ALgS/jT9E+FZyWBR3H/qD4eWgUP/uH4mffyev4OeA7i8vhc849lfF0jZmtxPeDuQpozk6tRNo55x7OePqGma0B1gHTgd9lpVIiKH5K7sv3+DnYW2R3EvQ96jB/JLD1yFcnPwStB2uB4/HHqcDMqjoUyzyGW+n8GMPgPs7p197d528rsN+FM8HVykPR8e2Sc+7P+P/v44NZOo59T/GzFxQ/+4ziZz/Jt/g5qBPZoC/Ha/jmdADMLBQ8X5GteuW6YMiN4/Ad7V8D4ux/DCcCY2k/hiuAUzpcyTwDqAfeOhJ1zlHr8f/gmceuAt/nKPPYVZnZ1Iz1LsD/767MKHO+mUUzyswA3nXO7emnuuc0MxsDDMN/RkHHsc8pfvaO4mefUfzsJ3kXP7N9BV22J+Bq/FWOn8VfmfdvwB4yrhAd7BPwHXyfmXH44V+eAXYA1cHyH+FPlX0cf/HCcmB5xvph4A18x+/TgJn4/jbfzPZrOwLHrgw4PZgc8IXg77HB8i8Hn7f/BZwCPAb8GSjK2MZTwB+As4Dz8K05D2Usr8QH9J/iL/64Gj8Mzbxsv/4jcRyDZfcA5wSf0QvxCcJaoFDHsV/fF8XPgx8jxc/eHzvFz34+jgMhfmb9AOfCBNwYBJJW/K+Ls7Ndp1yagIeBzcHx2RQ8Py5jeRFwH77jdyN+DMSaDts4Bvgt0BQE8e8AkWy/tiNw7KYHgaPj9JNgueHHg9yKTwieBU7osI2hwEPAPvyQO/8BlHUocyrwQrCNTcCXs/3aj9RxBIrxX/Lb8UMZbcCPbziywzYG/XHsp/dG8bP746P42ftjp/jZz8dxIMRPC3YuIiIiIpJXBnUfWRERERHJX0pkRURERCQvKZEVERERkbykRFZERERE8pISWRERERHJS0pkRURERCQvKZEVERERkbykRFZERERE8pISWRERERHJS0pkRURERCQvKZEVERERkbykRFZERERE8tL/A6Dqwx3gEzaqAAAAAElFTkSuQmCC\n"},"metadata":{"needs_background":"light"}}],"source":["check_loss(100000, fname=f'allloss_0.5_{100*i}')"]},{"cell_type":"code","execution_count":19,"metadata":{"id":"N76CcRjaHuil","executionInfo":{"status":"ok","timestamp":1679767825724,"user_tz":420,"elapsed":9,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":["rho_next, rods_dict, losses, losses_rods = loadall()\n","EPS_MIN_ROD, EPS_MAX_ROD = 0.98,1.02"]},{"cell_type":"code","execution_count":20,"metadata":{"id":"qMcmOrg4X3ZO","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1679767827627,"user_tz":420,"elapsed":1912,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}},"outputId":"b8b188f9-460d-4052-f982-26ad66ff8a4a"},"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-7-d26a2201a1c0>:104: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  return rho*design_region + bg_rho*(design_region==0).astype(np.float)\n","<ipython-input-9-97639221a84f>:11: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_source = np.zeros_like(source,dtype=np.float)\n","<ipython-input-9-97639221a84f>:14: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n","  mask_probe = np.zeros_like(probe,dtype=np.float)\n"]}],"source":["check_structure_for_paper(rho_next, offsets = task_offsets, fname=f'struct_final')"]},{"cell_type":"code","execution_count":20,"metadata":{"id":"PQPuQJmkX9ie","executionInfo":{"status":"ok","timestamp":1679767827628,"user_tz":420,"elapsed":6,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":[]},{"cell_type":"code","execution_count":20,"metadata":{"id":"bsJK2e31YM0J","executionInfo":{"status":"ok","timestamp":1679767827628,"user_tz":420,"elapsed":4,"user":{"displayName":"Beicheng Lou","userId":"17721363065364648269"}}},"outputs":[],"source":[]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}