{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Design of a Coupled Resonator Optical Waveguide band-pass filter with Photontorch" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imports" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "from tqdm.notebook import tqdm # [pip install tqdm]\n", "import torch # [conda install pytorch -c pytorch, only python 3!]\n", "import photontorch as pt # [pip install photontorch] my simulation/optimization library" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Coupled Resonator Optical Waveguide" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A coupled resonator optical waveguide is a cascade of ring resonators.\n", "Such a network with $n$ rings has $2n+1$ parameters that you can optimize: $n$ ring phases and $n+1$ couplings." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Parameters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's define some global simulation parameters:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "c = 299792458.0 # speed of light\n", "ring_length = 50e-6 #[m]\n", "ng=3.4 # group index\n", "neff=2.34 # effective index" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulation Environment" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Photontorch expects a simulation environment to be set. This environment contains all global parameters for a simulation, such as the timestep of the simulation, the speed of light for the simulation, the wavelength, ..." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
keyvaluedescription
nameenvname of the environment
t0.000e+00[s] full 1D time array.
t00.000e+00[s] starting time of the simulation.
t1None[s] ending time of the simulation.
num_t1number of timesteps in the simulation.
dtNone[s] timestep of the simulation
samplerateNone[1/s] samplerate of the simulation.
bitrateNone[1/s] bitrate of the signal.
bitlengthNone[s] bitlength of the signal.
wl[1.500e-06, 1.500e-06, ..., 1.600e-06][m] full 1D wavelength array.
wl01.500e-06[m] start of wavelength range.
wl11.600e-06[m] end of wavelength range.
num_wl1001number of independent wavelengths in the simulation
dwl1.000e-10[m] wavelength step sizebetween wl0 and wl1.
f[1.999e+14, 1.998e+14, ..., 1.874e+14][1/s] full 1D frequency array.
f01.999e+14[1/s] start of frequency range.
f11.874e+14[1/s] end of frequency range.
num_f1001number of independent frequencies in the simulation
df-1.332e+10[1/s] frequency step between f0 and f1.
c2.998e+08[m/s] speed of light used during simulations.
freqdomainTrueonly do frequency domain calculations.
gradFalsetrack gradients during the simulation
\n", "
" ], "text/plain": [ "Environment(name='env', t=array([0.000e+00]), t0=0.000e+00, t1=None, num_t=1, dt=None, samplerate=None, bitrate=None, bitlength=None, wl=array([1.500e-06, 1.500e-06, ..., 1.600e-06]), wl0=1.500e-06, wl1=1.600e-06, num_wl=1001, dwl=1.000e-10, f=array([1.999e+14, 1.998e+14, ..., 1.874e+14]), f0=1.999e+14, f1=1.874e+14, num_f=1001, df=-1.332e+10, c=2.998e+08, freqdomain=True, grad=False)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# define the simulation environment:\n", "env = pt.Environment(\n", " wavelength = 1e-6*np.linspace(1.50, 1.6, 1001), #[m]\n", " freqdomain=True, # we will be doing frequency domain simulations\n", ")\n", "\n", "# set the global simulation environment:\n", "pt.set_environment(env)\n", "\n", "# one can always get the current environment from photontorch:\n", "pt.current_environment()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Components" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The network defined above consists of directional couplers and waveguides. We could use the `photontorch` default components (`pt.Waveguide` and `pt.DirectionalCoupler`), but as a good introduction to photontorch, we will define them ourselves." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Waveguide" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A waveguide is a component with two ports. The waveguide introduces a delay (for time domain simulations; we will not use this here) and a phase shift. An additional `torch` optimizeable parameter is added to the waveguide, which acts as an additional phase shift on top of the phase introduced by the ring length. You can think of this as for example a heater on top of the waveguide which adjusts the phase of the ring." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "class Waveguide(pt.Component):\n", " \"\"\" Waveguide\n", " \n", " Each waveguides has two ports. They are numbered 0 and 1:\n", " \n", " Ports:\n", "\n", " 0 ---- 1\n", "\n", " \"\"\"\n", " \n", " # photontorch requires you to explicitly define the number of \n", " # ports in the component as a class variable:\n", " num_ports = 2\n", "\n", " def __init__(\n", " self,\n", " length=1e-5,\n", " loss=0, # in dB/m\n", " neff=2.34, # effective index of the waveguide\n", " ng=3.40, # group index of the waveguide\n", " wl0=1.55e-6, # center wavelength for which the waveguide is defined\n", " phase=0, # additional phase PARAMETER added to the waveguide\n", " trainable=True, # a flag to make the the component trainable or not\n", " name=None, # name of the waveguide\n", " ):\n", " \"\"\" creation of a new waveguide \"\"\"\n", " super(Waveguide, self).__init__(name=name)# always initialize parent first\n", " # Handle inputs\n", " self.loss = float(loss)\n", " self.neff = float(neff)\n", " self.wl0 = float(wl0)\n", " self.ng = float(ng)\n", " self.length = float(length)\n", " \n", " \n", " # handle phase input\n", " phase = float(phase) % (2*np.pi)\n", " if not trainable: # if the network is not trainable, just store it as a normal float:\n", " self.phase = phase\n", " else: # else, make an optimizable parameter out of it:\n", " # create a torch tensor from the phase\n", " phase = torch.tensor(phase, dtype=torch.float64)\n", " # store the phase as a optimizable parameter\n", " self.phase = torch.nn.Parameter(data=phase)\n", "\n", " def set_delays(self, delays):\n", " \"\"\" set the delays for time-domain simulations \"\"\"\n", " delays[:] = self.ng * self.length / self.env.c\n", "\n", " def set_S(self, S):\n", " \"\"\" set the S-matrix\n", " \n", " NOTE: because PyTorch does not support complex tensors, the real \n", " ane imaginary part of the S-matrix are stored in an extra dimension\n", " \n", " NOTE2: the S-matrix needs to be defined for all wavelengths, therefore\n", " one needs an extra dimension to store each different S-matrix for each \n", " wavelength\n", " \n", " ----------------\n", " \n", " Taking the above two notes into account, the S-matrix is thus a\n", " 4-D tensor with shape\n", " \n", " (2=(real|imag), #wavelengths, #ports, #ports)\n", " \n", " \"\"\"\n", " # during a photontorch simulation, the simulation environment\n", " # containing all the global simulation parameters will be \n", " # available to you as `self.env`:\n", " current_simulation_environment = self.env\n", " \n", " # you can use this environment to get information about the\n", " # wavelengths used in the simulation:\n", " wavelength = current_simulation_environment.wavelength\n", " \n", " # however, this wavelength is stored as a numpy array, while\n", " # photontorch expect torch tensors. We need to make a torch\n", " # tensor out of this:\n", " wavelength = torch.tensor(\n", " wavelength, # make this numpy array into a torch tensor\n", " dtype=torch.float64, # keep float64 dtype\n", " device=self.device, # put it on the current device ('cpu' or 'gpu')\n", " )\n", " \n", " # next we implement the dispersion, which will depend on the\n", " # wavelength tensor\n", " neff = self.neff - (wavelength - self.wl0) * (self.ng - self.neff) / self.wl0\n", " \n", " # we have now calculated an neff for each different wavelength.\n", " # let's calculate the phase depending on this neff:\n", " phase = (2 * np.pi * neff * self.length / wavelength) % (2 * np.pi)\n", " \n", " # next, we add the phase correction parameter.\n", " phase = phase + self.phase\n", " # note that in pytorch, inplace operations, such as\n", " # phase += self.phase\n", " # are not allowed, as they obscure the computation graph necessary to \n", " # perform the backpropagation algorithm later on...\n", " \n", " # because pytorch does not allow complex numbers, we split up exp(1j*phase) into\n", " # its real and imaginary part and revert back to the default dtype (usually float32).\n", " cos_phase = torch.cos(phase).to(torch.get_default_dtype())\n", " sin_phase = torch.sin(phase).to(torch.get_default_dtype())\n", "\n", " # finally, we can calculate the loss and add it to the phase, which\n", " # gives us the S-matrix parameters\n", " loss = 10 ** (-self.loss * self.length / 20) # 20 because loss works on power\n", " re = loss * cos_phase\n", " ie = loss * sin_phase\n", "\n", " # the last thing to do is to add the S-matrix parameters to the S-matrix:\n", " S[0, :, 0, 1] = S[0, :, 1, 0] = re\n", " S[1, :, 0, 1] = S[1, :, 1, 0] = ie" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Directional Coupler" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second component we need is a directional coupler. A directional coupler has a single optimizeable parameter: its **coupling**. It introduces no delays." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "class DirectionalCoupler(pt.Component):\n", " r\"\"\" A directional coupler is a component with 4 ports that introduces no delays\n", " \n", " Each directional coupler has four ports. They are numbered 0 to 3:\n", "\n", " Ports:\n", " 3 2\n", " \\______/\n", " /------\\\n", " 0 1\n", "\n", " \"\"\"\n", "\n", " # photontorch requires you to explicitly define the number of \n", " # ports in the component as a class variable:\n", " num_ports = 4\n", "\n", " def __init__(self, coupling=0.5, name=None):\n", " \"\"\" creation of a new waveguide \"\"\"\n", " super(DirectionalCoupler, self).__init__(name=name)# always initialize parent first\n", " \n", " # to save the coupling as an optimizable parameter, we could just do the\n", " # same as we did for the waveguide: create a torch tensor and store it as a parameter:\n", " # coupling = torch.tensor(float(coupling))\n", " # self.phase = torch.nn.Parameter(data=coupling)\n", " \n", " # however, this could lead to problems, as this parameter would be unbounded\n", " # and we know for a fact the coupling should be bounded between 0 and 1.\n", " # an easy solution is to define the coupling as the cosine of a hidden parameter\n", " # which we call (with little imagination) `parameter`:\n", " \n", " # create a parameter. The coupling will be derived from the parameter as cos(self.parameter):\n", " parameter = torch.tensor(np.arccos(float(coupling)), dtype=torch.get_default_dtype())\n", " self.parameter = torch.nn.Parameter(data=parameter)\n", " \n", " @property\n", " def coupling(self):\n", " return torch.cos(self.parameter)\n", "\n", " def set_S(self, S):\n", " \"\"\" Fill the S-matrix with elements. Rememeber that the S-matrix has a shape\n", " \n", " (2=(real|imag), #wavelengths, #ports, #ports)\n", " \n", " \"\"\"\n", " \n", " t = (1 - self.coupling) ** 0.5\n", " k = self.coupling ** 0.5\n", "\n", " # real part scattering matrix (transmission):\n", " S[0, :, 0, 1] = S[0, :, 1, 0] = t # same for all wavelengths\n", " S[0, :, 2, 3] = S[0, :, 3, 2] = t # same for all wavelengths\n", "\n", " # imag part scattering matrix (coupling):\n", " S[1, :, 0, 2] = S[1, :, 2, 0] = k # same for all wavelengths\n", " S[1, :, 1, 3] = S[1, :, 3, 1] = k # same for all wavelengths" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A first filter: the AllPass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a first \"filter\" we define a simple AllPass filter, which we define as a photontorch `Network` of a `Waveguide` and a `DirectionalCoupler`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Network Definition" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class AllPass(pt.Network):\n", " def __init__(\n", " self,\n", " ring_length=1e-5, #[um] length of the ring\n", " ring_loss=1, #[dB]: roundtrip loss in the ring\n", " name=None\n", " ):\n", " super(AllPass, self).__init__(name=name) # always initialize parent first\n", " \n", " # handle arguments:\n", " self.ring_length = float(ring_length)\n", " self.ring_loss = float(ring_loss),\n", " \n", " # define subcomponents\n", " self.source = pt.Source()\n", " self.detector = pt.Detector()\n", " self.dc = DirectionalCoupler()\n", " self.wg = Waveguide(length=ring_length, loss=ring_loss/ring_length)\n", "\n", " # link subcomponents together:\n", "\n", " # The `link` method takes an arbitrary number of string arguments. \n", " # Each argument contains the component name together with a port numbe\n", " # in front of and a port number behind the name (e.g. `\"0:wg:1\"`).\n", " # The port number behind the name will connect to the port number \n", " # in front of the next name. The first component does not need \n", " # a port number in front of it, while the last component does \n", " # not need a port number behind.\n", "\n", " self.link('source:0', '0:dc:2', '0:wg:1', '3:dc:1', '0:detector')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we have to create an instance of our network" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "allpass = AllPass()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can simulate the AllPass filter by just using it as a normal function on a source array. What you will get out is the detected array. If you are just simulating a constant source (which obviously is the case in the frequency domain), one can just add a source amplitude:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([1, 1001, 1, 1])\n" ] } ], "source": [ "detected = allpass(source=1)\n", "print(detected.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see that we get a 4D array out. This is always the case. Photontorch always returns 4D arrays. The shape of the array corresponds to\n", "```\n", " (# timesteps, # wavelengths, # detectors, # parallel simulations)\n", "```\n", "In this case, we only simulated for a single timestep, as we are doing a frequency domain simulation. Moreover, we simulated for 1001 wavelengths and we had a single detector in the network. The number of parallel simulations can be useful for training purposes, as we will see later." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Each network also has a plotting function that smartly handles the 4D detected array and gives you the most useful plot possible:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "allpass.plot(detected)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimization" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is neat, but what if we want to filter out the wavelength at 1550nm: We can shift the transmission minimum to 1550nm as follows:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First we define a target function for the transmission at 1550nm. We want it to be as close as possible to 0, so let's just take 0:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "target = torch.tensor(0.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we choose a loss to be optimized. Let's take the [MSE loss](https://en.wikipedia.org/wiki/Mean_squared_error):" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "lossfunc = torch.nn.MSELoss()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we need to choose an optimizer to find the minimum in the loss for us. PyTorch has a [whole collection](https://pytorch.org/docs/stable/optim.html) of optimizers readily available. They are all based on a version of gradient descent. However, if you do not know which one to use, the `Adam` optimizer is always a good choice:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# to define an optimizer, one needs to provide the parameters to optimize\n", "# and the learning rate of the optimizer. \n", "# the learning rate is an important parameter that needs to be tuned manually to \n", "# the right value. A too large learning rate will result in an optimizer that cannot find the loss\n", "# a too small value may result in a very long optimization time:\n", "optimizer = torch.optim.Adam([allpass.wg.phase], lr=0.03) # let's just optimize the phase of the ring" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Furthermore, for this optimization, we will just simulate at a single wavelength: 1550nm. We can define a new environment. Also, we will use this environment for training purposes so **one needs to allow gradient tracking**:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "train_env = pt.Environment(\n", " wl=1.55e-6, #[m]\n", " freqdomain=True, # we will be doing frequency domain simulations\n", " grad=True, # allow gradient tracking\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that this environment is not yet enabled. One can do this globally with the `pt.set_environment` function. However, we will choose to only *temporarily* use this environment by using a **context-manager** or **with-block**:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e9f86f74993d4cf9b29750e0f548e847", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=0.0, max=400.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "loss: 0.06149\n" ] } ], "source": [ "with train_env: # temporarily override the global environment\n", " # we train for 400 training steps\n", " for i in tqdm(range(400)):\n", " optimizer.zero_grad() # set all the gradients to zero\n", " result = torch.squeeze(allpass(source=1)) # squeeze: 4D -> 0D\n", " loss = lossfunc(result, target) # MSE loss\n", " loss.backward() # calculate the gradients\n", " optimizer.step() # use the calculated gradients to perform an optimization step\n", "\n", "print(\"loss: %.5f\"%loss.item())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that the allpass filter is trained to have minimal transmission at 1550 nm, Let's have a look by simulating it again:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhcZ3n38e+tfV9sSV7kXd6XbDaOYxISUgpJoFlaloQQlpaGQEOhLbxAS2kohUJbCgQCIVDgTV9KEiBNQxIIbZpAQjbbWbzvji3ZsixZtiVZ1jr3+8c5ciayJI/lGc2M5ve5rrlm5pwzZ+7HHs09z3Kex9wdERHJXFnJDkBERJJLiUBEJMMpEYiIZDglAhGRDKdEICKS4ZQIREQyXMISgZn9wMwOmdnGYfabmd1uZjvNbL2ZXZCoWEREZHiJrBH8CLhihP1XAvPC283AdxIYi4iIDCNhicDdfwu0jnDINcDdHngWqDCzKYmKR0REhpaTxPeuBeqjnjeE2xoHH2hmNxPUGiguLl6+cOHCMQlQ5Iy07Ajuq+YlNw6RIaxbt67F3auH2pfMRGBDbBtyvgt3vwu4C2DFihW+du3aRMYlMjo/fGtw/4GHkxuHyBDMbO9w+5I5aqgBmB71fBpwIEmxiIhkrGQmggeB94ajh1YBx9z9lGYhERFJrIQ1DZnZT4DLgCozawD+DsgFcPc7gUeAq4CdQCfwgUTFIiIiw0tYInD3G06z34E/S9T7i4hIbHRlsYhIhlMiEBHJcMkcPjouRSLO0RO9tHR009zeTevxHtq7+mjr6qW9qzd4fCK4P97TR09fhO6+yMn77r5+esLn0QaPq802Iy8n69Vb9quP83OyKMnPpawgh5KCHEoLcigtyD15P6Eoj+rSfKpK8qgsyiMra6iRvCKpIRJx2rp6OdLZy9HOHo529nIkvD92opfOnj46e/o50dPP8ajHnT39dPX10x9x+vqdvkgkeBxx+vvD+4hjBllmZGfZax5nhY9zs7PIz82iMDebgtzs8D6LgvB5UV425YW5lBXkBveFA/c5lBfmMrE4n8K87GT/M45IieAMdfb0Ud96gvrWTuqPdLKvtZP61hM0tXXR3N5NS0c3fZGhl//MzrLwyziHsoJcivKyKcrLobIo+KDlZWeRn5NNfm4WOVlZDP5+tqjnfRE/mTB6+iOvedzdG2H/0RNsDRNPe1cvw4REdpYxsThIDNWl+dRWFDJ9QhHTK4uYPqGQ6ZVFVBTlYqZkIfEXiThN7V280tJJw5FODrV3c/BYFwfbumhq6+LgsS5aOrqH/fwCFIZfxoV5A/c5FOVmM6U8l4K8bHKzjOysLHKyjJxsI2fgebaRZYbjRCJOxCHirz7ud8fd6elzuvr66QoTS2dPH63HI3T19tPV209Hdx/t3X2MtOpvaX4O1WX51JTmM6msgJrSfGpKC5haUciMCUXMmFBEeVFu/P+BY6REMIze/gjbDraz7WA725sGbh3sP3riNccV5WUzvbKIyeUFLJxcevILNfjFnc+E4jzKwl/jRXnZSflCdXc6e/pPJoXW4z00d3TT0t4d3gfPD7V38VL9UY529r7m9aUFOcyrKWHB5FLm1ZSyYHIp8ycFZRWJRVdvPzsPdbC5sY0dTe28criTvYePs/dwJ92Dar8VRblMKi1gUvg3VVNaQGVxHpVFuVQU5VJRlEdFYS6VRXmUFeaSnQI12kjE6ejp41hYS2k70UtbV/C4paOH5vbg7+tQWzcv7jvKofYuunpfW+6yghxmTAySwuyqYuZPCv7W5lSVkJeT2FZ8JYLQobYu1rxyhBf3HeGl+qNs2H/s5Ac0LzuLOdXFLJ9ZyQ0rpzNjYjHTK4NfzhOL81L+17KZUZyfQ3F+DpPLC057fHtXb1DrOdJJfWsnew93sr2pnV9tPMhPOl+dFWRqeQHnzajgvOkVnD+jkmW15RTkpnYVWBKvpy/CpgPHWLf3COsbjrGlsY3dLcfpD3/W5+dkMXNiETMnFnPp/GpmVRUza2Ix0yoLmVRWkJafoawso6wgaB6afvrDcXfau/vYf+RE2KoQtC7sa+1ka2M7j25qOvnvlZNlzKkuZsHkMv7gnCm8ecnkuMefsYngRE8/z+45zFM7WnhqRwvbmtoByMvJYlltOe9ZNZNzp1eweEoZsyYWkZOdOf3qpQW5LJ6ay+KpZa/Z7u40d3Szo6mDLY1tvNxwjBf3HeGRDQeB4N9uxcxKLp5XxSVzq1kytUz9Dxmgpy/Cur1HeGpnM2teOcLL9UdP/oiaWl7AoillvGXJZBZNKWPRlFJmTixOiV/xyWQWJo4puSyaUnbK/u6+fva0HH9Nq8QLe4+wYFJJQhKB+UgNWynobOYa6uzp44ltzTy8oZHHtx6is6efvJwsVs6awMXzqrhozkQWTSlLeDVsvGlu7+bl+qM8t+cwT+5oYevBIKlOKM7jzYsnceWyKayum0jueE+mGTTXUEtHN7/e1MQT2w7x9K7DdHT3kZNlLJlaxvKZE1gxq5IVMyupKTt9DVRiF4n4qH9cmdk6d18x1L6MqRH8ckMjf3nfy5zo7WdicR7Xnl/LW5ZM5sLZE9KyKppKqkvzedPiSbxp8SQADrV38fTOw/zv1kP84uUD3LOmnvLCXK5aNpl3vW4G504rT/nmNDnVsc5efrmxkYfWN/L0rhYiDrUVhVx93lQunV/N6rqJlBYkr8MzEySqhp0xiWDhlDL+aHktVy2bwoWzJ2Z81TSRakoLuPb8Wq49v5au3n6e3NHCIxsaeeDFA/zk+XoWTi7lhpUzePvyaRTnZ8xHMC25Oy/sO8qPn9vLQ+sb6emLMHNiER++rI63nTOVhZNLldTHgYxqGpLkauvq5cGXDnDPmn1s3N9GRVEu77toFu9bPYsJxXnJDu/sjaOmob7+CA9vaOTO3+xmS2MbJfk5XHd+Le9YMY1ltarRpSM1DUlKKCvI5T2rZvKeVTNZt7eV7zyxm288toO7frubP33DHG5+wxxKVENIqr7+CPe/sJ9vP7GTVw53Mq+mhC9dt4yrz5uq/5txTP+zkhTLZ07g+++bwI6mdr7+2A5uf2wH//HcPv7qzfN514rpGm2UBI9vO8QXH97CzkMdLKst5873LOfNiyfp/yIDKBFIUs2bVMod776AP73kKF96ZAufuX8D97/QwD/+4TLm1pQmO7yM0HCkk88+sJEntjUza2IRd75nOW9ZMknNPxlEiUBSwnnTK7j35lX8/IX9/MPDm7nqG0/xF78/nw+9YY5+kSZIJOL8+Lm9fPmXWwH47FsX8d6LZmn4dAZSIpCUYWa8ffk0LltQzef+ayNf+dVWnt19mH9957lMLNF0FvHU0tHNx+95iad2tnDJvCr+8Q+XMa2yKNlhSZIo9UvKqSrJ5453X8CXrlvGM7sPc9XtT7Jx/7FkhzVurH2llbfd/hRrXmnli9ct5e4/XqkkkOGUCCQlmRnvvnAGD3zk9eRkZfHO7z7DY1uakh1W2vvZugauv+tZ8nOzuP8jq7nxwpnqCxAlAklti6eW8Z8fWU1ddQl/evda7l2zL9khpSV3547Hd/KJn77MhXMm8OCtF7Nkanmyw5IUoUQgKa+mrIB7P7SKS+ZV86mfb+Ce55UMzoS78/cPbeafH93GdefX8sP3r6S8UFNByKuUCCQtFOXl8N2blvPGBdV8+v4N3Le2/vQvEtydLz2yhR/+7hX++PWz+dd3nqtRQXIKfSIkbRTkZnPnTct5w/xqPnP/Bp7YdijZIaW8r/3PDr735B7ed9FM/vZti9QfIENSIpC0kp+TzbdvvIAFk0r5sx+/oNFEI/jp2npuf2wH71wxjduuXqIkIMNSIpC0U5Kfww8/8DrKC3P50L+v48jxnmSHlHKe3X2Yv/7PDVw8t4ovXrdMSUBGpEQgaWlSWQF33rSc5vZu/vK+l4iMtLp5hjl4rIuP/PgFZkwo4o4bLxj/CwLJWdMnRNLWOdMq+OzbFvH4tma++9vdyQ4nJfRHnI/d8yInevr57k0rNDpIYqJEIGntplUzeeuyKXz119vYfKAt2eEk3e2P7eC5Pa184dqlzK0pSXY4kiaUCCStmRn/cO1SKory+OTPXqa3P5LskJJmQ8Mxvvm/O7ju/FrevnxassORNKJEIGmvsjiPf7h2KZsOtPHd3+xKdjhJ0dsf4VM/X8/Eknxuu3pJssORNKNEIOPCFUsnc9WyyXzr8Z3sP3oi2eGMuX97ag+bG9v4+6uXqF9AzpgSgYwbf/PWxbjDPz6yJdmhjKmGI518/X+28+bFk7hi6eRkhyNpSIlAxo3aikJuubSOh9Y38tzuw8kOZ8z8y6PbcIe/00VjMkpKBDKu3HJpHVPKC/jKr7biPv6vLVjfcJQHXjrAn1w8m9qKwmSHI2lKiUDGlcK8bG69fC4v7DvKE9ubkx1OQrk7X3x4CxOL8/jwZXXJDkfSmBKBjDvvWD6daZWFfO2/t4/rWsEzuw/z3J5WPnr5XEoL1EEso5fQRGBmV5jZNjPbaWafHmJ/uZn9wsxeNrNNZvaBRMYjmSEvJ4s/v3we6xuO8b9bx+8Mpd98bCfVpflcv3JGskORNJewRGBm2cAdwJXAYuAGM1s86LA/Aza7+7nAZcBXzSwvUTFJ5rjuglqmlhfwvSfH59QTa19p5Zndh/nQG+ZQkJud7HAkzSWyRrAS2Onuu929B7gHuGbQMQ6UWjDUoQRoBfoSGJNkiNzsLN7/+lk8u7t1XE5VfcfjO5lQnMe7L1RtQM5eIhNBLRC9jFRDuC3at4BFwAFgA/Axdz9ljgAzu9nM1prZ2ubm8d0BKPHzrtfNoDgvm397ak+yQ4mr3c0dPL6tmZtWzaQoLyfZ4cg4kMhEMNSA5sE9d28BXgKmAucB3zKzslNe5H6Xu69w9xXV1dXxj1TGpfLCXN75uun84uUDNLV1JTucuLn7mb3kZhs3rlJtQOIjkYmgAZge9XwawS//aB8A7vfATmAPsDCBMUmGed9Fs+iLOD9b15DsUOKio7uPn61r4KplU6gpLUh2ODJOJDIRrAHmmdnssAP4euDBQcfsA34PwMwmAQuA8dm7J0kxq6qYVXMmcO+a+nGxeM39LzTQ0d3H+1bPSnYoMo4kLBG4ex9wK/AosAW4z903mdktZnZLeNgXgNVmtgF4DPiUu7ckKibJTNe/bgb7Wjt5dk/6Tztx75p6lkwt4/zpFckORcaRhPY0ufsjwCODtt0Z9fgA8OZExiByxdLJlP5XDveuqWd1XVWywxm1LY1tbDrQxm1/sFhzCklc6cpiGfcKcrO57vxafrnxIG1dvckOZ9R+vq6B3Gzj6vMGD74TOTtKBJIRrjmvlp6+CP+zuSnZoYxKX3+EB146wOULa5hQrGsuJb6UCCQjXDCjgtqKQh5a35jsUEblyR0ttHR080cXaAlKiT8lAskIZsZbz5nCkzuaOdaZfs1Dv1h/gPLCXC5bUJPsUGQcUiKQjPHWZVPo7Xce3XQw2aGckYEmrTctmkRejv5kJf70qZKMcc60cmZMKOKhDenVPPTM7sO0dfVxpZahlARRIpCMYWZcuXQyz+xqoaM7feY2/OWGRkryc7h4XvoOfZXUpkQgGeWNC2vo7Xee2pEekxf29Uf49eYmLl9Yo+mmJWGUCCSjLJ9ZSVlBDo9tSY8Fa9buPULr8R41C0lCKRFIRsnNzuLSBTU8vq05LeYeemJbMzlZxiXzNeuuJI4SgWScyxdW09LRzYY0WLDmiW2HWDGrkpJ8rTsgiaNEIBnn0vk1ZBk8tiW1rzJuauti68F2XTsgCadEIBlnQnEe506v4MmdqT3R7W+2BR3aly1Qs5AklhKBZKTX11WxvuEY7Sk8Cd0T2w8xuayABZNKkx2KjHNKBJKRVtdNpD/irHmlNdmhDKmvP8KTO1q4dH61ppyWhFMikIx0wcxK8nKyeHpnai5Ws+lAG+1dfbqITMaEEoFkpILcbFbMrOTpXamZCJ7dHcR14ZwJSY5EMoESgWSs1XUT2dzYRuvxnmSHcopndx+mrrpYC9TLmFAikIx1Ubhs5TMpVivo64+w9pUjXDhnYrJDkQyhRCAZ65xp5RTmZqdch/Hmxjbau/tYpUQgY0SJQDJWbnYW502vYN3eI8kO5TUG+gdWzVb/gIwNJQLJaMtnVrK5sY3OntSZlvq53a3MqSqmpkz9AzI2lAgkoy2fWUl/xHm5PjXmHYqE1zasVG1AxpASgWS082dUAPDCvtRoHtrdcpy2rj4umFmZ7FAkgygRSEarKMpjbk1JyvQTvBgmpAvCBCUyFoad29bMHozh9a3u/v74hSMy9pbPqOTRzQeJRJysrORO5/Bi/VFKC3KYU1WS1Dgks4w0yfki4IMj7DfgjviGIzL2ls+s5N619exuOc7cmuR+Ab+47yjnTa9IekKSzDJSIvgbd//NSC82s8/HOR6RMXfBzKAZ5sV9R5KaCI5397HtYBu/f/m8pMUgmWnYPgJ3v+90L47lGJFUN7uqhKK8bDYmecWy9Q3HiPirHdgiY2VUncVmdnO8AxFJluwsY+nU8qQvXflifdBRfP50JQIZW6MdNaQGTBlXltaWs7mxjb7+SNJieHHfUeZUFVNRlJe0GCQzjSoRuPt34x2ISDItm1ZGV2+Enc0dSYth4/5jLJtWnrT3l8w1UmcxAGb2uaG2u/vfxz8ckeRYVhs0x2xoOMbCyWVj/v6HO7ppPNbF0qlKBDL2YqkRHI+69QNXArMSGJPImJtTVUxxEjuMNx1oA2BJ7dgnIZHT1gjc/avRz83sX4BYLjbDzK4AvgFkA9939y8PccxlwNeBXKDF3S+N5dwi8ZSVZSyZWs76JCWCjQeC912iGoEkwWj6CIqAOac7yMyyCS44uxJYDNxgZosHHVMBfBu42t2XAO8YRTwicbFsWjlbktRhvOlAG9MnFFJemDvm7y0SSx/BBsDDp9lANRBL/8BKYKe77w7Pcw9wDbA56ph3A/e7+z4Adz8Ue+gi8bW0Nugw3tV8nAWTS8f0vTftP6b+AUma0yYC4G1Rj/uAJnePZfL2WqA+6nkDcOGgY+YDuWb2BFAKfMPd7x58ovC6hZsBZsyYEcNbi5y5RVOC9vmtB9vGNBG0dfXyyuFO3rFi+pi9p0i0WPoI9o7y3ENda+CDnucAy4HfAwqBZ8zsWXffPiiGu4C7AFasWDH4HCJxMaeqhNxsY+vBdq4Zw/fdEnYUL56qjmJJjtFeWfxQDIc1ANE/caYBB4Y45lfuftzdW4DfAueOJiaRs5WXk0VddQlbG9vG9H03holATUOSLKO9svhPYzhmDTDPzGabWR5wPaeONvov4BIzyzGzIoKmoy2jjEnkrC2aUsbWg+1j+p5bGtuoLs2nujR/TN9XZMBoryxujOGYPuBW4FGCL/f73H2Tmd1iZreEx2wBfgWsB54nGGK6cTQxicTDwsmlNB7r4mhnz5i95/amdhaOcee0SLRYRg3NA/6RYAjoydW03f20Q0jd/RHgkUHb7hz0/J+Bf44xXpGEWniyw7idVXMmJvz9+iPO9qZ2brxwZsLfS2Q4sdQIfgh8h2DE0BuBu4F/T2RQIsmyKPxlPlb9BPWtnXT1RlgwSTUCSZ5YEkGhuz8GmLvvdffbgMsTG5ZIclSX5jOhOG/M+gkG3mesr1sQiRbLdQRdZpYF7DCzW4H9QE1iwxJJDjNj4eRStoxRItje1I4ZzJukNYoleWKpEXycYFqJPycY8/8e4H2JDEokmRZMLmXbwTYikcRfsrKtqZ0ZE4ooyovlN5lIYsRyQdma8GEH8IHEhiOSfPMnldLVG2H/0RNMn1CU0PfadrCd+eofkCQbtkZgZred7sWxHCOSbgYWsN95KLGL1HT39bOn5bg6iiXpRqoRfNDMRho6YQQXid0W14hEkmxudZAIdhxq540LE9cdtuvQcfojro5iSbqREsH3CCaCG8n34hiLSEqoLM6jqiQ/4TWC7U0aMSSpYdhE4O6fH8tARFLJ3JpidiQ4EWw92E5utjG7qjih7yNyOqOda0hkXJtXU8rOpg7cEzdyaEdTezjjqf4MJbn0CRQZwrxJJbR393GovTth77GrueNkx7RIMp02EZjZhLEIRCSVnOwwbkpM81B3Xz/7Wjupq1azkCRfLDWC58zsp2Z2lZkNtdiMyLgzd9LAENLEXGG893AnEYc61QgkBcSSCOYTrA52E7DTzL5kZvMTG5ZIclWX5FNemJuwDuOBEUl11UoEknynTQQe+G93vwH4IMH0Es+b2W/M7KKERyiSBGbG3JqShCWCXeF556hpSFJALH0EE83sY2a2FvgE8FGgCvgr4D8SHJ9I0syrKTn5hR1vu5o7qK0o1BxDkhJiaRp6BigDrnX3t7r7/e7e5+5rgTtP81qRtDW3poTDx3toPR7/1cp2NR9XbUBSRiyJ4LPu/gV3bxjYYGbvAHD3ryQsMpEkG+jI3dUc31qBu7OruUP9A5IyYkkEnx5i22fiHYhIqhkYQhrv5qHGY1109vRrxJCkjGEbKM3sSuAqoNbMbo/aVUawbKXIuFZbUUh+Tlbc5xwaqGHoGgJJFSP1VB0A1gJXA+uitrcDf5HIoERSQVaWMae6JO5NQwM1DF1VLKlipEnnXgZeNrMfu7tqAJKR6qqLWd9wLK7n3NV8nNKCHKpL8uN6XpHRGmlhmvvChy+a2fqo2wYzWz9G8Ykk1dyaEuqPdNLV2x+3cw50FOtCfUkVIzUNfSy8f9tYBCKSiuqqS3CHPS3HWTSlLC7n3NXcwcVzq+NyLpF4GLZG4O6N4cMWoN7d9wL5wLkE/Qci497AEM949RO0dfXS1NZNXY06iiV1xDJ89LdAgZnVAo8RLGD/o0QGJZIq5lQXYxYsKxkPu5uD8+gaAkklsSQCc/dO4A+Bb7r7dcDixIYlkhoKcrOZVlnIzjjVCDRiSFJRTIkgnFzuRuDhcJsmSJGMUVcdvzmHdjV3kJNlzJhQFJfzicRDLIngYwRXEv+nu28ysznA44kNSyR11FWXsLulg0jk7Jet3NXcwYyJRVqeUlLKaX/Zu/tvCfoJBp7vBv48kUGJpJK5NSV09UbYf/QE08/yl/yu5uMnp64QSRWnTQThIjSfAGZFH+/ulycuLJHUET1y6GwSQV9/hL2Hj/OmRZPiFZpIXMTS1v9Tgummvw/E76oakTQxMCfQrubjXLZg9OepP3KC3n7XHEOScmJJBH3u/p2ERyKSoiaW5FNZlHvW1xIMdDhr1lFJNbH0WP3CzD5iZlPMbMLALeGRiaSQuuqSs56F9OSso1VKBJJaYqkRvC+8/2TUNgfmxD8ckdRUV13CY1ubzuocu5uPU1WSR3lRbpyiEomPWBavnz3ELaYkYGZXmNk2M9tpZkMtcDNw3OvMrN/M3n4mwYuMlbqaYlo6ejjaOfplK3c1dzBHI4YkBcWyeH2RmX3WzO4Kn88zs9NORGdm2cAdwJUEVyLfYGanXJEcHvcV4NEzDV5krMyNw7KVwayj6iiW1BNLH8EPgR5gdfi8AfiHGF63Etjp7rvdvQe4B7hmiOM+CvwcOBTDOUWS4uQQ0lHOOdR6vIcjnb2aY0hSUiyJoM7d/wnoBXD3E0AsE6nXAvVRzxvCbSeFE9ldRzA8dVhmdrOZrTWztc3NzTG8tUh8TassIi8na9Q1gt0nl6dUIpDUE0si6DGzQoIOYsysDuiO4XVDJYvB1+h/HfiUu494fYK73+XuK9x9RXW15nGXsZedZcypKh71yKGBWUfnqGlIUlAso4ZuA34FTDezHwOvJ5iK+nQagOlRz6dx6joGK4B7wpWaqoCrzKzP3R+I4fwiY6quuoRNB0a3bOWu5g7ysrOYVqnJ5iT1xDLX0K/NbB2wiuBX/sfcvSWGc68B5pnZbGA/cD3w7kHnnj3w2Mx+BDykJCCpqq66mF9ubKS7r5/8nOwzeu2u5g5mVxWTnaXlKSX1xDJq6DF3P+zuD7v7Q+7eYmaPne514YL3txKMBtoC3BfOXnqLmd1y9qGLjK26mhIiDnsPd57xa3c3H1ezkKSsYWsEZlYAFAFVZlbJq23+ZcDUWE7u7o8AjwzaNmTHsLu/P5ZziiTLQEfvzkMdzJ9UGvPrevoi7G3t5KplUxIVmshZGalp6EPAxwm+9NfxaiJoI7g+QCSjDPyiP9NFava1Hqc/4lqnWFLWsInA3b8BfMPMPuru3xzDmERSUlFeDrUVhWc8hHTXwIghzTEkKSqWzuJvmtlqTl2P4O4ExiWSkupqSs54/eKBIafqI5BUFcvCNP8O1AEv8ep6BA4oEUjGqasuZs2eViIRJyvGEUA7mtqprSiktECTzUlqiuU6ghXAYnc/+wVbRdJcXXUJJ3r7OdjWxdSKwphes62pg3mT1CwkqSuWK4s3ApMTHYhIOohetjIWff0Rdh3qYMEZjDISGWux1AiqgM1m9jxRU0u4+9UJi0okRQ3MQrrzUAeXzDv9dCevHO6kpz9yRsNNRcZarFNMiAhQVZJHWUFOzDWC7U3tACyYrEQgqSuWUUO/GYtARNKBmVFXUxLzdNTbDrZj9mpNQiQVjXRlcTunzhYKwYVl7u5lCYtKJIXNrS7hie2xTYe+vamdWROLKcg9s7mJRMbSsJ3F7l7q7mVD3EqVBCST1dWU0NzezbETvac9dltTO/M1YkhSXCyjhkQkyrywmWdH2P4/nBM9/bzSclwjhiTlKRGInKGlteUAbNg/8toEmxvbiPirx4ukKiUCkTM0qayA6tL80yaCDQ1HAVg2TYlAUpsSgcgoLKstZ0PDaRLB/jaqSvKZXFYwRlGJjI4SgcgoLK0tZ1dzB509fcMes2H/UZbVlhEuxSqSspQIREZhWW05EYfNB9qG3N/Z08fOQx0sm1YxxpGJnDklApFRODds93+p/uiQ+zfuDzqKz1FHsaQBJQKRUagpK2DmxCKe39M65P7ndh8GYMWsyrEMS2RUlAhERmnlrAk8/0qwNsFgz+1pZeHkUiqK8pIQmciZUSIQGaWVsydwtLOX7Ydee2FZb3+EdXuPcOHsCUmKTOTMKBGIjNLquVUAPLHttfMOPb+nlRO9/Sf3i6Q6Jcui0VQAAAtaSURBVAKRUaqtKGRpbRmPbjr4mu2PbjpIQW4Wb4hhvQKRVKBEIHIW3rJ4Mi/uO8rBY10AOM6vNzVx6fxqCvM046ikByUCkbPwB+dOBeAnz+8D4GhnLwfburj63NpkhiVyRpQIRM7CrKpi3rSohh/8bg9dff3Ut3ZSW1HIW5ZMSnZoIjFTIhA5S3/z1sX09Tsv1R+ls7ef265eQk62/rQkfcSyZrGIjGB2VTE/+/BFFP44n8qiPCoXqzYg6UWJQCQOlkwthyqtRCbpSfVXEZEMp0QgIpLhlAhERDKcEoGISIZTIhARyXAJTQRmdoWZbTOznWb26SH232hm68Pb02Z2biLjERGRUyUsEZhZNnAHcCWwGLjBzBYPOmwPcKm7nwN8AbgrUfGIiMjQElkjWAnsdPfd7t4D3ANcE32Auz/t7kfCp88C0xIYj4iIDCGRiaAWqI963hBuG86fAL8caoeZ3Wxma81sbXNz81CHiIjIKCUyEdgQ205d0w8wszcSJIJPDbXf3e9y9xXuvqK6WnO8i4jEUyKnmGgApkc9nwYcGHyQmZ0DfB+40t0PJzAeEREZQiJrBGuAeWY228zygOuBB6MPMLMZwP3ATe6+PYGxiIjIMBJWI3D3PjO7FXgUyAZ+4O6bzOyWcP+dwOeAicC3zQygz91XJComERE5VUJnH3X3R4BHBm27M+rxB4EPJjIGEREZma4sFhHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDKRGIiGQ4JQIRkQynRCAikuGUCEREMpwSgYhIhlMiEBHJcEoEIiIZTolARCTDJTQRmNkVZrbNzHaa2aeH2G9mdnu4f72ZXZDIeERE5FQJSwRmlg3cAVwJLAZuMLPFgw67EpgX3m4GvpOoeEREZGiJrBGsBHa6+2537wHuAa4ZdMw1wN0eeBaoMLMpCYxJREQGyUnguWuB+qjnDcCFMRxTCzRGH2RmNxPUGAA6zGzbKGOqAlpG+dp0pTKPtT+2ZLyr/p8zw9mUeeZwOxKZCIb6a/BRHIO73wXcddYBma119xVne550ojJnBpU5MySqzIlsGmoApkc9nwYcGMUxIiKSQIlMBGuAeWY228zygOuBBwcd8yDw3nD00CrgmLs3Dj6RiIgkTsKahty9z8xuBR4FsoEfuPsmM7sl3H8n8AhwFbAT6AQ+kKh4QmfdvJSGVObMoDJnhoSU2dxPaZIXEZEMoiuLRUQynBKBiEiGS/tEYGY/MLNDZrYxatttZrbfzF4Kb1dF7ftMOKXFNjN7S9T25Wa2Idx3u5klZTB4LM6kzGb2+2a2LizbOjO7POo147LMUftnmFmHmX0ialtalHkUn+tzzOwZM9sUlq8g3J4W5YUz/lznmtn/Dcu2xcw+E/WatC5zuP2j4XfUJjP7p6jtifn+cve0vgFvAC4ANkZtuw34xBDHLgZeBvKB2cAuIDvc9zxwEcG1Db8Erkx22eJU5vOBqeHjpcD+qH3jssxR+38O/DT6mHQp8xn+H+cA64Fzw+cTM+Bz/W7gnvBxEfAKMGuclPmNwP8A+eHzmvA+Yd9faV8jcPffAq0xHn4NwYen2933EIxWWmnBtBZl7v6MB/+qdwPXJibis3cmZXb3F9194NqMTUCBmeWP5zIDmNm1wG6CMg9sS5syn2F53wysd/eXw9cedvf+dCovnHGZHSg2sxygEOgB2sZJmT8MfNndu8NjDoXbE/b9lfaJYAS3WjCj6Q/MrDLcNtyUFrXh48Hb081QZY72R8CL4Qds3JbZzIqBTwGfH3TseCjzUP/H8wE3s0fN7AUz+z/h9vFQXhi6zD8DjhNMR7MP+Bd3b2V8lHk+cImZPWdmvzGz14XbE/b9NV4TwXeAOuA8gg/KV8Ptw01pEdNUFyluuDIDYGZLgK8AHxrYNMQ5xkuZPw98zd07Bh2f7mUerrw5wMXAjeH9dWb2e6R/eWH4Mq8E+oGpBM0kf2VmcxgfZc4BKoFVwCeB+8I2/4R9fyVyrqGkcfemgcdm9j3gofDpcFNaNISPB29PGyOUGTObBvwn8F533xVuHs9lvhB4e9jJVgFEzKyLoM8gbct8ms/1b9y9Jdz3CEG78/8jjcsLI5b53cCv3L0XOGRmvwNWAE+S5mUm+P+8P2zmed7MIgSTzSXs+2tc1gjstVNZXwcM9Mg/CFwftpHPJlgH4XkPprVoN7NVYeZ9L/BfYxr0WRquzGZWATwMfMbdfzdwwHgus7tf4u6z3H0W8HXgS+7+rXQv8wif60eBc8ysKGwzvxTYnO7lhRHLvA+43ALFBL+et46HMgMPAJcDmNl8II9gxtHEfX8lu9c8Dr3uPyGoMvYSZMY/Af4d2EAwkuJBYErU8X9D0Nu+jaiedYJfExvDfd8ivOo6FW9nUmbgswRtqS9F3QZGIYzLMg963W28dtRQWpR5FJ/r9xB0jG8E/indyjuKz3UJwYiwTcBm4JPjqMx5BLW5jcALwOVRxyfk+0tTTIiIZLhx2TQkIiKxUyIQEclwSgQiIhlOiUBEJMMpEYiIZDglAklpZvY1M/t41PNHzez7Uc+/amZ/Gcf3+5GZvT1e54s6719HPZ41eLbJEWLZY+GqfnGI4S/MbJ+ZfSse55PxQ4lAUt3TwGoAM8siuMJySdT+1cDvhnhdqvnr0x8ypE96sKzrWXP3rwGfi8e5ZHxRIpBU9zvCRECQADYSXEVZaWb5wCLgRTP7nJmtMbONZnZXeMXpIjN7fuBE4S/x9eHj5eGEXuvCWsaUwW883DFm9oSZfcXMnjez7WZ2Sbi9yMzuCydIuzecNGyFmX0ZKLRgPv0fh6fPNrPvWTDf/K/NrPB0/xBhDeF2M3vazHYP1FzM7LIwzvvCeL5sZjeG8W0ws7rR/uNLZlAikJTmwRTafWY2gyAhPAM8RzD3+gqC6Zd7gG+5++vcfSnBtMRvc/ctQF44GRnAuwgm8MoFvgm83d2XAz8Avhj9vjEck+PuK4GPA38XbvsIcMTdzwG+ACwPy/Bp4IS7n+fuN4bHzgPucPclwFGCmWFjMYVgYrm3AV+O2n4u8DFgGXATMD+M7/vAR2M8t2SocTnpnIw7A7WC1cC/Ekyxuxo4RtB0BPBGC6ZfLgImEEw98AvgPuCdBF+a7wpvCwgW6fnvYGoWsgku8492umPuD+/XAbPCxxcD3wBw940DtY9h7HH3l4Y4x+k84O4RYLOZTYravsaDOWcws13Ar8PtGwgWOhEZlhKBpIOBfoJlBE1D9cBfAW3ADyxYlvHbwAp3rzez24CC8LX3Aj81s/sBd/cdZrYM2OTuF43wnnaaY7rD+35e/Ts6k+UBu6Me9xPUYs70dTbM9kjU8wj6O5fTUNOQpIPfETSFtLp7vwcLkFQQNA89w6tf+i1mVgKcHPXjwbTb/cDfEiQFCCbsqjazi+Dk+rfRHdCxHjPYUwS1D8xsMUHiGtAbNjeJpBwlAkkHGwhGCz07aNsxd29x96PA98JtDwBrBr3+XoLZOe8DCPsU3g58xcxeJpiRdXX0C2I5ZgjfJkge6wlWSFtP0HwFcBewPqqzWCRlaPZRkTgxs2wg1927wpE6jxF02vaM8nw/Ah5y95/FMcb3EzSh3Rqvc0r6U9uhSPwUAY+HTUAGfHi0SSB0DPiCmVXF41oCM/sL4BaCldpETlKNQEQkw6mPQEQkwykRiIhkOCUCEZEMp0QgIpLhlAhERDLc/wcZKak55/Q1aQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "detected = allpass(source=1)\n", "allpass.plot(detected)\n", "plt.plot([1550,1550],[0,1])\n", "plt.ylim(0,1)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We clearly found a minimum at 1550 nm. \n", "\n", "However, we can do better! What if we decide to also optimize the coupling of the directional coupler? Let's have a look:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# let's just optimize both the phase and the coupling\n", "optimizer = torch.optim.Adam([allpass.wg.phase, allpass.dc.parameter], lr=0.03)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Sidenote**: in stead of explicitly listing all the parameters in the optimization, one can also use the `.parameters()` method, to get all optimizable parameters of the network. For the creation of the optimizer above, this would be:\n", "```python\n", "optimizer = torch.optim.Adam(allpass.parameters(), lr=0.03)\n", "```" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "281ca3b85aa54e8d86e5bf18ccd31d05", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=0.0, max=400.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "loss: 0.00000\n" ] } ], "source": [ "with train_env: # temporarily override the global environment\n", " # we train for 400 training steps\n", " for i in tqdm(range(400)):\n", " optimizer.zero_grad() # set all the gradients to zero\n", " result = torch.squeeze(allpass(source=1)) # squeeze: 4D -> 0D\n", " loss = lossfunc(result, target) # MSE loss\n", " loss.backward() # calculate the gradients\n", " optimizer.step() # use the calculated gradients to perform an optimization step\n", "\n", "print(\"loss: %.5f\"%loss.item())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By optimizing both the phase in the ring and the coupling to the ring, we can get 0 loss!" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZwcZ33n8c+vj7lPjUa3ZMnyKYNtbGFjm9PkwF42xlmScAQWJ17HmzUBNmEDuywxYZeFJIRwew3rOGazGENMMGAgBAgOGGPJ+JRPIVvWLY2kuY++fvtHVY/aozl6erqnq6e/79drXl1dVV39K6mrf/08Tz3PY+6OiIjUr1i1AxARkepSIhARqXNKBCIidU6JQESkzikRiIjUOSUCEZE6V7FEYGa3mNlhM3tshu1mZp8ys51m9oiZXVCpWEREZGaVLBHcCrxulu1XAKeHf9cBn69gLCIiMoOKJQJ3vwc4NssuVwG3eeA+oMvMVlcqHhERmV6iiu+9FthT8HxvuO7A1B3N7DqCUgOtra0XnnXWWYsSoMi89D0TPC4/vbpxiEzjgQce6HP33um2VTMR2DTrph3vwt1vBm4G2Lp1q2/fvr2ScYmU5m//TfB4zberG4fINMxs90zbqpkI9gLrC56vA/ZXKZYFyeWciUyOiUyW8XSO8XSWiUzwmF9OZXJkck7OnUzOyeZyZHOQzeXC5yf+MjknPwSU2YmMGSzb5HLwGD4HEnEjEYuRiBvJuJGMx0jEYiTjRiIeK1gXPDYmYjQ3xGlpSNCcjNOUjE0eT6Sa0tnc5HUz+ZcNrq9Udur6HNnw2spfQ8Ey5Hzm9XlmELPgyspfY2bBtWVALL8cXovx8BpriMeC6ylcToTXV3Ly8cRyQyJGSzJBU0OMhnj0rrNqJoK7gBvM7HbgYmDA3U+qFlosY6ksR0cmODqc4thIir7hCY6NpBgYSzM0nmF4IsPQeJrB8QzD4xmGJtIMj2cYSWVJZXLVCruszKA5GQ/+GoLHloY4bU0JOpuTdDYn6Qgfu5obJtd1tSRZ0dFIT2sj8Vi0PuCy+FKZHP1jKfpH0/SPpjk+mqJ/NMXx8PnQeJrRVJbhiQyjqQzDE1lGJzIvWJfOLt3BMOMxoyV/jRVcZy0NCZqScdqbEnQ0JehoTtLRlKSjORE+Jjmlp4V13S1lj6liicDMvgy8GlhuZnuBPwOSAO5+E3A3cCWwExgFrqlULAD9oykePzDIvuNj7O8fZ3//GPsHxth3fIyDg+OMprLTvi4RM9qbErQ1JWhvTNLWlGBNVxNtjW20NyVpaYzTlIjTlIzTmIjRFP6ybkwEj/n1DYkY8Vjwiz0es3D5xGOs4Hk8ZsTMJksFjhcsh4/uBcvBhkxYukhnc6SzTiZ8TGdzZHIFy1knFf7iGk9lGU1lGE1nw+XsScvD42kODowzMJZhcCxNKjt94ovHjJ7WBlZ0NLKyvYkVHY2s7mzmlJ4WNixr4ZSeVrpbkpH7NSTFS2dz7D0+xnNHR9jfP8ahgXEODU5wcHCcQ+Hf8dH0jK9Pxo3O5iQtDQlaGuK0NgY/MtZ0NtHSkKCtMU5LY4KWZJzGZPDruSERpyG8hhrCkmz+mmpIxCZLubGYEbfw+gmXY8aJ5fz1ZUYsvE1m8rryoJTgnLi2PHfi2juxDbK5/DUVPOZL+8F1F15nmeCaS4XX4UQmx2gqqCEYTQVJbyyVZSydfcHy0ZEUwxPBj8/BsTS5Kfnw+ldt5n1XlL+NtGKJwN3fPMd2B/5Tpd5/qn99po93fvnByee97Y2s6Wrm7NUdvPrMFSxvb6CntYGe1kaWtTWwPHxsbYjri6uAuzOezjEwlp78OzaS4sjQOIeHJjg8OMGhoXEODIzz8N4B+oYnXvD6tsYEp/S0cOaqds5e1cFZq9s5e3UHy9saq3RGMp3xdJanDg7xxIFBnjgwyK6+EXYfHWVf/xjZ3AurVXrbGlnZ0cS67hYuPKWbFe1NLGtN0tnSQHdLku6WBrrCxxZdT0XL5ZyRVIbBMCkMjKVZ2dFUkfeqZtXQonrZqT38v2svZk1XM6u7mmhMxKsdUk0ys8ki7arOuT+U4+kse46NsvvoKLuPjfL80RF29Y3wk2f6uPMX+yb3W93ZxNaNy3jpxm4uPKWbs1Z1qJppkbg7zx0dZduzx7j/uWM8tKefXUeGJ3+NtjbE2byijfPWd3HV+Ws4paeVjT0trO1upretkURcAxRUQixmtDclaW9KsraruaLvVTeJoLe9kd52/epcbE3JOKevbOf0le0nbTs6PMFTB4d4/MAgD+8dYNuzx/jmw8H9At0tSV5z5gpec9YKXnlGL53NycUOfUkbGk9zz9N9/OCJQ/zrzj6ODAUlt+6WJBds6ObKF61iy5oOzl7dwfruFmJKykta3SQCiZ6etkYuPa2RS09bDgS/TPf1j7HtuWPc83QfP3zqMHc+uI9k3HjtWSv5dxeu49Vn9pLUL9CSjKezfP/xQ/zDL/by0519pLNOV0uSV57ey8WnLuOijcvY3NumL/06pEQgkWFmrOsO7oq4+iXryOach/Yc59uPHOQbD+3juzsOsrytgbe9bCNvv+QUulsbqh1yTdh9dIT/85Nn+fqD+xgaz7Cms4nfu2wTrz17JRds6FLVjigRSHTFY8aFpyzjwlOW8f4rz+Kep4/wf+/bzSf++Wk+/+OdvOWiU3jn5acpIczgyYODfPqHO/nOowdIxGJc+eJV/NbW9Vxyao9+9csLKBFITUjGY7z27JW89uyVPH1oiJvv2cWt9z7LVx/YwzsvP41rLtukKqPQkaEJ/vr7T/GVbXtobUhw3Ss3c81lGyt2x4nUPiUCqTlnrGznr37rPK575al85O4n+MjdT/KNh/bz8d8+j7NWdVQ7vKpxd772wF7+/JuPM5bO8o5LN/FHrz2NrhaVmGR2+gklNeuMle3ces1F3PS7F3JocJx/++mfcNvPnsN96fZKncnxkRT/4bbtvPdrj7BlTQf/9J5X8sF/u0VJQIqiEoHUvNe9aBUv3djNe7/2CB/8xg527Bvkz99wTt30FXnm0BDX3radA/3j/PfXb+GaSzeqDUDmRSUCWRJ62hr54tu3csNrTuMr2/dw7d9tZ2yGYUOWknt39nH15+5lNJXl9j94Gb//8k1KAjJvSgSyZMRixp/8+pn85RvP5Sc7+/i9W7cxmspUO6yKuefpI1xz6zbWdjVz1w2XccGG7mqHJDVKiUCWnN/aup5P/Pb5/PzZo/zRlx98wdg4S8X2545x7W3bObW3jS9f9zJWd1Z2CAJZ2pQIZEl6w0vWcuNvnMM/P3GY//Htx6sdTlntPjrCdV96gLVdzfz9tRezTP0oZIHUWCxL1tsv2cjuo6P8n588y7nrOrn6JeuqHdKCjUxk+L1bt5Fz55Z3vFRJQMpCJQJZ0t5/xVlctHEZH/j6Y+w+OlLtcBbsQ9/cwa6+ET73lgvYtLy12uHIEqFEIEtaIh7jE286n0Q8xh/f8TC5Gm4v+M6jB7hj+17+8NWbJwfqEykHJQJZ8tZ2NfOBf3M223cf56sP7Kl2OCUZGk/zZ3ft4Jw1Hbz7V86odjiyxCgRSF1444XruGjTMv7Xd57k+Eiq2uHM219//2mODE/wkatfrDGVpOz0iZK6YGZ8+KoXMTiW5vM//mW1w5mXXUeGue1nu3nLRRs4b31XtcORJUiJQOrGmavaecP5a/m7e5/j0OB4tcMp2if++RkaEzHe86uqEpLKUCKQuvLuXzmDbM757I92VjuUojxxYJBvPryfay7byPI2TbUqlaFEIHVlQ08Lv3nBWu7Yvof+0ei3FXzuX35Je2OC616xudqhyBKmRCB15/devonxdI7bt0X7DqKDA+N859ED/M5L19PZkqx2OLKEKRFI3TlrVQeXbu7htnufI5PNVTucGX3pvufIuvP2SzZWOxRZ4pQIpC5dc9km9g+M84MnD1c7lGlNZLL8v58/z6+cvZINPS3VDkeWOCUCqUuvObOX5W2N3PmLvdUOZVo/evIwx0fTvPXiDdUOReqAEoHUpUQ8xhvOX8MPnzwcyQ5mX39wH8vbGnm5hpKQRaBEIHXrNy9YRzrrfOuR/dUO5QUGRtP86Mkj/MZ5a0ioF7EsAn3KpG5tWdPB5t5WvrvjYLVDeYG7HztAKpvj6pesrXYoUieUCKSu/do5q7hv17FI9Sn4zmMH2djTwovWdlQ7FKkTSgRS1379nFVkc84PI3L30MhEhvt+eZRfOXslZpqEXhaHEoHUtXPXdrKyo5HvP36o2qEA8NOdfaSyOS4/e0W1Q5E6okQgdS0WM159xgp+urMvEpPc//DJw7Q3JnjpxmXVDkXqiBKB1L3LTl/O4HiGR/cNVDUO96CK6pVn9GrOAVlU+rRJ3btscw8AP3nmSFXjeOrQEIeHJnjVmb1VjUPqT0UTgZm9zsyeMrOdZva+abZ3mtk3zexhM9thZtdUMh6R6fS0NXLOmg5+srOvqnH8fNcxAC45taeqcUj9qVgiMLM48FngCmAL8GYz2zJlt/8EPO7u5wGvBj5uZg2ViklkJpedtpxf7O5nIpOtWgz37TrK2q5m1i/T2EKyuCpZIrgI2Onuu9w9BdwOXDVlHwfaLbhPrg04BmQqGJPItC48pZtUNsdj+war8v7uzv3PHuPiTWoklsVXyUSwFigc8H1vuK7QZ4Czgf3Ao8C73P2kcYHN7Doz225m248cqW49rixNF2zoBuAXu49X5f13Hh7m6EiKi09VIpDFV8lEMF1vmKn35/068BCwBjgf+IyZndSd0t1vdvet7r61t1cNaVJ+ve2NnNLTwgNVSgTbw/fVbaNSDZVMBHuB9QXP1xH88i90DXCnB3YCzwJnVTAmkRlduKGb7buP4774/Qke2dtPZ3OSTctbF/29RSqZCLYBp5vZprAB+E3AXVP2eR54LYCZrQTOBHZVMCaRGb3klG76hifYe3xs0d/74T0DnLuuU8NKSFVULBG4ewa4Afge8ARwh7vvMLPrzez6cLcPA5ea2aPAD4A/dffq3sMndevFazsBeGyRO5aNpbI8dWiI89Z1Ler7iuQlKnlwd78buHvKupsKlvcDv1bJGESKddaqduIxY8f+Qa548epFe9/HDwyQzTnnrutctPcUKaSexSKhpmSczb2tPH5gcW8hfXhPUAI5f71KBFIdSgQiBc5Z08mO/YtbNbRj/yC97Y2s6Gha1PcVyVMiEClwzpoODg1O0Dc8sWjv+dShQc5a1b5o7ycylRKBSIEta4JuLDv2L071UDbnPHNomDNXKhFI9SgRiBQ4a1WQCJ4+OLQo7/fc0REmMjnOVIlAqkiJQKTAstYGlrU2sPPw8KK831NhwsknIJFqUCIQmeK03jZ2Hlm8RGAGp61oW5T3E5mOEoHIFJtXtLHz8PCiDDXx1MEhNva00twQr/h7icxEiUBkitNWtDEwlqZvOFXx99p5ZFilAak6JQKRKfJfzL+scPVQNuc8f3SUUzXQnFSZEoHIFPlEUOkG4/39Y6SyOY04KlWnRCAyxZrOJloa4hVPBM/2jQCwUYlAqkyJQGQKM2PDshb2HBut6PvkE4GqhqTalAhEprFhWQvPL0IiaG2I09veWNH3EZmLEoHINE7pCRJBJW8hfbZvhI3LWzUZjVSdEoHINDYsa2Eik+PwUOUGn3vu6IjaByQSlAhEprF+WQtAxaqHMtkce4+PsbGnpSLHF5kPJQKRaWzIJ4KjlUkEBwbGyeac9d1KBFJ9SgQi01jX3YJZ5UoE+/rHAFjb3VyR44vMhxKByDQaEjHWdDZXLhEcDxLBOpUIJAKUCERmsH5Z5RLB3jARrO7U9JRSfUoEIjNY09XMgbAKp9z29Y+yor2RpqRGHZXqUyIQmcGazmYODU2QzZW/L8G+/jG1D0hkKBGIzGBVZxPZnHOkAn0J9h4fY22XEoFEgxKByAzWdAX19/sHyls9lMs5B/rH1VAskZGYaYOZ3VXE64+5+zvKF45IdKzqCH6xHxwYL+txjwxPkMrmVDUkkTFjIgDOBq6dZbsBny1vOCLRMVkiKHOD8WQfgi7dMSTRMFsi+G/u/uPZXmxmHypzPCKR0dmcpDkZL3uJ4PBgcLx8iUOk2mZsI3D3O+Z6cTH7iNQqM2N1ZxMHypwIDg0Gjc8rOzT8tERDSY3FZnZduQMRiaLVXU1lbyw+ODhOMm50tzSU9bgipSr1riENoC51YVVHc9mrhg4NjrOivYlYTJeRRENJicDd/3e5AxGJojVdTRwaHC9rp7LDgxOsULWQRMhsjcUAmNkHp1vv7n9e/nBEomVFeyM5h2MjqbJNKXlocJzNvW1lOZZIORRTIhgp+MsCVwAbKxiTSGTkv/zL2bv40OA4qzTYnETInCUCd/944XMz+yugmM5mmNnrgE8CceCL7v7RafZ5NfA3QBLoc/dXFXNskcUwmQiGy5MIxlJZBsczqhqSSJkzEUyjBTh1rp3MLE7Q4exXgb3ANjO7y90fL9inC/gc8Dp3f97MVpQQj0jF9LYFv9zLVSI4FPYhWNmuEoFERzFtBI8C+ZayONALFNM+cBGw0913hce5HbgKeLxgn7cAd7r78wDufrj40EUqb3l7cItn2RNBhxKBREcxJYLXFyxngEPuninidWuBPQXP9wIXT9nnDCBpZv8CtAOfdPfbph4o7LdwHcCGDRuKeGuR8mhpSNDWmChfIhhSZzKJnmLaCHaXeOzpbpKeeg9eArgQeC3QDPzMzO5z96enxHAzcDPA1q1byz84vMgsetsby9ZGkB9eYoWqhiRCSu1Z/K0idtsLrC94vg7YP80+33X3EXfvA+4BzislJpFK6W1r5MhQeTqVHR1JkYwbHc2lNM+JVEapPYv/QxH7bANON7NNZtYAvImT7zb6BvAKM0uYWQtB1dETJcYkUhG97Y1lqxo6OjxBT2sjZupVLNFR0s8Sdz9QxD4ZM7sB+B5BI/Mt7r7DzK4Pt9/k7k+Y2XeBR4AcwS2mj5USk0il9LY38q/PlCsRpOhp0xhDEi3F3DV0OvC/gC3AZMWmu895C6m73w3cPWXdTVOe/yXwl0XGK7LoetsbGRzPMJ7OLniy+b6RFD1taiiWaCmmauhvgc8T3DH0GuA24EuVDEokSnrDL+6+MjQYHx2eYHmrSgQSLcUkgmZ3/wFg7r7b3W8ELq9sWCLRUc6+BKoakigqpo1g3MxiwDNhnf8+QD2ApW4saw1KBMdHUws6zmgqw1g6q6ohiZxiSgTvJhhW4o8I7vn/XeDfVzIokShZFk4gc2wkvaDjHB0OEkmPqoYkYorpULYtXBwGrqlsOCLR092aBOD4yMJKBPk2huUqEUjEzFgiMLMb53pxMfuI1Lq2xgQN8RhHF5gIJksEaiOQiJmtRHCtmQ3Ost0IOondWNaIRCLGzOhuTS64RHB0JCgRqI1Aoma2RPAFgoHgZvOFMsYiElndLQ0cW2BjcZ/aCCSiZkwE7v6hxQxEJMqWtTYsvEQwnKKtMbHgTmki5VbqWEMidaW7deElgqMjE5MNzyJRokQgUoSe1gaOLbBE0D+anrwVVSRK5kwEZrZsMQIRibLulgYGxtJksrmSj9E/lqZTiUAiqJgSwc/N7KtmdqVp7FypU8taG3CHgbHSO5X1j6boalbVkERPMYngDILZwd4G7DSzj5jZGZUNSyRausM7fRYyzET/aJruFiUCiZ45E4EHvu/ubwauJRhe4n4z+7GZXVLxCEUiIF+3n+8UNl/ZnDM4rqohiaZi5iPoIRhf6G3AIeCdBDONnQ98FdhUyQBFomBymIkSSwSDY2ncUYlAIqmY0Ud/RjD/wBvcfW/B+u1mdtMMrxFZUnrCEUhLHWYin0C6lAgkgoppI/iAu3+4MAmY2W8BuPvHKhaZSITkv8D7R0trLO4PG5m7VDUkEVRMInjfNOveX+5ARKKsKRmnIRFjsMS7hgbCBKK7hiSKZqwaMrMrgCuBtWb2qYJNHQTTVorUlc7mZMm3j56oGlKJQKJntjaC/cB24DeABwrWDwHvqWRQIlG0kESQr1JSY7FE0WyDzj0MPGxmf+/uKgFI3etaUCJIYQbtTUoEEj2zVQ3d4e6/DTxoZl64iaB7wbkVj04kQjqbkxwcHC/ptf1jaTqbk8Rj6pwv0TNb1dC7wsfXL0YgIlHX2ZzkyYNDJb32+GhaDcUSWTPeNeTuB8LFPmCPu+8GGoHzCNoPROpKR3Oy5LuG+kdTaiiWyCrm9tF7gCYzWwv8gGAC+1srGZRIFHU2JxmayJDN+dw7TzEwllZnMomsYhKBufso8JvAp939amBLZcMSiZ7OsGqnlFLBcY08KhFWVCIIB5d7K/DtcF0xQ1OILCn5RFDKnUP9o2lVDUlkFZMI3kXQk/jr7r7DzE4FflTZsESip9REkMnmGBrPqGpIImvOX/bufg9BO0H++S7gjyoZlEgU5b/I55sI8vt3q0QgEVXMMNRnAH8CbCzc390vr1xYItFTaokgP+Bcp9oIJKKKqev/KnAT8EUgW9lwRKKr1EQwqEQgEVdMIsi4++crHolIxHWUmAiGxoMRWtqbdI+FRFMxjcXfNLM/NLPVZrYs/1fxyEQipikZpzERm3+JYDzYv0MlAomoYn6i/Pvw8b0F6xw4tfzhiERbZ3Nycm6BYqlEIFFXzOT1m6b5KyoJmNnrzOwpM9tpZtNNcJPf76VmljWzN84neJHFVspQ1ENhiUAjj0pUzZkIzKzFzD5gZjeHz083szkHojOzOPBZ4AqCnshvNrOTeiSH+30M+N58gxdZbKUkgsGxDDGD1oZ4haISWZhi2gj+FkgBl4bP9wL/o4jXXQTsdPdd7p4Cbgeumma/dwL/ABwu4pgiVdXVUlqJoL0piZmGoJZoKiYRbHb3vwDSAO4+RjAnwVzWAnsKnu8N100KB7K7muD21BmZ2XVmtt3Mth85cqSItxapjI5SSgTjGTqa1T4g0VVMIkiZWTNBAzFmthmYKOJ10yWLqcM2/g3wp+4+a/8Ed7/Z3be6+9be3t4i3lqkMjpLGIp6aDxNe6PaByS6ivmZciPwXWC9mf09cBnBUNRz2QusL3i+jpPnMdgK3B4WmZcDV5pZxt3/sYjjiyy69qYTQ1EXO9vY4HhGdwxJpBUz1tA/mdkDwMsIfuW/y937ijj2NuB0M9sE7APeBLxlyrE35ZfN7FbgW0oCEmUd4Rf6SCpDR5F3AQ2OpVm/rKWSYYksSDF3Df3A3Y+6+7fd/Vvu3mdmP5jrdeGE9zcQ3A30BHBHOHrp9WZ2/cJDF1l8+V/2+b4BxRhSiUAibrbJ65uAFmC5mXVzos6/A1hTzMHd/W7g7inrpm0Ydvd3FHNMkWrK9wUI+gY0F/WawfF00aUHkWqY7WfKHwDvJvjSf4ATiWCQoH+ASN2Zb4kgl3OGJzKTVUoiUTTjp9PdPwl80sze6e6fXsSYRCLrhSWCuY2kMrirV7FEWzGNxZ82s0s5eT6C2yoYl0gktTXOr0QwGO6nfgQSZcVMTPMlYDPwECfmI3BAiUDqTr6KZ7DIRKBxhqQWFPMzZSuwxd2ndgYTqTv5L/ThYksEY2GJQIlAIqyYnsWPAasqHYhILWhKxkjErOg2ghMlAlUNSXQV8+lcDjxuZvdTMLSEu/9GxaISiSgzo70pUXQbgeYikFpQ7BATIhJqb0oWXSLQ7GRSC4q5a+jHixGISK1QiUCWmtl6Fg9x8mihEHQsc3fvqFhUIhHW1lh8IhgcS9OYiNGY0KQ0El2zdShrX8xARGpFe1OSff1jRe0bjDyqaiGJtmLuGhKRAh1NiXndNaThJSTqlAhE5mk+bQSD4xna1VAsEadEIDJP7U1JhicyFNPHUiUCqQVKBCLz1N6UIJtzRlOzzrAKBI3F6lUsUadEIDJPbfMYilqT0kgtUCIQmafJ8YYm5m4wViKQWqBEIDJP7UWOQJrO5hhLZ1U1JJGnRCAyTx1FVg2pV7HUCiUCkXkqdpaywTGNMyS1QYlAZJ6Knbf4RIlAiUCiTYlAZJ5OTFc5e4lAcxFIrVAiEJmn1oYEZnPPUjaoRCA1QolAZJ5iMaOtMTHnXUOTE9erakgiTolApAQdTUndNSRLhhKBSAnaixiBNL8936YgElVKBCIlKGYE0qHxDC0NcRJxXWYSbfqEipSgvSnJ0BxDTAyNp1UtJDVBiUCkBMVMVzk8odnJpDYoEYiUoL0pMeftoxpwTmqFEoFICdqLuGtI8xVLrVAiEClBe1OCVDbHeHrmyWnURiC1QolApATFjEA6NJ7RNJVSE5QIREpQzAikQYlAVUMSfRVNBGb2OjN7ysx2mtn7ptn+VjN7JPy718zOq2Q8IuXS0Tz75DTpbI7xdI52dSaTGlCxRGBmceCzwBXAFuDNZrZlym7PAq9y93OBDwM3VyoekXKaq0Sg4SWkllSyRHARsNPdd7l7CrgduKpwB3e/192Ph0/vA9ZVMB6RsplrToITQ1Crakiir5KJYC2wp+D53nDdTH4f+M50G8zsOjPbbmbbjxw5UsYQRUqTH1E0PwvZVCoRSC2pZCKwadb5tDuavYYgEfzpdNvd/WZ33+ruW3t7e8sYokhp5ioRDKpEIDWkkj9X9gLrC56vA/ZP3cnMzgW+CFzh7kcrGI9I2bQ2JIjZiS/8qVQikFpSyRLBNuB0M9tkZg3Am4C7Cncwsw3AncDb3P3pCsYiUlb5yWlmbiPQpDRSOyr2c8XdM2Z2A/A9IA7c4u47zOz6cPtNwAeBHuBzZgaQcfetlYpJpJzam5KzlAg0TaXUjop+St39buDuKetuKli+Fri2kjGIVEpHc5LBsdlLBG1KBFID1LNYpESzzVI2NJ6mKRkjqUlppAboUypSoo6mmSewH9LIo1JDlAhEShRMYD/zXUNqH5BaoUQgUqLZ5i0e1IBzUkOUCERK1NEclAjcT+4nqSGopZYoEYiUqL0pQc5hJHXy5DSalEZqiRKBSIlmG4F0aDxDe6OqhqQ2KBGIlOjEwHMntxMMT6ixWGqHEoFIiU4MPPfCEkEmm2M0lVVjsdQMJQKREnU0hyWCKYlgeEIDzkltUSIQKdFMQ1Hnq4ryiUIk6qmKFloAAAq0SURBVJQIREqUTwRTexf3j6UA6FIikBqhRCBSoplmKesfDZ53tSgRSG1QIhApUVMyTkM8dlLV0MCYEoHUFiUCkQXoaE6c1FjcHyYCtRFIrVAiEFmAjuYkA6MvTAQDo0EbQacSgdQIJQKRBehuaeB4+MWf1z+apqUhTmMiXqWoROZHiUBkAYJEMKVEMJbWHUNSU5QIRBaguyXJ8ZEpJYKxNJ0tDVWKSGT+lAhEFqC79eSqoYHRNJ3N6lUstUOJQGQBulsamMjkGCsYirp/LEVXs0oEUjuUCEQWoDvsK1BYKhgYS6sPgdQUJQKRBegK2wKOFbQT9I+m6VQikBqiRCCyAPkSQX5Yiaw7E5mcqoakpigRiCzAstbgCz9fNZTO5gBY3qZEILVDiUBkAfJVQ/0nJYLGqsUkMl9KBCILkG8UPjYSVA2lsw4oEUhtUSIQWYBkPEZXS5K+4QmgoETQrqohqR1KBCILtKqjiYOD48CJRNDTqhKB1A4lApEFWtHRxOHJROB0NidpSOjSktqhT6vIAq3qaJwsEaQyOVa0qzQgtUWJQGSBVnY0cWRoAseZyGRZ191c7ZBE5kWJQGSBVnY0kfOgWmgik2P9spZqhyQyL0oEIgu0sacVgOGJDNmcq0QgNUeJQGSBTl/ZBpzoVLauWyUCqS0VTQRm9joze8rMdprZ+6bZbmb2qXD7I2Z2QSXjEamEFe2NtDcmODocJIJTe1urHJHI/FQsEZhZHPgscAWwBXizmW2ZstsVwOnh33XA5ysVj0ilmBlnrGon607MjNN626odksi8VLJEcBGw0913uXsKuB24aso+VwG3eeA+oMvMVlcwJpGKuPysFQB0NidJxFXjKrWlkvPprQX2FDzfC1xcxD5rgQOFO5nZdQQlBoBhM3uqxJiWA30lvrZW6ZwX2/utGu+q/+f6sJBzPmWmDZVMBNNdDV7CPrj7zcDNCw7IbLu7b13ocWqJzrk+6JzrQ6XOuZJl2L3A+oLn64D9JewjIiIVVMlEsA043cw2mVkD8Cbgrin73AW8Pbx76GXAgLsfmHogERGpnIpVDbl7xsxuAL4HxIFb3H2HmV0fbr8JuBu4EtgJjALXVCqe0IKrl2qQzrk+6JzrQ0XO2dxPqpIXEZE6ovvcRETqnBKBiEidq/lEYGa3mNlhM3usYN2NZrbPzB4K/64s2Pb+cEiLp8zs1wvWX2hmj4bbPmVmVbkZvBjzOWcz+1UzeyA8twfM7PKC1yzJcy7YvsHMhs3sTwrW1cQ5l/C5PtfMfmZmO8LzawrX18T5wrw/10kz+7vw3J4ws/cXvKamzzlc/87wO2qHmf1FwfrKfH+5e03/Aa8ELgAeK1h3I/An0+y7BXgYaAQ2Ab8E4uG2+4FLCPo2fAe4otrnVqZzfgmwJlx+EbCvYNuSPOeC7f8AfLVwn1o553n+HyeAR4Dzwuc9dfC5fgtwe7jcAjwHbFwi5/wa4J+BxvD5ivCxYt9fNV8icPd7gGNF7n4VwYdnwt2fJbhb6SILhrXocPefefCvehvwhspEvHDzOWd3f9Dd830zdgBNZta4lM8ZwMzeAOwiOOf8upo553me768Bj7j7w+Frj7p7tpbOF+Z9zg60mlkCaAZSwOASOef/CHzU3SfCfQ6H6yv2/VXziWAWN1gwouktZtYdrptpSIu14fLU9bVmunMu9O+AB8MP2JI9ZzNrBf4U+NCUfZfCOU/3f3wG4Gb2PTP7hZn9l3D9UjhfmP6cvwaMEAxH8zzwV+5+jKVxzmcArzCzn5vZj83speH6in1/LdVE8HlgM3A+wQfl4+H6mYa0KGqoi4ib6ZwBMLNzgI8Bf5BfNc0xlso5fwj4hLsPT9m/1s95pvNNAC8H3ho+Xm1mr6X2zxdmPueLgCywhqCa5I/N7FSWxjkngG7gZcB7gTvCOv+KfX9VcqyhqnH3Q/llM/sC8K3w6UxDWuwNl6eurxmznDNmtg74OvB2d/9luHopn/PFwBvDRrYuIGdm4wRtBjV7znN8rn/s7n3htrsJ6p3/LzV8vjDrOb8F+K67p4HDZvZTYCvwr9T4ORP8f94ZVvPcb2Y5gsHmKvb9tSRLBPbCoayvBvIt8ncBbwrryDcRzINwvwfDWgyZ2cvCzPt24BuLGvQCzXTOZtYFfBt4v7v/NL/DUj5nd3+Fu290943A3wAfcffP1Po5z/K5/h5wrpm1hHXmrwIer/XzhVnP+Xngcgu0Evx6fnIpnDPwj8DlAGZ2BtBAMOJo5b6/qt1qXoZW9y8TFBnTBJnx94EvAY8S3ElxF7C6YP//RtDa/hQFLesEvyYeC7d9hrDXdRT/5nPOwAcI6lIfKvjL34WwJM95yutu5IV3DdXEOZfwuf5dgobxx4C/qLXzLeFz3UZwR9gO4HHgvUvonBsISnOPAb8ALi/YvyLfXxpiQkSkzi3JqiERESmeEoGISJ1TIhARqXNKBCIidU6JQESkzikRSKSZ2SfM7N0Fz79nZl8seP5xM/vPZXy/W83sjeU6XsFx/2vB8sapo03OEsuzFs7qV4YY3mNmz5vZZ8pxPFk6lAgk6u4FLgUwsxhBD8tzCrZfCvx0mtdFzX+de5dpvdeDaV0XzN0/AXywHMeSpUWJQKLup4SJgCABPEbQi7LbzBqBs4EHzeyDZrbNzB4zs5vDHqdnm9n9+QOFv8QfCZcvDAf0eiAsZaye+sYz7WNm/2JmHzOz+83saTN7Rbi+xczuCAdI+0o4aNhWM/so0GzBePp/Hx4+bmZfsGC8+X8ys+a5/iHCEsKnzOxeM9uVL7mY2avDOO8I4/momb01jO9RM9tc6j++1AclAok0D4bQzpjZBoKE8DPg5wRjr28lGH45BXzG3V/q7i8iGJb49e7+BNAQDkYG8DsEA3glgU8Db3T3C4FbgP9Z+L5F7JNw94uAdwN/Fq77Q+C4u58LfBi4MDyH9wFj7n6+u7813Pd04LPufg7QTzAybDFWEwws93rgowXrzwPeBbwYeBtwRhjfF4F3FnlsqVNLctA5WXLypYJLgb8mGGL3UmCAoOoI4DUWDL/cAiwjGHrgm8AdwG8TfGn+Tvh3JsEkPd8PhmYhTtDNv9Bc+9wZPj4AbAyXXw58EsDdH8uXPmbwrLs/NM0x5vKP7p4DHjezlQXrt3kw5gxm9kvgn8L1jxJMdCIyIyUCqQX5doIXE1QN7QH+GBgEbrFgWsbPAVvdfY+Z3Qg0ha/9CvBVM7sTcHd/xsxeDOxw90tmeU+bY5+J8DHLietoPtMDThQsZwlKMfN9nc2wPlfwPIeuc5mDqoakFvyUoCrkmLtnPZiApIugeuhnnPjS7zOzNmDyrh8Pht3OAv+dIClAMGBXr5ldApPz3xY2QBe7z1Q/ISh9YGZbCBJXXjqsbhKJHCUCqQWPEtwtdN+UdQPu3ufu/cAXwnX/CGyb8vqvEIzOeQdA2KbwRuBjZvYwwYislxa+oJh9pvE5guTxCMEMaY8QVF8B3Aw8UtBYLBIZGn1UpEzMLA4k3X08vFPnBwSNtqkSj3cr8C13/1oZY3wHQRXaDeU6ptQ+1R2KlE8L8KOwCsiA/1hqEggNAB82s+Xl6EtgZu8BrieYqU1kkkoEIiJ1Tm0EIiJ1TolARKTOKRGIiNQ5JQIRkTqnRCAiUuf+P6VXYpg3WyyPAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "detected = allpass(source=1)\n", "allpass.plot(detected)\n", "plt.plot([1550,1550],[0,1])\n", "plt.ylim(0,1)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Extra: Time domain simulation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As an aside, one can also do time domain simulations. Let's do a time domain simulation of the optimized ring at 3 different wavelengths simultaneously:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# define the simulation environment:\n", "time_domain_env = pt.Environment(\n", " time = np.linspace(0, 1e-11, 1000),\n", " wavelength = [1.547e-6, 1.550e-6, 1.560e-6], #[m]\n", " freqdomain=False, # we will be doing a time domain simulation\n", ")" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "with time_domain_env:\n", " detected = allpass(source=1)\n", " allpass.plot(detected)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Coupled Resonator Optical Waveguide" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After this introduction, we can go on to define a real filter: a CROW:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "class Crow(pt.Network):\n", " def __init__(\n", " self,\n", " num_rings=1,\n", " ring_length=1e-5, #[m]\n", " loss=1000, #[dB/m]\n", " neff=2.34,\n", " ng=3.4,\n", " wl0=1.55e-6,\n", " random_parameters=False,\n", " name=None\n", " ):\n", " super(Crow, self).__init__(name=name) # always initialize parent first\n", " \n", " # handle variables\n", " self.num_rings = int(num_rings)\n", " \n", " # define source and detectors:\n", " self.source = pt.Source()\n", " self.through = pt.Detector()\n", " self.drop = pt.Detector()\n", " self.add = pt.Detector()\n", " \n", " # if the random_parameters flag is set, we will initialize with \n", " # random parameters, else, we will initialize with parameters\n", " # set to zero:\n", " random_coupling = np.random.rand if random_parameters else (lambda : 0.5)\n", " random_phase = (lambda : 2*np.pi*np.random.rand()) if random_parameters else (lambda :0)\n", " \n", " # define directional couplers\n", " for i in range(self.num_rings + 1):\n", " self.add_component(\n", " name=\"dc%i\"%i,\n", " comp=DirectionalCoupler(\n", " coupling=random_coupling(), # initialize with random coupling\n", " )\n", " )\n", " \n", " # define waveguides between directional couplers:\n", " # let's only make the bottom waveguide trainable.\n", " for i in range(self.num_rings):\n", " self.add_component(\n", " name=\"top_wg%i\"%i,\n", " comp=Waveguide(\n", " length=0.5*ring_length,\n", " loss=loss,\n", " neff=neff,\n", " ng=ng,\n", " wl0=wl0,\n", " phase=0,\n", " trainable=False,\n", " )\n", " )\n", " self.add_component(\n", " name=\"btm_wg%i\"%i,\n", " comp=Waveguide(\n", " length=0.5*ring_length,\n", " loss=loss,\n", " neff=neff,\n", " ng=ng,\n", " wl0=wl0,\n", " phase=random_phase(), # initialize with random phase\n", " trainable=True,\n", " )\n", " )\n", " \n", " # lets now define the links\n", " link1 = [\"source:0\"]\n", " link2 = [\"through:0\"]\n", " for i in range(self.num_rings):\n", " link1 += [\"0:dc%i:3\"%i, \"0:top_wg%i:1\"%i]\n", " link2 += [\"1:dc%i:2\"%i, \"0:btm_wg%i:1\"%i]\n", " \n", " if self.num_rings % 2 == 1: # top=drop, btm=add\n", " link1 += [\"0:dc%i:3\"%(self.num_rings), \"0:drop\"]\n", " link2 += [\"1:dc%i:2\"%(self.num_rings), \"0:add\"]\n", " else: # top=add, btm=drop\n", " link1 += [\"0:dc%i:3\"%(self.num_rings), \"0:add\"]\n", " link2 += [\"1:dc%i:2\"%(self.num_rings), \"0:drop\"]\n", " \n", " self.link(*link1)\n", " self.link(*link2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Single ring CROW:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "crow = Crow(num_rings=1)\n", "detected = crow(source=1)\n", "crow.plot(detected)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Multiple ring CROW:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3adcd1cc5755404f8d763332ddcf95d1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(IntSlider(value=1, description='num_rings', max=10, min=1), Output()), _dom_classes=('wi…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ipywidgets import interact, IntSlider\n", "@interact(num_rings=IntSlider(min=1, max=10, step=1))\n", "def plot_detected(num_rings=5):\n", " crow = Crow(num_rings=num_rings)\n", " detected = crow(source=1)\n", " crow.plot(detected)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimizing a CROW\n", "We will optimize a crow with 10 rings and randomly initialized parameters" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "device = 'cuda' # 'cpu' or 'cuda'\n", "crow = crow = Crow(num_rings=10, random_parameters=False).to(device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will also do a simulation on a smaller range than the globally set environment:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "train_env = pt.Environment(\n", " wavelength = 1e-6*np.linspace(1.53, 1.58, 1001), #[m]\n", " freqdomain=True, # we will be doing frequency domain simulations\n", " grad=True, # we need to enable gradients to be able to optimize\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "lets have a look at an initial simulation (maybe try the same for the `through` port as well):" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO29eZwkV3Xn+zsRkWstXdWrWr3QkmgJBAgMzaZBz4ANBp7GMm8YVmObMaORMRgz4Ae2GZ78eOMxnsEesxhZYMzg52csMGAZZGOGh8GsWgDtCDUSSK1u1HttuUbEmT9u3MiIyNiyurIqovJ8P5/6ZGVkROaNzIh77tmJmSEIgiBMLsZGD0AQBEHYWEQQCIIgTDgiCARBECYcEQSCIAgTjggCQRCECcfa6AGMyvbt2/nAgQMbPQxBEIRScdttt51k5h1xr5VOEBw4cAC33nrrRg9DEAShVBDRj5NeG5tpiIg+SkTHieiuhNeJiN5HRIeJ6A4ieuq4xiIIgiAkM04fwccAvCjl9RcDOOj9XQ3gQ2MciyAIgpDA2AQBM38VwOmUXa4C8HFWfAvAHBHtHtd4BEEQhHg2MmpoD4CHA8+PeNuGIKKriehWIrr1xIkT6zI4QRCESWEjBQHFbIstfMTM1zPzIWY+tGNHrNNbEARBWCUbKQiOANgXeL4XwNENGosgCMLEspGC4EYAv+RFDz0LwAIzH9vA8QiCIEwk4wwf/WsA3wRwCREdIaJfJaJriOgab5ebADwA4DCADwN4w7jGIghFxXEZn7j5ISx1+iMdZzsu/uX+E7Add0wjEyaJcUYNvYqZdzNzhZn3MvOfM/N1zHyd9zoz868z80XM/CRmliwxodS89Ybb8V9uunekY268/RG849N34rqv/HCk4/7i6z/Ca//8Znzmu4+MdNynbjuCl//ZN9EXASIEkFpDghDD2VYPf/TFH6Bn55swmRl/+50j+LOvPgDHzd/s6fvHlgAAD55cGWl89z2qjrv76OJIx73tk7fj5gdP4+HTrdzH3HlkAV+7/+RInyOUCxEEghDDh//lAbzvS/fjU7cdybX/o4td//8TS92UPcMcOdsGABxfzH8MADzkTeSjTOhBRhE8//oDX8Mv/vm3V/U5QjkQQSAIMViGujUeyjnRnlweTORHF9q5P+fRhY56XOqMMLrB551c6eU+ptWz/f+P5xRW4oOYDEQQCEIMi57zNu9EuNwdTLJnW/kn54W2+pxRNYJTy+ozTo6gfZwOCI2zrXzO6cXO4LzaPSf3ZwnlQgSBIMRwxps0lwITYRrB/fIeAwwETtd2c/sj+o7rC5BTK/kFgT4GAM628wmr4DFBrUfYXEy8IDiz0sPr/uJmHF8cTTUXysmp5W6uVX7LW/0udfOtnIPhn0HtIIvFto2aZQy9R/pnqfffNlVFp+/mjgAKCYKVfJ8VPKaVQyP4yg9O4Iv3PJrrvYXiMPGC4LPfewRfvu8EPvDlwxs9FGEdeNZ/+RKufP/XMvdr9z1BkHN1H5z8l3Me07NdtPsO9sw3RvqsFe+zds3WQ8+zWAxM6os5hc5iSBCkfw4z45c/ejP+/cclErxsTLwg2L1F3UxHz+Z38AnlxHUZfYfx/Z8sZe7rawSrMA3lnpi9yXjPXCP0PAstpHbN1kYao7b3b52q5lrdA2EtIMtH0M1p2hKKR+k6lK01VU8tP5PTeSaUl76bf6LSE2Cnn2/CXOz0UTUN1CwDSyOu0PeuUiPYOVMf6Tg9kW+fruZ2/AbPv53xXfQkwqi0TLwg6Dv5k3+EcjPKb60nwLwO3OWOjZm6hapl5DYN6RX63vkmgPw+Aj2Ja40gr0+i5QuCWsj2n+eY6P9x5P2uhOIx8aYhnQXKLAJhs9MfYaLS9vC8GsFSx8Z03cJ0zco9MWuNYGAayqkReBPyTs9HsJzTod3u2SAC5pv5NYKgFpB1jJStKC+iEcjFOzGM8lvrSS+v3Xup08dM3ULFNPILAu0jGNE0pIWUdhbnNg31HTQqJqZqZm4fQVAQZjmLRSMoLxMvCHyNYIPHIYyfUWzYet+8gmCl62C6pgRB7kgjb7/z/Al9NHPNakxDjYqJZtXKnNQ1QS0g67sQQVBeJt40ZIuPYGII+giyTIF637ymIb3anqnnNw3pCX26ZmGqamKxvTpncV6fRLvnoFE10ajm1wjafcfPc8ia6CVqqLyIIBihUqRQboITWZp24LgMx2VYBsF2OVcCWqfvoGap1Xbe8FFtf29UTTRrFtr90Vbp26arMGg0jaBZNdGsmLBdzrWCb/eVpkOUrVEFX5caReVCBMEIIYVCuQn6CNImQb3fTF1ZTvOsdDu2g3rFQHOE1XarZ8MgoGaNdtxKz0HVNFAxDUzXrPy+hb6DRtVCs6bOK4/DuGe7qFkGqqaRKTj6OQWtUDxEEDg6amiDByKMneDklBZKqif+mXol9DyNbt9FvaLMLlnx9pp2z0WzaoGI0KiMJkCaNRMARrT322hWTDSr6tiVHMd1bRe1iomqZWT7CHIKWqF4iCAQjWBiCK1Yc2gE0zWtEWRP0J2+owRBxUTPdnM1p2n3bTSqekI3c4d0tnoOmhXvuBEigHzTkPeZeY7r2Y6fKJdpGsr5/QrFQwSBRA1NDEEtYBTTUKefxzTkouaZhoDsUEu1j+PvP8rKXmkElnfcCI5fz1ncrOY3DXW988plGgoICkdU7FIhgkCihiaG4ESVpgn2hkxD6ROm6zlea5aJhp5kc5iHdDgngJEieUICpDKKANHho/lNQz3bRdU0ULWMzDyMoKCV+6pciCDQKrysYDY9QXNNmulGT3iz2lmcoRFok0m9YvgTe57Vtl6hA0CjYuYOVW11A4KgNopJyUazaqKux5jj83yNwMrWCPJ+v0LxEEHg3cRSc2jzEzRX5HMWa9NQ+oSpX69bo9nf2/2gaWgEjaBvY6o6MA2t5M4SdtGoWr6w6uYQBEGNYBTTkIRllwsRBN4FK07jzU9+jUC9ljdqSPsQdNQQMIppSE3ojVGcxd2gJmHlOs52XPQc19MIjNxj7NoqP6JqZjuLRSMoLyIIvJtebJqbn+DklFaSurdajWBk05Ad1gj6Tq7ihyu9gUag6gblcEx7Y2xWB8IqjxO8Z7uoWipnIUsgBrUAWViVCxEE3gU7Sq16oZy4PJqPYDpnQlnHcybXRjQNRaOGHJdzJWK1gr6FnKYhLZgaVRN1K7+w6uqEshymoWA2sWgE5UIEgXfBihzY/Ng5o1p6TjRqKKPGTn/gLG6OYBqKOov1tjSYGa2eg6naIGooT96CFkwhjSBHfoTWCGp5BEFIIxBBUCZEEHg3vaxgNj9BZ3Gu8NHaqKahQPhoDnONLlQHILcm0XPUpN8MmIbUcemfp19vVCy/iFwe01DXC4ut5kgoEx9BeRFB4F2wkgCz+XFzrlijpqGslXDHHg4fzdPNy3bZFwB5ncyt7mBlHzwu6/OCpiEiQr1i5ApX1RpBnoSy4HcqfT7KhQgCz0QgK5jNT8h0kWYassMlJrJWwnpCDfoIsib0wcTsRQ3lNA1pp28wfBTIFgRB0xCgtJcsQeB6Pov8PoJsjeDEUjckkIViMPGCQF+wIgg2P2Fncf5aQ5kaQSBqqGYZIMozoStTTdBZDOSY0L2S042h49JNQ37J68rAJ5E1Ri0Aq1oQZJqG0vMIji208fT//D/xvv///tT3EdafiRcE+qaPW6Usdfp42ydv91sKCuUmFD6a6ixWr9UrJiyDMktMaGdyzTJzVxKNrtAHJp70CV1HCPnO4pwaQSfQ+wDwNIKc1URVGWozO6Es6COI+X6Pnu0AAP75vhOp7yOsPxMvCPTkELeC+djXf4RP3XYEH/nqA+s9LGGVfOehMzjwjs/j8PGlodfyOjP1hJc3o7YbcBYDXiXRvKahiLM4U5MIOH2Dx+UWBJWBIMj6LB0Nldc05GT4YHSOhGlQ6vsI689YBQERvYiI7iOiw0T0jpjXtxDR3xPR7UR0NxG9bpzjiaOfw1ksVqPy8Pk7jgGIX3VmTVSaftQkkjuzWN1OebKE236C14i2/m5UI8gXpaTHU/cFgZGp6Qw0gkHUUFrCW5aPQG8zSQRB0RibICAiE8AHAbwYwKUAXkVEl0Z2+3UA9zDzkwE8F8B7iag6rjHFoe2acaYhw1u5uBJRVBos7zeLM/2EwkdT7N164q+YhGqOjNqgsxiAZxrKCufUphrDPwYYOIMTj+uHTUp+JdFuluBxQ5+Tx0egNR2dRwBktfhMr+6qBYEx8XaI4jHOn+QZAA4z8wPM3APwCQBXRfZhADNERACmAZwGkK+m7hqhJ4y4FaJeuIhGUB602SHOGRy0W2dpBETqvWqVHBqB7cAgJTgAFQnUzojRb0dMPH74aJYA6Wonc/i4LAHS9oWVuuWVjyC/s1ifW2ofhwzTmyOmocIyTkGwB8DDgedHvG1BPgDg8QCOArgTwJuZeehKI6KriehWIrr1xIm1dTQFL9ioVkBQFyxL25rSYPmCYPi13BqBoypuEnkaQUa0jG5TSd7KoVkxs001Qyt7beJJ/6yokzmvaUh1UDN8LTefRhB0FqupIs3JniVofY1ATEOFY5yCIO7Xjl4dPwfgewDOB/AUAB8gotmhg5ivZ+ZDzHxox44dazpIO6V0rl64iGWoPJie3SHONJE3oUyXXgaAqmVm9iNQjetN/3meJjOtXjiKxzQIVcvww0qTj4toBJWcpqFAExwAqFWMzMzikEZgaUGQfIztckAQD3+/rmgEhWWcguAIgH2B53uhVv5BXgfg06w4DOBBAI8b45iGCE4IUV+AbxoS21BpsDwTRtxEb+eMGuo7KpsWQK5evZ2+i7o1uJXyNLBvRwQBkK9v8UrPUb4L7/NMQ2UJZ35ePywI8jTCGWgEpi8Y00xDtuv6pqd4jUA9irO4eIxTENwC4CARXeA5gF8J4MbIPg8B+BkAIKJdAC4BsK6xmmmRDlqFFTFQHvRqM054O8y+cM/SCCq+RmCgl2FL7/Qd1AKTbDOH2SUaPqqPy1MqIngMkK/fcafvoB4QOnkyi3vOwFlczakRaM3Iidlv4CwWQVA0rHG9MTPbRPRGAF8AYAL4KDPfTUTXeK9fB+DdAD5GRHdCmZLezswnxzWmOOyUbEht85WoofKQFjXkuoyapUwiaSUm+g6jYqn3qVkGlrtZk+xgJQzkNA311cpeCxwAqOfRCLo2pmrh27ZZNf2w0uQxhgWI1iKY2b/OowR9BHqcqVFDDqdqBL5pSDSCwjE2QQAAzHwTgJsi264L/H8UwAvHOYYs7FRnsULkQHlIixqyXUbFMNAlN7P6qDaF1CwDp1cynMUxPoI8pqHhlX2OsNO+EzInDY7LNg3VI6Yhl5XQq1rxE3M4asjTCOyUPALX9TWj1DwC0QgKx8RH9IZMQxw1DanHPF2jhGLgOytjfjPXZRgGoWIY6aYhJ2oayhM1NLiV8vQIaPcc3+EbPC5PraGpyHGNqpUdPtqLagTZxfGimcVAukZgu/k0AjENFQ8RBIGV4ZCPwE8oW9chCeeAHzWUkFBmGQTToNTw0b4zMPXkSigb0gjUsWmr+3bMyj6PJrHSGz5uqmr6+QXJn+eGxqj/T2tg3x0xj8BxOZdGYIkgKBwTLwiclJA3fbmKj6A86N8yKY7dMAiWQSM6i7Mzi8M+Ai+2P2WSbcWYhlT/4eyV/dQqTEOdiODRgiAthLQbyJge5BFkCFAzLWpI8giKysQLgn7AwTUkCCRqqHSYKXHsjsswiWCZNEL4qJkvfDQS/QOkF5Br9+0YW7+VubJf6dlo1oZNQ/l8EgFhlcM0FKo+miNqyHEZlqkEbZyPxjcNiRwoHBMvCNLUWT98VDSC0mCmagTqddMw0stQRzSCNPMJ4DmLrbCzGEgvINcONK7XTOVoRN/uOb6gCR2XaRoajhoC0ttwah9B1QxEDaXmEbD3/cZrXFqG6FwPoThMvCAI2oOjDsZBQtl6j0pYLbocSGytIdeFaRAqZvyKVdNzOGwayqURhMNHgdFNQ81adj5AXPhonmqn0TyCvBpB1VRlKfKEj9qOMrNaBsX2I3BYTENFZeIFgROIdEgMHxXjUGnQspxiKpw4jMGKNTWPYLA4qFlKe0jLLu9EQjPzmYbinb59h1NX3XHHNasmWl5OQByuy+jabqTEhPYRpGsEwe8BSK81ZLsMyzQSNQJXfASFZaIFATN7IW/qphiuNSRRQ2Uj7bdyXYZByOUs1uaLrLBJZjXJRhPKgNFNQ1ltJ3u2i77DMc5iC4432cehq4xG8wiADEFgO6h5mk4e05DjukojMI1UH4zIgeIx0YJAX6zVRGexepSoofKgV8VxWpzturAMI3Oi6juBonPeY9Ik67epDGoEOUxD7V5YiwAGzWaS/AR+d7Jo/kFGd7O4chYDH0FK1JDt+oskHT6aWmLCSfcRiK+tuEy0INAXa1LUkI9cv6Uh7adyXPjho1lhkH7UkDd5Jq2Eu353sqCzOLs0dLufohEkOH61hhEXPgok9ySINq5XY8yRUBbQdPLWGqqYRmLUkNxGxWWsJSaKji8IKvHOYv1UNILykLbqdJmhFvjp4aPBqKGarxHET5gDs0swszjdNNSzXdguD2UW59cIRhMg2vwTKjpnZZuGOn3HFwC5ag1lRA3JbVRcJlsQBHqyAsPOYm1eEB9BeUibbFR4o7eyzSgxUY2shJM0An+SjQkfTVptR/sHa7ImdN1zIFpiIqvfsW52syqNoKJNQ9k+gr7jDqKGUkpMCMVjsgVBxDQUXcXop3L5lgf9W8XNOa7LMEkFAaSFj/Yd9m3iWb16tY29FtAIapYBohSbfaQ7mSZrQte5AnHho2nHxZmG9HllZRbr/fRKPyuhLE0jEIrLZPsInLAgiGoEegUjK5nykPZTBSeqpDBIx2U4LqNqqklTawRJXcriNAIiSu0t4Jt4EjSClQTfgjYZTUcEwVRGtJEeo66BpMdYrxgZUUPhaKiqmZ6IpzuUWYYRm0eg7yMJGioeky0I3LBpKMlHIBdueUgT2g4rQZBWYkKveHU/gqzwUR01FDXzpBWQ81fo0TyCWj6NoFkbTZMYNK4PH5fVnKZrh0tnVExKzyx23PQ8AllPFZbJFgRaI6jEm4a04zGpcYdQPNKjhjxBkFKG2q/BHwkfzfQRVMK3Ulq2r96eFDWUVC5CN8iJagSNjPDRToLgqVvpGcldO1xMLyvLuq9rDSVkbotiXVwmWxDoPAIzyTSkHkUMlIg0jcBlGORVH02Y0PrehO9HDelyzUlRQ/0Ex28luVxEKyauH1i9jyDLpBSXRwAowdBJWeGrzOLBMVXT8L+fOGzHRcVI0whEEhSVCRcEYUdf1FwgCTDlIzWz2OtHkG4aCicZZmkESWaeetVEO8GvkHRMxVRVPrN8BNGic3lNQ1FBULOMDI3ADTnBKykagesyXEag+qjcO2VisgWB7yyOrz7qawSiEpQGP7M4Zh7Sma+WYSRGv/g+AjMcPppYviFRIzATE8oGpqHhoL2plP7DK10bzao51OGrZhkwckQpxTXCSdJ0gGHTUMVM+d7cwfeWVWtITK3FY7IFQTSzmKOCQFY1ZSPtF3NZmYbMlBVr1zcNhcNHkwRBktklrVlMkmlIHWclawQxlUcBL0op5bh2zwERQpM6kMdHMGwa6iX0LA72I7aM+BIecjcVl4kWBI4fNZRRYkIoDWk/oRNwZiY5i/sRZ3EtI6FMm3+ik3p9FVFDgNelLEEjWO7aQ45iTTPFOb3SdTBVtYZW4spHEH8Ms6qCGtIIrDRNatCGUnwE5WOiBUHfjxpKMg1J3HPZSCs6F3YWZwiCETOLo6ttZRpKihqKzyMA0jWCVs/xQ0yHj0vWQLRJKYrKI8gqphfMI0gOH7UDJrXkDmWxhwoFYKIFgRM1DSX6CEQUbAYGeQQp4aPRqCFLRw0lC4J6xRiy26dOzD0HFZN8IRMkrW/xcteO9SsAqtBdUpTSci9ek6inCCtfEARNQykagf4+LTOl34PvvxGJUDQSS0wQ0Y05jj/NzL+ydsNZX/qRWkPDUUPrPiThHMmTWaz6EcRPaL0EZ3Fa1FDcyj7NNLTcSTPxWDi13Ip9baVrY9dsPfa1qTSfRIJvoV5Jdhbr7VFn8XInXtj4TnbDSDS96U2iGRSPtFpDjwfw+pTXCcAH13Y468tQP4IEZ7HoA+UhNbNYN69PKIEADIeP6pIUPSc5OSzWxFOx0LNdX/gEWenamK6n2PoTBEiSsxhQ9v6lhEl6pRtvUmqkaQT9sP8MUIIgSTNyQhpBkrM42WwnbCxpguB3mfkraQcT0e+t8XjWlX5GrSGWGhOlI63onK8RmOSHO0bRCVPaWQyo6yOp1lA70gtYM4jttzFTr4ReW+raQxVEB8dZfpXRKCs9B9MpPoJHFzuxry13bezeMqxJ1CsGOrYLZh4yf8Y13KmmhY86waiheI3LL+IocqBwJPoImPmGrIPz7FNkoj6C4RIT6z4k4RzJW3QuKUKsF6k1BKSXVuj0nVDBOY0WDnGr++WOjZkEjUCZeJLDR5N8BFNVK8UnEa9JNComHJdjC8nFmYaqVnLROTuSRxCncbGYhgrLqpzFRHT1Wg9kIxhkFmcklIlKUBqyis5ZBqGSUiY5mlAGqJVwmkYQFwaa1sB+JcF5CwDNmprQh65Fl72ooWTTUGr4aIKPAEBsCOnAWRw0DaVFDQ3CR5N6Qg+cxCIJisZqo4Y2xcw4VIY6yUewKc5WcByGYSgbNnN83kgvxjSUloHb6bsJYaDJZR+WO8m2/llPU4g6ZXVIaZppKC0RLe44XxDEjHHgIwhWH82XkZ2kcaWZ7YSNZVWCgJn/bK0HshHYkYSyIdOQfpQLtzSkhSZqjcDysobj7NhRZzHgZeCmdBuLlpcA0k1DS91k09CWhvInLLT7oe1+d7KUaKNO3x3yczkue/2RUzSCGG3HNw1VwqahJBNZMHy0khCeq8cmiWXFI7NDGRG9K247M//faz+c9cWORA0lOYslyqE8pNmfdatKy4visR1GdF7teRNg0DSUVkCuswrTUFr46KwnCBY7YUGw5D2fjTie/c8LCJ6gsGj14ktXA4OEtjhh5fdZGCoxkW4aSvPBiLO4uOTRCFYCfw6AFwM4kOfNiehFRHQfER0monck7PNcIvoeEd1NRKlRSmtNtOjccKtKfeWu56iEcyHtJ1POYvjhnHGrVq0R6FpDAFC3kjt5qTyC4dvI7z8cEQR6hZ60sk/SCPRzLSiGP083vo+YlFI0Cd1DIe7c4jKL00xDQWdxUtTQIHxUKBqZGgEzvzf4nIj+G4DMZDMiMqHyDF4A4AiAW4joRma+J7DPHIA/BfAiZn6IiHaOOP5zIlsj8B7Xc1DCOZGkvTGzJwgMf7Uf6yOIlJgAlI/g9Eov9n2TEsp0W8joajupuYxGC4LFiCBY9DWCZNMQMKyBLPs9DJJ9BLEaQUzpjKplwGXE5kbYkVpDsT4CP2pI7qiisRofQRPAhTn2ewaAw8z8ADP3AHwCwFWRfV4N4NPM/BAAMPPxVYxn1ej6KDrSYTihTD1KSnx5SDI/6O16ogIQ25wmmCGrqVvJLR3bvfg8goY/MYdX6HpiTvIRzCZoBIttddyWDI0gqoFo01Bc3sLARzB8brphTTWSUAYgVivoO1GNICVqSG6nwpHHR3AnBj+dCWAHgDz+gT0AHg48PwLgmZF9LgZQIaJ/BjAD4E+Y+eMxY7gawNUAsH///hwfnY+gg8uIuXj1hStxzyUiIURRmypMg3yzT9xk1bNdWAaFagcl9R92XVZ9fWPyCLSPIDox62igtTYNNQIJbKHPS+hqBqSbhnQkUdDJrL+3aC9jIFprSEVluS6HvkdX5EBhyRQEAK4M/G8DeJSZ4+PUwsQFXUavAQvA0wD8DIAGgG8S0beY+Qehg5ivB3A9ABw6dGjNriO/wJhhwCQaNg0lDFooLkmRXtpkbXrhowBiC6P1HTfkKAZ0cba4yBqvBHWsRhBvdskyDU1VTZgGDTmLtakoyVmsJ/qo4NE+gjRncVzUUFzPBG0mStMILK/WEKCEQzUgCLTZTkxDxSOPj+DHq3zvIwD2BZ7vBXA0Zp+TzLwCYIWIvgrgyQB+gHXAdl2Y3upPlc4Nv64Fg5iGykOSHdrXCCioEcSHj0argtYrhm8zD5LUAhJQkybFdA3LMg0REWbrVqxG0KiYsRVLgYCzuBt1Fq/OR9Dq26haRsgXkGYa8msNBUxvSQmacjsVj9VmFn8ux263ADhIRBcQURXAKzHsZP47AFcQkUVETSjT0b2rGdNq6DvsTwpGTA110QjKh+uH/Ea2hzSCFNNQjEbQqMSbhtIEARGhWRmuCJplGgKUeWihHZ7QFzv9RP8AAMw1qwCAs62wAEkzDTXSfAQ9Z6iHgf5e4kJIfWex17MYGBa0nPDbCBtPHtNQHP8+awdmtonojQC+AOVb+Cgz301E13ivX8fM9xLRPwK4A4AL4CPMfNcqxzQyQTOAGessFqNm2dA/VXSO15NSaKKKMQ31bBdVM2zVrFdM2C4PmY30aj/OWQzoHgFRU026aQhQgmAoaqhtY7aRfMycJyTOJkQbxQmRtISyVs/x/RyaSpppKFJrCEgu6y6moeKxKkHAzMdy7ncTgJsi266LPP+vAP7rasZxrgwJgsj1PZADcuGWBf83i0w2elIyvDLUwW1B+o7rT3ia4Mo5KAj8xvUJ5prZuuWvyDV6Yo5WJA0d16gMmYbOtHqYa1QTj2lWTVRNA2da4TDXhVYfVcuIzX7WNv9409BwolzV1wiGv7dorSFA8nLKRKZpiIgOEtGniOgeInpA/63H4MaNHTANmRRjGvI7Kq370IRVkvSbaW3PMgim95vHlaLuO26ozhAQjK4J75/l+J1tVHA2MjGfafVgGpSYD6CPizqLT630sG06WRAQEbY0Kzi7MuxbmEswKRkGeSW2Y8xevRhB4FVkjSsz4TuLTcN3xidpBLKwKh55fAR/AeBDUBFDzwPwcQB/Oc5BrRc9x/VXh3EagTi3ysfArxNxFnsrVsMgP0cgvugcx0YNAcO29JUU+zsAzDWHV/ZnW8rWn2GadYwAACAASURBVNb+dEujgoWIrf90hiAAgPlmBWfbEY2gne5bSAqNbfccNCvh88rjLK6YaRqB9xifnCxsIHkEQYOZvwSAmPnHzHwtgOePd1jrgx2IEDENSqw+KiuY8uDnfkQmm7iolrgJrRdnGsoIBU0UBI3KkPP2bKuPuWbyxAwA26eqONPq+WO2HRdnWj1snaqlHjfXqOLMiJ+XlCyXbhqKcRa74VpDAIZ6EkiHsuKSRxB0iMgAcD8RvZGIXgpgXUtBjIu+4/qrFzMuoUw/ynVbGtwE84M2DekOZUCCjyDOWWzFF5BLi9EHVCRP1DR0tt3DfDN9Zb9jpgaXgVMrXQDAmVYfzMD2DI1grjmsSeTTCIYn9nbPHooaSuvfHO1ZDMRFDYUfheKQRxD8JlRZid+ASv76RQC/PM5BrRcqfFR9BQalVR8VykJSFywnsGJNMl0A8eGjSeUb0mL0AS/6p2OHBM6ZlWSbvWbHjFr5n1hSgkDXOdqWoRHMN6vDzuJ2PzEbGVAO47gKqa2YXsxpJSlsh2EQvH4PSVFDkqlfVPIklN3i/bsM4HXjHc76oqKG1EVrGcbQCkY/lRVMefA1gQRBoKJakjOLu7YztILWpp+hZC2vnENS+8hgAbn5KbWaX2j38fjds6nnoAXByWU1qZ9aVgJh61S2RnC23Q/1IFbO4uTjpmvW0HkB8c5iHWUU18C+77qwPAGa5SOQpVXxSNQIiOjarIPz7FNkbHew+jPiwkclpax0JMWqDzQCI2Aaiikb0Xf9KCGNLwiGSjzbaFTMoUqcGm2bDzqMz7R6mM/wEeyYVo3mtUZwwhMEO2ayBEEVPdv1fRl9x8Vy1041Dc3EhLgC8JrZRASBpxHEdWvr2+z7EJKihlyJwissaRrB64loMeV1gsoWvnZNR7SO9G32JwUr1lmsHuXCLQ9J5ryBM3OwYo1rxN6xnVB7RmDgA4hOmMsJvYA1WhCcafVwAFPo9B20ek62s9ib8LUgeORsGwBw/lwj9Tj9vmdbfTSrFk55GsX2FAEyXa/gwZMroW3MHFteW+dLxCWg9RzH9yEkaQSDZD+5oYpGmiD4MFRF0DQ+vIZjWXf6rotpL0QurvpoUrkCobgkTTZBjSAtDLLbd0M1+IGBDyCujk9SD2EA2D4dtvXrx50z9dRzaFYtzNYtHFtQAuCRM23MNyuJJijNfEDwnD/X8D9vx3Syb2GmbmEp0h+51XPADDQjQi5NI1AZ2YMIPGBY4xKfW3FJvLKY+ffWcyAbQSizOMZZjAQzg1BckiJTfEFAlBr90rVjBEFVawTDzuI0jUBP+Me9CVk/7phNd/oCwP5tTTx0ugUAOHq2nakNAMC26bBv4cRyR33eTIogqFlYGtJ04gvjaY2gG6cR2O6wRhANHxUNu7CsqujcZiGYWWwZhtg0NwGD3yySUBboR+ALgjiNwB5uRm8YhGbVHNIIljMEwfbpKogCgmBRTcw7UyZmzf6tTTx0SguCDvbkEATnzSrB8xNPk/A1gjRBULfQs93QKn8poQyG5dUR6sRpBI4byskBkn0EsrAqHhMtCHrOINLBMFLK5q73wIRVk+Te11YKy0zWCJgZnRjTEKAcxnFRQ2nF4yzTwLapKk4sKQGgBcKu2XTTEADs3zqFh8+00HdcPHymhT3z2YJAv++xBfV5WhBsTzUNqcl+OWAe0qaiuFLZqiRFgkago4YSGv/I/F9c8tQa2roeA9kIbIdDds1o9dFBQplcwWUhqx+BQeT/5tEwSK0h1GIKtE3XhqNrFtr91JpBALBjpo7ji9o01IFlELZmJJQBwIFtTfQdxtfuP4lWz8GlGSGngEr42j5dxaOLA0GwpVGJLTin0YJsKU4QxHY1M2PDR7t2UCNIihpSj3I7FY88GsG3ieiTRPQSSiuQUkLCmcXJpiGhPCQVndO/pWVQYqkEPcHFaQRxpqGFVnrWLqDMQFoT+MlCF9una6H2jUk8ed8cAOBj3/gRAOCJe7ZkHgMA522p+xrBI2c7vrkoCb3qjxUEMRVSa5YRm1AW6yNITCiT+6po5BEEF0O1iXwtgMNE9PtEdPF4h7U+BEsOm5ScCSnXbXlIyizWjkvdka5i0pCPQE9wcRrBVM3CSiAD13UZSxkx+gCwd76BH59aATPjR6dW8JhtzVznccmuGczWLXzlBydQsww8dud0ruPOm23gqBdu+qNTKziwPf3zprUg6A5yHZa9/6eTTEMxGkHPGZjUEqOG9KPcT4UjUxCw4ovM/CoAr4cqL3EzEX2FiJ499hGOkb7DqARqDUnZ3PLjFzZLDB9Vv3fVNIY1gn6yRhDNwF3q2GBObiavuXDHNBY7Nk6t9PDAiWVcuCPfhG4YhOc/TpX0euETzhsqe5HERTun8KOTLfRsFw+dauHAtqnU/XUP5MV2Ph+BMg2lh49m9SOQ+6l4ZJaYIKJtUPWFXgvgUQBvgmo5+RQAnwRwwTgHOE6GG9NI1FDZSQwfDZiGAGVPH8U0NFu3cP/xwapZZwtnaQQX7lAT8Xd+fAZnWn1cuD19Yg5y7c8/AY/bPYt/+7S9uY+5eOcMeo6Lbz5wCj3HxYGMz9OlL4LF8RY9QTAdk7egTEPp4aNZPYul1lDxyNOh7JtQ/Qd+gZmPBLbfSkTXJRxTCmyH/aih+FaV6lEEQXkYTDbxGoGRKgi8jmMxpqG5ZjXU9CWvILhou9IAvnD3owAGgiEPc80qrvnpi3LvDwCXnKdyQD9/x1EAwAVZgsBLQjsdEATLHRUNFefLqFkJGoET9BHE13LigYotFIw8+uY7mfndQSFARP8WAJj5PWMb2ZhhZnXxmgNn8XD1Ue9RrtzSoH+rJEEQ1AiiE1onxTQ016xgqWv72ch5BcHe+QbmmxX87XfU7aOdwOPisTunUTUN3HDrEZgG4UkZTuZGxUTNMkJ9E5Y6/VizEADUKgk+gmBmcUKZbzENFZc8guAdMdt+e60Hst74E0MgszgpykE0ghKRoMXZcT4CJ14jiNYaAuD3ENBN5bUgmMsIBTUMwvM8W/+T982lxvSvBfWKiSsObgcAXH7RttSEN0C1uNw6VfVLXQNef+SE86pZZqZpKMlHoO85MQ0Vj8SrhIheDOAlAPYQ0fsCL81Cta0sNbrgWLj6qNQaKjv6N4ua+YacxZaZ6COIVh8FggXk+tg2XfNbQmZpBADwthdeAgD4d/9qfdxp/+nKS7GlUcGvPTefWWk+0kDn1EoP2xJKXiuNID181PQFQaSsuy+k5Y4qGmnLhaMAbgXw8wBuC2xfAvCWcQ5qPdCNyysp1Ud56B+h6GQXnVO/d1wYpG7iHqcR6BXyQlv3CFCP81PZguD8uQb+6OVPyXkG586B7VP4o1fk/7z5qUpIIzi90sO++fiw07plxmYWd53sWkPa9Cq3U/FIKzp3O4DbieivmLn0GkAUvRoMrmKSGmmITbM8+HkECT2LTcoRNRSnEXgr/zOew/jEUhdzzUqs0Cgb880qjp0dVJw/tdxLbILTrJpoRfoyMDN6tovaUPXRpFpDazZ0YY1IMw3dwMwvB/BdIgr+dASVXnDZ2Ec3RnTykO5HaxAltqqUC7c8JBU2s31nsZqsapYxVDJCt2yMixrSPoKz7YEgSCvvXCa2TVX95jdd28Fy107sj6wEQdg0pM2sQ1FDUR+BZJQVljTT0Ju9xyvXYyDrjR8hUhmos0O1hsSmWTqSTENayOuIlriEMj3BTVVjBIFnAjq9MugallbVs0yct6WBpY6Nla6NRa/y6NaE/siNqqo15Ljsr/y10304j0D6EZSFxKghZj7m/XsSwMPM/GMANQBPhvIflBpfI/BWf4ZBcKI2Tblwy4f3Y0UrTNs5TEPa5BHt1QuozOKpqunX8Tm+1Nk0gmD3lkHVUu37SDIN6d4MQfOQb2bNyCweRA3JHVU08oSPfhVAnYj2APgSVAP7j41zUOtBNHnIpLiEMgkfLRtJJSb0b2kGE8qcYY0gWJQuCBFh91wDx852wMybyjQ0EARtv3LpzoTmOVpItgPmoYG/bbCoMmJqd0mCZnHJIwiImVsA/g8A72fmlwK4dLzDGj/aNKS7LplmWq0hoSxoa8SQj8CJJJQlmIYaVRNJRXZ3b6nj2EIbZ1p9dPouztuS3VegDOjuZ8cWOn5XtMdsjY8a0g3tV2IFwWA6sQxjOPjClYVVUcklCLzicq8B8HlvW57SFIUmahoyKVkQyJVbHrRGEP0ttb06rcREq2f7E10c529p4OhCBw+eXAYwWrmIIqNX/0fPtvHQ6RamqmZq1BAQNg0NtOvBdJJWu0tMQ8Ujz4T+ZqhM4s8w891EdCGAL493WOMn6iyOrzUkPoKykVR0rhdoQgQkCQIntUG8bgh/77ElAMAF2/NVEi06NcvE/q1N3P/oMrq2g31bm4lakf5+gqYhrR0Ehahl0HAegQiAwpIpCJj5q1B+Av38AQC/Mc5BrQfR8FHTIDAr9VWvGkUhKB96ERoV6rbj+smDgNIE25EGK+2ek6oR6IJun7vjKComYV+O9pFl4dLds7j76AJMg3BRSqnsgUYw+O58J3tlMJ0oU2tSZvFajVpYK/KUob4YwNsAHAjuz8zPH9+wxk8nxlkMqAnEgPpfimSVkXjzQ7AJEaBCRG2XQ6URVjJMQz+1XxWM+9YDp/G482b8OlWbgSecP4t/vPsnAICrnrIncb9GjGmonaQRiGmoNOS5kj8J4LsA3gngtwJ/mRDRi4joPiI6TERxxev0fk8nIoeIXpbnfdcC31lcGTiLgbBtWVYw5SMps7jnsJ/oBACNGBNHu+f42+PYNVv3I2ye89jtazTiYvDMC7f5//+rx25L3K/ph48GNYJhQRDnI3CkxERhyeMjsJn5Q6O+MRGZAD4I4AUAjgC4hYhuZOZ7YvZ7D4AvjPoZ50KcsxiIOBklfLR0JGYWB0qOA4OksZWejS1eQblWz8H5c+klI373f388PnnrEbz+igvXctgbztMPzOPVz9wPg4Cn7p9P3G8qxjTkawSBSqdxUUOSoFlc8giCvyeiNwD4DICu3sjMpzOOewaAw55PAUT0CQBXAbgnst+bAPwtgKfnHfRaMCgwFsmG5BiNYD0HJpwTSZnFfccNmXIasbZuJzaZLMiVl52PKy87f20GWyCICL//0idl7heXR6DNRM1KTo1AbqjCkUcQ/LL3GDQHMYCsJdEeAA8Hnh8B8MzgDl6S2ksBPB8pgoCIrgZwNQDs378/x5Cz6diq2baOjtCCwA2ZhuKTk4TiEmxez8z+79t3OOQsjsuQzQofFQamoWCdJh011MjpI5C7qXjkiRpabRH1uPiz6DXw3wG8nZmdpHA1bwzXA7geAA4dOrQm11Gn74SKi+lEo34g5E3m//IR/MmYAX1ZBftTA0nRL+nho4JaME3XLL/BPaC0A4PCnd2URhCNGpKFVVHJEzXUBPAfAexn5quJ6CCAS5j5cxmHHgGwL/B8L4ZrFB0C8AlPCGwH8BIispn5s3lPYLUoQTC4cPUkEWymISUmykdwkglGgEUFQTT6pWs76NouZjI6egnAbN3yi9MBAwEaXMyZsXkE4UehOOSJGvoLAD0Al3vPjwD4f3IcdwuAg0R0ARFVAbwSwI3BHZj5AmY+wMwHAHwKwBvWQwgAKmooqBHoSSKYZDQwM8iVWxaCP1Xwd7PdiGmoFo5+0Stc7TgWkpltVPyWnQDQ7ttDvhUrpmTLIGpI7qeikUcQXMTMfwigDwDM3Ea82SeE18zmjVDRQPcCuMHLTL6GiK45hzGvCZ2+4yeTAfBjzPuBQmR+AbP1HZpwDgQnmaBQ6NkRjcBbBLS6ShDoHsSzdREEWczWK0MaQbR0txlXa0g07MKSRw/uEVED3nxIRBchED2UBjPfBOCmyLbrEvb9lTzvuVYsdWzM1Aenr0MLe3ZcHoFcuWUhaJYOrkj7jhuy/w80AqUJ6BVunh7Ek85sw8LRsx3/eSsm/8KKiRpKKv8hbDx5NIJrAfwjgH1E9FdQpajfPs5BjYPbfnwab/ir23DcK7O71O2HBUGMRiBRDuUjqBGkmYaiVTQXPdPQbEN8BFkMawTD0Vaq9WvYWTwIH5U7qmhkCgJm/ieoEtS/AuCvARxi5tIVnTu13MNNd/4Ejy4qZWapY2M2sPrTZoOgIBgUG1qvUQrnSshHEPgpe3Y4j6BmGTBoEA+/IBpBbqI+guWO7WtYmjiNQBZWxSVTEBDRl5j5FDN/npk/x8wniehL6zG4tUSX1T3dUh2YFtthjcB3FotGUGqSnMV9xw1VHyUiTFUtPx5+UXwEuZmtW1jq2n7OzZlWH/MRJ7sptYZKRVrz+jqAJoDtRDSPgYN4FkDpUivndPPxVg/MrDSCepxGEDYnAKLKlomgachJMQ0BKkJIawLa1DErGkEms40KmFV5jpl6BWdbPcw3w/0L4jUC9Si3U/FIM4j+BwC/CTXp34aBIFiEqiFUKvSK5cxKD+2+A9tlzAQEgV4t9gPho64UySodiRpBxDQEKC3x9IrSEBfafVQtIxRSLMSjF1WnV3poVEwsdmzMDWkExlAegRSdKy6JgoCZ/wTAnxDRm5j5/es4prGwpVEBEXC61fdjxoOOwYrlRQ0FTENaIxBVtjxEM4s1PYdD4aOAmtDOeqbCsyt9zIk2kIsdM6qj2YmlLqY930D0u4tqBEGtWjTs4pGnxMT7iehyDPcj+PgYx7XmWKaBWU+N1fbgmVjT0EAQSJGs8hEU2sGJyHbD1UcBYGuz4redPL7USWzYLoTZMT0QBPOe720+0trSNMNRQ2GhsA6DFEYiT4mJvwRwEYDvAdCFWRhAqQQBoEwBZ1r9QahgKI9gOLPYFkFQOkYxDc1PVXFmRS0Kji91sWt2czSjHze+RrDcxc6W+n8uw0cQ9NfI7VQ88gRNHwJwKW8CfW6uWcGZlXiNYJBHEIhDF9NQ6Qj+UsHw0b47bBra2qxiuWujazt4dLGLy/ZuWZ9BlpytU1UYpDQCLUijpqFo1FDQXyD3U/HIk1B2F4Dzxj2Q9WD7dA3Hlzo4saxyCXbODEwBcaYh8RGUD+awOUhv60d6FgMDc8bJ5R5OrXSxY0Y0gjyYBql7abHrh2NvnUrXCGwxDRWaPBrBdgD3ENHNCDem+fmxjWpM7N/axNfuP4lHF1R28Y6QIBhUqdQ4viBYx0EK50RwktG/n+MymDGkEWzzJq/vH1sEM7BLfAS52Tlbw7HFDo6d7YAIQ/6VaK0h27uvDBJncRHJIwiuHfcg1ov9W5to9x3cc2wRs3UrvvpoSCMYrCiFchDMI9BmPj0hRQXBge1TAICvHz4FANglGkFuLtoxjVt/dAa7Z+vYPl1DzQqH3VZMil1UVUxDNIICkidq6CvrMZD1YP/WJgDga/ef9CcBTbQMNTNL/fQS4rqqGQ3zYPLRwj1qGrpg+xSIgC/e+xMAwIU7wteEkMzBndP4u+8dxV1HF/z7Kki9Yvp9wQHlowE8QbBuoxTykugjIKIlIlqM+VsiosX1HORasc+7YJe69pAgMA2CaQxWMUH7pvgIygMDqBiev8fT6HSSYFQjqFdM7J1v4OHTbVQtw78+hGwO7poBANx9dBEXe/8HqVsGOn3X16YdRwsCEg27gKQllA3/uiXngsDk/5R9c0OvK3U2bE4Awn2MhWLDrEpJ9JyBMNe/pWUOt9G4ZNcsHj7dxlP2zQ0JCiGZYITV0x4zP/R6zTO7dm3VAEqbWSumEhBCsZioK980CG/52YuxZ66BKy/bPfR61TR801BYI1i3IQrnCPNwk6GuN/FE7dgA8O+ecwDzzQp+9Tmrbc09meze0sC/eepeXLh9Ci+4dNfQ69r/pr97O2QakhuqaExc8fU3/+xB/MbPPDbUX1VTtYyBachTX4nENFQmGIN8AS3M256tuhFTR+jyi7bju+964foNcBPx3pc/Gcwcey/pfuAd28EWVPw8gqolzuIiMlEagSbuwgXUasUXBPrCNQ0RBCWCGagY6vfVk492WurJSVg7ku4l3QZWf/cD0xCJICggcmcEUIIgbFdWgmAjRyWMAmNgGrJzaATCeNCmoU7ENGQZYhoqIiIIAlRMGvIRWBLlUCpcHpiGdBKTrxFURRCsF75pSGsEOmpITEOFRARBgIppoGuHfQQV0QjKRSCDWK9CfUEQ4ywWxsNAIwibhqomiam1gIggCNComuja6sIdxD2Lj6BMMOCXm3Z8QaAmoYZoBOvGwFnsmYacYNSQUDREEARoVk20epEVjKfKinmoHARNQ9rxLz6C9UeH6ra9+0lKTBQbEQQBGhUrIAgGmZCAVEwsC8yDxDE/fLQnUUPrjZ9H4GnYfSec3S0Lq2Ihd0aAZtVEu6ea1minsb6gxTxUDoJ5BLq+TcfWgkA0gvViyFmso/C8lrDidysWIggCNCoD05B2GmsHo1y45cB1B93m/KihngMioGbJ5b5eRMNHZWFVbOTOCNComr49WV+4NW9lIxduedC/mTZHdGwXdctMTH4S1p5o1JA2EU1VVTEDR1ZWhUIEQQBlGvIEgRNewYgcKAfM7Gtxus5Nu+dIxNA6U7e0acir9+QtrJre7yCCoFiIIAjQrJqwXUbPdkWVLSkM5Sy2DPInn3bf8ScmYX2wTAMVk3wNuxsJ4XXkfioUcncEaHhqa7vnDASBJaahMuEyg0CoWYZvluj0Hckq3gBm6hUsd1Vze20a0iG8Utq9WIggCKDV1lbfRs/xLtyqvnA3bFjCCDguYBiEWsX0NYJO35Gs4g1gpm5hsa2i8Lq2C6KBhi2moWIxVkFARC8iovuI6DARvSPm9dcQ0R3e3zeI6MnjHE8WviAIagRiGioVLjMsQ2kEehW60nUwVRNBsN7M1itY6miNwEXNMmB4lWHFNFQsxiYIiMgE8EEALwZwKYBXEdGlkd0eBPDTzHwZgHcDuH5c48mDVlvFNFRebMeF6QsC9RsutPvY0qhs8Mgmj5m6haXOIC+nZpkwvcgt0bCLxTg1gmcAOMzMDzBzD8AnAFwV3IGZv8HMZ7yn3wKwd4zjyaTp+QhaPcefRGoVySMoEy4DBhFqluk7KBfafcyKIFh3ZusVLHYGPoKaZUB3AxWNoFiMUxDsAfBw4PkRb1sSvwrgH+JeIKKriehWIrr1xIkTazjEMA3fNGT7gqDhh4/KhVsGbNeFZRLqlYFpaFE0gg1htjHQCNo9B7WKAcPXCOR+KhLjFARx2Tuxvz4RPQ9KELw97nVmvp6ZDzHzoR07dqzhEMPM1pVGsNSxsdK1YRoU8BGM7WOFNcR1BxpBu+/AcRlLXVsEwQYwU69gsa00guWug+laBaYRrgMlFINxCoIjAPYFnu8FcDS6ExFdBuAjAK5i5lNjHE8m81NVAMDplR5aPQdTVdNXZcVHUA4cz1k8Xbew0nX8iUgEwfozW69gpefAdlysdG1M18yBIJD7qVCMUxDcAuAgEV1ARFUArwRwY3AHItoP4NMAXsvMPxjjWHIx16iASAmC5a6N6ZrllyUQQVB8mBmOyzAMwnTNwnLXxlkRBBvGjKdhL3dtLHdtTNUsMQ0VFGtcb8zMNhG9EcAXAJgAPsrMdxPRNd7r1wF4F4BtAP7Um3BtZj40rjFlYZkGtjQqONPqodWz0QxcuCIHio+eW7RGsNSxsSCCYMPQDvqFdh8rXRuP2dYUjaCgjE0QAAAz3wTgpsi26wL/vx7A68c5hlHZ2qx6GoHjrWDUdtEIio9uJmQahJmaheVuXwTBBrJrtgYAeHSx62vYemElPoJiMVZBUEbmp6o40+qh3XMwXTMHqqxct4VHx6YbpExDnb6LE0tdAMBcUwTBerN7Sx0AcGyh7Yfwao1A8giKhZSYiDDfrOLUcg9nWn1snaqBRCMoDdrcYBnkT/z3HlsEAOyarW/YuCaV87Y0AAD3P7qMru1i+3QVlicIbJEEhUIEQYStUxWcWunh5FIX26aqAR+BCIKi43gN0g2DsGNGTfx3HlnAdM3CTF00gvVGfe8W7jq6AADYNlXzS0zIwqpYiGkowt75pm9O2D5d9VVZW2xDhSeoEeyYUfbp7zx0BhfumNrIYU00u7fUcccRJQi2z9T8EhOOKASFQjSCCI/Z1vT/372lMVBlHREERUebGwyDsGeu4W1jPHbn9EYOa6LZv3UKp1d6AIALtk3B0CUmZGFVKEQQRHjini3+/xfvmhk0QpclTOHRZmeTyI9YAYAnnL8l4Qhh3Fy2d/Dd75lvDIrOiWmoUIggiHDh9ins29rAnrkGHrd7BpYppqGyEDQNERFe9QyV2P5zTzhvI4c10bzkSbthEPALTzkfpkFSYqKgiI8gAhHhi2/5aXT7LiqmAcsQjaAsBJ3FAPDuq56It77wEmyfrqUdJoyRx+6cxq3vfIFfx0v6ERQTEQQx1CumX2yuYoqPoCwENQJAZYqLENh4tno1vAAE+hHI/VQkxDSUgeX5CCTuufg4AWexUEwkCq+YiCDIQK8u+6IRFB4n4CwWiknVElNrERFBkIGOGhLTUPEJ1hoSiknVu590K1ihGIggyGAQNSQXbtHRkSgiCIqL1ghEEBQLEQQZiGmoPOjJpWbJZV1UxDRUTOSOycB3FsuFW3hEEBQfLQi6ohEUCrljMqhIlENp0JNLVQRBYfF9BLKwKhRyx2QgGkF56NoOAKBmmRs8EiEJcRYXExEEGUiJifIgGkHxMQyCZZAIgoIhd0wGFb/EhAiCotMVH0EpqFqGOIsLhtwxGehJpdN3NngkQha+s7gil3WRqVqGaAQFQ+6YDAyDUK8YaIsgKDy+RmCKj6DIVE1DnMUFQwRBDppVC62evdHDEDLwncWiERSaRtVEuycLqyIhd0wOGhUTLblwC0+37zmLTbmsi8x0zcJyVxZWRULumBzICqYcLHdtNKumVB8tOFM1C0sdEQRFQgRBDppV0QjKwFKnj5m6tNgotVPeDQAAC+xJREFUOjOiERQOEQQ5aFREIygDSx0bs/XKRg9DyGC6bmFFBEGhEEGQg9lGBYud/kYPQ8hgUTSCUjBds7AopqFCIYIgB9unqzi53NvoYQgZLLZtzIhGUHi2TddwptWTsi0FQgRBDrZOVXGm1ZM+qwXn0cUOds5Ij+Kis3OmBmbI4qpAiCDIwfbpGhyXcbolF25R6dkuTix3cf5cY6OHImSwa7YOAPjJYmeDRyJoRBDk4MC2KQDAj06ubPBIhCQeOdsGM7BnXgRB0blgu7qffnh8eYNHImhEEOTgoh3TAIDv/2Rpg0ciJHHXIwsAgEt3z27wSIQsDmxromYZuP3I2Y0eiuAxVkFARC8iovuI6DARvSPmdSKi93mv30FETx3neFbLvq0NnDdbx5fufXSjhyIk8OXvH8dM3cLFu2Y2eihCBpZp4LmX7MA/3PUTv8+0sLGMTRAQkQnggwBeDOBSAK8ioksju70YwEHv72oAHxrXeM4FIsKrn7kfX77vBP6/bz8kMdAFYqHdx6duO4Ibbz+Kl/7UHulFUBJe9rR9OLHUxTs/exeOnm2DWQTCRjLOoOtnADjMzA8AABF9AsBVAO4J7HMVgI+zugq+RURzRLSbmY+NcVyr4vVXXIB/uf8Efuczd+J3PnMnZusW6hUTFdOAZRJMIiBnZYM8uxGNViZB30ih24kxtC26X/D+Y29raFvM/Rn3Wex/Fsdsi3uvmM+KvH/iOL0nLsPPUP2p/XN46wsvGR6sUEh+9vE78frnXICPfO1B/PXND6FqGphtWLAMdT9VTAN5boGsXfLcR2UqSPKKp+/D66+4cM3fd5yCYA+AhwPPjwB4Zo599gAICQIiuhpKY8D+/fvXfKB5aFYtfOLqZ+MbPzyJO44s4PhiB13bRd9hOK6bu4NZrr1yLo4YDApexhR6UP97N0J4W3i/4M1CQ//A/wwa/qjItpj9Yt5w+PPzflb4liVSESiX7p7F5Rdt89uKCsWHiPDOKy/FK56+D18/fBLHFjpY6tqwHRe2w+i7nKklZN4mOe4jznuzFYTt0+MJjx6nIIgTtNFvPc8+YObrAVwPAIcOHdqwX840CFcc3IErDu7YqCEIwqbi4K4ZHBS/zoYzziXUEQD7As/3Aji6in0EQRCEMTJOQXALgINEdAERVQG8EsCNkX1uBPBLXvTQswAsFNE/IAiCsJkZm2mImW0ieiOALwAwAXyUme8momu8168DcBOAlwA4DKAF4HXjGo8gCIIQz1hLNTLzTVCTfXDbdYH/GcCvj3MMgiAIQjoSZiEIgjDhiCAQBEGYcEQQCIIgTDgiCARBECYcKluNDyI6AeDHqzx8O4CTazicMiDnPBnIOU8G53LOj2Hm2GzY0gmCc4GIbmXmQxs9jvVEznkykHOeDMZ1zmIaEgRBmHBEEAiCIEw4kyYIrt/oAWwAcs6TgZzzZDCWc54oH4EgCIIwzKRpBIIgCEIEEQSCIAgTTukFARF9lIiOE9FdgW3XEtEjRPQ97+8lgdd+m4gOE9F9RPRzge1PI6I7vdfeR6P2ilxHRjlnInoBEd3mndttRPT8wDGb8pwDr+8nomUieltgWynOeRXX9WVE9E0iuts7v7q3vRTnC4x8XVeI6H9453YvEf124JhSn7O3/U3eHHU3Ef1hYPt45i9mLvUfgP8NwFMB3BXYdi2At8XseymA2wHUAFwA4IcATO+1mwE8G6pr2j8AePFGn9sanfNPATjf+/+JAB4JvLYpzznw+t8C+GRwn7Kc84i/sQXgDgBP9p5vm4Dr+tUAPuH93wTwIwAHNsk5Pw/A/wRQ857v9B7HNn+VXiNg5q8COJ1z96ugLp4uMz8I1QfhGUS0G8AsM3+T1bf6cQC/MJ4RnzujnDMzf5eZdde3uwHUiai2mc8ZAIjoFwA8AHXOeltpznnE830hgDuY+Xbv2FPM7JTpfIGRz5kBTBGRBaABoAdgcZOc868B+ANm7nr7HPe2j23+Kr0gSOGNRHSHp3rNe9v2AHg4sM8Rb9se7//o9rIRd85B/g2A73oX2KY9ZyKaAvB2AL8X2XcznHPcb3wxACaiLxDRd4jo//S2b4bzBeLP+VMAVgAcA/AQgP/GzKexOc75YgBXENG3iegrRPR0b/vY5q/NKgg+BOAiAE+BulDe622Ps5txyvYykXTOAAAiegKA9wD4D3pTzHtslnP+PQB/zMzLkf3Lfs5J52sBeA6A13iPLyWin0H5zxdIPudnAHAAnA9lJnkrEV2IzXHOFoB5AM8C8FsAbvBs/mObv8baoWyjYOZH9f9E9GEAn/OeHgGwL7DrXgBHve17Y7aXhpRzBhHtBfAZAL/EzD/0Nm/mc34mgJd5TrY5AC4RdaB8BqU954zr+ivMfNJ77SYou/P/ixKfL5B6zq8G8I/M3AdwnIi+DuAQgH9Byc8Z6vf8tGfmuZmIXKhic2ObvzalRuDZzDQvBaA98jcCeKVnI78AwEEANzPzMQBLRPQsT/L+EoC/W9dBnyNJ50xEcwA+D+C3mfnreofNfM7MfAUzH2DmAwD+O4DfZ+YPlP2cU67rLwC4jIians38pwHcU/bzBVLP+SEAzyfFFNTq+fub4ZwBfBbA8wGAiC4GUIWqODq++WujveZr4HX/ayiVsQ8lGX8VwF8CuBMqkuJGALsD+/8ulLf9PgQ861Cribu81z4AL+u6iH+jnDOAd0LZUr8X+NNRCJvynCPHXYtw1FApznkV1/UvQjnG7wLwh2U731Vc19NQEWF3A7gHwG9tonOuQmlzdwH4DoDnB/Yfy/wlJSYEQRAmnE1pGhIEQRDyI4JAEARhwhFBIAiCMOGIIBAEQZhwRBAIgiBMOCIIhEJDRH9MRL8ZeP4FIvpI4Pl7ieg/ruHnfYyIXrZW7xd4398J/H8gWm0yZSwPEtE1azSGtxDRQ0T0gbV4P2HzIIJAKDrfAHA5ABCRAZVh+YTA65cD+HrMcUXjd7J3ieW3mPm6tRgAM/8xgHetxXsJmwsRBELR+To8QQAlAO6CyqKcJ6IagMcD+C4RvYuIbiGiu4joei/j9PFEdLN+I28lfof3/9O8gl63eVrG7ugHJ+1DRP9MRO8hopuJ6AdEdIW3vUlEN3gF0v7GKxp2iIj+AECDVD39v/Le3iSiD5OqN/9PRNTI+iI8DeF9RPQNInpAay5E9FxvnDd44/kDInqNN747ieii1X75wmQggkAoNKxKaNtEtB9KIHwTwLehaq8fgiq/3APwAWZ+OjM/Eaos8ZXMfC+AqleMDABeAVXAqwLg/QBexsxPA/BRAP85+Lk59rGY+RkAfhPA/+VtewOAM8x8GYB3A3iadw7vANBm5qcw82u8fQ8C+CAzPwHAWajKsHnYDVVY7koAfxDY/mQAbwbwJACvBXCxN76PAHhTzvcWJpRNWXRO2HRoreByAH8EVWL3cgALUKYjAHgeqfLLTQBboUoP/D2AGwC8HGrSfIX3dwlUk54vqtIsMKHS/INk7fNp7/E2AAe8/58D4E8AgJnv0tpHAg8y8/di3iOLzzKzC+AeItoV2H4Lq5ozIKIfAvgnb/udUI1OBCEREQRCGdB+gidBmYYeBvBWAIsAPkqqLeOfAjjEzA8T0bUA6t6xfwPgk0T0aQDMzPcT0ZMA3M3Mz075TMrYp+s9OhjcR6O0B+wG/negtJhRj6OE7W7guQu5z4UMxDQklIGvQ5lCTjOzw6oByRyUeeibGEz6J4loGoAf9cOq7LYD4D9BCQVAFezaQUTPBvz+t0EHdN59onwNSvsAEV0KJbg0fc/cJAiFQwSBUAbuhIoW+lZk2wIzn2TmswA+7G37LIBbIsf/DVR1zhsAwPMpvAzAe4jodqiKrJcHD8izTwx/CiU87oDqkHYHlPkKAK4HcEfAWSwIhUGqjwrCGkFEJoAKM3e8SJ0vQTlte6t8v48B+Bwzf2oNx/grUCa0N67VewrlR2yHgrB2NAF82TMBEYBfW60Q8FgA8G4i2r4WuQRE9BYA10B1ahMEH9EIBEEQJhzxEQiCIEw4IggEQRAmHBEEgiAIE44IAkEQhAlHBIEgCMKE878A7nF8BItJlXcAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# over the original domain\n", "detected = crow(source=1)[0,:,0,0] # single timestep, all wls, (drop detector=0; through detector=2), single batch\n", "crow.plot(detected)\n", "plt.show()\n", "\n", "# over the trainin domain:\n", "with train_env:\n", " detected = crow(source=1)[0,:,0,0] # single timestep, all wls, (drop detector=0; through detector=2), single batch\n", " crow.plot(detected)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's now define a target that is one over a range of 10 nm and zero over the rest:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "target = np.zeros_like(train_env.wavelength)\n", "target[train_env.wavelength > 1.55e-6] = 1\n", "target[train_env.wavelength > 1.56e-6] = 0\n", "target = torch.tensor(target, dtype=torch.get_default_dtype(), device=device)\n", "crow.plot(target)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we need to define an optimizer that optimizes all parameters of the network:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "optimizer = torch.optim.Adam(crow.parameters(), lr=0.01)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now start the training" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8e071909abe843a19397d84e5a14d397", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=0.0, max=150.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "loss: 0.00806\n" ] } ], "source": [ "range_ = tqdm(range(150)) # we train for 150 training steps\n", "with train_env: # temporarily override the global environment\n", " for i in range_:\n", " crow.initialize()\n", " optimizer.zero_grad() # set all the gradients to zero\n", " result = crow(source=1)[0,:,0,0] # single timestep, all wls, (drop detector=0; through detector=2), single batch\n", " loss = lossfunc(result, target) # MSE loss\n", " loss.backward() # calculate the gradients\n", " optimizer.step() # use the calculated gradients to perform an optimization step\n", " range_.set_postfix(loss=loss.item())\n", "\n", "print(\"loss: %.5f\"%loss.item())" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# over the training domain:\n", "with train_env:\n", " detected = crow(source=1)\n", " crow.plot(target, label=\"target\")\n", " crow.plot(detected[:,:,:,:])\n", " plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "ptdev", "language": "python", "name": "ptdev" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.7" } }, "nbformat": 4, "nbformat_minor": 4 }