From e577213fef08dfcd774b165c3a3a2370ee960868 Mon Sep 17 00:00:00 2001 From: thomas Date: Mon, 1 Aug 2022 19:02:50 -0700 Subject: [PATCH 1/9] return eps array if ax=None --- python/visualization.py | 39 +++++++++++++++++++++------------------ 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/python/visualization.py b/python/visualization.py index 1fe46f0a6..58aace1d6 100644 --- a/python/visualization.py +++ b/python/visualization.py @@ -439,11 +439,11 @@ def sort_points(xy): def plot_eps( sim: Simulation, - ax: Axes, + ax: Axes = None, output_plane: Volume = None, eps_parameters: dict = None, frequency: float = None, -) -> Axes: +) -> Union[Axes, Any]: # consolidate plotting parameters if eps_parameters is None: eps_parameters = default_eps_parameters @@ -524,22 +524,25 @@ def plot_eps( ) if mp.am_master(): - if eps_parameters["contour"]: - ax.contour( - eps_data, - 0, - levels=np.unique(eps_data), - colors="black", - origin="upper", - extent=extent, - linewidths=eps_parameters["contour_linewidth"], - ) - else: - ax.imshow(eps_data, extent=extent, **filter_dict(eps_parameters, ax.imshow)) - ax.set_xlabel(xlabel) - ax.set_ylabel(ylabel) - - return ax + if ax: + if eps_parameters["contour"]: + ax.contour( + eps_data, + 0, + levels=np.unique(eps_data), + colors="black", + origin="upper", + extent=extent, + linewidths=eps_parameters["contour_linewidth"], + ) + else: + ax.imshow( + eps_data, extent=extent, **filter_dict(eps_parameters, ax.imshow) + ) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + return ax + return eps_data def plot_boundaries( From 4e12834c4cb792fd467a7bf8f6a6678825fb571b Mon Sep 17 00:00:00 2001 From: thomas Date: Mon, 1 Aug 2022 19:04:37 -0700 Subject: [PATCH 2/9] plot/update eps and/or fields in Animate2D --- python/visualization.py | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/python/visualization.py b/python/visualization.py index 58aace1d6..d9c37b347 100644 --- a/python/visualization.py +++ b/python/visualization.py @@ -1058,6 +1058,7 @@ def __init__( realtime=False, normalize=False, plot_modifiers=None, + update_epsilon: bool = False, **customization_args ): """ @@ -1092,11 +1093,14 @@ def mod1(ax): plot_modifiers = [mod1] ``` + + **`update_epsilon=False`** — Redraw epsilon on each call. (Useful for topology optimization) + + **`**customization_args`** — Customization keyword arguments passed to `plot2D()` (i.e. `labels`, `eps_parameters`, `boundary_parameters`, etc.) """ self.fields = fields + self.update_epsilon = update_epsilon if f: self.f = f @@ -1147,14 +1151,25 @@ def __call__(self, sim, todo): self.w, self.h = self.f.get_size_inches() self.init = True else: - # Update the plot - filtered_plot_fields = filter_dict(self.customization_args, plot_fields) - fields = sim.plot_fields(fields=self.fields, **filtered_plot_fields) - if mp.am_master(): - self.ax.images[-1].set_data(fields) - self.ax.images[-1].set_clim( - vmin=0.8 * np.min(fields), vmax=0.8 * np.max(fields) + if self.update_epsilon: + # Update epsilon + filtered_plot_eps = filter_dict(self.customization_args, plot_eps) + eps = plot_eps(sim=sim, **filtered_plot_eps) + if mp.am_master(): + eps_idx = -1 if not self.fields else -2 + self.ax.images[eps_idx].set_data(eps) + + if self.fields: + # Update fields + filtered_plot_fields = filter_dict( + self.customization_args, plot_fields ) + fields = sim.plot_fields(fields=self.fields, **filtered_plot_fields) + if mp.am_master(): + self.ax.images[-1].set_data(fields) + self.ax.images[-1].set_clim( + vmin=0.8 * np.min(fields), vmax=0.8 * np.max(fields) + ) if self.realtime and mp.am_master(): # Redraw the current figure if requested From 4184c0c15de41a0a8e61db710eba272b3d456394 Mon Sep 17 00:00:00 2001 From: thomas Date: Thu, 4 Aug 2022 12:43:26 -0700 Subject: [PATCH 3/9] add step_funcs to OptimizationProblem --- python/adjoint/optimization_problem.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/python/adjoint/optimization_problem.py b/python/adjoint/optimization_problem.py index 707eb8beb..1511679bb 100644 --- a/python/adjoint/optimization_problem.py +++ b/python/adjoint/optimization_problem.py @@ -37,8 +37,9 @@ def __init__( minimum_run_time=0, maximum_run_time=None, finite_difference_step=utils.FD_DEFAULT, + step_funcs: list = None, ): - + self.step_funcs = step_funcs self.sim = simulation if isinstance(objective_functions, list): @@ -184,15 +185,17 @@ def forward_run(self): if any(isinstance(m, LDOS) for m in self.objective_arguments): self.sim.run( mp.dft_ldos(self.frequencies), + *self.step_funcs, until_after_sources=mp.stop_when_dft_decayed( self.decay_by, self.minimum_run_time, self.maximum_run_time ), ) else: self.sim.run( + *self.step_funcs, until_after_sources=mp.stop_when_dft_decayed( self.decay_by, self.minimum_run_time, self.maximum_run_time - ) + ), ) # record objective quantities from user specified monitors @@ -254,9 +257,10 @@ def adjoint_run(self): # Adjoint run self.sim.run( + *self.step_funcs, until_after_sources=mp.stop_when_dft_decayed( self.decay_by, self.minimum_run_time, self.maximum_run_time - ) + ), ) # reset the m number @@ -376,15 +380,17 @@ def calculate_fd_gradient( if any(isinstance(m, LDOS) for m in self.objective_arguments): self.sim.run( mp.dft_ldos(self.frequencies), + *self.step_funcs, until_after_sources=mp.stop_when_energy_decayed( dt=1, decay_by=1e-11 ), ) else: self.sim.run( + *self.step_funcs, until_after_sources=mp.stop_when_dft_decayed( self.decay_by, self.minimum_run_time, self.maximum_run_time - ) + ), ) # record final objective function value @@ -409,15 +415,17 @@ def calculate_fd_gradient( if any(isinstance(m, LDOS) for m in self.objective_arguments): self.sim.run( mp.dft_ldos(self.frequencies), + *self.step_funcs, until_after_sources=mp.stop_when_energy_decayed( dt=1, decay_by=1e-11 ), ) else: self.sim.run( + *self.step_funcs, until_after_sources=mp.stop_when_dft_decayed( self.decay_by, self.minimum_run_time, self.maximum_run_time - ) + ), ) # record final objective function value From 4d31ceb07fc78738db362686800e2cc519995384 Mon Sep 17 00:00:00 2001 From: thomas Date: Thu, 4 Aug 2022 13:48:39 -0700 Subject: [PATCH 4/9] make step_funcs default to empty list --- python/adjoint/optimization_problem.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/adjoint/optimization_problem.py b/python/adjoint/optimization_problem.py index 1511679bb..fdeb33e07 100644 --- a/python/adjoint/optimization_problem.py +++ b/python/adjoint/optimization_problem.py @@ -39,7 +39,7 @@ def __init__( finite_difference_step=utils.FD_DEFAULT, step_funcs: list = None, ): - self.step_funcs = step_funcs + self.step_funcs = step_funcs if step_funcs is not None else [] self.sim = simulation if isinstance(objective_functions, list): From 716d35c6eda0652300c56d95de39330b74eae2eb Mon Sep 17 00:00:00 2001 From: thomas Date: Thu, 4 Aug 2022 14:07:27 -0700 Subject: [PATCH 5/9] set Animate2D 'sim' argument default value to None --- python/visualization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/visualization.py b/python/visualization.py index d9c37b347..b0c0ab319 100644 --- a/python/visualization.py +++ b/python/visualization.py @@ -1052,8 +1052,8 @@ class Animate2D: def __init__( self, - sim, fields, + sim=None, f=None, realtime=False, normalize=False, From ce3b42f4e7eaaa9856cd8a6e112a79ae1d59cf8e Mon Sep 17 00:00:00 2001 From: thomas Date: Thu, 11 Aug 2022 09:20:21 -0700 Subject: [PATCH 6/9] fix visualization tests --- python/tests/test_visualization.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/python/tests/test_visualization.py b/python/tests/test_visualization.py index 627686b0e..e0c094f20 100644 --- a/python/tests/test_visualization.py +++ b/python/tests/test_visualization.py @@ -221,10 +221,10 @@ def test_animation_output(self): sim = setup_sim() # generate 2D simulation Animate = mp.Animate2D( - sim, fields=mp.Ez, realtime=False, normalize=False + sim=sim, fields=mp.Ez, realtime=False, normalize=False ) # Check without normalization Animate_norm = mp.Animate2D( - sim, mp.Ez, realtime=False, normalize=True + sim=sim, fields=mp.Ez, realtime=False, normalize=True ) # Check with normalization # test both animation objects during same run @@ -252,10 +252,10 @@ def test_animation_output(self): sim = setup_sim(5) # generate 2D simulation Animate_xy = mp.Animate2D( - sim, fields=mp.Ey, realtime=False, normalize=True + sim=sim, fields=mp.Ey, realtime=False, normalize=True ) # Check without normalization Animate_xz = mp.Animate2D( - sim, mp.Ey, realtime=False, normalize=True + sim=sim, fields=mp.Ey, realtime=False, normalize=True ) # Check with normalization # test both animation objects during same run From ecd1710f1942a70c19739817aa94ae2464ab27d6 Mon Sep 17 00:00:00 2001 From: thomas Date: Fri, 12 Aug 2022 20:26:42 -0700 Subject: [PATCH 7/9] enable Animate2D in Jupyter notebooks --- python/visualization.py | 65 ++++++++++++++++++++++++++++++++--------- 1 file changed, 52 insertions(+), 13 deletions(-) diff --git a/python/visualization.py b/python/visualization.py index b0c0ab319..17f8db859 100644 --- a/python/visualization.py +++ b/python/visualization.py @@ -1,6 +1,9 @@ from collections import namedtuple import warnings +from time import sleep + +import matplotlib.pyplot as plt import numpy as np import meep as mp @@ -10,6 +13,7 @@ ## Typing imports from matplotlib.axes import Axes +from matplotlib.figure import Figure from typing import Callable, Union, Any, Iterable # ------------------------------------------------------- # @@ -791,9 +795,7 @@ def plot_fields( if mp.am_master(): ax.imshow(fields, extent=extent, **filter_dict(field_parameters, ax.imshow)) return ax - else: - return fields - return ax + return fields def plot2D( @@ -812,12 +814,14 @@ def plot2D( plot_sources_flag: bool = True, plot_monitors_flag: bool = True, plot_boundaries_flag: bool = True, + nb: bool = False, ) -> Axes: # Ensure a figure axis exists if ax is None and mp.am_master(): from matplotlib import pyplot as plt + # nb = plt.get_backend() == 'module://ipympl.backend_nbagg' ax = plt.gca() # validate the output plane to ensure proper 2D coordinates @@ -837,7 +841,10 @@ def plot2D( # Plot boundaries if plot_boundaries_flag: ax = plot_boundaries( - sim, ax, output_plane=output_plane, boundary_parameters=boundary_parameters + sim, + ax, + output_plane=output_plane, + boundary_parameters=boundary_parameters, ) # Plot sources @@ -869,7 +876,10 @@ def plot2D( output_plane=output_plane, field_parameters=field_parameters, ) - + # If using %matplotlib ipympl magic, we need to force the figure to be displayed immediately + if mp.am_master() and nb: + display_immediately(ax.figure) + sleep(0.05) return ax @@ -1016,6 +1026,21 @@ def plot_box(box, proc, fig, ax): # modify plot # customization_args .. [dict] other customization args # to pass to plot2D() +# +def display_immediately(fig: Figure): + """ + Trigger the specified figure to display immediately, rather than waiting on the cell execution to end. + Due to limitations in ipympl: https://github.com/matplotlib/ipympl/issues/290, which might be fixed at some + point in the future. + """ + from IPython.display import display + + canvas = fig.canvas + display(canvas) + canvas._handle_message(canvas, {"type": "send_image_mode"}, []) + canvas._handle_message(canvas, {"type": "refresh"}, []) + canvas._handle_message(canvas, {"type": "initialized"}, []) + canvas._handle_message(canvas, {"type": "draw"}, []) class Animate2D: @@ -1059,6 +1084,7 @@ def __init__( normalize=False, plot_modifiers=None, update_epsilon: bool = False, + nb: bool = False, **customization_args ): """ @@ -1073,8 +1099,7 @@ def __init__( initialization. + **`realtime=False`** — Whether or not to update a figure window in realtime as - the simulation progresses. Disabled by default. Not compatible with - IPython/Jupyter notebooks. + the simulation progresses. Disabled by default. + **`normalize=False`** — Records fields at each time step in memory in a NumPy array and then normalizes the result by dividing by the maximum field value at a @@ -1095,21 +1120,26 @@ def mod1(ax): + **`update_epsilon=False`** — Redraw epsilon on each call. (Useful for topology optimization) + + **`nb=False`** — For the animation work in a Jupyter notebook, set to True and use the cell magic: + `%matplotlib ipympl` + **`**customization_args`** — Customization keyword arguments passed to `plot2D()` (i.e. `labels`, `eps_parameters`, `boundary_parameters`, etc.) """ self.fields = fields self.update_epsilon = update_epsilon + self.nb = nb if f: - self.f = f - self.ax = self.f.gca() + self.f: Figure = f + self.ax: Axes = self.f.gca() elif mp.am_master(): from matplotlib import pyplot as plt - self.f = plt.figure() - self.ax = self.f.gca() + self.f: Figure = plt.figure() + self.ax: Axes = self.f.gca() + # This is another option for enabling notebook plotting + # self.nb = plt.get_backend() == 'module://ipympl.backend_nbagg' else: self.f = None self.ax = None @@ -1139,7 +1169,9 @@ def __call__(self, sim, todo): # Initialize the plot if not self.init: filtered_plot2D = filter_dict(self.customization_args, plot2D) - ax = sim.plot2D(ax=self.ax, fields=self.fields, **filtered_plot2D) + ax = sim.plot2D( + ax=self.ax, fields=self.fields, nb=self.nb, **filtered_plot2D + ) # Run the plot modifier functions if self.plot_modifiers: for k in range(len(self.plot_modifiers)): @@ -1154,6 +1186,7 @@ def __call__(self, sim, todo): if self.update_epsilon: # Update epsilon filtered_plot_eps = filter_dict(self.customization_args, plot_eps) + # when calling with no 'ax', returns array of epsilon data eps = plot_eps(sim=sim, **filtered_plot_eps) if mp.am_master(): eps_idx = -1 if not self.fields else -2 @@ -1164,16 +1197,22 @@ def __call__(self, sim, todo): filtered_plot_fields = filter_dict( self.customization_args, plot_fields ) + # when calling with no 'ax', returns array of fields data fields = sim.plot_fields(fields=self.fields, **filtered_plot_fields) if mp.am_master(): self.ax.images[-1].set_data(fields) self.ax.images[-1].set_clim( vmin=0.8 * np.min(fields), vmax=0.8 * np.max(fields) ) + # If in a Jupyter notebook, we need to redraw the canvas + if self.nb and mp.am_master(): + self.f.canvas.draw() if self.realtime and mp.am_master(): # Redraw the current figure if requested - plt.pause(0.05) + # For some reason, plt.pause() causes ipympl to redraw the same figure, and we end up with + # a new copy of the figure every time this class is called. + plt.pause(0.05) if not self.nb else sleep(0.05) if self.normalize and mp.am_master(): # Save fields as a numpy array to be normalized From b2b3eb0a3e02fc32b9f8c37e227118229b6a33ca Mon Sep 17 00:00:00 2001 From: thomas Date: Sat, 13 Aug 2022 13:58:46 -0700 Subject: [PATCH 8/9] use ion/ioff to prevent duplicate figures in notebooks --- python/visualization.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/python/visualization.py b/python/visualization.py index 17f8db859..8b0d3c0e8 100644 --- a/python/visualization.py +++ b/python/visualization.py @@ -1136,7 +1136,13 @@ def mod1(ax): elif mp.am_master(): from matplotlib import pyplot as plt + # To prevent 2 figures from being created in a notebook, interactive must be turned off and back on here + # https://matplotlib.org/ipympl/examples/full-example.html#fixing-the-double-display-with-ioff + if self.nb: + plt.ioff() self.f: Figure = plt.figure() + if self.nb: + plt.ion() self.ax: Axes = self.f.gca() # This is another option for enabling notebook plotting # self.nb = plt.get_backend() == 'module://ipympl.backend_nbagg' From 36cf445280e80d2314645e9a8551fcc0e77a278f Mon Sep 17 00:00:00 2001 From: thomas Date: Sat, 13 Aug 2022 17:23:35 -0700 Subject: [PATCH 9/9] update adjoint tutorial 3 with animated plot --- .../03-Filtered_Waveguide_Bend.ipynb | 41320 +++++++++++++++- 1 file changed, 39877 insertions(+), 1443 deletions(-) diff --git a/python/examples/adjoint_optimization/03-Filtered_Waveguide_Bend.ipynb b/python/examples/adjoint_optimization/03-Filtered_Waveguide_Bend.ipynb index ba833ce4c..83b21c28b 100644 --- a/python/examples/adjoint_optimization/03-Filtered_Waveguide_Bend.ipynb +++ b/python/examples/adjoint_optimization/03-Filtered_Waveguide_Bend.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "# Filtering and Thresholding Design Parameters and Broadband Objective Functions\n", "\n", @@ -18,7 +22,15 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -26,18 +38,32 @@ "text": [ "Using MPI version 3.1, 1 processes\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/thomas/.local/lib/python3.10/site-packages/numpy/core/getlimits.py:500: UserWarning: The value of the smallest subnormal for type is zero.\n", + " setattr(self, word, getattr(machar, word).flat[0])\n", + "/home/thomas/.local/lib/python3.10/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for type is zero.\n", + " return self._float_to_str(self.smallest_subnormal)\n", + "/home/thomas/.local/lib/python3.10/site-packages/numpy/core/getlimits.py:500: UserWarning: The value of the smallest subnormal for type is zero.\n", + " setattr(self, word, getattr(machar, word).flat[0])\n", + "/home/thomas/.local/lib/python3.10/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for type is zero.\n", + " return self._float_to_str(self.smallest_subnormal)\n" + ] } ], "source": [ "import meep as mp\n", "import meep.adjoint as mpa\n", + "from meep import Animate2D\n", "import numpy as np\n", "from autograd import numpy as npa\n", - "from autograd import tensor_jacobian_product, grad\n", + "from autograd import tensor_jacobian_product\n", "import nlopt\n", "from matplotlib import pyplot as plt\n", "from matplotlib.patches import Circle\n", - "from scipy import special, signal\n", "\n", "mp.verbosity(0)\n", "Si = mp.Medium(index=3.4)\n", @@ -46,7 +72,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Let's choose our basic geometry parameters, along with the frequency range to simulate. If our frequency points are too close together than the resulting adjoint simulation may take longer to simulate each iteration." ] @@ -54,7 +84,15 @@ { "cell_type": "code", "execution_count": 2, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "waveguide_width = 0.5\n", @@ -72,7 +110,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Now we'll specify our smoothing filter radius (in microns). This is determined by our minimum length scale and erosion threshold point. In this example, we won't actually enforce the length scale constraints, but the following machinery is required to do so.\n", "\n", @@ -82,7 +124,15 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -106,7 +156,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "As before, we'll generate our simulation cell with the specified sources, boundary layers, geometry, etc." ] @@ -114,7 +168,15 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "Sx = 2 * pml_size + 2 * waveguide_length + design_region_width\n", @@ -144,7 +206,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Let's set up our design region. The defauly grid type behaves just like any other geometry object -- the last object in the tree overides any objects underneath it. In some cases, it's important to *average* overlapping design regions, i.e. to enforce particular symmetries. To enable this capability, we'll set our design variables to use the `U_MEAN` grid type." ] @@ -152,7 +218,15 @@ { "cell_type": "code", "execution_count": 5, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "Nx = int(design_region_resolution * design_region_width)\n", @@ -170,7 +244,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "The optimizer doesn't know anything about the geometry outside of the design region. We can \"hint\" what parts of the design must be waveguides by forcing boundry constraints. We'll build bitmasks that map the border of the design regions to either silicon or silicon dioxide." ] @@ -178,7 +256,15 @@ { "cell_type": "code", "execution_count": 6, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "x_g = np.linspace(-design_region_width / 2, design_region_width / 2, Nx)\n", @@ -201,7 +287,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Next, we'll define various filters that perform smoothing, projection, and material scaling. We'll be sure to use autograd so that we can easily backpropogate our gradient provided by the adjoint solver. We have some smoothing and thresholding filters already defined in the adjoint package that we'll use here." ] @@ -209,7 +299,15 @@ { "cell_type": "code", "execution_count": 7, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def mapping(x, eta, beta):\n", @@ -237,7 +335,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Let's build the geometry and simulation objects. We can force a rotational symmetry by adding extra blocks with the same design variables, but different basis vectors (`e1`, `e2`, etc.) In our case, we need one additional block object rotated by 90 degrees.\n", "\n", @@ -247,7 +349,15 @@ { "cell_type": "code", "execution_count": 8, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "geometry = [\n", @@ -279,7 +389,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Let's formulate our broadband objective function. To keep it simple we'll just maximize the average of the transmission." ] @@ -287,7 +401,15 @@ { "cell_type": "code", "execution_count": 9, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "mode = 1\n", @@ -319,7 +441,15 @@ { "cell_type": "code", "execution_count": 10, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "opt = mpa.OptimizationProblem(\n", @@ -327,13 +457,17 @@ " objective_functions=J,\n", " objective_arguments=ob_list,\n", " design_regions=[design_region],\n", - " frequencies=frequencies,\n", + " frequencies=frequencies\n", ")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Next, let's see how well our filtering and projection functions work." ] @@ -341,11 +475,19 @@ { "cell_type": "code", "execution_count": 11, - "metadata": {}, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -357,27 +499,74 @@ } ], "source": [ + "%matplotlib inline\n", + "plt.figure()\n", "rho_vector = np.random.rand(Nx * Ny)\n", "opt.update_design([mapping(rho_vector, eta_i, 1e3)])\n", - "opt.plot2D(True, output_plane=mp.Volume(center=(0, 0, 0), size=(3, 3, 0)))\n", - "plt.show()" + "opt.plot2D(True, output_plane=mp.Volume(center=(0, 0, 0), size=(3, 3, 0)))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "plt.figure()\n", + "rho_vector = np.random.rand(Nx * Ny)\n", + "opt.update_design([mapping(rho_vector, eta_i, 1e3)])\n", + "opt.plot2D(True, output_plane=mp.Volume(center=(0, 0, 0), size=(3, 3, 0)))" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "We can increase our `beta` term, which controls the thresholding, and simultaneously sweep our perturbation term (`delta`) which is used to generate erosion and dilation geometries typically used in the literature. " ] }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -389,39 +578,48 @@ } ], "source": [ + "%matplotlib inline\n", "beta = 2048\n", "\n", - "plt.figure()\n", - "ax1 = plt.subplot(1, 3, 1)\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3)\n", "opt.update_design([mapping(rho_vector, 0.498, beta)])\n", "opt.plot2D(True, ax=ax1, output_plane=mp.Volume(center=(0, 0, 0), size=(3, 3, 0)))\n", - "plt.title(\"Dilation\")\n", + "ax1.set_title(\"Dilation\")\n", "\n", - "ax2 = plt.subplot(1, 3, 2)\n", "opt.update_design([mapping(rho_vector, 0.5, beta)])\n", "opt.plot2D(True, ax=ax2, output_plane=mp.Volume(center=(0, 0, 0), size=(3, 3, 0)))\n", - "plt.title(\"Intermediate\")\n", + "ax2.set_title(\"Intermediate\")\n", "\n", - "ax3 = plt.subplot(1, 3, 3)\n", "opt.update_design([mapping(rho_vector, 0.502, beta)])\n", "opt.plot2D(True, ax=ax3, output_plane=mp.Volume(center=(0, 0, 0), size=(3, 3, 0)))\n", - "plt.title(\"Erosion\")\n", + "ax3.set_title(\"Erosion\")\n", "\n", - "plt.tight_layout()\n", - "plt.show()" + "fig.tight_layout()" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "With our framwork in place, we can define our `nlopt` cost function wrapper that also includes our mapping layers and their corresponding gradients. We'll systematically increase our `beta` term so that the thresholding gradually turns on, as suggested by the literature." ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": 14, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "evaluation_history = []\n", @@ -440,20 +638,6 @@ "\n", " evaluation_history.append(np.real(f0))\n", "\n", - " plt.figure()\n", - " ax = plt.gca()\n", - " opt.plot2D(\n", - " False,\n", - " ax=ax,\n", - " plot_sources_flag=False,\n", - " plot_monitors_flag=False,\n", - " plot_boundaries_flag=False,\n", - " )\n", - " circ = Circle((2, 2), minimum_length / 2)\n", - " ax.add_patch(circ)\n", - " ax.axis(\"off\")\n", - " plt.show()\n", - "\n", " cur_iter[0] = cur_iter[0] + 1\n", "\n", " return np.real(f0)" @@ -461,1602 +645,374 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ + "\n", "We'll now run our optimizer in loop. The loop will increase beta and reset the optimizer, which is important since the cost function changes." ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": 15, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + }, + "scrolled": true, + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Current iteration: 1\n", - "Starting forward run...\n", - "Starting adjoint run...\n", - "Calculating gradient...\n" + "Starting forward run...\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP0AAADnCAYAAADVeFABAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAObElEQVR4nO3dy44bV37H8V9deWnLstKGFbSghQLHkQFjXmEWQRbRwps8wyC7bGblBzCQbV4hy+yy8BNkm4VjA0EMeGdYA2MASW01L8W6ZeH5HxVL7CLV1axm6Xw/AGFd2mI1m1+eqlNFnqCuawHwR3jXGwBgWEQPeIboAc8QPeAZogc8sy/6mttp3oqiqMuydL//9ttv62fPntVBELhbkiRbv3+XW/v/ffbsWf3dd9+5+yvLcuv+uZ3kbSdGesAzRA94hugBzxA94BmiH6kgCO56EzBSRD9SvGcCN0X0gGeIHvAM0QOeIXrAM0QPeIboAc8QPeAZogc8Q/SAZ4ge8AzRjxTX3uOmiH6kuPYeN0X0gGeIHrhF//ntz3r2b/+lP/z7f+vFYnPXm7NTfNcbALwv/vw60x//439UVLX+90+/6vzs//Sv//S7u96stzDSA7dknZcqqjdzLa/XxR1uzfWIHrglj/9qrn/+/d8oCKS//nCqf/n7v73rTdqJ3XvgFn31j5/rj//wd0rj0x1PT3fLgJE65eAloge8Q/SAZ4ge8AzRA54hesAzRA94hugBzxA9boy3944T0ePG+CCPcSL6kSI43BTRjxS71rgpogc8Q/SAZ4ge8AzR48aYVxgnogc8Q/S4MU4bjhPRA54hesAzRA94hugBzxA94BmiBzxD9CPWdXFMGIa9TqkFQbD1/0dR9NZ9c3HOOBH9e+q2gyTw9wfLWo1UGG6/XkdRpCzL3O/rulZR3HwBxaIotkLPsmzrPtv3j/HgJwd4hpH+QM1R77pfD7ktNhLPZjNJ0nK51KNHj/TRRx9puVxqPp+rqiplWaaqqlTXtaqq6vx3bR4gDENNJhOFYej+rYuLC61WK/e1WZYpCALFcXwnl+M27/O6X2M3ot/DgpHeTF5ZQM3JrKHit/ssikJ5nuvly5daLpe6vLzU06dPVRSFnj9/rsvLS11eXmq1WinLMpVlufW9tFnsURRpMploNpvp/v37un//vi4uLvT06VO9evVKP/74o+bzueI4VpIkLvqhYrP7sfu0F6rmNtifYzei79CMvBl789YcQYcI3+6vKAplWabXr1+78B8+fKiyLDWdTvXTTz9J+u1YP45jbTabt47Tm6IoUhiGStNU0+lUH3zwgT7++GM9fvxYT5480SeffKLFYqHnz5/rwYMHunfvniaTieI47n2m4FB2H809kuatGX5d14z61yD6A7SDL8vSjZzN+IfalrIsVRSFNpuN8jxXURTuz+wFKIoiJUmiJEnchJ6Nfu1ttTjiOHYjeJIk7jRd83suy1J5nmuz2SgIAlVVpSiKBh3pm6E3TyXa90fs3Yh+j13BF0Xhbs347eul3554t/lCYP9ec6S36O33q9VKy+VSZVm64/I8zyXJbW/X7r1FP5lM3ChelqWWy6VWq5X7fvM813q9VlVVWyP9sb5n+7WkrdjjOH7r/sIw5PTiHkTfoR28HUfbSGe/thF26N37zWaj9XqtxWKh9XqtsiwVBIHSNNXZ2Znqunan8jabzUHH9GmaumP6+XyuNE0VBIGKonD3JUl5nitN08F378Mw3NobSdNUVVUpTdOtr2P3/npEv0d7hLfQsixzt2ZQxw7foi/LUpvNRlmWabVaabVauZHXjsktYjueL8uyM3obPe24fj6fazabKY5jVVWl9Xqt169fuxeANE3dXMCxA2tO3NkL02Qycd9Tewa/fQUh3iD6PZqR2UifZZmWy6WWy6ULv3k8feztaR/X2wuPjfRJkmg2m7lf23Z3vShZVDYjb+Hb7HxZlu40nb3gxHHsjueHGFVtlJ9MJu77ld5MVjYn+HA9ou+w63jeRnqL3sK3Y+shdvGbE4gWtI3mFm5d125UtAm4Q6KPoshFZLvQtnu/2WwkyT0OzQm1Y7OYkyTZCr65ux9F0WB7XGNG9Hu0o7fALPyrq6utkXaobdo1uWi7uVEUKU1TF/2hZxiaM+M2sWcjeV3Xbm+hKIqdp8mOzb4vm5y07689oUrw3Yh+j2ZgNmJuNhsX/nq91mq1Up7nW8fMxwph14VCzYuFLFab4W5+TfvfMO3j4ebxs4VthxQW/a4LYo75/dqLmW2DHYI05ysY5Q9D9B3agTXDt5n75mx+nze43NY2Sm8Cue68/D67Qm6+sLT/bihx/NvTNYqiresTmocuQ18hOUZEv0f7SdS+Ks+edEOettvnWKPvXY6iNq9go7099s3RneAPQ/TvoP1k2vVku+sn3LF3s+/arsMV+3MchnMbR8KFIf3xGB4HI31Pu56Yx57c6nKsEe+uAtx1aW/XY479GOl72hUZu5q3h8fy9hE9RocXgn6IHvAMx/QDGfvoNNT2c2x+fIz0gGeIHvAM0WN0OAToh+gBzxA94Bmix+iM/UzIXSN6wDNEj9FhIq8fosfosHvfD9EDniF6jA679/0QPUaH3ft+iB7wDNFjdNi974foMTrs3vdD9IBniB7wDNEfoL2E1HWfvQ6MAdF3aK9m07wRP8aq8zPyhlqF9VRYvLYGnC1X1b7ZUlansowV8C46o+/7hG4vVGC/37WAwW3dx66/l272vVRVpTzPtV6v3SKVdrO161gpFWPTGb2tEuqr+XyuFy9e6OrqamtdeluP/pQWrQQO5XfVB1gsFnr58qXbpV8sFlqv19psNsrz3K2eSvgYi87ov//++6G246REUaSqqrRcLvXq1Sstl0t3fL9er7VarZRlmVsjHcPiirx+OqP/6quvhtqOkxCGoeq6VpZlCsNQFxcX+vzzz3V+fq48z7VarbbWRi+Kghn8O8Bj3U9n9N98881Q23GSHj58qKqq9Omnn6ooCq1WK4VhqCiKFATB1s30mTgEhsAxfYerqyv9/PPP7hReVVVK01TT6VRxHCtNU4VhqDiO3dcAp47oG2z33kbpyWSiFy9eKAgCRVGkKIp0dnamoig0nU4lSWmaqqqqt0Z84FRxyq7Bos3zXEEQqKoq/frrr26En0wmLnBJ7oUgDEOFYUj0A+Fx7qezap9npuu61nq91mKxUBAEbrY+iiKlaaokSdzVeb69ON415kv64dnaoaoqZVmmKIqUJInCMNR6vdZsNnPBc3HO8Bjp+yH6DnVdqyxLt7uf5/lb1+Nb8IQ/HB7rfphy7mDvsmuHblfn2dfwJMSYEP0eFv6ut9ISO8aI6A9A3HifED3gGaLH6DB73w/RY3Q43OqH6A/AyIL3CdHvEQSBu8S2/a46XgwwRkTfwYKPokhxHLubXXNvX0P8GBOi72DvrkuSRHEcK0mSt14Adr2nHjhlXIbbIQxDTSYTzWYz9/756XSqNE3diM/76DE2vLW2of3W2ul0qrOzM52dnbm31s5mM02nUzf626foAGPBW2sbmvHWda0wDPXhhx/q/Pzc7dbP53PN53MXvo32hI+x8Gso36N9/jfLMp2fn+vx48fuGnzbxU+SxL3dluiHxWPdD9F3uHfvni4uLvTkyZO3PhizGTpPQoxJZ/RffvnlUNtxEmyJLPsI7EePHumzzz5zH4G9Xq/dqjbXfQS2/bf9QsBVZLeHx7Kfzui//vrrobbjpMRxrLqu3eo2i8XircUubE07+2ANPkFnOOxZ9dMZ/RdffDHUdpysH374Qb/88ov74IyrqytFUaTlcinpzYdoVFV1x1vqD15c++GYfo+zszM9ePBARVEoyzL3EVo28tvpvdtciRc4Jk7Z7WAX3KxWKyVJonv37mmz2SgMQ3dsz3l6jFVn9L49meu63vqe7RJc+6z7siyVpqm7Iq/9RhxgDDqjtzeV+MouyLGJuvYbbjg/jzHiwvEO9i67XbfrFrAETh3RH6AdOLFjzIj+HRA53gdE/w44JYf3AdEDniF6jA6HWf0QPeAZosfoMLfSD9FjdNi974foMTqM9P0QPeAZosfosHvfD9EDniF6jA7H9P0QPeAZogc8Q/SAZ4ge8AzRY3Q4ZdcPH4E9EJ6oOBWM9BgdTtn1Q/QYHfaa+iH6nnY9AXlS3h4ey9vHMX1Pu3Y1bdEMdkP7ue4xPPTPsBsj/ZHwJOyPx/A4GOnfQXtXs/359+yKHk/zMd615gCP/eGIfo920LbqjS1rZUtcxXHs7YKfQ2kvKdZcWowX38MRfYf26NKOPEkSJUmisiwl/bb2XXsRTPRnj2kURW4B0eaqwbZyMOEfhuj3aAcfx7F74k2nUxVFoSAIGOkHYC+0k8lE0+l0awXh9qiP6xH9Hs1FLJvRT6dTVVUlSUqSRHmeq6oqN/nE7H1/zcfQfg4W/Xw+d+EnSeKiZyXh/Yi+Q3OUD8NwZ/BRFGkymagoiq3ocbvs52A/g2b4tqvfXlEYuxH9Hs1d+6qqlCSJptOpJLljzKIoVBSF6rreGpnQX/PxtMOoJElc+DbaNyf4eOy7Ef0eYRhujd42qWS7mtPpVHmeu+AZ6Y+jOVFnI7vFv2sXH9cj+g7N3XuTpqkb+W2Ut916gj+u5s/DJu/iON6ayGP3fj+i32NX+Pbn9qTjWH44zTmW5ilUgj8c0R/AnkTN8IMg2BrhGemPr7mL346f4A9H9B3aF3s0j+ebozvBD6f9M7nuijziv16w58nKM/kv2pN51/0djq/runti37LzwSB64P21M3rObQCeIXrAM0QPeIboAc8QPeAZogc8Q/SAZ4ge8AzRA54hesAzRA94hugBzxA94BmiBzxD9IBniB7wDNEDniF6wDNED3iG6AHPED3gGaIHPEP0gGeIHvAM0QOeIXrAM0QPeIboAc8QPeAZogc8Q/SAZ4ge8AzRA54hesAzRA94hugBzxA94BmiBzxD9IBniB7wDNEDniF6wDNED3iG6AHPED3gGaIHPEP0gGeIHvAM0QOeIXrAM0QPeIboAc/Ee/4+GGQrAAyGkR7wDNEDniF6wDNED3iG6AHPED3gmf8H5Xh9SXsZLCkAAAAASUVORK5CYII=\n", + "application/vnd.jupyter.widget-view+json": { + "model_id": "6e66d8db18754d0fbbe5e390768ff708", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAEgCAYAAADVKCZpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAW3ElEQVR4nO3db4hld33H8c/3nPtvZrPZpJs1dje7biBqEkKoZbEtoQTUtlGkoiBoQQTFfVJBixSNgT4TApY8qVa7YJCWoAgqCjHVCIIUVIyyqGmMBKsmu6IJ2eyfuX/PPd8+2PmdnLl7Z3Y2M/ec85v7fsHgzs5473fu6n3P75zfPdfcXQAAxCapewAAAF4JAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiFKr7gEw30033eTHjx+vewzM4e4ys+Lzfr+vM2fO6MKFCwu5v+uvv1633HKLVlZWFnL72F2/+c1v9MILL9jVvxM7RcAa6vjx43riiSfqHgNzZFkmM1OappKk06dP65Of/KQee+yx4ntarZayLHtFtz/7373nnnv04IMP6u6775YkTadTSSruH81y4sSJukdYGhxCBABEiYABAKJEwIBrVD7/BaA+BAy4Ru5e9wgARMAAAJEiYACAKBEwAECUCBgAIEoEDAAQJQIGAIgSAQMARImAAQCiRMAAAFEiYACAKBEw4BpxLUSgGQhYBczsqJl9z8yeMrMnzewjdc+EV45rIQLNwBtaViOT9DF3/6mZ7Zf0EzN73N3/t+7BACBWrMAq4O6/d/efrv/5oqSnJB2pdyoAiBsBq5iZHZf0Bkk/qnkUAIgaAauQmV0n6auSPuruF+Z8/aSZPWFmTzz//PPVDwgAESFgFTGzti7H6xF3/9q873H3U+5+wt1PHDp0qNoBASAyBKwCdnnf9RckPeXuD9U9DwDsBQSsGvdIep+kN5nZ6fWPt9U9FADEjG30FXD3/5HEq18BYBexAgMARImAAQCiRMAAAFEiYACAKBEwAECUCBgAIEoEDIgQb+kCEDAgSrypJkDAgGtGPIBmIGDANeLwHdAMBAwAECUCBgCIEgEDAESJgAER4jwcQMAAAJEiYECE2MoPEDAAQKQIGAAgSgQMABAlAgYAiBIBAwBEiYABAKJEwIBXYKsXEidJsqNt7ma24b+fpukV980LmQECBuy63Y4LsQLma9U9ABCbJNn4e1+aphqNRsXn7q4sy17x7WdZtiFao9Fow33O3j+wrPh/AgAgSqzA0Hjl1chmf65ylrBCWllZkST1+30dOXJEN9xwg/r9vlZXV5XnuUajkfI8l7srz/MtbzecN0uSRN1uV0mSFLd1+PBhDQaD4ntHo5HMTK1Wq5ZLSpXvc7M/A1UgYGis8OQvvbxxIcSgvJGhqpCF+8yyTJPJROfOnVO/39f58+d1++23K8synT17VufPn9f58+c1GAw0Go00nU43/CyzQrjSNFW329XKyooOHDigAwcO6PDhw7r99tv10ksv6ZlnntHq6qparZba7XYRsKrCEe4n3GeIbnmG8PdAFQgYGqkcrHK4yh/llU0VEQv3l2WZRqORLl68WETs5ptv1nQ6Va/X07PPPivp8rmxVqul8Xh8xXmtsjRNlSSJOp2Oer2errvuOt100006evSobr31Vr3qVa/S2tqazp49qxtvvFH79+9Xt9tVq9Xa8Y7H7Qr3UV4plj/KEXN3VmOoBAFDo83GazqdFiuacsiqmmU6nSrLMo3HY00mE2VZVvxdiGmapmq322q328VmjrAqmZ01PNG3Wq1iZdVut4ut8+WfeTqdajKZaDwey8yU57nSNK10BVaOVnl7f/j5CBeqRMDQWPPilWVZ8VEOWfh+6fKT6G5GLdxeeQUWAhY+HwwG6vf7mk6nxXmsyWQiScW8Wx1CDAHrdrvF6mo6narf72swGBQ/72Qy0XA4VJ7nG1Zgi/qZw58lbQhXq9W64v6SJGHLPypFwNBIs/EK553CCiT8Oax8qj6EOB6PNRwOtba2puFwqOl0KjNTp9PRvn375O7F9vrxeLytc2CdTqc4B7a6uqpOpyMzU5ZlxX1J0mQyUafTqfwQYpIkG1aJnU5HeZ6r0+ls+D4OIaIqBAyNNbvyCtEYjUbFRzkOi45YCNh0OtV4PNZoNNJgMNBgMChWROEcVghSOP81nU63DFhY1YTzYKurq1pZWVGr1VKe5xoOh7p48WIRs06nU5w7W3Qsyps2QmS73W7xM83uRJy9cgiwKAQMjVUORliBjUYj9ft99fv9ImLl80+Lnmf2PFiIaFiBtdttraysFH8Oc28V2BCIsLMwRCzsMpxOp8XW+RDPVqtVnP+qYrUTVl/dbrf4eaWXN6qUN3cAVSFgaKR557/CCiwELEQsnIuq4jBiefNIiFNYZYUIuXuxWgmbL7YTsDRNiyCEw3ThEOJ4PJak4nEob6ZYtBCmdru9IV7lQ4ppmla2EgYCAlYRM3tY0tsl/dHd76p7nhjMBizEIkTs0qVLG1ZAVc00b2NJOJSWpqk6nU4RsO3ulCzv8AubOsIKy92LVVyWZXO3ri9a+LnCxpTw881upiFeqBIBq84XJX1G0n/WPEc0yrEIK5nxeFxEbDgcajAYaDKZbDjHtKgn9Xkvqi6/sDqEJ+zUK3/P7G0Es+ePyuebQqTCYcsQsHkvHl7kzxvCHGYIhznL5/dYfaEOBKwi7v59Mzte9xyxmI1FOWJhB2J5V+JOLp67WzNKLz/Zb/a6r6uZF6VyJGe/VpVW6/JTRZqmG17/Vj48WvWVUQAChsaafUKcvRpHeAKtciv91SxqVVTn6iachwursPDYl1ddxAt1IGANYmYnJZ2UpGPHjtU8TbPMPjHOe+Ks+8lz0Yfy6jbvkGj4e6AO7HltEHc/5e4n3P3EoUOH6h4nWryIdud4DBEDVmCI1rwn2UVvbNjKolYidcVk3uWptnrMgaqxAquImX1J0g8kvd7MnjOzD9Y9U+zmBYPDWbuHxxJNxwqsIu7+3rpnAHaKqKFJWIEBAKLECgx7Xuyrhqrm51wWYsMKDAAQJQIGAIgSAQOwbRxmRJMQMABAlAgYACBKBAzAtsW+oxN7CwEDAESJgAHYNjZxoEkIGIBt4xAimoSAAQCiRMAAbBuHENEkBAzAtnEIEU1CwAAAUSJgALaNQ4hoEgIGYNs4hIgmIWAAgCgRMABAlAgYGs3dN/0AsNwIGBrJ3ZXn+dwPQgZAklp1D4DNTafTukeoTAhRklz+nWo6nSrLsis+ptOpptNpETIAy4uANdROVxdmtuG/Hz6f/fuduNpthS3Xr+T+8jzXZDLRcDjUZDLReDwuPrIsu2I1BmD5ELCGMjO1Wsv7z7O6uqoXX3xRly5dKgI2HA41Go02RIx4ActreZ8h0Xhra2s6d+5ccdhwbW1Nw+FQ4/FYk8lEeZ5rOp0SMWBJEbCGGgwG+vnPf173GJVL01R5nqvf7+ull15Sv98vzocNh0MNBgONRiNNJhNlWVb3uEuHK3GgSQhYQ505c0b3339/3WNUJkkSubtGo5GSJNHhw4d1xx136ODBg5pMJhoMBsXmjRA0diJWj8caTULAGur8+fN69NFH6x6jNjfffLPyPNdtt92mLMs0GAyUJInSNJWZbfgIdrJpBEB8CBga6dKlSzpz5kyxrT7Pc3U6HfV6PbVaLXU6HSVJolarVXwPgOVCwNAI4RBiWD11u129+OKLMjOlaao0TbVv3z5lWaZerydJ6nQ6yvP8ipUYgOVAwBpsmbbRhwBNJhOZmfI814ULF4qVV7fbLWIlqYhakiRKkoSAVYTHGU2yPM+QEVrWXXburuFwqLW1NZlZseswTVN1Oh212+3iqhzLFPkm4PwimoT/96OR8jzXaDRSmqZqt9tKkkTD4VArKytFvHghc/VYgaFJCBgayd01nU6LQ4qTyeSK6yOGeBGx6vBYo0nYvlURM7vPzJ42s2fM7BN1z9N04Wr0s9EKV+UI38MTKrC8CJgkM/uWmR1f4O2nkj4r6a2S7pT0XjO7c1H3t1eEiM17+xTCBYCAXfZFSd8xswfMrL2A23+jpGfc/dfuPpb0ZUnvWMD97DmECsBmOAcmyd2/YmaPSvoXSU+Y2X9Jyktff2iHd3FE0rOlz5+T9Bc7vE0AWGoE7GUTSWuSupL2qxSwXTBv69YVSwszOynp5C7eL7Cr2IWIJiFgurzBQtJDkr4p6c/dvb/Ld/GcpKOlz2+RdHb2m9z9lKRT6zNx7AyNwyFdNAkBu+wBSe929ycXdPs/lvRaM7tV0hlJ75H0Dwu6rz2F3/gBbIaASXL3v17w7Wdm9mFJ35aUSnp4gbHcM8ysuEzU7NXnCRsAAlYRd/+WpG/VPUcsQrzSNFWr1So+wjUQw/cQMmB5sY0ejRSuQt9ut9VqtdRut6+I2bz3BAOwPFiBoZGSJFG329XKykrx/l+9Xk+dTqdYifE+YMByI2ANtkxXWp99O5Ver6d9+/Zp3759xduprKysqNfrFauy8O7MAJbT8jxDRmiZ3k6lHCJ3V5Ikuv7663Xw4MHi0OHq6qpWV1eLiIVVGBEDlhMBQyPMvr5oNBrp4MGDOnr0aHFNxHAYsd1uF2+xQsCqxWONJiFgaKT9+/fr8OHDuvXWW5VlmQaDQbErsRwtnlCB5UXAGurAgQO699576x6jMmYmd9doNFKSJDpy5Ihe97rX6eDBg5pMJhoOh8qybMNbrGx2hfrZqHH1iN3DY4kmIWANdeTIEX3qU5+qe4zKtVotubvW1tZ07tw5ra2tFcEaDocaDAYaj8caj8fFm1zyzszVYcWLJiFgDbWysqK77rqr7jFq9fTTT+sPf/hD8SaWly5dUpqm6vcvX6oyrL7yfDevu4yt8IsCmoSAobH27dunG2+8UVmWaTQayd2LmGVZVmy5D4cfASwXAtZQ7r5U2+iD8OLkwWCgdrut/fv3azweK0mS4lwYrwMDIBGwxlq2SyS5+4afN1xGKs9zmZmm06k6nU5xJY7Zi/wCWD4ErMHCRWuXUXjxctikMXsxX17/BYCLyaGRwtXo533Me3sVAMuHgKHRZmNFuAAEBAxRIFgAZhEwRIFt8gBmETAAQJQIGIBt41AumoSAAQCiRMAAbBvnItEkBAzAtnEIEU1CwABsGyswNAkBAwBEiYAB2DYOIaJJCBgAIEoEDMC2cQ4MTULAAABRImAAgCgRMABAlAgYACBKBAzAtrGNHk3SqnsAYNF40gX2JlZgALaNbfRoEgIGYNtYzaJJCNiCmdm7zexJM8vN7ETd8+wl855MeYLdPTyWaDrOgS3eLyS9S9J/1D3IXjPvcJa7y8w41LVDmz2G2/07oAoEbMHc/SmJ32arxBPqzvEYIgYEDFGY/QXAzIqPeV/H7ik/xuXHfPbrQNUI2C4ws+9KevWcLz3g7t+4hts5KemkJB07dmyXpovXbJzMTEmSKE3T4j/TNFWr1VKWZXWOuue1Wq3i8S7/G/CLBOpEwHaBu79ll27nlKRTknTixImlPoYz+1v/bLDa7bba7bam06kkKU3T4vwXdk94TNM0VafTUafTUbvd3hA0Ioa6EDA01my8Wq1W8STa6/WUZZnMjBVYBcIvDd1uV71er/h3CCErr8aAqhCwBTOzd0r6N0mHJD1qZqfd/e9qHisKIV6zAev1esrzXJLUbrc1mUyU53mx8YBdiDtXfgzDv0MI2OrqahGxdrtdBCxEDKgKAVswd/+6pK/XPUdsyquvJEnmxitNU3W7XWVZtiFg2F3h3yH8G5QjFg4nlgNGxFAVAobGKh8+zPNc7XZbvV5PkopzMlmWKcsyufuGFQN2rvx4hkO17Xa7iFhYhZU3d/DYo0oEDI2VJMmGVVXYUBAOZ/V6PU0mkyJerMAWo7xJI6y4QsjmHUYEqkLA0EjlQ4hBp9MpVmRh9RUOHRKvxSr/e4SNG61Wa8MmDg4homoEDI01L2Lh78MTKOe+qlM+J1l+WQPxQl0IGBotPCGWI2ZmG1ZerMAWr3wYcTZkxAt1IWBopNkXxpbPf5VXXcSrOrP/JptdiYOQoSoEDI0VVl2zGznKiFe1troOIuFC1QgYGo8nSQDzsOcVABAlAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiBIBAwBEiYABAKJEwAAAUSJgAIAoETAAQJQIGAAgSgQMABAlAgYAiBIBWzAz+7SZ/dLMfmZmXzezG+qeCQD2AgK2eI9Lusvd75b0K0n31zwPAOwJBGzB3P077p6tf/pDSbfUOQ8A7BUErFofkPRY3UMAwF7QqnuAvcDMvivp1XO+9IC7f2P9ex6QlEl6ZIvbOSnppCQdO3ZsAZMCwN5BwHaBu79lq6+b2fslvV3Sm93dt7idU5JOSdKJEyc2/T4AAAFbODO7T9LHJd3r7v265wGAvYJzYIv3GUn7JT1uZqfN7PN1DwQAewErsAVz99vqngEA9iJWYACAKBEwAECUCBgAIEoEDAAQJQIGAIgSAQMARImAAQCiRMAAAFEiYACAKBEwAECUCBgAIEoEDAAQJQIGAIgSAQMARImAAQCiRMAAAFEiYACAKJm71z0D5jCz5yX9tsYRbpL0Qo33f61imjemWaW45m3CrK9x90M1z7AUCBjmMrMn3P1E3XNsV0zzxjSrFNe8Mc2KneMQIgAgSgQMABAlAobNnKp7gGsU07wxzSrFNW9Ms2KHOAcGAIgSKzAAQJQIGDZlZp82s1+a2c/M7OtmdkPdM23FzN5tZk+aWW5mjdyJZmb3mdnTZvaMmX2i7nm2YmYPm9kfzewXdc9yNWZ21My+Z2ZPrf9v4CN1z4TFI2DYyuOS7nL3uyX9StL9Nc9zNb+Q9C5J3697kHnMLJX0WUlvlXSnpPea2Z31TrWlL0q6r+4htimT9DF3v0PSX0r6x4Y/ttgFBAybcvfvuHu2/ukPJd1S5zxX4+5PufvTdc+xhTdKesbdf+3uY0lflvSOmmfalLt/X9KLdc+xHe7+e3f/6fqfL0p6StKReqfCohEwbNcHJD1W9xCROyLp2dLnz4kn2V1nZsclvUHSj2oeBQvWqnsA1MvMvivp1XO+9IC7f2P9ex7Q5UM0j1Q52zzbmbfBbM7fsQ14F5nZdZK+Kumj7n6h7nmwWARsybn7W7b6upm9X9LbJb3ZG/Cai6vN23DPSTpa+vwWSWdrmmXPMbO2LsfrEXf/Wt3zYPE4hIhNmdl9kj4u6e/dvV/3PHvAjyW91sxuNbOOpPdI+mbNM+0JZmaSviDpKXd/qO55UA0Chq18RtJ+SY+b2Wkz+3zdA23FzN5pZs9J+itJj5rZt+ueqWx9Q8yHJX1blzcZfMXdn6x3qs2Z2Zck/UDS683sOTP7YN0zbeEeSe+T9Kb1/62eNrO31T0UFosrcQAAosQKDAAQJQIGAIgSAQMARImAAQCiRMAAAFEiYEAF1q+W/n9m9ifrn9+4/vlr6p4NiBUBAyrg7s9K+pykB9f/6kFJp9z9t/VNBcSN14EBFVm/1NFPJD0s6UOS3rB+VXoArwDXQgQq4u4TM/tnSf8t6W+JF7AzHEIEqvVWSb+XdFfdgwCxI2BARczszyT9jS6/Y/A/mdmf1jsREDcCBlRg/Wrpn9Pl96n6naRPS/rXeqcC4kbAgGp8SNLv3P3x9c//XdLtZnZvjTMBUWMXIgAgSqzAAABRImAAgCgRMABAlAgYACBKBAwAECUCBgCI0v8D3kR06PALQFwAAAAASUVORK5CYII=", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ + "Starting adjoint run...\n", + "Calculating gradient...\n", "Current iteration: 2\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 3\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 4\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 5\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 6\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 7\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 8\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP0AAADnCAYAAADVeFABAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkiElEQVR4nO2dzY4b6XmFX/41yW7N2KMBxrIGAQaBM3IAI7eQRZBFtPAm1xBkl01WcwEGss0tZJldFr6CbLOY2MAg3ns8BoLRGJLIbv5noZzqU6ffr6rIbrXUqvMABCk2WVUs1fne3++rweFwCGNMfxi+6wMwxtwvFr0xPcOiN6ZnWPTG9AyL3pie0Sb6gx/v52O73R52u13176+//vrw/Pnzw2AwqB6TyaT272Me+t3nz58ffvOb31T72+12tf378V4+UmzpjekZFr0xPcOiN6ZnWPTG9AyL/oEyGAze9SGYB4pF/0DxnAlzKha9MT3DojemZ1j0xvQMi96YnmHRG9MzLHpjeoZFb0zPsOiN6RkWvTE9w6I3pmdY9A8U996bU7HoHyjuvTenYtEb0zMsemPukP/4+tt4/q//Gf/wb/8VLxbrd304KeN3fQDGfCj876tV/PO//3ds94f45ruX8enF/8S//P1fvevDuoEtvTF3xNVmF9v9da7l1dX2HR5NGYvemDvizx6fxz/+9Z/HYBDx5ONZ/NPf/MW7PqQUu/fG3CFf/d1fxj//7bM4G7+/9vT9PTJjHijvs+AjLHpjeodFb0zPsOiN6RkWvTE9w6I3pmdY9Mb0DIvemJ5h0ZuT8fTeh4lFb07GC3k8TCz6B4oFZ07Fon+g2LU2p2LRG9MzLHpjeoZFb0zPsOjNyTiv8DCx6I3pGRa9ORmXDR8mFr0xPcOiN6ZnWPTG9AyL3pieYdEb0zMsemN6hkX/gGlqjhkOh7cqqQ0Gg9r3R6PRjX27OedhYtF/oNy1IC3wDwff1uqBMhzWx+vRaBSr1ar69+FwiM1mc/L29bvr9bq2T92/eTj4f86YnmFL3xF2b0uv7/NYtttt7Pf7OD8/j4iI5XIZT58+jR//+MexXC7j/Pw89vt9rNfr2O/3nWJwxPHD4TDOzs5iOBxW23ry5Eksl8vqs1dXVzEcDmM8Hr+TdlzeZ+m1ybHoW4BgIq6TVywi/tt9gP1vt9vYbDbxww8/xGKxiB9++CGePXsWm80mvvvuu3j58mW8fPkyLi8vY7PZxHa7rR1vJo7BYBDj8Tgmk0lcXFzEo0eP4kc/+lE8efIkvvzyy3jx4kX87ne/i4uLixiPx3F2dhbj8fjWScNj4AQjBii8p++bHIu+ARY2C54feA+fv49j2u12sd1u4+rqKl69ehUvXryIxWIRn332Wfz85z+P+Xwev//972MwGMRkMomrq6tYr9fVbygJdDQaxWQyiel0GhcXF/Hpp5/G559/Hl988UV89tln8fr16/jDH/4Qn3zySXz00Uex2+1iMpnEcDi8IbKmQaCLx9H0N/ZI+MHCb/qdfcei74AKfrfbxW63uyH++zoOiH69XldWHI/9fl9Z7LOzs8rCdxHDcDisRA8rPhgMqv3Bu1iv11Vib7/fx2g0qkT/NoWmgh+NRrXzfh/H8CFg0beggsfFDyGw+PH5Y2i7QHV72Ndms4nVahVXV1ex2+1is9nEcrmMxWIRm80mRqNRTKfTSpTT6bTm2pfc++FwGNPpNGazWYzH49jtdrFYLGK5XMbHH38c2+02VqtVjEajytJD9OxeZ7/vtgMjjns0GlWP8bh+CQ+HQ5cXW7DoG8gED0u32WyqByzs27zYsG14GhDf5eVlLBaLKnaPiJhMJjGfzyMiatY+4qa15OOGoOAlzOfzKqG33W5juVzGZDKpEoTT6fSG6LP4Wn9DF9gz4fdY7JPJJM7Ozm5s15a+GYu+BXbp4VJfXV1VVhauLlv7U8gu1KxKgGPBwHN1dRXL5TKWy2XsdrsYjUYxm81iv9/HeDyO+Xweu90uIqISJ4uUcxIAwjo7O6ssPkQ/GAxivV7HcrmM6XRa5QE0rr6tq52JHseOQQmejO4Hv8viz7HoW4AoVPSXl5exXC4r4cPa34aSVeQKAY4FHsZqtaoGIFj68Xgcs9ksJpNJTfAQO0TK+9OyHoTLcf3V1VUcDodYrVZxdnYWk8kkxuNxtd2mxNoxv73pMxA8BraI68FABxyTY9E3kCXwEEsjfr68vIzVahWbzeaGq4xttNGW6c5Ej0GIE2sscLi9cIkhdhVqRFTi4fwEtoXtwaXfbrfV9/XBXgREf6rFR+jBwMpPp9PqWPl34Tg9L6AZi74FFRon0CB8iH673b7140D2HjkGzqxzph4WGgJFNp7jcJ5Eo4MJtr3b7WoDX0TEarW6UTJrE76KvmtzDQsYAsfvRBMRDwL3VUl5yFj0LXCNnoW/Xq8r8cPFv80F1xTTa1MQBJo9I1vPSTkkvPiBwQD75RCGk5TwIDDIcJmSRc3C5wGAxa+/U98rnQMWPQZWDGQcWtnKd8OibyATHQufhaHJvMw9LVGKQfn72hikFpgHHCTx2LWH+PnBLj5ae9n1R0KMt7vZbKpBgI8fD3wfnXoYWNjNz8ReyvZndXgkD3UQsti7YdG3oMLPxAcLmbXlduk+4/gZQuP9l7oBWfz4bCnrnXWxqbjZknK7L2+TPR4tA47H49pxYhAolfN0IGiz9DhG9nhK7dAeAMpY9EdSyqrjGcLTiy67CPlzmVj5glYXP3vo/krf4f1jIMD7SIZlmfiISAeerA0XbLfbYh2fvSI9L/obSufD4j4ei/5ISp1sTX9vep//pq5tqQLAYuZ/4/VwOKxq9mwVNeblfXCzTlvZjUOdiKieIWQWc0mcp5wn/bvr8Kdh0d8harm7uPb8fOy2ShYPyTx2/zOPQY8jIoquuO6Pt4sQhUWPAaRk0dXDaTtHer6azp1pxqJ/S9yF29lm6fm1uu1ZGMJkU1KzfeP7WingsAFewm63q8Sedcrh3yXvIiOL1zMs/u5Y9HfI24gvS/FsFtuXjkMtd8maQ8D8b82O8wxDduvxrIm8zLPQhp0m4Z96Tj0IlLHo3zF6cWqXXES97z7L5rOoVFCcRGtrlS2JXSsVbPX1d+gghYEhc/c1rCgl9rIcQdfzaW5i0d8BamVPvfCaesZZTJn4sV+2mFnHHNfNNTPP+2KXHg072qkHEWvCThOFLPJSOIHj5c+XzoFioR+HRf+O6HKhNpXs1O3mxJjW5NEsgwf333NcjX1qExK3+fI6AjzA6Tx2HQDY3WfPgnsU9Ph5Wxb23WHRvyewlVdLxyLP2m41Ez4Y3FxogsXOE2aaynEQN3cfoiMPTTxacwfZdpHhZ1cfCUA9DxB6NpDgtTkNi/4d0LXcVLLymkVngbD1RruqPlj4+B5vF514KvZsWa5jYfFjuSs+Bmw3K1Nq/sKchkV/jxzTWKI18ZKVhxB4vTgWfdZzD+Fr0pD3p1N3Wfjs2ut+S4lBPQ9ZVj/CN9G4Dyz6O6aLFS9l7BUWRWbtWXyokUN0Gsdn7j3H4Vxu09l2vCgm9ovjxvdLrbSl34WQQKf3avlQv2f3/vZY9HfAMV1lSqk8pW49W3nOnnNzDOB57XDxMZ2Wk3i8H7zORM+xPJfqdIDjBGKG5h40fGnrQsyqA+Z4LPo7BBdqU1mKaetC0/KczqzLataZa68Wn2v3uj0dWDRzr1l73m/2zL+JX7d5Ak3nhT/TVrc3N7Hoj6B0oUdElYVuE3tTzKoNOU1i51ZXPh6tzWeCh+g1GZfF87zMtyYOsc/swWjdvgtdhG9Ow1mTt0B2YTdNP43I3XpOrHG9W//O+80Ws8gEr264dt6xZWeXXpN2/NtKjT7ZM2+jyTPKehHM7bClvweOte7a/orPlQSg4mGx47V24zE8uGTufFs/AB+DbldfZ94SDx7m7WPR3zNZjVkTaVl5rsm6czOOil2XqNZ18bI4Xi28ruzD++NtaqjAz4yKPCtldrXqWYnQNGPRvwU0dm3qJddHNnU1s7TabssWPWu15fXwsO/MpeesPZfneL/syuuqOPy79Pdztx1vE3/jppwse2/uBov+FmQXdlOySjPOWZzOQuTbZWVZeggQAkdpLsvYqxXOXHq9TRffDgtoklAn8vC5yM5RyYVXi82lSE44lpKGtvLdseiPILM8WkbKMtWlMpO2lbJF17o8b5uFA+FB6BC93tSiLUuPrju+E67uU3MGLPbSoMLnjGf/NcX4aumzBTQt+NOx6I8ku6BLNePS3yG6iEhdeBU/b1cz5rgjLe40i3XtudWWRc8hhN4hh4XP7bbYH/aP5bPxzCveZmEKHzd+s06sKVl6kH0my/x7AGjHor8lWd28JHy17ixqfT9L3sHKwu1llx7C15tZsNvNHgTuy4cH7omXCT7LHbCHkeUKOAGJbRwOhxiPx7XfyG24jAof++fnbBDAa1PGou+AilgFXHJn8Xmdq67JOs6QawyfJe8geL57Kz90Ug0ExAMNLDru0MOiRxIPosM94LmtVwcV3b6WHDFgYZXezFtqEquK3+W907HoW1BLnr3OLnL9fpaZV4uoWXqgFp7jd3bt2dojeacuN6w83+2WH3wbq4h6HK75A03eaUIy2w4fD84Pn6esZJdVDfjfWVOQKWPRN6DZ9GziS0mwav2zmjgn1DJXPqIuFhY8xK2C1+47HAsft95u+/LysrL2cO85nFC3HrF8qUSnvwvvqUeg56fN0pce5jgaRa9LGX3oaNKKu9M44cU96aUmGmwvi+F5ANGYXt15HA+79BA8i13jeU6UYR/4LavVqhI8xI/722vyDg8tBUL0mrDTgZK3xa69npfB4Hp6MH4/PzMlwXsA6Eaj6NXNPBZtsHgbjRdt28rcxa7s929u2Ai3NytrZcJVi6/eQGnJq8yljYialYWwVfCI5Vnw+A2cvINLD9HD0vPttg+HQ+Uy63617g/DkOUkMOBwiS7Lj3AIwOGRJghLOIl3HI2iRwKnr1xcXMT3338fr169qsQPq8jC1+RcRJ7wayrFMVnCTrP0auGzOJtDiM1mU8Xxl5eX1QPWfrVa1ZpxUJrT21zroAJrz5SSmko2MLJ4sV1O/LVxV8bkQ6bfqu7AYrGIFy9eVK7xYrGohKJTT7NMfpYIVIvOr1nwvLxVU9KudL95DETwTlTwPICt1+taPoH3y/V/iJ4HrmzWnlKyxNiOfp/PA7wFPce8DYu9O42i/+1vf3tfx/FegfvALZfLePHiRSwWiyquZ+vImW4uy5WSeKDNHdUeerbq6tZr513EtUu/2+0qtx3ZebbwHLKwi82exWw2q/bJCTwk3nAr62y5LM24l7oDgeaQ8B29Eaee32xbpkyj6L/66qv7Oo73Aliw1WoVw+Ewnj59Gs+ePYvHjx9XsTCSXbwUdKk/nuPVzKIzbOV10kwWv6tLzzecwHHBurPYYd3h0nNZDYJGDD+bzWI+n1f75IoAvpcto82ChydQmtqr4ZBug8MNTRBm035NO42i//Wvf31fx/Fe8pOf/CS222387Gc/i81mE8vlMiKi1kWmwtYLl60viwF/589x8mw0GtViaS7RQZTq0jfF70jYIWkHCw93nvcN74Kt/NnZWa0RJ6Lejw8yVx+ihxeBf/M5zCw3zgm8iWw+ApMlC81NHNM38Pr16/j2229jPB5XgoIg2NXleBPWDSLPBKJWvakezok0XuCSu+0ioha/w7ovl8sqB8GCzyw8tlVKGOL34rdlS4OphVcXH9vgSTpZGITvokefzxHnULI8iQXfjkVPsIscETGdTuNPf/pTbfro+fl5daGx9cPAgMFB14PHsy5ooVZQu964pTaL3yOuBa81eIh+sVjUGnAQkuA3syg5h8Bhhd4YoxSX82DGv1ktPX9Xa/u8La3zlxb6sIvfHZfsCFzIm82msjSvXr2KiKisH9eu1XJFRM3aszhY6LzKjU5T1XnwuhIOCyriOrbmGB6if/36dSV6xPGoQkREzeLyUtmaO+Als9nCZ3E4hM1hA/9uFTxvS8ueOnhA+Lycl1r7ruXCPtOoalwcfeRwOFQu8nA4rOLf6XRaXWycdMPFyUkmoNZdO9v039lClpr5ZncYrbUQPISOh1YbMDBx/K2VAp2Xz40zum8WaZOVz/IPfM4yweIzGIS5S1K7Ii32bvTLlB/J4XCoxHQ4vLl1FJe3NMsecfMCZmvHllvvK8dz01koOsmEQwieE8/NQ+zWI57nKbOaU8iacHROPp8TTaax6DMrrwnHiKgNnLzdTLg45kzwWj2x8Nux6Bs4HA6VqGBpcEHxNFOe1aZ1eS3DqeA5MZctU83ZcRY89gO3XifQcGkO9XiuMvAxZS495snr1NxSG3FE1DwRrkKol6IeA9x2Pu945kQpu/Z6my3H9d2x6BtQkWmsyS5xSfQa02Y3ktQVaLL54prs4skz2nijgmdryBUCXlMvq/3zLL1MdOxWazdh5rVgWzxXXwc2nF8WPg8qLPjszju29O1Y9C2UMtMqGlhGvfBUBJqJzxak0NVkMuuuc+JZ8HifBRERteNgsWdTc9XCayjB8w7Y++E4Plu9BwKGhefzqtUT/v343Sjb6V10s4SeybHoj6DUNcfucEQ9q62WnoWeufSarFO3Ghd8qdOOBc/z4vmYuSQ3n89rDTj8OyBQ7vDj1l0eUFi4+tt4AOH6O46Je+/xtyxG514Eje+dyOuORd+Cup3shmuPvNbOOTuupbqS4EEpYZeJvTQfICJuHAPi9/l8HhcXFzGfz6tWW7bK2DeEpuvp4XjUo8lKjTyIIMTgLkAcG5KlGEjYxccDIsfAo3G9hd+ORX8kWezKD45HtSONP6ctrJxk0/5ytrKI1dF8w9l5TK7JOu04nzCbzeLi4iLOz89rk2kmk0lN8CoyFjwSg5xs00FNz0nWkcjnCM8RUbXe4lxiph3OR1u93pSx6I8ku6hY2GytSxe1lqnwWa5b4wFrxpNnYNV1qStd9SbL0qOfHhYe02Z1YQwIn/evi4fw4IZ96iCo50PRkAmoxcfxoHSXxfR8Pk0Zi/4I2rq+2HKXrBnH6dimlqu4Ds6CR/MNu/eaoYd4eJDhvAOLXjvu2MtgDyNbLUhn5pX6CvR3lRKd+n6peaepFde1+m5Y9B3RCzgi0lIR3NgMFjpvkxNVfGFnVl6XrMaMuayXXsuKpeW1MsHzvtmqcnKQzw17O/q7tNxYWl9AJyvxPvg77N5rnd60Y9E3gAsv6yhjd5IvOhV8NgigvZkHChU8J+54jXoInUWpJbPBYFDrBeAVdniaLGJ4FjyX5NilR65ALTS79tkghn+z98CWmbeFJB9e8znkcII9IR1EbOXbsegbgHg4G61NJpxQwvuckCpZ82zQYHcVlpUTaCxG7BcXOUSnU3J5Hr621nISkQUP70Ez5CxSnQijnlAWj2dizc65bosfKnR9Nu1Y9A0Mh8PayrNZCQrCZNdU21GzeruKPMtK89Lb3HaqN5eE2HnV2uxWV+j847o5HwsvvsGZel0wkwVfit3xWoWKfalFxnbUwmudHrV8Z+pPx1NrCVy86LWfTqdxfn4ejx49ivF4XCW/kOnm7ji42aUJMpogY4FzrRnv87JcaiE1Q58tntkk+Ii6y5xl6eFZZA04eM3hBG8TaNtwlqwDKt6sRm+R3w2eWkuoxRoOh/Ho0aN4/PhxFQPP5/OqEYctZMS1JWLXngWvFrzUQ84DQGbV2KXOMvPZLa4wUGGw6iJ4Ls2xuJuy8/xaHzwggKwhiYWd/XY8l0qhpUSqeUO/THkLakVWq1U8fvw4Pv/884h4cwGifRVe0G73ZsVZiLpk5TVOV8Gr6JvKW7wKDTfccEttFsPzb8TxlurwWS2eS3PaRaglSM558IAAeADS/wNNznEvQ0TUvKmmMqHJsegbePToUTx9+jS++OKLas17nRjDF7sm8LTmriJT0TdZRMTtEfXbXHHDDQTPDTelyTPZBJrSRBoebLI5AjgH2kXIVp5/B58nRl1/HYS1NNg0FdniL9Mo+l/+8pf3dRzvBRDGer2OwWAQP/3pT+PLL7+MTz75pCqZZa2fHPPydtTKsyvNWXj0sKuF09o3i68pYZf1vWu1gXvpm7L0meA1mYntw3vg3IV6KuyKZ+VNLWEizMI2sjUJtDHINNMo+l/96lf3dRzvFbCor169iu+//z5ev35diRP97jy5RRNseGY3l2N5dvPZ8mo2m5/ZumWr5OrKO4CtcBa/6+25MoGW5g3wPiB4DVHYNWcLD0FzEpAz/fx3Phc6yUmFbyvfTqPof/GLX9zXcby3fPPNN/HHP/6xEu1kMomI65g4ImrurNaUVfTZI4vd1SLq/PRsNhsveqG1co7hs4SdluUgHLXwus5d1q/AZUkOe1TAup0sq4/P8sxGHews+uNwTN/A4XCosvdYgw6JO4gmIm5Yt6wmX2odxX4yl55X21G3lhN02SQeiE0Fr51+OB6gpTg+Fk1SNpUhS/F4RDn7XyrNwTvgiUMqfCf0uuOSXQIussvLy5hMJvHRRx9Vcf7V1dWNm11E1G8JrSUxbcQp9Z5n1pXd9mxhCm4K4n1yXkEtMYufBx9uvGGhlQaWroJnQWYtzWrx9bsohaqVx2te48CCb6dR9H07eRxjRlx35KGnfrvd3piZxjFqSfBZgk5ry3ifBZYtja0NMZxI1G5APSZt/tHBR2ve2TE2CT5rhdUFR3RJMM1l4Hdk54PXBNAeBB2YTJlG0etabX2Dret+v7/hWjeVr0ruLVvzrOEkS5zhYtf9sEXH+nEqUK6Ta6yN/WdtteyK6+8qCT4LE9hLgfg5RIi4XjCj6XxhAC4lMLVkZ8o4pm9Ay1XZI2sUgRgz8bAV5n9zZluz5DpBhpN0bN1LJbAsd4B9ZseZxdvYl4YKmeA58QdRqjgjrm9kwf0OOIbdblcrv7UtKGrRd8eib4EvJLXCsGZ4Dx15EVG7aGHV2Gry30oP7ENDCLa22EZEvaW16++JiBuiAVozb7PwPEhy4rHUN4CQSQcuPQ72GHgAaRK8hV/Gou9AZgmzjjDU9/F5WPyIspUFGqtnF7B2tzEseN0Gx+Y8kPCAlQlee+e1ZTiz8Cx4bgNWb4VDE63lc8yvx8rn3Bb+NCz6I1CLz5YfcX/EtTiRWW9qKe1inUrlLG0Bjqi75xwe6ADQthIv1/iRM+BEoGbpWfA8CUiTnuz1bDabGI3erIUHF5/PGc6JWnotzVnsx2HRH4EKR+N7nnKrfedZt13EzVgfaCsqVwWyyTh8fCx2ThhmjT0aZ+sxc5mRew7aBJ8l23gfEP/hcL3sNQ8+GuM3uf/mOCz6FjIrrPE9nvVCLYmTt5NdvNqdxkLjMmDWxRcRN8SuA5WKHn/X48Q+tL1WBxp4DtkiHrpSD7vz+F18/jTBWfo/4PNT6uQzORb9kai1wQXPnW0QPChZ5Qy9cLnspha31MmXiV3bdrMZeDrQqHXPcgps5dmlZ8HzfvB9btbBfrThCGFLW64hE74HgDIW/RFkCTIWG8TPFyt3yEU0X4wquiyW5/c5iVYSu/bNZ+VGPYZSXV+bbzibzpOAsptzZklJzY3gOPF3nD+gYi95PRZ8Mxb9LeALmS9arY1HXLvKJfGfcsGyYDPxsDtf6i3g/fNgwmLK3G4e6DRk0Bl/mjPg85W9xoCg/QXaCaiz+UphlKlj0R9BloHnC5pdU8A1+axNlbdbumDVq9Dv6aDDLjcPAFqLP9ad59/LIUNWi8/KaU15DWTpcb64eoBzl81WbFppyORY9HcAWyi2hICtm66KUxI8Wzz8nZNubAm5Bg8x8iBQiotZ/NxtBwFpW21WveCBhj2NrBrRltTk86WeB58DXdKrFH6YHIu+ha4XUVZK0hwA3PvSRc/uf0S9nIckGBJe2SDBZTpthsFvyWr7XCFgV1l/G8/F0P2wVdccBO8/y03oYMCf4VmAyPRnawva0nfHou8IX0ilLHwmevYA2Npng4Amuw6HQ+37WWlL98UWmOE6v1pjtfRZWQ65Ch4AsoFOvYRMzDq48DN/n2P3w+FQDTBNrr1px6K/A/jCZ6uswouoZ6Wz+rMCl1atY6kdtzTTDq9Lsb2KDnB4waLXfAb2A1Hi8/g+hyNswbPGn2wlHhwTi57/ljVBmRyL/g7ROJstfETdTW7KimdofN8lPtZMvFr4zNrz9uGVtNXNuSTJ28I+dYBRrwIPvoMPv+bBiMMc3g+2zcdgciz6O0CFgPdUwCyg/X5fnFOfeQDqIrMLXoqJdbucIyi551nYkIk94tpriYiadYfYs/IgHz+Ezivx6n3nIXrsA808dudPx6K/JSpWzdpnwteEV7YdJuvw4zZfbFPr1fwddrPxWXXTm8IM3jeDBTCQa8DkGfYSeB9snVX0uAlIFrNn5yz7P9D3zE0s+hPQi6wUm2vZDXDJrJQUbKr/szudbSeLz3VhDy6vwZKXQgvebkl0OA6ePJP1B7Cl5zX7+K4/fA89eDRcOSjlFbL/A3MTi/5EMsFnF1wmfIiG3WP+fGmbEA0Li2NvTcjBmur2sxCDB5VsENFSG46fj5kTmINBfcWfzNJD3Cr40pp7LHTtDcj6EUyORf8WyC48vmBZGKW4tHTxchIuGzS0xq2WmcWuiUGO+fl9ts78Pm+v5EFgP5xs40Qer8zLgtfBCtvmrj+dJXhMmNJnLPqOdL2Qmqx9KQzIhA+Xm0t7XVGxcuYd4sZCmpp8y7Lw/LqUL2D3fb/f125znjXocJaenzPBa2sxL86Rrcpj0Tdj0d8jKmJ9DVTw2eeasv0la8duufa3c1yeVQXY1VaXG/kCbuDBtjQJB9e+1ENfEnw2X5+X47J73x2LvoVTrGzb9kqxc2k7pc9pLwCHD5xUy7aJz2h/fSmWz/afVSz0N3Dyjkt12nHH7bZArTvfpFMFrwlDi7+MRd9Cm4gzN7rp+03b04tek2uMZvo5Icf1/6bGlezYNFbXz3FOIcucZ96Gegy6om7W+pu587g7L8Tv+9idhkV/Iipy/TdbzVNbRDXrn13QvLBkxPWtyLAvLOzBdX091lLczn+LqM/Z12MrTanlc6Ett6Umm9KaeyXRq4W38Jux6FtoyqIfe4G1fVbdZL2Qs0QVrDtPytlsNtVrNM9w/K4TXbJsvwpRcws8APCiGXiPv4PvaZNR9tsRlmQWfjab1YRvS38aFn0H1GXlC57rxBH15Bz+raWx0nTTTGgqeM2UYxtsQSEueABwp3kQ4O+pB6BzAjRnwKLUu82w28/bgweivQHYBw8MfHdeFvx8Po/5fB6z2ayy/pnoLfxmLPoGNF5lgfOFjwuaY+mMUiigr3WQUdFlJT9uyMHNKTlu5i43lMg4g49tYqBQ0evdZdjSsvh4ll+Wrefzp4nGiKhl6eHGQ/Sz2SzOz89rwufbZbV1FJo3WPQtqGXnTPJ6va4uWp4Igu9FlGvw6uaWsuMR+d1k1Ztgi3o41G9Ooe2tugiF3rFGE3dcMuMYezweF91sHJfOoOO6vM6ew/nNRI/HfD6vhJ8tsW03vx2LvgV1a3HRz2azqj49Ho9rt35uu+C6ZNKzkKIpWcWTbzhDriLnzresz51d/cyd19KZ3sWXQw8WPe+fs/a8L90PL6WdWXxYe8f1x2HRN6AxPFt5WOrRaBRnZ2e1KaC6DaVLGS8rfTXFrSwydqmzeer6zFNYm5pjeIlrde/VxWbXXo9By3T4LRxCcCOO7hsJPYv+NCz6FtjaHQ6HODs7q000mUwm1QVdiudLF2FT/K+Zek56tYmeE3vaBJNZXHbv2VvheJ4tsK5rr+vk8fHwcWTLVgPNl/A+eD0+XWM/i+st+mYs+ha4QSbiWqi4MNVVBXdx4WkDDr9XEj2EpDPtSuJTEbK7rV4OC0/X08/ExqVBrdFzMpMHmOymHLrqbnanHmfwu2PRN8AXvr4P0atg+DO33XfX15oX0NIbDwDaHMMPLRtqElMFqFNamwai0nPEzTvt6qOpTJrdwMOCb8aib6EkfJS71Grpd2+772O3l5UCtQmnVJ/PRM9JxJIYS0LLtq3Hx7+rKWmp75UGBwu+HYu+AxpX4z3OUjfF57fZZ9f3I25WBbK+AB0EMhHq/jLhlVxpnJOm48j2pcLXbWfvlwYIi78Zi74Bvei4jHWMaO76mEqUqgIl0WXHrdYXrzPx8efaqhRN5yj7fV2emwYIU2bQ8p/g5Ub/n+wCLv37bXNKNaDp712F2OUYunBslaPrMVjsN0hPiEVvzIdLKno3KxvTMyx6Y3qGRW9Mz7DojekZFr0xPcOiN6ZnWPTG9AyL3pieYdEb0zMsemN6hkVvTM+w6I3pGRa9MT3DojemZ1j0xvQMi96YnmHRG9MzLHpjeoZFb0zPsOiN6RkWvTE9w6I3pmdY9Mb0DIvemJ5h0RvTMyx6Y3qGRW9Mz7DojekZFr0xPcOiN6ZnWPTG9AyL3pieYdEb0zMsemN6hkVvTM+w6I3pGRa9MT3DojemZ1j0xvQMi96YnmHRG9MzLHpjeoZFb0zPsOiN6RkWvTE9w6I3pmdY9Mb0DIvemJ5h0RvTMyx6Y3qGRW9Mz7DojekZ45a/D+7lKIwx94YtvTE9w6I3pmdY9Mb0DIvemJ5h0RvTMyx6Y3rG/wHHGILGDDngHwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 9\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 10\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 11\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 12\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 13\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 14\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 15\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 16\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 17\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 18\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 19\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 20\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 21\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 22\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 23\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 24\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 25\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP0AAADnCAYAAADVeFABAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAv20lEQVR4nO19y25j6dXdoiRS4lWkKIm6VpXTjt0xGvGsPbCBDIIM0oD/SZ4hyCyTf+QHMPBP8woZZpaBnyDTDJw2EGTSrosuVRJFSqR4Ee8ZFNandbYOdaHa3a0+ewGEVJLIc6mzvn1be3+p2WwGh8ORHCz92CfgcDh+WDjpHY6EwUnvcCQMTnqHI2Fw0jscCcNDpJ/566f5Go/Hs8lkEv7917/+dfbNN9/MUqlUeKXT6ci/n/Ky7/3mm29m3377bTjeZDKJHN9fP8lXLNzSOxwJg5Pe4UgYnPQOR8LgpHc4EgYn/QtFKpX6sU/B8ULhpH+h8J4Jx6Jw0jscCYOT3uFIGJz0DkfC4KR3OBIGJ73DkTA46R2OhMFJ73AkDE56hyNhcNI7HAmDk97hSBic9C8Urr13LAon/QuFa+8di8JJ73AkDE56h+N7xP/86wm++W//C//5v/9vNLvDH/t0YrHyY5+Aw/FzQf16gH/+H/8H4+kM//djG9X8/8O//Kd/+2Of1h24pXc4vifcjCYYT29zLdc34x/xbObDSe9wfE843Mjhv/y7f4VUCtgpreG//vt//WOfUizcvXc4vkf86T/+G/zzf/g1Mis/XXv60z0zh+OF4qdMeMBJ73AkDk56hyNhcNI7HAmDk97hSBic9A5HwuCkdzgSBie9w5EwOOkdC8Pbe18mnPSOheGDPF4mnPQvFE44x6Jw0r9QuGvtWBROeocjYXDSOxwJg5Pe4UgYnPSOheF5hZcJJ73DkTA46R0Lw8uGLxNOeocjYXDSOxwJg5Pe4UgYnPQOR8LgpHc4EgYnvcORMDjpXyh+iHKZHmN5edlLdD8TOOkdj4Kr734+8G2tXijiSDgYDML3qVTqWZY5lUpFjtHr9TCZTO49vuNlwC29w5EwOOlfKKwlT6VS2N/fx9raGoDPlng8Xnyr5MlkgnQ6DQCoVCr41a9+hWw2O/f4jpcDJ/0LxdLSEpaWPv/30e3+8ssv8bvf/Q6bm5sAnueCz2YzZLNZfPXVV/jjH/+IP/zhDyiVSuH3TvqXCyf9CwVJN5lM0Gq1MBwOUalUsLe3h2Kx+OzPX15eRi6Xw+HhIX7729/il7/8ZfAi9PiOlwdP5L1wjEYj9Ho9tNtttFotdLvdZ7n1qVQKKysrWF1dRaFQQKFQQCaTwdLSEmazGWazmZP9hcNJ/8KgLvt4PEav18PV1RXOzs5wcnKC8/NzdLvdBz+Hlpr196WlJSwvL2N5eRlra2vI5/Oo1WpYX1/HysoKJpMJptNpIL2T/+XCSf9MKAn1+38EIWhpp9MpJpMJ+v0+Li4ucHx8jA8fPuD09BRXV1cYj8d3Sm56XiR3Op0OVj2TySCdTgcLXy6Xsbu7i4ODA1QqFayurmIymWA4HGJ5eRnA57wCr/OHXAB8sXkenPQLQglIC3gf6ePIMe9v4hYSPdZoNMJgMECr1cLx8THevn2L9+/f4/z8HJ1OB6PRKJb0tOaZTAaZTAb5fB6FQgG5XC58zeVyKBaLKJfL2N7ext7eHqrVKjKZTAgl1DuYdx2Pud64nz9EaH62LjiOp8FJvwBI8PF4jPF4jNFodMf91Yf+oRf/Lu4YSvbJZILRaIR+v4/r62vU63W8e/cO7969C1b+5uYmkN2SiYTPZrMoFouoVCrY3NxEtVrF+vo6SqVSiOMLhQJKpRLW19eRz+cBADc3N8GL4DnqVyWkvuKu8757pH+neQQNQ1ZWVu58tuNxcNIvABJ+OByi3++j3+9jMBhgMplgNpvdedj5vf48jhT2QZ/NZphMJphMJuF4Nzc36HQ6aDQaODs7w7t373B0dIR6vY5OpxOSeEtLS5hOp+Gc1aXP5/Mh07+3t4fd3d1A/EKhgGw2G1z+TCYTYvput4vpdBoWu/F4HK6ZxCQh9at6Bnqtj70XvI6lpaUQgjAc8Z6Ap8NJ/0TwIRyPx+j3+2i1Wmi32+j1ehgOhwA+E4wPML/Xr3HfW3eV1p2exGAwQL/fR6/XQ6vVwsXFBT5+/IiTkxNcXFzg+voag8EgEMS630tLSyF+z2azKJfL2Nrawv7+Pg4ODrC1tYX19XXkcrmQrefCoSFFr9dDt9tFr9fDzc0NBoNBZKFZWVlBOp1GOp0OxCT5rQfA69eXvRf0cHhfmWQsFArhujyp+DQ46RcASUACNhqNQDoAEQtHS2St38rKSuT7ONLTnadHwdLc1dUV6vU6zs7OIsdWy25de7XCJE6pVEKlUkG1WkW1WkWpVEI2mw3nzEWHxO52u7i8vESz2cTV1RXa7TZubm4wGo2Ch8OFhS/1Fuxix3vARcJ6BrrAzmYzrKysIJ/PYzqdRt7Pxc3xODjpnwh9EAeDAbrdbiAiLT0f4JWVlUB4faD5oPPnSgj7sA+Hw2BhO50OWq1W8C6ur69DaEFiEHFJQf25Wv9MJoPV1VWsra1hdXU1ZOfpuvP7fr+PdruNi4sL1Ot1XF1dhcShkj6bzSKTyWBtbQ1ra2t3LL69B/o31mVnGDGdTpFOpzEej5FOp5HNZpHNZr3xZwE46RcAY2263jc3N8Hi0ULy70ggEtlm5vUVR3oeI+4rvQGbSNPMvU10MeHI5KPG5fx7Wk6eE983HA7R6/VwfX2Nq6srNJtNdLtdDIdDTCaTQORer4dsNhsWEY2/1ULzd6PRKHgGXAjotvN6Sfrl5eWwyGnlxN37x8NJ/wxYEgO4E8fHxaxx2eo4xDXV6M/jkmMa59pz48+4aAyHw/C9Ej/u2BrXM9TodruB9MDnmD6TyYT7wkVpPB7fCWfS6XRYgHg8DXGU9CR4KpUKic24e+94HJz0C0BjZHWRgc/JJlowjTnnJfRsgkut9HQ6DZ9v3/+YhSOuVq9VAbWU9n369zahSM9mOBxiOBxGYm4SnGTnuZKsy8vLwcugJ8GqAt+rC5b1hvTlWAxO+gVha8YrK59vJWvhq6urd+J6LVEp2eNqzvOsuK3fq9W7jwj6GVykNIFm8wqEhjJK+MFgEAiv2XuSm+fFsIALAa/dahp4Dlwo9PiPuT7H4+GkfwYs8QFE5K0ax1prriU9S7I4UY7G94PBIJBO43t96TlqLZwJNirvisUi8vl8iKd5ruptjMdj3NzcoN/vo9vtotPphATicDgMrjevR70D/Qw9F7r3Wt/XBYf3haEHvR53658PJ/2CsDG0ddltie4+wU6cGIUPu3WrKQbq9XqhVq5u9jyrSKKtra0FmW2lUkG5XEaxWAz1eXom/JzJZBKpUrCTr9vthmPzfmhdX4luz4kk54Kl95T3gIuoLh5LS0shlLCf53g8nPQLwEpC1dLbGv1DSTz7wFqNPUt2Nzc3gWztdhudTgfdbjdSsqNbzc/RUIFhRy6XQ6lUwsbGBjY2NlAul1EoFLC2tnan5m0Jf3l5iVarFSkVTiaTiIW3r9FoFM7HWna14DaESafTYRHhNTHeV0/G8XQ46Z8Im0FXUqsEd17ybh7hNXa1iTNmyq+vrwPplPgsF5JUWjJUbyKdTocOumq1io2NDZRKpTtWnp9BnX+r1UKz2cTl5SUuLy8j7r3ei3nlSF6PVdfpIqAe03Q6RSaTCbE/F4Z0Ou3u/fcAJ/0CmOfWsy6vVt0uAA/pyzWGZ3ms0+mg3W4HERCJT8KrpVdS6HHo2pP01sozngduBTGDwQDtdhvNZhMXFxe4uLjA1dVVUADSfee122Py2jQfwfPT+Fzvkd4D1TgsLy/fCV8eKnk64uGkXxDz3HurL7dxfJzOXpNm/KoNPbTylL7Syqtrf188T2JqPF8ul4OVVxWcWvlutxskv+fn50Hj3+/3MRwO7xDP5it4bSQ+ZcX8W5vE0/BiOp2GewogUtd3S/88OOkXgI3pWW6y7v08Mc080lvrqKQn2Sm/ZRLPZu/jwHg+n8+jWCyGNlpm7enWM+lGyS0be0h4ym4Zy/Oz46z8POJbBR3vRzqdxmAwiFj7dDodWVT4fsfz4KRfENZ1X1lZCY0gcSU6+7KkAG4n0ai1ZSttp9PB9fV1xK1nyS6uVGc77Nhks76+HmmhZcJMz4XNRFdXV0FnT8kte+pZc9fjsN6uoYLmF1QYxGPapKW69HqMVCrllv57gpN+QZBM2jjCn1uxTVzizmarmaxS4msPvdbH5xHeegyatc9ms1hfX0elUgmkZ3ONEpAZ++vr6xDLNxoNtFot9Hq9iBhHrTbvhZYq+Tc2xuf1aqJOcxm6YOh9VE9Br9PxNDjpF8B9JTuNUeMUbvZz+NW6/WrtVQlHwisB5lk/7Xoj4VmbZ8ZexUFcaG5ubkKJrtlshtq8Sm7j4ngugKwEkPDz7p3eA6vVV1DNx5ftEXA8DU76BWEfdk068WdxZTmrKVfy6OcCt00uVoVHYtguOz0+F53V1dVQl9/a2ooMy1CPhKRjJx1Jr9l6nZJj74EOzaB7z847W6qc1zugFl/vM4A7i5xjcTjpnwEb16uLPs+SEeriAogQSq0eM95M2NkRVfNAIubzeWxsbKBWq6FWq2FzcxOlUglra2vBE+H5UCev6rvr6+uIDkCvne/XSTmU88YlMTXpZ8uYes808WcXBI/nnw8n/TNgM/JatrNuJ11duzDoz9WFtRJc2wZ7X4ecEr5cLqNWq4VZeBsbG2EDCy3TAZ8XHiYOWSnodrsRK89j8DqZz6CV51e9Zpu4tFUPlSoTel3qAdjypuPpcNJ/T4irV8fJUrW2bZN5TKKR5Hwxs21r8fMIv7S0hNXVVRSLRdRqtTC/vlaroVwuI5vN3pHcamMNSU8rz4VGj6NWngMwVORjs/b8Nz0brc3bBKANiZTsD3k4jofhpH8G7MOnDya/2uy0tc7q/qvWnRJb1uOtAGce2EmXz+exubmJnZ0dHB4ehom3+Xw+1soznldNQKfTCcfWc9WqgI7FomtvG2/ikm/qJajV56IQd68t4Z38i8FJvyDUgimhrYUnUe3YaFtX13IZB1DGNbfMS2aRiFTera+vY2trCwcHB9jb28P29nYklrflQlp5kp4CICrv9Dg67iqbzSKfzyOXy4USIBewuHCEnxFX8lQrH7eAzvNwHE+Dk34BWEuubbD6QJPIdM+ty65k4GeQ9FTDsVw2GAwiTTUK69YXCgVUq1Xs7+9jf38fOzs7oUxnxTgA7hyX+n6V2zIUIFFXV1eRy+WQz+eRz+fDMMylpaXIcA0dtsEQgce3cT0TgLqY8vrmleZ8AXg6nPQLQmvKJLVKU6kg04m27IWn5VbdvM6so3t/dXUVutrsiGsgmlDT5F21WsXOzk4keUe33ibLWBbUMh2PeXNzE46pRF1dXQ1kp5yXJUCrsGPlQSfmWrmyqvg0ucl7qCU+x/PhpF8AWlLTnvfRaHRHNqrtsYzT+SL5SQqS5ObmJrTTUoJrM+hKXhI+m82iVCphe3sbu7u72N3dDSW61dXVCHk0/KAYp9FooF6vx87SV09C97vjEI7V1VUAn7e+0uvW6wNue+KBu0ImWnodwMG/i9M8OBaDk/6J0FjeToflg0py6Vw5aucZL2svfBzxSRj1COaVzehuF4tFbG1thWz99vZ2JFtvpbAk/PX1NS4uLvDp0yecnZ2h2WyGefa0ukwQcggH98Fj2LC0tBTOW0nPa+LnxE3AtUk8FeTYnznxnw8n/QJQIQutsu4jp33pTI5xAIZuVEEXmqRmzK5ftX4flwFX1R13mWUcz2y9imW06YWEr9fr+PjxI05PT3F2dobLy0t0u91wPSQlCb+5uRk2vqQXMZlM0Ol0ACByDQx7VJ9AqLCJLy4Ms9ksqPp4vXr/HYvDSf8EKGF0M0mWuNTSAwitsfybq6urIGu1zTNakrNyVJuxpieh+8mrhd/f3w/Zerr19vw5IKNer+Pk5AQfPnzA0dERzs/P0W63g3UmGRk6bG1tYXt7G9vb2yFXkEqlglVn6KBDM/jSEiGvQZV5Wq7TcwXu7tjjxF8cTvonQlteab053IIPPZNVdP1p2dXKa3usbSa5rzRFslDyWigUsLm5ib29Pbx69QqHh4fY2dlBpVIJbj1w651oF129XsfR0VHY3/709BSNRgPdbjfE4CwB0sJT7LO9vY319fVg5XlNccS1nXHz9gDQARoWXrr7/nAv6VWFlSSoNbLZbrrFzHTX63XU63VcX19HSlLT6TSSwFOXXqfY0sJbctjeeE1mURBDwu/u7uLVq1d49eoV9vf3IyIctbzWpT85OcHbt2/x97//He/fvw9Wngk8xvGFQiHo9/f394PQp1gsYmlpKYQnFP1Y2HKflursmHDtzLNCHNtV6MRfDPeS/rk3VN05/bf9+fd5jLjfA4+7FlsSUtks8DlG5061jIM/ffoUSK9/qx1rVmGnWnrV0M/T0hPM0ivh9/b2cHh4GAi/tbUV3HrGx3zR6yDh3717F/a3Pz8/R6vVCgo8ZtNzuRwqlUogPOW8lUoFq6urmE6noRKhBOa5a2KTZFedvu5oa/MO+oojvGMx3Et6bRdNMmiNu90uLi4ucHR0hPfv3+Pdu3f4+PEjms0m+v1+RFevm1vqjHqSKm7izUPyWmbpKbHd3d0NhGe2XlV3WlbUeXcnJyc4OjrChw8fcHJygnq9Hghvs/V063d3d7G/v4+9vT1Uq1UUCoUwu34ymdzZfNIKbjQkoWyXu9WS9Fb0ZBWIdh87J/5icFY/gNFohHa7jX6/j2aziePj4+AOHx8fh2GRVrnGWjMTflaMEzfxxsJ28NHVjnPpGWNzf3ktKXY6HTSbTXz69CkQ/vj4OOxvrzoAWmQKfSqVShD6UM7LWB5AuDYtu+l2WXT5dU5foVAIG2xwZBfr88Dtzrq8h5rJd+I/H/eS/m9/+9sPdR4/OuLCBD6IzHR//PgxWPnT01PU6/VAGFuu44PJuJ11eH2gH0t4ZumZPWfSTi086+VUxbFyoKHI8fExjo6O8PHjx7C/PJN2uqEERTjU75P0PE4+n494EhqTk/zMO9Bl17CkUCgERR/1+lykNGuv5NZ/e2/983Av6f/0pz/9UOfxk4Bm3VOpFA4ODvDrX/8axWIRl5eXOD09xenpKc7PzwNhmPRS1x64q8t/7EPL92vrKsdd0cK/fv0ah4eHEQuvhB+NRsG6n52d3bHuFxcXQSPAMIPXTze8UCigUqkEdd/29jYqlQqKxWLYoVd7DfQecpGiHj+VSoV/k/Rs0Emn05jNbrfPVldek5xLS0t3Gpbc0i+Ge0n/l7/85Yc6j58kSqUSvv76a2xtbeH6+joku9S6a5bdEsC2ls7rkNP321FX1LeTfIeHhzg8PMTe3l4YfcUtqeiVUGGn9XcS/vLyMtK1F6fw0xLdzs5OqMlzYwxm2YHbuXpaT2fugaSkladrn8/nQ+89gGDhB4NBsOq6WKqlj+va0wSq42F4TH8P2u02vv32W+Tz+ZDIU4tkocIcABFrrpbJlqa0pMUEGltWq9VqILx2zVENp0m70WgUFifW39+9exe8E07CiZP08hzoWZTL5TBTb2NjA8ViMSwuvB5tGdb7wto+Y3x6DiS9jt5mGZHhkXbYqaXXpGHcbj6Ox8NJHwN10c/Pz+/8Tklip9/Yh/A+kY1+r24xx1xtbGxgZ2cnZM13d3extbWFSqVyJx4eDofodDqhuvDdd9/h7du3+PDhAy4uLkL9Xa2yLZ+urKwEK89BmtVqNSQIbesrdfU6pZf1fXXvSXZ163ne9Dg0F6KhEBcD3SHnsQNFHPHwkl0MSHqq0hRaO7aWnb+3rqbqE+zPtcOMO9Bsbm4GHT3Jvr29Hay7xsraGttsNnF6eoq3b98Gld3Z2VkIR+hGz7tmHZddrVbvEJ45D5JPd9JlfoM1fl4TM/XFYjH03fO54v1lDoX3j2TXsiaAO/MInPiL4V5W2/njjvlQUts4md/bf1Ossra2hlwuF6yrauh3dnZCN5vdhkplta1WC2dnZ0E/8OHDB5ydnUU2m4wjB8MNdcO5jTXdeur31cLrdlvMc/T7/YiSjw066+vrgfTs6aeV10464HZOgeZDWEqkrFmblOblRxzzkUxT/j1CyRxnyflVpbTMzNudZ3Z2dkKybm9vD7VaLchd1doCiFhcJu6Ojo5wdHSE09PTkKG/j/A8N1Xf8Vx4XOYMgNvuuV6vh+vr67AZxuXlZdAyjMfjSJhSKpVQKpXCNdDK69ZYqmK0ZFdrvry8HNqYdfNOLjSezHscnPQLwJI37mGzmXjVnbOGTcIzdmdbLDPz1rrT2mrGvNvtBrf++Pg4ZOk1hn/I/WWlgGW6arUajs0MO+No9h3o9tUU+AyHw7CY6TgtJvE0lgeie/dpAk9LdlxoeM854YeehZYcHY+Dk34BMP5VIhM2I64acya3crkcCoVCJGG2s7MTymOcdsPY3X4+Cdjv93F1dYVPnz7h+PgYJycnEZf+vhieUCtfLpfD1lecjU9JsYqUms0m6vV6qPlTwgsgZO3pxWSz2cik3Hn9DUp4rXRoVWA2m4VwgiEFM/9xn+2Ih5P+iSDhKTWlFQaiZTkKUmjRmb0ulUooFAqRveW2trbCUArdXDJuR1mSggQ8Pz8PFv7Tp0+RARgPEZ6LlmbsNzc3Q/KOhOcEIAp+SHiKlPr9PiaTSVjYdDz26upqWLji+vrjpLVxLj4Te+l0OswO5NDQ0WgUmRvguB9O+ieChKfrms1mgw5dpaTMhJPgnCdXLpfDdtF8lcvlsBiwCUVJYl1gJfzJyQmOj4/x8eNHNBqNMLbrobZoLl6Uxm5sbKBarQYrz00jOQabgzrr9TrOz89xfn6OZrMZfs8OO7so6n55vEdKZH3ZjkMdOqrKvMvLyxBWcEOOXC73j/2P/xnBSf8EMI7PZrMoFouRkpaOfqYKTevtfJHgzGaz6cR2nM2T9Np+eHbKsTSnU3nvuw7VwnPeHcOKTCaD6XQaFhDO4b+4uMD5+Tnq9XrwKIbDYViU6B2wKqHtsqqh5yBRlt/idu6xTTfUAACIzDHgqG6P6x8PJ/0ToPFvtVqNTJvVdtrpdIpMJoNisYhKpRIhvNar6fqySUUn6VrC6/AOWvj379/j6OgInz59Ctlznb4TB3Xpi8ViGI5BbX02m8VsNguEZ/2fbv3FxQWurq7CAjObzSL712nzjQ7wABC5jpubm1B+00YkQsuDOlxzOp2i1Wqh0Wig0WjcmefneBhO+ieAFpL97My0l8tlrKysROa7p9PpyJhouu8ku7q+SnYgquJTC88BGJTYvn37FicnJ2HElcbx+lnaxKMuPefjUwtQLBaxvLwcNr5QC0+SMYGmYYzKiO3YK3oCJK3uAaADRZT0vAZ6ADb2X15eDuVC5hSc9I+Hk/4JYDmKrj1FNBsbG0in0yFWVfe+WCxG5Kcar8dZdUIHYPT7/VCLPz4+xtu3b/Hdd9/h6OgI9Xo9JLNIGjuAUhVyqunXqkG5XEY6nQ772XU6nUD4i4uLkDjjrjfT6TSi2NQSJYDgxnM0Nl12klytvbruev2qRdA8BScAceagk/5pcNI/AdSUM1avVqsh687RUdqXzlo1S1Y2Xp9n2VXXzvFcjUYDp6en+PDhA96+fYvj42PU6/VQj9cuN00AkuwqlmEMv729HTr1stlsiOO1LKfiG23F1QYdlRPzGnjuw+Ew/Ezn+ut8f92uy8b1au35c84e1AGjTvrHw0n/BOj0F7vDy9raGoBba02yMd7Vue5xyS3tKqMl5N5yjUYDnz59CgIcO+JKB3ISdpPJYrEYhEBcrNgfn06nA+E1YddoNMKkXx6HKjo71FJ3wZ1HeDtIhOet2XtbptP2Ws3sM0zQicLeYvs4OOkfCS1xkfTMvudyuSBkIVS4Y2vU1nXVHW0Y63Y6HbRaraB8Ozs7C7XxZrMZiMgWXerxdXgmy4pcnKrVKjY2NlCpVIL4Z3l5OZD08vIS5+fnkRq8CmB4LMbyvE5eI8U0dNmBW+muTv4l9L7EEV+HkMTV8G25z0n/ODjpHwkdBGF3arXEtlNgrZXSspXuW0d3lZtnUITSaDQibjYTYJxcoyOlVd6rOnqSfX19PTS+AIhsT82trbiwsAZO0tnQQRc1AGHiLmN4ei3aFafvpRdEebHu7mu76PQeAlGdvnfZPQ3eWhsDWgvdXoklrkqlgnK5HFRzVnuv3+uDqiSgNefedtyHXjfD4Fe+OEJb96nXkVrUzjNmZ5lwc3MTGxsbodNNp+zQo6DSjjV4JbzOzyO57dx6bUXmubH1VvfpoyXm+zgRl8+Z7nJrLfh9dXjbwei4H95aK7DDMdkeSpmq6uNLpVJkiuu8mNL2n3PjC24JTQtOwpOEWtIicbSVVGfIq6x3c3MzTLyhwq5UKoUQhLPmrPCGu9Vy2y1LeMJWA7jwqKJOs/PM1muTDRuO+Pe8j3xfnLXX+8n/K7s7jstwH4dkmvI5sG7ieDzGmzdvcHh4GBpSDg4OsLe3F0hPt1Qz2uqOUreu7agkGOvfHLLJVliWoEgWGwezK07bcre2tlCr1VCr1SITb9S6U0BEwmtZjjVvHZiphNcwQnsOdHKPzvpn66tu20Wdg3XbOUyD52aTc1rd4MKszUxcfPT/0S3/fDjp70GtVsPXX3+N3/zmN0FMQ7eZ02fjLJFadwpdmIXX7rRGoxFpE6Xrrl1lhMbQDDXK5XIYXrm3txcZYqnWXXfRZdzMzS+0Dm+z9AptD6aunhZar1WVdrqLD4AwE0/1BMBtGMkkoC3jWXDRYf5Cm54cD+PeO/VP//RPP9R5/CTAiS69Xg/Ly8v48ssv8fvf/x6vX78ObrxKTlU4oqOd+G92pmn/+fn5eaRZxE7WVbKpWk/HYbMjrlarYWdnBwcHB2Gklg6xpAVkPoEWmRZepawkfNyEX1p4Ek07ALX+TrIze6/lNrrjtNKj0SiU+WjpNQ9gm3D0fNjMROGT5gUcD+PeO/XnP//5hzqPnwRUTZZKpUKXHMc58yHWcVE6yUUTUdalJ+nVndf3WBeWIFl0yo5adyU8O+RIAh1xpVJebVihtNZm6TVpR1ESCa+W1Q7H5Es9FsKO+aJEly67bcKxVp6lQm7EwVIkN99wPA73kv6rr776oc7jRYAPaq/XC5adDSlaSqPVYxmO+9JryU3j5jgXVhNVVPbZHWc4EptjqrlAkVx2pp3mFJTwLLNxsbO7zLIUSMLTrVePRmfXWYWdEhu4TW5SI8BEoK3n8/0MC7gYsTOQ153P5+9Igh3z4T7RE2BbRrkxJK349fV1iElZ/+50OsGN19jdEgOIjtNWRR0nylI6u7u7G2L4uIm1ACKZdGrVKa1lP/zl5WXolmMJUBWFui+dEl7derXuel2PaXVV3QJJrwlEm9MAEKoVW1tbIZxxS/80eMnuHsRp5PlzZp1JespiWUun9aMbr8SwySy1TDZDztFalM5qOU71Aqp712Yd9t83Go2gtrP72LHyoHJaLm62/Ze5jYcIb0OVuJmBPF8lvarx9P+B71tbWwsJTO4BkMvlnPRPwL2kT6qbpCUfG1+rq8o5dZwqc3l5GXHdVRuuTTHAbdKQ3+uDrYMlC4VCpLmHQhsOmlTycICkklIn3pDwzWYz0g9P15huuw7wpLVXuWwc4eN2nVFlom5sqd6Sld1aD0Hbgtn3wF1/OMtgdXU1sc/qIriX9L563oUq8NgqSove6XRCvG8bTAjGpSoksUM0dRxXqVSK9OTb2fEk4Hg8Dok7agMor2UczwEYtPBKeBJHVX5q+bVpJo7wcb38vFe6bTW9El30gNvmI7toMKa3G3GwYYilUyf94+Ex/YLQ5g+rGdc914Bbi6cZdf6c1l1derbB2u2g7P5v3LOd32vNXLv0WD1otVphUUqlUsGS07PRjjkNF7Rpht5LHOGthde8BBOBekx+Xtw8AfW0dHiJdgnqRhyOx8NJvwCsvt5q7Ak+3LRs+ntaQdWwk/B07Tkum/u8s6GFmfN+vx9RxgGIkJ56fWr7ua02dQaZTCZYUl2UNHzR/ncV3jxEeBXQsBNRt+NiRYHnrB14NqSiTp9WnnsCuJVfDE76BWE76Ug8uqL8uW7uoOUru/mFjozmkEy1iqPRKMThvV4voopT0itZGXqwJAfgjnVXl17DFmb0NYSJS9pZwtvNLritFTe8YLMPS4isMPAc6L0AtxoB9kBwHgD7CXT3Hcfj4aRfEKpUY3Iqk8lEpr0o4fV9cYTXTTF0UOZ0Og1k06SWjb2tlVYVHgdfsKvNZtLVvaaIRxV8tPC23BiXYaeIiDJhboRp+/fb7XYguA7M4GfpfaLsmH0G2h7sVv7pcNIvAH0g1Y3lyCzOjI9LTGlpjKRXq61JLhJPJb5a6lN5rlp8O7yD7rFdKHTEFcMCTryxhL+vLMfFRlWDKhPmSC7uD9Dv90OZjV6FnfFH74lW3u5+S4/FSf90OOkXgLXyJP3a2lpErhs35MFmyOPmw9vatU0Q6iKipTDmA3guWv7jSz0JJTybcAaDQQgnbPOM3YmG56AxPMdq60acW1tbKBaLwRPqdrthAdA5eZQAM7ZXrYIdXKJTeB1Pg5N+QdDS0yWPI31cokuhijQAwdJpeUw3huAiwPdqOYyttgBClp91bZKFXXe6G810Og19AoPBAACCi6/98HFaevV4SM5yuYxarYbDw0O8evUKu7u7qFarka7EXC4XpLc8joqEeI0kve6Jp+eu99Et/uPhpF8AmgCzWXcSVq0QyWLr0trcYrPmOi5arb21spPJJLi6/B2VdKzzsxvNWkm68KlUKnzVUV56/Ickwxw0wln6u7u72N3dRa1WQ7lcDuc4Ho9DMo9JSW0rpqXX5hrd6gu4rZj4mKzF4KRfEIynGdfT4vPB1ew3cLtpRVw3nU2maTefEl5DBp2bT8LboZhMfuk+ebbdluUzIDrEkl/nyWp5D9QFt9N7VCqsTTrAbe/8+vp6RNTEbjsmQunJqHrPLkSOp8FJvwBUcabCGsbK7CDT7ZxUsBNHfPUMrH5e+8rj4mkbZlDUQytfLBbDZhu6wy6AQDQVGelMO82o268qvlHJMCf2aDhBbQAQHYKh8bqOzWa/Pe+LagU03HlMY48jCif9gtDsOZNi6XQag8EgEB+4q9yj6x6X3FNrT8LZzL9dcJTsJB4z3bpBpnbI6XmpV6GlM+220+vUjD0XG+YzGHerR2EHh+q16IIZt8stCa37AFBwRO0BF0GP6R8PJ/2CUPJpGY6EtzVznapjS2/8O+BuvwPJxc/ke3R0lsp1KYJRsquGHoh2tsXtIGuFO5wFSFUhf6f7z3NRYejAa9XkI3AbQtgKh75s5YMek25lxcSjHevleBhO+mdACa9lsHkTWnWIhFooLhDW1Y8btKkKQN2bTgmvc+OU6Pys+5J1PC5dcF0E7OgrVSHyGEzOdTodZLPZEE4wf8BmIFX40WXX87G71jA5WiqV0G63I+PAPa5/Gpz0C0JVY0p66tmpcVexjJKb2XObkNPFQi27HlcFORzpRcKT7HZUFsnDf3O4htbhuTBoVUIn1qhqTvvi2TzDYR2sErA5aDQahcYYNgjpzH/O+GdCj7G9njez9/zbbrcbWRgcj4eTfgHEEZ4ZfI3l7X5sVsVmRTYaIlgNvy2RsSzHWJqJurjJNmy7BaIbSZL0Oi6LC1c2m71DcN0jnuetx2m325Gwhh7Fzc1NZJMNLg4czMnx2yR0v9+PJD3pZSwvL6Pb7UZmFngi7+lw0j8DJIOOlNKuNT74cVLcOBkrPQNV6qlcVj0A7b3X2B1AcKGprIvTAKh7zzo5z4+fnc1m71hR3ZRSOws1+agjsXu9HtbX10NrMHsJSHr2+XN+oNbsddGZzWYhUeqZ++fBSf9EaMlKs9qrq6shYWUTZySdJvzsyCy18lr+U6uvC4AuNnSlSXJV2inhbbaeGXu71xwXFQpp9HrooispGatzISHhuaB0Oh3k8/lA+sFgEIZ7cKMNjhqjBY9rQ7aDOjxjvxic9AvAdoGReJw+o4IS/r0uEJSj2sSY/l6tvs0LcCGwwy7o7tLd1sqAzY6r+6wknicb1s49DVu03q9xv+4/3+v1AukpvtEpwa1W687OOvPEQFris30LjsfBSb8gbEkrk8mE2JkWUpN0ltSqduPnqeuuhLf7wOvnaggRZ/2U8LbzT8mlngCz53aOv25GqZ1/ev521h0XoW63G5KcOsqLmXjb1KOfCXwmPHMYTFp6p91icNIvCOuu0wIx0cYSFaEPL99jraXG7OpNWDWc1fHrz6ywxxLetvsSuhBY91zLayowUpkxF0A7KITnNhqN7mjudWS41u7j7rN28HGIBodyOOmfBif9M6DWmcQHEBGyWHGOQokf587q+2ydnLDkti67detts4p+5XvUysdN9FVy6uKhDTPLy8thgWCSkAlMuzmGtfB6f9jMw/l429vbYfQ1dQBO+qfBSb8grBVX60ZSUUmn5by4HnsAESLy37a/fN7f2Jjc/syq3GzmXX+vklxV6c3rHbD3wpYXeZ70fLRtWBc8ez90Zx3u7MNNPti5x0k8jqfBSf89QK1l3AOs8b/KatXyx20sonE6rSd/pm68JvFITLsA2O/5Xvu9NgfZz4y7PiW8Xp9NtvHcdUHShUc/Sy08Cb+/v49Xr17h8PAQ29vbPgn3GXDSLwhrJW2zirWufI9N7AG4YxX1q9aq485BLbpaexJYFwB+H0fqeZ6CzRUouPjYaoZOE6I2XxcvXaxsIpA5ESX8wcEB3rx5gzdv3mBvby+yVbi79k+Hk/4ZUJmruqzAbf+8TdYBiCTrmAfge+KEPPNq0nFxeZz7b5tf4lz2h4huz982HMWNvNZ2XibzWOHQhU8XPybtlPC/+MUv8MUXX0SsPLUJTvqnw0n/TCgprDrNkpflN+A2ix8n07Xus42ReVwSWrvwSPClpduxU7TG6sZrU0sc2dU7sWDPgAqEtJTGXgDdVJOjsZiQ1CEjzINQWlwoFLC5uYm9vT28efMGX3zxBV6/fo3d3d0Qy7uVXxxO+gUQJ87R5hQA4SHm79XqK9F1lNa8JJ9aVSWjWnEbZjBrTqGOnZYTl8TTn8VBKwckKMddc+Q1J/XoXnuz2SyU6XRcl+obOBugUChgY2MDOzs7eP36Nd68eYPDw0Ps7OyEbay4kDjpF4OTfgGoKIflJGbpNdMeJ4qJy6DbuD8uflbMU9jpQqKTZnq9Hrrdbuhsm1fvpyfA7/V6qTSk+83uvnK5jI2NjbDdVLlcRrFYDFaecTx33Gm320GFx5545jry+TzK5XJI3B0cHIRputzRxgU5z4eT/onQTDxd0dlshkwmg5ubmzs18Hkv+3v9N4C51pZ/pwuGltvU2lNgw/523deu2Wyi3W6j0+kglUqFuXRxXoYm5ziGi2TnNlPcULJUKoVYXr0LTr7hwsNWWno63KuOM/ZqtRq2trawsbGBYrH44DQex+PhpF8A2mQDfK4p53K52M6v+yz2vN/bBB1hrbIlv1p+tfZsemm1Wmg2m7i4uAgvbltNq8tmF+CW8CRksVgMm0dSJENiViqVyCw+WmOS3nod2h7L4+guvXbOnp1H4FgcqQceSp9OMAdxljXOUsbhsQ9tnIBHv7degl0AWJYj8bvdLq6urkJ328XFBRqNRrD42vACIBCeSbpKpYJqtYparYbt7e2IO0+yW/fbVjh0PJducKHjrrlpp8b/TvaFEHvDnPTPgJLsoTicmPfg2sz8fZi3GMSFDXH97dfX12i1WiG21qYX9VaYXGP8zhHXatnj5vDZa1GvxIpzeO22j8H2IDgWgpP+H4XHkH0envJAP+U4dgHQWr020uhmE7bzT9uGOem2UChEhm4+Znsp66HEXUtcWdLxbDjpk4z7LG6cVkCtr90Y063wi4GT3vEwbKnO8aIR+x/o2XtHBE70nz+c9AmHlufu+73CF4aXDXfvHY6fL2JXZ29GdjgSBie9w5EwOOkdjoTBSe9wJAxOeocjYXDSOxwJg5Pe4UgYnPQOR8LgpHc4EgYnvcORMDjpHY6EwUnvcCQMTnqHI2Fw0jscCYOT3uFIGJz0DkfC4KR3OBIGJ73DkTA46R2OhMFJ73AkDE56hyNhcNI7HAmDk97hSBic9A5HwuCkdzgSBie9w5EwOOkdjoTBSe9wJAxOeocjYXDSOxwJg5Pe4UgYnPQOR8LgpHc4EgYnvcORMDjpHY6EwUnvcCQMTnqHI2Fw0jscCYOT3uFIGJz0DkfC4KR3OBIGJ73DkTA46R2OhMFJ73AkDE56hyNhcNI7HAmDk97hSBic9A5HwuCkdzgSBie9w5EwOOkdjoTBSe9wJAxOeocjYVh54PepH+QsHA7HDwa39A5HwuCkdzgSBie9w5EwOOkdjoTBSe9wJAxOeocjYfj/fI37t0DHUuwAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 26\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 27\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 28\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 29\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 30\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 31\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 32\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 33\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 34\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 35\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 36\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 37\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 38\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 39\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 40\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 41\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 42\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 43\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 44\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 45\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 46\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 47\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 48\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 49\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 50\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 51\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 52\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 53\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 54\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 55\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 56\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 57\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 58\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 59\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP0AAADnCAYAAADVeFABAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA1aklEQVR4nO2dyXKb6ZKeX8wgZhAgCBDERIKzSjXoqE732Xjh8MJn0Rtfg8M7b3rVF9AR3voWvPTOi74CR3R0RLuqNHGQOILEQMzzDJBeVGTqAwhSBCmpxIN8IhilgfrxE4X3//LLL/NNzfX1NQRBmB20f/QNCILwdRHRC8KMIaIXhBlDRC8IM4aIXhBmjE+J/lq+vs2vwWBwPRwO+fevXr26/utf/3qt0Wj4y2AwjPx+mq/xf/vXv/71+s2bN/x6w+Fw5PXl65v8mois9IIwY4joBWHGENELwowhoheEGUNE/0TRaDR/9C0ITxQR/RNFeiaEhyKiF4QZQ0QvCDOGiF4QZgwRvSDMGCJ6QZgxRPSCMGOI6AVhxhDRC8KMIaIXhBlDRC8IM4aI/okitffCQxHRP1Gk9l54KCJ6QZgxRPSC8Bn5P69S+Ov//L/4r//r/6HU7P3RtzMR/R99A4Lwt0K+3sU//u/XGFxdYy9Tg8d6gP/xX57/0bd1A1npBeEz0ekPMbj6mGupdwZ/4N3cjoheED4ToXkL/tt/WIFGA/gdZvz3/7j2R9/SRCS8F4TPyD/95y3843/agFH/7a6n3+6dCcIT5VsWPCCiF4SZQ0QvCDOGiF4QZgwRvSDMGCJ6QZgxRPSCMGOI6AVhxhDRCw9G2nufJiJ64cGIkcfTRET/RBHBCQ9FRP9EkdBaeCgiekGYMUT0gjBjiOgFYcYQ0QsPRvIKTxMRvSDMGCJ64cHIseHTREQvCDOGiF4QZgwRvSDMGCJ6QZgxRPSCMGOI6AVhxhDRP1HGj8s0Gg202i/3v1On08kR3d8IIvq/Ia6urr7YtaX67m8HGWv1RBkX4XA4RKfT4d8/duXXarXQaDT8Oq1WC8Ph8NbXF54OstL/DTEuRBGmMAkR/RNFo9GM7LGtVivW1tbgcDgA/C74fr//4Ov3ej1+aDgcDsTjcVgslltfX3g6SHj/RBkXnNvtxt/93d8hn8/j3/7t33B5eTnyvfdd9dXv1Wg0CIfDePnyJf7yl7/A5XLd+vrC00FW+ifK+Eqr0+kQCAQQjUZHxDkt6sPBZrNhZWUFP//8M3Z2dmC1Wm99feHpIKJ/oqiC6/f7KJfLKBaLqFar6Ha7j76+wWDA4uIiQqEQAoEAXC4X9HoJDP8WENE/YTQaDa6urlCpVJBMJnF8fIyzszM0Go2R75s2oWcwGBAMBrG5uYnNzU0sLy/DbrdDp9N9ztsX/iDk0f3EuL6+Hlnle70e8vk8Tk9PcXx8jEwmc0P000Ar/NbWFn7++Wf89NNPWF1dxfz8/MSV/nOdEMhW4eshon/iVKtVnJ+f4/DwEKenp8hmsyPn9dNgMBjg9XqxtraGH374AX/605+ws7ODQCDAqzw9dESkTxcJ758YqtgajQZSqRSOjo5wdHSEZDKJarX6oNVXq9XC5XIhGo3iu+++ww8//IC1tTUsLCyMhPUi9qePrPRPkKurKzSbTaTTaRweHuL9+/c4OztDuVx+UCmuRqOB1WqFz+fD2toadnZ2EI/H4fP5YDKZANzcVtCfXV1djXwRVNE3HhVM+vX4f4Uvi4j+kdAHX11d6QNPfI4PM13/+voanU4H+Xwex8fH2Nvbw4cPH5BOp9FqtR50baPRCKfTiaWlJcRiMUQiEfh8PszNzd14/aurK3S7XbRaLTSbTbRaLXS7XQwGAy7T1Wq10Ol0/EXvB5UFa7Va/h69Xg+DwcBf9G/U94weJnQNuqbwMET0j+Tq6grD4RDD4RDX19cjH+hJYn/oA+D6+pofMO12G8ViEefn5zg9PUUqlUKlUnlwBZ5Wq4XNZoPX64XX64Xb7YbZbL7x4Lq6ukKr1UK5XMbl5SUuLy9RKBRQr9fR6/VYnCRmvV4Po9EIvV7P74cqdpPJBIvFAqvVCrvdDqvVirm5ORiNRv7+q6srDAYDXF9fQ6fTwWAwwGQywWg0PuhnFUT0j+b6+hrD4ZA/mFqtFnq9/kZoS/+dFCZ/6vrqr6+urtDv99FqtVCv11Gv19FsNh9VcqvVallMZrMZBoMBWq2WHzT0ut1uF+VyGYlEAoeHhzg6OsLFxQWq1SqLnh56RqMRRqMRJpOJHwDqA9FoNMJqtcLpdMLj8WBhYQEejwculwsWiwVGoxEajQaDwYCvrdfrYbFYWPyyHXgYIvpHMi6M20pepxU7Mel6tGKqofHnDnfVn4vq+BuNBnK5HI6Pj/HmzRvs7e0hkUigVquh1+sBwMh9mUwmGAwGGI3GkbBcq9XCbDbDbrfD4/HA7/fzg4uiprm5OWi1WvR6PXQ6HQwGA34Q0MNJRP8wRPSPhFZzdd86KYn1mA8oCV+j0Yyskna7HTabjVfGbrf7oMw9idRoNPK+Wn3Y0CpfrVaRyWRwdnaG4+Nj3lq02+2R66krPV1bfZ8osrDb7Wg0GhgMBtDpdDCZTPygAH7fJnS7XTQaDQyHQw7r1RZfYXpE9I+EhEgiGU80fa6EnvoQmZubg91uh8vlgtPpxNzcHG8pHlJ9Z7PZMD8/D4/Hc+N6RK/XQ7VaRTabRTqdRjabRa1Ww2AwuHGf6r+lCIh+TfT7fY6MaG9vs9lgtVp5RdfpdGi32xwFDAYDWCwW3koJD0NE/0jUVX7S7+nPPtdrAb9n281mM8xmM6+MtIJOc2Sn1+s5a7+ysoJYLIZAIACHw8EhOb1mv99HvV5HsVhEPp9HpVLhIiB6bfp+2sNTJh74mPug7QIJV6PRwGAwwGw2w2KxwGw2Q6vVot/vw2AwoN1uo1qtYjgccrKv3++L6B+BiP6R3Occ+ku8JvBxFaXjsmnP6K1WKwKBADY2NvDdd99ha2sLoVAIDodjJCSnhFqz2USlUkGlUkG9Xke322Uh06qtflG0Q/emJjw1Gg3/Oa3qFCFQ/sBgMKDT6aBarfIWw2azjfT6C9Mjov8MjAv9a5SpXl1dodfrod1uo91uc7h8X+bm5rC4uIi1tTU8f/4cz549w+rqKjwez43jMDWRV61WUa1W0Wq1OHlH3wOMJhlplSdx0z3S99Kf07aIjug6nQ7K5TKMRiM6nQ5qtRqA36MNt9uNTqcz8rM+NEk6q4joH8kf8WEjEdJ+t91uT9VOazKZsLCwgNXVVXz//fd4/vw5VlZWJgoe+H0/32w2UavVUKlU0Gg00Ol0RsRGYqeth8lkgk6n40iAVniq3KN/qz4s6PftdpujjU6nw6u+VqtFIBBAp9ORZN4jENF/JtQM+5eGzulrtRqq1erU5/Rms5lX+Z2dHayvr8Pn800U/GAwQKPRQLFYRDabRbFYRKPR4FWefmbKyFssFjgcDrbWoocDnSyQ4NUv4OPDczAYcAGQXq/n6r+5uTlYLBbUajWObAhZ5adDRP8Z+ZI15HTN4XCIer2OUqmEQqEwklC769+qe2AK7aPRKGKxGPx+P8xmM4CboXK320U+n8fFxQXOzs6QzWbRbDZvvIZOp4PFYoHb7YbP54PT6cRwOESlUuFKPrr+eMHRcDjkhwj9ularQa/X8zm9xWKB1+tFvV6/IXphOkT0n4GHHJU9lE6ng2KxiHQ6jUwmg1Kp9EnRq/em1+vhcrmwtLSE5eXlkRp7WonVrrp6vY50Oo2TkxMW/fi5PB27OZ1OBAIBRCIRuN1u9Ho9pNNptNtt1Gq1OwuXaM9PDwE69uz3+xwlNBoNtFotFj19nzAdIvrPxJcKMcdX3larhcvLS5yfnyORSKBYLI4k1D6F2+1GKBRCNBpFIBCAzWa79Xvb7Tby+TzOzs5wcnKCZDKJcrl8Y5U1Go2w2+3w+/1YXV1FPB6Hx+NBo9GARqNBpVJBsVi89T0ioau/JjH3+330ej1O6lH+otfriegfiIj+CdHtdrnR5uTkBKlUCuVy+d6idzqdCIVCiMfjWF1dxeLiIof1wMdCI+B3sZVKJVxcXODk5ASJRAL5fP5GwlCj0cBsNsPj8WB5eRlra2vY2NiAy+VCpVJBq9VCJpNBOp3+ZAGRWsRD30PFP/1+n1f9brc79WmF8BER/TfKuEPNcDhEuVxml5zj42Nks9l7W2OZzWYsLS1hZ2cHz58/537527rVGo0G0uk0jo+PcXx8jFQqNbF1V6fTwWazcY4gHo8jFovBarXCZDIhl8vB7XZzlZ9Op7tRxaf+zNS0Q4JWHwSDwYDFPxgMRPQPRET/BCDBn52d4eDgAAcHB+yScx9MJhP8fj82Njbw/fff49mzZwiHw3A6nQA+rqxUTHN9fY1arTZitnnbNkKn03FoH4lEEA6HEQgEOAnncrm4ks5kMt2r55+Er0Jhv2rYIQU6D0NE/41CK/zV1RVqtRoSiQTevXuH169f4/DwELlc7l5eeHq9HvPz81hZWcGzZ8/w7NkzxGKxO73xB4MBarUaMpkMLi4ucHl5yQUydG8kOErgLS4uIhAIYGFhAU6nE1dXV1xaS33ydNY+fj4//jPTzy1GGV8GEf03hpq4o+O5i4sLvHv3Dr/88gt2d3dxfn5+71XebrcjHA5jZ2cHz5494yIc1dl2PMHWarVQKpWQy+VQKBRGfPfGBWu1Wrkffn5+notqhsPhSPce1eNPql4kSOTjoT1BGf1J7jrC/RHRf2OoKzwJfm9vD69evcK7d++4f/0+oS3ttcd979QzeXpNel1KFmYyGWQyGZTL5ZHknfq6VqsVXq8XgUAAfr8fLpeLPfVuE+RdzUlqpyKhWmVRW7HqxiNMj4j+G2F8hadE2t7eHn799Ve8efOGzS9vS4SpaDQaOJ1ORKNRbGxsYGNjA8FgcGQ01ThXV1eoVqtIpVI4OztjG65Jr0cdeoFAAKFQCEtLSyNTcNSz916vh8FgwMk3nU43Usk3/oC4bb+u9umTpZYwPSL6b4TxkD6dTmN/fx+vXr3C69evcXJygkKhcO8ae71eD7fbjXA4jHg8jkgkciOsB27WAdBrn5+fI5VKcYfbpOtTkU8oFILf74fdbudVmpqB6vU6arUal+6qpxKTQnXqGhwXPrXg0nZBRP9wRPR/IOPJLHWF39/fx2+//YbXr1/j6OgIhUJhqiEWZrMZ8/PzCAQCWFpagtfrZUea23oErq+v0Wq1kM/nkU6nRxJ4ajvv+PUDgQC8Xi+sViu3xjabTZTLZeTzeRSLRW7FpQcICV6106L3gCIDtamGHg6qu47s6R+GiP4PRP3Qjq/wv/zyC169eoWjoyPk8/mJ9e63QRl7v9+PpaUlzM/Pj8yWn5Q5B34v8a1UKigUCpzAU6F/p9VqOWO/tLQEn88Hu90OvV7Pbr3lchmZTAbJZBKXl5c8WJOy8mS2QWYg5JZDEQLZatOXup+nPb16X/IAuD8i+q/MeMgKjCbtKKQnwVODyzTz5SnsjkQivNe+LRRWu9uKxSIuLy+RzWZRrVZHym3VB4W6lw8Gg3C5XFzkQ9HK5eUlEokEzs7OkMlkUK/XOWxXffLMZjMcDgfm5uZY9CaTidt3qcZeDevJx094GCL6z8Rtq+c4438/HA5RrVaRTCaxu7vLSTt1hZ/WAov28rFYDMFgEHa7/UbvuwpNvj0/P+cEXq1Wm9izTm250WgUKysrWF5ehsPhGNnLTyrfbbfbI9cjow2bzQaXyzXSP1+r1fh4jpKIFNIbDAa20xYehoj+kUxqFb1N+JMET5V2u7u7+O233/DmzRucnp6iUCjce4VXz851Oh373lGCzWazjbz2+ANKnXz74cMHJBIJVCqVidbbTqeTa+xXV1cRCARgt9t5L1+v15HP53F+fo7z83POC1ACkl5Tq9XCZDLBZrPB4/HA7XbDZDKh2+2yTx5Zamk0GjbnoNBeRP9wRPSPZJIZxH3ssmhFPDs7w9u3b/Hrr7/i3bt3ODs7mzppN94r7/F4+Ozc7XZzKKyG1uq/qVaruLi44AEW6XQa9Xp95DU0Gg2f+8diMcTjcYRCIXg8HphMpht7+fPzc2QymVv7/VXve7fbjcXFRVgsFnS7XRgMBj7yo9JfErw6Jkt4GCL6KZkUxqvDG++qFBsOh+h0Omi1Wtwtd3BwgFevXmF3d5dX2Gmsr1SMRiMWFxcRDAYRDAYxPz/PxTLqvdP9X19f86jr9+/f4/3797dOvjUajfB4PIhGo1hfX8fKygoWFhZGCn1arRYKhQL3+t/28KLjN7Ly9nq9LHr6/l6vh263y9sbCu9llX88IvopGRd7p9PhhBOFoTSPTT3m6vV6bCGdzWZ5NNTBwQEODw9xfn4+0Uf+vhiNRgQCAcTjcWxsbLCr7W217dfX16hUKjg7O8O7d+/w9u1bHB4eolAoTHSlsdvtCIVCWFtbw9raGucK1J+RZuxlMhlks1lO3k16D2lgh8vlgsfjgcfjwdzcHGfuaWTX3Nwcr/4yuPLzcKfoZ9V8cDzpNSlcJyeXQqGAYrGIdrvNgyDtdjuvsFSV1mw2USqVkE6nkUgkcHJywsYUNDjioV1jer0ei4uL2NzcxI8//ojt7W2EQiFYLJaRn4VaVulo7vz8HLu7u/jll1/w9u1bpFKpiUeDdrsdwWAQGxsb2NnZwcrKCrxe740oguyqy+Uy99JP+gzRKu9wODA/P4/5+Xku4dVqtex/rybu1IeLdNc9jjtF/9g3d9wwQTWP/Fz/4z51rfGikvteazwhN/77RqOBVCqF4+NjXFxcsGOrw+HgIyxa4ckuikLf8/NzJJNJ5HI5VKvVqfbv4xgMBng8HsTjcfz000/405/+hK2trRsGGcDvD/FarYZsNouzszPs7+/j7du32Nvb4+Th+EmB2WyG3+/H+vo6vvvuO2xubrLjznjU0+v10Gq10Gg00G63b/jTq2G90+mE1+vlRh2n0wmNRoNutzsy7JKurU4HVrdTwvTcKfrxks1Zhz7YlUoFqVQKHz58wP7+Ps7OztBoNGA0GuFwOHilHw6HaLfbaDQaqNfrXPhSLBZRLpfvbYBxGwaDAT6fD+vr63jx4gVevHiBzc1N+P3+G7PlqZHm4uICR0dHeP/+PQ4ODnB0dIRkMolSqXRDSFqtFh6PB7FYDDs7O9je3kYkEoHL5Zp47Nfv93m7Q+42KlRR53A4sLCwAL/fD5/PB7fbzeOq6Fo0GKPX66Hf70Ov17N5BtlqCw9DVH1PSOy5XI6Fs7+/j8PDQx7iaDQaYbFYuHecRNBqtdjQsdPpoNfrTeVrB9yMaPR6PTweD9bX1/Hy5Uu8fPkS29vbCAQCI4IHgGaziUwmg+PjY+zt7WF/fx9HR0c4Pz9HoVBAo9GYuHLa7XYsLS1hY2MD29vbHNarTTVqcQ8114xbWdH2yGAwcCXf8vIylpeXsbi4CKfTyYMpaZJNu91Gq9XiB4hWq2VvvPESXWE67hT927dvv9Z9/OGoK9dgMIBGo4Hdbmd3GSo4OT09ZbsqtZCl3+/z2TPVhZMQJq1606IK3mg0wufzYW1tDS9evMDLly/x7NkzLC0twWq18t59OByi2WwimUxif38fb968wbt379hqi0pjJ2E2m7GwsIBYLIbNzU3O1qv1+6ro6eckUaqip5FVTqcTfr+frbdDoRC8Xi/nHigyoiSe6n5LoT89VET0D+dO0f/TP/3T17qPbwI6v242m9DpdNjc3MSf//xneL1e5PN5HB0d4fj4GCcnJ9xr3mq1RgTd7Xa5g+xL7D0pS7+1tYUff/wRL168wPb2NpaWlmCz2fh1u90uKpXKSKXf27dvcXJywonHu+7NbrdzEU48Hp8YQairPDnVttttDtNphTebzbDZbOyWu76+jtXVVQSDQa4joCiIRmfRvDxa7XU6HW8d6MEyfh/C/bhT9P/yL//yte7jm+T169fI5XIIBoMolUpIJBJIp9OcgLvNw50KSz4H1Jii0+lG5s+R4Le2tkaq7mi1LBaLNyr9SPCT7lvdPlDDTjgcxurqKkKhENxu90S3HUpWklipZh4A18m7XC74fD6srq5ic3MTGxsbiEQi8Hq9mJubY7NLGpBJOY9arcYz84xG48jsPhqeKTX40yN7+jvI5/P413/9V9jtdl6F6vX6o7Lt00A96263m4tYlpeXeY9NgqdmFaqKy+fzOD4+xuvXr/HLL79gf38fiUQC5XL51tdSHwQ2mw0+nw/hcBihUGhkIIbaGku/b7fbqFQqKJVKXIGn0WgwNzcHm83Go7A3NzdHtgoWi4UHWlDNfbFY5Os0m03Of9Aor2azyacD/X5fRP8ARPQTUFexZDL51V+bWk7n5+exvLyMUCjEfev0e0qCqWKkDP3x8TF+++03/Pu//zvevn2LZDI5lVX2wsIClpeXEQ6Hsbi4eOdADDLRzOVyyGazPHGHegB8Ph9WVlawvb2Nzc1NHqNFuQfKe1AdQ7FYRLFY5Mm4lBSkVb5SqaBcLqNarXIJsIT30yFHdhOgvf3XnJdGJpNOpxNut5v74aPRKKLRKDfPzM/Ps6W0eg5Pc+MSiQRev37Ngr+4uLh3L77aUBOPxxGNRkfMN9TvAz6W3qqeesViEZ1OByaTCfPz84hEIlhfX8fGxgZWVlawuLgIh8MBvV7P5+7tdhvVahXFYhH5fH5klaeEHbXsFotF5HI5lEolduuh1V766u/Hnap+aEmoMB16vZ6940ngS0tL7HoTDAZZ8FTeO74vbzQaSCaT7Jo7reCBj734y8vLiMViWF5ehtPpHCl9Vb3xKXeQSqVwfn6OdDrNuQ673Y5AIMDNOdFoFH6/n1toKf8wXp5cLBZHJtPSdoKm51JEUSwW0Wq15Lz+AczmUj4Fk1pSH3Ot8WvQSKhQKIT19XXe8y4tLcHj8XCxj+o/p94XlQOTTfZvv/2Gvb09JJPJewl+vC2XpsP6/X4+TgN+3z6o5cj9fp9PB2gKTiaTQavV4tA+EAggHA7zoEyHwzHy0BoOhzyWOpfLIZ/Pj5yI0Ex7en3aAtD3jedW7utpMOuI6D/B51xJJgne7/cjHo9jZ2eHZ8WHw2EWHAn9tg9yp9PB5eUlDg4O2IAjkUjcew+v3pPZbIbT6cT8/DwnDydB1l6pVApHR0f48OHDyBQcqqf3+/08AMNms/GwC7VtllZ51WO/0+mMVN3RQ6Lf76NWq6FUKqFarX7y2FGYjIj+D8LlciEYDHJN+87ODtbW1tjTbnwfDXy0hqY6gOFwiGKxiKOjI7x584bP4SuVytT3Q8d0i4uLvCqrOR01W1+v15FMJvH+/Xu8e/cOHz58YEssk8kEq9WK+fl5LCws8MQbaqaha1A2nswzc7ncyCqvuuGqDzwqa65Wq3ySQlZd9/ExEET0Xx2DwQC3241IJILt7W18//333Lnm8/lgsVhuTaCOD4Go1Wo8DOPdu3c4PT1FsVic+p7UvTz56o031AAfG3aSySQODg7w5s0b7O3tsQ/A1dUVJxlptXc6nTy8ku57MBiMJO9I8Kpj7m0Rluq0Sys+FSWJ4O+HiP4rYDKZYDab2dVmeXl5ZIWPRqOYn58fycaPu/GMT35pt9u4vLzE0dER9vb2cHx8jHw+P5WBJn0vGWSovnqqmSYl7Wq1GlKpFJf0kpcfhfXkbEu1BS6XCxaLhRN3tI/vdruo1WrI5/O4vLxELpdDpVLh5N14ia36M1GkkclkkEgksLy8zH350mt/P0T0Xxir1YqFhQUsLi6yq00kEsHq6ipbTk1yq71r1SIjS2qPpVr6+zrujF97bm4OPp8PkUgEkUiEK/zotRqNBvveffjwAbu7u9jd3cXp6Sny+Tw6nQ70ej2H9k6nEy6XCzabjRN3VJLc7XZRrVaRzWZHHHaoD0Btbb6NarWKRCKBQCCAYDAIj8fDr6X+W1n5JyOi/0KQ0yvVm6+trSESiXChzeLiIhYWFuBwOPjfTDKiHP81Od4kEgns7+/j/fv3PNDyvkkt9XVMJhMX40SjUSwtLfE9NRoN7iw8Ozu74fRTKpV49LTJZOI+eZfLBafTCYvFAp1Ox22yVHWXz+dxcXHBDUuFQoGTcvcxyajVamyxnUwmsbKygmAwyKIX7kZE/wUwGo1wOp0jibpnz54hGo1yJttkMt36IZ3kjU9/Tiv87u4u3r59i+Pj41tnx6vXmCQkk8nEFXNra2tssUUe+Nlslm2xqbMwkUiMONxeX1/zdFpV9JStp/N1ctWh6TnklptOp1Gr1Thjfx+ur6/56G5Sa7AU6dyNiP4R0MAGSlJRCa1qL/X8+XM8f/4ca2trE91sJk2OnZRAo3NxmlP/66+/Ym9vDxcXFzeca8dRBU/3TCF9LBbDd999h7W1NXi9XlxdXSGbzSKbzeLk5GSkjZg6C1WRkX89Da0gwev1enS7XZRKJQ7p8/k8MpkMj8yist1GozFyJn/bQ0r9816vh2azyXkAKdK5PyL6B6LX62GxWOByuWC1WvmIjZJiKysrvMLHYjEsLCyMeMoBN/3eJq1Og8GAj7XItZay5qenpzf86e+yD6MGHo/Hww016tbDbDZzSe3R0REODg5wfHyMZDLJIbi67wbA46YsFgucTicX4PR6PXbDrVQqyOfz/DApFAoolUosWhphNa1wVftxEf39EdE/AJPJBJfLxbPcPB4Ph+omkwlerxcrKyvY2tpCLBYbOXf/lD8+raCUMS8UCjwt5v379+xNT3vh8Q/7+AOAHGRNJhOfHIRCoZGafjK5bDQanBzc29vDyckJ0uk0KpXKrdsHquJzuVxwuVyYm5vDYDBAPp9nb/9cLodcLjfSMkvhPImdXHPGf4a7oHoFOZ+fDhH9JxhfOY1GIzvKUE35wsICi5728zTrbVzwqj/+OLTvbTQa3FueyWRwdnaGDx8+sAknhcR3iYOOzpxOJ2fUFxcXEYlEEIvFEIlEEAgE4HA4cHV1hWKxyM061Hufy+VQq9VuTRDSLDqq4qOptdReqwpeNcWgoZTAaNHPtCu2HNE9DBH9JxgXfCAQGDljD4fDcLlcvK+nlc9ut3NzCUEr7/j1B4MBms0mCoUCUqkUMpkM8vk8h8TU0JJKpVCv1+/s/qNTA8rI00pOIb3f78fy8jJ3qA0GA2SzWWQyGezt7eHNmzfY399HNpu90zeAJtSQ4KnOgLruCoUCLi8vUSwW2Q671+vx0Z26QlNp7rSh+l1FPMLtSGvtBCa11ppMJgSDQTx79gw//vgjnj9/jtXVVXi9XpjN5hF7b71ezxNWb4PcZmq1GqrVKkqlEoubstr5fB71eh21Wo1XytugRBqV0oZCIayurnJ3G9XSk+8fncNTlv7w8JBD+kmCH494VFdb6rm/urrirPrl5SUKhQKH8uMPKmrg0el0I2fz03jfSWj/MKS1dgLqh0ir1XLb6/b2Nn7++We8ePEC8Xj8xlinSZn4SdBqmE6nkUwmkclkkMvlkMlkkEqlkEqlOCT+lOWzVqtl8ZHxRTgc5kKb5eVleL1enh9PKyvw+zk8Zenfv3/PIf2kFX5SY47P5+NeAcoJUNFNPp9HrVbj1X0SJPKHDrKYNgcg/M5sLuWfQP0QRaNR9onb2trCTz/9hK2trRvmEuMf2PH9JrnFksvMxcUFt6RSdpwcYaiZ5FNQWW8wGMTKygri8Tjfq8/ng9frhcPh4PZYFTLdOD8/HxlcWavV7nxNk8k04mrr9/s5rK9UKshms8jn83c67ao8JvNOjr8S5k+HiP4OFhYW8Je//AU//fQTl3yurq7C7/dPHHOlJqNotVdbSAuFApLJJBKJBAv+7OyMjTbJ7PE+lXVkUrGysoKNjQ1sbm6y4BcWFmC327nmfRzqwadJN8fHx0ilUtw0cxtqkpKSgU6nk6faUB6CVvgvDUUtktCbjjtF/w//8A9f6z6+Ccg+mubSra+v4+///u+xsbEBp9MJu92O+fn5ieEoFdCo3uw0oYWSdOfn5zg+Psbp6SkSiQQymQxKpdLE1XXSOC4a/Ejz5zc3N7Gzs4OtrS2srKzw3n28AGjczJLMM6nSjsZjq0KdtIen111bW0MsFoPX6+X2XqqO+5LGoer9kFEoHROqCVLZ49/NnaL/53/+5691H98EJAraZ1LBCdWQ0xdBHy7qHKNadQrPm80mJ+JoUu3p6SmSySTbPd2ViR/fLthsNvad29zcxLNnz7hLj/ILk5KvqgiGw+GNefSZTAbtdvvW11YfNOR3R9EOhfOqKeaXZm5uDktLS4hGowiHw5ifnxdX3Cm4U/TPnj37WvfxpFBru8nyqVQq8dEXebjR/py83KkibVKxy/jKqiYFLRYLHA4HFhcXEYvFsL6+ju3tbfaP93g8I/kFNURX+8ypHz6VSvEsO2qcuW3/ra7w6+vrWF9fRygUgslk4mM5mgXQbDa/SvLX6XSy4eb45B1AVvpPIXv6B6B+qDqdDg+WoD16Op1GoVBApVJBrVbjopRmsznx+Oq20lm9Xs9iD4VCWFlZwfr6OtbW1kY64m47Wh1f4cl04+DgALu7u3j//j0uLy/RbDYnvj5l6QOBANbW1rCxsYFwOAyLxcJmGupor/u29k7L+PujOvbGYjF4PB5Z6adAjuzu4LZS2XEL6MvLS3z48IHtqmg1p6EMk4Suon6gDQYDdDodV9RRsi4ej3MFIB3DUQWceg31SI7+nLzlaKbd69evsbu7y2KdNK1WzdLHYjH2qzcajajVakgkEjg5OUEikeAxWV8DGge+uLiIQCAwMlBz3LxTmMydopc3727IYCKdTrO5BI2t7na7PLjyPsdJtGen1lQylgyHw1hZWcHKygpX16nmFMDNYZIEPZTItfb9+/d4/fo1W2tNCuvV0loy1iD/ewB8AkEz/bLZLJrN5hc1qFTfv0kmHcJ03Cl6CZluMm7d1Gw2kc/nuZru8vJyZM46MDl812q1nBg0mUyw2+3weDwjfvfkeR8MBhEIBG5YahHq6kZHh2Q8WSwWkUwmcXh4iN3dXbx79w4nJycoFArsG6/eC0UYCwsLWFpaYq/64XDIOYmzszMkEglks1lui/0amM1m+Hw+dthVIx16H4RPI3v6R6Bm7VV3VuBjKS9BH0ga2zw3N8f1+bSy09iqcDjMH2yXywW73c7GG3dB8+HJz45q+Y+Pj/HhwwccHh4ikUiMZNn1ej1bXc3NzXHr7cLCApcYt1otFAoFvl46nUaxWPxqiTvgo3knRT4PsRkTfkdE/whoRe31ejdm0NOZP4Xd6qrucDjg8XjYF56ss9TfU+ksecUD4HJctRCIRkP1ej0eskn96+l0mo8Jz87OcHl5yScHZHxB/6WafLfbDbfbzc1CdOxYKBSQzWaRy+U4MXnfKjgy2lBzDWpb7X0gF2HqKaBGp0kDQIS7EdE/AioDndQkoh6V6XQ6GAwGWCwWuN1u3qtHIhGEw2GeJuNyueBwOGCz2WC1WkdWMQrX6YscY+ih0+v10Gq1eBiEajxJ3W7UjkuutWazGVarlQVPjTgmk4nzFeVymVd5qi24b5Zeq9XCarXylB6z2czFT/V6nW207hMt0NQcv9+PYDA4MklX7LGmQ0T/GRi3uSLB0ypEzjJer5fr5NfW1njForJZk8kEnU7He3QqyaUVnCa6kntsq9VCp9Nh0ZPxZKVS4dHRNAlmOBxibm6OE3Vqxx313VO+gOoOyNJKrbS7bzivzucjM1CbzYZ+v49CoYB0Os3bhPtck04TPB4P3G73yCRdEf10iOgfgRq2GwwGDsVpn0x/rybHwuEw4vE41tbWeIqr0+m8cdZOe/N6vc5mFKq/XKlUQr1e55Jftey30+mg0+mwtZVOp+MhFJRHILGTgMjEslwuc1ktdf9NW1pLofjy8jL3BYTDYdjtdrTbbWQyGezv7/PPST/DXdhsNn5QqcMzhOmRd+4RkKhJ8AaDgY/SSPS0sqpOsTQIgmrGaXtAWX6q1y8Wi7i8vMTFxQXbPVPbqmpMMd56S9l4yh9QopBm1NHrqyaWnU6HPe2oH56aZ6YpuiEfvmg0ip2dHe5KXFpagsViQbfbRTKZhMFg4Aim2WzeKXrahthsNn7PZHV/OCL6R0DiIrHTl+pNp+7tB4MBut0uD22kD77ZbOawnkY+lUoltso6PT3FxcUF0uk0N+jQnl4Njakhh7LwanLQ7/djYWEBHo+H9+40Qqvb7SKfz7N7LYX00wqevAdCoRB2dnbw8uVL/PDDD4hGo3A6nTAajRgMBjCZTHwikM/nUSwWuVFp0jXpZGFubg5Go5FPRm5zDxbuRkT/CNSV3mg0wmQyjdhmEcPhEO12G+VyGclkkpNkuVyOG3qodpzacPP5PJe5np+fI5vN8kTX24w1yJmWKtbID4+OAL1eL78eiWcwGPARHm0jaEb8tO2xFosFi4uL2NjYwE8//YTvv/8e8Xgcbreb3xeKBOh4MpFIIJVK8fGfWuSjPjz1ej3/WkT+OET0j4CSdeMhPn1wKbOvHrOR+NPpNGfrVQttigToiIzGPtFwx9vug87aXS4XlpaWsLq6yg0p1GPvcDg4mUdRBVUP0ox4cuzpdDpTVdlpNBpe5Tc2NtgJWBU8oR5bUuShTrmh65G41aPR8QeDMD0i+kdCoqeVaLwyTu2zbzabqFarKBQKHK7Sl7rS09FbvV5HvV5Hu93+5AQbNVu+urqKzc1NbG1tIRKJjEzVoXskIZEDLz1kKFfwqcTaOHq9fsQFOBAIwOl0csRDZpjq/VKugxJzk8wwqACK6gUoqTgcDsU844GI6B/B+BGdKniyeaYCFArFm83mjejAaDSyOKjQhva4FMrf9vpqwo6cfTY3N7G9vc1NMpNq9WnLQbPq6CyfTgSmhe5DTbipzj3jY7bppGFSIlJ9b2noJeVBcrkcW4C73e6R7xXuh4j+kVCyjo7uaBUFwOfstOKPl+WqR37jM+vo36nhrgqdDKj97jRgY3NzE9FolF1qaf8OfCwoUsdFkwcArfIPDZ/punRc2O/3R/rcCXrtcrnMwy9oLr36HqgPqWaziVwuh1QqhWQyiUAgwJGCMB0i+kei7uvpS6vVssgnCR7AyD6/3++PeMCTQOla6mvRlzowksw1qOc9Foux4NXZ8LTCjg+TVN1rH7pnpo6+YrHIzUdGo5Htu+hh2O12kcvlkEwmuUGJcgjqScT4+9XtdnkgRygUQjAYhMPhgMlk4vdIjvHuh4j+EajZe5PJBJPJxEUu9AG+74dwUhceXV/NYtNrkeB9Ph+Wl5e5/TYcDsPr9fJxnCp4KvipVqvI5XLssZ/JZEaER30D06C2GR8cHECv16PVavHent6Xer2OZDKJvb09fPjwgQ05x2fkjb8nNMAzlUohkUggFovxSDHZ20+HiP6RUMUdVbvZ7XZexSm8v80ZR0VdxdWqPpqKazKZOJyl8llq2gkGgwiHwywCi8XC0QblBLrdLlqt1sgKTy2yuVwOjUZjpEjoPvesQlN60uk0NBoNF/uEQiF4PB6YzWau+CPb7cPDQ2Sz2XtvKer1Oucf8vn8Dccf1UhEuB0R/SOgMJsGOHo8HrRaLV6l1U6yu/zdx0N7Og0gkVMDDk2Fpao6r9eLxcVF9rin+nmNRoN+vz8idqrJpyx9Op1GKpXikt52u82rPN3DXUM2xqGBm7SFIH//8/NzeDwezM3NYTgcolwu4/Lykgd6VKvVqRKHrVaLTUd7vZ743T8AEf0jINFbrVZ4vV4sLS3h6uoKZrN5JFvebrf5XPw+4qciG3KwoTJamknn8Xi4rJbO+smxV23zpb566pQjX/p8Po9cLsfDNZrNJofXasQx7WpPdQj9fp9bfDOZDBwOB3fYqY7BVEY8DWozk6zoD0NEPyXjHzSqgFtYWECr1YJOp4PVaoXZbB4pwyUPOUrsjaN+iOnfUUhPhSw+nw8+nw8ej4fNNaiwh1x8qIyXpt7SMVcul+P22Gq1yqW8dDSotgk/dvWknAbN6ysWi1ygQ81Ad427ug2DwcDbGjWqEaZDRP8IaKW32Ww8+IHaVqkxZNyokYpe1FFMk7zt1NeglZ8SeJQwBDDSZacWAJVKJRQKBeRyOR5EQUMw6UhNPRZU72fa6bG3Qb0BnU7nxpHhtNfWaDSw2WxcvktTdyedbgh3I6J/JGR95XQ6cX19DZPJBIvFApPJxMdUtM9VS3IB3Fjp1D9Xi3Q6nQ6vyq1Wi6/d6XRGmnTq9Tqv7tTIUiwWuZiF9sG3Hcup03o+h+jpmg+11FK3FxqNhusRYrEY22WJc870iOgfAe0tySTj6uqKj/C0Wi2XubbbbS6lVUNo9WiMylTVarV2uw2j0YhKpcKrOyXnqHRVNdkg4wwSO63sqtjvM/DxW0yOGY1GeL1ebiIiz38R+vSI6B/JeOKN6Pf7qNfr3MZKZakU8pPA1f8CH0NrasNtNptc1399fc1GnJQzUKfhkmMODdloNpucWFNzCV9b1OMlytOcCAC/5zh8Ph+i0Sji8TiWl5fhdrulKOeBiOgfyfj5ulqdp56z09/R13h4TcKnQhoAHCmoxphUTUchPmXpyZG32WzykA2agvupU4Ov8f6ov79PzQJ9j9FoxMLCAuLxOLa2thCPx+Hz+T7pDCzcjoj+kajlreN7cFppKXGmWkNNGoIxadIMZcJVe2uz2QyDwcDTazqdDprN5sjKTqv7eMLwawqfHnZqodJ9UAVP/fkvXrzADz/8gFgsBqfTKX73j0BE/0jG9+DqpFr6L4mRRH/fs2kqnVUjCQrxKdxXHzSqSea4wFSXmccKXw3Vb/t7s9nMpiK0VRlvqrkLrVYLj8eDjY0N/PnPf8bPP/+Mra0tBINBWCyWR93/rCOi/wyojTW0MlOyjvb7VqsV3W6XBTHJ/UYtOqFae7LgIstqaselkwHaPuj1ehiNRhY9RQfT+svf9+dVofukKkK1vVav17NHABXkUDQy6TpUn+D1erG2toYXL17g5cuX+O6777C0tDQS1ste/mGI6B/JeNMNhbEkuqurKza4oFWfVmQ15KUPPCX71Jp7OqM3Go0jPerjwzbGtxaNRoNf81MmHJ/itoeG2WzmKkGqDqSJPFSrQElNtVCIko3081PhDRU6RSIRbG1t4fvvv8f29vYNwd/3voWbaD6xAnx7ZzffGOqxnGo9TTXitVqNR141Gg0e8EB7e/rQq6YaVMZLX6oVFz0caJ+smlHQ61I1HhXlkE8++d8/1nJKPaakIZeRSITn7VFxkurD12g0eOYfOfuSvTaAEdedSCTCk3ppJLca0ssKf28mvkki+keiWmKpXW3qCkwPA7XIhurjSXyU6acWXVXsqinkuAMNvSYd3dGZPXneZbNZtsymB496rDeN+K1WK1tnk7W23+/HysoKVldXEQwG4Xa7eYWnrQr10ZfLZaRSKe7uu7y8RK1Wg0ajgdvt5kEg6jhuMvIkpJNuKkT0X5pJZaxqTTs9CNThFNR6qx7xkeDHHWAnleuqzjzjAyxLpRJKpRK701B5biaTQSKR4Akz9xlkQdVw0WgUkUiEh3R4vV6EQiEsLy/D5/PBZrPd6nVHJhs0tKNQKKDZbAIAO/guLy9jaWkJLpdLjuUej4j+W4AEOn6cNn7G/5jr06pPlYDqPr9YLOL8/BxHR0c8brrdbnOFIDAaPlO77fz8PGKxGNbX1xGPx9l7z2Kx8By8SWO0xyG/O9rqkGsQ+es5nc4bNfXj9yTcGxH9rKGG7nT8R+2uZ2dnSKVSKBaLnxS9TqeDw+FAKBTi8Nvr9XL78LSNLrc19NDphfDZENH/ETxmD/qQTrT7XLNaraJcLqNSqdwYKUXn+OoJgUajGZldPz8/PzEaGRfyJDPP+yJ798+CiF74Hcr836f5hlC3HrIaPxlE9LOGmlgEPm+/+bg190NW8du87mV1/2yI6IXPy+dIrkkY/0UR0QsfuW21vQtZiZ8cInphlIfU44vgnxQT/2dJ7f0MIwKeTSQNKwgzhoheEGYMEb0gzBgiekGYMUT0gjBjiOgFYcYQ0QvCjCGiF4QZQ0QvCDOGiF4QZgwRvSDMGCJ6QZgxRPSCMGOI6AVhxhDRC8KMIaIXhBlDRC8IM4aIXhBmDBG9IMwYInpBmDFE9IIwY4joBWHGENELwowhoheEGUNELwgzhoheEGYMEb0gzBgiekGYMUT0gjBjiOgFYcYQ0QvCjCGiF4QZQ0QvCDOGiF4QZgwRvSDMGCJ6QZgxRPSCMGOI6AVhxhDRC8KMIaIXhBlDRC8IM4aIXhBmDBG9IMwYInpBmDFE9IIwY4joBWHGENELwowhoheEGUNELwgzhoheEGYMEb0gzBgiekGYMfSf+HvNV7kLQRC+GrLSC8KMIaIXhBlDRC8IM4aIXhBmDBG9IMwYInpBmDH+P8JiC8w21srQAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 60\n", "Starting forward run...\n", - "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Current iteration: 61\n", - "Starting forward run...\n", - "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Current iteration: 62\n", - "Starting forward run...\n", - "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Starting adjoint run...\n", + "Calculating gradient...\n", + "Current iteration: 61\n", + "Starting forward run...\n", + "Starting adjoint run...\n", + "Calculating gradient...\n", + "Current iteration: 62\n", + "Starting forward run...\n", + "Starting adjoint run...\n", + "Calculating gradient...\n", "Current iteration: 63\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 64\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 65\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 66\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 67\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 68\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP0AAADnCAYAAADVeFABAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA1AElEQVR4nO2dyXIb2ZfeP8wAMc8zAXCmSImUWFWSqhfuDocX/i9642dweOeNV/0AHeGtX8FL77zoJ3BE1b9LpRIlUhQpDiDmeZ5HeqG4txIJkARBlkosnF8EQpRIZiag/PLee+4535FcXV2BIIj5QfpnXwBBEF8XEj1BzBkkeoKYM0j0BDFnkOgJYs64TfRX9Po2X/1+/2owGPC/7+/vX/3tb3+7kkgk/KVQKEb+fpeX+Hf/9re/XX348IGfbzAYjJyfXt/kayI00hPEnEGiJ4g5g0RPEHMGiZ4g5gwS/SNFIpH82ZdAPFJI9I8UqpkgZoVETxBzBomeIOYMEj1BzBkkeoKYM0j0BDFnkOgJYs4g0RPEnEGiJ4g5g0RPEHMGiZ4g5gwS/SOFcu+JWSHRP1Io956YFRI9QcwZJHqCeED+734Cf/tf/w//9X//imKj+2dfzkTkf/YFEMRfhVytg//xf96jP7zCUaoKq/YY//O/PPuzL2sMGukJ4oFo9wboD3+PtdTa/T/xaq6HRE8QD4TfsoD/9h+WIJEALoMa//0/rv7ZlzQRmt4TxAPyL/95E//jP61DKf92x9Nv98oI4pHyLQseINETxNxBoieIOYNETxBzBomeIOYMEj1BzBkkeoKYM0j0BDFnkOiJmaHy3scJiZ6YGTLyeJyQ6B8pJDhiVkj0jxSaWhOzQqIniDmDRE8QcwaJniDmDBI9MTMUV3ickOgJYs4g0RMzQ9uGjxMSPUHMGSR6gpgzSPQEMWeQ6AliziDRE8ScQaIniDmDRP9IEW+XSSQSSKV/3H+nTCajLbq/CCT6vxDD4fAPOzZl3/11INE/Uq6urkaEOBgM0G63+d8lEsm9RmapVDoyc2i1WhgMBteen3g8kOgJYs4g0T9SxCO5VqvFysoKDAYDgC8jca/Xm/n43W6XLxe0Wi2CwSA0Gs215yceDyT6R4pYdCaTCa9evcI//dM/weVyjf3stIiDgTabDf/4j/+Ily9fwmg0Xnt+4vFAon+kiAWnUCjg9XqxtLQEk8k083GFwUCJRIJQKIS9vT1sbm5Cp9ONfI9E/zgh0T9imOiGwyHq9Tqq1SoajQb6/f6DHN/r9SIYDGJxcRFWqxVyufxBjkv8udD/4iNFOMrW63WkUilcXl4iFouhXq+P/Oxdo+xyuRwejwdbW1vY3t5GIBCA0Wgk0f9FoP/FR8bV1dWI4Pv9PgqFAiKRCM7Pz5FMJtFoNGY+vlKphMvlwtOnT/Hq1St8//33WF9fh81mGxP9Q2zbsfdCS4WvB4n+kVOpVHB5eYnj42Ocnp4inU6j1WrNdCyJRAKLxYLl5WXs7e3h1atX2N7ehtPp5KJkDx1a0z9eaE3/yBBP6yORCD5+/IiPHz/i8vISxWJx5jW9SqWC0+nE+vo6tre3sb6+PiJ48fmJxwmJ/pEgnkY3Gg3E43EcHR3hw4cPODk5QTabvdfevE6ng9vtxtLSEoLBIOx2+8gIT/w1oOn9I6VcLuPi4gIfP37E0dERIpHIWADvLmg0GthsNng8Hni9XlgsFqhUqrGfu7q6QrvdRr1eR71eR6vVunZmIVwCSKXSkfW7TCaDXC6HSqWCSqWCWq2GQqGATCYbyxUQPnBoWXF/SPQPBLsxv8YN2e/3Ua1WkUgkcHFxgVgshnK5PPPxpFIp9Ho97HY7nE4nzGYz1Gr1yM+w99XtdpHL5RCNRpFIJJDL5dDpdMaOyar+hC8mWKlUCoVCAa1WC6PRCKvVCqvVCpPJBI1GA7lczoV/dXWF4XDIP1/h8YjZINE/AMKRSBxd/6PO1+l00Gg0UKvVRkb4WabjUqkUSqUSOp0Oer0eCwsLkMvlY+9lOByiUqkgEong/fv3ODo6QiwWQ7PZHDueUPQymYyX5kokEsjlciiVShgMBrjdbgQCAQSDQX4+YbrvcDjEYDDgSUMymQwKhWKmz434Aon+kcLEpFAoRkQwy9qbCZFNs5VKJWQy2cjPDIdDNBoNpNNpnJ6e4t27d3j37h0ikQharRYXujC6f53o2XWbTCb4/X7UajVcXV1BpVLxc7OlRb/fR6/XQ7/fh0QigUKh4MckZoNE/wCwm519/UfDRLGwsICFhYWxqfisx9NoNNBoNFCr1ZDL5SPvpdvtolgsIhqN4vT0FGdnZ7i8vESpVLrz+Zh4y+Uyut0uH931ej20Wi1UKhWf4vf7fbRaLf5z7NqI2aFP74H4GlN6YVBMKFKlUgmpVDqziYZGo4HZbIbNZoPZbIZWqx0TVqfT4Wv5cDiMVCo1cz4AqwBstVrI5/NQqVQwGo0wmUzQ6/VQq9V8dtBqtVCpVNBsNiGTyaDX66FUKkeWAMTdINE/UuRyOX+xiPcsotdqtXA6nQiFQlheXobX64XRaIRSqRz5uW63i1KphFQqhVQqhUKhgG63y7/Ppu7ih5MQdn3sZwaDAer1OnK5HCKRCLRaLTQaDSQSCVqtFhQKBRqNBgqFAhqNBjQaDRwOB7Ra7chxv0Yc5a8Eif6RwqLaLMg1i+CVSiXsdjvW1taws7ODZ8+eIRQKwWQyQaFQjKX71ut1FAoFFAoF1Go1fk7h8mYSwui78E92/eVyGbFYjK/X2+02crkcVCoV6vU6stks2u02LBYLJBIJrFYrCf0ekOgfKVdXV+j3++j3+yOGF9Mil8tht9uxurqK3d1d7O7uYn19HQ6HY+Kama2tm80mGo3GSBLQJEFLJJKRkf26hwILELKg32AwQLVahc1mg1qtRqPRQC6Xw2AwgM/ng8FgQCAQuNN7JUYh0T9ihsMhut3unbPwlEolLBYL1tbWsLe3h729PaytrcFut3PBiwOTnU4HrVYLrVZrbF9eHMgURuvZiN7v928UfrPZRC6XQ7/fR7lc5kuMZrOJUqnEZwGhUAjdbndkpKdR/26Q6B8pnU4H7XYbnU5nZG09DaySbmNjAy9evMD29jY8Hs/Y/jcTUr1eR7FYRKFQQLVaHXvICBNnNBrNyI6C8GFxU01Ar9dDo9FAt9tFtVrlSTqtVgu1Wg0GgwEOhwOtVgu9Xg/D4ZASdGaERP9IEAbJGo0GSqUSyuUy6vX6rSO9OGFHoVDA6XRieXkZq6ur8Pv9XPDCfXbgSwAvk8ng8vISl5eXSKfTEzPwgC+7AHa7HS6XC2azGcPhELlcjtcE3FYI1O/3MRgM0O/3ebS+0+mg3+9DJpPxh1y/3/9D7b7/6pDoHwlCERYKBSSTSaRSKZTL5amq6oRTa4PBAJfLBZ/PB6fTOSL4wWAwsqavVCqIRqM4OTnhpbtCq22GQqGAxWJBKBTCxsYGPB4P2u02zs7OeNrwpN+bdJ29Xg+DwYDv0wOjSTrsT7bDQFP7u0Gi/8YRT2Pb7TbS6TTC4TDC4TCy2eyt03uh4Fkl3eLiIlwu18j2l3ht3Ol0kMlkcHZ2hpOTE1xeXqJQKIzNLORyOSwWC4LBIJ49e4a9vT14vV5eD5DNZpFKpe78vsUxABbDmCWOQfwOif6RUS6XeVZcOBxGPp+fek3PrKw3NzexsrIyFqkXPlyYI8/l5SU+f/6M8/NzZDKZiWLT6XTweDzY2NjA7u4unj9/DofDgUwmg2w2yyPx94HNQnq93pjoaaS/GyT6bxQ26gqFyIpdjo+PcXZ2hnQ6PbU1FhP88+fP8cMPP+DJkydwuVw8x108ytdqNcTjcZydneH09BTJZHJi6a5UKoXJZEIwGMTGxgY2NzcRDAah0+nQ6/VgsVhgNBp5lt+sBh9si1IoegrmzQZ9Yo+EWq2GcDiMw8NDHB4e4vLyEpVKZarfVavVcLvd2Nrawg8//IC9vT2srKzAbDZDJpNN3EevVquIxWI4Pz9HJBJBqVSauOUmk8lgNBrh9XoRCoXg9/u5VbZMJuM59QsLCxPr8+8KS0SaNP0npoNE/40iHnXPz8/x9u1bvHnzBkdHRzdG0cWYTCaEQiFsb2/j2bNnE73xxQJi++bJZBKZTAa1Wo1fl3B0lclkWFhYgMVigdVqHWmIAXzZHmSFQUqlkqbi3wAk+m+MSbZYkUgE+/v7+Omnn/Du3TtcXl5yEd6GWq2Gy+XCysoKNjY2EAgEYDabx35OXFFXr9dRKpVQKpVGziUWrVqthsFggMFggFarHcnZl0qlvHaelQDfpySWlQCzF03tZ4PW9N8YQlE1m01Eo1EcHBzg119/xf7+PsLh8NSCVyqVcDgcfBstGAzCarVysQyHwzFn28FggHw+j1QqhXQ6jVKpNBIoFO6Pq9VqOJ1OuN1u2O12aLXaESGK8wNYdt6snwt7gKhUqpHaAMrIuxv0qPwGmLSmbrfbSCQSODw8xC+//IL9/X1Eo9Gp1/EAeIBtfX0dKysrcLlcY1F04XmHwyFKpRIikQhOT0/5Wn5S8E2hUMBmsyEYDGJ5eRl+vx9Go3FEfMISWlYTf5+kGma+wcw2iNkg0X8DiM0em80md7p9+/Yt9vf3cX5+fqsPntiq2mg0YnFxEaurqwiFQmOtqcSjo0QiQbVaHdkSLBaLE4UqkUhgNpsRCASuFX2n0+Httur1+lTJOTe9N6FT0H3dguYZmt7/iUxy22m320ilUjg8PORT+ouLi6kz7xhyuRxGoxEejwd+vx9utxsLCwv8vJOmwyzFN51OIxqNIh6P86WEcEnA/q7T6Xhmn8vl4scHvgi+XC4jn8/zUtzrDDTFs4Prrk9ov0Xr+dkh0f+JiG/sRqOBZDKJo6Mj/PLLL/jtt99wcnKCXC43dQorw2Qywel0wuPxwOl08r714p8T0mq1UCqVkMlkkMlkxqywhL+n1+vhcDjgcrlgs9lGOtp2Oh0Ui0WkUilEo1FkMhlUq9WJ52QmICzANxgM+Et8TrHDLjEbJPo/AeFoyWg0GohGozg8PORTeib4u9hSsWm93+/H0tISn3ZPEolwlO31ekin04jH40in06jX62PrfYZOp4PX60UgEIDH4xkRPPDl4ZFKpXB+fo6Li4trrbVYdJ9ZfslkshFPPKELLrteoZU2MRsk+j8BsQBrtRoikQgODg7wyy+/4P379zg/P7+z4IEvwS7Wj25tbY13nBVOmcWCGQwGKBQKCIfDODs7QzweR7VaneiIwxJ91tfXsb6+Dp/PNyZ6VqRzenqKi4sLZLPZiVN7JniLxQK9Xg+VSoV2u41yuYxqtcrLaNn7oh56DwOJ/h5cN02+7t8n3bDVahXn5+fY39/Hmzdv8OHDBx60mzbwJfbHMxgM8Pl8IyO9sDSXrZvZlHo4HKJYLCIcDuP4+BjhcBjlcnni+9DpdPD5fNjY2MD6+joWFxeh1+v59+v1OjKZDMLhMC4uLpBMJq8NQMpkMl7x53a7odVq0Ww2+XZhoVBAu93G1dXViJc+Cf9+kOjvwXU33nX/LhZRpVLBxcUF3r59i59++gnv379HNBq9c9BOeFyVSgWz2Qy32w2PxzPWj26SYFqtFhdqOBxGIpHgDxzhaK9QKGC1WhEMBrGyssL73QmPk8/nEYvFbu28w+ysTSYTfD4flpeXYTKZUK/XoVar+XZfs9lEu93mbbBI8PeHRH9H7uNvL5FI0O12+RQ2Eong8PAQb968wW+//XanfPpJ1wQAdrsdfr8fXq8XZrN5LDLOrkOYjMNKdS8uLsZaXQuPzXLsl5aWEAgEYLFYRq6DFemcn58jHA7fuDxRqVQwGAxwOp1YXFzEysoKrFYr3y1oNpuo1+sol8vodDpj7bGI2SHRz8CkNTHLbmNrz0kwO+dMJsOr5Q4PD3F0dHSn1NrrrsnpdGJtbY2vtcVW0eLr6vV6SCaTOD4+5q2ur4uya7Va+Hw+rK+vY3V1FW63e6SA5urqCvV6HalUCpeXl4jH4yiVStfu8bNR3uVywe/384dIpVLhDrjZbBYajYa76NAo/zDcKHq2bTJviINek74GvoiYBZ16vR5vQqFSqcaq1zqdDkqlEhKJBMLh8EiXmHQ6fW/BezwebG9v4+XLl3j+/DkCgQC0Wu1I+Slzm2XT5mQyiZOTE7x9+xYfPnxANBqdWKqrVqvh9/vx9OlT7OzscBNNcVZcu93mD7V8Ps9LccXpuKyjjd1uh8/nw+LiItxuN3Q6Hd99MBgMvEiHRveH5UbR3zfTSRz9FQeTHoLbjiW+4aY91m1uq9VqFfF4nAerWq0WZDIZb9ggl8tH9pxbrRbK5TKSySRfO6fTaVSr1amr5a67ZqfTic3NTbx+/Ro//vgjNjc3uQ2W8H0PBgNUKhXk83kkEgmcnp7i48ePODg4wOfPn5FKpcZGZrVazR8o33//PXZ3d/mOgBiWcttoNMYeHsLPVqlUwmg0wu12w+fzwePxwGKxjGTcidfvrJSWvPHuz42ip55h4zCL5svLSxwdHfFpcaPR4GWkrCBE6PTSbre5oSWbus7aFoohkUjgcrmwtbWFV69e4eXLl9ja2oLT6eSReaG3Huskc35+jvPzc+6IE41Gkc/nJwrKbDZjdXUVOzs72NnZwcrKythanjEcDic627DvMVimYDAYhM/ng81mg1ar5TbZ7HMT+uGxJRSbPVGRzeyQqqdkOByiVqshn8/j8vISHz9+5O2aE4kEWq0W5HI57/rKttGYANifrDnFXW2rpVLpyHKBjfDb29v48ccf8fr1a2xtbcHhcIyVr7LU3pOTE3z48AGfPn3CxcUF4vE4isUi6vX6xN0C5qe3sbGB7e1tHmwTfibCPvLCl1Dk4mCgx+PB2toaVldXsbi4yD3ue73eSAvuWq2GZrPJ3W/Zn2SgcT9uFP3BwcHXuo4/HeGowWIZOp0ORqMRMpkM1WqVB6mOj49xdHSE4+PjidtSbGoqzii7D8LjSKVSuN1ubG5u4uXLl3j16hW2t7fhdDrHZmftdhuxWAyHh4f47bffsL+/j7OzM2QymRvts5VKJaxWK5aWlrC+vs4LdoSfEds/Z9cnFOOkDECDwYDFxUVsbW1ha2uL+/RpNBpcXV2h0+mgVquhWCzyOn42G2L/JyT4+3Oj6P/lX/7la13HNwEbTRuNBmQyGTY2NvDy5Us4HA6Uy2WEw2Gcn5/zAFw2m50Y+JrVB45xWxzC6XTi6dOnePXqFV69esWn9ELBs64xiUQC79+/x88//4x3797h8+fPKBaLt8YRtFot/H4/VlZWsLS0BIfDMVLZNmkngL3EDzqJRAK9Xg+v14vt7W3s7e1he3sbi4uLMJlMvKlFtVpFPp/nhprCeAebPdBIf39uFP2//du/fa3r+CbZ399HJpOBz+fje9CJRIKbSwjF/ZDBSXHwk03XVSoV7HY7fxj9+OOPfEovbEfFusGyEf7vf/87fvnlF5ycnFzbT17cmspqtd5YNiseyev1OiqVCve3F+78sP39ra0t7O3tYWdnB0tLS7BarVCr1RgMBmi32ygWi0in00gkEsjn86jVavyaWBOMbreLTqeDXq/H3zOt7e8GrelvIJ/P4+eff4Zer0ev10OtVkOj0UCz2fxqUWSj0QiLxQKDwQCz2Qy/38+tpp88eTIStAPAG0BGo1Hs7+/j3//93/Hu3Tucnp5eK3hg3BvfbrdjcXERi4uLcDgcvGx2UrEQS71lfnrVapX/nF6v51P6Fy9eYHd3F8vLy7BarSNOvMyTLx6PI5lMjlUWXl1dodvtotFooF6v89bVAIn+rpDoJyCcXsfj8al+5yGnm8waymQyIRAIIBQKwefzwe12w+v18mQWcdBuOByiXq9zwf/000948+YNwuHw1Jl+KpUKNpsNgUAAwWAQbrd74vYcg20DsvwDlpRzdXUFrVYLr9eLjY0N7O3t4fnz51hZWYHdbodKpRqp8KtWq/zBwbYyxTZdLJDK8gCY4SZxN2jLbgJsbf+1u6golUqYTCYYjUYYjcaRfnNLS0vweDwwm83QarXQarVjDScbjQZisRj29/fx888/4+3btxMFf91SRCqVwmw2IxgMYnV1FcFgEDabbew+EP5up9NBoVBANBrF5eUlkskkqtUqZDIZ7HY7VlZWsL29jadPn3LBq9Vqfg2DwQC1Wo0777KlU7PZnJhjkEgkEIlE4PP5YDQaeSIUuy4a9W/nRlXfNyBFTI9Go4HT6UQgEOAZamxUZ9Nsm802lqzC/t5ut5FMJkfW8NeN8DfNSoS1+Gw77bq1/HA45EK8uLjgwc1er8eXImtra3jy5AkPBoo9+lgWXzKZRDweRyaTQaPRmNjSqlwuIxaLIRwO8z1+YcEPMR3zOZTfgUkFK/c5lvgYGo2Gu9yw7THWSdbhcMBkMsFgMIz51Iv727Ep/d///ne8e/du6im98JqGwyFUKhUsFgtcLtfIWp4F5oTLCZZrz5J9EokEms0mN80MhUJYX1/n1XiTTDnr9TrS6TQuLy8Ri8VQKBSu3VlotVrIZrNIp9PI5/NjD4f7FEPNEyT6W/gjt4ZY8ksoFMLq6ip3rWVraYPBwJca19HpdMZG+NPT05mq9RQKBRYWFmA0GmEymUbq5IHJXn6fP3/G8fExzs/PUSgUMBgMYDKZ4Ha7EQgEEAgE4HQ6edBNiHDKHovFkEgkUC6XxxKXhA8mVnnHdglo6+7ukOi/ImKPuWAwyBNVWA84p9MJq9U6IhKh8YWwx91gMEAul8PJyQl+/fVX7ql3U5T+pmuy2Wxwu91wOBzQ6XQjo7rw636/j3Q6jU+fPuG3337Dx48fkUgkUK1WIZfLodfr4XQ6eV692WzmdQDChB7myZdOp5FKpVAoFCb2yxPCUppbrRbfuiM77LtBov8T0Ov1WFpawvPnz/H999/j6dOnvLRUrVZPDKCKK/wGgwGvATg4OMCHDx9u3Za7DqlUCovFgqWlpZHU2EkIBf/rr7/i7du3ODs7Q6FQAAAuervdDrvdDrPZjIWFhbFiq16vh0qlwttY53K5kX3565BIJOj1emg0GjwvgJUQk1nmdJDovwKsKwuzpfZ6vXjy5Am+++47vHjxgveWE9604jx7setNr9dDPp/HxcUFjo6ORoTHuC5Kz47D9tJlMtlIym0wGITFYhlrXd1qtZBOp/nM4u3btzg5OUE2m+VBX51OB6vVCqvVCpPJxAXPzgv8nkuQTCYRiUSQSCRuzBKc1Oork8kgFovB7/djYWEBBoOB1vJTQqL/g1EoFLDb7XA6nXA4HHC73dwpZmtrC8vLyyP21AzxDSzejmo0GkgkEjg7O8PFxQUymczYWvgmrz6hr55MJhvpVrO4uDhiwNFsNnlZ8OfPn/H+/Xvs7+/j+PgYmUyGC56ZXLJR3mAwjG0rslyCdDrNA4DxeByVSmUq/4arqys+w3G5XHC5XDCZTNxRV/i+6SEwGRL9H4hSqYTT6cT6+jo2NjZ4kg2LjLtcrhHBMxEKb1b2tXBN3e12kUqlcHp6itPTUyQSiVvXwkJY/jrDarVyS2ufz8evqdvtolgsIpfLIRaL4ezsDJ8+fcLHjx9xcXGBXC7HBS+RSKDT6Xjk3+VywWw2cyEOh0O0Wi2evXdycsJnKKlUCvV6fWrTFuZlcH5+jmAwiEAgALfbTWv7KSHR/0GwVFZxNhrbBlMoFGM3qTBgJ/w3If1+H4lEAp8+fcLh4SGPmt+UU3FTAQ/rd8dGeLY12Ov1uMHlxcUFzs7OuPcdi7ILk5eYgYjD4eANNoxGI+RyOfr9PqrVKnK5HFKpFMLhME5OTvDp0ydcXl7yqf20kfjhcMgderLZLOr1+lgpL43y10OifwCEho0ymYy3e1pdXcXu7i5evHiB7e1t+Hy+G7PbrvOAYyW6zWYT6XSa97g7PDxENBq91WpLeA7WFkoul8NisSAUCvE8frfbDYlEgkKhgFQqxUf1k5MT7vRTLBYnnk+hUPAsQtbBdjAYoFQqoVqtIpvNIhKJ8EpF5qOXzWZ5zfxtCGMUzPKr2WzeuzHmvEGivydarRY6nY53aFGr1TCbzVheXsbu7i52dna4keQkwQun9JME3+12USgU+MgWDodxdHSE9+/f8w444i4wN42YVqsVFosFNpsNXq8Xy8vLePLkCdbX16HX6/na/dOnT/jw4QM+fvzIG1kKm08IkUqlMBgMsFqt3AWn2+0inU6jXC4jnU4jFotx0cfjcV5F1263Z053pj362SDRz4BEIuEWzg6HA1arlQt/YWEBNpsNKysrXPDC/HXhXrWwbJbBXHWB39tDMU899rq8vEQkEkEmkxkb4cSjulQqRb/f51lyy8vLWFpaQjAYRDAYhN/vh8vlgl6vR7vdHtkCZNPvfD5/42fBtuicTidMJhNfgtRqNSQSCUSjUSSTSV6FVyqV0G63uT3WrLBZC7nk3g0S/S2Iu8ewkdzpdMLr9cLr9cJut0On00GtVmNhYQFmsxk+n4+nnwoLQgaDwbU3aL/f59PhRqOBYrGIeDyOs7MzfP78mUfpK5UKGo3GjVNa1vTCaDRCrVZDo9HA7XZjbW0Na2trWF5ehs/ng8lkgkQi4RHxN2/e4M2bN/j8+TMfqW9CrVbzQCAz8sjlcnzGEIlEkEqlUCqVUKlUeFLNQ8C2FEnwd4NEfwtCYSmVSrhcLi6cpaUluN1uvh/N7K+1Wi2vlhOO5KxkVgyrFc/lcjwHPZ1OI5PJ8Kkxq2C7rdUVi6Lb7XZevGOxWGAymeBwOEbaXbE0W1bwcnBwgDdv3mB/fx/pdPpWHz+VSgWr1cqba+h0Ov6wikQi3N6bteh66Ok4+7+haf7doNLaCbARRHjTS6VSeL1e7OzsYG9vD1tbWwgEAjCbzTzxhrVcZjbObI960r4xM+WoVqvcFCKZTHI//Gg0yiPTtVrt1t52SqWSJ8Y4nU74/X5eksv2svV6PQwGAywWCy+kYdt/bA3PRnjhe58U/WeFOT6fj+fXX11dcR9BocX3HxVko752s0GltRMQF7nI5XL4fD48ffoUr1+/xsuXL7GysgKbzQaVSjXRkll8Iwr/3mq1UCgUEI/HEYvFkMvlUCwWkclkcHl5ySPblUplqlFMp9PBZrNxcw32CoVC8Pv9sNvt0Ov1fNYhfKjFYjEu+E+fPk0c4cXXoFAoeN39+vo6/H4/lEoln6mcn58jlUrdq4HHNAgtsYnpmc+h/BaEI5PL5UIwGEQoFMKzZ8/w/fff48mTJyN13LeNNux7nU6HR7MjkQhOT0+5QEqlEsrlMkqlErelnnQc4Q3O1tMejwehUAjLy8tYWVnB4uIiXC4XbDYbjEbjxAo3ACgWi7i4uMDh4SH37xev4cXnZEYfwWAQz549w+rqKhYWFlAqlVAoFPjS5I8QvPhamGcec+YlpoNEfwMmkwmvX7/GixcveGCOtXS6K7VajYudBebOzs4QiUSQzWZRq9X4DXzddFgseJ/Ph9XVVd42mo3sDocDBoOBW3FPgnnSXVxc8H14YZR+UqKQcIRnLa5cLhdqtRqi0SgvnLmuH959EQubpRPT9P5u3Cj6f/7nf/5a1/FNwCL17XYbUqkUoVAIL1++xNraGsxmM0wm01izB3EHWObW2u120e/30e/3uTsM88w/OTnBxcUFH+En2WgL/eTFCM0md3d3sbW1hVAoBLvdPnFkFxtgsF0CllrLsuJuggmeJfM8f/4cS0tLAIBUKoVEIoFUKjVTHf+0TDLvtFqt0Gq1YwFT4npuFP2//uu/fq3r+CZgQmPbahqNhjdSZIE6YXBTWIU2GAx4V1q2Rq/X62i322g2m1z0p6envI2z2AdOjPh7rAec3+/Hs2fPsLe3N+Iue93ILv431rySBQ1TqdRYi61JIzwTPItpqFSqkaSbfD7/YNtxN6HT6RAIBPgOit1un9ug8yzc+Eltb29/ret4VIibW7J+8+l0GtFolE91i8UiGo0G2u02rx1Pp9NjufKTRnVxboBer+fbY+vr67y33PLy8lhvOXE3HOHDqdfr8fJYlnxTKpVu7HQjFPz333+Pzc1NaLVa7pzz6dMnRKPRqQOP94VlPG5tbWF9fZ0362TQSH8z9HicAeFN1Ww2kc1m+Sh+cnKCy8tLPnVnueFs2t/pdCbuilwnFoPBAI/HA5/Ph1AoxI0uWMDObDZfe53iY/Z6PaRSKRwfH+P9+/fc8ea6oJtCoeBBu+fPn+OHH37AkydPYDQakcvlcHR0xN16stnsnfvzTYs4gMfaY7EtSfbQo0Kb6aAtuxtg6/Xrtt+urq54EIvVmLN97lKpdG1jSDHCkVmhUPDgFJvKs2AdM8x0u928Xp3BliTikZ3BDDA+fvyIX3/9Fe/fv0c4HL42445l9LEo/e7uLlZWVrCwsIBcLofDw0O8ffsWBwcHiMVityYNPRRyuZznI9jt9pFZDtXRT8eNoqcPbxzxaMJEf3BwgHfv3iEajfLClLsmpWg0Gm4xZTAYuLHF+vo6d7QxmUy8FTbjpt5urElEKpXC0dERd7w5Pj5GLpebOK1niTdLS0vY3t7G7u4ulpaWoFQqeTHOr7/+ig8fPvCOvbdxH1dh4c+zBhcsA5Lu0btzo+jFxSDE6A3I2jHl83nE43FEIpGpo9dsBsEChMz3nvnNMyMKNrX3+/0jOwdCJo3urD9cpVJBMpnE8fEx3r17h3fv3nHHm0mNJhcWFnimHVtGsGy7WCyGz58/4927dzg4OLhxaXDT5zYrLO3X6XRyg47hcMjvU3oATAet6e8JExd7CRGbQTIUCgV0Oh3Pz9fr9dwOe3V1FcvLy/B6vbx6T6vVjtlR3wRL22VZfxcXF7y99ufPn8fKcYHfp802m42n1vr9fmi1WlSrVV4td3x8jOPjY8Tj8alG+IdC2H2HxTPEvoIACX8aSPT35DqXG6HQxRltFosFfr8fwWAQXq8XFosFer2eF8T4/X44nc6JfdrECTNCa2yWz5/JZPjMIxwO4+zsDOFwGMlkEvl8fqSGXy6XQ6lU8vMLKweVSiXfakwmkwiHw4hGo2PNJaeBzWwmfSbTIJPJeFCRtdyyWq20Pz8DJPp7cNONKy5SkcvlUKvVvPPLxsYGNjY2uPMs609nNBphMBgmps42m03UajXU6/WRuAEz4+h2uyiXy7wGn+XxM0954VScnW9hYQEmk4nXw7My4eFwiFwuh1wuh3Q6jXQ6zbPt7hKlF85olEoler0e6vU6f93keiNun20wGHhJs8vl4p8RRe3vBon+D0I8A1Cr1bDb7VhdXcWzZ8+ws7ODzc1NeL1emEwmKBSKa3P42S5BLpdDIpHgIzZznWGiZ1506XSam1awJKDhcAiFQsF96c1mM2w224jYDQYDZDIZr/hjZb5M7Hcd3fV6PbxeL1ZWVngpL0sMisfjSCQSKBQKUx1XKpXyFmBms3lkuUOivxsk+gfgum094SjP2jZvbm7ixYsXeP78OQKBwLXFMMCXAp1Go4FyuYxMJoNoNDrSKLJer4/sEjDH2VqtxhtB9Pt9qFQqXlZrNBphNptht9vhdrv59p9Wq0Wv10M2m0WxWOTVcrMWz2i1WgQCAezu7vLtPoPBgHq9jnA4jPfv3wP4spV4nejFtQYajYZbXVNji9kh0d8D4T7+JOsroX01c9xhEXmbzXaj4FutForFInefEdplMY85lvgjROi7x8wvmd++0+mEzWaD1WqFw+GA0+mE0+mEVqtFp9NBPB7nDjrhcJhbU98VrVaLYDCI3d1d/MM//ANevHiBQCAAnU6HVqsFp9MJiUSCer2OfD6Pcrl86/amWq3m3X9I8PeDRH9PhKIX3oyTUmv7/T7Pz08mk2i1WiMeb2x2wNJ6k8kkzs7OeL5+IpFAJpPhdlo3odPp4HA4sLi4iFAoxIOGdrudG2qwfIDBYIBkMsk97ZjjzSyCZz36dnd38erVK3z33XdYXV3lbbJYE41SqYRkMsm729xkyyWRSLgpCXuwDodDEv+MkOjvCRvhbxuB2u02crkcTk9PMRgMkMlkYDab+XSVFYx0Oh0+ArIqODbqlsvlqfzhjUYjPB7PSCZfMBiEy+WCxWKBRqPhvvsymYz717FtuUwmM9OUXqfTcXehH3/8Ed999x1WVlbG+uLp9Xq4XC4sLi7C6/XyFtfXBQiFmYZUSnt/SPT3hN2QMplsTPRslB8MBmg2m0ilUuh0OrzDC9ujZ80vWLJPrVZDPp/nzR3z+fxYjbpwZiCMcJtMJgQCAWxubuLp06fY3NzkdlbMy09Ir9dDtVpFKpXihULTTLcnYTKZsLy8jJ2dHTx//nxkhBeWIctkMhgMBtjtdjgcDpjNZpRKpWtFz4KUzCzjulRjYjpI9PfkpjW9cA+dbbGxRBdhOikb7VktP9uWY1tzNzV2FBei+Hw+bG9vY29vD0+fPsXS0hJvfS0uPx0Oh6hWq7wZZDKZRLFYnDpKL046YnX+y8vLCAQCI4IXtqgGft/CZFuHSqVybIuOvUfgS4yj1WpxoxFidkj0D8Ckaae4zZLQUAP4YlUll8t5Hr1CocBgMECv1+MmHDchnuKbTCb4/X5sb2/jxYsXPGJut9uhUqn47wi3t1qtFnK5HHeuTSaTqFarM6fMKpVKaDQa6PX6kQaYk+IdzA6cmY3cJuROp4NarcZtxZrNJp+10HT/bpDo74kwiCeect4mHvYgEG753XVazarxmIXV3t4ednZ2Row7hdcjPE+tVkMymeTbgOl0Gs1m807nF9LtdvnypNls8r30SaJstVrcD7BcLqPVao1lGordg1kfgEgkAqfTCZ/PR0U3M0CivyfCqb24v/y03NXRVRg8ZCP81tYWXrx4gZ2dHSwtLY0JHvh9hO33+7xdNOstx5pS3iXbblLf+FQqhYuLC+4jKPTqY+JkNQGs8w1rmXXT8Xu9HvL5PC4uLuDxeHgjUKfTyT93StKZDhL9PWDiY00u2FSdjd4P7SIjlUr5FJo11PB6vVhdXcX29jaePHmCUCgEi8XC18hier0eKpUKUqkUTk5OuOkHy/C7D7VaDbFYDAcHB5BIJCiVSvB4PDAajVAoFDxmkUgkcHBwgOPjY8RisamMNK+urlAqlfgDxefzwe12w2azjT1sSfg3Q6K/JwqFgufMm0wm3rrpJlfbaRGW3yoUCmg0Gt4DnmXUhUIhXpnn9/tHBM8eOiz63W63USqVkEqlcH5+jo8fP+LTp0+8RPa+pimtVgvJZBJXV1e8hzxr7bWwsIDBYIByuYxoNIqTkxMcHx8jm81O/bDpdDpIpVKIx+NIpVJj8QcS/HSQ6O+I+KZiDjMejwd+vx+9Xo8Xt9xH+MIKuIWFhRG3GFYJxyryvF4vHA4HjEbjyJS+3++j1WqhXq+jUqmgUCggm80iGo3i/PycO+Fms9mxNfUsMF9/9nBh+fsOh4O3ri4Wi7x+IJPJTJUAJOwnyNKMWbEO+d3fHRL9PWCOuczhptFocEOMbDbL7a1nET5bOmg0GpjNZrjdbvj9ft7Fhtlm2Ww2GAwGqNVq3qGW9carVqsoFApIp9PcopqNlMlkkveZazabM7eLFsKyCZl5B+tzz/IDhsMhKpUKisUiqtXq1M654m5DSqWS8u/vAYn+johHetZlJhQKAfhi52QwGKDVanmW3qyiYvECg8EAl8uFpaUlrKysIBAIwOVywWw2Q6vV8vUy28tuNpvcfZfl7kciEaTTaeTzeZ6Bxwp2/ggvRFYZyEZ9lnzUbrfvbL4h3Lu32+28e49OpyPhzwCJ/p6wNk8AuEBNJhMXo1QqRS6XQ6PRmElcbJq/sLDAK+TYyCmRSNDpdPjoWq1WUSwWeQ18MplELBbjI3uhUODTYjYj+KOnx71e70FmERKJBFarFYFAACsrKwgGgzCbzSOip2aW00GivycymQwLCwuQSqW8TbVer4darQbwZV3d6/Xu3HONJa/0ej20223U63VUq1WUy2Xo9XoMh0PI5XJcXV2h0+mgWq0in8/zbjPJZJKn8BYKBd7T/jGtgcVOOwaDgRuQsG1Jcs65OyT6eyKVSiGXy6HRaPh0nAmeJaqUy2Ve2z7tqMdE32q1uBuOWq3GYDBArVbj22Cscq9YLI6YZ2QyGZTLZTQaDXS73QcZbb82QtErFApYLBYsLi5iaWmJ+/cBFLW/KyT6B4BNMVmfeolEgmazCYfDMRJou8tWHrvhWUAunU5jMBigXq8jm81Cp9NBoVCg2+1y0efzeeRyOT6yf03jytsQ59JPg/BzYjkJgUAAbrd7pHKPRH83SPQPDKu4Y3n1rGyWPQxYVpyQ625atr/Oet71ej00Gg3kcjloNBpIJBL+b9VqFbVajbfR+qO6zdzENMK+LWmJrcvFgl9eXsba2hoCgQCPoYjPS0wHif4BEHrUMRHWarURITJbqOtu+En/Ljwua4RZqVSgVqt5swu25r+pGu9rcZdmnDf9nPBnLRYL1tbW8N133+H58+cIhUIjnX0AEv1dIdHfE6Ewu90uWq3WSCJMLpfj22MPkfzCilrYkoIV7dzGfTrMXHes247DipBuuj4285l0LJPJhLW1Nbx+/RqvX7/G06dPR9byxGyQ6B8AsfDZyNvr9bgTrslkQrPZ5Gv66wQjLkMVu8YIHXqE5xVaYbNzDAYDLriHjNqLjyWVSrmbL0ueYe48bKrOthVZA092XeIOu8DvjTNDoRC+++47vH79Gi9evIDf74dSqRy5Dhrl7w6J/oEQipNt47FMPaVSCa/Xi1arxUXKhMocZdjvChtYsqw89n1hNR8bHdk2IDsWWwowF13WSPO2a7/te9cFH1nfO6vVyjv1aDQaHtSUyWS8C1CtVkOhUOABR2HOPduHN5lMsFgs8Hg8WF9fx7Nnz/gILxT8bddNXA+J/p4I7bIUCgXUajWMRiPfR7dYLFhZWeEecGw2wL5mFXnMs05oACkUP/t6kiWX8NXtdrnHXjweRzweRzabRaVSGRldxSYf1yH+HrseVgBkt9sRCAQQCoXgcrlgMpn4KC98QPV6PZRKJcTj8RHfv2q1CoVCAYfDwY8TCASwuLiIQCDAU45phH84SPT3RDgaC6P2Wq0WNpuNr8OZwFmiDts77/f7fNrOov2sKYVQ5OwmnyR6Nuoz0bPWVpeXl4hEIkilUqhUKjyqX6/XuXnFXeoCDAYDLBYLTCYT77HncDiwvLyM1dVV+Hw+mM3mkaIf9h5Y3n00GoXH44HL5UIsFkOlUoFcLofL5cLq6irW19exvLwMl8sFo9EInU434uv3mJKLvlUkt3yI9Ak/EGwqzrLs2IOATe9lMtmI4IXW2NMyHA7R6/XQbDZRKBRGuuHUajVecZfJZEb886cpbTUYDAgGg1heXkYwGITNZuOpwawIyOVy3dhos9vtIp1O81oA5qsvl8thtVpHEm/u0rCTuJaJNw+J/k9EGLV+6MKRVqvFtwzZdh7z008kEjg5OUE4HEY6neYe+iylVTh97nQ6kEqlvCXX1tYW1tbW4HA4+EOKeQnc1LyD0ev1UC6XUS6XUavV0O12IZVK+QOE9fUTQ1P6mSDRzxvidTvrassaXLIOtEz0zC2XOdey3wG+7JcvLS1hdXUVoVAIVqsVEokEg8FgYqzhJoQuwcIKurseh7gVEv3X5LqWzGy0mjRqXfc7d2GaJQGLorN6f5a9N8lrjrnULiws8HZY4ow44fVPk213G0LXXhrd7wWJnviCML4gzBkQJt2IE3CE6cUkxEcDiX7emDRzeIjps3haLvxz1utix6AHyoMy8cOkLbu/MGIBPZSghMeZ5ZiTfofE/vWgkX5OmSV+QCPxo4Om98Qodw0YkuAfHTS9J0YhEc8ntClKEHMGiZ4g5gwSPUHMGSR6gpgzSPQEMWeQ6AliziDRE8ScQaIniDmDRE8QcwaJniDmDBI9QcwZJHqCmDNI9AQxZ5DoCWLOINETxJxBoieIOYNETxBzBomeIOYMEj1BzBkkeoKYM0j0BDFnkOgJYs4g0RPEnEGiJ4g5g0RPEHMGiZ4g5gwSPUHMGSR6gpgzSPQEMWeQ6AliziDRE8ScQaIniDmDRE8QcwaJniDmDBI9QcwZJHqCmDNI9AQxZ5DoCWLOINETxJxBoieIOYNETxBzBomeIOYMEj1BzBkkeoKYM0j0BDFnkOgJYs4g0RPEnEGiJ4g5g0RPEHMGiZ4g5gwSPUHMGSR6gpgz5Ld8X/JVroIgiK8GjfQEMWeQ6AliziDRE8ScQaIniDmDRE8QcwaJniDmjP8PSYX8yuxRoIcAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 69\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 70\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 71\n", "Starting forward run...\n", "Starting adjoint run...\n", - "Calculating gradient...\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating gradient...\n", "Current iteration: 72\n", "Starting forward run...\n", "Starting adjoint run...\n", "Calculating gradient...\n" ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ + "%matplotlib ipympl\n", + "\n", + "# Create the animation\n", + "animate = Animate2D(\n", + " fields=None,\n", + " realtime=True,\n", + " eps_parameters={'contour': False, 'alpha': 1, 'frequency': 1/1.55},\n", + " plot_sources_flag=False,\n", + " plot_monitors_flag=False,\n", + " plot_boundaries_flag=False,\n", + " update_epsilon=True, # required for the geometry to update dynamically\n", + " nb=True # required if running in a Jupyter notebook\n", + ")\n", + "# This will trigger the animation at the end of each simulation\n", + "opt.step_funcs=[mp.at_end(animate)]\n", + "\n", "algorithm = nlopt.LD_MMA\n", "n = Nx * Ny # number of parameters\n", "\n", @@ -2089,17 +1045,39459 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We'll wait for a few minutes (or longer) and visualize the results. We see that every time `beta` increases it either drives the cost function out of a local minimum or into a poorer spot. It gets harder to converge as `beta` increases. This is expected as the gradient starts to swing wildy at these thresholded transition regions. Regardless, we are still able to generate a somewhat smoothed structure after just 72 iterations." + "The animation can be embedded in the notebook using the 'to_jshtml' method:" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "animate.to_jshtml(fps=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We'll wait for a few minutes (or longer) and visualize the results. We see that every time `beta` increases it either drives the cost function out of a local minimum or into a poorer spot. It gets harder to converge as `beta` increases. This is expected as the gradient starts to swing wildy at these thresholded transition regions. Regardless, we are still able to generate a somewhat smoothed structure after just 72 iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Average Insertion Loss (dB)')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -2111,29 +40509,51 @@ } ], "source": [ + "%matplotlib inline\n", "plt.figure()\n", "plt.plot(10 * np.log10(evaluation_history), \"o-\")\n", "plt.grid(True)\n", "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Average Insertion Loss (dB)\")\n", - "plt.show()" + "plt.ylabel(\"Average Insertion Loss (dB)\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "To be sure, we can plot our results and see the resulting geometry." ] }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, + "execution_count": 18, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "text/plain": [ + "(-2.75, 2.75, -2.5, 2.5)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -2145,6 +40565,7 @@ } ], "source": [ + "%matplotlib inline\n", "opt.update_design([mapping(x, eta_i, cur_beta)])\n", "plt.figure()\n", "ax = plt.gca()\n", @@ -2157,21 +40578,32 @@ ")\n", "circ = Circle((2, 2), minimum_length / 2)\n", "ax.add_patch(circ)\n", - "ax.axis(\"off\")\n", - "plt.show()" + "ax.axis(\"off\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "Of course we want to check the final frequency response. We can run another forward run to pull the objective function parameters and calculate the transmisson." ] }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, + "execution_count": 19, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -2191,12 +40623,20 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, + "execution_count": 20, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2208,7 +40648,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAEGCAYAAACpXNjrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA6mUlEQVR4nO3deXxU1fn48c9DEkhYQ1hiCMgOiiAiERQUg1CwaoW6t1YRpajVWmu1dalfW7UVl1p/tVpFpaJWxQVXUEQwoOACkSXs+xYCAUICIQlkeX5/zI0McZIMk5ncmczzfr3mlbuce+9zJM6Te86954iqYowxxgRTI7cDMMYY0/BYcjHGGBN0llyMMcYEnSUXY4wxQWfJxRhjTNDFuh1AOGjbtq126dIloGMPHTpEs2bNghtQmLM6Rwerc3SoS50zMzP3qmo7X/ssuQBdunRh8eLFAR2bkZFBenp6cAMKc1bn6GB1jg51qbOIbK1unzWLGWOMCTpLLsYYY4LOkosxxpigs+RijDEm6Cy5GGOMCTpXkouIJInIbBFZ7/xsXU25cU6Z9SIyzsf+D0Vkhdf6X0QkW0SWOp8LQlkPE37eX5LN0Elz6Xr3DIZOmsv7S7LdDsmYqOTWncvdwBxV7QnMcdaPISJJwAPAYGAQ8IB3EhKRS4BCH+f+p6qe5nxmhiR6E5beX5LNPdOzyM4vRoHs/GLumZ5lCcYYF7iVXMYAU53lqcBYH2VGA7NVNU9V9wOzgfMBRKQ5cAfwcOhDNZHi8VlrKS4tP2ZbcWk5j89a61JExkQvt5JLsqrmOMu7gGQfZVKB7V7rO5xtAA8B/wCKfBx3q4gsF5Ep1TW3mYZpZ37xcW03xoROyN7QF5HPgRN87LrPe0VVVUT8nrFMRE4Duqvq70WkS5Xd/8GTeJSjCej6as4zEZgIkJycTEZGhr8hHKOwsDDgYyNVONb5cJkS2whKK368r3W81DnecKxzqFmdo0Oo6hyy5KKqI6vbJyK7RSRFVXNEJAXI9VEsG0j3Wu8IZABnAWkisgVP/O1FJENV01V1t9c1XgA+riG+ycBkgLS0NA10+AMbLsJ9+w8dYfzLiyitKCIuRigtP/Zvlbi4xqSePJCeyS0Cvka41bk+WJ2jQ6jq7Faz2IdA5dNf44APfJSZBYwSkdZO89YoYJaq/kdVO6hqF+BsYJ2qpgM4iarSz4EVmAYtO7+Yy55byKqcAzx/zUAev6w/qYkJCJCamMDN53anXJWL/72AdzN3uB2uMVHDrYErJwFvicgNwFbgCgARSQNuUtUJqponIg8Bi5xjHlTVvFrO+5jTbKbAFuDGUARvwsP63Qe5dsp3FJaU8cr1gzizWxsAxg5IPabc+KFduO3NJfzh7WV8u3kff724LwmNY9wI2Zio4UpyUdV9wAgf2xcDE7zWpwBTajjPFqCv1/o1QQ3UhK3Mrfu5/uVFNI5txLQbz6JPh5bVlm3fMp7XbhjM/5uznn9/sYFl2wt45urT6dG+eT1GbEx0sTf0TcSZu2Y3V7/4Da2bxjH95iE1JpZKsTGN+MOo3kwdP4g9hYe5+N9f2fsvxoSQJRcTUd7N3MGvX8mkR/vmvHPzEDolNT2u44f1asfM286hb4dW3D5tKfdMX05JlXdjjDF1Z8nFRIzJ8zfyh7eXcWa3JN749Zm0bd4koPOc0Cqe1389mN+kd+eN77Yz9pkFbNrja7AHY0ygLLmYsFdRofx95mr+PnMNF56awpTrzqBFfFydzhkb04g/nn8S/x1/BrsPlPCzp7/iw2U7gxSxMcaSiwlrpeUV3PnOMibP38S1Z3XmX1cNoEls8J70Gt67PTN/dw4np7TktjeWcN97WdZMZkwQWHIxYav4SDk3vprJ9O+zueMnvfjrxacQ00iCfp2UVgm8MfFMbjy3G//7dhuXPLuQLXsPBf06xkQTSy4mLOUXHeHqF78hY20uf/t5X24b0ROR4CeWSnExjbjnpyfz0rg0dhYUc9HTXzFjeU7tBxpjfLLkYsJOTkExlz/3NSuyD/Ds1adz9eDO9XbtEScnM+O2c+iV3JxbXv+e//tgBYfLrJnMmOPl1hv6xvi0Ifcg1770HQdLyph6/SDO6t6m3mNITUxg2o1n8dina3jhy818v20/13b3MSKmMaZadudiwsaSbfu57LmvOVKuvHnjma4klkpxMY2478I+vHBtGtvzinlgYTGfZFkzmTH+suRiwkLG2lx++cK3tEqI492bz+KUDq3cDgmAn/RJZsZtZ5PSrBE3/+97/vLhSmsmM8YP1ixmXPf+kmzufHsZvU9owcvjB9GuRWAvR4ZKx9ZNuXdwPF8XJfPSV55msmd+efpxjw5gTDSxOxfjqhe/3MTt05ZyRpck3px4ZtgllkqxjYT7L+rD89cMZPPeQ1zwry/5dMUut8MyJmxZcjGuUFUmfbKGh2es5oJ+J/Df8XV/674+jD7lBGbedg5d2zbjptcyefCjVRwps85+Y6qy5GLqXVl5BX98ZznPzdvIr848kad/cTrxcZEzv0qnpKa8fdNZXDekC1MWbOby579me16R22EZE1YsuZh6VXyknJtey+TtzB3cPrInD43pG5K37kOtSWwMf7n4FP5z9elsyi3kwn99yexVu2s/0JgoYR36pt4UFJVyw9RFZG7bz0Nj+3LNmfX3cmSo/LRfCn06tOSW17/n168s5tfndOWP559EXIz93WZ8e39JNo/PWsvO/GI6JCZw1+jeP5o9tSGw5GLqxa6CEq6d8i1b9hbxzC9P54J+KW6HFDSd2zTj3ZuH8LcZq3nhy80s3rqfi/t34MUvNzf4LxBzfN5fks0907ModgZHzc4v5p7pWcCPp+eOdJZcTMht3FPItS99R0FxKS+PP4MhPdq6HVLQNYmN4cExfRnUNYk/TFvKkm35P+xryF8gpnaqSt6hI+QUlPDgx6t+SCyVikvLeXzW2gb3u2HJxYTU0u35jP/vd8Q0Et6ceCZ9U8Pj5chQuejUDjz08Sp2Hzh8zPaG+gUS7VSVAyVl5BQUk5Nfws4qP3MKiskpKOFwLU8U7swvrqeI648lFxMy89ft4abXMmnbvAmvXD+ILm2buR1SvcitklgqNcQvkEgSSF9H0ZEydlYmiarJo6CEnPxiDh059k6kkUByy3hSWsVzSmorftInmZRWCXRIjOf+91eyp/DHvx8dEhOCWtdw4EpyEZEkYBrQBdgCXKGq+32UGwf82Vl9WFWnOtszgBSg8v/WUaqaKyJNgFeAgcA+4EpV3RKyiphqfbA0mz+8tYyeyS2Yev0ZtG8R73ZI9aZDYgLZPhJJQuMYCopLaZUQ/u/zNDS++jrunr6cfYWHOSW1FTkFxezMLyFz1WFe3bKInQUl7MwvpqC49Efnatu8CR0S4+nerhln92hLh8T4H5JHSqsE2rdoQmw1D3SUlFYcEwdAQlwj7hrdOzQVd5Fbdy53A3NUdZKI3O2s/8m7gJOAHgDSAAUyReRDryR0taournLeG4D9qtpDRK4CHgWuDGVFjIf3X4UtE2IpKC5jcNckXhiXRssIeDkymO4a3ftHXyCxjYTiI+WM+uc8/ja2HyP7JLsYYfR5fNbaH/V1lJRW8NCM1cdsaxYHJ7YtoUOreAZ2TjwmaXRolUByqyZ1mgm18k7p8Vlrf/gD5JqzOjfI5lK3kssYIN1ZngpkUCW5AKOB2aqaByAis4HzgTdqOe9fnOV3gH+LiKiqBiVq41PVvwoListoJHDZwI5Rl1jg2C8Q7yaY7u2ac9c7y5jwymLGnNaBB352CknNGrscbcO3cmeBzzvJSq/dMJiURE8z1ncLvyI9/ZyQxjN2QCpjB6RypKyC9Me/IHNrPqoa0snw3CBufO+KSL6qJjrLguduI7FKmTuBeFV92Fm/HyhW1SecZrE2QDnwLp4mMxWRFcD5qrrDOWYjMFhV9/qIYSIwESA5OXngm2++GVBdCgsLad68eUDHRqqqdf5DRhH7Sn78e9QmXvhHesMY3DFY/85lFcrHm0r5aGMpTePgmj5NGHRCeHZ9RvLvtqqyOq+CmZtKWbGv+lGsq/6O1nedP99aymurj/CnM+I5uY07o1TUpc7Dhw/PVNU0X/tC9lstIp8DJ/jYdZ/3ipMUjjfDXa2q2SLSAk9yuQZPX4vfVHUyMBkgLS1N09PTjzMEj4yMDAI9NlJVrXPepzN8lssr0Qbz3yaY/84jz4Mbcw7wx3eW8+zSAjb3bc2DY/qG3aCdkfi7XVZewacrd/H8vE1kZRfQtnkT/nh+DxKbxvHQR6ur9HXEcP+YfqR7NUnVd53PLC1n1mNf8GVeM26+9Mx6u663UNU5ZMlFVUdWt09EdotIiqrmiEgKkOujWDZHm84AOuJpPkNVs52fB0XkdWAQnuSSDXQCdohILNAKT8e+CaHqOrAb4hMwwXJySkve+80QXvhyM//8fB1fb5rHAz/rw9jTUhtc80h9KCkt5+3F23nhy81syyuiW9tmTLqkH2MHpP4wbl3TuNiwezM+Pi6GG4d14+EZq8ncmsfAzkmuxhNMbt2PfwiMAyY5Pz/wUWYW8HcRae2sjwLucZJGoqruFZE44CLg8yrn/Rq4DJhr/S2hd3laR576fP0x2xLiYhrkEzDBFBvTiJvTu/OTPsn88Z1l/H7aMj5alsPfft6XlFaWmP2x/9ARXv1mK1MXbmHfoSOc1imRey84mZ/0Sf7RmHWVfR3h5peDT+TZjI08PXcDL48f5HY4QeNWcpkEvCUiNwBbgSsARCQNuElVJ6hqnog8BCxyjnnQ2dYMmOUklhg8ieUFp8xLwKsisgHIA66qvypFr0Vb8mjeJIYW8XHsKigJm78KI0WP9s15+6YhTF24hcdmrWHUk/O578KTufKMTnYXU40d+4t48cvNTFu0neLSckac1J4bz+3OGV1aR9x/s6aNY7nh7K48Pmsty3fkc2rHRLdDCgpXkouq7gNG+Ni+GJjgtT4FmFKlzCE877H4Om8JcHlQgzU1WrhhLws27OP+i/pww9ld3Q4nYsU0Eq4/uysjTm7Pn95dzt3Ts/h4eQ6PXNLPZrz0smrnASbP38hHy3MQYMxpqUwc1o3eJ7RwO7Q6ufaszjw/byP/nruBydf67B+POOH5mIqJCKrK45+tJaVVPFcPPtHtcBqEzm2a8fqEM3n9u208MnM1o5+az90/PYlfDe5MowicmiAYVJWvN+7jufmbmL9uD80ax3D90C6MH9q1wfTrtYiPY/zQrvy/OetZnXOAk1Nauh1Sndm44CZgc9fksmRbPreN6BlRk32Fu0aNhF+d2ZnP7jiXtC5J/N8HK7lq8jds3nvI7dDqVXmFMmN5DmOeWcAvX/yWVTsPcNfo3iy8ZwT3XdinwSSWSuOHdqF5k1ie+WKD26EEhd25mIBUVChPfLaOzm2actnAjm6H0yClJiYwdfwZvJO5g4c+XsX5T83nzlG9uf7srhE5wZq/SkrLeTtzBy9+uYmt+4ro2rYZj1zSj597PfnVECU2bcw1Z3XmuXkbuT23kB7tI/Mdo0p252ICMiMrh9U5B7jjJ71sYqwQEhEuT+vE7DvO5Zye7fjbzNVc+p+FrN990O3Qgi6/6AhPz1nP0Elzuf/9FbRu2pjnfjWQz+84l18MOrFBJ5ZKE87uSpPYRjybEfl3L3bnYo5beYXyz9nr6J3cgp+d2sHtcKJCcst4Xrh2IB8u28lfPlzJhf/6it+N7MnEYd0iPrnv2F/ES195nvwqOlLOeSe158Zh3RjUNSninvyqqzbNm3D14M68vHALt4/oxYltIvdhDksu5rgt2FnGpr1HeP6agVHbyewGEWHMaakM7dGWBz5cyeOz1jIzK4fHLjuVUzpE3jw5q3MOMHn+Jj5cthMBLj6tAzcO6x7xT37V1cRh3Xj1m638Z94GHrnkVLfDCZglF3NcDpeV88GGUvp3bMUoG9nXFW2bN+GZX57Oz07N4c/vr2TMvxfwm/Tu3HJejzqN2Bsqx86jEs+YAamszD7APOfJr/FDunD92Q3nya+6Sm4Zz5VpnXhz0TZuPa8nqRH63yWy76dNvXvzu+3sK1HuHN076posws35fVP4/I5hXNy/A/+au4GfPf0Vy7bnux3WMTwjZi8nO78YBbLzS3j2i41kbs3zPPl19wj+fFHDe/Krrm5K744qTJ630e1QAmZ3LsZvRUfKeHruBk5KasTZPdq6HY7B84TRk1eexkX9U7h3+gp+/uwCfj2sG78f2SvkHeAVFcr+oiPkHjzs+RwoIffgYfY4n9yDJXy/LZ/yih+PwNQyPo5bhvcIaXyRLDUxgUtP78gbi7Zzy/AetG8ZeZPtWXIxfpu6cCt7Cw9z4+B4u2sJM+edlMxndyTxyMzVPD9vE7NX7uai/im8m5l93AM1HimrYG/hYTbll3Nk5a4fkocnaZQ4ieQwewsPU+YjcbRoEku7lk1o36KJz8QCkFNQUuc6N3Q3p3fn7cztvPDlJu67sI/b4Rw3Sy7GLwXFpTw3byPDe7ejZ+sit8MxPrSMj+ORS07lwn4d+O0b3/OvOUcfZ62c1jf3YAn9OyYevds4WHL0TuOAZ31/kdfUvt9kAiACbZo1pl2LeNq1aEKv5Ba0b+FJIO1berZ51uNJaHz0jmnopLk2YnaAurRtxpjTUnntm23cdG532jQPrykZamPJxfjlpS83UVBcyh9G9Wbv+iVuh2NqcHbPtk6T2LHzv5eUVvD3mWuO2RYXI7R3EsaJbZqS1qU17VvE075lE3ZvWcd5Q9Jo3yKeNs0bB/TIs68pn23EbP/dMrw77y/NZsqCzdw1+iS3wzkullxMrfYVHualrzZzYb8U+qa2ImN97ccYd+2qodnp1RsGeRJIiyYkNo2rtokzo2hTnUforW7KZxsx2z892rfggr4pTF24lYnndKdV08iZNtySi6nVfzI2Ulxazu9/0svtUIyfqpvALTUxgXN6tqvXWMJ1HpVIccvwHszIyuHlhVv43ciebofjN3sU2dRoV0EJr3yzlUtO7xjxYx1Fk7tG9yahytNi1hwVmfp0aMnIk5OZsmAzB0tKaz8gTFhyMTV6eu56VJXfjYicv5iM527hkUv6kZqYgOC5Y3nEmfbXRJ7fnteDguJSXvtmm9uh+M2axUy1tu0rYtqi7fxy8Ik2YVUEsuaohqN/p0SG9WrHi19uYtyQzjRtHP5f3XbnYqr11OfriI0RbrWX3Yxx3W/P68G+Q0d447vtbofiF7+Ti4i0FpFTRKSbiFhSauDW7T7Ie0uzGXdWl4h8O9iYhuaMLkmc2S2JyfM3UuL1aHe4qjFJiEgrEblXRLKAb4DngbeArSLytogMr48gTf178rN1NGscy03ndnc7FGOM47fn9WT3gcO8nbnD7VBqVdsdyDvAduAcVe2tqmerapqqdgImAWNE5IbjvaiIJInIbBFZ7/xsXU25cU6Z9SIyzmt7hoisFZGlzqe9s/06EdnjtX3C8cZmYPmOfD5duYsJ53SldbPGbodjjHEM6d6G009M5LmMjZSWV7gdTo1qTC6q+hNVfVVV833sy1TV21X1pQCuezcwR1V7AnOc9WOISBLwADAYGAQ8UCUJXa2qpzmfXK/t07y2vxhAbFHvic/W0bppHDec3dXtUIwxXkSE357Xk+z8Yt77PtvtcGpUa9+JiMSK8wqviHQSkctEZEAdrzsGmOosTwXG+igzGpitqnmquh+YDZxfx+uaWny7aR/z1+3h5vTutIiPnLeBjYkW6b3b0Te1Jc9mbKAsjO9eRNX3qKUAIvJr4FGgEHgIuAv4HhgATFHVRwO6qEi+qiY6ywLsr1z3KnMnEK+qDzvr9wPFqvqEiGQAbYBy4F3gYVVVEbkOeATYA6wDfq+qPh+tEJGJwESA5OTkgW+++WYgVaGwsJDmzRvGy4WqyiPflZBbpDw2LIHGMb6HBWlIdfaX1Tk6REqdM3eX8fSSw0w8tQlDOtTtseS61Hn48OGZqprmc6eqVvsBVgKtgROBQ0BbZ3tTYGUtx34OrPDxGQPkVym738fxdwJ/9lq/H7jTWU51frYAPgOuddbbAE2c5RuBuTXFWPkZOHCgBuqLL74I+Nhw88Wa3dr5Tx/rKws311yuAdXZX1bn6BApdS4vr9BRT87TEf/I0PLyijqdqy51BhZrNd+rtTWLHVHV/aq6DdigqnudhFQEHKnpQFUdqap9fXw+AHaLSAqA8zPXxymygU5e6x2dbahq5c+DwOt4+mRQ1X2qetgp/yIwsJb6GYeq8sRna+nYOoErzzjR7XCMMTVo1Ei45bwebMgt5NOVu9wOx6fakkuCiAwQkYFAY2f5dGe9Li8/fAhUPv01DvjAR5lZwCjn/ZrWwChgltMH1BZAROKAi/DcEVUmqkoXA6vrEGNU+XTFLlZkH+D2kb1oHGuvMRkT7i7sl0K3ts14eu6GytadsFJbY90u4Ekfy5XrgZoEvOU8xrwVuAJARNKAm1R1gqrmichDwCLnmAedbc3wJJk4IAZP89sLTpnbRORioAzIA66rQ4xRo7xC+cfsdfRo35yf23AhxkSEmEbCb4b34M63lzFndS4j+yS7HdIxakwuqpoeiouq6j5ghI/ti4EJXutTgClVyhyimuYuVb0HuCeowUaBD5ZmsyG3kGevPp2YRjZ9sTGRYsxpHXjq83U8/cUGRpzcPqymH68xuYjIJTXtV9XpwQ3H1LcjZRX88/N1nNKhJeefcoLb4RhjjkNcTCN+k96De9/L4sv1exnWq37n6qlJbc1iP3N+tgeGAHOd9eHAQsCSS4R7a/F2tucV89/xfWlkdy3GRJxLB6by9Nz1/HvuhrBKLrW9oT9eVccDcUAfVb1UVS8FTnG2mQhWUlrO03PXk9a5Nelh9EtpjPFfk9gYbhzWje+25PHNpn1uh/MDfx8L6qSqOV7ru/G8+2Ii2Ktfb2X3gcPcObp3WLXVGmOOz1WDTqRt8yb8e+4Gt0P5gb/JZY6IzHIGhrwOmIHnKS0ToQ6WlPJsxgbO6dmWM7u1cTscY0wdxMfFMHFYV77asJfvt+13OxzAz+SiqrcCzwH9nc9kVf1tKAMzoTXlqy3sLyrlzlE2p7oxDcHVgzvTumlc2Ny91Pa0mDiv+KOq7wHv1VTGRIb9h47w4pebGNUnmf6dEt0OxxgTBM2axHLD2V154rN1rMguoG9qK1fjqe3O5QsR+a2IHNO/IiKNReQ8EZnK0TftTYR4bv5GCo+U8Qe7azGmQbl2SBdaxMeGxd1LbcnlfDwjD78hIjtFZJWIbAbWA78AnlLVl0Mcowmi3AMlTF24hTH9O9D7hBZuh2OMCaKW8XGMH9KFT1fuYu2ug67GUtujyCWq+qyqDgU643mrfoCqdlbVX6vqknqJ0gTNM19soKxcuX1kL7dDMcaEwPihXWnWOIZnvnD37sXvEQpVtVRVc9THrJQmMmzPK+L177ZxeVonurRt5nY4xpgQaN2sMb86qzMfL9/Jpj2FrsVhw99GkX/NWY+IcNuIHm6HYowJoQlnd6NxbCOezdjoWgyWXKLExj2FvPv9Dq45szMprRLcDscYE0LtWjThF4NO5L0l2WzPK3IlBr+Si4g0E5FGznIvEbnYGfLeRIgnZ68jPi6Gm9O7ux2KMaYe3DisOzEi/GeeO3cv/t65zAfiRSQVz7TC1wAvhyooE1wrdxYwY3kO1w/tStvmTdwOxxhTD05oFc/laR15Z/EOcgqK6/36/iYXcaY2vgR4VlUvxzN4pYkA//hsHS3jY/n1sG5uh2KMqUc3ndudclWen7ep3q/td3IRkbOAq/GMKwaeWSBNmMvcup+5a3K58dzutEqwlkxjokmnpKb8fEAqb3y3jdyDJfV6bX+Ty+14Znh8T1VXikg34IuQRWWCQlV5fNYa2jZvzPihXdwOxxjjgt+kd6e0vIKXvtxcr9f1d+DKeap6sao+6nTs71XV20Icm6mjBRv28c2mPG4Z3oOmjWubF84Y0xB1a9eci07twKvfbGX/oSP1dl1/nxZ7XURaikgzYAWwSkTuCm1opi5Ulcc/W0uHVvH8crBNvWNMNLv1vB4UHSlnyoL6u3vxt1msj6oeAMYCnwBd8TwxZsLU7FW7WbY9n9+N7EmTWOseMyaa9UpuwfmnnMDLC7ZQUFxaL9f0N7nEOe+1jAU+VNVSIOBh9kUkSURmi8h652frasqNc8qsF5FxXtsbi8hkEVknImtE5FJnexMRmSYiG0TkWxHpEmiMkayiQnly9jq6tm3Gpad3dDscY0wYuPW8Hhw8XMYrC7fUy/X8TS7PA1uAZsB8EekMHKjDde8G5qhqT2COs34MEUkCHgAGA4OAB7yS0H1Arqr2AvoA85ztNwD7VbUH8E/g0TrEGLE+Wr6TNbsOcvvInsTG2CAMxhjom9qK805qz0sLNnPocFnIr+dvh/6/VDVVVS9Qj63A8Dpcdwww1VmeiueOqKrRwGxVzVPV/cBsPFMAAFwPPOLEVqGqe32c9x1ghETZ5PCl5RX8c/Y6TjqhBT87tYPb4Rhjwsit5/Ugv6iU177ZGvJr+fUIkYi0wnMXMczZNA94ECgI8LrJqprjLO8Ckn2USQW2e63vAFJFJNFZf0hE0oGNwK2qutv7GFUtE5ECoA2wlypEZCIwESA5OZmMjIyAKlJYWBjwsaEwb3spW/Yd4XenN2H+/Hm1HxCAcKtzfbA6R4doqPMpbRrxzJw1dC3bRuMYCVmd/X0+dQqep8SucNavAf6L5419n0Tkc+AEH7vu815RVRWR4+m/iQU6AgtV9Q4RuQN4guN8wEBVJwOTAdLS0jQ9Pf14Dv9BRkYGgR4bbCWl5dz7RAb9OyVy++VDCNVNWzjVub5YnaNDNNQ54cR9XDn5G7LjuzB+aNeQ1dnf5NJdVS/1Wv+riCyt6QBVHVndPhHZLSIpqpojIilAro9i2UC613pHIAPYBxQB053tb+Ppa6k8phOwQ0RigVZO+ajw+rfb2FlQwuOX9w9ZYjHGRLbB3dowqEsSz8/bFNLXFPzt7S0WkbMrV0RkKFCXkdA+BCqf/hoHfOCjzCxglIi0djryRwGzVFWBjziaeEYAq3yc9zJgrlO+wTt0uIxnMzZwVrc2DO3R1u1wjDFh7LcjerDrQAmD/zaH6z49xNBJc3l/SXZQr+HvnctNwCtO3wvAfo5+iQdiEvCWiNwAbMVpbhORNOAmVZ2gqnki8hCwyDnmQVXNc5b/BLwqIk8Be4DxzvaXnO0bgDzgqjrEGBHeX5LN47PWkp3vyfVXD05yOSJjTLjbe/AwIpDvvPOSnV/MPdOzABg7IDUo1/AruajqMqC/iLR01g+IyO3A8kAuqqr78NxxVN2+GJjgtT4FT39P1XJbOfpwgff2EuDyQGKKRO8vyeae6VkUl5b/sG3y/E10bdssaL8gxpiG54nP1lG1Tae4tJzHZ60N2nfHcb0EoaoHnDf1Ae4ISgQmYI/PWntMYoGjvyDGGFOdnfm+ezWq2x6IurxhZz3GLquPXxBjTMPTIdH3VOfVbQ9EXZJLVHSUh7P6+AUxxjQ8d43uTULcsWMOJsTFcNfo3kG7Ro3JRUQOisgBH5+DgL3+7bK7RvcmttGxN5DB/gUxxjQ8Ywek8sgl/Uh1/hBNTUzgkUv6BbWvtsYOfVVtEbQrmaAbc1oH/vrRSoqOlHOkrIIOiQncNbq3deYbY2o1dkAqYwekuv4SpQlDK7IPsL+olEcv7ceVZ9icLcaY8GFD5kawGVk5xDQSRvXxNcqOMca4x5JLhFJVZmblMKR7G1o3a+x2OMYYcwxLLhFq5c4DbMsr4sJ+KW6HYowxP+JXchGRS5zZIAsqnxYTkbpMFmbq6IcmsVOsScwYE3787dB/DPiZqq4OZTDGP95NYknWJGaMCUP+NovttsQSPlbuPMDWfUVcYE1ixpgw5e+dy2IRmQa8Dxyu3Kiq06s9woTMTKdJbLQ1iRljwpS/yaUlngm6RnltU45O2GXqSWWT2FndrEnMGBO+/B1yf3ztpUx9WJ1zkC37ivj1sG5uh2KMMdXy92mxjiLynojkOp93RaRjqIMzPzYzK4dGgjWJGWPCmr8d+v/FM4VwB+fzkbPN1KPKJrEzu7WhbfMmbodjjDHV8je5tFPV/6pqmfN5GWgXwriMD2t2HWTT3kP2lJgxJuz5m1z2icivRCTG+fwK2BfKwMyPVTaJnd/XmsSMMeHN3+RyPXAFsAvIAS4DrJO/HqkqM7JyGNzVmsSMMeHPr+SiqltV9WJVbaeq7VV1rKpuC/SiIpIkIrOdIWVmi0jrasqNc8qsF5FxXtsbi8hkEVknImtE5FJn+3UiskdEljqfCYHGGG7W7j7Ipj2HuOBUaxIzxoS/Gh9FFpE/qupjIvI0PqY1VtXbArzu3cAcVZ0kInc763+qcu0k4AEgzbl2poh8qKr7gfuAXFXtJSKNgCSvQ6ep6q0BxhW2Zi53msTsKTFjTASo7T2XyiFfFgf5umOAdGd5KpBBleQCjAZmq2oegIjMBs4H3sDTTHcSgKpWAHuDHF9YqWwSG9Q1iXYtrEnMGBP+apvm+CNnsUhV3/beJyKX1+G6yaqa4yzvApJ9lEkFtnut7wBSRSTRWX9IRNKBjcCtqrrb2X6piAwD1gG/V1Xvc3jHPxGYCJCcnExGRkZAFSksLAz4WH9lH6xg455izmpbGvJr+aM+6hxurM7RweocRKpa6wf43p9tVfZ/Dqzw8RkD5Fcpu9/H8XcCf/Zav9/Z1hZPM9llzvY7gFed5TZAE2f5RmCuP/UbOHCgBuqLL74I+Fh/PfnZWu1y98e6+0BxyK/lj/qoc7ixOkcHq/PxARZrNd+rtfW5/BS4AM8dw7+8drUEympJWiNrOO9uEUlR1RwRSQFyfRTL5mjTGUBHPM1n+/CMc1Y5rtnbwA3ONb0fj34Rz1QBEW9mVg5ndEmifYt4t0Mxxhi/1Pa02E48/S0lQKbX50M8fSKB+hCofPprHPCBjzKzgFEi0tp5mmwUMMvJlh9xNPGMAFYBOImq0sUc7TOKWOt3H2R9bqHNOGmMiSi19bksE5EVwGhVnRrE604C3hKRG4CteN6hQUTSgJtUdYKq5onIQ8Ai55gH1encx9P5/6qIPAXs4eg7N7eJyMV47qrygOuCGLMrZmTlIAI/tRcnjTERpNZRkVW1XEQ6iUhjVT0SjIs6zVcjfGxfDEzwWp8CTPFRbiswzMf2e4B7ghFjuJiZlcMZnZNo39KaxIwxkcPf+Vw2AwtE5EPgUOVGVX0yJFEZADbkHmTd7kL+8rM+bodijDHHxd/kstH5NAJahC4c423G8l0A/NT6W4wxEcbfycL+CiAiTVW1KLQhmUqfrMghrXNrkq1JzBgTYfydLOwsEVkFrHHW+4vIsyGNLMpt3FPIml0HbXh9Y0xE8ndU5KfwPHq8DzxPkeGjQ90Ez8zlngEMftrPnhIzxkQef5ML+uNhVMqDHIvxMiMrh4GdW5PSKsHtUIwx5rj5m1y2i8gQQEUkTkTupAG8oBiuNlmTmDEmwvmbXG4CbsEzmGQ2cJqzbkJgZpanSewCaxIzxkQof58W2wtcHeJYjGNG1i5OPzHRmsSMMRHL36fFHhORlk6T2BxntsdfhTq4aLR57yFW5xywJjFjTETzt1lslKoeAC4CtgA9gLtCFVQ0q2wSsxcnjTGRzN/kUtl8diHwtqoWhCieqDczK4fTOiWSmmhNYsaYyOVvcvlYRNYAA4E5ItIOzzD8Joi27jvEyp0HbHh9Y0zE8yu5qOrdwBAgTVVL8QxeOSaUgUWjGVn24qQxpmHwd+BKgJOALiLifcwrQY4nqs3MyqF/p0Q6tm7qdijGGFMnfiUXEXkV6A4s5eib+Yoll6DZtq+IFdkHuPeCk9wOxRhj6szfO5c0oI8zxbAJgR+axPpaf4sxJvL526G/ArCOgBCamZVD/46t6JRkTWLGmMjn751LW2CViHwHHK7cqKoXhySqKLNtXxFZ2QXc81NrEjPGNAz+Jpe/hDKIaDdzReVYYtYkZoxpGPwdW2xeMC8qIknANKALnjf+r1DV/T7KjQP+7Kw+rKpTRaQF8KVXsY7Aa6p6u4g0wfOQwUA8c89cqapbghl7KHySlUO/VGsSM8Y0HDX2uYjIQRE54ONzUEQO1OG6dwNzVLUnMMdZr3rtJOABYDAwCHhARFqr6kFVPa3yA2wFpjuH3QDsV9UewD+BR+sQY73YnlfEsh0FdtdijGlQakwuqtpCVVv6+LRQ1ZZ1uO4YYKqzPBUY66PMaGC2quY5dzWzgfO9C4hIL6A9R+9kvM/7DjBCRKQOcYbcJ06TmL2Vb4xpSI7nJcpgSlbVHGd5F5Dso0wq4D375Q5nm7ergGlej0j/cIyqlolIAdAG2Fv15CIyEZgIkJycTEZGRkAVKSwsDPhYgDe/LqZzy0ZsyvqOTQGfpX7Vtc6RyOocHazOwROy5CIin+P78eX7vFdUVUUk0PdnrgKuCeRAVZ0MTAZIS0vT9PT0gALIyMgg0GN37C9i06df8Mfze5Oe3iOgc7ihLnWOVFbn6GB1Dp6QJRdVHVndPhHZLSIpqpojIilAro9i2UC613pHIMPrHP2BWFXNrHJMJ2CHM0xNKzwd+2Hpk6xdgDWJGWMaHn9fogy2D4FxzvI44AMfZWYBo0SktYi0BkY52yr9AnijhvNeBswN51EFZmTlcEqHlnRu08ztUIwxJqjcSi6TgJ+IyHpgpLOOiKSJyIsAqpoHPAQscj4POtsqXcGPk8tLQBsR2QDcgY+n0MJFdn4xS7fn21NixpgGyZUOfVXdB4zwsX0xMMFrfQowpZpzdPOxrQS4PHiRhs4nWfbipDGm4XLrziXqzczK4eSUlnRta01ixpiGx5KLC3bmF/P9tnwutEnBjDENlCUXF3yywvOUmDWJGWMaKksuLpiZlcNJJ7SgW7vmbodijDEhYcmlnuUUFJO5db+922KMadAsudSzyhcnLzjVkosxpuGy5FLPKpvEuluTmDGmAbPkUo92FZSweOt+68g3xjR4llzq0ac/zDhpjyAbYxo2Sy71aGbWLnolN6dH+xZuh2KMMSFlyaWe5B4oYdHWPGsSM8ZEBUsu9eSTFbtQteH1jTHRwZJLPZmRlUPP9s3pmWxNYsaYhs+SSz3IPVDCoi3WJGaMiR6WXOrBpyudJjF7cdIYEyUsudSDGctz6NG+Ob2sScwYEyUsuYRY7sESvrMmMWNMlLHkEmKzVu5G1V6cNMZEF0suITZzeQ7d2jWjtzWJGWOiiCWXENpbeJhvN+/jwn4piIjb4RhjTL2x5BJCn67YRYXajJPGmOjjSnIRkSQRmS0i652fraspN84ps15ExjnbWojIUq/PXhF5ytl3nYjs8do3oR6r9SMzs3Lo1rYZJ51gTWLGmOji1p3L3cAcVe0JzHHWjyEiScADwGBgEPCAiLRW1YOqelrlB9gKTPc6dJrX/hdDXpNq7C08zDeb9nGBNYkZY6KQW8llDDDVWZ4KjPVRZjQwW1XzVHU/MBs437uAiPQC2gNfhi7UwMxaaU1ixpjoFevSdZNVNcdZ3gUk+yiTCmz3Wt/hbPN2FZ47FfXadqmIDAPWAb9X1e34ICITgYkAycnJZGRkHHclAAoLC30e+79FxSQ3FXavzSR3XcO6c6muzg2Z1Tk6WJ2DJ2TJRUQ+B3y93HGf94qqqoioj3L+uAq4xmv9I+ANVT0sIjfiuSs6z9eBqjoZmAyQlpam6enpAQWQkZFB1WP3FR5mzazPuTm9O8OHnxTQecOZrzo3dFbn6GB1Dp6QJRdVHVndPhHZLSIpqpojIilAro9i2UC613pHIMPrHP2BWFXN9LrmPq/yLwKPBRZ93Xy2ajcVCj/ta01ixpjo5Fafy4fAOGd5HPCBjzKzgFEi0tp5mmyUs63SL4A3vA9wElWli4HVQYv4OMzMyqFzm6ac0qGlG5c3xhjXudXnMgl4S0RuwPO01xUAIpIG3KSqE1Q1T0QeAhY5xzyoqnle57gCuKDKeW8TkYuBMiAPuC6EdfAp79ARFm7cx8Rh3ewpMWNM1HIluTjNVyN8bF8MTPBanwJMqeYc3Xxsuwe4J3iRHr/PVu6ivEJtxkljTFSzN/SDbEZWDicmWZOYMSa6WXIJov1Ok5i9OGmMiXaWXILos1XWJGaMMWDJJahmZO2iU1ICfVOtScwYE90suQRJftERFm7YywV9rUnMGGMsuQTJZ6t2U1ahNpaYMcZgySVoZmbl0LF1Aqd2bOV2KMYY4zpLLkFQUFTKgg177SkxY4xxWHIJgs9W7aK03JrEjDGmkiWXIJiZlUNqYgL9rUnMGGMASy51dqhU+WrDXi7od4I1iRljjMOSSx0tyS2zJjFjjKnCrVGRI977S7J5fNZasvOPECOwZe8hBpzY2u2wjDEmLFhyCcD7S7K5Z3oWxaXlAJQr3PveCkSEsQOqzsRsjDHRx5rFAvD4rLU/JJZKxaXlPD5rrUsRGWNMeLHkEoCd+cXHtd0YY6KNJZcAdEhMOK7txhgTbSy5BOCu0b1JiIs5ZltCXAx3je7tUkTGGBNerEM/AJWd9p6nxYpJTUzgrtG9rTPfGGMcllwCNHZAKmMHpJKRkUF6errb4RhjTFhxrVlMRJJEZLaIrHd++nxJRETGOWXWi8g4r+2/EJEsEVkuIp+KSNvjOa8xxpjQcbPP5W5gjqr2BOY468cQkSTgAWAwMAh4QERai0gs8P+A4ap6KrAcuNXf8xpjjAktN5PLGGCqszwVGOujzGhgtqrmqep+YDZwPiDOp5l4BvRqCew8jvMaY4wJIVFVdy4skq+qic6yAPsr173K3AnEq+rDzvr9QLGqPiEilwFTgEPAejx3MeX+nNfZNxGYCJCcnDzwzTffDKgehYWFNG/ePKBjI5XVOTpYnaNDXeo8fPjwTFVN87UvpB36IvI5cIKPXfd5r6iqiojfWU5E4oCbgQHAJuBp4B7gYX/Pq6qTgckAaWlpGminfDR26Fudo4PVOTqEqs4hTS6qOrK6fSKyW0RSVDVHRFKAXB/FsoF0r/WOQAZwmnP+jc653uJo34o/5z1GZmbmXhHZWnuNfGoL7A3w2EhldY4OVufoUJc6d65uh5uPIn8IjAMmOT8/8FFmFvB3rye+RuG5Q4kH+ohIO1XdA/wEWH0c5z2GqrYLtBIisri628KGyuocHazO0SFUdXYzuUwC3hKRG4CtwBUAIpIG3KSqE1Q1T0QeAhY5xzyoqnlOub8C80Wk1Dn+uprOa4wxpv641qHfUNhfOtHB6hwdrM7BY2OL1d1ktwNwgdU5Olido0NI6mx3LsYYY4LO7lyMMcYEnSUXY4wxQWfJpRoiMkVEckVkRTX700WkQESWOp//89p3voisFZENIhIxY5sFWmcR6SQiX4jIKhFZKSK/q9/IA1eXf2dnf4yILBGRj+sn4rqr4+92ooi8IyJrRGS1iJxVf5EHro51/r3ze71CRN4Qkfj6izxwtdXZKZPu1HeliMzz2l737zBVtY+PDzAMOB1YUc3+dOBjH9tjgI1AN6AxsAzo43Z9QlznFOB0Z7kFsK6h19lr/x3A6zWVCbdPXeqMZ7y+Cc5yYyDR7fqEss5AKrAZSHDW3wKuc7s+QapzIrAKONFZb+/8DMp3mN25VENV5wN5ARw6CNigqptU9QjwJp7BNMNeoHVW1RxV/d5ZPojnhdaImDmtDv/OiEhH4ELgxaAGFWKB1llEWuH5wnrJOc8RVc0PbnShUZd/ZzzvAyY4o7E35egguWHNjzr/Epiuqtuc8pWjmQTlO8ySS92cJSLLROQTETnF2ZYKbPcqs4MI+aL1k686/0BEuuAZ8+3beo8sdKqr81PAH4EKd8IKKV917grsAf7rNAW+KCLNXIwx2H5UZ1XNBp4AtgE5QIGqfuZmkEHUC2gtIhkikiki1zrbg/IdZsklcN8DnVW1P56BM993N5x6UWOdRaQ58C5wu6oeqP/wQsJnnUXkIiBXVTNdjC1Uqvt3jsXTzPIfVR2AZ0TyiOlTrEV1/86t8fzV3hXogGeaj1+5FWSQxQID8dx9jwbuF5FewTq5JZcAqeoBVS10lmcCceKZDTMb6ORVtKOzLeLVUOfKkarfBf6nqtNdDDOoaqjzUOBiEdmCp9ngPBF5zb1Ig6eGOu8Adqhq5V3pO3iSTcSroc4jgc2qukdVS4HpwBAXQw2mHcAsVT2kqnuB+UB/gvQdZsklQCJygoiIszwIz3/LfXjGQespIl1FpDFwFZ7BNCNedXV2tr0ErFbVJ92MMdiqq7Oq3qOqHVW1C55/47mq2iD+oq2hzruA7SLS2yk6Ak+HcMSr4f/nbcCZItLU2T+Co4PkRroPgLNFJFZEmuKZ8Xc1QfoOc3PgyrAmIm/geYKkrYjswDPdchyAqj4HXAbcLCJlQDFwlXoetSgTkVvxjOgcA0xR1ZUuVOG4BVpnETkbuAbIEpGlzunudf4CDGt1+HeOWHWs82+B/zlfOpuA8fUcfkDqUOdvReQdPM1mZcASImSImNrqrKqrReRTPNPEVwAvquoK59g6f4fZ8C/GGGOCzprFjDHGBJ0lF2OMMUFnycUYY0zQWXIxxhgTdJZcjDHGBJ0lF9MgiMg/ReR2r/VZIvKi1/o/ROSOIF7vZRG5LFjn8zrvvV7LXWoa0bbKcbd7Dd/h77UWHm98dSUi7ZzHX00DZ8nFNBQLcN6cFpFGQFvAexywIUC9f5kG4N7aixzLGVDxejyjM/tNVf1+09y5Rp2p6h4gR0SGBuN8JnxZcjENxUKgcm6RU4AVwEERaS0iTYCTge9F5P9EZJF45uaYLB4nich3lSdy7hiynOWBIjLPGdhvloikVL1wdWWcAQEfFZHvRGSdiJzjbG8qIm+JZ/6b90TkWxFJE5FJeEbfXSoi/3NOHyMiL4hnvo3PRCTBR93PA75X1TKv6/5TRBaLZ86VM0RkuoisF5GHveIu9Fr+k4hkiWfgxkle53lKRBYDvxOREeIZsDJLPHOFNHHKbRGRv4rI986+k5zt58rR+VGWiEgL53LvA1f7/09rIpElF9MgqOpOPKMjnIjnLuVrPCMznwWkAVnO8OH/VtUzVLUvkABcpKprgMYi0tU53ZXANPGMl/Y0cJmqDgSmAH/zvq4fZWJVdRBwO543pAF+A+xX1T7A/XgGD0RV7waKVfU0Va388u0JPKOqpwD5wKU+qj8UqDqA5hFVTQOewzPMxy1AX+A6EWlTpQ4/xTM442Bn4MbHvHY3ds7zDPAycKWq9sMzusfNXuX2qurpwH+AO51tdwK3qOppwDl43nwHWOysmwbMkotpSBbiSSyVyeVrr/UFTpnhzp1CFp6/+Cubzt7Ck1Rwfk4DeuP5Qp7tDGvzZzyD+HmrrUzlIJ6ZQBdn+Ww8g13iDLexvIY6bVbVpT7O4S0Fz1D43irHgsoCVjpz7hzGM2RLpyplRwL/VdUiJybvOUCmOT97O7Gsc9an4pnbpZKvei4AnhSR2/BMKlbmbM/FM8KwacBsbDHTkFT2u/TD0yy2HfgDcADPHCTxwLNAmqpuF5G/AJVT1k4D3haR6YCq6noR6Yfni7mmqXylljKHnZ/lBPb/22Gv5XI8d1tVFXO0HlWPq6hyjorjjOOQn+V+VE9VnSQiM4ALgAUiMtq5S4zn6F2MaaDszsU0JAuBi4A8VS13/gJPxNM0tpCjX8B7xTP3zA9Pe6nqRjxfjPdz9K/1tUA7ceaJF5E4+fEEaf6UqWoBcIVTvg+eZFip1GlqOx6rgR7HeYy32cB48YyMi4gk+SizFugiIpXXuQaY56PcD0Sku6pmqeqjeEbaPcnZ1QtP8jcNmCUX05Bk4XlK7Jsq2wpUda8zJe8LeL7YZuH5wvM2DfgVniYynD6ay4BHRWQZsJQqc3n4U8aHZ/EkpFXAw8BKoMDZNxlY7tWh749POLaJ6rio6qd4mtEWO017d/ooU4JnBOS3nSbFCjz9OTW53XlwYjlQ6sQJMByYEWi8JjLYqMjG1DMRiQHiVLVERLoDnwO9nUQV6DnfA/6oquuDFWeoiMh8YIyq7nc7FhM61udiTP1rCnzhNH8J8Ju6JBbH3Xg69sM6uYhIO+BJSywNn925GGOMCTrrczHGGBN0llyMMcYEnSUXY4wxQWfJxRhjTNBZcjHGGBN0/x/Pi+UVJYpuYwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2220,6 +40660,7 @@ } ], "source": [ + "%matplotlib inline\n", "plt.figure()\n", "plt.plot(1 / frequencies, top_profile * 100, \"-o\")\n", "plt.grid(True)\n", @@ -2236,13 +40677,6 @@ "# plt.ylim(-0.1,0)\n", "plt.show()" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In summary, it is very easy to implement design constraints and density parameter operations using the native adjoint solver interface. One could use this same design flow to implement robus optimization over many frequency points." - ] } ], "metadata": { @@ -2261,7 +40695,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.10.5" } }, "nbformat": 4,