From 04a57b81fe1b9d9ceda0cc7b7c79ac36360374ca Mon Sep 17 00:00:00 2001 From: Claudio Scafuri <claudio.scafuri@elettra.eu> Date: Wed, 4 Oct 2023 10:09:47 +0200 Subject: [PATCH] esrf workshop materials --- .../1_Introduction-checkpoint.ipynb | 1199 +++++++++++ .../1_Introduction-checkpoint.py | 385 ++++ .../2_LatticeManipulations-checkpoint.ipynb | 991 +++++++++ .../3_SimpleOptics-checkpoint.ipynb | 1764 +++++++++++++++++ esrfworkshop/1_Introduction.ipynb | 1199 +++++++++++ esrfworkshop/1_Introduction.py | 385 ++++ esrfworkshop/2_LatticeManipulations.ipynb | 991 +++++++++ esrfworkshop/2_LatticeManipulations.py | 324 +++ esrfworkshop/3_SimpleOptics.ipynb | 1764 +++++++++++++++++ esrfworkshop/3_SimpleOptics.py | 497 +++++ esrfworkshop/PyAT_Installation.pdf | Bin 0 -> 282486 bytes esrfworkshop/arc.mat | Bin 0 -> 18336 bytes esrfworkshop/dba.mat | Bin 0 -> 472424 bytes 13 files changed, 9499 insertions(+) create mode 100644 esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.ipynb create mode 100644 esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.py create mode 100644 esrfworkshop/.ipynb_checkpoints/2_LatticeManipulations-checkpoint.ipynb create mode 100644 esrfworkshop/.ipynb_checkpoints/3_SimpleOptics-checkpoint.ipynb create mode 100644 esrfworkshop/1_Introduction.ipynb create mode 100644 esrfworkshop/1_Introduction.py create mode 100644 esrfworkshop/2_LatticeManipulations.ipynb create mode 100644 esrfworkshop/2_LatticeManipulations.py create mode 100644 esrfworkshop/3_SimpleOptics.ipynb create mode 100644 esrfworkshop/3_SimpleOptics.py create mode 100644 esrfworkshop/PyAT_Installation.pdf create mode 100644 esrfworkshop/arc.mat create mode 100644 esrfworkshop/dba.mat diff --git a/esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.ipynb b/esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.ipynb new file mode 100644 index 0000000..8db1dbe --- /dev/null +++ b/esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.ipynb @@ -0,0 +1,1199 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to the PyAT tutorial.\n", + "Here we will go through some of the basic syntax of PyAT. Slowly evolving into more complex examples.\n", + "The outline of the tutorial is as follows:\n", + "> 1. Defining some simple elements and creating a lattice object\n", + "> 2. Simple tracking, orbit correction, radiation flags\n", + "> 3. Accessing and modifying ring elements\n", + "> 4. Matching\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we can import PyAT (and other useful packages) and see all accessible functions using dir" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import copy\n", + "import matplotlib.pyplot as plt\n", + "import at\n", + "#dir(at)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many functions! But we cannot do anything because we do not have a lattice. Let's define some key parameters for a DBA lattice. Here I am simply taking the values from the at/machine_data/dba.m file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I want to define a drift. But how do I know what to provide to the function? We can use 'help' or ? to tell us." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All elements are found in the file:\n", + "> at/pyat/at/lattice/elements.py\n", + "\n", + "This can also be accessed by:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ABC',\n", + " 'Aperture',\n", + " 'BeamMoments',\n", + " 'Bend',\n", + " 'CLASS_MAP',\n", + " 'Collective',\n", + " 'Collimator',\n", + " 'Corrector',\n", + " 'Dipole',\n", + " 'Drift',\n", + " 'Element',\n", + " 'EnergyLoss',\n", + " 'Generator',\n", + " 'Iterable',\n", + " 'LongElement',\n", + " 'LongtMotion',\n", + " 'M66',\n", + " 'Marker',\n", + " 'Monitor',\n", + " 'Multipole',\n", + " 'Octupole',\n", + " 'Optional',\n", + " 'Quadrupole',\n", + " 'QuantumDiffusion',\n", + " 'RFCavity',\n", + " 'Radiative',\n", + " 'Sextupole',\n", + " 'SimpleQuantDiff',\n", + " 'ThinMultipole',\n", + " 'Wiggler',\n", + " '_DictLongtMotion',\n", + " '_Radiative',\n", + " '__builtins__',\n", + " '__cached__',\n", + " '__doc__',\n", + " '__file__',\n", + " '__loader__',\n", + " '__name__',\n", + " '__package__',\n", + " '__spec__',\n", + " '_array',\n", + " '_array66',\n", + " '_nop',\n", + " 'abc',\n", + " 'annotations',\n", + " 'build_class_map',\n", + " 'copy',\n", + " 'deepcopy',\n", + " 'get_class_map',\n", + " 'numpy',\n", + " 're']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(at.elements)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDrift\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfamily_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'str'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlength\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'float'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m Drift space element\n", + "\u001b[0;31mInit docstring:\u001b[0m\n", + "Args:\n", + " family_name: Name of the element\n", + " length: Element length [m]\n", + "\n", + "Default PassMethod: ``DriftPass``\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/lattice/elements.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m Collimator\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#help(at.elements.Drift)\n", + "at.elements.Drift?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that we need to provide first a 'family_name' as a string, and a 'length' as a float. We can also use the dir function to see all available attributes that can be accessed from the drift." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['FamName',\n", + " 'Length',\n", + " 'PassMethod',\n", + " '_BUILD_ATTRIBUTES',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '__weakref__',\n", + " '_conversions',\n", + " '_entrance_fields',\n", + " '_exit_fields',\n", + " '_get_collective',\n", + " '_get_longt_motion',\n", + " '_no_swap',\n", + " '_part',\n", + " 'copy',\n", + " 'deepcopy',\n", + " 'divide',\n", + " 'equals',\n", + " 'insert',\n", + " 'is_collective',\n", + " 'is_compatible',\n", + " 'items',\n", + " 'longt_motion',\n", + " 'merge',\n", + " 'swap_faces',\n", + " 'track',\n", + " 'update']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "DR_24 = at.Drift('DR_24', 2.4)\n", + "\n", + "# To see all of the available attributes\n", + "dir(DR_24)\n", + "# i.e. Length can be re-set by DR_24.Length = New_Length" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A note on pointers " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python uses pointers. When creating a lattice, this can cause some headaches. Observe the following simple examples:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 1 2 3 4 100 6 7 8 9]\n" + ] + } + ], + "source": [ + "a = np.arange(10) #the array is assigned some memory\n", + "b = a #b is now a pointer to the location of the memory for a\n", + "b[5] = 100 #we modify b[5], but it also modifies a due to pointers\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0 2.0\n" + ] + } + ], + "source": [ + "drift = at.Drift('Test',5) # Drift of length 5m\n", + "pointer_test = [drift, drift] # Here we make a list of 2 drifts of 5m each\n", + "\n", + "# Now we can reduce the length of the first drift\n", + "pointer_test[0].Length = 2\n", + "print(pointer_test[0].Length, pointer_test[1].Length)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "As you can see, the drift variable was placed twice in the list. When you modify the length of one, you are in fact modifying all. This can cause issues if you predefine elements (drifts, quads, sexts) and then place them in multiple places in the lattice. One must be careful!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can perform similar actions to define the needed dipoles, quadrupoles, sextupoles and markers" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "Nhalfcells = 25 #actually it is 50 half cells\n", + "K_QF1 = 0.38041 #Strength of the quadrupoles\n", + "K_QD2 = -0.2708\n", + "K_QD3 = -0.33319\n", + "K_QF4 = 0.4588\n", + "\n", + "Ks = 0.1 # Strength of the sextupoles\n", + "L1 = 3\n", + "\n", + "# get arc lattice structure\n", + "arc_half=[at.Drift('DR_01', L1*6/8),\n", + " at.Quadrupole('QF1', L1/4, K_QF1),\n", + " at.Drift('DR_02', L1*2/8),\n", + " at.Quadrupole('QD2', L1/4, K_QD2),\n", + " at.Drift('DR_03', L1*2/8),\n", + " at.Bend('Bend', L1, 2*np.pi/(2*Nhalfcells)), \n", + " at.Drift('DR_04', L1/16),\n", + " at.Quadrupole('QD3', L1/4, K_QD3),\n", + " at.Drift('DR_05', L1/16),\n", + " at.Sextupole('SD', L1/16, -Ks),\n", + " at.Drift('DR_06', L1*3/16),\n", + " at.Quadrupole('QF4', L1/4, K_QF4),\n", + " at.Drift('DR_07', L1/16),\n", + " at.Sextupole('SF', L1/4, Ks)\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have made a list of elements that represent a half cell consisting of drifts, dipoles, quadrupoles and sextupoles. This is just a python list. We will now use this half, make a full cell (first half + reverse of the first half) and convert it into a lattice object and start to benefit greatly from what PyAT has to offer." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Periodicity: 25\n" + ] + } + ], + "source": [ + "arc_half_copy = copy.deepcopy(arc_half) #This is to avoid problems with pointers when copying the half arc\n", + "arc = arc_half + [at.Monitor('BPM_CellCenter')] + arc_half_copy[::-1] #We also add a monitor in the center for later on\n", + "arc = at.Lattice(arc, energy=3e9)\n", + "print('Periodicity:', arc.periodicity)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen. We had to define the energy of the ring. The periodicity of the ring has been automatically set based on the total bending angle of the cell. We can do a quick check of the linear optics using the plot_beta function." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import at.plot\n", + "arc.plot_beta()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets now make a full ring of 25 cells." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "ring = []\n", + "for i in np.arange(int(Nhalfcells)):\n", + " ring += copy.deepcopy(arc)\n", + " ring += [at.Monitor('BPM_SS')]\n", + " ring += [at.Corrector('Corrector', 0, [0, 0])]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_geometry\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstart_coordinates\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'tuple[float, float, float]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mcentered\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'bool'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Axes'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Compute and plot the 2D ring geometry in cartesian coordinates.\n", + "\n", + "Parameters:\n", + " ring: Lattice description\n", + " start_coordinates: x,y,angle at starting point\n", + " centered: it True the coordinates origin is the center of the ring\n", + " ax: axes for the plot. If not given, new axes are created\n", + "\n", + "Keyword arguments are forwarded to the underlying\n", + ":py:func:`~matplotlib.pyplot.plot` function\n", + "\n", + "Returns:\n", + " geomdata: recarray containing, x, y, angle\n", + " radius: machine radius\n", + " ax: plot axis\n", + "\n", + "Example:\n", + " >>> ring.plot_geometry()\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/plot/standalone.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring = at.Lattice(ring, energy=3e9)\n", + "ring.plot_beta() \n", + "geom,radius,ax = ring.plot_geometry(centered=True)\n", + "ring.plot_geometry?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets check to see if our ring has the correct total bending angle. For this we need to use some functions to access certain lattice elements.\n", + "\n", + "Here we will use 'get_uint32_index'. For all of these kinds of functions, you can specify either a string 'BPM' or a string with a wildcard 'BPM*' or an element in order to select the correct indices. More detail will be provded later on how to access and modify lattice elements. But for now we can see:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50\n" + ] + } + ], + "source": [ + "bpm_inds = at.get_uint32_index(ring,'BPM*')\n", + "\n", + "bpm_inds = at.get_uint32_index(ring, at.Monitor)\n", + "print(len(bpm_inds))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So what do we want to do? We want to look at every Bend element, and look at its 'BendingAngle' attribute, then sum them all. To achieve this, we can use 'get_value_refpts. This uses 'get_uint32_index' to get the appropriate indexes for the elements, then extracts the given Attribute Name." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dipole_bending_angles = at.get_value_refpts(ring, at.elements.Bend, 'BendingAngle')\n", + "np.sum(dipole_bending_angles) - 2 * np.pi" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quad_strengths = at.get_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', 1)\n", + "#This searches in ring, for all elements that match a quadrupole, then finds\n", + "#the PolynomB attribute, and takes the second index (python indexes start at 0)\n", + "\n", + "quad_strengths" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, parameters can be set using 'set_value_refpts'. For example, lets increase all quadrupole strengths by 1%" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the final part of this lattice building section. We must discuss something very important.\n", + "\n", + "If you call 'set_value_refpts' with copy=False (default behaviour), the values that you set will be modified for the ring lattice.\n", + "If you call it with copy=True, you function will return a copy of the original lattice with the modifications made, so the correct usage is" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11.761000000000001\n", + "58.805000000000014\n" + ] + } + ], + "source": [ + "new_ring = at.set_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', quad_strengths*5, 1, copy=True)\n", + "print(np.sum(at.get_value_refpts(ring, at.Quadrupole, 'PolynomB', 1)))\n", + "print(np.sum(at.get_value_refpts(new_ring, at.Quadrupole, 'PolynomB', 1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This question of in-place modification will show up in many different locations (tracking, radiation flags)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have one thing missing! An RF Cavity! Let's generate it and then place it in the straight section of the 4th cell. We can use the BPM in the center of the straight section to find the right index" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Cgamma',\n", + " 'Cq',\n", + " '__builtins__',\n", + " '__cached__',\n", + " '__doc__',\n", + " '__file__',\n", + " '__loader__',\n", + " '__name__',\n", + " '__package__',\n", + " '__spec__',\n", + " '_cst',\n", + " '_e_radius',\n", + " '_hbar_c',\n", + " '_sqrt',\n", + " 'clight',\n", + " 'e_mass',\n", + " 'p_mass',\n", + " 'pi',\n", + " 'qe']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from at.constants import clight\n", + "dir(at.constants)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#at.elements.RFCavity?\n", + "harmonic_number = 992\n", + "frf = harmonic_number * clight / ring.circumference\n", + "rfca = at.elements.RFCavity('RF_Cavity', 0, 5e6, frf-100, harmonic_number, ring.energy, PassMethod='IdentityPass') \n", + "#From the help, we can see we need family_name, length, voltage, frequency, harmonic_number, energy\n", + "straight_section_inds = at.get_uint32_index(ring, 'BPM_SS')\n", + "ring.insert(straight_section_inds[2], rfca)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 29, 60, 91, 122, 153, 184, 215, 246, 277, 308, 339, 370, 401,\n", + " 432, 463, 494, 525, 556, 587, 618, 649, 680, 711, 742, 773],\n", + " dtype=uint32)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "straight_section_inds" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([91], dtype=uint32)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "at.get_uint32_index(ring, 'RF*')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications. These will be covered in detail in the next notebook.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have a pretty realistic looking lattice. But at the moment the radiation is off and longitudinal motion is disabled. Lets first enable the 6D tracking and finish setting up the cavity.\n", + "There are two functions for this:\n", + "\n", + "> ring.enable_6d\n", + "\n", + "> ring.disable_6d\n", + "\n", + "When we ask to switch on 6D, the function goes through every single pass method in the lattice, and if an equivalent pass method exists that contains the ending '*RadPass' instead of '*Pass' then it updates the pass method. It also switches all RFCavity elements to have CavityPass. The information in the help of the function allows the user to specifically give pass methods for certain groups of elements. \n", + "\n", + "When ring.disable_6d is called, the pass methods ending in *RadPass* are switched to their *Pass* equivalents, and the RFCavity is switched to IdentityPass (i.e. nothing) if it has length 0, or DriftPass if it has a non-zero length. This effectively disables longitudinal tracking, which is necessary for the accurate computation of uncoupled linear optics.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['BndMPoleSymplectic4RadPass' 'CorrectorPass' 'DriftPass' 'IdentityPass'\n", + " 'RFCavityPass' 'StrMPoleSymplectic4Pass' 'StrMPoleSymplectic4RadPass']\n", + "['BndMPoleSymplectic4Pass' 'CorrectorPass' 'DriftPass' 'IdentityPass'\n", + " 'StrMPoleSymplectic4Pass']\n" + ] + } + ], + "source": [ + "ring.enable_6d()\n", + "print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod')))\n", + "ring.disable_6d()\n", + "print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod')))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# cavity on, radiation on\n", + "ring.enable_6d()\n", + "\n", + "#cavity on, radiation off\n", + "ring.disable_6d(cavity_pass='RFCavityPass')\n", + "\n", + "#cavity off, radiation on\n", + "ring.enable_6d(cavity_pass='IdentityPass')\n", + "\n", + "#cavity off, radiation off\n", + "ring.disable_6d()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can switch on 6D tracking and use some in built lattice functions to set the RF frequency and the cavity phase." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-100.0" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring.enable_6d()\n", + "freq_old = ring.get_rf_frequency()\n", + "ring.set_rf_frequency()\n", + "freq_new = ring.get_rf_frequency()\n", + "freq_old - freq_new" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "503.5243331614815 MHz\n", + "503.5244331614815 MHz\n", + "992 503.5244331614815\n" + ] + } + ], + "source": [ + "print(freq_old/1e6, 'MHz')\n", + "print(freq_new/1e6, 'MHz')\n", + "print(ring.harmonic_number, ring.revolution_frequency*ring.harmonic_number/1e6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see. our initial guess of 352 MHz was not good for the specified harmonic number. In this simple case set_rf_frequency has applied the RF frequency from harmonic_number*f0.\n", + "\n", + "We can also set the timelag of the cavity. If the TimeLag of the cavity is 0, the there is no phase shift on the RF wave, and the beam will settle itself at a synchronous position where it recovers the energy loss per turn. We can use the function 'set_cavity_phase' to numerically compute the value needed to ensure the beam oscillation point is at ct=0." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.0056910420684217885\n" + ] + } + ], + "source": [ + "print(ring.get_rf_timelag())\n", + "ring.set_cavity_phase()\n", + "print(ring.get_rf_timelag())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have a pretty functional lattice. We can now use the function 'envelope_parameters' to numerically compute some interesting and important parameters (emittances, synchrotron frequency, damping numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Frac. tunes (6D motion): [0.44976772 0.82375107 0.01324872]\n", + " Energy: 3.000000e+09 eV\n", + " Energy loss / turn: 3.001470e+05 eV\n", + " Mode emittances: [7.43505870e-09 6.21205223e-38 1.30912010e-06]\n", + "Damping partition numbers: [0.99736993 0.99999969 2.00263038]\n", + " Damping times: [0.03948775 0.0393839 0.01966608] s\n", + " Energy spread: 0.000525758\n", + " Bunch length: 0.00249121 m\n", + " Cavities voltage: 5000000.0 V\n", + " Synchrotron phase: 3.08153 rd\n", + " Synchrotron frequency: 6724.85 Hz\n" + ] + } + ], + "source": [ + "envelope = at.envelope_parameters(ring)\n", + "print(envelope)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We may also use the class radiation_parameters, but there is one key difference when compared with envelope_parameters. Radiation_parameters uses the analytical formula rather than numerically solving. So the results may differ in some cases as not all pass methods are included." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Drift('DR_01', 2.25), Quadrupole('QF1', 0.75, 0.38041), Drift('DR_02', 0.75), Quadrupole('QD2', 0.75, -0.2708), Drift('DR_03', 0.75), Dipole('Bend', 3.0, 0.12566370614359174, 0.0), Drift('DR_04', 0.1875), Quadrupole('QD3', 0.75, -0.33319), Drift('DR_05', 0.1875), Sextupole('SD', 0.1875, -0.1), Drift('DR_06', 0.5625), Quadrupole('QF4', 0.75, 0.4588), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 0.1), Monitor('BPM_CellCenter'), Sextupole('SF', 0.75, 0.1), Drift('DR_07', 0.1875), Quadrupole('QF4', 0.75, 0.4588), Drift('DR_06', 0.5625), Sextupole('SD', 0.1875, -0.1), Drift('DR_05', 0.1875), Quadrupole('QD3', 0.75, -0.33319), Drift('DR_04', 0.1875), Dipole('Bend', 3.0, 0.12566370614359174, 0.0), Drift('DR_03', 0.75), Quadrupole('QD2', 0.75, -0.2708), Drift('DR_02', 0.75), Quadrupole('QF1', 0.75, 0.38041), Drift('DR_01', 2.25)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=25, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One last thing on this lattice. Let's check and set the tunes and chromaticities using the in built functions" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4497677209814676 0.8237510706933476 0.013248720495888577\n" + ] + }, + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_tune\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLattice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnewval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtol\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mniter\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mregex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Fits the tunes using 2 families\n", + "\n", + "Args:\n", + " ring: Lattice description\n", + " refpts1: Selection of the 1st family\n", + " refpts2: Selection of the 2nd family\n", + " newval: New tunes, in case an non-zero integer part\n", + " is provided, fit_integer is set to True\n", + "\n", + "Keyword arguments:\n", + " tol: Tolerance for the matching; Default: 1.0e-12\n", + " dp: Momentum deviation. Default: 0\n", + " niter: Maximum number of iterations. Default 3\n", + " fit_integer: bool (default=False), use integer tune\n", + " regex: Using regular expressions for refpt string matching;\n", + " Default: False\n", + "\n", + "Typical usage:\n", + "at.fit_tune(ring, refpts1, refpts2, [0.1,0.25])\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/matching/globalfit.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qx, qy, qs = at.get_tune(ring)\n", + "print(qx,qy,qs)\n", + "at.fit_tune?\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Fitting Tune...\n", + "Initial value [0.45 0.85]\n", + "iter# 0 Res. 7.088607489670002e-25\n", + "Final value [0.45 0.85] \n", + "\n", + "[0.45 0.85 0.01324438]\n" + ] + } + ], + "source": [ + "a = at.fit_tune(ring, 'QF*', 'QD*', [0.45,0.85], copy=True)\n", + "print(ring.get_tune())" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-26.155162008704483 -26.080688870333223 0.18192596033633204\n" + ] + } + ], + "source": [ + "Qpx, Qpy, Qpz = at.get_chrom(ring)\n", + "print(Qpx, Qpy, Qpz)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Fitting Chromaticity...\n", + "Initial value [-26.15516201 -26.08068887]\n", + "iter# 0 Res. 0.00021621790326182433\n", + "iter# 1 Res. 1.96355512309201e-11\n", + "iter# 2 Res. 3.387860729741137e-14\n", + "Final value [-1.84059097e-07 9.25292061e-10] \n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "array([-1.84059097e-07, 9.25292061e-10, -1.70282238e-03])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "at.fit_chrom(ring, at.get_uint32_index(ring, 'SF*'), at.get_uint32_index(ring,'SD*'), [0,0])\n", + "ring.get_chrom()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "ring.save('./dba.mat', mat_key='RING')\n", + "arc.save('./arc.mat', mat_key='ARC')" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring.plot_beta()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.py b/esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.py new file mode 100644 index 0000000..1fe93b7 --- /dev/null +++ b/esrfworkshop/.ipynb_checkpoints/1_Introduction-checkpoint.py @@ -0,0 +1,385 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Introduction + +# Welcome to the PyAT tutorial. +# Here we will go through some of the basic syntax of PyAT. Slowly evolving into more complex examples. +# The outline of the tutorial is as follows: +# > 1. Defining some simple elements and creating a lattice object +# > 2. Simple tracking, orbit correction, radiation flags +# > 3. Accessing and modifying ring elements +# > 4. Matching +# +# + +# First we can import PyAT (and other useful packages) and see all accessible functions using dir + +# In[1]: + + +import numpy as np +import copy +import matplotlib.pyplot as plt +import at +#dir(at) + + +# Many functions! But we cannot do anything because we do not have a lattice. Let's define some key parameters for a DBA lattice. Here I am simply taking the values from the at/machine_data/dba.m file + +# I want to define a drift. But how do I know what to provide to the function? We can use 'help' or ? to tell us. + +# All elements are found in the file: +# > at/pyat/at/lattice/elements.py +# +# This can also be accessed by: + +# In[2]: + + +dir(at.elements) + + +# In[3]: + + +#help(at.elements.Drift) +get_ipython().run_line_magic('pinfo', 'at.elements.Drift') + + +# We can see that we need to provide first a 'family_name' as a string, and a 'length' as a float. We can also use the dir function to see all available attributes that can be accessed from the drift. + +# In[4]: + + +DR_24 = at.Drift('DR_24', 2.4) + +# To see all of the available attributes +dir(DR_24) +# i.e. Length can be re-set by DR_24.Length = New_Length + + +# ## A note on pointers + +# Python uses pointers. When creating a lattice, this can cause some headaches. Observe the following simple examples: + +# In[5]: + + +a = np.arange(10) #the array is assigned some memory +b = a #b is now a pointer to the location of the memory for a +b[5] = 100 #we modify b[5], but it also modifies a due to pointers +print(a) + + +# In[6]: + + +drift = at.Drift('Test',5) # Drift of length 5m +pointer_test = [drift, drift] # Here we make a list of 2 drifts of 5m each + +# Now we can reduce the length of the first drift +pointer_test[0].Length = 2 +print(pointer_test[0].Length, pointer_test[1].Length) + + +# +# +# As you can see, the drift variable was placed twice in the list. When you modify the length of one, you are in fact modifying all. This can cause issues if you predefine elements (drifts, quads, sexts) and then place them in multiple places in the lattice. One must be careful! + +# We can perform similar actions to define the needed dipoles, quadrupoles, sextupoles and markers + +# In[7]: + + +Nhalfcells = 25 #actually it is 50 half cells +K_QF1 = 0.38041 #Strength of the quadrupoles +K_QD2 = -0.2708 +K_QD3 = -0.33319 +K_QF4 = 0.4588 + +Ks = 0.1 # Strength of the sextupoles +L1 = 3 + +# get arc lattice structure +arc_half=[at.Drift('DR_01', L1*6/8), + at.Quadrupole('QF1', L1/4, K_QF1), + at.Drift('DR_02', L1*2/8), + at.Quadrupole('QD2', L1/4, K_QD2), + at.Drift('DR_03', L1*2/8), + at.Bend('Bend', L1, 2*np.pi/(2*Nhalfcells)), + at.Drift('DR_04', L1/16), + at.Quadrupole('QD3', L1/4, K_QD3), + at.Drift('DR_05', L1/16), + at.Sextupole('SD', L1/16, -Ks), + at.Drift('DR_06', L1*3/16), + at.Quadrupole('QF4', L1/4, K_QF4), + at.Drift('DR_07', L1/16), + at.Sextupole('SF', L1/4, Ks) + ] + + +# We have made a list of elements that represent a half cell consisting of drifts, dipoles, quadrupoles and sextupoles. This is just a python list. We will now use this half, make a full cell (first half + reverse of the first half) and convert it into a lattice object and start to benefit greatly from what PyAT has to offer. + +# In[8]: + + +arc_half_copy = copy.deepcopy(arc_half) #This is to avoid problems with pointers when copying the half arc +arc = arc_half + [at.Monitor('BPM_CellCenter')] + arc_half_copy[::-1] #We also add a monitor in the center for later on +arc = at.Lattice(arc, energy=3e9) +print('Periodicity:', arc.periodicity) + + +# As can be seen. We had to define the energy of the ring. The periodicity of the ring has been automatically set based on the total bending angle of the cell. We can do a quick check of the linear optics using the plot_beta function. + +# In[9]: + + +import at.plot +arc.plot_beta() + + +# Lets now make a full ring of 25 cells. + +# In[10]: + + +ring = [] +for i in np.arange(int(Nhalfcells)): + ring += copy.deepcopy(arc) + ring += [at.Monitor('BPM_SS')] + ring += [at.Corrector('Corrector', 0, [0, 0])] + + +# In[11]: + + +ring = at.Lattice(ring, energy=3e9) +ring.plot_beta() +geom,radius,ax = ring.plot_geometry(centered=True) +get_ipython().run_line_magic('pinfo', 'ring.plot_geometry') + + +# Lets check to see if our ring has the correct total bending angle. For this we need to use some functions to access certain lattice elements. +# +# Here we will use 'get_uint32_index'. For all of these kinds of functions, you can specify either a string 'BPM' or a string with a wildcard 'BPM*' or an element in order to select the correct indices. More detail will be provded later on how to access and modify lattice elements. But for now we can see: + +# In[12]: + + +bpm_inds = at.get_uint32_index(ring,'BPM*') + +bpm_inds = at.get_uint32_index(ring, at.Monitor) +print(len(bpm_inds)) + + + +# So what do we want to do? We want to look at every Bend element, and look at its 'BendingAngle' attribute, then sum them all. To achieve this, we can use 'get_value_refpts. This uses 'get_uint32_index' to get the appropriate indexes for the elements, then extracts the given Attribute Name. + +# In[13]: + + +dipole_bending_angles = at.get_value_refpts(ring, at.elements.Bend, 'BendingAngle') +np.sum(dipole_bending_angles) - 2 * np.pi + + +# In[14]: + + +quad_strengths = at.get_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', 1) +#This searches in ring, for all elements that match a quadrupole, then finds +#the PolynomB attribute, and takes the second index (python indexes start at 0) + +quad_strengths + + +# Similarly, parameters can be set using 'set_value_refpts'. For example, lets increase all quadrupole strengths by 1% + +# For the final part of this lattice building section. We must discuss something very important. +# +# If you call 'set_value_refpts' with copy=False (default behaviour), the values that you set will be modified for the ring lattice. +# If you call it with copy=True, you function will return a copy of the original lattice with the modifications made, so the correct usage is + +# In[15]: + + +new_ring = at.set_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', quad_strengths*5, 1, copy=True) +print(np.sum(at.get_value_refpts(ring, at.Quadrupole, 'PolynomB', 1))) +print(np.sum(at.get_value_refpts(new_ring, at.Quadrupole, 'PolynomB', 1))) + + +# This question of in-place modification will show up in many different locations (tracking, radiation flags). + +# We have one thing missing! An RF Cavity! Let's generate it and then place it in the straight section of the 4th cell. We can use the BPM in the center of the straight section to find the right index + +# In[16]: + + +from at.constants import clight +dir(at.constants) + + +# In[17]: + + +#at.elements.RFCavity? +harmonic_number = 992 +frf = harmonic_number * clight / ring.circumference +rfca = at.elements.RFCavity('RF_Cavity', 0, 5e6, frf-100, harmonic_number, ring.energy, PassMethod='IdentityPass') +#From the help, we can see we need family_name, length, voltage, frequency, harmonic_number, energy +straight_section_inds = at.get_uint32_index(ring, 'BPM_SS') +ring.insert(straight_section_inds[2], rfca) + + +# In[18]: + + +straight_section_inds + + +# In[19]: + + +at.get_uint32_index(ring, 'RF*') + + +# There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications. These will be covered in detail in the next notebook. +# +# + +# Now we have a pretty realistic looking lattice. But at the moment the radiation is off and longitudinal motion is disabled. Lets first enable the 6D tracking and finish setting up the cavity. +# There are two functions for this: +# +# > ring.enable_6d +# +# > ring.disable_6d +# +# When we ask to switch on 6D, the function goes through every single pass method in the lattice, and if an equivalent pass method exists that contains the ending '*RadPass' instead of '*Pass' then it updates the pass method. It also switches all RFCavity elements to have CavityPass. The information in the help of the function allows the user to specifically give pass methods for certain groups of elements. +# +# When ring.disable_6d is called, the pass methods ending in *RadPass* are switched to their *Pass* equivalents, and the RFCavity is switched to IdentityPass (i.e. nothing) if it has length 0, or DriftPass if it has a non-zero length. This effectively disables longitudinal tracking, which is necessary for the accurate computation of uncoupled linear optics. +# + +# In[20]: + + +ring.enable_6d() +print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod'))) +ring.disable_6d() +print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod'))) + + +# In[21]: + + +# cavity on, radiation on +ring.enable_6d() + +#cavity on, radiation off +ring.disable_6d(cavity_pass='RFCavityPass') + +#cavity off, radiation on +ring.enable_6d(cavity_pass='IdentityPass') + +#cavity off, radiation off +ring.disable_6d() + + +# Now we can switch on 6D tracking and use some in built lattice functions to set the RF frequency and the cavity phase. + +# In[22]: + + +ring.enable_6d() +freq_old = ring.get_rf_frequency() +ring.set_rf_frequency() +freq_new = ring.get_rf_frequency() +freq_old - freq_new + + +# In[23]: + + +print(freq_old/1e6, 'MHz') +print(freq_new/1e6, 'MHz') +print(ring.harmonic_number, ring.revolution_frequency*ring.harmonic_number/1e6) + + +# As you can see. our initial guess of 352 MHz was not good for the specified harmonic number. In this simple case set_rf_frequency has applied the RF frequency from harmonic_number*f0. +# +# We can also set the timelag of the cavity. If the TimeLag of the cavity is 0, the there is no phase shift on the RF wave, and the beam will settle itself at a synchronous position where it recovers the energy loss per turn. We can use the function 'set_cavity_phase' to numerically compute the value needed to ensure the beam oscillation point is at ct=0. + +# In[24]: + + +print(ring.get_rf_timelag()) +ring.set_cavity_phase() +print(ring.get_rf_timelag()) + + +# We now have a pretty functional lattice. We can now use the function 'envelope_parameters' to numerically compute some interesting and important parameters (emittances, synchrotron frequency, damping numbers) + +# In[25]: + + +envelope = at.envelope_parameters(ring) +print(envelope) + + +# We may also use the class radiation_parameters, but there is one key difference when compared with envelope_parameters. Radiation_parameters uses the analytical formula rather than numerically solving. So the results may differ in some cases as not all pass methods are included. + +# In[26]: + + +arc + + +# One last thing on this lattice. Let's check and set the tunes and chromaticities using the in built functions + +# In[27]: + + +qx, qy, qs = at.get_tune(ring) +print(qx,qy,qs) +get_ipython().run_line_magic('pinfo', 'at.fit_tune') + + + +# In[28]: + + +a = at.fit_tune(ring, 'QF*', 'QD*', [0.45,0.85], copy=True) +print(ring.get_tune()) + + +# In[29]: + + +Qpx, Qpy, Qpz = at.get_chrom(ring) +print(Qpx, Qpy, Qpz) + + +# In[30]: + + +at.fit_chrom(ring, at.get_uint32_index(ring, 'SF*'), at.get_uint32_index(ring,'SD*'), [0,0]) +ring.get_chrom() + + +# In[31]: + + +ring.save('./dba.mat', mat_key='RING') +arc.save('./arc.mat', mat_key='ARC') + + +# In[32]: + + +ring.plot_beta() + + +# In[ ]: + + + + diff --git a/esrfworkshop/.ipynb_checkpoints/2_LatticeManipulations-checkpoint.ipynb b/esrfworkshop/.ipynb_checkpoints/2_LatticeManipulations-checkpoint.ipynb new file mode 100644 index 0000000..1073073 --- /dev/null +++ b/esrfworkshop/.ipynb_checkpoints/2_LatticeManipulations-checkpoint.ipynb @@ -0,0 +1,991 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import at\n", + "import at.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as aplt\n", + "\n", + "ring = at.load_mat('./dba.mat', mat_key='RING')\n", + "arc = at.load_mat('./arc.mat', mat_key='ARC')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAHHCAYAAAAPuHTSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADG9UlEQVR4nOzdd3hUZfbA8e+09N5DKIEACTV0BARUUBQFC5ZVVyyoPxVs7LrKujZ2FSuwuqi7NnRdy1qwrAoKUqTX0Ak1hJbeezJzf3/czCQhCaTMzJ3MnM/zzDOTmTv3npkkM+e+5bw6RVEUhBBCCCGEy9FrHYAQQgghhGiaJGpCCCGEEC5KEjUhhBBCCBcliZoQQgghhIuSRE0IIYQQwkVJoiaEEEII4aIkURNCCCGEcFGSqAkhhBBCuChJ1IQQQgghXJQkakKIVlu8eDE6nY60tDSH7P/ZZ59Fp9O1aNt///vfJCUlYTKZCAkJcUg87ZWWloZOp2Px4sVahyKE6GAkURPCDezdu5ff//73xMXF4e3tTadOnbj11lvZu3dvu/b7wgsv8M0339gnSAc4cOAAd9xxBwkJCbzzzjv861//0jSeTz75hIULF2oagxDCvehkrU8hOravv/6am2++mbCwMGbMmEH37t1JS0vjvffeIzc3l88++4xrr722TfsOCAjg+uuvb9QSZDabqa6uxtvbu8UtX63x7LPP8txzz3G+j6e3336b+++/n0OHDtGzZ0+7x9FaV111FXv27GnU0qgoCpWVlZhMJgwGgzbBCSE6JKPWAQgh2u7IkSPcdttt9OjRgzVr1hAZGWl77OGHH2bs2LHcdttt7Nq1ix49etjtuAaDwSUSjqysLACX7fK00ul0+Pj4aB2GEKIDkq5PITqwV155hbKyMv71r381SNIAIiIi+Oc//0lpaSkvv/yy7X7r+K8DBw5w4403EhQURHh4OA8//DAVFRW27XQ6HaWlpXz44YfodDp0Oh133HEH0PwYtZ9++onx48cTGBhIUFAQw4cP55NPPrE9/ttvv3HDDTfQtWtXvL296dKlC48++ijl5eWtfu3x8fE888wzAERGRqLT6Xj22WdtsVtvn/0c62uo/zrWrVvH7NmziYyMxN/fn2uvvZbs7OxGzz/X67vooov44YcfOH78uO39io+PB5ofo/brr78yduxY/P39CQkJ4eqrr2b//v0NtrH+vg4fPswdd9xBSEgIwcHB3HnnnZSVlTXY9pdffuHCCy8kJCSEgIAAEhMT+fOf/9yKd1UI4WqkRU2IDuz7778nPj6esWPHNvn4uHHjiI+P54cffmj02I033kh8fDzz5s1j48aNvP766+Tn5/PRRx8B6iD9u+++mxEjRnDvvfcCkJCQ0Gwsixcv5q677qJfv37MmTOHkJAQduzYwdKlS7nlllsA+OKLLygrK+P+++8nPDyczZs388Ybb3Dy5Em++OKLVr32hQsX8tFHH7FkyRLeeustAgICGDhwYKv2YfXggw8SGhrKM888Q1paGgsXLmTWrFl8/vnnLX59Tz75JIWFhZw8eZIFCxYAatdxc5YvX84VV1xBjx49ePbZZykvL+eNN95gzJgxbN++3ZbkWd144410796defPmsX37dt59912ioqJ46aWXAHWc4lVXXcXAgQOZO3cu3t7eHD58mHXr1rXpPRFCuAhFCNEhFRQUKIBy9dVXn3O7qVOnKoBSVFSkKIqiPPPMMwqgTJ06tcF2DzzwgAIoO3futN3n7++v3H777Y32+cEHHyiAcuzYMVssgYGBysiRI5Xy8vIG21osFtvtsrKyRvuaN2+eotPplOPHj9vus8Z4PtbtsrOzG9wPKM8880yj7bt169bg9Vhfx8SJExvE+eijjyoGg0EpKCho1eu78sorlW7dujU67rFjxxRA+eCDD2z3DRo0SImKilJyc3Nt9+3cuVPR6/XK9OnTG73Gu+66q8E+r732WiU8PNz284IFC5p8L4QQHZt0fQrRQRUXFwMQGBh4zu2sjxcVFTW4f+bMmQ1+fvDBBwH48ccfWx3LL7/8QnFxMU888USjsVj1Jxv4+vrabpeWlpKTk8Po0aNRFIUdO3a0+rj2cu+99zaIc+zYsZjNZo4fPw60/PW11JkzZ0hJSeGOO+4gLCzMdv/AgQO59NJLm/wd3HfffQ1+Hjt2LLm5ubbfq3Wc3rfffovFYml1TEII1ySJmhAdlDUBsyZszWkuoevVq1eDnxMSEtDr9W2qjXbkyBEA+vfvf87t0tPTbclJQEAAkZGRjB8/HoDCwsJWH9deunbt2uDn0NBQAPLz84GWv76WsiaAiYmJjR7r06cPOTk5lJaWtirGm266iTFjxnD33XcTHR3N7373O/773/9K0iZEBydj1ITooIKDg4mNjWXXrl3n3G7Xrl3ExcURFBR0zu0cUWajPrPZzKWXXkpeXh6PP/44SUlJ+Pv7c+rUKe644w6nJBRms7nJ+5ubwaq4UPWi88Xo6+vLmjVrWLlyJT/88ANLly7l888/55JLLuHnn392iVm6QojWkxY1ITqwq666imPHjrF27domH//tt99IS0vjqquuavTYoUOHGvx8+PBhLBZLg0HsLU3erJMM9uzZ0+w2u3fv5uDBg7z22ms8/vjjXH311UycOJFOnTq16BitERoaSkFBQYP7qqqqOHPmTJv215LXBy1/v7p16wZAampqo8cOHDhAREQE/v7+rYwS9Ho9EyZMYP78+ezbt4/nn3+eX3/9lZUrV7Z6X0II1yCJmhAd2GOPPYavry//93//R25uboPH8vLyuO+++/Dz8+Oxxx5r9NxFixY1+PmNN94A4IorrrDd5+/v3yjhacpll11GYGAg8+bNa1DiA+pafKwtOvVbqRRF4e9///t5999aCQkJrFmzpsF9//rXv5ptUTuflrw+UN+vlnThxsbGMmjQID788MMG7++ePXv4+eefmTx5cqtjzMvLa3TfoEGDAKisrGz1/oQQrkG6PoXowHr16sWHH37IrbfeyoABAxqtTJCTk8Onn37aZFmNY8eOMXXqVC6//HI2bNjAxx9/zC233EJycrJtm6FDh7J8+XLmz59Pp06d6N69OyNHjmy0r6CgIBYsWMDdd9/N8OHDueWWWwgNDWXnzp2UlZXx4YcfkpSUREJCAn/84x85deoUQUFBfPXVV7YxVvZ09913c9999zFt2jQuvfRSdu7cybJly4iIiGjT/lry+kB9vz7//HNmz57N8OHDCQgIYMqUKU3u85VXXuGKK65g1KhRzJgxw1aeIzg4uMkacOczd+5c1qxZw5VXXkm3bt3IysrizTffpHPnzlx44YVtet1CCBeg4YxTIYSd7Nq1S7n55puV2NhYxWQyKTExMcrNN9+s7N69u9G21nIP+/btU66//nolMDBQCQ0NVWbNmtWo9MSBAweUcePGKb6+vgpgK21xdnkOq++++04ZPXq04uvrqwQFBSkjRoxQPv30U9vj+/btUyZOnKgEBAQoERERyj333KPs3LmzUemK9pbnMJvNyuOPP65EREQofn5+yqRJk5TDhw83W55jy5YtDZ6/cuVKBVBWrlzZqtdXUlKi3HLLLUpISIgC2Ep1NFWeQ1EUZfny5cqYMWNs+5syZYqyb9++Fr3Gs38HK1asUK6++mqlU6dOipeXl9KpUyfl5ptvVg4ePHje91EI4bpkrU8hPIx1Hc3s7Ow2tzAJIYRwDhmjJoQQQgjhoiRRE0IIIYRwUZKoCSGEEEK4KBmjJoQQQgjhoqRFTQghhBDCRUmiJoQQQgjhojyu4G1NTQ07duwgOjoavV7yVCGEEKIjsFgsZGZmMnjwYIxGz0lfPOeV1tqxYwcjRozQOgwhhBBCtMHmzZsZPny41mE4jcclatHR0YD6i46NjdU4GiGEEEK0xJkzZxgxYoTte9xTeFyiZu3ujI2NpXPnzhpHI4QQQojWaO2wpUWLFvHKK6+QkZFBcnIyb7zxxjl71goKCnjyySf5+uuvycvLo1u3bixcuJDJkye3N/Q28bhETQghhBCe4fPPP2f27Nm8/fbbjBw5koULFzJp0iRSU1OJiopqtH1VVRWXXnopUVFRfPnll8TFxXH8+HFCQkKcH3wtSdSEEEII4Zbmz5/PPffcw5133gnA22+/zQ8//MD777/PE0880Wj7999/n7y8PNavX4/JZAIgPj7emSE3ItMehRBCCOF2qqqq2LZtGxMnTrTdp9frmThxIhs2bGjyOd999x2jRo1i5syZREdH079/f1544QXMZrOzwm5EWtSE8ABms5nq6mqtwxB2ZjKZMBgMWochhFMVFxdTVFRk+9nb2xtvb+9G2+Xk5GA2mxtNPoiOjubAgQNN7vvo0aP8+uuv3Hrrrfz4448cPnyYBx54gOrqap555hn7vpAWkkRNCDemKAoZGRkUFBRoHYpwkJCQEGJiYtDpdFqHIoRT9O3bt8HPzzzzDM8++6xd9m2xWIiKiuJf//oXBoOBoUOHcurUKV555RVJ1IQQ9mdN0qKiovDz85MvczeiKAplZWVkZWUBSLkh4TH27dtHXFyc7eemWtMAIiIiMBgMZGZmNrg/MzOTmJiYJp8TGxvbqKW6T58+ZGRkUFVVhZeXlx1eQetIoiaEmzKbzbYkLTw8XOtwhAP4+voCkJWVRVRUlHSDCo8QGBhIUFDQebfz8vJi6NChrFixgmuuuQZQW8xWrFjBrFmzmnzOmDFj+OSTT7BYLLYyIAcPHiQ2NlaTJA1kMoEQbss6Js3Pz0/jSIQjWX+/MgZRiMZmz57NO++8w4cffsj+/fu5//77KS0ttc0CnT59OnPmzLFtf//995OXl8fDDz/MwYMH+eGHH3jhhReYOXOmVi9BWtSEcHfS3ene5PcrRPNuuukmsrOzefrpp8nIyGDQoEEsXbrUNsEgPT29QQHdLl26sGzZMh599FEGDhxIXFwcDz/8MI8//rhWL0ESNSGEEEK4r1mzZjXb1blq1apG940aNYqNGzc6OKqWk65PIYQQQggXJYmaEEIIIYSLkq5PITqimkowV4F3oNaRtEu1uZrs8uxzbvPll1/y9ttvc/LkSeLi4njyySe55JJLnBKfXqcnyi8Kva6Dn9OW54N3EOhlVqgQHY0kakJ0FIoCR36FtQvg+HpAgX7XwaQXIDD6vE93JSeKTvDylpdZd3od1ZbzzFbUgeF+A93oBsBL+S/x0lcvOSFKlb/Jn8ndJ/PwkIcJ9g522nHtImM3LJ0Dab+B0Rd6T4Kxf4DYgVpHJoRoIUnUhHB1Fgsc/AnWvAqntzd8bM+XkLUP7vwJfEM0Ca+1Np/ZzKxfZ1FeUw6AUW/EoGu6paeyshK9Xm9bHNlsNlNVVWWrH+ZoZouZ0upSvjj4BWtOrmHx5YvpHNjZKcdut+xU+HCK2poGUFMO+75RL70vh7F/hC7DtYxQCNECkqgJ4aosZti7BH6bD1l71fuMvjD0Dhj5f1BRAJ/8Tk3Uvrkfbv5Uy2hb5EDeAVuSNjR6KH8e+Wd6hfRqssREcXExISEhrF+/npEjRwLwxz/+kW3btrFy5UqnxFtjqWFb5jbmbphLenE6d/98N59e+SmhPqFOOX6bVVfAJzepSVrcULj+A/X2hn/Anq/g4FL10uMiGPcYdBsDUuZDCJckiZoQrsZcDbs+VxO0vCPqfV6BMOJuuGAmBETWbXvrF/DOxZD6IxxeAT0nnHPXiqJQXm12YPDN0+treGLNE5TXlDMyZiSLJi7C29D00i8AO3fuRK/Xk5ycTFlZGZ988gmvv/46S5YscVrMRr2RkbEj+eDyD7j9p9s5WXKS5zc9z6vjX3VaDG2ycRHkH4PAWLjlC/APh9BuMO1duGgOrJ0POz+Do6vUS5cL1ISt5wRJ2IRwMZKoCeEqqitgx79h3d+h8IR6n28ojLwfRt6r3j5b7EAYcS9sfBN+/gskXHLOL9ryajN9n17moBdwbg9df5gjhUcI8wnjlfGvnDNJA0hJSSEpKYlt27Zx4YUXAnDddddxxRVXOCPcBqL8onj1ole59YdbWZa2jMvjL2dit4lOj6NFyvLUJB9g4nNqklZfeAJcvQjGP67+rW3/N5zYCP+ZBrGD1IQtcTLoO/gECiHchPwnCqG1yhJY/wb8fSD8+Ec1SfOPgkvnwiO74aLHm07SrMb/SW1xy9oHR53TJdhaOmMRnxz4NwB/ueAvLeo6TElJYciQIQwYMIBNmzYxf/58li5dyty5cx0dbpP6hffjrv53AfD37X+nxlKjSRzntf1DqCqBmAEw4IbmtwvpCle+Bg/vhFGzwOQHZ1Lg81vh7TGw+0u1+10IoSlpURNCK+UFsPkdtTWsPE+9L6gzjHkYhtwGphYOmPcNhUE3w+Z/qftLaL50ha/JwL65k9ofeyu9tOV5vj5cyaDIQUzs2rKWqJSUFG677TaCgoIYMWIEI0aMIDU1lU2bNgHq4snz589n5MiRzJgxg/79+/Poo4868mUwY8AMvjz4JWlFaXx7+Fum9Z7m0OO1msUMW95Tb4+8v2WtYkGxMOl5uPBR9W9x8ztq0v/VDFj5gjpLdOCNYDA5NnYhRJMkURPC2UqyYONbsOVdqCxS7wvroX5RDvwdGL1av8/h96iJWupPUHgSgpuemajT6fDzcu6/fW55Lt8f/RaAh4Y81KK1KWtqati7dy99+vRpcP/OnTu56qqrAHjqqad48cUXGTt2LHq93uFJGqilOu4ecDevbH2FD/Z+wLW9rnWtGmuHflFbZH3DoP91rXuufwRMeBpGP1R7ArFIHSP57QNqwjZ6FgyZDl7+joldCNEkF/qEEcLN5R6B7x+BBf3VwdyVRRDZB6a9BzO3qF+CbUnSACJ7Q9fRgAL7vrVn1O32xcEvqLZU0z+8P8Oih7XoOQcOHKCiooK5c+eyY8cOUlNTeeSRR0hLS2PGjBkAXH755aSnp/PDDz/w5ptvOvIlNHB97+sJNAVyvOg4a0+tddpxW2TPV+r1wJta3iJ7Nt8QGP8YPLIHLv0rBERD0UlY+gQs6KcmbaW5dgtZCHFuLpuovfjii+h0Oh555BHbfRUVFcycOZPw8HACAgKYNm0amZmZ2gUpREucToEv7oB/DINtH4C5EuKGwU3/gfvXw4DrwWCHVi5rC8pe582KPJ9qSzX/Tf0vALf2vbVFrWmgdnvGxsbi6+vL2LFjGTduHCdOnGDlypXExMQAsGXLFvLy8ggODrbVWXMGP5Mf1/a6FoBP9n/itOOeV3WFOvsXWt+a1hTvABjzEDy8C65aqLb6lufD6pfUhO3HP0FBevuPI4Q4J5dM1LZs2cI///lPBg5sWD370Ucf5fvvv+eLL75g9erVnD59muuus8MHkhD2pihwZCV8dDX8a7yaPCkW6Hkp3PED3L0c+lxl35l1faYCOji5xWW+QNedWkd2eTZhPmFM6tbysXEpKSmMHDmSX375hZKSEjIzM/nqq69ISkoC4NSpU9x99938+uuvpKWlsWfPHke9hCb9Lul3AKw/vZ6M0gynHrtZ6RvUSQRBndUTAXsx+cCwO2HWVrhhsToztKYcNv8T/j4Ivr4XMvfa73hCiAZcLlErKSnh1ltv5Z133iE0tG5mWGFhIe+99x7z58/nkksuYejQoXzwwQesX7+ejRs3ahixEPVYzLDna/jXRfDva9QaVToDDLgR7lsHv/8S4i90TK2qwGjoNlq9feBH+++/Db478h0AV/a4ElMrBqOnpKQ0OlGzKi8v54YbbuCNN96ge/fuzJkzh7/+9a92ibelugR2YVj0MBQU/nf0f049drOOrlav+17tmNIaegP0uxbuXQXTv1WL5SpmtebfW6PhPzeqS5spiv2PLYQHc7lEbebMmVx55ZVMnNhwZti2bduorq5ucH9SUhJdu3Zlw4YNze6vsrKSoqIi26W4uNhhsQsPVl2hzrZ7Yyh8eada5sDoCyP+Dx7aAdPegZj+jo+jd22r1ZEVjj/WeRRWFrL6hJo8TE2Y2qrn7ty5s9lEzdfXl/Xr1zNu3DgAbrjhBj7//PP2BdsG1tf0/ZHvUVwhOTlRe8La28GzenU6NUmb/q2atPW9BtDBoWXwwRXw3mXqiYLF4tg4hPAQLjXr87PPPmP79u1s2bKl0WMZGRl4eXkREhLS4P7o6GgyMprvepg3bx7PPfecvUMVQlWeD1vfV2dxlmar9/mGqgnaiHsbFxt1tIQJ8MvTkLYWqiude+yz/Jr+K1WWKnqF9iIpLKlVz83OznZQVPZzabdLeX7T8xwtPEpqfmqrX6NdmaugLEethdb1Aucdt9NguPFDdaLM+tch5RM4uRk+uxkiEtWZogNuVLtPhRBt4jItaidOnODhhx/mP//5Dz4+9vunnjNnDoWFhbbLvn377LZv4cHyjqmDqef3gxVz1SQtuAtc/iI8uhcunuP8JA0guh8ExEB1mdqqp6EV6Wqr3mXdLtM0DkcJ8ApgdCe1q9n6WjVTXaFedx8HxnOv+OAQ4Qkw5e9qgeYxj4B3EOSkwncPwsL+sPplmSkqRBu5TKK2bds2srKyGDJkCEajEaPRyOrVq3n99dcxGo1ER0dTVVVFQUFBg+dlZmbaZoE1xdvbm6CgINslMDDQwa9EuLX0TfD57+GNIepg6upSiOoH1/5T7eK84H5t60zpdHXrfaZrN3aztLqU9afXA7S4wG1HZF1Gavnx5doGUlObqCWce61XhwuMgUufg0f3wGV/Uyc2lGbDyufVmaL/exRyDmsboxAdjMskahMmTGD37t2kpKTYLsOGDePWW2+13TaZTKxYUXfmmpqaSnp6OqNGjdIwcuH2zDXqrM13J8L7l8H+72tncE6E25bA/esg+XeuU7m9+3j1+vQOzUL47eRvVFuqiQ+KJyEkQbM4HG185/EYdUYOFxzmeNFxbYJQLGrJF4Ae47WJ4Ww+wTD6QXg4Ra0TaJ0puvV9tUzNpzdD2jqZeCBEC7jMGLXAwED692842Nrf35/w8HDb/TNmzGD27NmEhYURFBTEgw8+yKhRo7jgAieOyRCeo7JYXbB601t15S4MXmox0VEzIarPuZ+vlW61Jy7ZB9QvcQ2sOrkKgIu7Xtzi2mkdUbB3MENjhrLpzCZWn1jN9H7TnR9EdYWa8PiEQERv5x//XAwmtU5g/2lwfB2s/wcc/Emt95b6ozrGbdQsdUKCPWoJCuGGOtR/xoIFC9Dr9UybNo3KykomTZrk1IrkwkMUnoRNb8O2D+uWePINg+F3w4h7ICBK2/jOJ6SrOl7OXAM1VU4/vEWxsP6U2u05Nm6s04/vbGPjxrLpzCbWnV6nUaJWpl7HDnJM2Rd70OnUsjTxF0LOIdiwCHZ+qrb6fjUDlj8LI+9TV+fwCdI6WiFciksnaqtWrWrws4+PD4sWLWLRokXaBCTc2+kd6hfI3iVgqVHvC++ptp4l39z2JXm00HUUHNtQ1yXmRPtz95NfmY+/yZ9BUYOcfnxnGxs3lle3vsrWjK2U15Tja3Ty30lVbaLWabBzj9tWEb1gykK45C9qSZvN/1LXJ/35SXXVg8G3qSdEYd21jlQIl+AyY9SE0IS5Wi1Q+94ktUjt7i/UJC1+LNz8uboG57C7OlaSBnWFb2ucn6j9duo3AC6IvQCT3kXG7TlQ9+DuxPrHUmWpYktG49JCDqUoUF2u3u40yLnHbi//CLjocXWW9JTX1XIelUXqYvCvD4ZPb1GL+Mo4NuHhXLpFTQiHKc2F7YvVM/qiU+p9eqNaeX3UrI73pXe2LiPVa3OV07/oNpxWC1CPiRvj1ONqRafTMSZuDF8e/JINpzcwrvM45x28phIwq12LEYnOO649mXxg6O1qS9qRFWpNwiMrIPUH9RLVD0b+Hwy4Abz8tI5WCKeTRE14ljO71LIau76o6xb0j1RbzYbeCUGx2sZnL5GJYPRTJxPUVALOaREsrylnV84uAC6I8ZxJPiNjR/LlwS/ZnLHZuQeuLlWvDV4dfzC+Xg+9LlUv2alql2jKp5C1F75/CJY/A0PvUMeKBnfWOlohnKaD/2cL0QLmGvXMfNM/1ZlnVrHJMPJ+6H+dNkVCHUlvqJuVWl0OhDjlsDuydlBjqSHGP4bOgZ7zZTo8ejgAB/MPkl+RT6hP6HmeYSfW8WkGN/v7jUyEK1+DS56CHR+rJ1cF6bB2Aax7HfpMUScfdL3AdSdQCGEnMkZNuK+yPFi7EF4fBP+driZpOgP0uw7u+hnuXQ2Dbna/JM0qqq96XVPutENuPqO2KI2IGWG3shyLFy+mb9+++Pn50adPH3744Qe77Neewn3D6RnSE8C549SsMz4NXs47pjP5hqjLUD2UAr/7RB07qphh3zfwweXwr/Fqq5sGYzGFcBZJ1IT7ydwL3z0E8/uq3SWFJ9TyGmP/oC5xc8MH0HWk+5+JWxeBty4v5ATWJGV4zHC77O+rr75i1qxZPPXUU+zZs4dJkyZx33332WXf9mZ9zU7r/rRY6iYSGN00UbPSGyDpSrjjf3DfOrWMh9EHzuyEb+5TVz1YMRcKTmgdqRB2J4macA81lbD7S3j/cnhrNGz/UG1Jih4AVy+C2ftgwtMQHKd1pM5jbVEzV6hf6g5WXlPOvlx1LV17JWrz58/nD3/4AzfffDM9evTgyiuvpLi42C77tjfra96etd05B6wpBxTAoE6E8RQx/WHqG/DoPpjwDATFqctU/fYa/H2gOlv08Aqn/M0L4Qwe9N8t3FJBOmz9ALZ/BGU56n16o3r2PfI+tZ6Yu7ecNScwBnRH1Ns15Q5fg3Rf7j5qlBoifSPp5N+p3fsrLi5m48aNzJ8/33bfsmXLGDzYNeuFDYocBMDh/MOUVpfib3Lwmq/W1jSTD+CBSYl/OIydrS5VlfojbHkXjq2pmy0a1gOGzYBBt4BfmNbRCtFmkqiJjsdiUafvb3kPDi5FbVUAAmPVmZtDprvP7M320Onq1h+trk3UFKVuXJOd7Tyjdnsmh/dD19QxTH6tSpp37tyJXq8nOTmZsrIyPvnkE15//XWWLFlir5DtKtJPTVBPl55md85uLoh18KxX60LsRh/AMb/TDsFggr5Xq5fsVHU90ZRPIO+oWkT317+qy1gNv7vjFAUWoh5J1ETHUZoLKR+rH8T5aXX3dx+vfggnXuE6C6O7Cusgc2vrS3UZvND+1q6m7IyKAH8/kncugd8+arzBn0+3qlUvJSWFpKQktm3bxoUXXgjAddddxxVXXGGvkO0uOTKZ06Wn2Zm10/GJWoPxaR6cqNUXmQhXvKTOFt39hdrKlrlHnTm642OIG6p+VvS7tuMVsRYeS8aoCdemKHBiCyy5D+b3gV+eVpM072C44AGYtRVu/w76TpUkrSn1W9QcSAF2eauzZwdW2md90ZSUFIYMGcKAAQPYtGkT8+fPZ+nSpcydO9cu+3eE5KhkAFstOYepvyKBwcexx+qIvANg2J1w31p1hveAG9WTllPb4Jv71c+Sn/+itroJ4eKkRU24pooi9Yx422LIqPelF5sMw++B/tOkSnlLGLyAGnWMmqKo3Y9/Pm33w5wuOU3O99dh1Bno+/D+2u64s5ha9/tKSUnhtttuIygoiBEjRjBixAhSU1PZtGkTAOPHj6ewsBCA3bt3s2nTJoYNG9bu19IeAyMGArArexeKotitREkj5mq1TAWAyU3Ly9iDTqfO8O46Eia9ADv+rY5pLUyH9W+ol+7j1UK6SVe5/+xZ0SFJoiZch6KoZ7zbPlDX36yuV8yz/zS1yyJuiOdODmgLvRGw1K1QYPJxyKSCnQWHAEgMS8LHL7zd+6upqWHv3r306dOn4XF27uSqq64CYPXq1QA888wzjB8/XvMkDSApLAlvgzcFlQUcLzpOfHC8Yw5krY1n9AGddIy0SECkOvlgzMNw6Ge1W/TwCji2Wr34Rah1FYfcARE9tY5WCBtJ1IT2yvNh139h24fqcjFWEYnqGoDJN8usrbbS6WoL+laog89Njukms3b1JUcm22V/Bw4coKKigrlz5xIZGYmfnx9vvfUWaWlpzJgxw7bdwoULSUtLY/HixXY5bnuZDCb6hvdlR9YOduXsclyiZpvxKeOsWk1vUMezJl4B+cdrx6/9G4rP1LWyxY9VW9n6THHfgtiiw5BETWhDUSB9g5qc7fum4Qy2ftfCkNtleRh7MXiptdRqHFf4dmfWTsB+iVpKSgqxsbH4+voyduxY/P39ufDCC1m5ciUxMTGAumLBmjVr+OKLLxzXxdgGAyMGsiNrBzuzdjI1YapjDmItYmyURK1dQrvBJU/C+MfVVrZti+HwL5D2m3rxDVPLewy5HSJ7ax2t8FCSqAnnKs2FnZ+qBWlzDtbdH91f/TAceAP4OmmdRE9h9AYzDluhoKKmggN5BwAYGDnQLvtMSUlh5MiRzZbiWLJkCZ999hnffvstBoPBLse0l+SoZNgHO7N3Ou4gNdKiZlcGIyRNVi8FJ+pa2YpOwYZ/qJeuo9VWtr5T5X0XTiWJmnCOjD2wdj7s/x7MtbMCTf7qguhD75SxZ45k9IZKHNaitj9vPzVKDeE+4cQF2Gflh5SUFMaMGdPs43fddReRkZGMHDkSgL/97W+2sWtas7YqHio45JjCtxZL3e/S5APVHljs1pFCusDFc2D8n+DwcrWV7eBSSF+vXn76Ewy8CS58VOo1CqeQRE04lqLAmldh1by6WWqxg9SxZ/2vB58gTcPzCIbaMTY1Fervw84J8Z6cPQAMiBxgty7InTt3cv/99zf7eH5+vl2O4whRflHE+MeQUZrBgbwDDI0eat8DWJM0nQH0JtQsXNid3gC9J6mXwlOQ8h91BZTCE7D5n2rPwNQ3oN81Wkcq3JwkasKx1i2ElX9Tb/eZqi6M3mmQlhF5HoMJtWRivZmfdmTt9uwb1tdu+8zOzrbbvrSQFJZERmkG+3P3OyBRq9ftKa3QzhEcp7awjf0DHF0JK19QZ6h/NUMtO9P7Mq0jFG5M5nULx0lbC8ufVW9f+le46d+SpGlBp6urteWA7k9ropYYlmj3fXdUfcLUsiL78/bbf+cy41M7egP0nAgzflGL6Fpq1GStyP61CYWwkkRNOEZ1OXz3oHp78G0w5iFt4/F01tmBdk7UqsxVHC1Qq7tbkxOhtqhBXRJrVzW1XZ1NFRUWzqE3wDVvQqchUFkEP/xRHVYghANIoiYcY/M76vIsgbEw6XmtoxFGx7SoHSo4RI1SQ7B3MDH+MXbdd0dmTVqPFhylymyfJbVsbKVspL6XpgwmuHqROk4w9Qe1nIcQDiCJmrC/qlJY93f19iV/AZ9gbeMRdS1qdi7RkZqXCkBSaJJL1TLTWox/DCHeIdQoNRyqXbXBLhRL3axpaVHTXnRftWQHwKoXpVVNOIQkasL+ti2GshwIjVensQvtWScQWGd+2sn+XHUMlrWrT6h0Ol1d92euHbs/a2qTNJ2+dnkwobmxs9Wi0sfXwfH1Wkcj3JAkasK+LBZ1DT1Q19QzmLSNR6gMXoAOUMBsv3IO1jFYSeGSqJ3NIRMK6nd7SgumawjqpK5eALDlHW1jEU1atGgR8fHx+Pj4MHLkSDZv3tzstosXL0an0zW4+Pho23otiZqwr2Or1LFpXoHqrCjhGnS6uq6yavskahbFQmp+XdenaMghEwqsSbZBuj1dyvC71ev930NxpraxiAY+//xzZs+ezTPPPMP27dtJTk5m0qRJZGVlNfucoKAgzpw5Y7scP37ciRE3JomasK9ti9XrQTeDd4CmoYiz2Lo/y+2yu/SidMpryvE2eDtu8fEOzNrKeDD/IGaL2T47tc34lIkELiVmAHQeoZbrSPlY62hEPfPnz+eee+7hzjvvpG/fvrz99tv4+fnx/vvvN/scnU5HTEyM7RIdHe3EiBuTRE3YT0UhpC5Vbw++TdtYRGPGeuPU7MDaUtQ7tDdGJ4yXuuiii3jkkUcAiI+PZ+HChQ4/Zns89/Bz6Gp0lNeUc7zITmfkkqi5riHT1evdX2obhwcoLi6mqKjIdqmsbLqXoKqqim3btjFx4kTbfXq9nokTJ7Jhw4Zm919SUkK3bt3o0qULV199NXv37rX7a2gNSdSE/Rz4Qe2aiUhUzzCFa7Elavbp+rSOvdJiIsGWLVu49957nX7c1nj976/TL7IfYMdxalKaw3X1maKOBc3aB5n7tI7GrfXt25fg4GDbZd68eU1ul5OTg9lsbtQiFh0dTUZGRpPPSUxM5P333+fbb7/l448/xmKxMHr0aE6ePGn319FSkqgJ+7GeSQ64XgY6uyJbLbVKu8z8tJXm0CBRi4yMxM/Pz+nHtaqqOn9ttODgYPpFqYmaXcapWWrUC0hpDlfkGwI9L1Vv75FWNUfat28fhYWFtsucOXPstu9Ro0Yxffp0Bg0axPjx4/n666+JjIzkn//8p92O0VqSqAn7KC+AY6vV2/2naRqKaIZ1cXbFXPeF30aKoji0Ra20tJTp06cTEBBAbGwsr732WoPH63d9KorCs88+S9euXfH29qZTp0489NBDDbb961//ys0334y/vz9xcXEsWrSowf4KCgq4++67iYyMJCgoiEsuuYSdO3faHn/22WcZNGgQ7777Lt27d7fNAvvyyy8ZMGAAvr6+hIeHM3HiREpLSwG44447+PXTXwG1Ra2yspKHHnqIqKgofHx8uPDCC9myZYvtGKtWrUKn07FixQqGDRuGn58fo0ePJjVVTYhtLaF6o1oZX7ie/tep1/u+0zYONxcYGEhQUJDt4u3ddAtzREQEBoOBzMyGEzwyMzOJiWlZgW6TycTgwYM5fPhwu+NuK5dK1N566y0GDhxoe/NHjRrFTz/9ZHv8oosuajRt9r777tMwYmFzeLn65R+ZBOEJWkcjmqLXo+hNlJkrKasooKy6rM2X9KJ08iry0Ov0dA7o3KLnKK1oxXvsscdYvXo13377LT///DOrVq1i+/btTW771VdfsWDBAv75z39y6NAhvvnmGwYMaNj1/sorr5CcnMyOHTt44oknePjhh/nll19sj99www1kZWXx008/sW3bNoYMGcKECRPIy8uzbXP48GG++uorvv76a1JSUjhz5gw333wzd911F/v372fVqlVcd911DV6nd4H6BXIg7wCP/ekxvvrqKz788EO2b99Oz549mTRpUoNjADz55JO89tprbN26FaPRyF133aU+IEtHub5el6orFeQeghztvtiFysvLi6FDh7JixQrbfRaLhRUrVjBq1KgW7cNsNrN7925iY2MdFeZ5uVTFxM6dO/Piiy/Sq1cvFEXhww8/5Oqrr2bHjh3066d2Idxzzz3MnTvX9hwtuz9EPam1CXXvy7WNQ5xTOTDy13vstj+LYmH8f8e3aNtNt2zCz3T+/9eSkhLee+89Pv74YyZMmADAhx9+SOfOnZvcPj09nZiYGCZOnIjJZKJr166MGDGiwTZjxozhiSeeAKB3796sW7eOBQsWcOmll7J27Vo2b95MVlaW7cz81Vdf5ZtvvuHLL7+0jYWrqqrio48+IjIyEoDt27dTU1PDddddR7du3QAaJYhexV4YdUYKKwt59/N3eXf+u1xxxRUAvPPOO/zyyy+89957PPbYY7bnPP/884wfr76nTzzxBFdeeSUVFRX4yEQC1+cTDPFj4OgqOPgTRDyodUQeb/bs2dx+++0MGzaMESNGsHDhQkpLS7nzzjsBmD59OnFxcbZxbnPnzuWCCy6gZ8+eFBQU8Morr3D8+HHuvvtuzV6DS7WoTZkyhcmTJ9OrVy969+7N888/T0BAABs3brRt4+fn12DabFBQkIYRCwDM1XCotnUicbK2sYhz6wBf8keOHKGqqoqRI0fa7gsLCyMxMbHJ7W+44QbKy8vp0aMH99xzD0uWLKGmpmHX7tlnz6NGjWL/frXrdufOnZSUlBAeHk5AQIDtcuzYMY4cOWJ7Trdu3WxJGkBycjITJkxgwIAB3HDDDbzzzjvk5+c3OI7OoiMhRG1hNnYyMmbMGNtjJpOJESNG2OKwGjhwoO229Sw+KytLZnx2FNbPwNSfzr2dcIqbbrqJV199laeffppBgwaRkpLC0qVLbRMM0tPTOXPmjG37/Px87rnnHvr06cPkyZMpKipi/fr19O3bV6uX4FotavWZzWa++OILSktLG3zI/uc//+Hjjz8mJiaGKVOm8NRTT52zVa2ysrLB1N3i4mKHxu2RTm6BykLwC4fOw7SORpyDr3cQmy55B7yD1CW+2uiJ355g5YmVPDj4QX7f5/ctO7Z1vVE769KlC6mpqSxfvpxffvmFBx54gFdeeYXVq1djMp1/ZYySkhJiY2NZtWpVo8dCQkJst/39/Rs8ZjAY+OWXX1i/fj0///wzb7zxBk8++SSbNm2ie/futu2SwpJIzU/Ft1vLXn/9mK3rp1osFjDXzviUYreurfck+OlPkL5RLVkkax1rbtasWcyaNavJx87+v1+wYAELFixwQlQt51ItagC7d+8mICAAb29v7rvvPpYsWWLLZG+55RY+/vhjVq5cyZw5c/j3v//N739/7i+JefPmNZjGq2VW7LaOrFSve1wkg5xdnM7ki5/BGz90+Jn82nw5XKCOvxkQMaDFz2npou0JCQmYTCY2bdpkuy8/P5+DBw82+xxfX1+mTJnC66+/zqpVq9iwYQO7d++2PV6/Vd76c58+6hJPQ4YMISMjA6PRSM+ePRtcIiIizv1+6nSMGTOG5557jh07duDl5cWSJUsabNMnXD2OX7wf69ats91fXV3Nli1bWvaZpCjSotZRhMZDWII6aSdtrdbRCDfgci1qiYmJpKSkUFhYyJdffsntt9/O6tWr6du3b4O6SQMGDCA2NpYJEyZw5MgREhKaHsA+Z84cZs+ebfv51KlTkqzZ29F6iZpwbWeX6GhDGZXiqmJOFJ8A6taztKeAgABmzJjBY489Rnh4OFFRUTz55JPo9U2fVy5evBiz2czIkSPx8/Pj448/xtfX1zZuDGDdunW8/PLLXHPNNfzyyy988cUX/PDDDwBMnDiRUaNGcc011/Dyyy/Tu3dvTp8+zQ8//MC1117LsGFNtxJv2rSJFStWcNlllxEVFcWmTZvIzs62JYBW1lmx4X3DeeyxxwgLC6Nr1668/PLLlJWVMWPGjPO/KZYaUCzqbaPX+bcX2kq4GPKOqCexSVdqHY3o4FwuUfPy8qJnz54ADB06lC1btvD3v/+9yRom1jEshw8fbjZR8/b2bjB1t6ioyAFRe7CKQji1Tb3d42JtYxHn12Bx9qo2tc5Y66fF+McQ4hNi1/CsXnnlFUpKSpgyZQqBgYH84Q9/oLCwsMltQ0JCePHFF5k9ezZms5kBAwbw/fffEx4ebtvmD3/4A1u3buW5554jKCiI+fPnM2nSJEBtFfvxxx958sknufPOO8nOziYmJoZx48adc+mYoKAg1qxZw8KFCykqKqJbt2689tprtskCVomh6ti6Sq9Kpt44ldtuu43i4mKGDRvGsmXLCA0NPf8bYm1NM3iBzuU6QsTZelwEW96tO4kVoh10SmvmzGvgkksuoWvXrixevLjRY+vWrePCCy9k586dDQbgnsvJkyfp0qULJ06caHYWmWiFAz/AZ7dAeE94cJvW0Yh6KioqOHbsWIO6XwBk7Vcr3IclgE/rJ+P8Z/9/eHHzi1zU+SLemPCGHSN2jPj4eB555BHb8lNauPLrK0kvTudfl/6LUZ1aVhaggdIcKDyhji08q/xNs79noZ3yAni5u9oK+sgeCOmidURuwVO/v13q1GzOnDmsWbOGtLQ0du/ezZw5c1i1ahW33norR44c4a9//Svbtm0jLS2N7777junTpzNu3LgWJ2nCAY6vV6/jx2obh2i5+t2fbbA/t7bQbbjzVyToqKzdn9bWyFaT8Wkdi28IxCart9M3nnNTIc7HpRK1rKwspk+fTmJiIhMmTGDLli0sW7aMSy+9FC8vL5YvX85ll11GUlISf/jDH5g2bRrff/+91mF7thO1A767tqGVQGjD+mVvbtvi7NblkLRYOqqjsr5XbV7zU9b47Hisn4knJFET7eNSY9Tee++9Zh/r0qULq1evdmI04ryqy+F0inq768hzbipciLW8Qxta1KrN1RwpVGuLOWIigSOkpaVpHYItUWvzmp+yKkHH02UkbHxTWtREu7lUi5roYE5tB0s1BMRASLfzby9cQzu6Pg8XHKbGUkOQVxCx/totqdLRWEt0pBWlUV5T3ronK7UTP6BuvVbh+rpeoF5n7lUnXQnRRpKoibazNul3vaBNZR6EczSaL2Tr+qwCi6VV+6rf7dnSumgCInwjCPcJx6JYOJR/qHVPNlcCCqAHQ+MCvi4+H8xzBcbUFpVW1KLgQrSRJGqi7dLrJWrC5Vgr3JeVlTV8QG8EXW1hYnPrWtWsY6xkfFrrWSdftLr7s/5EgiaSY+vvtyWrMAgn61L72Sjdn6IdXGqMmuhALJZ6EwkkUXNFBoOBkJAQdZ1I1HVyba1giglqaqC0GHxa3jK2P0dN1BICE6ioaNtkBE/VK6gX606tY0/WHqZ2m9ryJ5aWQI2iJtj13nNFUSgrKyMrK4uQkBAMBlkVxOV0vQB2fSaJmmgXSdRE22QfUMddmPwheoDW0YhmxMTEANiSNZuyXKgqhdzqFtdSsygWW2uQf6k/x44ds2us7i60Wi1suytzV+veu/I8qCwBn0rIr270cEhIiO33LFyM9ST25FYwVzfZdS3E+UiiJtrGOj6t81AwyJ+Rq9LpdMTGxhIVFUV1db0v+c0rYPPbkDQVJj7don2lF6dTYanAS+/FmD5jMOrl994ahggDCw4v4GTFSbp069Ly92/Jy3BqC0x4FroPbvCQyWSSljRXFpGoLspeUQgZuyBuqNYRiQ5IPmlF26RL/bSOxGAwNPxCD4uFkhOQuQ1aWM3+WIbaCtQrtBcBfgGOCNOt9fTuib/Jn9LqUjIqM+gZ2rNlTzyzCUpOQUS3Fv+uhIvQ69VxaoeWqZ+ZkqiJNpDJBKJtrLOYOo/QNg7RNuG1SUJuy2cgSqHb9tHr9LZ1P1tc+LaqFIpOqbfDm17PWLi4LrWfkTLzU7SRJGqi9SqKIE8tekqnwefeVrimsNov/bJcKMtr0VOsyUVHKXTrilq9lFRu7f+ZXzj4hTkoKuFQnQap12d2ahqG6LgkUROtl7FLvQ7uAv7h2sYi2sY7AAI7qbfzjrboKdbkQtb4bLtWr1CQe1i9Dm9hN6lwPbG1J7N5R6TwrWgTSdRE61mXjbIuOiw6JmtXmjUZOIec8hxyynPQoaNXSC8HB+a+6q/52aJCtdYWNUnUOi7/cPWkFuDMLm1jER2SJGqi9c6kqNfWJn3RMdnGqZ0/Udufq3Z7xgfH42fyc2RUbq1nSE+MeiNFVUWcKT1z/ifYWtRkfFqHZj2ple5P0QaSqInWs37YxA7SNAzRTtZELef8EwpS82u7PWUiQbuYDCZ6hqjve4u6P6Xr0z1YPyutJ7lCtIIkaqJ1KovrvtglUevYbC1qR867qbVFTRK19rPO/DxvoqYodbNyJVHr2Ky9D9ZhI0K0giRqonUydgMKBMVBQKTW0Yj2iKgda5Z35LyLs0tpDvvpE67Omj1viY7SnNrB5zoI6+H4wITjWLs+cw+rJ7tCtIIkaqJ1ZCKB+wjpqq4fWV0Gxc2PlyqtLiW9OB2QRM0eWjzz09qaFtIFTL4Ojko4VEBU7SxrpfZkV4iWk0RNtI6MT3MfBhOExqu3zzGhwFqWI8ovijAfqeXVXtauz4zSDAoqCprf0DY+TWbZugXp/hRtJImaaB2Z8eleWrBCgRS6ta8ArwC6BKrlGg7kn6NVzToWNEISNbdgm1AgMz9F60iiJlquqhRyDqq3pUXNPbRgQoGMT7M/W/dn7jkSNZnx6V5sKxSkaBmF6IAkURMtl7kXFAsERENgtNbRCHtoQS0124oEkqjZjbV18pwTCnJkxqdbsY7rzTkIVWXaxiI6FEnURMtl7lGvYwZoG4ewn/MkatXmag4VqAmDJGr2kximjlNrds1PczXkH1NvS9enewiMAf9I9WQ3+zwzfoWoRxI10XKZ+9TrqL7axiHsx5qo5R+HmqpGDx8pPEKNpYZAr0DiAuKcHJz7sraoHSs6RnlNeeMN8o+DpQZMfnVrsoqOL7qfep2xR9s4RIciiZpoucy96nV0f23jEPYTGAMmf1DMkJ/W6OH649N0Op2Tg3NfkX6RhPuEY1EsHMpvYiKHrdBtAujlY9ptWD87rZ+lQrSAfAKIllEUyLImav20jUXYj053zsXZrYmataSEsJ+k8HPUU7ONT5NuT7diS9SkRU20nCRqomWKTqlV0vVGiOitdTTCnqxjoJpI1KxLR1mr6Qv7SQo9R6KWK6U53FJMbaKWsUc9+RWiBSRREy1jHZ8W0RuMXtrGIuyrmQkFFsUii7E70Llb1KTYrVuK6K2e7FYWQuFJraMRHYQkaqJlrE31MpHA/TRTS+1U8SlKq0vx0nvRPbi7BoG5N+uEgoP5B6mx1DR80NaiJqU53IrRGyJqhxFI96doIUnURMtk1baoyfg092Mbo9ZwULu1xlfP0J6Y9CZnR+X2ugR2wc/oR6W5krTCtLoHygugNFu9LTXU3E+MjFMTrSOJmmiZTJlI4LasyUBJJlQU2e62dsnJ0lGOodfpbfXUGiwlZe2CDowF70ANIhMOJSU6RCtJoibOr6aqbukoSdTcj08w+Eept/Pquj9tMz7DZManozS5lJSsSODepESHaCVJ1MT55RxUi2/6BEOQFD11S02MU5MWNcezvrcNJhTIjE/3Zk3U8o7IUlKiRVwqUXvrrbcYOHAgQUFBBAUFMWrUKH766Sfb4xUVFcycOZPw8HACAgKYNm0amZmZGkbsIazj06L6qXW3hPs5q5ZaTnkO2eXZ6NDRO1TKsTiKtUVtf95+FGu5Bqmh5t4Co+uWksqSpaTE+blUota5c2defPFFtm3bxtatW7nkkku4+uqr2btXbSJ+9NFH+f777/niiy9YvXo1p0+f5rrrrtM4ag9gHfQq3Z7uy9qiVpskWNeg7BbUDT+Tn1ZRub2EkASMOiNFVUVklGaod1rHqEmLmvuyfpbKhALRAi6VqE2ZMoXJkyfTq1cvevfuzfPPP09AQAAbN26ksLCQ9957j/nz53PJJZcwdOhQPvjgA9avX8/GjRu1Dt292SYSSGkOt3VWLTXrjE+pn+ZYXgYvEkLU1sz9efvBYq7rfpYxau5LVigQreBSiVp9ZrOZzz77jNLSUkaNGsW2bduorq5m4sSJtm2SkpLo2rUrGzZs0DBSD2CdnRQ9QNs4hOPYVic4AorSYI1P4Vi2CQV5B6DwBJgrweANIV01jkw4TEztZ6lMKBAt4HKJ2u7duwkICMDb25v77ruPJUuW0LdvXzIyMvDy8iIkJKTB9tHR0WRkZDS7v8rKSoqKimyX4uJiB78CN1OaAyUZgA6iZFC52wqNB50eqoqhJMvW9SkTCRyv/jg1W7dnWA/QGzSMSjhU/RIdspSUOA+XS9QSExNJSUlh06ZN3H///dx+++3s27evzfubN28ewcHBtkvfvtJ91yrWpvmw7uAdoG0swnGMdS04ZVl7OF50HJDSHM5gTdRS81Lrlo6SFQncW0SiLCUlWszlEjUvLy969uzJ0KFDmTdvHsnJyfz9738nJiaGqqoqCgoKGmyfmZlJTExMs/ubM2cOhYWFtkt7kj6PZOv27K9tHMLxasdEpZ7aiIJClG8U4b7hGgfl/qyJ2pnSMxRk13aFyYxP92b0kqWkRIu5XKJ2NovFQmVlJUOHDsVkMrFixQrbY6mpqaSnpzNq1Khmn+/t7W0r9xEUFERgoFT6bhXrh0iMjE9ze7WJ2oFcNVmwLhouHCvAK4AugV2AevXUZMan+7MuJSUrFIjzMGodQH1z5szhiiuuoGvXrhQXF/PJJ5+watUqli1bRnBwMDNmzGD27NmEhYURFBTEgw8+yKhRo7jgggu0Dt19SWkOz2FN1IpPAJAYKt2ezpIUlsSJ4hMcKD3NBSAtap5ASnSIFnKpFrWsrCymT59OYmIiEyZMYMuWLSxbtoxLL70UgAULFnDVVVcxbdo0xo0bR0xMDF9//bXGUbsxczVkq4PKpevTA9S24uyvKQCgT7hMJHAW28xPpVy9Q1rU3J+U6HCaRYsWER8fj4+PDyNHjmTz5s0tet5nn32GTqfjmmuucWyA5+FSLWrvvffeOR/38fFh0aJFLFq0yEkRebicQ2CuAu8gKRXgCSISqQYO6xVAJ6U5nMiWqHmZICAafEO0DUg4nnU4SW7tUlJeUljaET7//HNmz57N22+/zciRI1m4cCGTJk0iNTWVqKioZp+XlpbGH//4R8aOHevEaJvmUi1qwsXU7/aUpaPcX2AMR/1DqNbpCDD6Ehcg67o6i7UMyjGTiXKZ8ekZAqLUpaRQZCkpB5o/fz733HMPd955J3379uXtt9/Gz8+P999/v9nnmM1mbr31Vp577jl69OjhxGibJomaaF7GbvVauj09g07HgbDOACT6RKHXyceDs0T4RhCm98ai03E4pJPW4Qhnke7PNikuLm5QH7WysrLJ7aqqqti2bVuDQvl6vZ6JEyees1D+3LlziYqKYsaMGXaPvS3kk1g0z7Z0lEwk8BQH/NRZ0X10PhpH4ll0Oh19FBMA+32lC8xjyISCNunbt2+D+qjz5s1rcrucnBzMZjPR0dEN7j9Xofy1a9fy3nvv8c4779g97rZyqTFqwsVIaQ6Pc0BvBiCpmTNU4ThJ5WWs84EDVGkdinAW62erlOholX379hEXVzc0w9vb2y77LS4u5rbbbuOdd94hIiLCLvu0B0nURNNKsqEkE1k6ynMoikJqdQEASYXZ2gbjaWoqSSrKBp9wDlTmah2NcBZbi9pedSkpGQvcIoGBgQQFBZ13u4iICAwGA5mZmQ3ub65Q/pEjR0hLS2PKlCm2+ywWCwBGo5HU1FQSEhLaGX3rSdenaJpt6age4OWvbSzCKU6VnKLYXIFJUeiRfRQsZq1D8hy5h22tmAeLjlFjqdE4IOEUEYmgN9UuJXVC62jcjpeXF0OHDm1QKN9isbBixYomC+UnJSWxe/duUlJSbJepU6dy8cUXk5KSQpcuXZwZvo20qImm2bo9ZSKBp7BWxe9ZXYPJXAkFx9VEXThedipda2rwU3SUmSs5XnSchBDnn7kLJzN6QWSi+nmbuVfKIDnA7Nmzuf322xk2bBgjRoxg4cKFlJaWcueddwIwffp04uLimDdvHj4+PvTv3/A7LyQkBKDR/c4kiZpomqzx6XH256klApL0tYPZs1MlUXOWnIPogURjIDvMRezP2y+JmqeI7qcmahl7IPEKraNxOzfddBPZ2dk8/fTTZGRkMGjQIJYuXWqbYJCeno5e79qdi5KoiabZZnxKouYprC1qSX6xwBE1UZMvDueoXQEkMaAzOwr3cSD3AFf1uErjoIRTRPcHPpeZnw40a9YsZs2a1eRjq1atOudzFy9ebP+AWsm100ihjZoqyK5dHFq6Pj2GNVHrE1q7IkHOQQ2j8TC173WfcHVw+YH8A1pGI5xJSnSI85BETTSWcxAs1eAdDMHaDJ4UzpVXkUdWWRY6dPTuNFy907rOq3Asi1ldrg1IihsNqEmzoihaRiWcpcFSUqXaxiJckiRqorH6hW5lurhHOJCrtuB0DeqKf/RA9c6cg2rJAOFY+WlgrgSjDz27jMGoM1JYWUhGadMFOYWbabCUlLSkisYkURONZdYuHSXdnh7D2tWWGJoI4QmgM0BlERRLsuBw1i7miF54mXzpEaJO4LBO7hAewLaU1G5t4xAuSRI10VhGvcXYhUewtqj1Ce8DRm8I664+kC1n+A5n7WKOSAQgKUwdI5iaJ13PHsN6UmztzRCiHknURGO2rk9ZOspT2Epz1CYJ1qRBJhQ4gfU9jlTf8z5h6kog0qLmQawtarKUlGiCJGqioZIsKM1CXToqSetohBOUVZdxvOg4UC9Ri+ytXsuEAseztlpGqO+59XdgnYUrPEB0vRY1GRcqziKJmmgoo3aMRHiCLB3lIQ7mH0RBIdI3kgjf2oWIpUXNORQFshu2qCWGqddnSs9QUFGgUWDCqSJ6y1JSollS8FY0lCnj0zyNteXGmiAA0qLmLMVnoKpYnbwRpq5EEOgVSOeAzpwsOUlqfiojY0dqHKRwuPpLSWXskaWkOpCwsLBWba/T6di+fTvdunVr8XMkURMNndmlXscM1DYO4TS2Qre1Y6MAWzccpVlQlgd+rfswEi1kTYTDeqhf1rX6hPfhZMlJDuQdkETNU1iXksrcC0mTtY5GtFBBQQELFy4kODj4vNsqisIDDzyA2Wxu1TEkURMNZdQmarGDNA1DOI9t6aiwemMSvQMhqDMUnVS7P7teoFF0bu6siQRWSWFJ/HL8F5lQ4ElsS0lJiY6O5ne/+x1RUVEt2vbBBx9s9f4lURN1KktsFdKJlRY1T1BtqeZQfm1V/LCzJo9E9lYTtexUSdQc5ayJBFa2CQW5MqHAY0iJjg7JYrG0avvi4uJWH0MmE4g6mXsBBQJi1GrZwu2lFaZRZanC3+RP58DODR+UCQWOl918ixrAsaJjVNRUODsqoQXrzE9ZSkqcRVrURB1bt2eytnEIp7FNJAhNRK8767xNJhQ4Xo612G3DFrVI30jCfMLIq8jjUP4hBkRKTUO3FxAF/lHquNCsA9B5qNYRiTY4ffo0a9euJSsrq1Fr20MPPdSmfUqiJuqcSVGvpdvTYzQqdFufrUVNEjWHKMuD0mz19lmJmk6no09YH9adXsf+vP2SqHmK6H5wNEsdpyaJWoezePFi/u///g8vLy/Cw8PR1VsrW6fTtTlRk65PUeeMtKh5GusyRU0mapG19xWckK4YR7B2KQd3Ae+ARg9by6VI4VsPElObkFs/i0WH8tRTT/H0009TWFhIWloax44ds12OHj3a5v1KoiZUNVWQVTvDTEpzeARFUWwtan3C+zTewD8c/MIBpW6SibCfZiYSWFnLpcianx7EepJ8Zqe2cYg2KSsr43e/+x16vX1TK0nUhCp7P1iqwSdEii16iNOlpymuKsaoN5IQnND0RtZWNRmnZn/W9zSy6aXarK2cB/MPYra0ru6S6KCsZZEy94C5RtNQROvNmDGDL774wu77lTFqQmU9g4sdCPX61YX7snap9QzpiclganqjqD5wfB1k7XNiZB7C+p5GNdGaCXQN6oqv0ZfymnLSitJICGkmmRbuI6wHeAWqq1XkHITovlpHJFph3rx5XHXVVSxdupQBAwZgMjX8XJ0/f36b9iuJmlDJigQep8lCt2eztvZkSeFVu7O+p80kanqdnsTQRFKyU9ift18SNU+g16sny8fXqSfPkqh1KPPmzWPZsmUkJqrjS8+eTNBWkqgJlaxI4HGsxVTPmahF1X5RZEuiZldleVCSqd4+q4ZafUlhSaRkp5Cal8pVPa5yUnBCU7HJdYnaoJu1jka0wmuvvcb777/PHXfcYdf9yhg1ARYzZNQuWyKlOTzGgfyWJGq1rT0F6erKFcI+rK1pwV3V5bqaYZ3kIUtJeRCZUNBheXt7M2bMGLvv16UStXnz5jF8+HACAwOJiorimmuuITW14SDmiy66CJ1O1+By3333aRSxm8g9AtVlYPKD8J5aRyOcoKCigIzSDEAtdtssvzAIiFZvy4QC+8k+d7enVf0SHYqiODoq4QqsiVrGLmjl8kRCWw8//DBvvPGG3ffrUl2fq1evZubMmQwfPpyamhr+/Oc/c9lll7Fv3z78/f1t291zzz3MnTvX9rOfn58W4boP65lbdH/QG7SNRTiFtYWmS2AXArwa1/BqIDJJ7abL2idFOO3FNj7tHK2ZQK+QXhh1RgorC8kozSA2INYJwQlNhfcCoy9UlUDeEYjopXVEooU2b97Mr7/+yv/+9z/69evXaDLB119/3ab9ulSitnTp0gY/L168mKioKLZt28a4ceNs9/v5+RETE+Ps8NxXhnXGpxS69RQtmkhgFdUXjq2uq/sl2i+r9r2MOvdgcS+DFz1CenAw/yAH8g5IouYJDEZ1gfaTW9STaEnUOoyQkBCuu+46u+/XpRK1sxUWFgIQFhbW4P7//Oc/fPzxx8TExDBlyhSeeuopaVVrj/qlOYRHsCZq1qKq52Rt9ZESHfahKHXvZTM11OpLCkuyJWoXd73YwcEJlxA7qDZRS4EB12sdjWihDz74wCH7ddlEzWKx8MgjjzBmzBj69+9vu/+WW26hW7dudOrUiV27dvH444+TmprabJNiZWUllZWVtp+Li4sdHnuHoihSmsMDtbpFDaREh72UZEF5HqA754xPq6SwJL478p1MKPAkMqFA1OOyidrMmTPZs2cPa9eubXD/vffea7s9YMAAYmNjmTBhAkeOHCEhoXGdoXnz5vHcc885PF57UBSF8mozheXVFJXX1F5XU1h7KaqoRoeO3tEBTOwbjclgh7kgBelQUQB603kHNgv3YC2gCi1M1KytPsVnoDwffEMdF5wnsE4kCOsBJt/zbm79HclSUh6kfqKmKHYpQl5UUc0vezM5nluKyaAnyNdEsK+JIF8jQT7W2yaCfEz4mPTtqvvlSYYMGcKKFSsIDW3Z5+KFF17I559/TlxcXIuP4ZKJ2qxZs/jf//7HmjVr6Ny58zm3HTlyJACHDx9uMlGbM2cOs2fPtv186tQp+vZtexFBs0WhssZMVY2FqhoLlbWXqhoLVWYLldVmKmoslFXWUFplpqyqhtLKs66rzLWP11BWZaakosaWiFWbWzazKyHSnwU3DWJg55A2vxagrn5aVBIYvdu3L9EhHMo/hEWxEO4TTqRf5Pmf4BMEQZ2h6KQ6tqrbKMcH6c7OU+j2bNZE7XTpaQorCwn2DnZUZMJVRCaBwQsqCqHgOITGt2t3P+4+w1Pf7CG3tKpF23sZ9GoCV5u4BXgb8fMyqBdvI/5eBny91Gs/byN+JgP+3gb8vNTtfEwGvIx6TAY9XkY9Xobai1G9GPTukwSmpKSwc+fORkO0zrV9/V6+lnCpRE1RFB588EGWLFnCqlWr6N69+3mfk5KSAkBsbNODbL29vfH2rktAioqKALjtvU14BR3FoiiYFQVFQb1tUW+bLQoWRb1UmxVbIma2OH6KvEGvI9h6tuNT+89S+3ON2cKK/VkcyS7l1nc28fHdI0nuEtL2g1m7PWUigcewdXuGt6A1zSqqj5qoZe+XRK29WpmoBXoF0jmgMydLTnIg7wAjY0c6MDjhEoxe6pCDMylqq1o7ErVvdpzi0f+moCjQI8KfCxLCsVgUiiqqbb03dbersShQZbaQU1JFTknLErvWMuh1mAy62uTNgFGvw6DXodOBXqdDb73W193W6XRUFmY5JJ72mjBhQovL57SlpdKlErWZM2fyySef8O233xIYGEhGhlrnKTg4GF9fX44cOcInn3zC5MmTCQ8PZ9euXTz66KOMGzeOgQNbN77qUGYJxnKfdsWr14GXUY+30WA7a/A26vE2GQioPbuwnmX41zsTaXB/7bU1MQv2NeHnZTjnL7OwvJp7PtrK5mN53PPRVpY9Mo5Qf6+2vQjrGIgYSdQ8hXWsU1JoaxK1JDj8i4xTswfre9iCiQRWSWFJkqh5mthkNVE7nQJ9r27TLvacKuSxL3eiKHDziC7Mvbr/OYfMKIpCSWUNRRU1DYbdlNX2/pRVmimtqqG8ymzrEWp4n9prVFmtNmxU1ettqs9sURtFKqotQMsXn68pcr2i28eOHWv1c87XU3g2l0rU3nrrLUAtalvfBx98wB133IGXlxfLly9n4cKFlJaW0qVLF6ZNm8Zf/vKXVh/r7zcPIiY2zpa9q9l83W31fh16PRj1uobJmEm9NtpjjFgbBPua+OCO4Uz9x1qOZJfyl2/2sOjWIW3bWYa0qHka61in1rWoyYQCu1CUujIn5ynNUV9SWBLL05fbWkOFB+g0CLZ/2OYJBRXVZh79PIVqs8JlfaN5/poB6M/T5ajT6Qj0MRHoYyIu5PzjJ1tKsfZM1SZv1ea6oUNVNZYGPVgWRd1evU+9bant8co4c4qb3rJbWHbRrVs3hx/DpRK18zUddunShdWrV9vlWCO7h9O5c4Rd9qUFf28jC28azLVvruOH3We49UgOoxNa+XpKstQB4uggup9D4hSupcZSw8H8g0ALS3NYyeLs9lF0CiqLQG9s1Sog1qWkJFHzIO2cUPDvDcc5lFVCRIA3L04beN4kzZF0Oh1eRh1eRj20Yyj0Sb/Wje1yFy61hJRonQGdg7l1ZFcAXvqpDUvMWMenhfcE7/NUpxduIa0wjUpzJX5GP7oEdmn5EyMTAR2U5UBJtsPic3vWRDe8pzoOqYWsy3wdKzxGRU2FIyITriaqH+gM6v9c0elWPbWwvJp/rDwMwOOXJxLW1qExwiVIotbBzbqkF35eBnaeLGRlaisHWp7eoV53Gmz/wIRLsi7EnhiWiF7Xin9/L38IrW3iz5ZWtTZrw/g0gCi/KMJ8wjArZg7lH3JAYMLlmHzqJpy0svtz8bo0Csur6R0dwHVDWjceSrgeSdQ6uMhAb35/gfoF+t7aVg5qlETN4xzIbUWh27PJOLX2s834bF2JIJ1OZ/udWZNt4QHaUPi2ssbMvzceB2DmxT3dqhSGp5JEzQ3cPjoeg17HusO57Dtd1PInSqLmcVq1IsHZZJxa+2W3bDH2ptgStVxJ1DxGGxK171JOk1NSSWywD5MHyNqwWqiqquLkyZOkp6c3uLSVJGpuIC7El8v7q4vUf7q5hX8MxRlQfBp0eogZ4MDohKtQFMXWGtO+FjVZ87NNLGbIrl1dILL1q4DYEjWZUOA5Ygep12dSWvyUT2q/A24b1c0+q9eIFjt06BBjx47F19eXbt260b17d7p37058fHyL6sI2p1WzPr/77rtWH+DSSy/F19d+03xF0343vAs/7DrDdztP8+SVffAxGc79hNMp6nVEokwk8BAZpRkUVhZi1BnpGdLyGYc20fW6Pu20rI1HyU+D6jIw+qjLR7WSNVE7mH8Qs8WMQX+e/3HR8cX0B3Tq7PziTAiMPufmh7NK2JFegEGv4/qhMjbN2e644w6MRiP/+9//iI2NtdsyXK1K1K655ppW7Vyn03Ho0CF69Gj9h5JondEJEcQG+3CmsIIV+7O4cuB5mrxPb1evpdvTY1gL3fYI6YGXoQ2zwMJ7qWvCVhZB4QkI6WrnCN1c5l71OjIJDK2vjNQtqBu+Rl/Ka8o5XnScHiHyuer2vPwhojfkpKrdn4GXnXPzr7afBODixEiiAttX0F20XkpKCtu2bSMpqQ09FufQ6nbRjIwMLBZLiy5+fn52DVY0z6DXcd0QdZHXJTtOnv8JMj7N47RrfBqo5SQi1TIRtqRDtJz1PYvu36an63V6W5kOa9ItPECnQeq19TO7GRaLwjc7TgEwTWZ6aqJv377k5OTYfb+tStRuv/32VnVj/v73vycoKKjVQYm2mZqsJmprDuVQXFHd/IaKUvdPH9fGFQ1Eh7M3V00U+oW3o7ixtTBy5h47RORhrO9ZO4pLJ4apiZqMU/MgnWo/o629IM1IOVnAmcIKAryNXJwU5YTAxNleeukl/vSnP7Fq1Spyc3MpKipqcGmrVrW/f/DBB63auXVJKOEcvaMD6BHpz9HsUn49kMXVg+Ka3rDoFJRmq9XRZUUCj6AoCntzahO1CHskatKi1mq2FrW2v//W1SSkRc2DWE+mT20/59jQn3afAWBCn6jzj1EWDjFx4kRAXaS9PkVR0Ol0mM3mNu3XpZaQEu2j0+mY3D+Wf6w8zI+7zzSfqFlb06L6gEkmeniCzLJMcityMegMtu6zNomSRK1NKksgv7bOYTsSNev6rKl5qbYPf+HmYgaoJ9WlWepJdnDjbk1FUfhxdwYAV/SXkhxaWblypUP2265EraKigl27dpGVlYXFYmnw2NSpU9sVmGiby/vH8I+Vh1lzMIeKanPTZ1YyPs3j7MtVS2okhCTgY2zHIGNrkpF7GKrLJdFvKWvtuYBo8G/7GsM9Q3pi1BkpqCwgsyyTGP8YOwUoXJbJVz2pztittqo1kagdyCjmVEE5PiY943tHahCkABg/frxD9tvmRG3p0qVMnz69yYFz7WniE+3Tr1MQMUE+ZBRVsPFoLhclNjFWQRI1j2OX8WkAgTHgGwbleWpNMOtAZ3FuWe3v9gTwNnjTPaQ7h/IPsT93vyRqnqLTEDVRO70d+jZuBFlzUF1/94Ie4fh6SbenlgoKCnjvvffYv189OevXrx933XUXwcHBbd5nm6vhPfjgg9xwww2cOXOm0WxPSdK0o9PpuDhJPaNaldrE4tn1JxJIouYx7Jao6XQyTq0t7DA+zUrGqXmg+uPUmrDmkPpZP66XtKZpaevWrSQkJLBgwQLy8vLIy8tj/vz5JCQksH37uSeDnEubE7XMzExmz55NdPS5C/AJ57u4thXt1wNZKIrS8MH8NCjPB4NX3Xgj4dYURWFfjtr12a6JBFbW8hKSqLVcO0tz1GdNtvfkyMxbj2Gb+ZkCZw0zKquqYcuxfADGJ0qi1pRFixYRHx+Pj48PI0eOZPPmzc1u+/XXXzNs2DBCQkLw9/dn0KBB/Pvf/27RcR599FGmTp1KWloaX3/9NV9//TXHjh3jqquu4pFHHmlz/G1O1K6//npWrVrV5gMLxxnTMwIvg570vDLScssaPmhtTYvur9bFEm7vTOkZ8ivzMeqN9A7t3f4dSomO1lEUu5TmsOofoSZ7e3P3Nj4RE+4pqo+6okVlIeQdbfDQxqO5VJktxIX40iPCX6MAXdfnn3/O7NmzeeaZZ9i+fTvJyclMmjSJrKysJrcPCwvjySefZMOGDezatYs777yTO++8k2XLlp33WFu3buXxxx/HaKwbVWY0GvnTn/7E1q1b2/wa2jxG7R//+Ac33HADv/32GwMGDMBkMjV4/KGHHmpzUKJ9/L2NDOoSwua0PDYcyaV7/X9e6fb0ONZuz14hvdq2IsHZ6idqspTU+RWdgopCdeZeRPsT5cSwRIx6I3kVeZwuPU1cQDOzu4X7MJjU2Z8nt6jj1CLqloBbc1AdJz6ud6TMAm7C/Pnzueeee7jzzjsBePvtt/nhhx94//33eeKJJxptf9FFFzX4+eGHH+bDDz9k7dq1TJo06ZzHCgoKIj09vdHKBCdOnCAwMLDNr6HNidqnn37Kzz//jI+PD6tWrWrwB6LT6SRR09gFCeFqonY0l1tG1lvqRxI1j2Otn9Y3vK99dhiZBDo9lOVCSdZ51x/0eNZuz4jeYPRu9+68Dd70Du3Nvtx97M7ZLYmap+g0RE3UTm2HgTfa7rZOJBjfu+2ziTua4uLiBgVkvb298fZu/L9VVVXFtm3bmDNnju0+vV7PxIkT2bBhw3mPoygKv/76K6mpqbz00kvn3f6mm25ixowZvPrqq4wePRqAdevW8dhjj3HzzTe35KU1qc2J2pNPPslzzz3HE088gV7f5h5U4SCjeoTz+opDbDiSW1dvyWJR14sDma3nQWwTCewxPg3Ayw/CEiD3kDqbURK1c7PjRAKrARED2Je7j705e7k8/nK77Ve4sLjGKxScyCvjaE4pBr2O0T09J1Hr27fhSeczzzzDs88+22i7nJwczGZzo7H00dHRHDjQ/OoehYWFxMXFUVlZicFg4M033+TSSy89b1yvvvoqOp2O6dOnU1NTA4DJZOL+++/nxRdfbMEra1qbE7WqqipuuukmSdJc1OCuIXgZ9eSUVHIku4SeUYGQc1BdUNvkB5F9tA5ROIFFsdhvxmd90X3VRC1zLyRcYr/9uiNrohZlpxZN1HFqn6d+zu6c3Xbbp3Bx1gkFZ3aBuQYMRttszyFdQwjyMZ3jye5l3759xMXVtSQ31ZrWHoGBgaSkpFBSUsKKFSuYPXs2PXr0aNQtejYvLy/+/ve/M2/ePI4cOQJAQkJCu9c9b3OWdfvtt/P555+36+DCcXxMBoZ2DQVgw5Fc9c6TW9TrToPBIItSeILjRccprirG2+BNr9Be9tuxzPxsOTvO+LTqH67ua1/uPswWKYfkEcJ7gncQ1JRDtlqaZfOxPABGJ3hOaxqoiVRQUJDt0lyiFhERgcFgIDMzs8H9mZmZxMQ0X4NQr9fTs2dPBg0axB/+8Aeuv/565s2b1+L4/Pz8GDBgAAMGDGh3kgbtaFEzm828/PLLLFu2jIEDBzaaTDB//vx2ByfaZ1RCOBuO5rLhaC63jYqHU7WzTjoP0zQu4Ty7sncB6vg0k96OZ9wy87NlairVlmywa9dn9+Du+Bn9KKsp42jhUfsm4cI16fUQmwxpv6nj1GIGsKU2URvRPUzj4FyTl5cXQ4cOZcWKFVxzzTUAWCwWVqxYwaxZs1q8H4vFQmVlZZOPXXfddSxevJigoCCuu+66c+7n66+/bvEx62tzorZ7924GD1YHpO/Z0/DDWmaeuIZRCeHwC2w8mofFoqA/uU19IE4SNU9h7RobEDHAvju2Jh3ZqWCuVmelicayU0Exg08IBHWy224NegN9w/uyNXMre3L2SKLmKeKGqIna6e2cSriR04UVGPQ6BncN0ToylzV79mxuv/12hg0bxogRI1i4cCGlpaW2WaDTp08nLi7O1mI2b948hg0bRkJCApWVlfz444/8+9//5q233mpy/8HBwbacpz2rD5xLmxM1Ry0+KuwnuXMIviYDeaVVHDqVQaJ1GRtpUfMY1ha1gZED7bvj4K7gFQhVxeq6n1Ey5rFJ9bs97XwCOyBigC1Ru7bXtXbdt3BRnepWKNiapram9e8UhJ+XDGVpzk033UR2djZPP/00GRkZDBo0iKVLl9omGKSnpzcYa19aWsoDDzzAyZMn8fX1JSkpiY8//pibbrqpyf1/8MEHTd62p1b9dnft2kX//v1bPIFg7969JCYmNij+JpzHy6hnWHwovx3K4UjKWhIVCwTF2fXMXriu8ppyDuar3W4DI+ycqOn16oSCE5sgY48kas2xFbq130QCK+ssXplQ4EGsMz+z9pFy9DQAw+Kl2/N8Zs2a1WxX59mF+//2t7/xt7/9rU3HKS8vR1EU27i048ePs2TJEvr27ctll13Wpn1CKycTDB48mNzc3BZvP2rUKNLT01sdlLCfkbVjF6qO104kiBuqYTTCmfbn7sesmInwjXDM4t0xtd2pGbvsv293YX1vYuycKFOXfB/KP0R5Tbnd9y9cUHAXCIgGSw1FR9Uxx8PjQzUOSlhdffXVfPTRR4C6OPuIESN47bXXuPrqq5vtOm2JVjV1KYrCU0891eJZDFVVVW0KStjP4NqZn6F5Keod0u3pMawtLQMjBjpm3Kg1+bDW5hMNKYpaSgEg1v6JWox/DFG+UWSVZ7E3Zy/DYuR/2+3pdNBlBOz/nsiCnUBXhnaTFjVXsX37dhYsWADAl19+SUxMDDt27OCrr77i6aef5v7772/TfluVqI0bN47U1NQWbz9q1Ch8fX1bHZSwn4Gdg9HpINF8EHTIRAIPsjNbTaAGRNp5IoGVNfnI2CVLSTWl8ARUFIDe5JC6hTqdjuSoZH45/gs7s3dKouYpOquJ2mDdIbpH+BMZaN8aYqLtysrKbEtF/fzzz1x33XXo9XouuOACjh8/3ub9tipRk0XYO55AHxOjIyqJKc7HojOglxUJPEb9FjWHiOqrrl9Zng+FJyGki2OO01FZW9OiksBohzVWm5AcWZeoCQ/RZQQAQ/SHGCazPV1Kz549+eabb7j22mtZtmwZjz76KABZWVkEBQW1eb+yrIAHmBx6AoBs3wTw8j/P1sIdZJVlkVGagQ6d/ZaOOpvRW133E2ScWlNs49OSHXaI5Eh13zuzd6IoisOOI1xI7CBqMBKpK+Si6DKtoxH1PP300/zxj38kPj6ekSNHMmrUKEBtXbOWM2sLSdQ8wAi9uqbZDhI1jkQ4y+5stTUtISQBf5MDk3PbODVJ1Bpx4Pg0qz7hfTDpTeRV5HGy+KTDjiNcR7Xei11KdwCG65tfr1I43/XXX096ejpbt25l6dKltvsnTJhgG7vWFpKoeYCuxTsAWFqcQI3ZonE0whl2ZKm/80FRgxx7oPrj1ERDDpzxaeVt8KZPuDr+LSU7xWHHEa4jNaOYTWa1JTsyd6vG0Qir6upqjEYjOTk5DB48uEEZsxEjRpCUlNTmfbtUojZv3jyGDx9OYGAgUVFRXHPNNY0mL1RUVDBz5kzCw8MJCAhg2rRpjdbxEvWU5eGVq551ra1O5EBGscYBCWfYka0makOihjj2QNKi1rTSXCg6Beggxn5rfDalfvencH8pJwrYZFGTc93xdRpHI6xMJhNdu3bFbLb/2rsulaitXr2amTNnsnHjRn755Reqq6u57LLLKC0ttW3z6KOP8v333/PFF1+wevVqTp8+fd71tTxa+gZ0KJwydiGHYHacKNA6IuFgFTUV7MvdBzihRc1aS63oJJTlOfZYHUlGbdIU1gO8Ax16KEnUPMuukwVstfTGgh7y06DwlNYhiVpPPvkkf/7zn8nLs+9nYasStR9//JFu3boRFhbGhAkTbH2wc+fO5corr2TevHlkZWW1OZilS5dyxx130K9fP5KTk1m8eDHp6els26auUVlYWMh7773H/PnzueSSSxg6dCgffPAB69evZ+PGjW0+rltLWwtATrg6dX9Her6W0Qgn2JOzhxpLDRG+EXQO6OzYg/kEQag6XkbqqdXjhPFpVtZE7WD+QcqqZXC5u9t5opAS/CgOrV3tovYzXmjvH//4B2vWrKFTp04kJiYyZMiQBpe2alV5jj/+8Y9cd911XHnllSxdupRrrrmGKVOm8NNPP3Hbbbfx/fff849//IOVK1fSu3fvNgdlVVhYCEBYmFrQb9u2bVRXVzNx4kTbNklJSXTt2pUNGzZwwQUXNNpHZWVlg1Xvi4s9rOvviLomqyHhYjgOO9ILtI1HOJx1rNLgqMGOKXR7ttiBkH9MHZOVcLHjj9cROGF8mlWMfwwx/jFklGawO2c3I2NHOvyYQhsllTUczFK/w4w9L4Ite+DoSkhueh1K4VzXXHONQ/bbqkTt+PHjPPzww8THxzNx4kSSkpL4v//7P+bPn8/DDz8MwCOPPMKTTz7JF1980a7ALBYLjzzyCGPGjKF/f3WMR0ZGBl5eXoSEhDTYNjo6moyMjCb3M2/ePJ577rl2xdJhFZ2G7P2Ajs5DLodft3Isp5SCsipC/BxT10lozzaRIHKQcw4YMxD2fSvj1OpzYosaqL/rpaVL2Z61XRI1N7bnVCGKAp2CffDvcxls+Qcc+VUKTruIZ555xiH7bVXXZ3x8PJs3b7b9fOutt6IoCmPGjLHd98ADD7B2bfubYmfOnMmePXv47LPP2rWfOXPmUFhYaLvs27ev3bF1GLWtacQNISQimm7h6tJfO08WahiUcCSLYiElKwVQW9ScwlpE+fR25xzP1ZUXQO4h9XbsIKcccki02q2yPVN+B+5sZ+0Y4+QuIdD1AjD6QkkmZO7VNC5Rp6CggHfffZc5c+bYxqpt376dU6faPpawVYnaY489xowZM5g7dy5btmzBYDCwdu3aBtNOy8rKGgz+b4tZs2bxv//9j5UrV9K5c90Ym5iYGKqqqigoKGiwfWZmJjExTS867e3tTVBQkO1iXd7BIxz5Vb1OuASAQV1CgLp/duF+jhUeo6iqCB+DD0nhbZ8O3ipxQ9XrvKNQmuOcY7qyU+qYWkK7g3+EUw5pnd27M3snNZYapxxTON/OkwVAbaJm9Ib4C9UHjqzQLCZRZ9euXfTu3ZuXXnqJV1991ZarfP3118yZM6fN+21VonbHHXewePFifv75Z0aNGkVgYCD3338/Dz74IG+88QbLly/noYceslXjbS1FUZg1axZLlizh119/pXv37g0eHzp0KCaTiRUr6v4oU1NTSU9Pb/Mx3Za5Gg4vV28nTAAguXMIIImaO7N2e/aP6I9Jb3LOQX1DIaJ2TOpJqetkew86D3faIXuF9iLQK5DymnIO5EkRVHe184TaGzKwc7B6R0/1s51Dv2gUkahv9uzZ3HHHHRw6dAgfHx/b/ZMnT2bNmjVt3m+rxqgBTJs2jWnTplFSUsLOnTtJSUkhJSWFjz76iL1791JRUUGnTp2YNm0aAwcOZODAgVx77bUt2vfMmTP55JNP+PbbbwkMDLSNOwsODsbX15fg4GBmzJjB7NmzCQsLIygoiAcffJBRo0Y1OZHAo6VvVBeE9gu3rQ2XbG1RO1mAoijOGWgunMqaqDmt29Oq8wjIOQgnt0Di5c49tqs5uUW9rv2/cwa9Ts+QqCGsPrmabZnb6B/h2Nptwvmyiis4VVCOTgcD4moTtcQrYOkTcHy9Wh7HL0zbID3cli1b+Oc//9no/ri4uGbH0bdEm+uoBQQEMGbMGGbOnMk777zDli1bKC4uZvfu3bz00kv06NGDtWvXct9997V4n2+99RaFhYVcdNFFxMbG2i6ff/65bZsFCxZw1VVXMW3aNMaNG0dMTAxff/11W1+G+0r9Ub3ufTnoDQD06xSEUa8jp6SKk/nlGgYnHGVbptrt5vxETS3/YktSPJXFUvceWN8TJ5Fxau5tV21rWs/IAAJ9alvLQ+Mhqh8oZmlVcwHe3t4UFRU1uv/gwYNERka2eb+tblE7F4PBQL9+/ejXrx+33nprq5/fkkWFfXx8WLRoEYsWLWpLiJ5BUeDAD+rtxCtsd/uYDPSJDWL3qUJ2niygS5ifRgEKR8gozeBUySkMOoMGiVptN9+pbWCuAYNdP1o6jtzDaku20QeinduqZR2ntiNrh7SYu6GU+hMJ6ku8ArL2QuoPUqZDY1OnTmXu3Ln897//BUCn05Gens7jjz/OtGnT2rxfl1qZQNjJmRQoOK7OCKqdSGCV3EVtMpdxau5nS4baktMnrA8BXgHOPXhUH/AJhqoSz17383jtjPfOw8HgpDGCtfqF98PH4EN+ZT7HCo859djC8XacUIuVD+4a0vCBpCvV64M/Q2WJc4MSDbz22muUlJQQFRVFeXk548ePp2fPngQGBvL888+3eb+SqLmj3V+q14mXg5d/g4cGdQkF6s7OhPuwdnsOi3Fulxugdq93Ha3e9uT1B9NqX3u3MefezgFMBhMDItUlvbZlbXP68YXjWCyKretz0Nktap0GqzOMa8oh9SfnBydsgoOD+eWXX/j+++95/fXXmTVrFj/++COrV6/G39///DtohiRq7sZigb1L1Nv9r2/08KDaFrXdpwqpMVucGZlwsK2Z6mzDYdEaJGoA3WoTtTQPTdQURR3UDRDv/EQN6ro/rUm7cA9HsksorqzB12QgMfqsElM6HQyo/azf85XzgxONXHjhhTzwwAP86U9/arCSUltJouZujq+FolPgHQQ9G/+B9IgIINDbSEW1hYOZ0kzuLrLKsjhedBy9Ts/gaCePT7OyJifp68Fi1iYGLeUfg+LToDdBnDbJ8tBotabd1oytLRrzKzqGHbU9IAM6B2M0NPG13b92/NPh5VLLUGMrVqzgqquuIiEhgYSEBK666iqWL1/ern1KouZutn2oXve/Dkw+jR7W63UMrG1Vk+5P97E1Q21NSwxNJMgrSJsgYpLBKxAqCj1znNqx39TruKHgpc1EnUFRgzDqjWSWZXKi+IQmMQj7s67RPPjsbk+rqD5qF6ilGlI+cVpcoqE333yTyy+/nMDAQB5++GEefvhhgoKCmDx5crsmQEqi5k7K8mD/d+rtoXc0u5kUvnU/tm5PLcanWRmM0H2setu6KoYnsVaH13Bhel+jLwMj1PVFN2Vs0iwOYV/Wk+pGEwnqG3K7er39I7UbXjjdCy+8wIIFC/j000956KGHeOihh/jkk09YsGABL7zwQpv3K4maO9n+EZir1EWyOzXf/TWoXuFb4R40H59mZZ1lbF1n1lNYzHB0lXq7diUQrYyIVQvtbjnj4TXt3ERZVQ2pGWptLutksCYNuB5M/uo6s8dWOyk6UV9BQQGXX9644Pdll11GYWHb19iWRM1d1FTBprfV2yPuPeem1kTtYGYxpZWyLmBHl1Oew7HCY+jQ2cYoacaaqKVv9KxSAae2q12+PsHnPElyhhExaqK2OWOzjFNzA7tOFmJRIDbYh5jgxsNZbLwDYdAt6u11rzsnONHA1KlTWbJkSaP7v/32W6666qo279dDq1K6od1fQPEZCIyFgTeec9OoIB9ig304U1jB7lOFXNAj3ElBCkew1k9LDEsk2DtY22DCekBIN7WO37E1kDRZ23icxdrt2eMizYv9Jkcm423wJrcil2OFx+gR0kPTeET7WLs9G5XlaMqombD1PfXvMWM3xAxwaGyiob59+/L888+zatUq2/rjGzduZN26dfzhD3/g9dfrEuiHHnqoxfuVRM0d1FTC6pfU2xfcD0bv8z5lUJcQzhRmkHKiQBK1Dm7jmY0AjIwZqXEkqKUCek+Czf9SlzHzlETNuhJIr8u0jQPwMngxKHIQmzI2sTljsyRqHVxK7USCFiVqYd2h7zWw92tY+QLc/KkjQxNnee+99wgNDWXfvn3s27fPdn9ISAjvvfee7WedTieJmsfZ8p7aghEQA8PvbtFTBnUJ4ac9GexIz3dwcMKRFEVh42k1Ubug0wUaR1Mr6craRO0ndexW7VqzbqsgXZ3lqtND7yvOv70TDI8ZbkvUfpf0O63DEe1QtyLBOcan1Xfxn2Hft+qJUto6zWr6eaJjxxyzIoiMUevoik7DqhfV2xfPabQSQXOGdFP/6benF8g4lg7sZPFJTpeexqg32oqdaq7bGHWsVlkOnPCAmYfW1rSuo8HfNVqnbRMKMrZgUaSwdUd1prCczKJKDHodA+JaOKwhohcMma7e/vExdfyy0ITZbCYlJYX8/PY1iEii1pEpCnz/CFQWQqchMOj3LX7qgLhgTAYd2cWVnMwvd1yMwqE2ZqitacmRyfiZtKnd1YjBBL1rZz7t+07bWJxh//fqtXXNRRfQP7w/vkZfCioLOJR/SOtwRBtZuz0TowPx9WpFy/QlfwG/cHWx9jUvOyY40cgjjzxi6+I0m82MGzeOIUOG0KVLF1atWtXm/Uqi1pGtehEOLQODF1zzZqsGMfuYDPTtpJ6hbZfuzw5r0xm1xWpkrAuMT6uv37Xq9d6vwezGM4sLTtSubaqDvlO1jsbGZDDZSrVsOL1B42hEW+1oSf20pvhHwORX1dtrXoX9/7NrXKJpX375JcnJyQB8//33pKWlceDAAR599FGefPLJNu9XErWOSFHgt9dgdW2X55WvqZWpW2lo7ZiHbcclUeuILIrFlqhdEOsi49OsEiaAbxiUZLp3Tafd/1Wv4y+E4M7axnKW0Z3UtVfXn16vcSSirVo1keBs/a+D4fcACnw1Q5I1J8jJySEmJgaAH3/8kRtuuIHevXtz1113sXv37jbvVxK1jqK6AvLT1H+2D6fAirnq/eP+VDceoZWGdAsBpEWtozqYf5CCygL8jH70j+ivdTgNGb3ULwqAXZ9rG4ujKArsqk3UBt6kbSxNGNVJLQ+wLXMbFTUVGkcjWqvabGH3KbVIaqtb1KwufxESJ0NNBXx+K3z9f2ph5sJTYK62W6xCFR0dzb59+zCbzSxdupRLL70UgLKyMgyGtk+qklmfWqoqg7Jc9VKeB6W5agtESQYUn3VdcVZVY4M3THoeRtzT5sMPrZ1QsP9MMWVVNfh5yZ9DR2JtTRsWMwyT3qRxNE1Ivhm2vAt7v1G/MPzCtI7IvtI3QPYBMPq6VLenVY/gHkT5RZFVlsX2rO22FjbRMew/U0R5tZlgXxM9IgLathODEW78Nyz7M2z+J+z6TL1Y+YWr1QICoyGg3sX6s2+Y+n/rG6aefIlzuvPOO7nxxhuJjY1Fp9MxceJEADZt2kRSUlKb9yvfzG2hKGCpgepy9VJVApVFUFkMFbXXlcV191UWQ0VBXVJWlqdet/Ys1+ANofFqUc1RMyG0W7teRmywr63w7c4ThYxKcI0Za6Jl1p1aB7hgt6dV3FCITYYzO9XlzS58ROuI7Gvzv9TrgTeqs1xdjE6nY3Sn0Xxz+Bs2nN4giVoHszVN7ekY2i0UvV7X9h0ZjDD5ZUi+CTa/o46pLDqtfodZv5Oy9p5/P14BtYlbaMMEzjdEXRXBK0C9tt0OAO+guttGX9C7dyfes88+S//+/Tlx4gQ33HAD3t5qTVODwcATTzzR5v16bqL23UMQ5qvWeVLMoFjqblss6nVNpZpM1VSoXY81FbX3lavb24PBSz2r8QsH39Das5mYpq99gtWConY0pFsoP+w6w/b0fEnUOpCy6jLb+p4Xxl2ocTTN0OnU5cy+nanW+hs1U50R6g4KT9XN9mxHq7aj1U/URMdiHTts7flot7ihcG3tEnMWi9qLU5IJxRlQklWvB8d6yVK3Kc9Xv++qStRLYXrbYzB4gdGn7troXXtd7369Qa1JqKu91hvUzxKdAfJcv0LB9ddf3+i+22+/vV379NxE7fAvEGSP7F5XdxbR4BLU8NonuC4h8wuru/YKsHvy1RpDutYmajKhoEPZkrGFaks1cQFxxAfFax1O8/pPg+XPqh/uuz6HwS0vIePS1i5QWyS6XejSy/RYZwOn5qeSU55DhG+ExhGJllAUha3H8wA7Jmr16fXqzFD/CIjud+5tLRa1R6g8X+0NKs9reF1RWNurVNt7ZLtdUneb2lqd5ir10lZFrlcT8PXXX+fee+/Fx8enwRJRTWnNagT1eW6idvFTEBNem60bGmbx+tpra8Zv8q3N/H3rzgBMPrVnAN4dujl3qK3wbT6KoqDTMGkULbf21FpAbU1z6d+ZyRfGPAw//wVWv6wOuu/orWqFp2D7h+rtix7XNpbzCPMJo09YH/bn7WfD6Q1MSZiidUiiBU4VqIVujXodyZ1DtA1Gr69tXAiD8ITWP99igeqyut6pmsq63ipzVb37KtTivIrlrF4u688KZOTAgj/b/zW2w4IFC7j11lvx8fFhwYIFzW7X2mWj6vPcRG3wLdDZtabTa6FvbBDeRj35ZdUcyymlR2QbB60Kp1EUxZaojenUAZaHGXYXrPu7uszZxrdgTNs+rFzGL0+pXzDdLoTu47SO5rxGdxrN/rz9rD+9XhK1DsLa7dmvU1DrCt26Ir2+dryaHb5bTp4EXCtRq79slCwhJRzCy6hnYGdr4dsCbYMRLZJenM7JkpOY9CbXK3TbFC9/mPisenvVPMg/rmk47XJ4Oez5Sm19v/wFraNpEesYxnWn1mG2mDWORrRE3fg0N5spLdrEc1vUhM2QrqFsSctn2/F8rh8qrYyuztqaNiR6iOssG3U+ybfAjv9A+nr44na4c6k6fKAjKTwFS+5Tb4+4V53R2gEkRyUTaAokvzKfvbl7GRg5UOuQxHnUn/EpXNvs2bNbvO38+fPbdAxJ1IRtgfYdUvi2Q/jt1G8AXNjJRWd7NkWvh2vfgn9dBKd3wJd3wfXvd5xkrTgD/nMDlGZDdH+Y8IzWEbWYSW9iVKdR/Hz8Z3479Zskai6upLKGAxlFAAyLl0TN1e3YsaPBz9u3b6empobExEQADh48iMFgYOjQoW0+hnR9CobULiWVmllMUYVUq3ZlFTUVbM1w8bIczQmNh+s/UCfgpP4A705US1wUnlJnlFVXqAOGtaYoan3EsjzIOwbbPlQTzKy94B8FN30MXh2kJbPW2M5jAVhzco3GkYjzSUkvwKJA51BfooM6yImMB1u5cqXtMmXKFMaPH8/JkyfZvn0727dv58SJE1x88cVceeWVbT6GtKgJIgO96RrmR3peGTvSCxjfO1LrkEQztmZupdJcSbRfNAkhbZiBpbWEi+H3X6nL2WTuhs/PLtehqzer2vesa596dZUMjWdsW39GaVwT0fZzvdlkthqJ5Q2vmytEHZYAv/8Swro7+l2yO2tSvy93n5TpcHEOLcshHOq1117j559/JjS07ncXGhrK3/72Ny677DL+8Ic/tGm/kqgJQG1iT88rY8uxPEnUXJh1NQKXL8txLt3HwoPb4bf5cGgZ5B2tV0BaUQtK15QDLtAVb/CCqD7Q71oYeZ9abqQDivCNoF94P/bm7mXtqbVc0/MarUMSzbBOJBgmiVqHU1RURHZ2dqP7s7OzKS4ubvN+JVETAIyID+Pr7afYnJandSjiHOrXT+vQ/CPUWZOXv6B2NZqr1eSsuuKs6/J6LV2VZ60g0kQrmWIGdI1b2ZpqfTPWttKZfOuuTb4NW/IM7vMRObbzWPbm7uW3k79JouaizBaFHbWz72XGp/0sWrSIV155hYyMDJKTk3njjTcYMWJEk9u+8847fPTRR+zZsweAoUOH8sILLzS7fX3XXnstd955J6+99ppt+02bNvHYY49x3XXXtTl+9/kUEu0yvLv6oZByooDKGjPexg5eu8cNnSg6QVpRGkadsWOU5Wgpna52CRkvl1wz012MjRvL2zvfZsPpDVRbqjHpO3jhYTeUmlFMSWUNAd5GEmMCtQ7HLXz++efMnj2bt99+m5EjR7Jw4UImTZpEamoqUVFRjbZftWoVN998M6NHj8bHx4eXXnqJyy67jL179xIXF3fOY7399tv88Y9/5JZbbqG6Wh3vbTQamTFjBq+88kqbX4NMJhAA9IjwJyLAi6oaC7tPFmodjmjCmlPqQPAh0UMI9JIPcdE6/cL7EeodSnF1MSlZKVqHI5qwrXZ82uCuIRjasxC7sJk/fz733HMPd955J3379uXtt9/Gz8+P999/v8nt//Of//DAAw8waNAgkpKSePfdd7FYLKxYseK8x/Lz8+PNN98kNzeXHTt2sGPHDvLy8njzzTfx9/dv82twqURtzZo1TJkyhU6dOqHT6fjmm28aPH7HHXeg0+kaXC6//HJtgnUzOp2O4fFqq9qmY9L96YqsM/bGdXb9avjC9Rj0BluXubXEi3AtW2vHp1ln4ov2qaqqYtu2bUycONF2n16vZ+LEiWzYsKFF+ygrK6O6upqwsJZ3Rfv7+zNw4EAGDhzYrgTNyqUStdLSUpKTk1m0aFGz21x++eWcOXPGdvn000+dGKF7syZqW2Scmsspqy5jS8YWoK7UghCtZf3b+e2kJGquRlEUNh1VP3tHdpfxaedSXFxMUVGR7VJZWdnkdjk5OZjNZqKjoxvcHx0dTUZGRouO9fjjj9OpU6cGyZ6zudQYtSuuuIIrrrjinNt4e3sTExPjpIg8y4jaD4dtafmYLYo0vbuQDWfUcUWdAzrTPajjlYcQrmF0p9HodXoOFxzmTMkZYgNitQ5J1DqRV05GUQUmg47B0qJ2Tn379m3w8zPPPMOzzz5r9+O8+OKLfPbZZ6xatQofH+1q2rlUi1pLrFq1iqioKBITE7n//vvJzc095/aVlZUNMu/2TJF1d31igwjwNlJcrzK2cA3WFpBxncd13LIcQnPB3sEkR6pLX0n3p2vZdEz9LhvYOaTjL8TuYPv27aOwsNB2mTNnTpPbRUREYDAYyMzMbHB/ZmbmeRt8Xn31VV588UV+/vlnBg7UdjWPDpWoXX755Xz00UesWLGCl156idWrV3PFFVdgNje/0PC8efMIDg62Xc7OxEUdg15nW05qi4xTcxmKojRI1IRoD+vfkHR/upbNtZ+5I6Tb87wCAwMJCgqyXby9vZvczsvLi6FDhzaYCGCdGDBq1Khm9//yyy/z17/+laVLlzJs2DC7x99aHSpR+93vfsfUqVMZMGAA11xzDf/73//YsmULq1atavY5c+bMaZB579u3z3kBd0AjateW25LmAsVGBQAH8g6QVZ6Fr9GXYTHaf2iIjm1snDpObVPGJirNTY/tEc5nncQl49Psa/bs2bzzzjt8+OGH7N+/n/vvv5/S0lLuvPNOAKZPn96gRe6ll17iqaee4v333yc+Pp6MjAwyMjIoKSnR6iV0rETtbD169CAiIoLDhw83u423t3eDzDswUMoanIt1QsHmtDwUV1h3Udhme46MHYm3oekzRyFaqndob6J8oyivKWdbxjatwxHAmcJy0vPK0Otk6Sh7u+mmm3j11Vd5+umnGTRoECkpKSxdutQ2wSA9PZ0zZ87Ytn/rrbeoqqri+uuvJzY21nZ59dVXtXoJrjWZoLVOnjxJbm4usbEyINZekruE4GXQk11cyfHcMuIj2j+1WLSPtX6adHsKe9DpdIztPJavDn3FmlNrGB03WuuQPJ6127Nfp2ACfaQQsb3NmjWLWbNmNfnY2T1yaWlpjg+olVyqRa2kpISUlBRSUlIAOHbsGCkpKaSnp1NSUsJjjz3Gxo0bSUtLY8WKFVx99dX07NmTSZMmaRu4G/ExGRjYWa0OL8tJaS+vIo/d2buBui4rIdrL+rck49Rcg3R7inNxqURt69atDB48mMGDBwNq3/LgwYN5+umnMRgM7Nq1i6lTp9K7d29mzJjB0KFD+e2335odSCjaxrqclEwo0N66U+tQUEgMTSTGX8rSCPu4oNMFGPVG0ovTOV50XOtwPJ5MJBDn4lJdnxdddNE5x0UtW7bMidF4rhHxYbzFEVmhwAXIagTCEfxN/gyNHsqmM5v47eRvdOvbTeuQPFZOSSWHs9SB6tYxwkLU51ItasI1DIsPxaDXkZ5XxqmCcq3D8Vg1lhrWnV4HSKIm7M/W/Sn11DRl7blIigkk1N9L42iEK5JETTQS6GOif5w6Tm3DkXMXFBaOk5KVQnFVMSHeIQyIGKB1OMLNWJeT2pKxhdLqUo2j8VybpNtTnIckaqJJo3qEA5Koack623NM3BgMeqlULuyre1B3ugZ2pdpSzfrT67UOx2PJ+DRxPpKoiSaNSlATtY1Hc6WemkZsqxHESbensD+dTsdFXS4CYNWJVVqG4rEKy6rZX7tcnyRqojmSqIkmDesWilGv41RBOSfyZJyas50uOc3hgsPodXrGxI3ROhzhpi7ucjGgTlqpsdRoHI3nUQuLQ48If6ICtVv0W7g2SdREk/y9jSR3CQFgw9EcbYPxQKtPrgYgOTKZYO9gjaMR7mpQ1CCCvYMpqCxgZ/ZOrcPxOOuPqJ+t1h4MIZoiiZpoloxT087K9JVAXYuHEI5g1BttXevS/el86w+rn61jekZoHIlwZZKoiWaNrj3L2yDj1JyqqKqILRlbAEnUhOPJODVtZBdXkppZDMAFPaRFTTRPEjXRrCHdQvEy6MksquRYjkzfd5bfTv5GjVJDj+AexAfHax2OcHNj4sZg0ptIK0rjWOExrcPxGBuOqq1pfWODCJP6aeIcJFETzfIxGRjcNQSo+1ARjrfyhNrteUnXSzSORHgCf5M/I2JGAHV/e8Lx1h9Wx6eNlvFp4jwkURPnZB3kKuPUnKPKXGUry3FJF0nUhHNI96fzrT8i49NEy0iiJs7JOqFg49E8GafmBJvObKKspoxI30j6RfTTOhzhIayJWkpWCnkVssavo53IKyM9rwyjXsdwqZ8mzkMSNXFOg7qG4G3UN1g4WDjOryd+BdRJBHqd/HsK54jxj6FPWB8UFNacXKN1OG7P2kOR3CWEAG+jxtEIVyffBOKcvI0GhsWHAnVN9cIxLIrF1vUk49OEs1lnGP+a/qvGkbi/dbX108bI+DTRApKoifManaCOofjtkBS+daTdObvJKc8hwBRgG9wthLNYTw7Wn15PWXWZxtG4L0VRbCe9oxJkfJo4P0nUxHmN6xUJqOt+VpstGkfjvqwtGRfGXYjJYNI4GuFpeof2pmtgVyrNlaw5Jd2fjnI4q4Ts4kq8jXqGdAvROhzRAUiiJs6rX6cgQv1MlFTWkHKiQOtw3JY1UZNuT6EFnU7HxG4TAVh+fLnG0bgva2va8PgwvI0GjaMRHYEkauK89HqdbQq5dH86xtGCo6QVpWHUG7kw7kKtwxEe6tJulwLqIu0VNRUaR+Oe1lnrp/WU8WmiZSRREy1i7f787VC2xpG4p2XHlwEwKnYUgV6BGkcjPFW/8H7E+sdSXlPO+tPrtQ7H7VSbLbbi4aNlfJpoIUnURItc2Ev9UNl5ooDC8mqNo3E/P6f9DMBl8ZdpHInwZPW7P385/ovG0bif7cfzKa6oIczfiwFxwVqHIzoISdREi3QK8SUh0h+LAhuOSPenPR0tPMrhgsMY9UZZhF1oztr9ufrEaqrNclJmT6sOqj0S43pFYNDrNI5GdBSSqIkWG2vr/pREzZ6srWkXxF5AsLecZQttJUcmE+kbSXF1MRvPbNQ6HLey8kAWABclRmkciehIJFETLTa2tvtz9cFsWU7Kjn4+Xtvt2U26PYX29Dq9bebx8nSZ/WkvGYUVHMgoRqeDcb0jtQ5HdCCSqIkWG5UQjpdRz8n8cg7JclJ2cazwGIfyD2HUG6Ush3AZ1pOGX9N/pcZSo3E07mH1QbU1LblzCGH+XhpHIzoSSdREi/l5GbmwtkzHL/syNY7GPUi3p3BFQ6KHEOodSkFlAVsytmgdjltYeUAdn3axdHuKVpJETbTKxD7RgCRq9iLdnsIVGfVGJnSbAMCytGUaR9PxVZstrK2tn3ZRonR7itaRRE20ysQ+6tlgyokCsoqlIGZ7HCs8xsH8gxh10u0pXM8V8VcAapkOmf3ZPlvS8iiprCFcynKINpBETbRKVJAPyV1CAFixP0vbYDo4a7fnyE4jpdtTuJyh0UOJ9I2kqKqIdafXaR1Oh7ZsTwYAFydFoZeyHKKVJFETrXZpbavacun+bBfragSTuk3SOBJt5JdWcTCzmMNZJRzPLSW3pJKKarOmM4oVRaG8ykxWcQVHs0vYeaKAfaeLKKvyvAH1Br2BSfHq3+aPx37UOJqOy2JR+Kk2UZs8IEbjaERHZNQ6ANHxXNo3hld/PsjawzmUVdXg5yV/Rq11MP8gh/IPYdKbPKrb02JR+N/uM7z321F2nixschuTQUeAt5EAHyP+XkYCfYz4mAx4G/V4GfV4GfSYDLW3jert5tooFKCqxkKV2aJe116qzep9pZU1lFaaKamsobiimtIqM2ZL40TRZNAxOiGC+y9K4IIenrNG4+Tuk/l4/8esOrGKsuoy/Ex+WofU4ew4kU9WcSWB3kbbmslCtIZ8w4pW6x0dQJcwX07klbM6NZsrBsRqHVKH88PRHwAY13mcx3R7ZhRWMPu/Kaw/kmu7L8TPBKjJVFmVGYBqs0J+WTX5ZdqNi9LpIKA2SSyvNpNfVs3qg9msPpjN74Z34Zkp/fD1MmgWn7P0j+hPl8AunCg+waoTq5jcY7LWIXU4P+5WW9Mm9InC2+j+fzPC/lwqUVuzZg2vvPIK27Zt48yZMyxZsoRrrrnG9riiKDzzzDO88847FBQUMGbMGN566y169eqlXdAeSKfTMbl/LP9cc5Tvd52WRK2VLIrF1pV0ZY8rNY7GOQ5nFXPbe5s5U1iBr8nAfeMTuHlkF6ICfWzbmC0KpVU1lFbWUFJRQ3HtdUllDeVVZlsrWFWNhUpr65jZQo3Zcs5jW1vdrK1xtpY5ox5fk5qMBXgb8feuu+1rMtjGEimKwrGcUt5de4xPN6fz2ZYTpGYW8/7twwl183pYOp2Oy+Mv553d7/DTsZ8kUWslRVFYWtvtKZ+Toq1cKlErLS0lOTmZu+66i+uuu67R4y+//DKvv/46H374Id27d+epp55i0qRJ7Nu3Dx8fnyb2KBxlSnIn/rnmKCv2Z1FcUU2gj0nrkDqMbZnbyCjNINAUyLjO47QOx+HSc8v43b82kVNSSUKkP+9MH0aPyIBG2xn0OoJ8TAT5mMCFGhl1Oh09IgN44doBXDUglvv/s50d6QXc/sFmPr3nAvy9Xepj1O4md5/MO7vfYe3ptRRWFnpMC7A97DpZyKmCcvy8DIyX1QhEG7nUZIIrrriCv/3tb1x77bWNHlMUhYULF/KXv/yFq6++moEDB/LRRx9x+vRpvvnmG+cH6+H6dQqiR6Q/lTUWft4rkwpaw9rteWn8pXgbvDWOxrGKKqq544PN5JRUkhQTyBf3jW4ySesoRveM4Iv7RhHm78Wuk4U8+OkOLE2MaXMnPUN70iu0FzWWGpYflyWlWuOnerM9fUzS7SnaxqUStXM5duwYGRkZTJw40XZfcHAwI0eOZMOGDc0+r7KykqKiItuluLjYGeG6PZ1Ox9XJcQB8t/O0xtF0HFXmKluR2yu7u3e3p6Io/OmLXRzNKaVTsA8f3jXCLZbO6R0dyHu3D8PbqOfXA1m8tfqI1iE53OTuapfnT8d+0jiSjsNiUfgu5RQAk/tLt6douw6TqGVkqGcm0dHRDe6Pjo62PdaUefPmERwcbLv07dvXoXF6kqmDOgGw9nAOuSWVGkfTMfx28jeKq4qJ8otiWMwwrcNxqM+2nGDp3gxMBh1v/n4o0UHuMzxhcNdQ/npNfwBe+zmVlBMF2gbkYJfHXw7A5ozNZJZKC3pLbDiay+nCCgJ9jEzoI8tGibbrMIlaW82ZM4fCwkLbZd++fVqH5Da6R/gzIC4Ys0Xhxz3NJ8uizg/H1G7Pyd0no9e577/f6YJynv9hPwCPTUpkUG2RZHdy47AuTE3uhEWBx77YSWWNWeuQHKZzYGeGRA1BQeF/R/+ndTgdwlfbTgLqeF7p9hTt0WG+KWJi1EKBmZkNz+YyMzNtjzXF29uboKAg2yUwMNChcXqaqclqq9qS7Sc1jsT1FVUVsfrEagCu6nGVxtE41vM/7KeksobBXUOYcWEPrcNxmOem9iMiwItDWSW8vzZN63Ac6uqeVwPw7ZFvNS1K3BGUVNbYxqddP7SzxtGIjq7DJGrdu3cnJiaGFStW2O4rKipi06ZNjBo1SsPIPNvVgzth1OvYnl5AaoaM/zuX5ceXU2WpomdIT3qH9tY6HIfZdjyPH3afQaeDF64dgMGNl8wJ9ffiz5P7APDmysPkuPEQgMu6XYaPwYdjhcfYnbNb63Bc2o+7z1BebaZHhD+D3bA1WTiXSyVqJSUlpKSkkJKSAqgTCFJSUkhPT0en0/HII4/wt7/9je+++47du3czffp0OnXq1KDWmnCuqEAfLu2rjhv8dHO6xtG4tm8PfwuotdN0OvdMXhRF4a//U7s8bxrWhT6xQRpH5HjXDIpjQFwwxZU1LFx+UOtwHCbAK4CJ3dTJXNa/ZdE0a7fntKGd3fZ/XTiPSyVqW7duZfDgwQwePBiA2bNnM3jwYJ5++mkA/vSnP/Hggw9y7733Mnz4cEpKSli6dKnUUNPYzSO6AvD19pOUV7nvOJ32OFZ4jO1Z29Hr9ExNmKp1OA7z/a4zpJwowM/LwOzL3LfVsD69XseTV6qtap9sSudgpvu2LFu7P39K+4lKs/u2HrZHWk4pm47lodPBtYPjtA5HuAGXStQuuugiFEVpdFm8eDGgloSYO3cuGRkZVFRUsHz5cnr39owvA1d2Yc8IOof6UlRRw4+7z2gdjkv65vA3AIyNG0uUn3vOAKsxW3h56QEA7h+f0GDVAXd3QY9wJvWLxqJgew/c0YiYEcT4x1BcVczKEyu1DsclfbThOADje0fSKcRX42iEO3CpRE10THq9ztaqJt2fjdVYavjuyHcAXNuzcTFnd/HTngxO5pcT7u/F3WPddwJBc/50eRI6HSzfn8X+M0Vah+MQep2eKT2mANL92ZTSyhq+2HoCgDtGx2sbjHAbkqgJu7hhaGcMeh1bj+ez77R7fkm11dpTa8kpzyHMJ8xtl4xSFIV3fzsKwO8v6OYRC5afLSEygMm16zm+tcp9i+Bauz/Xn15PVlmWxtG4lq93nKK4sobuEf6M6yVLRgn7kERN2EVUkA9X9FfLpLxT+4UtVEsOLQFgSo8pmAzuuSbq1uP57DxZiJdRz22jumkdjmbuH58AwP92neZ4bqnG0ThGt6BuDI4ajEWxSE21ehRF4cP1aQBMH9UNvRvPdu5oFi1aRHx8PD4+PowcOZLNmzc3u+3evXuZNm0a8fHx6HQ6Fi5c6LxAmyGJmrCb/xunfkl9t/M0pwrKNY7GNeSU57Dm5BoArul5jbbBOJC1NW3akDgiAtx7/dJz6R8XzEWJkVgUeHu1+56wXJ2gtqotObREaqrVWnc4l8NZJfj/f3t3HhZlvf9//HnPAMMOCgLiAi644II7Lnla3CvL5ZhamVnZyaOezPr1PXZK65zO8VS2nDyWHc9xqU5ulXayMpVEc981FXEDEWURkH0ZZub+/TGKoagIM9wzw/txXfelDPfMvIabm3nP5/4sHnqZO82BrFy5kpkzZzJnzhwOHDhATEwMQ4YMITOz6tbg4uJiWrZsyd///vdbztFal6RQEzbTqWkAfVoGYbaoLN6WpHUch7DuzDpMqonOwZ1p3aC11nHsIjmriA3HrRNRP31XC43TaO/391iP81f7U8nML9U4jX0MbTEUbzdvkvOT2ZexT+s4DuGTrdbL3b/t3hQ/T9dsOXdG7733HpMnT2bSpElER0ezcOFCvL29Wbx4cZX79+zZk3feeYdx48ZhMDjGh04p1IRNPXu3tRP5ij0p5JWUa5xGW6qqsua09bLnyCjXHUSwZHsSqgr3tm1E6xBZ+aNXi4Z0j2iA0Wzh813ntI5jFz7uPjzQ8gEAVieu1jiN9g6kXObnU1m46ZR6OZCmrhUUFJCfn1+xlZVVPVWM0Whk//79DBw4sOI2nU7HwIED2blzZ13FrTUp1IRN3dOmEW1D/SgymvlsZ7LWcTR1+NJhzuadxVPvWbGotavJLTayap91ck95g7rmasvi57tTKC13zbkFx7QZA8DGlI1kl2RrnEZb8+NOATCqWxOaNfTWOI3ri46OJiAgoGKbO3dulftlZWVhNpsJDQ2tdHtoaCjp6c6zPrUUasKmFEVhyj3Wvmr/2nqWvOL626q2/MRywHqZyNfDV+M09vHFnhRKys20b+xP31ZBWsdxGIOjQ2kS6EVOkZFvDl3QOo5dtA9qT6fgTpgsJr45U3+n6jiSmsvmxEvodQpT73XN7g2O5vjx4+Tl5VVss2bN0jqSXUmhJmxueEw4bUP9yC81sXCr605TcCvZJdlsOLcBgHHtxmmcxj6MJkvFKLdn7mohS+X8ipteVzGP1uJtyS7b4f5qq9rqxNVYVIvGabTxYdxpAB7uEk5EkI/GaeoHPz8//P39K7ab9SULDg5Gr9eTkZFR6faMjAyHGShQHVKoCZvT6xReGtIWsPZfctUO1bfy9amvMVmsgwg6BHXQOo5drDtykYz8MkL8DAyPCdc6jsN5pGczvD30JGYUsP20a14aHNpiKH7ufqQWprLr4i6t49S5PUk5bErIQKcgrWkOyMPDg+7duxMXF1dxm8ViIS4ujj59+miY7M5IoSbsYmD7ELo1D6S03MKHP53SOk6dMlvMrDq5CoCx7cZqnMY+VFVl0c/Wkb0T+0bi4SZ/Sq4X4OXOmCvTNCze7pqjoL3cvBjeyrpSweqT9WtQgcWi8ud1xwDresetGrlm9wZnN3PmTBYtWsSyZctISEhgypQpFBUVMWnSJACeeOKJSpdOjUYjhw4d4tChQxiNRi5cuMChQ4c4ffq0Vi9BCjVhH4qi8PLQdgAs33OeE+n1Z7WCLalbSC9KJ9AQyJDIIVrHsYudZ7JJSMvHy13PY7HNtY7jsJ7s1wJFgZ9OZHL2UqHWcezi6uXPzec316uVCr46kMrRC/n4GdyYOUjWnHZUY8eOZd68ecyePZsuXbpw6NAh1q9fXzHAICUlhbS0a2tUX7x4ka5du9K1a1fS0tKYN28eXbt25ZlnntHqJUihJuzn6kLVZovKq2uOYrG4Zj+d661MXAlYp+Qw6B1jHh5bu7r6xJgeTQn09tA4jeNqEezDgHYhACzZnqxtGDtp3aA13UK6YVbNfHnyS63j1ImiMhNv/5gIwPQBrQmqx5M8O4Np06Zx7tw5ysrK2L17N7GxsRXfi4+PZ+nSpRVfR0ZGoqrqDVt8fHzdB79CCjVhV3OGd8DbQ8++c5f5cn+q1nHsLjkvmR0Xd6Cg8EibR7SOYxenMwvYnHgJRYGn+skEt7dz9Wf05f5Ulx0FfXXAzMrElZSZq57TypW8u+EklwrKiAjyZqIsvi7sTAo1YVfhgV68MNB6WeBvPySQU2TUOJF9XW1N69+0P039XHMZmf9cWXViUPtQIoNllNvt9GkVRLswP0rKzazYm6J1HLsYGDGQUO9Qckpz+P7s91rHsas9STks2WE9B954qAMGN73GiYSrk0JN2N2T/SJpF+ZHbnE5s785qnUcuykqL+Kb09b5pMa1dc0pObIKy/jqgHVesMm/kQluq0NRFJ66MgHush3JmMyuN42Fu86dR9s/CsBnCZ+57HQkJUYzL395GFWFR3o05Z62IVpHEvWAFGrC7tz1Ot4a3Rm9TmHdkTS+PXxR60h28dXJrygoLyDSP5J+TfppHcculm5PxmiyENMskB4RDbSO4zQeigkn2NeDi3mlrD/mPDOi34nRUaPxcvPi1OVT7E7frXUcu5i3IZHk7GLC/D350wPRWscR9YQUaqJOxDQLrJhn6LVvjpLhYnOrlVvK+TzhcwAmdpiITnG9U6ugtJxPrywLNuXuVjLB7R3wdNfzWGwEAIu3ueZUHQGGAB5u9TAAnx3/TOM0trc3OadimpW5ozoR4CULr4u64XrvJsJhTb+vNR2b+JNbXM7/fXXEpS6PbEzeSFpRGg09G1bMK+Vqlu9JIb/URMtGPgyODr39HUQlj/eOwEOv40BKLnuTc7SOYxePRz+OgsLW1K0k5blOQVpsNPHyl0dQVfht96bc204ueYq6I4WaqDPueh3vP9IFDzcd8YmXWLH3vNaRbEJVVZYeWwrAo+0edckpOcpM5opBBM/d3QqdTlrT7lQjPwOjuzcB4J8/aTd5pj1F+Edwd9O7Afhvwn81TmM7f1l3nKSsIsL8PXntQbnkKeqWFGqiTkWF+vH/BluXl7r6x8/Z7UnfQ0JOAp56T8a2dc2VCNYevEBGfhlh/p6M6NJE6zhO67m7W6FTYMvJSxy9kKd1HLuYED0BgG9Of0Nuaa62YWxg/dF0lu85j6LAe4/EyCVPUeekUBN17qm7WtC7ZUOKjWamLz+A0eTco+CWHFsCwIjWIwj0DNQ2jB2YLSqfbLFOcPtM/xayXFQtRAT58NCVdVEXbHbNVrWeYT1p37A9peZSvjjxhdZxaiUjv5Q/fn0EgGd/05K+rYM1TiTqI/mLK+qcXqfw/tguBHq7c/RCPu/8eELrSDV26vIptl/Yjk7R8UT0E1rHsYsNx9I5m1VEgJc743vJclG1NeUe66Ca9cfSOZ1ZoHEa21MUhWc6WZfb+TzhcwqNzrl0lsWiMnPVIXKLy+nYxJ8XB7XVOpKop6RQE5poHODFO7+NAWDRz0lsTnTONQKXHLW2pg1oPoBm/s00TmN7qqoy/0p/qif6ROBjcNM4kfNrG+bH4OhQVBU+2nxG6zh2MTBiIC0DWlJgLGBF4gqt49TIop/Psv10Np7uOj4Y21VakoVm5DdPaGZQdCgT+1inLHhp1WEyC5xryo6U/BS+T7LOwv50x6c1TmMfPx7L4HhaPr4GN1kuyoauTlXzzeGLnM8p1jiN7ekUXUWr2qfHPqW43Lle477knIq1PGc/2IHWIb4aJxL1mRRqQlOz7m9PuzA/souMPL/8kFPN2r7ol0WYVTP9m/SnQ3AHrePYnMWi8sGmkwBM6hdJAx9ZfN1WYpoF0j8qGLNF5aN41+yrNqzFMJr6NuVy2WWnWqw9u7CMaV8cxGxRGR4TzvhertdSLpyLFGpCU57uev75aFe8PfTsPJvNextPah2pWlILUvn2zLcA/C7mdxqnsY/1x9I5kV6An8GNZ+6S5aJs7Q8DogBYvS+Vc9nOP/r5em46t4pWtaXHljrFYu0Wi8oLqw6Tnl9Ky0Y+zB3VSSZ2FpqTQk1ornWIH2+N7gzAR/Fn2OAES+z8+5d/Y1bN9A3vS0yjGK3j2Fyl1rS7WhDgLVMS2FrPyIb8pk0jTBaVDzad0jqOXTzU6iFCvUO5VHKJtafWah3nthZsPs3Wk5fwdNfx8WPd8ZU+mcIBSKEmHMLwmHAm9YsE4MXVh0l24PnVUgtS+eaMdfH152Ke0ziNfXz3SxonMwrx83Tj6bukb5q9vDS4DQBrD13gZIbrjQB117vzVMenAPj30X9jNBs1TnRzP5+6xPtXPpy8OaITbcP8NE4khJUUasJhzBrWnu4RDSgoNfHc5/spMZq1jlSljw59hMlionfj3nQN6ap1HJszW1T+EWdt4XnmrpYywacddW4ayJAO1hGg721wjsv+d2pU1ChCvENIL0pnVeIqreNU6Vx2EdO+OIhFhbE9mvHb7k21jiREBSnUhMPwcNOx4NFuBPt6cCK9gJe+POxw64GeunyKdWfXAfB8t+c1TmMfaw5e4HRmIf6ebky6K1LrOC7vxcFtURRrn8BfUl1vtQJPN8+KludFvyyiqNyxWssLy0xM/nQfeSXldGkWyJ9HuN7AIOHcnKpQe/3111EUpdLWrl07rWMJGwoL8OSjx7rjrlf47kgaH8Y51oi4+Qfno6IyKGIQHYM7ah3H5krLzby7wTotwdR7W+PvKa1p9tYm1I+Hr6xWMO/Kz97VjGg9guZ+zckpzeGz459pHaeCxaIyc+UhTmYUEuJn4JMJ3TG46bWOJUQlTlWoAXTo0IG0tLSKbdu2bVpHEjbWq0VD3hxhLYLe33SS746kaZzI6silI2w+vxmdomNal2lax7GLxduTSMsrpUmgFxP7Rmodp96YMbANep3ClpOX2HkmW+s4Nueuc2daV+s5s+zYModZA/QfcafYcDwDD72OTyZ0J9TfU+tIQtzA6Qo1Nzc3wsLCKrbgYFl7zRWN7dm8YoLVF1cf0nwBa1VVeXffu4B1JFvLQNebriKnyMjHV2bKf3FwGzzdpWWhrkQG+1TM1/Xmd8exWBzrkr8tDIkcQruG7SgsL+STI59oHYc1B1Mr+mK+ObIjXZs30DiREFVzukLt1KlThIeH07JlSx577DFSUlJuuX9ZWRn5+fkVW0GB642sclWv3N+Ou9s0orTcwtPL9nIht0SzLBvObeBA5gE89Z5M7TJVsxz2NP+nUxSUmWjf2J8RXZpoHafemTGwDX4GN45dzOfrgxe0jmNzOkXHC91fAGDFiRUk5SVplmXHmSxe/vLaYuuP9JBJbYXjcqpCLTY2lqVLl7J+/Xo+/vhjkpKS6N+//y2Lr7lz5xIQEFCxRUdH12FiURtueh3zH+1KVIgvGfllTFy8h9ziuh/eX2Yu4/397wPwVMenCPMJq/MM9nYuu4jPd50DrAWyTieTfNa1YF8DU++zLi0178dEio0mjRPZXt/wvtzT9B5Mqqmihbquncoo4Hef7afcrPJAp8b8caj0cxaOzakKtWHDhjFmzBg6d+7MkCFD+P7778nNzWXVqpsP+Z41axZ5eXkV2/Hjx+swsagtf093lj3VizB/T05nFjL5032UltfttB2fHf+MC4UXCPEOYWKHiXX63HXlL+sSKDer9I8Kpn9UI63j1FtP9o2kaQMv0vNLWbRVuxYne3qxx4u4KW5sSd3Cjos76vS5MwtKeXLJXgpKTXSPaMC7j8TIhxLh8JyqULteYGAgbdq04fTpm48MNBgM+Pv7V2x+fjKJobMJD/Ri6VM98fN0Y2/yZWasOIS5jvrwZBRlsOjIIgBmdJuBt7t3nTxvXdqcmMmmhAzcdAqzH5QWZy15uuv54zBrC8/CLWdIy9Pucr+9RAZEMq7dOADe3vM25ebyOnnevOJynvjPHi7kltAi2IdFT/SQfpjCKTh1oVZYWMiZM2do3Lix1lGEnbUL8+dfE3rgodex/lg6r649WidzrL29922KTcV0btSZB1o+YPfnq2tlJjN//tbayvxk30iiQuWDjNYe6NSYHhENKCk385d1rnkF4LmY52jo2ZAzeWf49Pindn++ojITTy7dw4n0AoJ9DSx5sicNfTzs/rxC2IJTFWovvfQSW7ZsITk5mR07djBy5Ej0ej3jx4/XOpqoA31aBfH+2C4oCizfk8Kf1x23a7G27cI2NpzbgF7RM7v3bHSKU50u1bJ4WzJJWUUE+xp4fmCU1nEEoCgKfxnREb1O4ftf0tly8pLWkWwuwBDAiz1eBGDh4YVcKLTf4InScjPPfraPgym5BHi58/kzvYgM9rHb8wlha071zpOamsr48eNp27YtjzzyCEFBQezatYtGjaRPTX3xQOfGvH1lAfcl25N5a32iXYq1UlMpf931VwAebf8obRu2tflzaC0tr4T5P1mnJ5g1rB1+Mrmtw2jf2J8nr8xjN+ebo3XeL7MuDG85nB6hPSg1lzJ391y7nMflZgvTlx9k++lsvD30LJ3Uk3Zh/jZ/HiHsyakKtRUrVnDx4kXKyspITU1lxYoVtGrVSutYoo6N6dGMv1yZEHfhljMVcyHZ0sLDC0ktTCXEO8Qlp+NQVZXX1h6l2Gime0QDRnaV6TgczYyBUYT4GUjOLuaTLWe1jmNziqLwWu/XcNNZBxZsPLfRpo9vNFmY9sUBNh7PwMNNx78n9pC50oRTcqpCTYirJvSO4NUH2gPwwaZTvL/xpM0+kf9y6ReWHFsCwCuxr+Dj7nqXSb77JY1NCZm46xXmjuokI98ckJ+nO69dGdyxIP40Zy4VapzI9loGtuSpjk8B8OauN8kusc2qDGUmM7//735+PGZddWDh493o20omRxfOSQo14bSe6d+S/7syB9I/4k7x1+8Sal2slZnL+NP2P2FRLdzf4n4GNB9gi6gOJbfYyOv/OwbAlHta00YGEDisBzs35jdtGmE0Wfh/qw/X2WjnuvS7zr8jqkEUl8su89fdf631OVxabubZT/ezKSETg5uORRN7cF+7UBulFaLuSaEmnNqUe1oxZ7i11eHf25J4Zc0vtXozW3BwAUl5SQR7BTOr1yxbxXQof/0ugaxCI61DfJl6r3QdcGSKovD3UZ3wNbhxICWX/2xzvUugHnoP3uz3Jm6KGxvPbWR98voaP1ZhmYmnl+1ly8lLeLnrWfJkT+5uI32YhXOTQk04vUn9WvD26M7oFFi+5zwzVh6izHTnna93XtzJ0mNLAZjdezaBnoG2DeoANp/IZPX+VBQF3hrdCYObzCPl6MIDvSou88/bcJLTma53CTQ6KJrJnScD8Jddf6nRKNDMglLGfrKz0sCBvq3lcqdwflKoCZfwSM9m/GNcV9x0Ct8evsgT/7mz5aaySrKY9fMsVFRGR43m3ub32jGtNjLzS3lp9WHAOmda94iGGicS1TW2Z7Nrl0C/dM1LoJM7T6ZzcGcKjAW8vPVlyi3Vnwj3zKVCRn20g2MX8wn29WDFs72JbRlkx7RC1B0p1ITLGB4TzuIne+JrcGN3Ug6jPt7Bueyi297Polr407Y/kV2aTevA1vxfr/+rg7R1y2JRmbnqMNlFRto39q/o2yecw9VLoH4GNw6m5PLexkStI9mcu86dt+9+Gz93P45cOsI/D/6zWvfbfy6H3368g9TLJUQGefPVlL50bhpo37BC1CEp1IRL+U2bRnw5pQ/hAZ6cvVTEyI92sP9czi3v88nhT9hxcQeeek/m3T0PLzevOkpbdz7ecoZtp7PwdNcxf3wXWTrHCYUHevHXUZ0AWLD5DBuOpWucyPaa+DbhjX5vALD46GI2p2y+5f4r96Yw/l+7uVxcTkzTAL6c0peIINcbpS3qNynUhMtpF+bPmqn96NjEn5wiI+P+tYtlO5KrHE226dwmPjr8EQB/6v0nWgW6Xuf6H4+lM2+DtQVmzvAOtA6RUZ7O6qGYcCb1iwTgxVWHOeuCU3YMihjEo+0eBeCPP/+R05dvXMu53GzhtbVH+b+vfsFotjC0QxjLn+1NsK+hruMKYXdSqAmXFOrvyarf9eH+TmGUm1Xm/O8YL6w8RLHRVLFPYk4ir2x7BYDH2z/OiNYjNEprP0cv5DFjxSFUFR7v3ZxxPZtpHUnU0iv3t6dHRAMKykw8tXQvlwrKtI5kcy/1fIleYb0oNhUz/afp5JbmVnwvs6CUx/69m892nUNR4MVBbfjosW54e7hpF1gIO5JCTbgsbw83FjzajVcfaI9ep7D20EVGLtjB6cwC0ovSmfbTNEpMJfRp3Kdi3UFXkpxVxNPL9lJSbqZ/VDCvD++AosjEts7OXa/jo8e60bSBF8nZxTy5ZA/5pdXveO8M3HXuvHv3uzTxbUJqYSrPb36eElMJcQkZDP3gZ/Yk5eBrcGPRhB5MHxAlEzYLl6ao9lzV2gGlpqbSrFkzzp8/T9OmTbWOI+rI7rPZTFt+kEsFZXh4lBDW7j9cLk8l0j+Sz+//nABDgNYRbSo5q4jxi3aRlldKm1BfVj/XlwAvWcvTlSRlFTFm4Q6yCo30atGQJU/2xMfgWq1Kpy6fYuIPEykoLyDMrRunfhkN6Gnf2J/547vSOsRX64iiDtXX929pURP1QmzLIL6bfhd3tfHFLdxapLmpDfhz7IcuV6SduVRYUaS1DvHlv8/0liLNBbUI9mHppF74GdzYk5TDo4t2kVNU/SlpnEFUgyj+0PFvoLqTbjqAZ/iXTOobwdqpfaVIE/WGFGquxGKxbqJKBkMZ5pCF6L1SUc3e5J2dxIRPTvKfbUmYzK7xc9t+OouRC7ZXFGnLJ/emkZ/GHaxNptvv46w0fm0dmwTw2TOxNPB253BqHr9duIPzOcWaZrKVwjITr//vGLOWF1Gc+hioOtwDDlIc+Bk6nWucr3bhyudbPSWFmqswm+Hrr2H1ajlRq5BVksWT65/kaPZRAg2BfHD3R3QJa0NhmYm/rDvOg/O3sS/51tN4ODJVVVm2I5knFu8hv9REt+aBrHjWAYq0w4dhwQLIytI2hz2cPg0ffgipqZrG6NIskNXPXZuS5sH524hLyNA0U22oqsr6o2kMem8LS3cko6rwcJsBvN7nb7gpbnyf9D0vxr+I0exarYc2UVgI//43bN0K9atXk0uTPmquoLwcVq2yvnEAtGwJY8eCh4e2uRzEycsn+cNPf+BC4QUaeTXiX4P+ResGrbFYVFbuO89b60+QW2ztjD2iSzgvDGrjVHMxZeaX8vJXR4hPvARYX8PfR3fWfq60PXvghx+s//f2hscfh8aNtc1kK8ePw1dfWVuw3d1h3DjreaehtLwSnvv8AIfP5wIwuX8LZg5qi5eH88yZty85h7k/nGD/ucsANG/ozd9GduKuKOtSUFvOb2Fm/EyMFiPdQrrx3j3vEeQlKxAAkJsLn30GOVc+cPbpA4MGgQsNIHLJ9+9qkELN2ZWVwRdfQEpK5dubNoVHHwUv15u89U5sOreJV7a9QomphKa+TfnXoH/RzL/yFBU5RUbeXn+CFXvPA6DXKTzSoynT74siPNBxf37lZgsr9qTw7saT5BaX4+Gm4+UhbXn6rhbaju5UVfj5Z9h83WSlBoP1d7J5c21y2crBg/Dtt5VbLPR6+O1voZ22Kz4YTRb+9n0CS3ckA9C0gRd/ebgj97YL0TTX7SSk5fPBppP8eMzaEujlrmdy/xZMuaf1DYXm7rTdzNg8g8LyQsJ8wvjHvf8gOihai9iOIyvLWqTl51e+vWtXePBB0LnGxTOXe/+uJinUnFlxMXz+OaSlVf390FBrK4Zv/et0W1xezHv732Nl4koAYhvHMu8382650PrRC3nM25BY0TLl4aZjZJcmPNkvkvaN/esidrUYTRZ+OJrGP+JOcfaSdYmsDuH+vD+2C21CNZ7MVlVh0ybYsaPq77u5WVt7W7eu21y2smsX/Phj1d9TFHj4YYiJqdtMVYhLyGD2N8e4kFsCQK8WDfnDfVH0ax3kMFO0qKrKzjPZLNx6lq0nreecTrGuazpjYBtC/T1vet+zeWd5/qfnSc5PxkPnwR+6/YHH2z+OXuc8rYc2k55uLdKKb9I3sUMHGDnS+mHCybnU+/cdkELNWeXnW0/O2/X9adgQnngCAlxrZOOt7ErbxRs73iC10Np3aEL0BGZ2n4mbrnpTF+xNzmHej4nsTrrWZ613y4ZM7BPJfe1DMLhp8wcvI7+U5XtS+GJ3CplXJjlt6OPBCwOjGNerOe56jT81Wyzw3Xdw4MCt99PpYPRoiHaiVhBVhS1brNvtDBsGvXrZP9NtFJWZ+EfcKZZuT8Z4ZbBMdGN/xvdqxsNdm+Dvqc1I4NxiI98evsiKvec5dtHaAqRTYFinxjw/IKraHzbyjfnM+nkWW1O3AtAtpBuz+8x2ydVFbiolxXpFpew2kx63bg2PPGK9TO/EXOb9+w5JoeaMcnKsRVpubvX29/eHCRMgONiusbSWmJPI+wfeZ/uF7QCE+YTx575/pk94nzt+LFVV2X/uMkt2JLP+aDpmi/U08fd0Y2jHMIbHhNOnZRBudi6OcoqMrD+azreHL7IrKbvialsjPwOPx0Yw6a5Izd5wKzGbYc0aOHasevsrCgwfbr004+hU1dqKtnt39e9z331w110O0T8oLa+ET7acZfmeFMpM1oLN013HgPahDOkQxr1tG+Fn59+hgtJytp/O4n+HL7LpeGZF4ejprmNsj2Y8fVdLmgd53/HjqqrKV6e+4p2971BsKkan6BjZeiRTYqYQ6hNq65fhWM6cgZUrrX2UqyMiAsaPt3ZBcFI1ff9esGAB77zzDunp6cTExDB//nx63eLD1OrVq3nttddITk4mKiqKt956i/vvv98WL6FGpFBzNpmZ1iKt8A7X+PP2thZrYWH2yaWRMnMZ8efjWZ24mt3p1jdSN8WNMW3HML3rdPw8an8p8GJuCZ/tOsfXB1LJyL/2ydXP043eLYPo2yqIPq2CiArxQ1/LGdILy0wcTLnMttNZ7DidzdGLeZW6QvWMbMCEPpEM7RCGh5uD9DspL7eONj516s7vO2QI9O5t+0y2YrFY+6MdOnTn9+3bFwYOdIhiDeBykZE1By+wYm8KJzOu/f3w0Ovo3SqI2BYN6RHRgJhmgbUeiFJsNHH8Yj77zl0mPjGTfcmXMVmu/SJHN/bnt92bMqJrExr61H7Q04XCC7y9521+Ov8TAG46NwY0H8CYNmPoEdrD9S6J/nowy51o3NjaHcb7zotiR1CT9++VK1fyxBNPsHDhQmJjY/nggw9YvXo1iYmJhITc2Hdzx44d/OY3v2Hu3Lk8+OCDfPHFF7z11lscOHCAjh072volVUu9LdT2Je4jLPzWRUt1fzQq1fwRVnu3W+z43/9WjOqp7vNW7BUYAI9PqNnzAqRngL8fqvcddLC/+pDFxZCfB2FVj/qrzmv56CMwK6UUuaVS4J5Cluc+sgwHMOtKrzyIjqbFg+h4+Q/4mmzfYV1VVTIsOZw1XyTZnEYZlT/J6tERqPgSqPMjUPHFSzHgqRjwVDxwx42rPwwVMKrllFBGiVpGsVrKZUsBl9UCCtWSG563oeLP5CHhPNi5Mc0aXvkDe+JEzTquqyokJtq203t8fPUuCd7Ms8/ecjRoOunEEYeRytMxeOHFIAYRxK1H/R3jGHvYc8PtjWjEIAZh4BYtDAcOWAu1mho3Dtq2rfn9r2eD466qKkdS81h/LJ3/bkknXy2qtKsOhUDFD3+dD/6KD/6KN56KBx6446644YYeCxYsqJixUKoaKVJLKFJLKVJLyLbkkacW3nBG+ys+NNOH0ErfhCCdfbpiZBkOcrTBB2R5Xrv87m72J6Q0lqCyLviWN8PbFI4Od/4wTY9O0aFTdCjcYTGdnGwdsOVWg5UgMjOtg7z8avghsrQUPvmk5tNvtG9v/YDkhNLT0unepvsdFWqxsbH07NmTf/7znwBYLBaaNWvG9OnT+eMf/3jD/mPHjqWoqIh169ZV3Na7d2+6dOnCwoULbfNC7pBrrTdyByb8NAG9lxN+yvK+stXU2lW2SlL3mlR9s5cphMjCkbQoGI232X7TPyiKQpg+iDB9EL3VjuSoeaSZs0mzZJNhycGEmWw1n2xz/u0f7BZ8FC8a64II1wXRWB+Mt+LJlHuu22nNGhg8GLp3r/4Dqyps3Ajnztm2UKvtvH1mc5U3q6jsYhdxxGGm6n3OcpZBDKIHPW54sy2jjB/4gcMcrvK+KaRwmtOMYASRRN5Rtmqz9ZyGX35pHcXXpUv176Oq1mlSMjKgXTsURSGmWSAxzQIp2dWWPLWQi5YsMiyXyTDnUEIZOWo+ObX8PfbCQLAugHB9ME11Ifjr7D/lTXBZV+5JX0auxwnO+q7mvO8PlOvzueCzkQs+Gyvtu2FNLZ9sfy3vXxu1uRhU+AN89Z7NotQlc4n1fCwoKCD/VyNcDQYDhiou6RqNRvbv38+sWbMqbtPpdAwcOJCdO3dW+Rw7d+5k5syZlW4bMmQIa9eutcErqJl6W6gZ9Abc9Ld/+bYeIVXdT243fV6jsdInqeqmsz6vcvv+Cbd6QLMZjOWgKCgGQ/Uu6agqStmVzB7ut/wEerufTXEx6FR3vE3h+JqaEmiMJrSkL/7lre78E3Et6RSFYCWQYF0gnWiFRVUpUIvJVQu4bCkgXy2iVDVSqpZRghGTaq6U0ENxt7a44YG3YiBA50dDxY9AnR+eSjUuBakqrFtn/XTdr9/t97dYrPsfPAjh4TV+3XWlgALWspaznL3lfuWU8z3fk0giD/EQ/lhH56aSytd8zWUu3/L+eeSxjGX0oQ/3cR9ujv4n0WKBb76xdh6Pja3+/keOVDktiqJYW88CdX5E0wJVVSlUS8hVrb/DeZYiCtRiytRyjJRTrpowYUaPDh069IoOD9zxUTzxUbzwUTwJ1PkRrAvAW7n5qE17CzS2o1vOa3TJmcVlw1EyPHeS53GKIrdUStwysFCOh6cFi2qp9pWTSsxm689WUcBNT7X+EqsWMF0p/N3canFJXIXyWnwA0ClQjfc+R1Sus17FiL5uINKcOXN4/fXXb9g/KysLs9lMaGjl/oqhoaGcOHGiyudIT0+vcv/09PRaJK8d5zxaNvDtsG+ds4/ahx/C5Vu/+dyUvz+88ELNn/vwYbj6qaI6E5imp1unDym6cmnloYdq1Xn8jTdqfFe70ykKAYoPAfgQoa/DfoCbNlnftO+99+Z/+K+uWnH8eJXfVlErFbrXf13XTnCC//E/SrjxMvDNnOEMH/Mx93M/OeSwhS3V75IA7GQnpznNKEYRhnb9OKt9LNavtx73/v1vftxNJmsLXGJitZ9fURT8FG/8atVs7zh0uBFU1oWgsi43fG/OnFo88Pffw9691v9XZxqk6/uUTZkCVfSPqpaiIpg3r2b3Beto6zFjan5/DaWmptKMZhw/fpwmTa5dYqmqNc2VOEhvZOF0ioth2bIbJ9q96vx5WLr0WpEm7Ofnn62XtqpqGSgvhxUrblqkAWSQgYVrnZIvctEeKattE5vuqEi7qpRS1rOeeOLvqEi76hKX2M72O76fLaVz7VP7ZS7f+uewebP1UnZVx91otE7bcAdFmqihjAzr37q8vKq/f/CgtWCWdZhtxs/PD39//4rtZoVacHAwer2ejIzKS6plZGQQdpOBdWFhYXe0f12QQk3UXFmZdQTq1aWrrjpzxnr77eb2Ebazd6+1tfPXbwalpdYWzeuPz3WKKCKJJAAsWPiFX+wYVNzKr3/2Rzhy+zvs3Gkd7PDr415SYj3/kpLskFBUKTsbFi+2/vtru3bB//4n625qxMPDg+7duxMXF1dxm8ViIS4ujj59qp62qU+fPpX2B9i4ceNN968LUqiJ2jGZYPnyay02CQnWr6s7t4+wnSNHrNNkmEzWlsxPP715i+d1rhYIySRTQIE9U4pbOMUpSihBRa1eoQbWFpuvv7Ze4i4stLbuaLxQfL2Unw9Llli7fKiqdTT0zVaxEHVm5syZLFq0iGXLlpGQkMCUKVMoKipi0qRJADzxxBOVBhs8//zzrF+/nnfffZcTJ07w+uuvs2/fPqZNm6bVS6i/fdSEDVks1qb9Ll2s803Jp0ftnDhhveRVUHD7VSt+JYEEIonkKEdvPV2FsCszZjazGX/8ySHn9ne46tgxawvq5cvXFuUWda+oyFoot2kDv0jLtCMYO3Ysly5dYvbs2aSnp9OlSxfWr19fMWAgJSUF3a/WQu3bty9ffPEFr776Kq+88gpRUVGsXbtWsznUQAo1YSuqav1kL7RXg0teRox8wzcARONESzu5oL3srdkdz5yxbRBRM2VlUqQ5mGnTpt20RSw+Pv6G28aMGcMYBxpwIZc+hRBCCCEclBRqQgghhBAOyikLtQULFhAZGYmnpyexsbHs2XPj8jBCCCGEEM7O6Qq1lStXMnPmTObMmcOBAweIiYlhyJAhZGZmah1NCCGEEMKmnK5Qe++995g8eTKTJk0iOjqahQsX4u3tzeLFi7WOJoTQ2OFVh3mn8TscW31M6yhCCGETTlWoXV1gdeDAgRW33W6BVSFE/VCYWchXv/uKovQivn32WwozC7WOJIQQteZUhdqtFli92YKpZWVl5OfnV2wFBTKZpxCuRlVV1j23DmOBEYCygjK+m/KdxqmEEKL2nKpQq4m5c+cSEBBQsUVHyxxRQriaY6uOcWLNCSxm61JKqlkl4esEjq46qnEyIYSoHacq1GqywOqsWbPIy8ur2I7fYnFqIYTzKcwsZN1z60C57hsKrPvdOrkEKoRwak61MsGvF1gdMWIEcG2B1ZvNOmwwGDAYri2Jk5ubC0BaWpq949qHj0/N7+vlVbs1AAsLoUGD2t2/Fs+fl1fzp3Z2N/zYAgKsazvWhMFQ6QFzyaUB146rDh2p3MFxMplq93tx3ULWXnhVynMrqqry9eSvKc0rhetXLlOhNK+UDRM38PSip6v1eApK5ddeXFy711ZQcEe/8z5UPr/TSKu8pFdgYM2zuLvfkEXOqRoym2v3e3HpEhiNNbtvWVntnlunc9q1YK++b1ssFo2T1DHVyaxYsUI1GAzq0qVL1ePHj6vPPvusGhgYqKanp1fr/tu2bVOx/kmXTTbZZJNNNtmcbNuzZ4+dKw3H4lQtanD7BVZvp3379gAcPXqUgIAAe0YVNVRQUEB0dDTHjx/Hz89P6ziiCnKMHJ8cI8cnx+jOWCwWMjIy6Nq1q9ZR6pSiqqqqdYi6lJ+fT0BAAHl5efj7+2sdR1RBjpHjk2Pk+OQYOT45RqI6nGowgRBCCCFEfSKFmhBCCCGEg6p3hZrBYGDOnDmVRoIKxyLHyPHJMXJ8cowcnxwjUR31ro+aEEIIIYSzqHctakIIIYQQzkIKNSGEEEIIByWFmhBCCCGEg5JCTQghhBDCQdWrQm3BggVERkbi6elJbGwse/bs0TqS+JXXX38dRVEqbe3atdM6Vr22detWhg8fTnh4OIqisHbt2krfV1WV2bNn07hxY7y8vBg4cCCnTp3SJmw9dbtj9OSTT95wXg0dOlSbsPXQ3Llz6dmzJ35+foSEhDBixAgSExMr7VNaWsrUqVMJCgrC19eX0aNHk5GRoVFi4WjqTaG2cuVKZs6cyZw5czhw4AAxMTEMGTKEzMxMraOJX+nQoQNpaWkV27Zt27SOVK8VFRURExPDggULqvz+22+/zYcffsjChQvZvXs3Pj4+DBkyhNLS0jpOWn/d7hgBDB06tNJ5tXz58jpMWL9t2bKFqVOnsmvXLjZu3Eh5eTmDBw+mqKioYp8XXniBb7/9ltWrV7NlyxYuXrzIqFGjNEwtHIqmK43WoV69eqlTp06t+NpsNqvh4eHq3LlzNUwlfm3OnDlqTEyM1jHETQDqmjVrKr62WCxqWFiY+s4771TclpubqxoMBnX58uUaJBTXHyNVVdWJEyeqDz/8sCZ5xI0yMzNVQN2yZYuqqtZzxt3dXV29enXFPgkJCSqg7ty5U6uYwoHUixY1o9HI/v37GThwYMVtOp2OgQMHsnPnTg2TieudOnWK8PBwWrZsyWOPPUZKSorWkcRNJCUlkZ6eXum8CggIIDY2Vs4rBxMfH09ISAht27ZlypQpZGdnax2p3srLywOgYcOGAOzfv5/y8vJK51G7du1o3ry5nEcCqCeXPrOysjCbzYSGhla6PTQ0lPT0dI1SievFxsaydOlS1q9fz8cff0xSUhL9+/enoKBA62iiClfPHTmvHNvQoUP59NNPiYuL46233mLLli0MGzYMs9msdbR6x2KxMGPGDPr160fHjh0B63nk4eFBYGBgpX3lPBJXuWkdQIirhg0bVvH/zp07ExsbS0REBKtWreLpp5/WMJkQzmvcuHEV/+/UqROdO3emVatWxMfHM2DAAA2T1T9Tp07l6NGj0vdW3JF60aIWHByMXq+/YRRNRkYGYWFhGqUStxMYGEibNm04ffq01lFEFa6eO3JeOZeWLVsSHBws51UdmzZtGuvWrWPz5s00bdq04vawsDCMRiO5ubmV9pfzSFxVLwo1Dw8PunfvTlxcXMVtFouFuLg4+vTpo2EycSuFhYWcOXOGxo0bax1FVKFFixaEhYVVOq/y8/PZvXu3nFcOLDU1lezsbDmv6oiqqkybNo01a9bw008/0aJFi0rf7969O+7u7pXOo8TERFJSUuQ8EkA9uvQ5c+ZMJk6cSI8ePejVqxcffPABRUVFTJo0Seto4oqXXnqJ4cOHExERwcWLF5kzZw56vZ7x48drHa3eKiwsrNTykpSUxKFDh2jYsCHNmzdnxowZvPnmm0RFRdGiRQtee+01wsPDGTFihHah65lbHaOGDRvyxhtvMHr0aMLCwjhz5gwvv/wyrVu3ZsiQIRqmrj+mTp3KF198wTfffIOfn19Fv7OAgAC8vLwICAjg6aefZubMmTRs2BB/f3+mT59Onz596N27t8bphUPQethpXZo/f77avHlz1cPDQ+3Vq5e6a9curSOJXxk7dqzauHFj1cPDQ23SpIk6duxY9fTp01rHqtc2b96sAjdsEydOVFXVOkXHa6+9poaGhqoGg0EdMGCAmpiYqG3oeuZWx6i4uFgdPHiw2qhRI9Xd3V2NiIhQJ0+erKanp2sdu96o6tgA6pIlSyr2KSkpUX//+9+rDRo0UL29vdWRI0eqaWlp2oUWDkVRVVWt+/JQCCGEEELcTr3ooyaEEEII4YykUBNCCCGEcFBSqAkhhBBCOCgp1IQQQgghHJQUakIIIYQQDkoKNSGEEEIIByWFmhBCCCGEg5JCTQjhlOLj41EUBUVRar0SQnJycsVjdenSxSb5hBDCFurNElJCCNeUmJhISEhIrR6jWbNmpKWlMW/ePDZt2mSjZEIIUXvSoiaEcGohISEEBgbW6jH0ej1hYWH4+vraJpQQQtiIFGpCCIfx5Zdf0qlTJ7y8vAgKCmLgwIEUFRXd0WPcc889TJ8+nRkzZtCgQQNCQ0NZtGgRRUVFTJo0CT8/P1q3bs0PP/xgp1chhBC2I4WaEMIhpKWlMX78eJ566ikSEhKIj49n1KhR1GQ54mXLlhEcHMyePXuYPn06U6ZMYcyYMfTt25cDBw4wePBgJkyYQHFxsR1eiRBC2I4UakIIh5CWlobJZGLUqFFERkbSqVMnfv/739focmRMTAyvvvoqUVFRzJo1C09PT4KDg5k8eTJRUVHMnj2b7Oxsjhw5YodXIoQQtiOFmhDCIcTExDBgwAA6derEmDFjWLRoEZcvX67RY3Xu3Lni/3q9nqCgIDp16lRxW2hoKACZmZm1Cy2EEHYmhZoQwiHo9Xo2btzIDz/8QHR0NPPnz6dt27YkJSXd8WO5u7tX+lpRlEq3KYoCgMViqV1oIYSwMynUhBAOQ1EU+vXrxxtvvMHBgwfx8PBgzZo1WscSQgjNyDxqQgiHsHv3buLi4hg8eDAhISHs3r2bS5cu0b59e62jCSGEZqRQE0I4BH9/f7Zu3coHH3xAfn4+ERERvPvuuwwbNkzraEIIoRkp1IQQDqF9+/asX7++1o8THx9/w23Jyck33FaTaT+EEKKuSR81IYRTa9q0KePHj6/VY6SkpODr68vf/vY3G6USQgjbUFT5WCmEcEIlJSVcuHABAF9fX8LCwmr8WCaTqaLVzWAw0KxZM1tEFEKIWpNCTQghhBDCQcmlTyGEEEIIByWFmhBCCCGEg5JCTQghhBDCQUmhJoQQQgjhoKRQE0IIIYRwUFKoCSGEEEI4KCnUhBBCCCEclBRqQgghhBAOSgo1IYQQQggH9f8B0cSiTnjc8JEAAAAASUVORK5CYII=\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring.plot_beta()\n", + "arc.plot_beta()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications:\n", + "> 1. sbreak\n", + "> 2. slice\n", + "> 3. insert\n", + "> 4. remove\n", + "> 5. append\n", + "> 6. pop\n", + "> 7. repeat\n", + "> 8. reduce \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## sbreak" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msbreak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbreak_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbreak_elems\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Insert elements at selected locations in the lattice\n", + "\n", + "Parameters:\n", + " break_s: location or array of locations of breakpoints\n", + " break_elems: elements to be inserted at breakpoints (array of\n", + " elements as long as break_s or single element\n", + " duplicated as necessary). Default: Marker('sbreak')\n", + "Returns:\n", + " newring: A new lattice with new elements inserted at breakpoints\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring.sbreak?" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Drift('DR_01', 2.25)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring_tmp = ring.deepcopy()\n", + "ring_tmp[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 0.2000000000000003\n", + "\tPassMethod : DriftPass \n", + " Marker:\n", + "\tFamName : hello\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass \n", + " Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 2.05\n", + "\tPassMethod : DriftPass\n" + ] + } + ], + "source": [ + "ring_tmp = ring_tmp.sbreak(0.2, at.Marker('hello'))\n", + "print(ring_tmp[0],'\\n', ring_tmp[1],'\\n', ring_tmp[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QF1\n", + "\tLength : 0.5499999999999998\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [0. 0.38046583]\n", + "\tEnergy : 3000000000.0\n", + "\tK : 0.3804658334791509 \n", + " Marker:\n", + "\tFamName : QuadSplit\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass \n", + " Quadrupole:\n", + "\tFamName : QF1\n", + "\tLength : 0.20000000000000018\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [0. 0.38046583]\n", + "\tEnergy : 3000000000.0\n", + "\tK : 0.3804658334791509\n" + ] + } + ], + "source": [ + "ring_tmp = ring_tmp.sbreak(2.8, at.Marker('QuadSplit'))\n", + "print(ring_tmp[3],'\\n', ring_tmp[4],'\\n', ring_tmp[5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For quadrupoles, there is an flag for the inclusion or exclusion of fringe fields at the entrance and exit of the quadrupoles. When you split the quadrupole, the internal fringe fields are disabled, and the outer fringe fields are kept. Similarly when you split a dipole, the exit and entrance angles are modified to ensure a continuous bend. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## slice / divide / merge" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You slice a lattice, you divide an element" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.75\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579871997393 \n", + "\n", + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.375\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579871997393 \n", + " Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.30000000000000004\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579871997393\n" + ] + } + ], + "source": [ + "quad = ring_tmp[3]\n", + "print(quad, '\\n')\n", + "quad_div = quad.divide([0.5, 0.4])\n", + "print(quad_div[0], '\\n', quad_div[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It may be useful to make nice smooth plots (for example of optics functions in the middle of elements and not just at the edges). For this you can use slice." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mring_tmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[float]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslices\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[int]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m'Lattice'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Create a new lattice by slicing the range of interest into small\n", + "elements\n", + "\n", + "Keyword arguments:\n", + " size=None: Length of a slice. Default: computed from the\n", + " range and number of points: ``size = (s_max-s_min)/slices``.\n", + " slices=1: Number of slices in the specified range. Ignored if\n", + " size is specified. Default: no slicing\n", + "\n", + "Returns:\n", + " newring: New Lattice object\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring_tmp.slice?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "new_ring_tmp = ring_tmp.slice(slices=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "700\n", + "2300\n" + ] + } + ], + "source": [ + "msk = at.get_value_refpts(ring_tmp, np.arange(len(ring_tmp)), 'Length') == 0\n", + "print(len(ring_tmp) - np.sum(msk))\n", + "\n", + "msk = at.get_value_refpts(new_ring_tmp, np.arange(len(new_ring_tmp)), 'Length') == 0\n", + "print(len(new_ring_tmp) - np.sum(msk))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zero length elements are of course not touched, but one can also specify a dz too" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also do the opposite of split, which is to merge two identical and adjacent elements" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "q = ring_tmp[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.75\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579871997393\n" + ] + } + ], + "source": [ + "print(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "q.merge(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 1.5\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579871997393\n" + ] + } + ], + "source": [ + "print(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 2.25\n", + "\tPassMethod : DriftPass\n" + ] + } + ], + "source": [ + "dr = ring_tmp[0]\n", + "print(dr)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 4.5\n", + "\tPassMethod : DriftPass\n" + ] + } + ], + "source": [ + "dr.merge(dr)\n", + "print(dr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## insert / append / pop / remove" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lattice objects are fundamentally lists. Which means that all of the standard python operations that can be performed on lists are valid for a lattice object" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp.insert(4, at.Marker('insert_test'))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marker:\n", + "\tFamName : insert_test\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass\n" + ] + } + ], + "source": [ + "print(ring_tmp[4])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Append puts elements automatically at the end. It is equivalent to insert with an index of -1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marker:\n", + "\tFamName : append_test\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass\n" + ] + } + ], + "source": [ + "ring_tmp.append(at.Marker('append_test'))\n", + "print(ring_tmp[-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pop removes and returns the element at the specified index" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "mark = ring_tmp.pop(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marker:\n", + "\tFamName : append_test\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass\n", + "Corrector:\n", + "\tFamName : Corrector\n", + "\tLength : 0.0\n", + "\tPassMethod : CorrectorPass\n", + "\tKickAngle : [0. 0.]\n" + ] + } + ], + "source": [ + "print(mark)\n", + "print(ring_tmp[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "mrk = at.Marker('ahoyhoy')\n", + "ring_tmp.append(mrk)\n", + "ring_tmp.remove(mrk)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([], dtype=uint32)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "at.get_uint32_index(ring_tmp, 'ahoy*')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## repeat" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "arc_tmp = arc.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0marc_tmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrepeat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'int'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy_elements\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "This method allows to repeat the lattice `n` times.\n", + "If `n` does not divide `ring.periodicity`, the new ring\n", + "periodicity is set to 1, otherwise it is et to\n", + "`ring.periodicity /= n`.\n", + "\n", + "Equivalents syntaxes:\n", + ">>> newring = ring.repeat(n)\n", + ">>> newring = ring * n\n", + "\n", + "Parameters:\n", + " n (int): number of repetition\n", + " copy_elements(bool): Default :py:obj:`True`.\n", + " If :py:obj:`True` deepcopies of the\n", + " lattice are used for the repetition\n", + "\n", + "Returns:\n", + " newring (Lattice): the new repeated lattice\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "arc_tmp.repeat?" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arc_tmp.periodicity" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = arc_tmp.repeat(arc_tmp.periodicity)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "29 725 825\n" + ] + } + ], + "source": [ + "ring_tmp.periodicity\n", + "print(len(arc_tmp), len(ring_tmp), 33*25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## reduce" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Very important and useful function! This function will remove all irrelevant elements from your lattice, and merge compatible adjacent elements. For example, say you have split a quadrupole in the center and put a marker there. The marker has an 'IdentityPass', pass method which means it will be removed. The now adjacent quadrupoles will be merged. Very useful for reducing as much as possible the number of elements that need to be actively tracked in your lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mring_tmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m'Lattice'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Removes all elements with an ``IdentityPass`` PassMethod and merges\n", + "compatible consecutive elements.\n", + "\n", + "The \"reduced\" lattice has the same optics as the original one, but\n", + "fewer elements. Compatible elements must have the same ``PolynomA``,\n", + "``PolynomB`` and bending radius, so that the optics is preserved. But\n", + "magnet misalignments are not preserved, so this method should be\n", + "applied to lattices without errors.\n", + "\n", + "Keyword Args:\n", + " keep (Refpts): Keep the selected elements, even with\n", + " ``IdentityPass`` PassMethod. Default: keep :py:class:`.Monitor`\n", + " and :py:class:`.RFCavity` elements\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring_tmp.reduce?" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "776" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ring_tmp)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring_tmp.reduce()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "776" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ring_tmp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### masks / refpts" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "776" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring_tmp = ring.deepcopy()\n", + "len(ring)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You have a ring. It has for example, 876 elements. There are a variety of different ways to select the desired elements in the list." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Drift('DR_06', 0.5625), Quadrupole('QF4', 0.75, 0.4588558334791509, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 1.1953442676109476), Monitor('BPM_CellCenter'), Sextupole('SF', 0.75, 1.1953442676109476), Drift('DR_07', 0.1875), Quadrupole('QF4', 0.75, 0.4588558334791509, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Drift('DR_06', 0.5625), Sextupole('SD', 0.1875, -5.128646884445229)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=1, harmonic_number=992, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "msk = np.zeros(len(ring_tmp), dtype=bool)\n", + "msk[10:20] = True\n", + "ring_tmp[msk]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Quadrupole('QF1', 0.75, 0.3804658334791509, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Drift('DR_02', 0.75), Quadrupole('QD2', 0.75, -0.27094579871997393, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Dipole('Bend', 3.0, 0.12566370614359174, 0.0, Energy=3000000000.0, PassMethod='BndMPoleSymplectic4RadPass'), Drift('DR_04', 0.1875), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 1.1953442676109476)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=1, harmonic_number=992, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "args = np.array([1,2,3,5,6,234,450])\n", + "ring_tmp[args]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we have already seen. We have the function 'get_uint32_index' to get the indexes of elements matching a certain criteria. We also have 'get_bool_index' in order to obtain a mask for the same values." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "msk = at.get_bool_index(ring,'BPM*')\n", + "inds = at.get_uint32_index(ring,'BPM*')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 14 29 45 60 76 92 108 123 139 154 170 185 201 216 232 247 263 278\n", + " 294 309 325 340 356 371 387 402 418 433 449 464 480 495 511 526 542 557\n", + " 573 588 604 619 635 650 666 681 697 712 728 743 759 774]\n", + "[ 14 29 45 60 76 92 108 123 139 154 170 185 201 216 232 247 263 278\n", + " 294 309 325 340 356 371 387 402 418 433 449 464 480 495 511 526 542 557\n", + " 573 588 604 619 635 650 666 681 697 712 728 743 759 774]\n" + ] + } + ], + "source": [ + "print(np.where(msk)[0])\n", + "print(inds)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/esrfworkshop/.ipynb_checkpoints/3_SimpleOptics-checkpoint.ipynb b/esrfworkshop/.ipynb_checkpoints/3_SimpleOptics-checkpoint.ipynb new file mode 100644 index 0000000..8a3ab38 --- /dev/null +++ b/esrfworkshop/.ipynb_checkpoints/3_SimpleOptics-checkpoint.ipynb @@ -0,0 +1,1764 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/home/claudio/src/gitlab/dt/exercises/pyatworkshop/dba.mat'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:39\u001b[0m, in \u001b[0;36m_open_file\u001b[0;34m(file_like, appendmat, mode)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfile_like\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# Probably \"not found\"\u001b[39;00m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/claudio/src/gitlab/dt/exercises/pyatworkshop/dba.mat'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m ring \u001b[38;5;241m=\u001b[39m \u001b[43mat\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_mat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m./dba.mat\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmat_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mRING\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m arc \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mload_mat(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m./arc.mat\u001b[39m\u001b[38;5;124m'\u001b[39m, mat_key\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mARC\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/load/matfile.py:169\u001b[0m, in \u001b[0;36mload_mat\u001b[0;34m(filename, **kwargs)\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mkey\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs: \u001b[38;5;66;03m# process the deprecated 'key' keyword\u001b[39;00m\n\u001b[1;32m 168\u001b[0m kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmat_key\u001b[39m\u001b[38;5;124m'\u001b[39m, kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mkey\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[0;32m--> 169\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mLattice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mringparam_filter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmatfile_generator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mabspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 170\u001b[0m \u001b[43m \u001b[49m\u001b[43miterator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams_filter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py:186\u001b[0m, in \u001b[0;36mLattice.__init__\u001b[0;34m(self, iterator, scan, *args, **kwargs)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 184\u001b[0m elems \u001b[38;5;241m=\u001b[39m iterator(kwargs, \u001b[38;5;241m*\u001b[39margs)\n\u001b[0;32m--> 186\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mLattice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43melems\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;66;03m# removing excluded attributes\u001b[39;00m\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m attr \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_excluded_attributes:\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py:1474\u001b[0m, in \u001b[0;36mparams_filter\u001b[0;34m(params, elem_filter, *args)\u001b[0m\n\u001b[1;32m 1471\u001b[0m cavities \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 1472\u001b[0m cell_length \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m-> 1474\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, elem \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(elem_filter(params, \u001b[38;5;241m*\u001b[39margs)):\n\u001b[1;32m 1475\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(elem, elt\u001b[38;5;241m.\u001b[39mRFCavity):\n\u001b[1;32m 1476\u001b[0m cavities\u001b[38;5;241m.\u001b[39mappend(elem)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/load/matfile.py:115\u001b[0m, in \u001b[0;36mringparam_filter\u001b[0;34m(params, elem_iterator, *args)\u001b[0m\n\u001b[1;32m 113\u001b[0m ringparams \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 114\u001b[0m radiate \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m elem \u001b[38;5;129;01min\u001b[39;00m elem_iterator(params, \u001b[38;5;241m*\u001b[39margs):\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (elem\u001b[38;5;241m.\u001b[39mPassMethod\u001b[38;5;241m.\u001b[39mendswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRadPass\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[1;32m 117\u001b[0m elem\u001b[38;5;241m.\u001b[39mPassMethod\u001b[38;5;241m.\u001b[39mendswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCavityPass\u001b[39m\u001b[38;5;124m'\u001b[39m)):\n\u001b[1;32m 118\u001b[0m radiate \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/load/matfile.py:67\u001b[0m, in \u001b[0;36mmatfile_generator\u001b[0;34m(params, mat_file)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 64\u001b[0m \u001b[38;5;66;03m# Remove any surplus dimensions in arrays.\u001b[39;00m\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m numpy\u001b[38;5;241m.\u001b[39msqueeze(data)\n\u001b[0;32m---> 67\u001b[0m m \u001b[38;5;241m=\u001b[39m \u001b[43mscipy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mio\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloadmat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetdefault\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmat_file\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmat_file\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 68\u001b[0m matvars \u001b[38;5;241m=\u001b[39m [varname \u001b[38;5;28;01mfor\u001b[39;00m varname \u001b[38;5;129;01min\u001b[39;00m m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m varname\u001b[38;5;241m.\u001b[39mstartswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__\u001b[39m\u001b[38;5;124m'\u001b[39m)]\n\u001b[1;32m 69\u001b[0m default_key \u001b[38;5;241m=\u001b[39m matvars[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m (\u001b[38;5;28mlen\u001b[39m(matvars) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRING\u001b[39m\u001b[38;5;124m'\u001b[39m\n", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:224\u001b[0m, in \u001b[0;36mloadmat\u001b[0;34m(file_name, mdict, appendmat, **kwargs)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;124;03mLoad MATLAB file.\u001b[39;00m\n\u001b[1;32m 89\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;124;03m 3.14159265+3.14159265j])\u001b[39;00m\n\u001b[1;32m 222\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 223\u001b[0m variable_names \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mvariable_names\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 224\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m _open_file_context(file_name, appendmat) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 225\u001b[0m MR, _ \u001b[38;5;241m=\u001b[39m mat_reader_factory(f, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 226\u001b[0m matfile_dict \u001b[38;5;241m=\u001b[39m MR\u001b[38;5;241m.\u001b[39mget_variables(variable_names)\n", + "File \u001b[0;32m/usr/lib/python3.10/contextlib.py:135\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 135\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgen\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerator didn\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt yield\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28mNone\u001b[39m\n", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:17\u001b[0m, in \u001b[0;36m_open_file_context\u001b[0;34m(file_like, appendmat, mode)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;129m@contextmanager\u001b[39m\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_open_file_context\u001b[39m(file_like, appendmat, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[0;32m---> 17\u001b[0m f, opened \u001b[38;5;241m=\u001b[39m \u001b[43m_open_file\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile_like\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mappendmat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m f\n", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:45\u001b[0m, in \u001b[0;36m_open_file\u001b[0;34m(file_like, appendmat, mode)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m appendmat \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m file_like\u001b[38;5;241m.\u001b[39mendswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.mat\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 44\u001b[0m file_like \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.mat\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 45\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfile_like\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m(\n\u001b[1;32m 48\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mReader needs file name or open file-like object\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 49\u001b[0m ) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/claudio/src/gitlab/dt/exercises/pyatworkshop/dba.mat'" + ] + } + ], + "source": [ + "import at\n", + "import at.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "ring = at.load_mat('./dba.mat', mat_key='RING')\n", + "arc = at.load_mat('./arc.mat', mat_key='ARC')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple Tracking, Optics and Orbit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will do some simple tracking through the lattice, and also show how to compute the optics and the orbit. \n", + "\n", + "First we need some particles to track, these must be in the format of ((6,N)) where 6 is the number of dimensions of AT (x,x',y,y',delta,ct) and N is the number of particles. This array can be manually created, but it is also desirable to generate a beam that is matched to the lattice. We can do this by generating the sigma correlation matrix using 'sigma_matrix'. The function will return a correlation matrix that can be used to generate a matched beam for the lattice you provide it. However there are some interesting things to be aware of, e.g." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "ring.disable_6d()\n", + "#sig_mat = at.sigma_matrix(ring)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have give a lattice with radiation off and asked for a correlation matrix. However, the emittances of a lattice with no radiation are 0 in x and y. Therefore we must provide the emittances that we want." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/tracking/particles.py:107: AtWarning: Monochromatic beam: no energy spread\n", + " warn(AtWarning('Monochromatic beam: no energy spread'))\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[ 2.45937189e-09, -2.37902221e-21, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [-2.37902221e-21, 4.06607883e-12, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, 1.67372947e-11,\n", + " -4.04065923e-23, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, -4.04065923e-23,\n", + " 5.97468119e-14, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sig_mat = at.sigma_matrix(ring, emitx=100e-12, emity=1e-12)\n", + "sig_mat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to the fact that the rad is off. We only have correlations for x,x' and y,y' and nothing in the longitudinal plane. But we can switch rad on and compare the difference. Here you may notice that we don't need to give the emittances, that is because if radiation is on and no emittances are specified, it will take the result from envelope_parameters. If you want a beam with veritcal emittance, you can also still specify it. There are many different cases that can be seen in the help, but the exception that is raised if something is missing is quite explanatory. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.82796706e-07, 8.80029073e-13, -9.03634961e-27,\n", + " -2.23193015e-27, -6.45406656e-12, -1.10736402e-11],\n", + " [ 8.80029502e-13, 3.02682564e-10, -3.93185281e-28,\n", + " 4.28789015e-29, -1.37026502e-12, 1.60304356e-13],\n", + " [ 1.14458611e-27, 2.36795948e-28, 1.67373110e-10,\n", + " 2.00352563e-16, -4.85449966e-23, -1.27782072e-23],\n", + " [-1.30926147e-28, -2.70856465e-29, 2.00352563e-16,\n", + " 5.97467540e-13, 5.55276393e-24, 1.46211048e-24],\n", + " [-6.45942538e-12, -1.35267982e-12, 8.54658540e-23,\n", + " -5.46753954e-24, 2.76400648e-07, 3.98317397e-08],\n", + " [-1.17777339e-11, 1.84183232e-13, 1.67970673e-21,\n", + " 7.49294951e-23, 3.98317397e-08, 6.20209387e-06]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sig_mat_rad_on = at.sigma_matrix(ring.radiation_on(copy=True), emity=10e-12)\n", + "sig_mat_rad_on" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the matrix we can generate a beam using 'beam'." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h, v, delta\n", + "(6, 50000)\n" + ] + } + ], + "source": [ + "nparts = 50000\n", + "parts = at.beam(nparts, sig_mat_rad_on)\n", + "print(parts.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.002487854833857263\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([1.000e+00, 0.000e+00, 1.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 1.000e+00, 2.000e+00, 2.000e+00, 2.000e+00, 0.000e+00, 7.000e+00,\n", + " 7.000e+00, 6.000e+00, 1.400e+01, 1.500e+01, 2.100e+01, 2.500e+01,\n", + " 3.000e+01, 3.800e+01, 4.800e+01, 6.100e+01, 8.600e+01, 1.060e+02,\n", + " 1.140e+02, 1.380e+02, 1.610e+02, 2.000e+02, 2.480e+02, 2.620e+02,\n", + " 2.870e+02, 4.030e+02, 4.050e+02, 5.020e+02, 5.850e+02, 6.510e+02,\n", + " 6.930e+02, 7.780e+02, 8.890e+02, 1.040e+03, 1.057e+03, 1.107e+03,\n", + " 1.237e+03, 1.334e+03, 1.365e+03, 1.459e+03, 1.560e+03, 1.528e+03,\n", + " 1.664e+03, 1.636e+03, 1.627e+03, 1.630e+03, 1.614e+03, 1.719e+03,\n", + " 1.676e+03, 1.674e+03, 1.593e+03, 1.507e+03, 1.470e+03, 1.334e+03,\n", + " 1.241e+03, 1.242e+03, 1.103e+03, 1.065e+03, 9.680e+02, 8.730e+02,\n", + " 7.920e+02, 6.810e+02, 6.450e+02, 5.470e+02, 4.930e+02, 4.520e+02,\n", + " 3.750e+02, 3.170e+02, 2.880e+02, 2.610e+02, 2.070e+02, 1.760e+02,\n", + " 1.490e+02, 9.900e+01, 7.700e+01, 7.100e+01, 5.500e+01, 4.900e+01,\n", + " 4.000e+01, 2.400e+01, 1.700e+01, 1.800e+01, 1.700e+01, 5.000e+00,\n", + " 1.200e+01, 5.000e+00, 5.000e+00, 4.000e+00, 3.000e+00, 2.000e+00,\n", + " 0.000e+00, 0.000e+00, 1.000e+00, 1.000e+00]),\n", + " array([-1.09313451e-02, -1.07209302e-02, -1.05105153e-02, -1.03001004e-02,\n", + " -1.00896855e-02, -9.87927058e-03, -9.66885567e-03, -9.45844075e-03,\n", + " -9.24802584e-03, -9.03761093e-03, -8.82719602e-03, -8.61678110e-03,\n", + " -8.40636619e-03, -8.19595128e-03, -7.98553637e-03, -7.77512145e-03,\n", + " -7.56470654e-03, -7.35429163e-03, -7.14387671e-03, -6.93346180e-03,\n", + " -6.72304689e-03, -6.51263198e-03, -6.30221706e-03, -6.09180215e-03,\n", + " -5.88138724e-03, -5.67097233e-03, -5.46055741e-03, -5.25014250e-03,\n", + " -5.03972759e-03, -4.82931268e-03, -4.61889776e-03, -4.40848285e-03,\n", + " -4.19806794e-03, -3.98765303e-03, -3.77723811e-03, -3.56682320e-03,\n", + " -3.35640829e-03, -3.14599338e-03, -2.93557846e-03, -2.72516355e-03,\n", + " -2.51474864e-03, -2.30433373e-03, -2.09391881e-03, -1.88350390e-03,\n", + " -1.67308899e-03, -1.46267408e-03, -1.25225916e-03, -1.04184425e-03,\n", + " -8.31429338e-04, -6.21014426e-04, -4.10599513e-04, -2.00184601e-04,\n", + " 1.02303120e-05, 2.20645225e-04, 4.31060137e-04, 6.41475050e-04,\n", + " 8.51889962e-04, 1.06230487e-03, 1.27271979e-03, 1.48313470e-03,\n", + " 1.69354961e-03, 1.90396452e-03, 2.11437944e-03, 2.32479435e-03,\n", + " 2.53520926e-03, 2.74562418e-03, 2.95603909e-03, 3.16645400e-03,\n", + " 3.37686891e-03, 3.58728383e-03, 3.79769874e-03, 4.00811365e-03,\n", + " 4.21852856e-03, 4.42894348e-03, 4.63935839e-03, 4.84977330e-03,\n", + " 5.06018821e-03, 5.27060313e-03, 5.48101804e-03, 5.69143295e-03,\n", + " 5.90184786e-03, 6.11226278e-03, 6.32267769e-03, 6.53309260e-03,\n", + " 6.74350751e-03, 6.95392243e-03, 7.16433734e-03, 7.37475225e-03,\n", + " 7.58516716e-03, 7.79558208e-03, 8.00599699e-03, 8.21641190e-03,\n", + " 8.42682681e-03, 8.63724173e-03, 8.84765664e-03, 9.05807155e-03,\n", + " 9.26848646e-03, 9.47890138e-03, 9.68931629e-03, 9.89973120e-03,\n", + " 1.01101461e-02]),\n", + " <BarContainer object of 100 artists>)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "coord=5\n", + "print(np.std(parts[coord,:]))\n", + "plt.hist(parts[coord,:], bins=100)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's do some tracking. but to make it easier we can start with only a single particle." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6,)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_in = np.array([1e-3, 0., 0., 0., 0., 0.]) #must be floats not ints\n", + "p_in.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "We need to use the function track. We must define the refpts in the lattice where we want to save the output. And we also want to specify nturns. There are two ways of tracking, either you use nturns=1 within a for loop, this has the benefit of allowing you to perform your own TbT analysis and save relevant parameters only. Or you can tracking for many turns, look at the full coordinates of the whole tracking, and perform the post processing later." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mr_in\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnturns\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'int'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Refpts'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEnd\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'End'\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0min_place\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'bool'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + ":py:func:`track_function` tracks particles through each element of a\n", + "lattice or throught a single Element calling the element-specific\n", + "tracking function specified in the Element's *PassMethod* field.\n", + "\n", + "Usage:\n", + " >>> lattice_track(lattice, r_in)\n", + " >>> lattice.track(r_in)\n", + "\n", + "Parameters:\n", + " lattice: list of elements\n", + " r_in: (6, N) array: input coordinates of N particles.\n", + " *r_in* is modified in-place only if *in_place* is \n", + " :py:obj:`True` and reports the coordinates at\n", + " the end of the element. For the best efficiency, *r_in*\n", + " should be given as F_CONTIGUOUS numpy array.\n", + "\n", + "Keyword arguments:\n", + " nturns: number of turns to be tracked\n", + " refpts: Selects the location of coordinates output.\n", + " See \":ref:`Selecting elements in a lattice <refpts>`\"\n", + " in_place (bool): If True *r_in* is modified in-place and\n", + " reports the coordinates at the end of the element.\n", + " (default: False)\n", + " keep_lattice (bool): Use elements persisted from a previous\n", + " call. If :py:obj:`True`, assume that the lattice has not changed\n", + " since the previous call.\n", + " keep_counter (bool): Keep the turn number from the previous\n", + " call.\n", + " turn (int): Starting turn number. Ignored if\n", + " *keep_counter* is :py:obj:`True`. The turn number is necessary to\n", + " compute the absolute path length used in RFCavityPass.\n", + " losses (bool): Boolean to activate loss maps output\n", + " omp_num_threads (int): Number of OpenMP threads\n", + " (default: automatic)\n", + "\n", + "The following keyword arguments overload the lattice values\n", + "\n", + "Keyword arguments:\n", + "\n", + " particle (Optional[Particle]): circulating particle.\n", + " Default: :code:`lattice.particle` if existing,\n", + " otherwise :code:`Particle('relativistic')`\n", + " energy (Optiona[float]): lattice energy. Default 0.\n", + " unfold_beam (bool): Internal beam folding activate, this\n", + " assumes the input particles are in bucket 0, works only\n", + " if all bucket see the same RF Voltage.\n", + " Default: :py:obj:`True`\n", + "\n", + "If *energy* is not available, relativistic tracking if forced,\n", + "*rest_energy* is ignored.\n", + "\n", + "Returns:\n", + " r_out: (6, N, R, T) array containing output coordinates of N particles\n", + " at R reference points for T turns\n", + " trackparam: A dictionary containing tracking input parameters with the\n", + " following keys:\n", + "\n", + " ============== ===================================================\n", + " **npart** number of particles\n", + " **rout** final particle coordinates\n", + " **turn** starting turn\n", + " **refpts** array of index where particle coordinate are saved\n", + " (only for lattice tracking)\n", + " **nturns** number of turn\n", + "\n", + " trackdata: A dictionary containinf tracking data with the following\n", + " keys:\n", + "\n", + " ============== ===================================================\n", + " **loss_map**: recarray containing the loss_map (only for lattice\n", + " tracking)\n", + "\n", + "\n", + " The **loss_map** is filled only if *losses* is :py:obj:`True`,\n", + " it contains the following keys:\n", + " ============== ===================================================\n", + " **islost** (npart,) bool array indicating lost particles\n", + " **turn** (npart,) int array indicating the turn at\n", + " which the particle is lost\n", + " **element** ((npart,) int array indicating the element at\n", + " which the particle is lost\n", + " **coord** (npart, 6) float array giving the coordinates at\n", + " which the particle is lost (zero for surviving\n", + " particles)\n", + " ============== ===================================================\n", + "\n", + "\n", + ".. note::\n", + "\n", + " * :pycode:`track_function(lattice, r_in, refpts=len(line))` is the same\n", + " as :pycode:`track_function(lattice, r_in)` since the reference point\n", + " len(line) is the exit of the last element.\n", + " * :pycode:`track_function(lattice, r_in, refpts=0)` is a copy of *r_in*\n", + " since the reference point 0 is the entrance of the first element.\n", + " * To resume an interrupted tracking (for instance to get intermediate\n", + " results), one must use one of the *turn* or *keep_counter*\n", + " keywords to ensure the continuity of the turn number.\n", + " * For multiparticle tracking with large number of turn the size of\n", + " *r_out* may increase excessively. To avoid memory issues\n", + " :pycode:`track_function(lattice, r_in, refpts=None, in_place=True)`\n", + " can be used. An empty list is returned and the tracking results of\n", + " the last turn are stored in *r_in*.\n", + " * To model buckets with different RF voltage :pycode:`unfold_beam=False`\n", + " has to be used. The beam can be unfolded using the function\n", + " :py:func:`.unfold_beam`. This function takes into account\n", + " the true voltage in each bucket and distributes the particles in the\n", + " bunches defined by :code:`ring.fillpattern` using a 6D orbit search.\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/tracking/track.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring.track?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Method 1, the output of the tracking is a big array with shape (6, N, R, T)\n", + "# where 6 is the particle coordinate, N is the particle index, R is the element index, \n", + "# and T is the turn number\n", + "pout, *_ = ring.track(p_in, refpts=np.arange(len(ring)), nturns=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tunex, tuney = ring.get_tune()\n", + "xdat = pout[0,0,0,:]\n", + "fig, (ax1,ax2) = plt.subplots(2,1)\n", + "ax1.plot(xdat)\n", + "ax2.plot(np.fft.rfftfreq(len(xdat)), np.abs(np.fft.rfft(xdat)))\n", + "ax2.axvline(tunex, color='r', linestyle='dashed')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An important note, back to pointers again! If you prefer to use them in a turn by turn way, you can go like this" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "p_in = np.zeros((6,3))\n", + "p_in[0,:] = np.array([1e-4,1e-3,3e-3])\n", + "n_turns=200\n", + "x_data = np.zeros((p_in.shape[1], n_turns))\n", + "xp_data = np.zeros((p_in.shape[1], n_turns))\n", + "for i in np.arange(n_turns):\n", + " _ = ring.track(p_in, nturns=1, in_place=True, refpts=None) #in_place means modify input particle, refpts=None stops the track function from generating big arrays for unneeded output\n", + " x_data[:, i] = p_in[0,:]\n", + " xp_data[:, i] = p_in[1,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'xp')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAGwCAYAAADolBImAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlQUlEQVR4nO3de1xUdf4/8NcMykVsIFQYUVhveL/glWBL6ys1ml1Md0vDtMKsNivTNK1Na7fNMtvMMm2/+1M0NcuNbl5Av1hZiZAI5i2zokBl0GIBIUFlPr8/pjkxcAZmYGbOOTOv5z54uJzzmeEzJ5jzns/n/Xl/dEIIASIiIiJSlF7pDhARERERgzIiIiIiVWBQRkRERKQCDMqIiIiIVIBBGREREZEKMCgjIiIiUgEGZUREREQq0EbpDpDzLBYLzpw5gyuuuAI6nU7p7hAREZEThBA4f/48oqOjodc7Hg9jUKYhZ86cQUxMjNLdICIiohYoLi5G165dHZ5nUKYhV1xxBQDrf1SDwaBwb4iIiMgZlZWViImJke7jjjAo0xDblKXBYGBQRkREpDHNpR4x0Z+IiIhIBRiUEREREakAgzIiIiIiFWBQRkRERKQCDMqIiIiIVIBBGREREZEKMCgjIiIiUgEGZUREREQqwKCMiIiISAUYlBERERGpAIMyIiIiIhVgUEZE5CHmajNyS3Jhrja3qr27jhORunFDciKiVjJXm1FUWYRYQyyMoUYAQPrJdDyb/SwswgK9To8liUswKW6Sw+dw1N5dxx31s6njRORdOiGEULoT5JzKykqEhYWhoqICBoNB6e4QaZ47ghS5ICgpOgmm90ywCIvUTq/TI3NypuzzmavNsu03jt+IaTuntfp45uRM7Duzz21BHBG5xtn7N6cvicjnyU3npZ9Mh+k9E1J3pcL0ngnpJ9ObPO7oeW0BDQBYhAXPZj+LgrMFdoGR7Vzx+WLZ5ymqLJJtn3823y3HD509JNvPw+cOyx43V5ubvA6cNiXyDE5fEpHPcHYaMSk6STYYiQuPkz2eFJ0kO1LkKJjSQQe9Tt9oxCrmihjZfscaYmXbD40c6pbjAsK1IO6cfBCXFJ3UohE3InIOR8qISHOcHflydSTLUZDiaITLFkzVp9fpMSRyCJYkLpHO2YIUR1OAxlCjbPtBnQa55Xh8ZLxsP21BXMPjQsgHcS0ZcWsKR9aI7HGkjIg0xZWRrxevedGlkSxHI02ORrhswVTD/hhDjZgUNwlJ0UkoPl+MmCtims3JctTeXcfl+mkL4hoetwVxrR1xKz5f7PB1c2SNqDEm+msIE/3J3zScjnSUEP/iNS9i/t75jR6/fMxyLNi7wG2J703109ngS0mO+il33JUFDE0tMHBlYYOtPRcYkK9x9v7NkTIiUpyzuWBd23d1aeRrSKchLo9kuTrCBVhHzLQQPDjqp9xxd4y4ObomjnLxis8XOwyWAa4GJd/HkTIN4UgZaZ0rifiujsg0dzPXwkiWVrgy4ubo8e7678tAjbTA2fs3gzINYVBGWuZK8OVoOnKtaS2Kzxcz+PIBjkZCU3elNmq7fPRyLPi88TT0nGFzsOLgCualkepx+pKIFCOXC+ZSIr7OcUmJkcaRDqcXtTKNSPLTo+Zqs0sLDF7JewUCQvq+fvkSjqCRFjEoIyK38nQuGMDgy1c0/O/oaDWr3GpQHXRSQGbjTF4akZpx+lJDOH1JaufOXCHb83E60v84sxq0/tSljTMrQTmCRkrg9CURuZUzNzNHq+pq6mpaVM+LI2L+ydnVoGFBYY1+py5cvtCilZ1EasCgjIia5WztLkfbBTEXjNyh4e+JK3lpwQHBDreOAsDRM1IFbrNERI3U3/7GUZK+3NY4jrYLqp8LNtI4kjc+cpuGv1OOfgcdjaBtOr7J6Q3oiTyNI2VEZKfhqNj0ftNd2kKnJcVXidzJ2RE0HXTYcHQDLJDfgJ75Z+RtHCkj8mMNN4SWGxXbcHwDdNDZPa6p/SABjoiR8pwZQZsxYIYUkNnYPnDIbXBP5GkcKSPyU66Urrh7wN3YcGyDU1voEKlVwxE0ANLvtQ3zz0hJDMqI/ET9qRgAsjedjeM3yiZJp/RLQUq/FE5JkuY1XCwgtyq4qfyzhh9OuHqT3IlBGZEfaJQn1l8+T6yp0hUAGIyRz3FlBef6o+sd7iBA5A4Myoh8jDNbHK0/uh566O3yaZwpXUHki5zZWWB6v+lIO5Zm97imFrwQtQSDMiIf4myemIDAjAEzHOaJsW4Y+TvZ/LPjjfPPmlrwwtWb5Cpus6Qh3GaJmtKSLY4AcESMyEnOFlF2tS35Pm6zROQH6n8Sb8kWRwDzxIic5WwNPkcFl7l6k5rDoIxIo+Q2aG7JFkdE5DxnpvYdfUDi6k1qDqcvNYTTl/6tYUkLuanKOcPmYMXBFXzTJ1KQo1QCIYS0etN2LHNyJj8k+QFOXxL5EGdLWgzsOBCZkzM5IkakIK7epJZiUEakQs0Vem2qpAVXThIpzx2rN8n/MCgjUhlnNgRvrqQFESnPmd0DmloswAUB/kdzG5KvWrUK3bp1Q3BwMBISEpCbm9tk+61bt6Jv374IDg7GoEGDsGPHDrvzQggsXrwYnTt3RkhICJKTk3Hy5Em7NmVlZUhJSYHBYEB4eDhSU1NRVVUlna+pqcHdd9+NQYMGoU2bNpg4caJsXz799FMMGzYMQUFB6NWrF9LS0lp0Dch3ubIheEq/FGROzsRa01pkTs5k7hiRyk2Km+TU3yw3Q/dfmgrK3nnnHcydOxdLlizBwYMHMWTIEJhMJpw9e1a2/b59+zB16lSkpqYiPz8fEydOxMSJE3HkyBGpzbJly7By5UqsWbMGOTk5CA0NhclkQk1NjdQmJSUFR48exe7du7Ft2zbs3bsXs2bNks7X1dUhJCQEjzzyCJKTk2X7UlhYiAkTJuC6665DQUEB5syZg5kzZyIzM9NNV4e0ylxtRm5JrvTJWC5XbMaAGdDrrH+u9T9hG0ONGGkcyU/SRBrR3N+so3Ia5mqzN7tJCtHU6suEhASMHDkSr7/+OgDAYrEgJiYGDz/8MBYuXNio/R133IHq6mps27ZNOnbVVVchPj4ea9asgRAC0dHRmDdvHh5//HEAQEVFBaKiopCWloYpU6bg+PHj6N+/P7766iuMGDECAJCRkYEbb7wRp06dQnR0tN3PvPvuu1FeXo4PPvjA7vgTTzyB7du32wWEU6ZMQXl5OTIyMmRfb21tLWpra6XvKysrERMTw9WXPkSurIVt9aQNC70S+Y/cklyk7kptdHytaS1irojhlKZGObv6UjMjZRcvXkReXp7dSJRer0dycjKys7NlH5Odnd1o5MpkMkntCwsLYTab7dqEhYUhISFBapOdnY3w8HApIAOA5ORk6PV65OTkON3/5voiZ+nSpQgLC5O+YmKYEOpL5D4Rrzi4Qqo3BnBUjMjfxBpipb9/G71OjyM/H+GUph/QTFD2888/o66uDlFRUXbHo6KiYDbLD+uazeYm29v+ba5NZGSk3fk2bdogIiLC4c91pS+VlZW4cOGC7GMWLVqEiooK6au4uNjpn0fq52iq0lbWgrliRP7HVk6j/gezhiPonNL0XVx9qWJBQUEICgpSuhvkIbZPxHJL5FnWgsh/NSyn4egDXPF56wd1Tmn6Ds2MlHXs2BEBAQEoLS21O15aWgqjUf4X0Wg0Ntne9m9zbRouJLh8+TLKysoc/lxX+mIwGBASEuL085B21E/glyP3iZhlLYgIsF8QwClN/6GZoCwwMBDDhw9HVlaWdMxisSArKwuJiYmyj0lMTLRrDwC7d++W2nfv3h1Go9GuTWVlJXJycqQ2iYmJKC8vR15entRmz549sFgsSEhIcLr/zfWFfIuzS9qdXSJPRP6LU5r+Q1PTl3PnzsWMGTMwYsQIjBo1CitWrEB1dTXuueceAMD06dPRpUsXLF26FADw6KOPYsyYMXj55ZcxYcIEbNmyBQcOHMC//vUvAIBOp8OcOXPw3HPPIS4uDt27d8fTTz+N6OhoqdZYv379MG7cONx3331Ys2YNLl26hNmzZ2PKlCl2Ky+PHTuGixcvoqysDOfPn0dBQQEAID4+HgDwwAMP4PXXX8eCBQtw7733Ys+ePXj33Xexfft271w88hpHS9qTopNkR8E4VUlEzXF2SvPQuUOcztQwTQVld9xxB86dO4fFixfDbDYjPj4eGRkZUgJ9UVER9PrfB/+SkpKwefNm/PWvf8WTTz6JuLg4fPDBBxg4cKDUZsGCBaiursasWbNQXl6Oq6++GhkZGQgODpbabNq0CbNnz8bYsWOh1+sxefJkrFy50q5vN954I3766Sfp+6FDhwKwFqcFrKNy27dvx2OPPYZXX30VXbt2xb///W+YTCb3XyjyuvrVt5vK/+CbJBG1VMMPcA1zUnXQYcFnC2DB7zsGcPRdWzRVp8zfOVvnhLzLlVpjDMqIyF3qv/fYdv0Q+P2Wzvcd9XD2/q2pkTIitWmq1pgtMGMCPxF5Qv0pzV8u/IL5e+fbnecKTe1hUEbUCs3VGmMFfiLyJNuUprnaLFti58jPRzBz10y7D4ic0lQvzay+JFIjR0vVbYEYK/ATkTdwhaZv4EgZUSvY3gjr55RxqpKIlOD0Cs2zh1AUzOlMNWKiv4Yw0V8Z9VdWOnoDM1ebOVVJRKpirjbD9J6p0QpNwLoggNOZ3uNzG5ITKcHZIrCcqiQitZGb0gR+X6HJ6Uz14fQlkQOuFoElIlIbrtDUFgZlRA3YpivLaspYBJaINI8rNLWDQRlRPXaFYKGHDrpGxRhjrohRsIdERC0jtzDJ0QpNzggog0EZ0W8aTVfCWiXbFphxZSURaR1XaKobgzKi38i9OQkILB+9HBEhEVxZSUQ+wZk9NOfvnc8Vmgrg6kvya+ZqM3JLcmGuNjssBDskcghXVhKRT+IKTXXhSBn5rYYbiS9JXMJCsETkd5xdocn3Qs9j8VgNYfFY95ErqqjX6ZE5ORMAWAiWiPySo/fGjeM34sLlC8wxayFn798cKSO/4ky5C05VEpG/kluheVOPmzBt5zSWzPACBmXkN+pPV9ZfVWnDchdERPbTmcEBwVJABrBkhqcx0Z/8QsNyF7ZgrH5yK/PHiIisbFvHXbh8weGsArkfR8rIpzU1XSkg8NLolxARzHIXRERybKvSG+aYcVbBMxiUkc9ypjr/kE5DGIwRETkgl2PGWQXPYVBGPonV+YmI3KPhLgBy75u2WQmuzmwdBmXkk1idn4jIfRruAlCfXM1Hrs5sGQZl5FNsn9ZC2oTI5kEMieR0JRGRuzSaleDqzFZhUEY+o+GntZt63IRtP2xjHgQRkYc42tCcOwC0DIMy8glyn9a2/bANG8dvRE1dDacriYg8wNHqzOCAYOSW5DLHzEWsU0aaZ642Y9ePu2Q/rdXU1bBCPxGRh8htaG7bASB1VypM75mQfjJd4V5qB0fKSNPqT1k2xFo6RESexx0A3IcjZaRZDacs62MOGRGR93AHAPfgSBlpllyCKQAsGLkA1//hegZkRERe5ijH7JcLv8Bcbeb7cjM4UkaaY642I7ckVyp7UZ9ep2dARkSkkIY5ZjroIITA/L3zmV/mBJ0QQjTfjNSgsrISYWFhqKiogMFgULo7inCm7AWLFhIRKctcbcahs4cwf+/8RtvbZU7O9LsPzs7evzl9SZrBshdERNpgDDWiKLjILiADrO/bh84d4pZMDjAoI81wVKTQVvaCiIjUQy6/TAcdFny2ABZwdkMOc8pI9ZrLIWPZCyIi9ZHLLwMAC+zLZZirzYr1UW04Ukaqxq2TiIi0q34Ns18u/IL5e+fbneeWTPYYlJFqMYeMiEj7jKFGGEONMFebWS6jGZy+JNVqLoeMf8BERNrBchnNY1BGqmVLEq2POWRERNo1KW4SMidnYvno5QAgrc5kfpkVgzJSLbmNbplDRkSkbcZQI64MvlK2XIa/b8fEnDJStfpJoswhIyLyDdyOSR5Hykg1bKUvGg5f2za69dc/UiIiX8P8MnncZklDfHmbpYalL1hQkIjI9/nLdkzO3r85UkaKkyt9wYRPIiLfx/wyewzKSHGOSl/44x8kEZG/kVtpr4NOyi/zJwzKSFHmajPKasqk7TdsWPqCiMg/ONqOyR/zy5hTpiG+llNWP4/M9kcoIJhTRkTkh8zVZhw6d0jasNzGF/LLnL1/syQGKaJhHpktGHtp9EsY0mmIpv/4iIjIdcZQozWdBfLpLP5wX+D0JSnCUR5ZRHCEX/zhERFRY452cvGX/DIGZaQIbqFEREQN+Xv9MgZlpAhuoURERHL8eX9M5pSRYriFEhERyTGGGlEUXOSwfpmv3i8YlJGijKFGn/3jIiKilvPH/TE5fUle4WhfSyIiIjn+mF/GOmUaotU6ZdzXkoiIWsoX9sfk3pekCtzXkoiIWsOf9sdkUEYexX0tiYiotfyljBKDMvIY7mtJRETu4C9llLj6kjyi4b6WOujs9rX0tT8kIiLyLH8oo6S5kbJVq1ahW7duCA4ORkJCAnJzc5tsv3XrVvTt2xfBwcEYNGgQduzYYXdeCIHFixejc+fOCAkJQXJyMk6ePGnXpqysDCkpKTAYDAgPD0dqaiqqqqrs2nz99de45pprEBwcjJiYGCxbtszufFpaGnQ6nd1XcHBwK66Eesnta6nT6bB8zHJkTs5kkj8REbWIMdSIkcaRPhmQARoLyt555x3MnTsXS5YswcGDBzFkyBCYTCacPXtWtv2+ffswdepUpKamIj8/HxMnTsTEiRNx5MgRqc2yZcuwcuVKrFmzBjk5OQgNDYXJZEJNTY3UJiUlBUePHsXu3buxbds27N27F7NmzZLOV1ZW4oYbbsAf/vAH5OXl4aWXXsIzzzyDf/3rX3b9MRgMKCkpkb5++uknN18hdeC+lkRERC0gNGTUqFHioYcekr6vq6sT0dHRYunSpbLtb7/9djFhwgS7YwkJCeL+++8XQghhsViE0WgUL730knS+vLxcBAUFibffflsIIcSxY8cEAPHVV19JbXbu3Cl0Op04ffq0EEKIN954Q1x55ZWitrZWavPEE0+IPn36SN+vW7dOhIWFtfCVW1VUVAgAoqKiolXP42lfn/1aDEobJAamDZS+Bq8fLEqqSpTuGhER+ZiSqhKRcyZH1fcYZ+/fmhkpu3jxIvLy8pCcnCwd0+v1SE5ORnZ2tuxjsrOz7doDgMlkktoXFhbCbDbbtQkLC0NCQoLUJjs7G+Hh4RgxYoTUJjk5GXq9Hjk5OVKb0aNHIzAw0O7nnDhxAv/973+lY1VVVfjDH/6AmJgY3HrrrTh69GiTr7m2thaVlZV2X2qXfjId03ZOa1RLhnlkRETkbukn02F6z4TUXak+UVBWM0HZzz//jLq6OkRFRdkdj4qKgtksX/PKbDY32d72b3NtIiMj7c63adMGERERdm3knqP+z+jTpw/Wrl2LDz/8EBs3boTFYkFSUhJOnTrl8DUvXboUYWFh0ldMjLpXLDbMJQMAPfTYOH4j88iIiMitfLEOpmaCMq1LTEzE9OnTER8fjzFjxiA9PR2dOnXCm2++6fAxixYtQkVFhfRVXKzu2l6yuWSwoKauxsEjiIiIWsYX62BqJijr2LEjAgICUFpaane8tLQURqP8tJjRaGyyve3f5to0XEhw+fJllJWV2bWRe476P6Ohtm3bYujQofjuu+/kXzCAoKAgGAwGuy+1stUk08P3i/sREZHyZAvKQo/gAO1WNtBMUBYYGIjhw4cjKytLOmaxWJCVlYXExETZxyQmJtq1B4Ddu3dL7bt37w6j0WjXprKyEjk5OVKbxMRElJeXIy8vT2qzZ88eWCwWJCQkSG327t2LS5cu2f2cPn364Morr5TtW11dHQ4fPozOnTu7chlUyTanb9uXzFYslrlkRETkKQ0LygLW2ZlpO6dpN7fMSwsP3GLLli0iKChIpKWliWPHjolZs2aJ8PBwYTabhRBC3HXXXWLhwoVS+y+//FK0adNGLF++XBw/flwsWbJEtG3bVhw+fFhq88ILL4jw8HDx4Ycfiq+//lrceuutonv37uLChQtSm3HjxomhQ4eKnJwc8cUXX4i4uDgxdepU6Xx5ebmIiooSd911lzhy5IjYsmWLaNeunXjzzTelNs8++6zIzMwU33//vcjLyxNTpkwRwcHB4ujRo06/fjWuviypKhGD1w+2W2k5KG2QyPghQ9UrYYiIyDdoYcW/s/dvTVX0v+OOO3Du3DksXrwYZrMZ8fHxyMjIkJLqi4qKoNf/HjEnJSVh8+bN+Otf/4onn3wScXFx+OCDDzBw4ECpzYIFC1BdXY1Zs2ahvLwcV199NTIyMuwKu27atAmzZ8/G2LFjodfrMXnyZKxcuVI6HxYWhl27duGhhx7C8OHD0bFjRyxevNiultl///tf3HfffTCbzbjyyisxfPhw7Nu3D/379/fkJfM4uTl9AYGIENYkIyIiz7tw+YLDzcq1dh/SCSFE881IDSorKxEWFoaKigrV5JcdPncYKTtSGpXAyJycqbk/BiIi0h5ztRmm90z2K/9Vdh9y9v6tmZwyUh/WJCMiIqX50mblHCnTEDWNlMl+MoEeG2/ciEGdBinYMyIi8kfmarNqNyt39v6tqZwyUg/WJCPykIrTwImdwJkC4GK19VhgKBAdD/QZD4R1UbJ3RKplDDWqLhhzFYMyapGQNiHQQddo6pI1yYha4eAG4KOH5c8VvAXsmAfc8howbLp3+0WkUeZqM4oqixBriNVEwMagjFyWfjIdz2Y/y1wyovqjWkHtgUF/BroOb/lzOQrI6vv4UaDnWI6YETXDdq+yCIt0j1L7ln8MysglTe1vyVwy8hun8oCsvwGFn9ofz1kNDLkTuG21689Z9r1z7YQFKPuhZUHZqTzg8FagtorToeTTHO2LmRSdpOrBAwZl5BLmkpHfe/9B4NBmx+cPbQZGznR9xCyip3PtdHogoodrzw007rdtOrT7GGDskpaP8BGpUFP7Yqo5KGNJDHKJ7F5jzCUjf3Eqr+mAzKZ4v+vPHdbFmi/WJB1w86uuj2411e/Cz4B//481aCPyEVq9V3GkjFxiqwfTcJ5ezZ88iNymKNu5djFXtez5h0235oudyADO5AMXf7Uel1ZfjmvZdKMz/W7pCB+RCsndq6b3U/8CGdYp0xC11SlTaz0YIo85lWcdVWpKS3PKPMmZfgOA6Xkg8SHP94fIS8zVZmw6vgnrj66HgFAs4Z8V/cmjjKFGjDSOZEBG/qXrcGvQJaf7tcDMPeoLyICm+11fS0f4iFRsw7ENUrUAW8K/udqscK/kcfqSiPzHqTzg2wygfVTLVx7etto6zXdkK1BT3bppRW+y9XvP34AfPm18fsidnLokn6O1hH8GZeQUrRXgI7JzKg/44EHg5xO/H2tNIdauw7UZwHQdDkz/8Lf6ar/lrQVdAQz6kzZfD1EzbAn/DTcrV2vCP4MyapYWC/ARSd6dARz7QP6cvxZiDesCjEp1z3O5Y/SRyENsCf/P7HtGmsIUQmDfmX2qvI8xp4ya5KgAn1rn44nsZP3NcUAG/F6IlVrm/QetCwj2LrOOPL7SH3hvpnUkjkglkqKT7L4XEKq9jzEooyY1NR9PpGoVp4HPX26mka5lhVjJce2zw1utwdnBDd7vE5GMosoiu20BAfXexxiUUZNiDbHQQWd3TM3z8UQSZ7Ytuv5vnG5rqeZqn330MEfMSBW0VEiWQRk1ad+ZfXbf66BjsVjShoieQIMPFHau/xvwx0e81h2fE5vYfJsTGZ7vB1EzbHlltsBMBx2m91dnIVkGZeSQLZ+s/rCvTqdrND9PpEphXYBbVqJRYDboduCxY8AfH1WkWz6j63Cgl6npNlWl3ukLUTMmxU1C5uRM3D3gbuigQ9rRNJjeMyH9ZLrSXbPD1ZfkkNbquxA1Ytu2qDjX+n3MKE5XutO0d4FNtwMnM+XP924maCPysg3HNsAC+4VrSdFJqrmnMSgjh7RW34VIVlgXIOw2pXvhu1Lela8Dx2K0pDJaGGhgUEYOcfNxInJK1+HA7FxrcFa837pdEwMyUhktDDRwQ3INUWpDcm4+TkREviD9ZLpdIVkddHgm6RmPF5J19v7NkTJqljHUyGCMlFVxGih4G/jlW2DAJOtek0RELnJUSFYteWUMyohI3b5cCex++vfvv34H6JoAzNylXJ+ISJOaKiSrhqCMJTFIlrnajNySXFVuQ0F+JOvv9gGZzakc1sDyFafygH2vW/8l8jC1F5JlUEaNpJ9Mh+k9E1J3paqyjgv5iS9fBT5f7vj8d7u91xfyDNvembuesv6bdovSPSIf17CQrB56zBk2RxWjZACDMmqAG5CTKlScBnYvbrpNr+u90xfyDLm9M3/8DPjnQGX6Q35jUtwkzBk2BzroYIEFKw6uUM3gA4MyssMNyEkVmtu3MnIAk/21ztHemZXFwKvxXu0K+RdztRkrDq6QcsvUNPjAoIzscANyUoWIno7PGYcCf9nn+DxpQ1N7Z/63ENixwHt9Ib+i5sEHBmVkhxuQkyqEdQFuea3x8V4m4IFPvd4d8oCuw4FuYxyfz/2XdRqbyM3kkv110Kli8IFBGUm4ATmpyrDp1o3Db/wnMPoJYOYe616L5Dvu/gho18nBSQGU/eDV7pB/sCX7N5wVajgooQQGZSRR85Au+amwLsCoVOB/nuS2Pb7q/s/kj+v0QEQP7/aF/EZSdJJdUGYrIqt0XhmDMpKovX4LEfkgaaq63qiFTgfc/Kr1HJEHFFUWwQL1DUKwoj9JjKFGzBk2B6/kvQIBwQ3Iicg7hk0Heo4FinOt38eMYkBGHqXWzck5UkaS9JPp0jJhHXSYM2yOxzdpJSICYA3CBt5m/WJARh6m1iKyDMoIQOOisQICKw6uUHx+nYiIyBPUWESWQRkBYJI/KaDiNFC4l2UPiEgRaiwiy5wyAvDb/Dr0domPaphfJx91cAPw0SMABAAdcMtKa14REZGXNDUYodQ0JkfKCIC1PotdfTIWjSVPqTgNfPQwIP2+Cev3HDEjIi9SY8UBBmUkWzQWAIvGkmdsniJ//NAW7/aDiPyaXBFZIYSiRWQZlJHsEK6AYD4Zud+pPKD0a/lzZw55ty+kPafygH2vW/8lcoOGgw9KF5FlThlJm5DXHylTegiXfFTeOsfnOg/xXj9Ie95/EDi0+ffvh9wJ3LZauf6QTyiqLGo0S6RkXhlHyoibkJP3XKhwfC7ewbQm0ak8+4AMsH7PETNqJbXllTEo83PchJy8amiK/PFR97NgKDl2wMEI69u3e7cf5HMaFZFVeCcbTl/6OTUuCSYf1mcc0DUBOJXz+zFjPHDjMsW6RBpQ42CEtfpn4ESG9feKqIUmxU1CUnQSis8XI+aKGEXvfQzK/Jxa9/8iHzZzl/VG+t1uoNf1vKFS84amAN98JH+uYDN/h6jVjKFGVQxEcPrSzzVcEsx8MvKKPuOACS/zZkrO6TMOCOkofy44zLt9IfIgBmUEAHZBGRGR6qS8K398+N1e7QaRJzEo83PSRuS/ba9kgfJ7fxERNdJ1uLUMRn1D7rQeJ3IDc7UZuSW53PuSlMNEfyLSjNtWAyNnAsX7gZirGJCR26SfTLcOUAiLtAJzUtwkr/eDQZmfY6I/EWlK1+EMxsitpBmj3+6DFmGdMUqKTvL64ASnL/2cMdSIm3rcZHfsph43cZSMSCGp63LR/+mdSF2Xq3RXiPxCUzNG3saRMj9nrjZj2w/b7I5t+2EbHh76MAMzIg/LOm7GK7tP4ueqWgQF6PDTf2t+P3fiHLot3I6IkDaouWxBYo8O+H/3jFKwt0S+SU0zRhwp83Nq+oRAPqziNFC41/ovAQAmvfElUtfn4ciZSpgra+0CsvrKLlzGr5csUpBGRO6lphmjFgdlZ8+exeeff47PP/8cZ8+edWefyIvUtu8X+aCDG4AVA4H1N1v/PbhB6R4pLuu4GQeLylv02GHPZrq3M0R+ztGMkRKrMF0Oys6fP4+77roLXbp0wZgxYzBmzBh06dIF06ZNQ0VFE5sNkyoZQ42YM2yOVJ9M6X2/yMdUnAY+ehiwjcYKC/DRI34/Ypa6vuUbaZdduMwRMyI3UtOMkctB2cyZM5GTk4Nt27ahvLwc5eXl2LZtGw4cOID777/fE320s2rVKnTr1g3BwcFISEhAbm7TybBbt25F3759ERwcjEGDBmHHjh1254UQWLx4MTp37oyQkBAkJyfj5MmTdm3KysqQkpICg8GA8PBwpKamoqqqyq7N119/jWuuuQbBwcGIiYnBsmWN9/Jrri9KSD+ZjhUHV0BAQAcd5gybo8gyYPJRJ3bKHBTWbZb8lLsCKgZmRO6hphkjl4Oybdu2Ye3atTCZTDAYDDAYDDCZTPjf//1ffPzxx57oo+Sdd97B3LlzsWTJEhw8eBBDhgyByWRyOH26b98+TJ06FampqcjPz8fEiRMxceJEHDlyRGqzbNkyrFy5EmvWrEFOTg5CQ0NhMplQU/N7fkdKSgqOHj2K3bt3Y9u2bdi7dy9mzZolna+srMQNN9yAP/zhD8jLy8NLL72EZ555Bv/6179c6ou3NVwGLCCw4uAKFo4l9/npS9eO+zh3r6j06xWazFMkN7FtN2gLzJScMdIJIYQrD4iNjcX27dsxaNAgu+Nff/01brzxRpw6dcqtHawvISEBI0eOxOuvvw4AsFgsiImJwcMPP4yFCxc2an/HHXeguroa27b9Pld81VVXIT4+HmvWrIEQAtHR0Zg3bx4ef/xxAEBFRQWioqKQlpaGKVOm4Pjx4+jfvz+++uorjBgxAgCQkZEhvdbo6GisXr0aTz31FMxmMwIDAwEACxcuxAcffIBvvvnGqb44o7KyEmFhYaioqIDBYGjBFbSXW5KL1F2pjY6vNa3FSOPIVj8/Ef59PXBKJnDommDdmNzP9H96J369ZJE910YHBLbRS6ssU9flIvuHX1B7yYI6B8/Xrq0ex/4+3nMdVquDG6zT4ja3vAYMm65cf8gnmKvNKD5fjJgrYtwekDl7/3Z5pOyvf/0r5s6dC7P599EUs9mM+fPn4+mnn25Zb51w8eJF5OXlITk5WTqm1+uRnJyM7Oxs2cdkZ2fbtQcAk8kktS8sLITZbLZrExYWhoSEBKlNdnY2wsPDpYAMAJKTk6HX65GTkyO1GT16tBSQ2X7OiRMn8N///tepvsipra1FZWWl3Zc7qWnIlnxUQKCD40He7YdKBLdx/Jb73dIJOPb38VLZi/93zygc+/t4fP/ChBY9n8+y5SnW99HDHDGjVjOGGjHSOFLRnGqX/6JXr16N/fv3IzY2Fr169UKvXr0QGxuLffv24c0338SwYcOkL3f6+eefUVdXh6ioKLvjUVFRdgFifWazucn2tn+baxMZGWl3vk2bNoiIiLBrI/cc9X9Gc32Rs3TpUoSFhUlfMTHuDZbUtAyYfFSP6xwcv9ar3VCLmsvyo2Tt2jb9VuzovKPn82kFbzs4vsW7/SDyAJeLx06cONED3SA5ixYtwty5c6XvKysr3RqYsXAseVz8VOCTv8scn+L9vqhAcBu97PTlr5csSF2XK1scNnVdrsMpT78cKStyMLtQtN+7/SCfY642o6iyCLGGWMXugS4HZaNHj8Z118l/+n3zzTc9tgKzY8eOCAgIQGlpqd3x0tJSGI3yF89oNDbZ3vZvaWkpOnfubNcmPj5eatNwIcHly5dRVlZm9zxyP6f+z2iuL3KCgoIQFOS5aR5uRk4eF9bFmu/TMP8nrItyfVJQUyNbDSv4B7fRo+zC5RY/n8+yOLgmlove7Qf5FLVsSO7yx6xx48Zh/vz5uHTpknTs559/xs033yybbO8ugYGBGD58OLKysqRjFosFWVlZSExMlH1MYmKiXXsA2L17t9S+e/fuMBqNdm0qKyuRk5MjtUlMTER5eTny8n6vK7Rnzx5YLBYkJCRIbfbu3Wt3TXbv3o0+ffrgyiuvdKovSmBOGXnFsOnAY8eAGdus//pxQnZijw7NtrFV8G8uIHP2+XyOvq38cUf5i0TNcLQhuSaKx37yySd4//33MXLkSBw7dgzbt2/HwIEDUVFRgYKCAg908Xdz587F//7v/2L9+vU4fvw4HnzwQVRXV+Oee+4BAEyfPh2LFi2S2j/66KPIyMjAyy+/jG+++QbPPPMMDhw4gNmzZwMAdDod5syZg+eeew4fffQRDh8+jOnTpyM6Olqapu3Xrx/GjRuH++67D7m5ufjyyy8xe/ZsTJkyBdHR0QCAO++8E4GBgUhNTcXRo0fxzjvv4NVXX7WbemyuL0pQ0zJg8nFhXYDu1/jtCJmNu/eu9Mu9MP9wlfzxWAfHiZqhpuKxLk9fJiUloaCgAA888ACGDRsGi8WCv//971iwYAF0Op0n+ii54447cO7cOSxevBhmsxnx8fHIyMiQEuiLioqg1/8eZyYlJWHz5s3461//iieffBJxcXH44IMPMHDgQKnNggULUF1djVmzZqG8vBxXX301MjIyEBwcLLXZtGkTZs+ejbFjx0Kv12Py5MlYuXKldD4sLAy7du3CQw89hOHDh6Njx45YvHixXS0zZ/qihElxk5AUneSxZcBEZO/HFya4pfDrj02syvRpQ6YCe2TyFIf4Z54itZ6aNiR3uU4ZABw8eBB33nknLl++jDNnzmDKlCl47bXXEBoa6ok+0m/cXaeMiJSTui4XWSfOufy4sX06+ecIWX0HNwAfP2rdtkunB25+1a+nxan1PJ1T5rE6ZS+88AISExNx/fXX48iRI8jNzUV+fj4GDx7cZM0tIiL63f+7ZxR+fGECxvbp5FT7sX064ccXJjAgA6wB2Jwj1jzFOUcYkJFb2MaoWjBW5TYuj5R17twZa9euxfjxv1eRvnTpEp588kmsXLkStbW1bu8kWXlypEwNS4GJ/Jmtgn9wG720+rLmskWq8E9EnmGuNsP0nqnR9GXm5Ey33Q+dvX+7nFN2+PBhdOzY0e5Y27Zt8dJLL+Gmm25y8ChSM7UsBSbyZwy8iJShpvJQLk9fNgzI6hszZkyrOkPep6alwERERN6mpvJQflgOmupT01Jg8gMVp4Ej6dYv7lVIRCqgpvJQLk9fkm9R01Jg8nEHNwAfPQKgXhrrLa8xSZuIVEENif4cKfNztk8IOlhrzOmgYwFZcr+K09YSBmjwZvfRwxwxIyJF2dJ4xG/vTwJCOxX9yTfVD8qI3K7se2tNKTmHtni3L6RdFaeBwr0M5Mmt1JTGw6DMz0mJ/vgt0R9M9CcPiOjp+Nz+N73XD9KurL8Br/QH1t8MvDLAOh1O5AaxhthGAxJM9CdFqOkTAvmwsC5Ap/7y534tBU7lebc/pC3vzgA+f7neAWHNT+SIGbnBvjP77L5XMo2HQZmfU9NSYPJxyUscnyve771+kLacygOOfSBzQgDFud7uDfmYhvlkAKDT6ZAUnaRIfxiU+Tk1LQUmH9dnHBA5QP5czFXe7QtpR9bflO4B+TC1zRaxJAZhUtwkJEUnofh8MWKuiGFARp7zl31A2i3Aj5/9fmzInUDX4cr1idSr4jRQ+Knj8zHcBYFaR21loRiUEQDriBmDMfKKuz+yTkkV77eOkDEgI0eKcxyf636tNVeRqBWMoUbMGTYHK/JWwAKL4rNFDMrIDjcmJ6/oOpzBGLXO2MVK94B8QPrJdKw4aA3IdNBhzrA5iu79zJwykqSfTIfpPRNSd6XC9J4J6SfTle4SEfmzmARArnZiv4kM6qnVGu79LCCw4uAKRUtCMSgjANyYnIhUKKwLcMtKQFohrgOueRy4Y72i3SLfoLYkf4DTl/Sbpn45OY1JRIoZNh3oORYo+wGI6ME8MnKbWEMs9NBLxdMB5UtCMSgjAOpbgUJEJAnrwmCM3G7fmX329clUsPczpy8JQON6ZbaER46SERGRr5ErGgtAsaKxNgzKSDIpbhLmDJsDHXRSwiOT/UkR+ZuAzVOs/xIRuZlcyo6AUHyLQQZlJDFXm7Hi4ArpkwOT/UkRr8YDH/4F+Han9d/lvZXuERH5GLVuMcigjCRqXIlCfiZ/E/DfQvtjVaXAS3HK9IeIfJJatxhkoj9J5JL9ddAp/smB/Mjxj+WPV58FVo4AHjng3f6Q553KA4qygdhE1h4jr1LjFoMcKSOJ7ZODrkGxxn1n9inUI/I7/W52fK7sJHAiw3t9Ic9LuwX49/8Au56y/vv+g0r3iPyMMdSIkcaRqgjIAAZl1EBSdJJdUCYgmFdG3jM0BWgf5fj8d7u91xfynIrTwLJe9hvTA8ChzdaRMyI/xaCM7BRVFtkV0gOYV0Ze9vi3QGik/Lle13u3L+R+BzcAr/QHfj0nf754v3f7Q37JXG1Gbkmu6gYcGJSRHbWuSCE/M/8kENEgub9rAtBnnDL9IfeoOA189HDTbWKu8k5fyG+peZ9nBmVkRy6vTAjBvDLyvkcOAFPfAUbOtP47c5fSPaLWKs5p+ny3MUz2J49S+z7PDMqokYYVjZlXRorpMw6Y8DJHyPyBIQa4+yOle0E+Tu2lnxiUUSNFlUWNtp5Q0y8tEWlUTALQYHU3AODK7sDcI17vDvkftafoMCijRtT+S0tEGhXWBbhlJSC9v+iAUfcDjxYo2SvyI8ZQI+YMmwM91FU01obFY6kRW16Zbd5dBx2m95+udLeIyBcMmw70HAuU/QBE9LAGakRekn4yHSsOroAF1nvbnGFzMCluktLdkuiEEKL5ZqQGlZWVCAsLQ0VFBQwGg8d/nrnajE3HN2HD0Q2wwCJ9olDTLzBRIxWngUNvAz+fBAbcxnw0IgJgvaeZ3jPZ5ZTpdXpkTs70+EiZs/dvjpRRkzYc2yDVLbOtUkmKTlLNUC+RnYMb7EsufL3FWox2yttc1Ufk55pK8lfLPY05ZeSQ2lepENmpOA189Ejj41Wl1i183p3h/T75ulN5wL7XWYWfNEEL+dIMysghuV9gblBOqlX2PYAmsjGOfQBk/c1bvfFtp/KA10Zy30rSFFu+tO2+prYkf4BBGTWBG5STpkT0hGy5hfo+f9k6okYtt/F2axD2y7f2x7lvJWnApLhJyJycibWmtcicnKm6HGkGZdQkblBOmmErt9Ccsh883xdftel24LtMx+dPNnGOSCWMoUaMNI5U1QiZDYMyahI3KCdNGTYdeOwY0LGfgwZ6axkGct2pvOaDrtAo7/SFyEcxKKMmySZGQo/ggGCFekTUjLAuwOz9wDXzGpzQAbe8yrpYLVWU3Xwblh8hlTJXm5Fbkqv6WR7WKdMQb9cps0k/mW63gSsA1iwjbag4DRTnWv9/zCgGZK1xKs+aS+bILa9ZRyqJVKb+PUype5ez928GZRqiVFAGAIfPHUbKjhS7PTG9VXSPSFG2YrQ/7Qf0AUBEd2DQn/2z7tn7D1oT+usbdDuQ/AwDXlIlJQvG1sfiseRWFy5fcLhJOYMy8lkNi9Ha5KwG4kxAyrve75OrKk4DJ3YCZwqAoPatCyhvWw2MnAl8m2ktyttnHIMxUjUtFIytj0EZOcWWW9bw0wZrlpHPclSM1uZkprU8xDSVBmYVp4H/WwIc3mp/PGc1MOROa4DVEl2H++coIWlSSJsQ6KBrNMuj1nsXE/3JKQ2L7nGTcvJ5zRWjBazlIVpTm6viNHAk3frlzvppBzcAr/RvHJDZsKYY+YH0k+mYtnNao4BMbQVj6+NIGTltUtwkJEUnSZuUpx1Nw4ZjG5jwT75JKkbbTGBWvL9lI0cHN/w2Elfv+TsPA6IGANHxQJ/xLZsarDgNfPxo8+1a2m8iDTBXmxstUNNBh43jN2JQp0EK9qxpHCkjl8ltUq72ZcZELnO2GG3MVa4/txQ4NQj4Sg4CBW8BO+ZZR7oObnD9ucu+Bxrk0MhqSb+JNEIul0xAoKauRqEeOYdBGbmEm5STX7EVo/2fxUCvG4D20fbnh9zZstEmZwOnjx5xfVozoiega+atvaX9JtIILWw+LofTl+QSuYR/HXQsJku+K6wLMLpeIdpTedapv5irWh7YODs1CmHdFsqVacywLsDNrzaeGgWAjn2AiasZkJFfmN5vOjYc32BXn0ytuWQ2rFOmIUrWKauPxWSJ3ODLlcDup5tppAMeO9ry3LITGdZSGMGhwEA/ra1Gfqf+PUoHHWYMmIGUfimKBmQsHuuD1BKUASwmS+QWX74K7F7s+Dyr5BO5RC3FYhti8VjyKBaTJXKDPz4KDPzT7yNaF6uBwHZA9FAWZiVqAa0Vi22IQRm1CIvJErlJWBdgVKrSvSDyCVorFtsQV19SizQsJquVJEoiIvJNWiwW2xBzyjRETTllNuZqM4rPFyPmihjN/NITEZFvkc0lgx4bb1RHsVjmlJFXGEONDMaIiEhRsrlksKi+WGxDnL4ktzNXm5Fbkssq/0RE5HHmajPKasqgh/aKxTakmaCsrKwMKSkpMBgMCA8PR2pqKqqqqpp8TE1NDR566CF06NAB7du3x+TJk1FaWmrXpqioCBMmTEC7du0QGRmJ+fPn4/Lly3ZtPv30UwwbNgxBQUHo1asX0tLSGv2sVatWoVu3bggODkZCQgJyc3Ptzl977bXQ6XR2Xw888EDLLoaKpZ9Mh+k9E1J3pcL0ngnpJ9OV7hIREfko2z1n/t75EBDQQQdAe7lkNpoJylJSUnD06FHs3r0b27Ztw969ezFr1qwmH/PYY4/h448/xtatW/HZZ5/hzJkzmDTp9+KmdXV1mDBhAi5evIh9+/Zh/fr1SEtLw+LFv9cNKiwsxIQJE3DdddehoKAAc+bMwcyZM5GZmSm1eeeddzB37lwsWbIEBw8exJAhQ2AymXD27Fm7/tx3330oKSmRvpYtW+amq6MODTeA5b6YRETkKQ3vObYE/+WjlyNzcqYmi5lrItH/+PHj6N+/P7766iuMGDECAJCRkYEbb7wRp06dQnR0dKPHVFRUoFOnTti8eTP+9Kc/AQC++eYb9OvXD9nZ2bjqqquwc+dO3HTTTThz5gyioqIAAGvWrMETTzyBc+fOITAwEE888QS2b9+OI0eOSM89ZcoUlJeXIyMjAwCQkJCAkSNH4vXXXwcAWCwWxMTE4OGHH8bChQsBWEfK4uPjsWLFCqdfd21tLWpra6XvKysrERMTo6pE//pyS3KRuqvx0v61prUYaRypQI+IiMhXaeme42yivyZGyrKzsxEeHi4FZACQnJwMvV6PnJwc2cfk5eXh0qVLSE5Olo717dsXsbGxyM7Olp530KBBUkAGACaTCZWVlTh69KjUpv5z2NrYnuPixYvIy8uza6PX65GcnCy1sdm0aRM6duyIgQMHYtGiRfj111+bfN1Lly5FWFiY9BUTo+65cbkNYLkvJhEReYKtJll9Wswjq08TQZnZbEZkZKTdsTZt2iAiIgJms/zUmNlsRmBgIMLDw+2OR0VFSY8xm812AZntvO1cU20qKytx4cIF/Pzzz6irq5NtU79vd955JzZu3IhPPvkEixYtwltvvYVp06Y1+boXLVqEiooK6au4uLjJ9kprWLsMsA4nT9s5jbllRETkNr5Qk0yOoiUxFi5ciBdffLHJNsePH/dSbzyrfv7boEGD0LlzZ4wdOxbff/89evbsKfuYoKAgBAUFeauLbjEpbhLiwuPs9sW05ZYlRSdp+o+FiIiU1zCXDLDOymwcr46aZK2haFA2b9483H333U226dGjB4xGY6Ok+cuXL6OsrAxGo/xN3mg04uLFiygvL7cbLSstLZUeYzQaG62StK3OrN+m4YrN0tJSGAwGhISEICAgAAEBAbJtHPUNsOahAcB3333nMCjTKu6LSUREniJXk0xAaK4mmRxFpy87deqEvn37NvkVGBiIxMRElJeXIy8vT3rsnj17YLFYpOCmoeHDh6Nt27bIysqSjp04cQJFRUVITEwEACQmJuLw4cN2Ad/u3bthMBjQv39/qU3957C1sT1HYGAghg8fbtfGYrEgKytLaiOnoKAAANC5c2dnLpWmOMot++XCL1yJSURELWarSeZruWQ2mlh9CQDjx49HaWkp1qxZg0uXLuGee+7BiBEjsHnzZgDA6dOnMXbsWGzYsAGjRo0CADz44IPYsWMH0tLSYDAY8PDDDwMA9u3bB8BaEiM+Ph7R0dFYtmwZzGYz7rrrLsycORPPP/88AGtJjIEDB+Khhx7Cvffeiz179uCRRx7B9u3bYTKZAFhLYsyYMQNvvvkmRo0ahRUrVuDdd9/FN998g6ioKHz//ffYvHkzbrzxRnTo0AFff/01HnvsMXTt2hWfffaZ09dAjdssOZJ+Ml0aXrb98QgIac5fi0uViYhIOVq+rzh9/xYa8csvv4ipU6eK9u3bC4PBIO655x5x/vx56XxhYaEAID755BPp2IULF8Rf/vIXceWVV4p27dqJ2267TZSUlNg9748//ijGjx8vQkJCRMeOHcW8efPEpUuX7Np88sknIj4+XgQGBooePXqIdevWNerfa6+9JmJjY0VgYKAYNWqU2L9/v3SuqKhIjB49WkRERIigoCDRq1cvMX/+fFFRUeHSNaioqBAAXH6cUkqqSkRGYYYYnDZYDEwbKH0NXj9YlFSVNP8EREREwno/Gby+8b0kozBDE/cTZ+/fmhkpI22NlNloqY4MERGpk9bvJT5Vp4y0Sy6/TK/TM7+MiIic4kt7WzaHQRl5VMPaZTroIITA/L3zuTcmERE1ydf2tmwOpy81RIvTlzbmajMOnT0k/WHZ6HV6ZE7O9Lk/LCIiah1ztRmm90yN6pG9NPolDIkcoqn7BqcvSVWMoUZcGXylw/plRERE9TmqRxYREqGpgMwVDMrIa1i/jIiInOUoJ9nX8sjqY1BGXiOXXwaA+WVERGTHXG1GUWUR5gybI90zfDWPrD7mlGmIlnPK6jNXm3Ho3CEs+GwBLPh9aJr5ZUREVL9IrF6nx5xhczCw40DEXBGj2fsDc8pItYyhRlwZdKVdQAYwv4yIyN813GzcIixYcXCFpgMyVzAoI0Uwv4yIiBqSS+73pw/sDMpIEcwvIyKihvwxub8+BmWkmElxk5A5ORPLxyy3FpX9rVyGRVjwbPazHDEjIvIzDT+w+0Nyf31tlO4A+TdjqNE6XO0gv8xf/hCJiMhqUtwkJEUnofh8sd/kktkwKCPF2Yar6+cR1N8f05/+IImI/Imt9EWsIdbuvd4YavTL935OX5LiuD8mEZH/se1rmborle/1v2GdMg3xlTpljnB/TCIi/yC3r6Uvv9ezThlpTlP7Yx46dwi5JblM/ici8gH+XvrCEeaUkarI5ZfpoJOq/9tW4kyKm6RgL4mIqKXM1WaU1ZRBD32jXV38pfSFIxwpI1VxVL/M9ofLchlERNplyyOzpanY3uP9rfSFIxwpI9Wpvxz6lwu/YP7e+XbnWS6DiEh7Gm6hZAvKlo9ejiGRQ/ieDgZlpFK25dDmarPsdCbLZRARaYtcHpmAQERIBN/Lf8PpS1I1bsdEROQb/H0LJWcwKCPV43ZMRETa5+9bKDmD05ekCdyOiYhI+/x5CyVnMCgjzXC0HROHvomItMNft1ByBqcvSTM49E1EpA3majMLfrcAR8pIUzj0TUSkbukn06XSFyz47Rrufakhvr73pbuYq80oqixCrCGWQRsRkRf5256WznL2/s2RMvIp/IRGROR9tg/DZTVlDve09OegzFkMyshnNKwWbSuZkRSdxDcDIiIPqf9hWPfb/2yliwAuyHIFE/3JZ8hVi7Z9QiMiIveT2zoJABdktRBHyshnOCqZERwQjNySXOaYERG5maOtk14a/RIigiO4IMtFDMrIZ9hKZtTPKbupx02YtnMac8yIiNzIlkMW0iZE9sPwkE7cYLwluPpSQ7j60jnmajOKzxcjOCBYCshsuAqIiKh1Gi6ouqnHTdj2wzZ++G0CV1+S37JVi84tyeUqICIiN5JbULXth23YOH4jaupqOF3ZSgzKfFBdXR0uXbqkdDcU1zmoM6KDolF/MFin08EYaERNTY1d27Zt2yIgIMDbXSQi0oTmSl7U1NVgpHGkQr3zHQzKfIgQAmazGeXl5Up3RTWe7/88ymvLpe/Dg8JRVVqFKlQ1ahseHg6j0QidTufFHhIRqZvddCX0LHnhQQzKfIgtIIuMjES7du0YXPzmUt0lXLJcQlt9W7QNaNvo/MXLF1FVXYVffvkFANC5c2dvd5GISJUaTVfCvhYZS164F4MyH1FXVycFZB06dFC6O6oSjGCH5/5b81+cqTkDBACWdhacOnsKkZGRnMokIoLjkhfLRy9HRAhLXrgbgzIfYcsha9euncI90Y5LdZdwpuqM9L0uUIfKi5U4U3kGMVdyKJ6I/FezJS8iWfLCExiU+RhOWTrvYt1F+wO/XboTZSdQUlPCYrNE5JecKXnB90bPYFBGfiswIFD2+Eu5L+HMxTOst0NEfoclL5TFvS/Jb7UNaIvo9tGNjttWFdk2NDdXm73dNSIirzJXm5FbkouCswVNlrxgQOZZDMpIcXv37sXNN9+M6Oho6HQ6fPDBB259/i+//BJt2rRBfHx8o3NXBl+J3lf2RrewbrJvNtzQnIh8XfrJdJjeMyF1VyoW7F0AHezTYFjywnsYlFEjJRUXsO/7n1FSccErP6+6uhpDhgzBqlWr3P7c5eXlmD59OsaOHeuwTduAtghtG4rggMarNOtvaM4RMyLyNQ2nK20zBXqdXvqXOWTew5wysvPOV0VYlH4YFgHodcDSSYNwx8hYj/7M8ePHY/z48Q7P19bW4qmnnsLbb7+N8vJyDBw4EC+++CKuvfbaZp/7gQcewJ133omAgIBmR+DaBrRFeFC4tFiCG5oTka9qqkK/gMBLo19CRDBLXngbgzKSlFRckAIyALAI4Mn0IxjduxM6h4Uo1q/Zs2fj2LFj2LJlC6Kjo/H+++9j3LhxOHz4MOLi4hw+bt26dfjhhx+wceNGPPfcc079rHZt2+HfN/wb5ovmRhua23LMkqKT+CZFRJrlTIX+IZ1Y8kIJnL4kSeHP1VJAZlMnBH78+VdlOgSgqKgI69atw9atW3HNNdegZ8+eePzxx3H11Vdj3bp1Dh938uRJLFy4EBs3bkSbNq599ujUrhNGGkfiwuULDjc0tyXFckqTiLRErkI/ACmPjNOVyuJIGUm6dwyFXge7wCxAp0O3jsoVpD18+DDq6urQu3dvu+O1tbXSzgXt27eXjk+bNg2rVq3CnXfeiWeffbbR41wRa4iVLZp45OcjmLlrJqc0iUgTbFOVsYZYVuhXOQZlJOkcFoKlkwbhyfQjqBMCATodnp80UNGpy6qqKgQEBCAvL6/R1ke2YKygoEA6ZjAYcP78eRw4cAD5+fmYPXs2AMBisUAIgTZt2mDXrl34n//5n2Z/tjHUiCWJS+yKKM4ZNgcrDq7glCYRaULDQrBzhs1hhX4VY1BGdu4YGYvRvTvhx59/RbeO7RQNyABg6NChqKurw9mzZ3HNNdfItunVq5fd9xaLBYcPH7Y79sYbb2DPnj34z3/+g+7duzv98yfFTUJSdBKKzxcj5ooY2U+ZFmHBoXOHpE+ifGMjIjWQKwS74uAKuw+XnK5UFwZl1EjnsBCvBmNVVVX47rvvpO8LCwtRUFCAiIgI9O7dGykpKZg+fTpefvllDB06FOfOnUNWVhYGDx6MCRMmNHo+vV6PgQMH2h2LjIxEcHBwo+POMIYa7d6wGn7K1EGHBZ8tgAWcziQiZTU3VWkRFgzsOBCZkzOlD5sMyNSDQRkp7sCBA7juuuuk7+fOnQsAmDFjBtLS0rBu3To899xzmDdvHk6fPo2OHTviqquuwk033eT1vjac0rQlx9qSZetPZwLg6BkReY2zU5W2QIzvS+qjE0KI5puRGlRWViIsLAwVFRUwGAx252pqalBYWIju3bsjOLhxEVRqnivX0FxtRvH5Yvxy4RfM3zu/0fm7B9yNDcc2cDEAEXmFudoM03umRgGY3FQl34u8r6n7d30cKSNqAdunTHO1WXY6c8PRDbKjZ/xkSkSewKlK38A6ZUStYJvOrL8lyYwBM6SAzIb1zYjIk2wlfOqrP1XJzcS1gSNlRK3UcIUmAGnq0ob1zYjIk+RK+HBVpfYwKCNyg4ZJs6xvRkTuVn9lpdz7RsMPiHxv0R7NTF+WlZUhJSUFBoMB4eHhSE1NRVVVVZOPqampwUMPPYQOHTqgffv2mDx5MkpLS+3aFBUVYcKECWjXrh0iIyMxf/58XL582a7Np59+imHDhiEoKAi9evVCWlqa3fm9e/fi5ptvRnR0NHQ6nezG10IILF68GJ07d0ZISAiSk5Nx8uTJFl0LUr9JcZOQOTkTa01rkTk5EwM6DOCWTUTUYukn02F6z4TUXakwvWdC+sl02XacqtQ2zQRlKSkpOHr0KHbv3o1t27Zh7969mDVrVpOPeeyxx/Dxxx9j69at+Oyzz3DmzBlMmvT7dFFdXR0mTJiAixcvYt++fVi/fj3S0tKwePFiqU1hYSEmTJiA6667DgUFBZgzZw5mzpyJzMxMqU11dTWGDBmCVatWOezLsmXLsHLlSqxZswY5OTkIDQ2FyWRCTU1NK64KqVn9N0dH+R5Hfj7i1BstEfmX+h/W5IrAPpv9LD/I+SBNlMQ4fvw4+vfvj6+++gojRowAAGRkZODGG2/EqVOnEB0d3egxFRUV6NSpEzZv3ow//elPAIBvvvkG/fr1Q3Z2Nq666irs3LkTN910E86cOYOoqCgAwJo1a/DEE0/g3LlzCAwMxBNPPIHt27fjyJEj0nNPmTIF5eXlyMjIaPRzdTod3n//fUycOFE6JoRAdHQ05s2bh8cff1zqX1RUFNLS0jBlyhTZ111bW4va2lrp+8rKSsTExLAkhod4+hrK1RCqP6UJWAO1zMmZ/JRL5McavldM7z8daUfTGrVba1qLkcaR3u8guczZkhiaGCnLzs5GeHi4FJABQHJyMvR6PXJycmQfk5eXh0uXLiE5OVk61rdvX8TGxiI7O1t63kGDBkkBGQCYTCZUVlbi6NGjUpv6z2FrY3sOZxQWFsJsNts9T1hYGBISEpp8nqVLlyIsLEz6iomJcfpnkvpwSpOImiM3Krb+6HroIb+yknyLJoIys9mMyMhIu2Nt2rRBREQEzGb5m5bZbEZgYCDCw8PtjkdFRUmPMZvNdgGZ7bztXFNtKisrceHCBaf7X/+55foiZ9GiRaioqJC+iouLnfp5pF6c0iSihup/CJOrNyYgMH3AdLvSO1xZ6ZsUXX25cOFCvPjii022OX78uJd6oz5BQUEICgpSuhvkIXJL2LlKk8i/OLs1Ukq/FKT0S+HKSh+n6EjZvHnzcPz48Sa/evToAaPRiLNnz9o99vLlyygrK4PRKP+LaTQacfHiRZSXl9sdLy0tlR5jNBobrca0fd9cG4PBgJAQ5zbttj2X3PM46r8/cWb1qqu++OIL/PGPf0SHDh0QEhKCvn374pVXXml9Z93MlSlNItK+5hL4VxxcIQVmgP2oGFdW+j5FR8o6deqETp06NdsuMTER5eXlyMvLw/DhwwEAe/bsgcViQUJCguxjhg8fjrZt2yIrKwuTJ08GAJw4cQJFRUVITEyUnvcf//gHzp49K02P7t69GwaDAf3795fa7Nixw+65d+/eLT2HM7p37w6j0YisrCzEx8cDsCb95eTk4MEHH3T6ebym4jRQ9j0Q0RMI6+LxH2dbvXrvvffarY5tjdDQUMyePRuDBw9GaGgovvjiC9x///0IDQ1tdtWutzWsceZoA2E5zdUtIiL1aJTA3286t0Yie0Ijxo0bJ4YOHSpycnLEF198IeLi4sTUqVOl86dOnRJ9+vQROTk50rEHHnhAxMbGij179ogDBw6IxMREkZiYKJ2/fPmyGDhwoLjhhhtEQUGByMjIEJ06dRKLFi2S2vzwww+iXbt2Yv78+eL48eNi1apVIiAgQGRkZEhtzp8/L/Lz80V+fr4AIP75z3+K/Px88dNPP0ltXnjhBREeHi4+/PBD8fXXX4tbb71VdO/eXVy4cMHpa1BRUSEAiIqKikbnLly4II4dO+bS88nKWy/EM+FCLDFY/81b37rncxEA8f7779sdq6mpEfPmzRPR0dGiXbt2YtSoUeKTTz5x+blvu+02MW3aNIfn3XYNW+m9b98Tg9cPFgPTBorB6weL9759r1XtiEh5JVUl0t+r7Wvw+sFiUNqgRsdKqkqU7i65WVP37/o0U9F/06ZNmD17NsaOHQu9Xo/Jkydj5cqV0vlLly7hxIkT+PXXX6Vjr7zyitS2trYWJpMJb7zxhnQ+ICAA27Ztw4MPPojExESEhoZixowZ+Nvf/ia16d69O7Zv347HHnsMr776Krp27Yp///vfMJlMUpsDBw7guuuuk76fO3cuAGDGjBlSodkFCxaguroas2bNQnl5Oa6++mpkZGSoq3xFxWng40cB2yc3YQE+ngP0HOuVETNHZs+ejWPHjmHLli2Ijo7G+++/j3HjxuHw4cOIi4tz6jny8/Oxb98+PPfccx7ubes5U5XbUd0i5p4RqUf9kWxHG4bfPeBuaVs2JvCTJuqUkVVTdU7cUmOrcC+w/ubGx2dsA7pf07LndFHDOm9FRUXo0aMHioqK7OrRJScnY9SoUXj++eebfL6uXbvi3LlzuHz5Mp555hk8/fTTDttqqdZbbkkuUnelNjpuq1vEaU0iZblSlxAApyp9nLN1yjQzUkZeENET0Ol/HykDAF0AENFDsS4dPnwYdXV16N27t93x2tpadOjQAQDQvn176fi0adOwZs0a6fvPP/8cVVVV2L9/PxYuXIhevXph6tSp3um8B9nKacjlnjW8GXDjcyLPq/9BCIDDBH5bYNZwVIzBGAEMyqi+sC7Aza9apyxFnTUgu3mFolOXVVVVCAgIQF5eHgICAuzO2YKxgoIC6VjDTyDdu3cHAAwaNAilpaV45plnfCIokyunsSRxCYDGNwPbtCYAjp4ReYBcBX4m8FNLMCgje8OmW3PIyn6wjpApGJABwNChQ1FXV4ezZ8/immvkp1B79erl1HNZLBa7bau0Ti73LLckV/ZmsOn4pkZ5Kxw9I3Jdw9SApirwW9B4JLvhamui+hiUUWNhXbwajFVVVeG7776Tvi8sLERBQQEiIiLQu3dvpKSkYPr06Xj55ZcxdOhQnDt3DllZWRg8eDAmTJgg+5yrVq1CbGws+vbtC8BaC2358uV45JFHvPKavKXhG7zctKYOOmw4ukG6QXD0jKhl5FIDurbvKluBf8aAGUzgJ5cxKCPFNbd6dd26dXjuuecwb948nD59Gh07dsRVV12Fm266yeFzWiwWLFq0CIWFhWjTpg169uyJF198Effff7/HX4+S5KY15TYz5ugZUfOayxN7NvtZbBy/kRX4yW24+lJDPL760s/50jU0V5ulmwEAmN4zNbppCCEgIOyOZU7OlKZkOIJG/kwuT6zhhxvAuuK5+HwxF9dQk7j6ksiPNZzWbDR61m860o6l2T3Gtp3TvjP7eIMhv9LaPLGRxpHN1hYkcgaDMiI/0HBRAABsOL6h0ehZcEAwV2+SX3FXnhgT+MkdGJQR+YnmRs+WJC7BhcsXXF69yalO0ipHO2MwT4yUwqCMyE/JldQwV5tdWr3JqU7SMkdbH9XU1ch+aGGhV/I0BmVEfqzh6JkrqzcPnT3U5P6bHEEjJTnz+9fUzhjMEyMlMCgjIjuy+WfHGuefCQjZUQYuFiBvaxiAObvVmKOdMZgnRkphUEZEjTiTfxYfGS87ysDFAuRNzW383XAEtyG5aXwipTAoI6JmObpxuWuxAFFLyCXqv5L3il39Pdvx4vPFDgMujoiRWjAoIyKnyN243LFYoKmbIfPS/JOz/93lEvUFBHTQNSqMbJuKJ1IzvdIdICJtM4YaMdI40i4PZ0niEuh11rcXvU6PGQNm2BXdBH4fvXAk/WQ6TO+ZkLorFab3TEg/me65F0GKMFebkVuSC3O1WTrmyn93W6J+fXqdHo8Nf8zu94/7TpJWMCgjRa1evRqDBw+GwWCAwWBAYmIidu7c2arnTE9Px4gRIxAeHo7Q0FDEx8fjrbfeclOPyRmT4iYhc3Im1prWInNyJlL6pcjePB2NXjiqH2W7ecvdzEm9nA2+mvvv3pDcB4AliUtwz8B77H7/OE1OWsHpS2rEm1NGXbt2xQsvvIC4uDgIIbB+/XrceuutyM/Px4ABA1r0nBEREXjqqafQt29fBAYGYtu2bbjnnnsQGRkJk8nk5ldAjjizWMDR75ej+lFc2al+zqyETIpOkg2+XrzmRYf/3R39rjjKd2SeGGkRgzKy4+xScne5+eab7b7/xz/+gdWrV2P//v0YMGAAysvL8fjjj+PDDz9EbW0tRowYgVdeeQVDhgxx+JzXXnut3fePPvoo1q9fjy+++IJBmYJcWeXmqH5UUys7W5Kbxpy1lpO7ds6uhHQUfOl0Ood1w5rCAIx8BacvSeLq1IG71dXVYcuWLaiurkZiYiIA4M9//jPOnj2LnTt3Ii8vD8OGDcPYsWNRVlbm1HMKIZCVlYUTJ05g9OjRnuw+OaFh/llT7eSmpRyt7GxJblpTuUucHrVydB2cnXpckbeiyeCrPr1OjyGdhsj+d2fARf6CI2UkaWrKyJNviocPH0ZiYiJqamrQvn17vP/+++jfvz+++OIL5Obm4uzZswgKCgIALF++HB988AH+85//YNasWQ6fs6KiAl26dEFtbS0CAgLwxhtv4Prrr/fYayD3c3ZlZ0ty0+LC4xyOuDU1Par1Ebem+ulsAVZH11R29AsW2ZWQtuBLbjqbdcPInzEoI0lTW454Up8+fVBQUICKigr85z//wYwZM/DZZ5/h0KFDqKqqQocOHezaX7hwAd9//z2KiorQv39/6fiTTz6JJ598EgBwxRVXoKCgAFVVVcjKysLcuXPRo0ePRlObpG7ObAPVkty0/LP5sscPnXO8dZSjYK2pKX9Xgzh3BX3OTC3W76crBVgdXVNHU4/1n8vZ4IvTkeSvGJSRxNUbnrsEBgaiV69eAIDhw4fjq6++wquvvooePXqgc+fO+PTTTxs9Jjw8HOHh4SgoKJCORURESP9fr9dLzxkfH4/jx49j6dKlDMp8gDty04ZGDpU9LoT81lGO9vlsyYibo+DI1eOOuJJYb9tlQXba0UEJE0fX1NHo16S4SRjffTyDLyInMCgjO2qYOrBYLKitrcWwYcNgNpvRpk0bdOvWTbatLfBy9jnJNzh7M3f0QWNQp0EubR3laJ9PV0fcHAVxrh53tLDBpanF34Is2UDUwbSj7T3B1alHBl9EzmFQRo148w100aJFGD9+PGJjY3H+/Hls3rwZn376KTIzM5GcnIzExERMnDgRy5YtQ+/evXHmzBls374dt912G0aMGCH7nEuXLsWIESPQs2dP1NbWYseOHXjrrbewevVqr7wmUhdHgYIrW0c5CtZcHXFzFMS5etxRnqerU4u21ARXph2bunYAAzCi1mBQRoo6e/Yspk+fjpKSEoSFhWHw4MHIzMyUkvJ37NiBp556Cvfccw/OnTsHo9GI0aNHIyoqyuFzVldX4y9/+QtOnTqFkJAQ9O3bFxs3bsQdd9zhrZdFKuMoUHB26yhAPlhzdcTNURDn6nFHeZ6uTi029dqamnZs6poSUcvphBCi+WakBpWVlQgLC0NFRQUMBoPduZqaGhQWFqJ79+4IDg5WqIfaxmtIzTFXm2WDFLnj7sodc0dOWf2FB46CrKbOEVHrNHX/ro9BmYYwKPMsXkNyN1eCuJYcd/XnEpEynA3KOH1JROQhrkybtuS4qz+XiNSNFf2JiIiIVIBBGREREZEKMCjzMUwRbDleOyIiUhKDMh/Rtm1bAMCvv/6qcE+0y3btbNeSiIjIm5jo7yMCAgIQHh6Os2fPAgDatWsHnU6ncK+0QQiBX3/9FWfPnkV4eDgCAgKU7hIREfkhBmU+xGi0rrayBWbkmvDwcOkaEhEReRuDMh+i0+nQuXNnREZG4tKlS0p3R1Patm3LETIiIlIUgzIfFBAQwACDiIhIY5joT0RERKQCDMqIiIiIVIBBGREREZEKMKdMQ2zFTSsrKxXuCRERETnLdt9urkg5gzINOX/+PAAgJiZG4Z4QERGRq86fP4+wsDCH53WCe8tohsViwZkzZ3DFFVd4vDBsZWUlYmJiUFxcDIPB4NGfpWW8Ts7hdXIer5VzeJ2cx2vlHE9eJyEEzp8/j+joaOj1jjPHOFKmIXq9Hl27dvXqzzQYDPwjdgKvk3N4nZzHa+UcXifn8Vo5x1PXqakRMhsm+hMRERGpAIMyIiIiIhVgUEaygoKCsGTJEgQFBSndFVXjdXIOr5PzeK2cw+vkPF4r56jhOjHRn4iIiEgFOFJGREREpAIMyoiIiIhUgEEZERERkQowKCMiIiJSAQZlfqCsrAwpKSkwGAwIDw9HamoqqqqqmnxMTU0NHnroIXTo0AHt27fH5MmTUVpaatemqKgIEyZMQLt27RAZGYn58+fj8uXL0vkvvvgCf/zjH9GhQweEhISgb9++eOWVVzzyGt1FqWuVnp6O66+/Hp06dYLBYEBiYiIyMzM98hrdQanrVFJSgjvvvBO9e/eGXq/HnDlzPPHyWmXVqlXo1q0bgoODkZCQgNzc3Cbbb926FX379kVwcDAGDRqEHTt22J0XQmDx4sXo3LkzQkJCkJycjJMnT9q1acl/DzVQ4lr94x//QFJSEtq1a4fw8HB3vySP8PZ1+vHHH5Gamoru3bsjJCQEPXv2xJIlS3Dx4kWPvD53UuJ36pZbbkFsbCyCg4PRuXNn3HXXXThz5kzLXoAgnzdu3DgxZMgQsX//fvH555+LXr16ialTpzb5mAceeEDExMSIrKwsceDAAXHVVVeJpKQk6fzly5fFwIEDRXJyssjPzxc7duwQHTt2FIsWLZLaHDx4UGzevFkcOXJEFBYWirfeeku0a9dOvPnmmx57ra2l1LV69NFHxYsvvihyc3PFt99+KxYtWiTatm0rDh486LHX2hpKXafCwkLxyCOPiPXr14v4+Hjx6KOPeuoltsiWLVtEYGCgWLt2rTh69Ki47777RHh4uCgtLZVt/+WXX4qAgACxbNkycezYMfHXv/5VtG3bVhw+fFhq88ILL4iwsDDxwQcfiEOHDolbbrlFdO/eXVy4cEFq05L/HkpT6lotXrxY/POf/xRz584VYWFhnn6ZrabEddq5c6e4++67RWZmpvj+++/Fhx9+KCIjI8W8efO88ppbSqnfqX/+858iOztb/Pjjj+LLL78UiYmJIjExsUWvgUGZjzt27JgAIL766ivp2M6dO4VOpxOnT5+WfUx5eblo27at2Lp1q3Ts+PHjAoDIzs4WQgixY8cOodfrhdlsltqsXr1aGAwGUVtb67A/t912m5g2bVprX5ZHqO1a9e/fXzz77LOtfVlup5brNGbMGNUFZaNGjRIPPfSQ9H1dXZ2Ijo4WS5culW1/++23iwkTJtgdS0hIEPfff78QQgiLxSKMRqN46aWXpPPl5eUiKChIvP3220KIlv33UAMlrlV969at00RQpvR1slm2bJno3r17a16Kx6nlWn344YdCp9OJixcvuvwaOH3p47KzsxEeHo4RI0ZIx5KTk6HX65GTkyP7mLy8PFy6dAnJycnSsb59+yI2NhbZ2dnS8w4aNAhRUVFSG5PJhMrKShw9elT2efPz87Fv3z6MGTPGHS/N7dR0rSwWC86fP4+IiAh3vDS3UtN1UpOLFy8iLy/P7jXq9XokJydLr7Gh7Oxsu/aA9TXb2hcWFsJsNtu1CQsLQ0JCgt11c/W/h9KUulZao6brVFFRocr3Ixu1XKuysjJs2rQJSUlJaNu2rcuvg0GZjzObzYiMjLQ71qZNG0RERMBsNjt8TGBgYKN8i6ioKOkxZrPZ7uZpO287V1/Xrl0RFBSEESNG4KGHHsLMmTNb85I8Rg3Xymb58uWoqqrC7bff3pKX4lFquk5q8vPPP6Ourk72NTR1XZpqb/u3uTau/vdQmlLXSmvUcp2+++47vPbaa7j//vtb9Dq8Qelr9cQTTyA0NBQdOnRAUVERPvzwwxa9DgZlGrVw4ULodLomv7755huluwkA+Pzzz3HgwAGsWbMGK1aswNtvv+3Vn6+lawUAmzdvxrPPPot333230c3Wk7R2nYjI806fPo1x48bhz3/+M+677z6lu6Na8+fPR35+Pnbt2oWAgABMnz4dogUbJrXxQN/IC+bNm4e77767yTY9evSA0WjE2bNn7Y5fvnwZZWVlMBqNso8zGo24ePEiysvL7UY2SktLpccYjcZGq1psK+kaPm/37t0BAIMGDUJpaSmeeeYZTJ06tdnX6C5aulZbtmzBzJkzsXXr1kbD6p6mpeukRh07dkRAQECjFaX1X2NDRqOxyfa2f0tLS9G5c2e7NvHx8VIbV/97KE2pa6U1Sl+nM2fO4LrrrkNSUhL+9a9/tfbleJTS16pjx47o2LEjevfujX79+iEmJgb79+9HYmKiS6+DI2Ua1alTJ/Tt27fJr8DAQCQmJqK8vBx5eXnSY/fs2QOLxYKEhATZ5x4+fDjatm2LrKws6diJEydQVFQk/YIlJibi8OHDdjeD3bt3w2AwoH///g77bbFYUFtb29qX7xKtXKu3334b99xzD95++21MmDDB3ZehWVq5TmoVGBiI4cOH271Gi8WCrKwsh2/MiYmJdu0B62u2te/evTuMRqNdm8rKSuTk5NhdN1f/eyhNqWulNUpep9OnT+Paa6/F8OHDsW7dOuj16g4X1PQ7ZbFYAKBl9zqXlwaQ5owbN04MHTpU5OTkiC+++ELExcXZLZc/deqU6NOnj8jJyZGOPfDAAyI2Nlbs2bNHHDhwoNESX1v5ghtuuEEUFBSIjIwM0alTJ7vyBa+//rr46KOPxLfffiu+/fZb8e9//1tcccUV4qmnnvLOC28Bpa7Vpk2bRJs2bcSqVatESUmJ9FVeXu6dF+4ipa6TEELk5+eL/Px8MXz4cHHnnXeK/Px8cfToUc+/aCds2bJFBAUFibS0NHHs2DExa9YsER4eLq0oveuuu8TChQul9l9++aVo06aNWL58uTh+/LhYsmSJ7JL88PBw8eGHH4qvv/5a3HrrrbIlMZr676FGSl2rn376SeTn54tnn31WtG/fXvp9On/+vPdevAuUuE6nTp0SvXr1EmPHjhWnTp2ye09SMyWu1f79+8Vrr70m8vPzxY8//iiysrJEUlKS6Nmzp6ipqXH5NTAo8wO//PKLmDp1qmjfvr0wGAzinnvusXsDKiwsFADEJ598Ih27cOGC+Mtf/iKuvPJK0a5dO3Hbbbc1+oP88ccfxfjx40VISIjo2LGjmDdvnrh06ZJ0fuXKlWLAgAGiXbt2wmAwiKFDh4o33nhD1NXVefw1t5RS12rMmDECQKOvGTNmePolt4hS10kIIXud/vCHP3jy5brktddeE7GxsSIwMFCMGjVK7N+/Xzo3ZsyYRv9N3333XdG7d28RGBgoBgwYILZv32533mKxiKefflpERUWJoKAgMXbsWHHixAm7Ns3991ArJa7VjBkzZH+H6v+uqo23r9O6detkr5EWxnG8fa2+/vprcd1114mIiAgRFBQkunXrJh544AFx6tSpFvVfJ0QLMtGIiIiIyK3UPUlMRERE5CcYlBERERGpAIMyIiIiIhVgUEZERESkAgzKiIiIiFSAQRkRERGRCjAoIyIiIlIBBmVEREREKsCgjIjIy3788UfodDrodDq3bJZte676m70TkfYwKCMiUsj//d//NdoQuSVKSkqwYsWK1neIiBTFoIyISCEdOnRAhw4dWv08RqMRYWFhbugRESmJQRkRUSucO3cORqMRzz//vHRs3759CAwMdHkU7O6778bEiRPx/PPPIyoqCuHh4fjb3/6Gy5cvY/78+YiIiEDXrl2xbt06d78MIlKBNkp3gIhIyzp16oS1a9di4sSJuOGGG9CnTx/cddddmD17NsaOHevy8+3Zswddu3bF3r178eWXXyI1NRX79u3D6NGjkZOTg3feeQf3338/rr/+enTt2tUDr4iIlMKRMiKiVrrxxhtx3333ISUlBQ888ABCQ0OxdOnSFj1XREQEVq5ciT59+uDee+9Fnz598Ouvv+LJJ59EXFwcFi1ahMDAQHzxxRdufhVEpDSOlBERucHy5csxcOBAbN26FXl5eQgKCmrR8wwYMAB6/e+fl6OiojBw4EDp+4CAAHTo0AFnz55tdZ+JSF04UkZE5Abff/89zpw5A4vFgh9//LHFz9O2bVu773U6newxi8XS4p9BROrEkTIiola6ePEipk2bhjvuuAN9+vTBzJkzcfjwYURGRirdNSLSEI6UERG10lNPPYWKigqsXLkSTzzxBHr37o17771X6W4RkcYwKCMiaoVPP/0UK1aswFtvvQWDwQC9Xo+33noLn3/+OVavXq1094hIQzh9SUTUCtdeey0uXbpkd6xbt26oqKhw+bnS0tIaHfv0008bHWtNzhoRqReDMiIihSQlJSE+Ph779u1r1fO0b98ely9fRnBwsJt6RkRKYFBGRORlXbt2xcmTJwGgxaUz6isoKABgLZdBRNqlE0IIpTtBRERE5O+Y6E9ERESkAgzKiIiIiFSAQRkRERGRCjAoIyIiIlIBBmVEREREKsCgjIiIiEgFGJQRERERqQCDMiIiIiIV+P/LGDmPM+Vl/QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_data[0,:], xp_data[0,:], linestyle='None', marker='.', label='1e-4')\n", + "plt.plot(x_data[1,:], xp_data[1,:], linestyle='None', marker='.', label='1e-3')\n", + "plt.plot(x_data[2,:], xp_data[2,:], linestyle='None', marker='.', label='3e-3')\n", + "plt.legend()\n", + "plt.xlabel('x [m]')\n", + "plt.ylabel('xp')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following section is very important. As we saw, we have the ability to enable or disable 6d motion. When computing the linear optics or the orbit, the 'get_optics' and 'find_orbit' functions will automatically select the most appropriate method to use out of the methods available. \n", + "\n", + "> at.linopt2\n", + "\n", + "> at.linopt4 / at.find_orbit4\n", + "\n", + "> at.linopt6 / at.find_orbit6\n", + "\n", + "for 2, 4 and 6 dimensional tracking respectively. One can also specifically call other methods in order to speed up computation (for example if you are doing uncoupled matching, it is faster to call at.linopt2 rather than do the full 6d computation)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(776, 6)\n" + ] + } + ], + "source": [ + "ring.disable_6d()\n", + "s_positions = ring.get_s_pos(refpts=np.arange(len(ring)))\n", + "orbit0_4, orbit_4 = ring.find_orbit(refpts=np.arange(len(ring)))\n", + "ring.enable_6d()\n", + "orbit0_6, orbit_6 = ring.find_orbit(refpts=np.arange(len(ring)))\n", + "print(orbit_4.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(s_positions, orbit_4[:,0], label='find_orbit4')\n", + "plt.plot(s_positions, orbit_6[:,0], label='find_orbit6')\n", + "plt.legend()\n", + "plt.xlabel('s [m]')\n", + "plt.ylabel('x [m]')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_optics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Lattice'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Refpts'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'float'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Callable'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mfunction\u001b[0m \u001b[0mlinopt6\u001b[0m \u001b[0mat\u001b[0m \u001b[0;36m0x15213c1bcd30\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Linear analysis of a fully coupled lattice\n", + "\n", + "Parameters:\n", + " ring: Lattice description.\n", + " refpts: Elements at which data is returned.\n", + " It can be:\n", + "\n", + " 1. an integer in the range [-len(ring), len(ring)-1]\n", + " selecting the element according to python indexing rules.\n", + " As a special case, len(ring) is allowed and refers to the end\n", + " of the last element,\n", + " 2. an ordered list of such integers without duplicates,\n", + " 3. a numpy array of booleans of maximum length len(ring)+1,\n", + " where selected elements are :py:obj:`True`.\n", + " dp: Momentum deviation.\n", + " method (Callable): Method for linear optics:\n", + "\n", + " :py:obj:`~.linear.linopt2`: no longitudinal motion, no H/V coupling,\n", + "\n", + " :py:obj:`~.linear.linopt4`: no longitudinal motion, Sagan/Rubin\n", + " 4D-analysis of coupled motion,\n", + "\n", + " :py:obj:`~.linear.linopt6` (default): with or without longitudinal\n", + " motion, normal mode analysis\n", + "\n", + "Keyword Args:\n", + " dct (float): Path lengthening. Defaults to :py:obj:`None`\n", + " df (float): Deviation of RF frequency. Defaults to\n", + " :py:obj:`None`\n", + " orbit (Orbit): Avoids looking for the closed orbit if it is\n", + " already known ((6,) array)\n", + " get_chrom (bool): Compute chromaticities. Needs computing\n", + " the tune at 2 different momentum deviations around the central one.\n", + " get_w (bool): Computes chromatic amplitude functions\n", + " (W) [4]_. Needs to compute the optics at 2 different momentum\n", + " deviations around the central one.\n", + " keep_lattice (bool): Assume no lattice change since the\n", + " previous tracking. Defaults to :py:obj:`False`\n", + " XYStep (float): Step size.\n", + " Default: :py:data:`DConstant.XYStep <.DConstant>`\n", + " DPStep (float): Momentum step size.\n", + " Default: :py:data:`DConstant.DPStep <.DConstant>`\n", + " twiss_in: Initial conditions for transfer line optics.\n", + " Record array as output by :py:func:`.linopt6`, or dictionary. Keys:\n", + "\n", + " R or alpha, beta\n", + " mandatory (2,) arrays\n", + " closed_orbit\n", + " Optional (6,) array, default 0\n", + " dispersion\n", + " Optional (6,) array, default 0\n", + "\n", + " If present, the attribute **R** will be used, otherwise the\n", + " attributes **alpha** and **beta** will be used. All other attributes\n", + " are ignored.\n", + "\n", + "Returns:\n", + " elemdata0: Linear optics data at the entrance of the ring\n", + " ringdata: Lattice properties\n", + " elemdata: Linear optics at the points refered to by *refpts*,\n", + " if refpts is :py:obj:`None` an empty lindata structure is returned.\n", + "\n", + "Warning:\n", + " The format of output record arrays depends on the selected method.\n", + " See :py:func:`linopt2`, :py:func:`linopt4`, :py:func:`linopt6`.\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/linear.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.get_optics?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "ring.disable_6d()\n", + "ld0_4d, bd_4d, ld_4d = at.get_optics(ring, refpts=np.arange(len(ring)), method=at.linopt2)\n", + "ring.enable_6d()\n", + "ld0_6d, bd_6d, ld_6d = at.get_optics(ring, refpts=np.arange(len(ring)))\n", + "ld0_6db, bd_6db, ld_6db = at.get_optics(ring, refpts=np.arange(len(ring)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(ld_4d.beta[:,1])\n", + "plt.plot(ld_6d.beta[:,1])\n", + "plt.show()\n", + "fig, ax = plt.subplots()\n", + "axb = ax.twinx()\n", + "ax.plot(s_positions, ld_6d.beta[:,1] - ld_4d.beta[:,1], color='r')\n", + "axb.plot(s_positions, orbit_6[:,0], label='find_orbit6', color='b')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_orbit4\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLattice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdct\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0morbit\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mkeep_lattice\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Gets the 4D closed orbit for a given dp\n", + "\n", + "Finds the closed orbit in the 4-d transverse phase space by numerically\n", + "solving for a fixed point of the one turn map M calculated with\n", + ":py:func:`.internal_lpass`.\n", + "\n", + ".. math:: \\begin{pmatrix}x \\\\ p_x \\\\ y \\\\ p_y \\\\ dp \\\\ c\\tau_2\\end{pmatrix}\n", + " =\\mathbf{M} \\cdot\n", + " \\begin{pmatrix}x \\\\ p_x \\\\ y \\\\ p_y \\\\ dp \\\\ c\\tau_1\\end{pmatrix}\n", + "\n", + "under the **CONSTANT MOMENTUM** constraint **dp** and with **NO**\n", + "constraint on the 6-th coordinate :math:`c\\tau`\n", + "\n", + "Important:\n", + " :py:func:`find_orbit4` imposes a constraint on *dp* and relaxes the\n", + " constraint on the revolution frequency. A physical storage ring does\n", + " exactly the opposite: the momentum deviation of a particle on the\n", + " closed orbit settles at the value such that the revolution is\n", + " synchronous with the RF cavity: :math:`f_{RF} = h*f_{rev}`\n", + "\n", + "To impose this artificial constraint in :py:func:`find_orbit4`,\n", + "the ``PassMethod`` used for any element **SHOULD NOT**:\n", + "\n", + "1. Change the longitudinal momentum *dp* (cavities ,\n", + " magnets with radiation)\n", + "2. Have any time dependence (localized impedance, fast kickers etc)\n", + "\n", + "Parameters:\n", + " ring: Lattice description (:py:attr:`~.Lattice.is_6d` must be\n", + " :py:obj:`False`)\n", + " dp: Momentum deviation. Defaults to 0\n", + " refpts: Observation points.\n", + " See \":ref:`Selecting elements in a lattice <refpts>`\"\n", + " dct: Path lengthening. If specified, *dp* is ignored and\n", + " the off-momentum is deduced from the path lengthening.\n", + " df: Deviation from the nominal RF frequency. If specified,\n", + " *dp* is ignored and the off-momentum is deduced from the frequency\n", + " deviation.\n", + " orbit: Avoids looking for initial the closed orbit if it is\n", + " already known ((6,) array). :py:func:`find_orbit4` propagates it to\n", + " the specified *refpts*.\n", + " keep_lattice: Assume no lattice change since the previous tracking.\n", + " Default: False\n", + "\n", + "Keyword Args:\n", + " guess (Orbit): (6,) initial value for the\n", + " closed orbit. It may help convergence. Default: (0, 0, 0, 0, 0, 0)\n", + " convergence (float): Convergence criterion.\n", + " Default: :py:data:`DConstant.OrbConvergence <.DConstant>`\n", + " max_iterations (int): Maximum number of iterations.\n", + " Default: :py:data:`DConstant.OrbMaxIter <.DConstant>`\n", + " XYStep (float): Step size.\n", + " Default: :py:data:`DConstant.XYStep <.DConstant>`\n", + "\n", + "Returns:\n", + " orbit0: (6,) closed orbit vector at the entrance of the\n", + " 1-st element (x,px,y,py,dp,0)\n", + " orbit: (Nrefs, 6) closed orbit vector at each location\n", + " specified in *refpts*\n", + "\n", + "See also:\n", + " :py:func:`find_sync_orbit`, :py:func:`find_orbit6`\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/orbit.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.find_orbit4?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Orbit Correction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By now we are basically experts. What we will now do is show how to use what we have learned and do some orbit correction.\n", + "First we need to get the orbit response matrix. This is a big matrix showing the orbit response from each steerer action." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "ring.disable_6d()\n", + "corrector_refpts = at.get_uint32_index(ring, 'Corr*')\n", + "bpm_refpts = at.get_uint32_index(ring, 'BPM*')\n", + "\n", + "orm = np.zeros((len(bpm_refpts), len(corrector_refpts)))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "kickang = 1e-6\n", + "for ic, corrector_ind in enumerate(corrector_refpts):\n", + " #init_steer_value = ring[corrector_ind].KickAngle[1]\n", + " #_, ref_orbit = ring.find_orbit(refpts=bpm_refpts)\n", + " ring[corrector_ind].KickAngle[1] += kickang\n", + " _, pos_orbit = ring.find_orbit(refpts=bpm_refpts)\n", + " ring[corrector_ind].KickAngle[1] -= 2*kickang\n", + " _, neg_orbit = ring.find_orbit(refpts=bpm_refpts)\n", + " ring[corrector_ind].KickAngle[1] += kickang\n", + " orm[:, ic] = (pos_orbit[:,2] - neg_orbit[:,2])/kickang" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'bpm #')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(orm)\n", + "plt.xlabel('corrector #')\n", + "plt.ylabel('bpm #')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can put a bad orbit, we can do this by introducing a misalignment on a couple of quadrupoles. Possible functions for this are 'set_shift' and 'set_tilt'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "ring_err = ring.deepcopy()\n", + "'''\n", + "at.set_shift?\n", + "quad_msk = at.get_bool_index(ring_err, at.Quadrupole)\n", + "shift_vals = np.zeros(quad_msk.shape[0]-1)\n", + "shift_vals[np.where(quad_msk)[0][0]] = 1e-6\n", + "shift_vals[np.where(quad_msk)[0][3]] = 5e-6\n", + "shift_vals[np.where(quad_msk)[0][4]] = -2e-6\n", + "shift_vals[np.where(quad_msk)[0][9]] = 3e-6\n", + "shift_vals[np.where(quad_msk)[0][11]] = 10e-6\n", + "shift_vals[np.where(quad_msk)[0][17]] = 0.5e-6\n", + "at.set_shift(ring_err, np.zeros(len(shift_vals)), shift_vals)\n", + "'''\n", + "all_corr_vals = at.get_value_refpts(ring_err, 'Corr*', 'KickAngle', 1)\n", + "all_corr_vals[0] = 2e-6\n", + "all_corr_vals[4] = -3.5e-5\n", + "all_corr_vals[7] = 6e-6\n", + "\n", + "at.set_value_refpts(ring_err, 'Corr*', 'KickAngle', all_corr_vals, 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "orb0, orb_bad = ring_err.find_orbit(refpts=bpm_refpts)\n", + "plt.plot(orb_bad[:,2])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "U,W,V = np.linalg.svd(orm, full_matrices=False)\n", + "Utran = np.transpose(U)\n", + "Winv = np.linalg.inv(np.diag(W))\n", + "Vtran = np.transpose(V)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3498502803537367e-05\n", + "6.74906454546305e-06\n", + "-3.3745090918992327e-06\n", + "1.6872517373670612e-06\n", + "-8.436255621495507e-07\n", + "4.2181276502819965e-07\n", + "-2.109063916433719e-07\n", + "1.0545320253039905e-07\n", + "-5.272660488756557e-08\n", + "2.6363304288466877e-08\n" + ] + } + ], + "source": [ + "niters = 10\n", + "orb_to_correct = orb_bad\n", + "for it in np.arange(niters):\n", + " dk = np.dot(Vtran, np.dot(Winv, np.dot(Utran, orb_to_correct[:,2])))\n", + " print(np.sum(dk))\n", + " at.set_value_refpts(ring_err, 'Corr*', 'KickAngle', -dk, 1)\n", + " orb0, orb_to_correct = ring_err.find_orbit(refpts=bpm_refpts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(orb_bad[:,2], 'r', label='before')\n", + "plt.plot(orb_to_correct[:,2], 'b', label='after')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(all_corr_vals, 'r', label='before')\n", + "plt.plot(at.get_value_refpts(ring_err, 'Corr*', 'KickAngle', 1), 'b', label='after')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MATCHING" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So we want to do some matching! The final piece of the introductory puzzle. Lets some back to our arc cell. Then lets ruin it a bit for fun in order to give us something to match back to." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arc.plot_beta()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can put some errors to make it a bit messy, then rematch to these values. However, we can use transfer line mode to speed up the matching and use only half of the cell as it is symmetric. First we need to save the initial optics, which we can use as input into the matching" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "ld0, bd, ld = at.get_optics(arc)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array(([-2.46666011e-15, -7.38098906e-15], [24.58333148, 16.86095871], [0., 0.], [[[2.45833315e+01, 2.46666011e-15, 0.00000000e+00, 0.00000000e+00], [2.46666011e-15, 4.06779692e-02, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 1.68609587e+01, 7.38098906e-15], [0.00000000e+00, 0.00000000e+00, 7.38098906e-15, 5.93086086e-02]]], [[4.95815807e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [4.97495253e-16, 2.01687801e-01, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 4.10620977e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 1.79751875e-15, 2.43533588e-01]], [-1.76362232e-06, 3.02779028e-18, 0.00000000e+00, 0.00000000e+00], [0., 0., 0., 0., 0., 0.], [[ 0.17496079, -24.20414349, 0. , 0. ], [ 0.04005053, 0.17496079, 0. , 0. ], [ 0. , 0. , 0.57269249, 13.82211287], [ 0. , 0. , -0.04861943, 0.57269249]], 23.625),\n", + " dtype=[('alpha', '<f8', (2,)), ('beta', '<f8', (2,)), ('mu', '<f8', (2,)), ('R', '<f8', (2, 4, 4)), ('A', '<f8', (4, 4)), ('dispersion', '<f8', (4,)), ('closed_orbit', '<f8', (6,)), ('M', '<f8', (4, 4)), ('s_pos', '<f8')])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ld0" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.76362232e-06 3.02779028e-18 0.00000000e+00 0.00000000e+00]\n", + "[-1.76362232e-06 3.02779028e-18 0.00000000e+00 0.00000000e+00]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "half_arc = arc[:at.get_uint32_index(arc, 'BPM_CellCenter')[0]]\n", + "print(ld0.dispersion)\n", + "#ld0.dispersion[0] = 1e-1\n", + "print(ld0.dispersion)\n", + "\n", + "#This uses plot_beta in transfer_line mode. When you provide twiss_in, you set\n", + "# the initial optics functions and then progress them in one pass through your lattice\n", + "arc.plot_beta(twiss_in=ld0)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Drift('DR_01', 2.25), Quadrupole('QF1', 0.75, 0.38041), Drift('DR_02', 0.75), Quadrupole('QD2', 0.75, -0.2708), Drift('DR_03', 0.75), Dipole('Bend', 3.0, 0.12566370614359174, 0.0), Drift('DR_04', 0.1875), Quadrupole('QD3', 0.75, -0.33319), Drift('DR_05', 0.1875), Sextupole('SD', 0.1875, -0.1), Drift('DR_06', 0.5625), Quadrupole('QF4', 0.75, 0.4588), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 0.1)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=25, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "half_arc" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "quad_refs = at.get_uint32_index(half_arc, at.Quadrupole)\n", + "sext_refs = at.get_uint32_index(half_arc, at.Sextupole)\n", + "for quad_ind in quad_refs: \n", + " half_arc[quad_ind].K *= 1 - random.randint(-50,50)/100\n", + " \n", + "for sext_ind in sext_refs: \n", + " half_arc[sext_ind].H *= 1 - random.randint(-50,50)/100" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/linear.py:128: AtWarning: Unstable ring\n", + " warnings.warn(AtWarning('Unstable ring'))\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "half_arc.plot_beta(twiss_in=ld0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have a messed up lattice, some initial optics parameters, and a rough idea on what we want it to look like again. So lets try and match it.\n", + "\n", + "We must define our Constraints (or Goals) and our Variables.\n", + "\n", + "Possible Constraint containers:\n", + "\n", + "Constraints - Generic container for user defined functions<br>\n", + "ElementConstraints - Constraints related to attributes of lattice elements <br>\n", + "EnvelopeConstraints - Constraints for values that can be found with envelope_parameters <br>\n", + "LinoptConstraints - Constraints for values that can be found with linopt output <br>\n", + "OrbitConstraints - Constraints relating to the orbit\n", + "\n", + "Possible Variable containers:\n", + "\n", + "Variable - Generic container for user defined variables <br>\n", + "ElementVariable - Variable related to attributes of lattice elements <br> \n", + "\n", + "We can start with some simple linear optics constraints, which we can recover using the quadrupoles and sextupoles strengths" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mVariable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msetfun\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Callable'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgetfun\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Callable'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'str'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'tuple[float, float]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfun_args\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'tuple'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfun_kwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "A :py:class:`Variable` is a scalar value acting on a lattice through the\n", + "user-defined functions setfun and getfun\n", + "\n", + "Parameters:\n", + " setfun: User-defined function for setting the Variable. Called as:\n", + "\n", + " :code:`setfun(ring, value, *args, **kwargs)`\n", + "\n", + " where :code:`value` is the scalar value to apply\n", + "\n", + " The positional and keyword parameters come from the\n", + " :py:class:`Variable` initialisation\n", + " getfun: User-defined function for retrieving the actual value of\n", + " the variable: Called as:\n", + "\n", + " :code:`value = getfun(ring, *args, **kwargs)`\n", + "\n", + " The positional and keyword parameters come from the\n", + " :py:class:`Variable` initialisation\n", + " name: Name of the Variable; Default: ``''``\n", + " bounds: Lower and upper bounds of the variable value\n", + " fun_args: Positional arguments transmitted to ``setfun`` and\n", + " ``getfun`` functions\n", + "\n", + "Keyword Args:\n", + " **fun_kwargs: Keyword arguments transmitted to ``setfun``and\n", + " ``getfun`` functions\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/matching/matching.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m ElementVariable\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.Variable?" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# First we initialise the constraint type by passing the ring and information about the setup\n", + "# These are the arguments that are passed to linopt when computing the optics\n", + "constr = at.LinoptConstraints(half_arc, dp=0.0, coupled=False, twiss_in=ld0)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "#Now we can add our optics constraints.\n", + "# Weights can also be applied here. See the help of constr.add. Also if phase advance is\n", + "# being used. UseInteger should be True. \n", + "constr.add('beta', 15, refpts=len(half_arc), index=0) #beta_x at end of half_cell = 15m\n", + "constr.add('beta', 10, refpts=len(half_arc), index=1) # beta_y at end of half_cell = 10m\n", + "constr.add('dispersion', 0.6, refpts=len(half_arc), index=0) # dispersion_x at end of half cell is 0.6m\n", + "constr.add('dispersion', 0., refpts=len(half_arc), index=1, weight=1/10000) # dispersion_x prime at end of half cell is 0\n", + "constr.add('alpha', 0, refpts=len(half_arc), index=0, weight=1/1000) #alpha_x is 0 at end of cell\n", + "constr.add('alpha', 0, refpts=len(half_arc), index=1, weight=1/1000) #alpha_y is 0 at end of cell" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "all_constraints = [constr]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "all_quad_vars = ['QF1','QD2', 'QD3', 'QF4'] #Quadrupole names that we want to add\n", + "all_sext_vars = ['SF','SD'] #Sextupole names that we want to do\n", + "all_vars = []\n", + "\n", + "# For each quadrupole family, create an element variable for the strength \n", + "# and add it to our list of variables\n", + "for var in all_quad_vars:\n", + " all_vars.append(at.ElementVariable(at.get_uint32_index(half_arc, var), 'K'))\n", + " \n", + "# Similarly for sextupole\n", + "for var in all_sext_vars:\n", + " all_vars.append(at.ElementVariable(at.get_uint32_index(half_arc, var), 'H'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/linear.py:128: AtWarning: Unstable ring\n", + " warnings.warn(AtWarning('Unstable ring'))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "6 constraints, 6 variables, using method lm\n", + "\n", + "`ftol` termination condition is satisfied.\n", + "Function evaluations 343, initial cost 2.9883e+07, final cost 4.7169e+01, first-order optimality 4.05e+01.\n", + "\n", + " Name Initial Final Target Residual\n", + "\n", + " beta_0 4.064947e+00 1.498141e+01 1.500000e+01 -1.858826e-02\n", + " beta_1 3.456260e+01 2.875505e-01 1.000000e+01 -9.712450e+00\n", + "dispersion_0 4.303153e-01 6.786836e-01 6.000000e-01 7.868357e-02\n", + "dispersion_1 -7.522413e-02 1.647641e-06 0.000000e+00 1.647641e-06\n", + " alpha_0 7.121116e-01 7.723382e-06 0.000000e+00 7.723382e-06\n", + " alpha_1 -7.661102e+00 7.427885e-07 0.000000e+00 7.427885e-07\n", + "\n", + " Name Initial Final Variation\n", + "\n", + " 3.766059e-01 3.594445e-01 -1.716137e-02\n", + " -3.141280e-01 -2.125521e-01 1.015759e-01\n", + " -1.765907e-01 -6.090772e-01 -4.324865e-01\n", + " 6.285560e-01 5.152221e-01 -1.133339e-01\n", + " 1.230000e-01 9.704217e+01 9.691917e+01\n", + " -1.170000e-01 -1.421718e+02 -1.420548e+02\n" + ] + } + ], + "source": [ + "new_lat = at.match(half_arc, all_vars, all_constraints)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_lat.plot_beta(twiss_in=ld0)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mconstr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mparam\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[Refpts]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[Union[int, slice]]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[str]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Add a target to the LinoptConstraints container\n", + "\n", + "Parameters:\n", + " param: 2 possibilities:\n", + "\n", + " * parameter name: see :py:func:`.linopt6` for the\n", + " name of available parameters. In addition to local\n", + " optical parameters, ``'tunes'`` and ``'chroms'``\n", + " are allowed.\n", + " * user-supplied parameter evaluation function:\n", + "\n", + " :code:`value = param(lindata, tune, chrom)`\n", + "\n", + " ``lindata`` contains the optics parameters at all the\n", + " specified refpoints\n", + " ``value`` is the constrained parameter value\n", + " (scalar or array).\n", + " target: desired value.\n", + " refpts: location of the constraint. Several locations may be\n", + " given to apply the same constraint at several points.\n", + " index: index in the parameter array. If :py:obj:`None`,\n", + " the full array is used.\n", + " name: name of the constraint. If :py:obj:`None`, name is\n", + " generated from ``param`` and ``index``.\n", + "\n", + "Keyword Args:\n", + " weight: Weight factor: the residual is\n", + " :code:`(value-target)/weight`\n", + " bounds: lower and upper bounds. The parameter is constrained\n", + " in the interval [target-low_bound target+up_bound]\n", + " UseInteger: Match integer part of mu, much slower as the optics\n", + " calculation is done for all refpts\n", + "\n", + "The target, weight and bounds values must be broadcastable to the shape\n", + "of value.\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/matching/matching.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "constr.add?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dynamic Aperture" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have several build in functions for the computation of the DA and lifetime. " + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_acceptance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLattice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mplanes\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnpoints\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mamplitudes\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnturns\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1024\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0moffset\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgrid_mode\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macceptance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mboundary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGridMode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mGridMode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRADIAL\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0muse_mp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdivider\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mshift_zero\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-06\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstart_method\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Computes the acceptance at ``repfts`` observation points\n", + "\n", + "Parameters:\n", + " ring: Lattice definition\n", + " planes: max. dimension 2, Plane(s) to scan for the acceptance.\n", + " Allowed values are: ``'x'``, ``'xp'``, ``'y'``,\n", + " ``'yp'``, ``'dp'``, ``'ct'``\n", + " npoints: (len(planes),) array: number of points in each\n", + " dimension\n", + " amplitudes: (len(planes),) array: set the search range:\n", + "\n", + " * :py:attr:`GridMode.CARTESIAN/RADIAL <.GridMode.RADIAL>`:\n", + " max. amplitude\n", + " * :py:attr:`.GridMode.RECURSIVE`: initial step\n", + " nturns: Number of turns for the tracking\n", + " refpts: Observation points. Default: start of the machine\n", + " dp: static momentum offset\n", + " offset: initial orbit. Default: closed orbit\n", + " bounds: defines the tracked range: range=bounds*amplitude.\n", + " It can be use to select quadrants. For example, default values are:\n", + "\n", + " * :py:attr:`.GridMode.CARTESIAN`: ((-1, 1), (0, 1))\n", + " * :py:attr:`GridMode.RADIAL/RECURSIVE <.GridMode.RADIAL>`: ((0, 1),\n", + " (:math:`\\pi`, 0))\n", + " grid_mode: defines the evaluation grid:\n", + "\n", + " * :py:attr:`.GridMode.CARTESIAN`: full [:math:`\\:x, y\\:`] grid\n", + " * :py:attr:`.GridMode.RADIAL`: full [:math:`\\:r, \\theta\\:`] grid\n", + " * :py:attr:`.GridMode.RECURSIVE`: radial recursive search\n", + " use_mp: Use python multiprocessing (:py:func:`.patpass`,\n", + " default use :py:func:`.lattice_pass`).\n", + " verbose: Print out some information\n", + " divider: Value of the divider used in\n", + " :py:attr:`.GridMode.RECURSIVE` boundary search\n", + " shift_zero: Epsilon offset applied on all 6 coordinates\n", + " start_method: Python multiprocessing start method. The default\n", + " ``None`` uses the python default that is considered safe.\n", + " Available parameters: ``'fork'``, ``'spawn'``, ``'forkserver'``.\n", + " The default for linux is ``'fork'``, the default for MacOS and\n", + " Windows is ``'spawn'``. ``'fork'`` may used for MacOS to speed-up\n", + " the calculation or to solve runtime errors, however it is\n", + " considered unsafe.\n", + "\n", + "Returns:\n", + " boundary: (2,n) array: 2D acceptance\n", + " survived: (2,n) array: Coordinates of surviving particles\n", + " tracked: (2,n) array: Coordinates of tracked particles\n", + "\n", + "In case of multiple refpts, return values are lists of arrays, with one\n", + "array per ref. point.\n", + "\n", + "Examples:\n", + "\n", + " >>> bf,sf,gf = ring.get_acceptance(planes, npoints, amplitudes)\n", + " >>> plt.plot(*gf,'.')\n", + " >>> plt.plot(*sf,'.')\n", + " >>> plt.plot(*bf)\n", + " >>> plt.show()\n", + "\n", + ".. note::\n", + "\n", + " * When``use_mp=True`` all the available CPUs will be used.\n", + " This behavior can be changed by setting\n", + " ``at.DConstant.patpass_poolsize`` to the desired value\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/acceptance/acceptance.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.get_acceptance?" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "56 cpu found for acceptance calculation\n", + "Single process acceptance calculation selected...\n", + "Consider use_mp=True for parallelized computations\n", + "The estimated load for grid mode is 121.0\n", + "The estimated load for recursive mode is 88.0\n", + "GridMode.RECURSIVE is recommended\n", + "\n", + "Running grid boundary search:\n", + "Element DR_01, obspt=0\n", + "The grid mode is GridMode.RADIAL\n", + "The planes are ['x' 'y']\n", + "Number of steps are [11 11]\n", + "The maximum amplitudes are [0.12 0.06]\n", + "The maximum boundaries are ((1e-06, 1.0), (3.141592653589793, 0.0))\n", + "The initial offset is [ 1.41249135e-08 -6.35644289e-08 0.00000000e+00 0.00000000e+00\n", + " -3.86596572e-05 1.51902323e-06] with dp=None\n", + "Calculation took 97.75581359863281\n" + ] + } + ], + "source": [ + "ring.enable_6d()\n", + "bound, surv, track = at.get_acceptance(ring, ('x','y'), (11,11), (120e-3,60e-3), nturns=4000)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*bound,marker='.', color='r')\n", + "plt.plot(*surv,marker='.',linestyle='None', color='b')\n", + "plt.plot(*track, color='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/esrfworkshop/1_Introduction.ipynb b/esrfworkshop/1_Introduction.ipynb new file mode 100644 index 0000000..7f9da0e --- /dev/null +++ b/esrfworkshop/1_Introduction.ipynb @@ -0,0 +1,1199 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Welcome to the PyAT tutorial.\n", + "Here we will go through some of the basic syntax of PyAT. Slowly evolving into more complex examples.\n", + "The outline of the tutorial is as follows:\n", + "> 1. Defining some simple elements and creating a lattice object\n", + "> 2. Simple tracking, orbit correction, radiation flags\n", + "> 3. Accessing and modifying ring elements\n", + "> 4. Matching\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we can import PyAT (and other useful packages) and see all accessible functions using dir" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import copy\n", + "import matplotlib.pyplot as plt\n", + "import at\n", + "#dir(at)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many functions! But we cannot do anything because we do not have a lattice. Let's define some key parameters for a DBA lattice. Here I am simply taking the values from the at/machine_data/dba.m file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I want to define a drift. But how do I know what to provide to the function? We can use 'help' or ? to tell us." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All elements are found in the file:\n", + "> at/pyat/at/lattice/elements.py\n", + "\n", + "This can also be accessed by:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['ABC',\n", + " 'Aperture',\n", + " 'BeamMoments',\n", + " 'Bend',\n", + " 'CLASS_MAP',\n", + " 'Collective',\n", + " 'Collimator',\n", + " 'Corrector',\n", + " 'Dipole',\n", + " 'Drift',\n", + " 'Element',\n", + " 'Generator',\n", + " 'Iterable',\n", + " 'List',\n", + " 'LongElement',\n", + " 'LongtMotion',\n", + " 'M66',\n", + " 'Marker',\n", + " 'Monitor',\n", + " 'Multipole',\n", + " 'Octupole',\n", + " 'Optional',\n", + " 'Quadrupole',\n", + " 'QuantumDiffusion',\n", + " 'RFCavity',\n", + " 'Radiative',\n", + " 'Sextupole',\n", + " 'ThinMultipole',\n", + " 'Tuple',\n", + " 'Wiggler',\n", + " '_DictLongtMotion',\n", + " '_Radiative',\n", + " '__builtins__',\n", + " '__cached__',\n", + " '__doc__',\n", + " '__file__',\n", + " '__loader__',\n", + " '__name__',\n", + " '__package__',\n", + " '__spec__',\n", + " '_array',\n", + " '_array66',\n", + " '_nop',\n", + " 'abc',\n", + " 'build_class_map',\n", + " 'copy',\n", + " 'deepcopy',\n", + " 'get_class_map',\n", + " 'numpy',\n", + " 're']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(at.elements)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDrift\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfamily_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlength\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m Drift space element\n", + "\u001b[0;31mInit docstring:\u001b[0m\n", + "Args:\n", + " family_name: Name of the element\n", + " length: Element length [m]\n", + "\n", + "Default PassMethod: ``DriftPass``\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/lattice/elements.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m Collimator" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#help(at.elements.Drift)\n", + "at.elements.Drift?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that we need to provide first a 'family_name' as a string, and a 'length' as a float. We can also use the dir function to see all available attributes that can be accessed from the drift." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['FamName',\n", + " 'Length',\n", + " 'PassMethod',\n", + " '_BUILD_ATTRIBUTES',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '__weakref__',\n", + " '_conversions',\n", + " '_entrance_fields',\n", + " '_exit_fields',\n", + " '_get_collective',\n", + " '_get_longt_motion',\n", + " '_no_swap',\n", + " '_part',\n", + " 'copy',\n", + " 'deepcopy',\n", + " 'divide',\n", + " 'equals',\n", + " 'insert',\n", + " 'is_collective',\n", + " 'is_compatible',\n", + " 'items',\n", + " 'longt_motion',\n", + " 'merge',\n", + " 'swap_faces',\n", + " 'update']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "DR_24 = at.Drift('DR_24', 2.4)\n", + "\n", + "# To see all of the available attributes\n", + "dir(DR_24)\n", + "# i.e. Length can be re-set by DR_24.Length = New_Length" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A note on pointers " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python uses pointers. When creating a lattice, this can cause some headaches. Observe the following simple examples:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 1 2 3 4 100 6 7 8 9]\n" + ] + } + ], + "source": [ + "a = np.arange(10) #the array is assigned some memory\n", + "b = a #b is now a pointer to the location of the memory for a\n", + "b[5] = 100 #we modify b[5], but it also modifies a due to pointers\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0 2.0\n" + ] + } + ], + "source": [ + "drift = at.Drift('Test',5) # Drift of length 5m\n", + "pointer_test = [drift, drift] # Here we make a list of 2 drifts of 5m each\n", + "\n", + "# Now we can reduce the length of the first drift\n", + "pointer_test[0].Length = 2\n", + "print(pointer_test[0].Length, pointer_test[1].Length)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "As you can see, the drift variable was placed twice in the list. When you modify the length of one, you are in fact modifying all. This can cause issues if you predefine elements (drifts, quads, sexts) and then place them in multiple places in the lattice. One must be careful!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can perform similar actions to define the needed dipoles, quadrupoles, sextupoles and markers" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "Nhalfcells = 25 #actually it is 50 half cells\n", + "K_QF1 = 0.38041 #Strength of the quadrupoles\n", + "K_QD2 = -0.2708\n", + "K_QD3 = -0.33319\n", + "K_QF4 = 0.4588\n", + "\n", + "Ks = 0.1 # Strength of the sextupoles\n", + "L1 = 3\n", + "\n", + "# get arc lattice structure\n", + "arc_half=[at.Drift('DR_01', L1*6/8),\n", + " at.Quadrupole('QF1', L1/4, K_QF1),\n", + " at.Drift('DR_02', L1*2/8),\n", + " at.Quadrupole('QD2', L1/4, K_QD2),\n", + " at.Drift('DR_03', L1*2/8),\n", + " at.Bend('Bend', L1, 2*np.pi/(2*Nhalfcells)), \n", + " at.Drift('DR_04', L1/16),\n", + " at.Quadrupole('QD3', L1/4, K_QD3),\n", + " at.Drift('DR_05', L1/16),\n", + " at.Sextupole('SD', L1/16, -Ks),\n", + " at.Drift('DR_06', L1*3/16),\n", + " at.Quadrupole('QF4', L1/4, K_QF4),\n", + " at.Drift('DR_07', L1/16),\n", + " at.Sextupole('SF', L1/4, Ks)\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have made a list of elements that represent a half cell consisting of drifts, dipoles, quadrupoles and sextupoles. This is just a python list. We will now use this half, make a full cell (first half + reverse of the first half) and convert it into a lattice object and start to benefit greatly from what PyAT has to offer." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Periodicity: 25\n" + ] + } + ], + "source": [ + "arc_half_copy = copy.deepcopy(arc_half) #This is to avoid problems with pointers when copying the half arc\n", + "arc = arc_half + [at.Monitor('BPM_CellCenter')] + arc_half_copy[::-1] #We also add a monitor in the center for later on\n", + "arc = at.Lattice(arc, energy=3e9)\n", + "print('Periodicity:', arc.periodicity)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen. We had to define the energy of the ring. The periodicity of the ring has been automatically set based on the total bending angle of the cell. We can do a quick check of the linear optics using the plot_beta function." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import at.plot\n", + "arc.plot_beta()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets now make a full ring of 25 cells." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "ring = []\n", + "for i in np.arange(int(Nhalfcells)):\n", + " ring += copy.deepcopy(arc)\n", + " ring += [at.Monitor('BPM_SS')]\n", + " ring += [at.Corrector('Corrector', 0, [0, 0])]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_geometry\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstart_coordinates\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mcentered\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_axes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAxes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Compute and plot the 2D ring geometry in cartesian coordinates.\n", + "\n", + "Parameters:\n", + " ring: Lattice description\n", + " start_coordinates: x,y,angle at starting point\n", + " centered: it True the coordinates origin is the center of the ring\n", + " ax: axes for the plot. If not given, new axes are created\n", + "\n", + "Keyword arguments are forwarded to the underlying\n", + ":py:func:`~matplotlib.pyplot.plot` function\n", + "\n", + "Returns:\n", + " geomdata: recarray containing, x, y, angle\n", + " radius: machine radius\n", + " ax: plot axis\n", + "\n", + "Example:\n", + " >>> ring.plot_geometry()\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/plot/standalone.py\n", + "\u001b[0;31mType:\u001b[0m method" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring = at.Lattice(ring, energy=3e9)\n", + "ring.plot_beta() \n", + "geom,radius,ax = ring.plot_geometry(centered=True)\n", + "ring.plot_geometry?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets check to see if our ring has the correct total bending angle. For this we need to use some functions to access certain lattice elements.\n", + "\n", + "Here we will use 'get_uint32_index'. For all of these kinds of functions, you can specify either a string 'BPM' or a string with a wildcard 'BPM*' or an element in order to select the correct indices. More detail will be provded later on how to access and modify lattice elements. But for now we can see:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50\n" + ] + } + ], + "source": [ + "bpm_inds = at.get_uint32_index(ring,'BPM*')\n", + "\n", + "bpm_inds = at.get_uint32_index(ring, at.Monitor)\n", + "print(len(bpm_inds))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So what do we want to do? We want to look at every Bend element, and look at its 'BendingAngle' attribute, then sum them all. To achieve this, we can use 'get_value_refpts. This uses 'get_uint32_index' to get the appropriate indexes for the elements, then extracts the given Attribute Name." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dipole_bending_angles = at.get_value_refpts(ring, at.elements.Bend, 'BendingAngle')\n", + "np.sum(dipole_bending_angles) - 2 * np.pi" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041, 0.38041, -0.2708 , -0.33319, 0.4588 ,\n", + " 0.4588 , -0.33319, -0.2708 , 0.38041, 0.38041, -0.2708 ,\n", + " -0.33319, 0.4588 , 0.4588 , -0.33319, -0.2708 , 0.38041,\n", + " 0.38041, -0.2708 , -0.33319, 0.4588 , 0.4588 , -0.33319,\n", + " -0.2708 , 0.38041])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quad_strengths = at.get_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', 1)\n", + "#This searches in ring, for all elements that match a quadrupole, then finds\n", + "#the PolynomB attribute, and takes the second index (python indexes start at 0)\n", + "\n", + "quad_strengths" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, parameters can be set using 'set_value_refpts'. For example, lets increase all quadrupole strengths by 1%" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the final part of this lattice building section. We must discuss something very important.\n", + "\n", + "If you call 'set_value_refpts' with copy=False (default behaviour), the values that you set will be modified for the ring lattice.\n", + "If you call it with copy=True, you function will return a copy of the original lattice with the modifications made, so the correct usage is" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11.761000000000001\n", + "58.805000000000014\n" + ] + } + ], + "source": [ + "new_ring = at.set_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', quad_strengths*5, 1, copy=True)\n", + "print(np.sum(at.get_value_refpts(ring, at.Quadrupole, 'PolynomB', 1)))\n", + "print(np.sum(at.get_value_refpts(new_ring, at.Quadrupole, 'PolynomB', 1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This question of in-place modification will show up in many different locations (tracking, radiation flags)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have one thing missing! An RF Cavity! Let's generate it and then place it in the straight section of the 4th cell. We can use the BPM in the center of the straight section to find the right index" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Cgamma',\n", + " 'Cq',\n", + " '__builtins__',\n", + " '__cached__',\n", + " '__doc__',\n", + " '__file__',\n", + " '__loader__',\n", + " '__name__',\n", + " '__package__',\n", + " '__spec__',\n", + " '_cst',\n", + " '_e_radius',\n", + " '_hbar_c',\n", + " '_sqrt',\n", + " 'clight',\n", + " 'e_mass',\n", + " 'p_mass',\n", + " 'pi',\n", + " 'qe']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from at.constants import clight\n", + "dir(at.constants)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#at.elements.RFCavity?\n", + "harmonic_number = 992\n", + "frf = harmonic_number * clight / ring.circumference\n", + "rfca = at.elements.RFCavity('RF_Cavity', 0, 5e6, frf-100, harmonic_number, ring.energy, PassMethod='IdentityPass') \n", + "#From the help, we can see we need family_name, length, voltage, frequency, harmonic_number, energy\n", + "straight_section_inds = at.get_uint32_index(ring, 'BPM_SS')\n", + "ring.insert(straight_section_inds[2], rfca)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 29, 60, 91, 122, 153, 184, 215, 246, 277, 308, 339, 370, 401,\n", + " 432, 463, 494, 525, 556, 587, 618, 649, 680, 711, 742, 773],\n", + " dtype=uint32)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "straight_section_inds" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([91], dtype=uint32)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "at.get_uint32_index(ring, 'RF*')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications. These will be covered in detail in the next notebook.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have a pretty realistic looking lattice. But at the moment the radiation is off and longitudinal motion is disabled. Lets first enable the 6D tracking and finish setting up the cavity.\n", + "There are two functions for this:\n", + "\n", + "> ring.enable_6d\n", + "\n", + "> ring.disable_6d\n", + "\n", + "When we ask to switch on 6D, the function goes through every single pass method in the lattice, and if an equivalent pass method exists that contains the ending '*RadPass' instead of '*Pass' then it updates the pass method. It also switches all RFCavity elements to have CavityPass. The information in the help of the function allows the user to specifically give pass methods for certain groups of elements. \n", + "\n", + "When ring.disable_6d is called, the pass methods ending in *RadPass* are switched to their *Pass* equivalents, and the RFCavity is switched to IdentityPass (i.e. nothing) if it has length 0, or DriftPass if it has a non-zero length. This effectively disables longitudinal tracking, which is necessary for the accurate computation of uncoupled linear optics.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['BndMPoleSymplectic4RadPass' 'CorrectorPass' 'DriftPass' 'IdentityPass'\n", + " 'RFCavityPass' 'StrMPoleSymplectic4Pass' 'StrMPoleSymplectic4RadPass']\n", + "['BndMPoleSymplectic4Pass' 'CorrectorPass' 'DriftPass' 'IdentityPass'\n", + " 'StrMPoleSymplectic4Pass']\n" + ] + } + ], + "source": [ + "ring.enable_6d()\n", + "print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod')))\n", + "ring.disable_6d()\n", + "print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod')))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# cavity on, radiation on\n", + "ring.enable_6d()\n", + "\n", + "#cavity on, radiation off\n", + "ring.disable_6d(cavity_pass='RFCavityPass')\n", + "\n", + "#cavity off, radiation on\n", + "ring.enable_6d(cavity_pass='IdentityPass')\n", + "\n", + "#cavity off, radiation off\n", + "ring.disable_6d()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can switch on 6D tracking and use some in built lattice functions to set the RF frequency and the cavity phase." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-100.0" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring.enable_6d()\n", + "freq_old = ring.get_rf_frequency()\n", + "ring.set_rf_frequency()\n", + "freq_new = ring.get_rf_frequency()\n", + "freq_old - freq_new" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "503.5243331614815 MHz\n", + "503.5244331614815 MHz\n", + "992 503.5244331614815\n" + ] + } + ], + "source": [ + "print(freq_old/1e6, 'MHz')\n", + "print(freq_new/1e6, 'MHz')\n", + "print(ring.harmonic_number, ring.revolution_frequency*ring.harmonic_number/1e6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "As you can see. our initial guess of 352 MHz was not good for the specified harmonic number. In this simple case set_rf_frequency has applied the RF frequency from harmonic_number*f0.\n", + "\n", + "We can also set the timelag of the cavity. If the TimeLag of the cavity is 0, the there is no phase shift on the RF wave, and the beam will settle itself at a synchronous position where it recovers the energy loss per turn. We can use the function 'set_cavity_phase' to numerically compute the value needed to ensure the beam oscillation point is at ct=0." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.0056910420684217885\n" + ] + } + ], + "source": [ + "print(ring.get_rf_timelag())\n", + "ring.set_cavity_phase()\n", + "print(ring.get_rf_timelag())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have a pretty functional lattice. We can now use the function 'envelope_parameters' to numerically compute some interesting and important parameters (emittances, synchrotron frequency, damping numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Frac. tunes (6D motion): [0.44976772 0.82375107 0.01324872]\n", + " Energy: 3.000000e+09 eV\n", + " Energy loss / turn: 3.001470e+05 eV\n", + " Mode emittances: [ 7.43505855e-09 -2.09766487e-37 1.30912010e-06]\n", + "Damping partition numbers: [0.99736994 0.99999969 2.00263037]\n", + " Damping times: [0.03948775 0.0393839 0.01966608] s\n", + " Energy spread: 0.000525758\n", + " Bunch length: 0.00249121 m\n", + " Cavities voltage: 5000000.0 V\n", + " Synchrotron phase: 3.08153 rd\n", + " Synchrotron frequency: 6724.85 Hz\n" + ] + } + ], + "source": [ + "envelope = at.envelope_parameters(ring)\n", + "print(envelope)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We may also use the class radiation_parameters, but there is one key difference when compared with envelope_parameters. Radiation_parameters uses the analytical formula rather than numerically solving. So the results may differ in some cases as not all pass methods are included." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Drift('DR_01', 2.25), Quadrupole('QF1', 0.75, 0.38041), Drift('DR_02', 0.75), Quadrupole('QD2', 0.75, -0.2708), Drift('DR_03', 0.75), Dipole('Bend', 3.0, 0.12566370614359174, 0.0), Drift('DR_04', 0.1875), Quadrupole('QD3', 0.75, -0.33319), Drift('DR_05', 0.1875), Sextupole('SD', 0.1875, -0.1), Drift('DR_06', 0.5625), Quadrupole('QF4', 0.75, 0.4588), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 0.1), Monitor('BPM_CellCenter'), Sextupole('SF', 0.75, 0.1), Drift('DR_07', 0.1875), Quadrupole('QF4', 0.75, 0.4588), Drift('DR_06', 0.5625), Sextupole('SD', 0.1875, -0.1), Drift('DR_05', 0.1875), Quadrupole('QD3', 0.75, -0.33319), Drift('DR_04', 0.1875), Dipole('Bend', 3.0, 0.12566370614359174, 0.0), Drift('DR_03', 0.75), Quadrupole('QD2', 0.75, -0.2708), Drift('DR_02', 0.75), Quadrupole('QF1', 0.75, 0.38041), Drift('DR_01', 2.25)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=25, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One last thing on this lattice. Let's check and set the tunes and chromaticities using the in built functions" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4497677209816889 0.8237510706933476 0.013248720495886924\n" + ] + }, + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_tune\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLattice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnewval\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtol\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-12\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mniter\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mregex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Fits the tunes using 2 families\n", + "\n", + "Args:\n", + " ring: Lattice description\n", + " refpts1: Selection of the 1st family\n", + " refpts2: Selection of the 2nd family\n", + " newval: New tunes, in case an non-zero integer part\n", + " is provided, fit_integer is set to True\n", + "\n", + "Keyword arguments:\n", + " tol: Tolerance for the matching; Default: 1.0e-12\n", + " dp: Momentum deviation. Default: 0\n", + " niter: Maximum number of iterations. Default 3\n", + " fit_integer: bool (default=False), use integer tune\n", + " regex: Using regular expressions for refpt string matching;\n", + " Default: False\n", + "\n", + "Typical usage:\n", + "at.fit_tune(ring, refpts1, refpts2, [0.1,0.25])\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/matching/globalfit.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qx, qy, qs = at.get_tune(ring)\n", + "print(qx,qy,qs)\n", + "at.fit_tune?\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Fitting Tune...\n", + "Initial value [0.44976772 0.82375107]\n", + "iter# 0 Res. 7.128877285629402e-09\n", + "iter# 1 Res. 2.9451669412131847e-13\n", + "Final value [0.45 0.84999946] \n", + "\n", + "[0.45 0.84999946 0.01324438]\n" + ] + } + ], + "source": [ + "a = at.fit_tune(ring, 'QF*', 'QD*', [0.45,0.85], copy=True)\n", + "print(ring.get_tune())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-26.155161466010924 -26.080691549050364 0.18192596140520467\n" + ] + } + ], + "source": [ + "Qpx, Qpy, Qpz = at.get_chrom(ring)\n", + "print(Qpx, Qpy, Qpz)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Fitting Chromaticity...\n", + "Initial value [-26.15516147 -26.08069155]\n", + "iter# 0 Res. 3.206677417642582e-06\n", + "iter# 1 Res. 7.106044543070933e-15\n", + "Final value [-8.42941077e-08 7.40233657e-10] \n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "array([-8.42941077e-08, 7.40233657e-10, -1.70283305e-03])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "at.fit_chrom(ring, at.get_uint32_index(ring, 'SF*'), at.get_uint32_index(ring,'SD*'), [0,0])\n", + "ring.get_chrom()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "ring.save('./dba.mat', mat_key='RING')\n", + "arc.save('./arc.mat', mat_key='ARC')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring.plot_beta()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/esrfworkshop/1_Introduction.py b/esrfworkshop/1_Introduction.py new file mode 100644 index 0000000..1fe93b7 --- /dev/null +++ b/esrfworkshop/1_Introduction.py @@ -0,0 +1,385 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Introduction + +# Welcome to the PyAT tutorial. +# Here we will go through some of the basic syntax of PyAT. Slowly evolving into more complex examples. +# The outline of the tutorial is as follows: +# > 1. Defining some simple elements and creating a lattice object +# > 2. Simple tracking, orbit correction, radiation flags +# > 3. Accessing and modifying ring elements +# > 4. Matching +# +# + +# First we can import PyAT (and other useful packages) and see all accessible functions using dir + +# In[1]: + + +import numpy as np +import copy +import matplotlib.pyplot as plt +import at +#dir(at) + + +# Many functions! But we cannot do anything because we do not have a lattice. Let's define some key parameters for a DBA lattice. Here I am simply taking the values from the at/machine_data/dba.m file + +# I want to define a drift. But how do I know what to provide to the function? We can use 'help' or ? to tell us. + +# All elements are found in the file: +# > at/pyat/at/lattice/elements.py +# +# This can also be accessed by: + +# In[2]: + + +dir(at.elements) + + +# In[3]: + + +#help(at.elements.Drift) +get_ipython().run_line_magic('pinfo', 'at.elements.Drift') + + +# We can see that we need to provide first a 'family_name' as a string, and a 'length' as a float. We can also use the dir function to see all available attributes that can be accessed from the drift. + +# In[4]: + + +DR_24 = at.Drift('DR_24', 2.4) + +# To see all of the available attributes +dir(DR_24) +# i.e. Length can be re-set by DR_24.Length = New_Length + + +# ## A note on pointers + +# Python uses pointers. When creating a lattice, this can cause some headaches. Observe the following simple examples: + +# In[5]: + + +a = np.arange(10) #the array is assigned some memory +b = a #b is now a pointer to the location of the memory for a +b[5] = 100 #we modify b[5], but it also modifies a due to pointers +print(a) + + +# In[6]: + + +drift = at.Drift('Test',5) # Drift of length 5m +pointer_test = [drift, drift] # Here we make a list of 2 drifts of 5m each + +# Now we can reduce the length of the first drift +pointer_test[0].Length = 2 +print(pointer_test[0].Length, pointer_test[1].Length) + + +# +# +# As you can see, the drift variable was placed twice in the list. When you modify the length of one, you are in fact modifying all. This can cause issues if you predefine elements (drifts, quads, sexts) and then place them in multiple places in the lattice. One must be careful! + +# We can perform similar actions to define the needed dipoles, quadrupoles, sextupoles and markers + +# In[7]: + + +Nhalfcells = 25 #actually it is 50 half cells +K_QF1 = 0.38041 #Strength of the quadrupoles +K_QD2 = -0.2708 +K_QD3 = -0.33319 +K_QF4 = 0.4588 + +Ks = 0.1 # Strength of the sextupoles +L1 = 3 + +# get arc lattice structure +arc_half=[at.Drift('DR_01', L1*6/8), + at.Quadrupole('QF1', L1/4, K_QF1), + at.Drift('DR_02', L1*2/8), + at.Quadrupole('QD2', L1/4, K_QD2), + at.Drift('DR_03', L1*2/8), + at.Bend('Bend', L1, 2*np.pi/(2*Nhalfcells)), + at.Drift('DR_04', L1/16), + at.Quadrupole('QD3', L1/4, K_QD3), + at.Drift('DR_05', L1/16), + at.Sextupole('SD', L1/16, -Ks), + at.Drift('DR_06', L1*3/16), + at.Quadrupole('QF4', L1/4, K_QF4), + at.Drift('DR_07', L1/16), + at.Sextupole('SF', L1/4, Ks) + ] + + +# We have made a list of elements that represent a half cell consisting of drifts, dipoles, quadrupoles and sextupoles. This is just a python list. We will now use this half, make a full cell (first half + reverse of the first half) and convert it into a lattice object and start to benefit greatly from what PyAT has to offer. + +# In[8]: + + +arc_half_copy = copy.deepcopy(arc_half) #This is to avoid problems with pointers when copying the half arc +arc = arc_half + [at.Monitor('BPM_CellCenter')] + arc_half_copy[::-1] #We also add a monitor in the center for later on +arc = at.Lattice(arc, energy=3e9) +print('Periodicity:', arc.periodicity) + + +# As can be seen. We had to define the energy of the ring. The periodicity of the ring has been automatically set based on the total bending angle of the cell. We can do a quick check of the linear optics using the plot_beta function. + +# In[9]: + + +import at.plot +arc.plot_beta() + + +# Lets now make a full ring of 25 cells. + +# In[10]: + + +ring = [] +for i in np.arange(int(Nhalfcells)): + ring += copy.deepcopy(arc) + ring += [at.Monitor('BPM_SS')] + ring += [at.Corrector('Corrector', 0, [0, 0])] + + +# In[11]: + + +ring = at.Lattice(ring, energy=3e9) +ring.plot_beta() +geom,radius,ax = ring.plot_geometry(centered=True) +get_ipython().run_line_magic('pinfo', 'ring.plot_geometry') + + +# Lets check to see if our ring has the correct total bending angle. For this we need to use some functions to access certain lattice elements. +# +# Here we will use 'get_uint32_index'. For all of these kinds of functions, you can specify either a string 'BPM' or a string with a wildcard 'BPM*' or an element in order to select the correct indices. More detail will be provded later on how to access and modify lattice elements. But for now we can see: + +# In[12]: + + +bpm_inds = at.get_uint32_index(ring,'BPM*') + +bpm_inds = at.get_uint32_index(ring, at.Monitor) +print(len(bpm_inds)) + + + +# So what do we want to do? We want to look at every Bend element, and look at its 'BendingAngle' attribute, then sum them all. To achieve this, we can use 'get_value_refpts. This uses 'get_uint32_index' to get the appropriate indexes for the elements, then extracts the given Attribute Name. + +# In[13]: + + +dipole_bending_angles = at.get_value_refpts(ring, at.elements.Bend, 'BendingAngle') +np.sum(dipole_bending_angles) - 2 * np.pi + + +# In[14]: + + +quad_strengths = at.get_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', 1) +#This searches in ring, for all elements that match a quadrupole, then finds +#the PolynomB attribute, and takes the second index (python indexes start at 0) + +quad_strengths + + +# Similarly, parameters can be set using 'set_value_refpts'. For example, lets increase all quadrupole strengths by 1% + +# For the final part of this lattice building section. We must discuss something very important. +# +# If you call 'set_value_refpts' with copy=False (default behaviour), the values that you set will be modified for the ring lattice. +# If you call it with copy=True, you function will return a copy of the original lattice with the modifications made, so the correct usage is + +# In[15]: + + +new_ring = at.set_value_refpts(ring, at.elements.Quadrupole, 'PolynomB', quad_strengths*5, 1, copy=True) +print(np.sum(at.get_value_refpts(ring, at.Quadrupole, 'PolynomB', 1))) +print(np.sum(at.get_value_refpts(new_ring, at.Quadrupole, 'PolynomB', 1))) + + +# This question of in-place modification will show up in many different locations (tracking, radiation flags). + +# We have one thing missing! An RF Cavity! Let's generate it and then place it in the straight section of the 4th cell. We can use the BPM in the center of the straight section to find the right index + +# In[16]: + + +from at.constants import clight +dir(at.constants) + + +# In[17]: + + +#at.elements.RFCavity? +harmonic_number = 992 +frf = harmonic_number * clight / ring.circumference +rfca = at.elements.RFCavity('RF_Cavity', 0, 5e6, frf-100, harmonic_number, ring.energy, PassMethod='IdentityPass') +#From the help, we can see we need family_name, length, voltage, frequency, harmonic_number, energy +straight_section_inds = at.get_uint32_index(ring, 'BPM_SS') +ring.insert(straight_section_inds[2], rfca) + + +# In[18]: + + +straight_section_inds + + +# In[19]: + + +at.get_uint32_index(ring, 'RF*') + + +# There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications. These will be covered in detail in the next notebook. +# +# + +# Now we have a pretty realistic looking lattice. But at the moment the radiation is off and longitudinal motion is disabled. Lets first enable the 6D tracking and finish setting up the cavity. +# There are two functions for this: +# +# > ring.enable_6d +# +# > ring.disable_6d +# +# When we ask to switch on 6D, the function goes through every single pass method in the lattice, and if an equivalent pass method exists that contains the ending '*RadPass' instead of '*Pass' then it updates the pass method. It also switches all RFCavity elements to have CavityPass. The information in the help of the function allows the user to specifically give pass methods for certain groups of elements. +# +# When ring.disable_6d is called, the pass methods ending in *RadPass* are switched to their *Pass* equivalents, and the RFCavity is switched to IdentityPass (i.e. nothing) if it has length 0, or DriftPass if it has a non-zero length. This effectively disables longitudinal tracking, which is necessary for the accurate computation of uncoupled linear optics. +# + +# In[20]: + + +ring.enable_6d() +print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod'))) +ring.disable_6d() +print(np.unique(at.get_value_refpts(ring, np.arange(len(ring)), 'PassMethod'))) + + +# In[21]: + + +# cavity on, radiation on +ring.enable_6d() + +#cavity on, radiation off +ring.disable_6d(cavity_pass='RFCavityPass') + +#cavity off, radiation on +ring.enable_6d(cavity_pass='IdentityPass') + +#cavity off, radiation off +ring.disable_6d() + + +# Now we can switch on 6D tracking and use some in built lattice functions to set the RF frequency and the cavity phase. + +# In[22]: + + +ring.enable_6d() +freq_old = ring.get_rf_frequency() +ring.set_rf_frequency() +freq_new = ring.get_rf_frequency() +freq_old - freq_new + + +# In[23]: + + +print(freq_old/1e6, 'MHz') +print(freq_new/1e6, 'MHz') +print(ring.harmonic_number, ring.revolution_frequency*ring.harmonic_number/1e6) + + +# As you can see. our initial guess of 352 MHz was not good for the specified harmonic number. In this simple case set_rf_frequency has applied the RF frequency from harmonic_number*f0. +# +# We can also set the timelag of the cavity. If the TimeLag of the cavity is 0, the there is no phase shift on the RF wave, and the beam will settle itself at a synchronous position where it recovers the energy loss per turn. We can use the function 'set_cavity_phase' to numerically compute the value needed to ensure the beam oscillation point is at ct=0. + +# In[24]: + + +print(ring.get_rf_timelag()) +ring.set_cavity_phase() +print(ring.get_rf_timelag()) + + +# We now have a pretty functional lattice. We can now use the function 'envelope_parameters' to numerically compute some interesting and important parameters (emittances, synchrotron frequency, damping numbers) + +# In[25]: + + +envelope = at.envelope_parameters(ring) +print(envelope) + + +# We may also use the class radiation_parameters, but there is one key difference when compared with envelope_parameters. Radiation_parameters uses the analytical formula rather than numerically solving. So the results may differ in some cases as not all pass methods are included. + +# In[26]: + + +arc + + +# One last thing on this lattice. Let's check and set the tunes and chromaticities using the in built functions + +# In[27]: + + +qx, qy, qs = at.get_tune(ring) +print(qx,qy,qs) +get_ipython().run_line_magic('pinfo', 'at.fit_tune') + + + +# In[28]: + + +a = at.fit_tune(ring, 'QF*', 'QD*', [0.45,0.85], copy=True) +print(ring.get_tune()) + + +# In[29]: + + +Qpx, Qpy, Qpz = at.get_chrom(ring) +print(Qpx, Qpy, Qpz) + + +# In[30]: + + +at.fit_chrom(ring, at.get_uint32_index(ring, 'SF*'), at.get_uint32_index(ring,'SD*'), [0,0]) +ring.get_chrom() + + +# In[31]: + + +ring.save('./dba.mat', mat_key='RING') +arc.save('./arc.mat', mat_key='ARC') + + +# In[32]: + + +ring.plot_beta() + + +# In[ ]: + + + + diff --git a/esrfworkshop/2_LatticeManipulations.ipynb b/esrfworkshop/2_LatticeManipulations.ipynb new file mode 100644 index 0000000..7760658 --- /dev/null +++ b/esrfworkshop/2_LatticeManipulations.ipynb @@ -0,0 +1,991 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import at\n", + "import at.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as aplt\n", + "\n", + "ring = at.load_mat('./dba.mat', mat_key='RING')\n", + "arc = at.load_mat('./arc.mat', mat_key='ARC')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAHFCAYAAABCcNXZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAADGnUlEQVR4nOzdd3xUZfb48c+UZNI7KbRQQ+9NOoKiiA3WsuqqWFexLGL5ybK7ol9XXAviriuru4q69lVRd0UQlSq9hN5JCIT03pOZub8/bu4kgSSkzMydZM779ZrXTGbu3DlJYHLmeZ5zHoOiKApCCCGEEMLjGPUOQAghhBBC1E8SNSGEEEIIDyWJmhBCCCGEh5JETQghhBDCQ0miJoQQQgjhoSRRE0IIIYTwUJKoCSGEEEJ4KEnUhBBCCCE8lCRqQgghhBAeShI1Idq4rVu3cuONNxIXF4evry+xsbHccMMNbNmypVXnffPNN3nvvfcuuD85ORmDwVDvY85iMBhYtGjRRY9LTk5m5syZREREYDAYmDdvnstiupjS0lIWLVrEunXrLnjsvffew2AwkJyc7Pa4hBBtmyRqQrRhf/vb3xg/fjxnz57lpZde4scff+SVV14hNTWVCRMm8MYbb7T43A0lanFxcWzZsoWZM2e2InLneOyxx9i2bRvvvvsuW7Zs4bHHHtMtltLSUp599tl6E7WZM2eyZcsW4uLi3B+YEKJNM+sdgBCiZX755RfmzZvHVVddxYoVKzCba/47//rXv2bWrFn87ne/Y9iwYYwfP95pr2uxWLjkkkucdr7WOHDgAKNHj+b666/XO5RGdejQgQ4dOugdhhCiDZIRNSHaqMWLF2MwGFi2bFmdJA3AbDbz5ptvYjAYePHFFx33L1q0CIPBwJ49e5g9ezYhISGEhobym9/8hqysLMdx3bp14+DBg6xfvx6DwYDBYKBbt25Aw1OfR44c4ZZbbiEmJgaLxULXrl254447qKioACArK4u5c+fSv39/goKCiI6OZurUqWzcuLHZ3/u6deswGAycOHGC77//3hFjcnJyg9OM2nNqj3hNmTKFgQMHsmPHDiZOnEhAQAA9evTgxRdfxG6313l+fn4+jz/+OD169MBisRAdHc1VV13FkSNHSE5OdiRizz77rCOeOXPmAA1Pfb777rsMGTIEPz8/IiIimDVrFocPH65zzJw5cwgKCuLEiRNcddVVBAUF0aVLFx5//HHHz1azbNkyhgwZQlBQEMHBwfTt25ff//73zf75CiE8hyRqQrRBNpuNtWvXMnLkSDp37lzvMV26dGHEiBH8/PPP2Gy2Oo/NmjWLXr168cUXX7Bo0SK+/vprrrjiCqqqqgBYsWIFPXr0YNiwYWzZsoUtW7awYsWKBuPZu3cvo0aNYuvWrTz33HN8//33LF68mIqKCiorKwHIzc0F4JlnnuG7775j+fLl9OjRgylTptQ7XdiY4cOHs2XLFmJjYxk/frwjxpZMLaanp3Pbbbfxm9/8hm+//ZYZM2awYMECPvzwQ8cxRUVFTJgwgbfeeou77rqL//73v/zjH/8gISGBtLQ04uLiWLVqFQD33HOPI54//vGPDb7u4sWLueeeexgwYABfffUVr7/+Ovv27WPs2LEcP368zrFVVVVce+21TJs2jW+++Ya7776b1157jb/85S+OYz799FPmzp3L5MmTWbFiBV9//TWPPfYYJSUlzf6ZCCE8iCKEaHPS09MVQPn1r3/d6HE333yzAigZGRmKoijKM888owDKY489Vue4jz76SAGUDz/80HHfgAEDlMmTJ19wzqSkJAVQli9f7rhv6tSpSlhYmJKZmdnk78FqtSpVVVXKtGnTlFmzZtV5DFCeeeaZi54jPj5emTlzZp37li9frgBKUlJSnfvXrl2rAMratWsd902ePFkBlG3bttU5tn///soVV1zh+Pq5555TAGXNmjUNxpKVldVg3OfHlJeXp/j7+ytXXXVVneNSUlIUi8Wi3HrrrY777rzzTgVQPv/88zrHXnXVVUqfPn0cXz/88MNKWFhYg/EJIdomGVEToh1TFAVQqyhru+222+p8fdNNN2E2m1m7dm2zX6O0tJT169dz0003XXQd1j/+8Q+GDx+On58fZrMZHx8ffvrppwum+9wpNjaW0aNH17lv8ODBnD592vH1999/T0JCApdddplTXnPLli2UlZU5pkY1Xbp0YerUqfz000917jcYDFxzzTWNxjh69Gjy8/O55ZZb+Oabb8jOznZKrEIIfUmiJkQbFBUVRUBAAElJSY0el5ycTEBAABEREXXuj42NrfO12WwmMjKSnJycZseSl5eHzWZrcApWs2TJEh588EHGjBnDl19+ydatW9mxYwdXXnklZWVlzX5dZ4mMjLzgPovFUiemrKysi35/zaH9nOubqu3YseMFv4eAgAD8/PwuiLG8vNzx9e233867777L6dOn+dWvfkV0dDRjxoxhzZo1TotbCOF+kqgJ0QaZTCYuvfRSdu7cydmzZ+s95uzZs+zatYupU6diMpnqPJaenl7na6vVSk5OTr1Jy8VERERgMpkajEPz4YcfMmXKFJYtW8bMmTMZM2YMI0eOpKioqNmv2RgtoTl/oX1rRpg6dOhw0e+vObSfc1pa2gWPnTt3jqioqBad96677mLz5s0UFBTw3XffoSgKV199dZ2RNyFE2yKJmhBt1IIFC1AUhblz515QLGCz2XjwwQdRFIUFCxZc8NyPPvqozteff/45VquVKVOmOO47f1SpIf7+/kyePJn//Oc/jSZDBoMBi8VS5759+/a1ujHv+bTq1H379tW5/9tvv23xOWfMmMGxY8f4+eefGzxG+96a8jMbO3Ys/v7+dQoWQE2uf/75Z6ZNm9biWAECAwOZMWMGCxcupLKykoMHD7bqfEII/UgfNSHaqPHjx7N06VLmzZvHhAkTePjhh+natSspKSn8/e9/Z9u2bSxdupRx48Zd8NyvvvoKs9nM5ZdfzsGDB/njH//IkCFDuOmmmxzHDBo0iE8//ZTPPvuMHj164Ofnx6BBg+qNZcmSJUyYMIExY8bw9NNP06tXLzIyMvj222956623CA4O5uqrr+b//u//eOaZZ5g8eTJHjx7lueeeo3v37litVqf9XEaNGkWfPn144oknsFqthIeHs2LFCjZt2tTic86bN4/PPvuM6667jqeffprRo0dTVlbG+vXrufrqq7n00ksJDg4mPj6eb775hmnTphEREUFUVJQjcawtLCyMP/7xj/z+97/njjvu4JZbbiEnJ4dnn30WPz8/nnnmmWbHeN999+Hv78/48eOJi4sjPT2dxYsXExoayqhRo1r8vQshdKZvLYMQorW2bNmi3HDDDUpMTIxiNpuV6OhoZfbs2crmzZsvOFar+ty1a5dyzTXXKEFBQUpwcLByyy23OCpDNcnJycr06dOV4OBgBVDi4+MVRam/6lNRFOXQoUPKjTfeqERGRiq+vr5K165dlTlz5ijl5eWKoihKRUWF8sQTTyidOnVS/Pz8lOHDhytff/21cueddzrOraEVVZ+KoijHjh1Tpk+froSEhCgdOnRQHnnkEeW7776rt+pzwIABFzy/vpjy8vKU3/3ud0rXrl0VHx8fJTo6Wpk5c6Zy5MgRxzE//vijMmzYMMVisSiAcueddyqK0nAl6r/+9S9l8ODBiq+vrxIaGqpcd911ysGDBy+IJTAw8IIYtd+l5v3331cuvfRSJSYmRvH19VU6duyo3HTTTcq+ffsa+vEJIdoAg6JUl4UJIdq9RYsW8eyzz5KVldXidVBCCCHcR9aoCSGEEEJ4KEnUhBBCCCE8lEx9CiGEEEJ4KBlRE0IIIYTwUJKoCSGEEEJ4KEnUhBBCCCE8lNc1vLVarezZs4eYmBiMRslThRBCiLbAbreTkZHBsGHDMJu9J33xnu+02p49exg9erTeYQghhBCiBbZv3+5Vu214XaIWExMDqL/ouLg4naMRQgghRFOkpaUxevRox99xb+F1iZo23RkXF0fnzp11jkYIIYQQzdHcZUtvvvkmL7/8MmlpaQwYMIClS5cyceLEBo+vqKjgueee48MPPyQ9PZ3OnTuzcOFC7r777taG3iJel6gJIYQQwjt89tlnzJs3jzfffJPx48fz1ltvMWPGDA4dOkTXrl3rfc5NN91ERkYG77zzDr169SIzMxOr1ermyGt4XcPbs2fP0qVLF86cOSMjakIIIUQb0ZK/32PGjGH48OEsW7bMcV+/fv24/vrrWbx48QXHr1q1il//+tecOnWKiIgIp8XeGlL2KIQQQoh2p7Kykl27djF9+vQ690+fPp3NmzfX+5xvv/2WkSNH8tJLL9GpUycSEhJ44oknKCsrc0fI9ZKpTyG8gM1mo6qqSu8whJP5+PhgMpn0DkMItyoqKqKwsNDxtcViwWKxXHBcdnY2NpvtguKDmJgY0tPT6z33qVOn2LRpE35+fqxYsYLs7Gzmzp1Lbm4u7777rnO/kSaSRE2IdkxRFNLT08nPz9c7FOEiYWFhxMbGYjAY9A5FCLfo379/na+feeYZFi1a1ODx5//fUBSlwf8vdrsdg8HARx99RGhoKABLlizhhhtu4O9//zv+/v6tC74FJFEToh3TkrTo6GgCAgLkj3k7oigKpaWlZGZmAki7IeE1Dh06RKdOnRxf1zeaBhAVFYXJZLpg9CwzM7PBFh9xcXF06tTJkaSBuqZNURTOnj1L7969nfAdNI8kakK0UzabzZGkRUZG6h2OcAHt031mZibR0dEyDSq8QnBwMCEhIRc9ztfXlxEjRrBmzRpmzZrluH/NmjVcd9119T5n/Pjx/Oc//6G4uJigoCAAjh07htFo1K0AUYoJhGintDVpAQEBOkciXEn7/coaRCEuNH/+fP71r3/x7rvvcvjwYR577DFSUlJ44IEHAFiwYAF33HGH4/hbb72VyMhI7rrrLg4dOsSGDRt48sknufvuu3WZ9gQZUROi3ZPpzvZNfr9CNOzmm28mJyeH5557jrS0NAYOHMjKlSuJj48H1N0OUlJSHMcHBQWxZs0aHnnkEUaOHElkZCQ33XQTzz//vF7fgvRRE6K9Ki8vJykpie7du+Pn56d3OMJF5PcsvIW3/v2WqU8hhBBCCA8liZoQQgghhIeSNWpCtEU2K1SVgF/oxY/1YFa7lazSLBQaXoHxxZdf8I9l/+Ds2bN07NiRhQsXMm3aNLfEZ8BAVEAUPkYft7yey5QXgo8/mNr49yGEF5JETYi25Owu2PgKnPgRbJXQezpcsRiieukdWbNkl2WzZOcSfkz5kTLrxbdmMT1oIh518e9L+S/x0pcvuTpEBz+TH5O7TOaJkU8QGxjrttd1irzTsPr3cOR/YPSB7pNg4nzoNkHvyIQQTSSJmhCeTlHg9C+w4WU4ta7uY8d/gPT9cM8PENZVl/Ca63jece5ZfQ95FXkAmA1mTMb6+39VVFRgNBrx8VFHgmw2G5WVlW4rk7cpNspt5axOXs3m1M38c/o/GRA1wC2v3WpFGfD+NZB/Wv3aXgUnf1IvXcfCpCeg5zSQqlEhPJokakJ4KkVRR842vAJntqr3GUww+GYY9wiYfOGz30DWYfj0Nrh/HTSQ8HiK9JJ07l9zP3kVefQO782fLvkTg6IG1ZuoFRUVERYWxubNmxkzZgwAjz/+OLt27WLdunVuideu2Dmcc5j/2/p/HMw5yG9//C0fXfUR8SHxbnn9FlMU+M8cNUkL7wa3fApGM2xdBnv+DSlb4MNfQcdhMOlJSJgBRlmyLIQnkkRNCE9jt6tTVRtfgbS96n0mXxh2O4z/HYTXShJ+8yUsGwvp+2D3BzDyrkZPrSgKZVU2FwbfMD+zkT/+8keyy7LpFdaL5VcsJ9TS8Bq7vXv3YjAYGDx4MKWlpXz00Uf87W9/48svv3RbzEaDkQFRA3jnine4d/W9HMg5wMJNC3n/yvcbHAX0CAe+hJTN4BMAv/kKInuq91+9RE3MNv8Ndr4L5/bAp7dC9ACY9Dj0v97jk30hvI0kakJ4CpsVDn4FG1+FrCPqfT4BMPJuGPswhNSzl2NoJ5iyAFY9DT8/r462+Ta8E0FZlY3+f1rtom+gcYvvLGFr2lb8TH68NuW1RpM0gMTERPr27UtiYiLjxo0DYNasWcycOdMd4dYR6BPIkilLmP3tbPZm7eXDwx9y54A73R5Hk9iq4MdF6u0J82uSNE1IHFz5grpWbcvfYfs/IfMgfHE3RL4AEx+HQTdK4YEQHkLGuoXQm7USdr0Pb4yEr+5TkzRLCEx8AuYdgCv+XH+Sphl1L4TFQ2k27P/cfXE3h6GSt/cvA+DhYQ/TLbTbRZ+SmJjIsGHDGDhwINu2bWPp0qX88MMPPPPMMy4Otn5xQXE8PvJxAN7e9zaFlYW6xHFRh7+FgjMQFAPjHm74uMAouOwZeGw/XLoQ/MMh5wR8/SD8bTjseAesFe6LWwhRLxlRE0IvVWXqdOUvf4XCs+p9/hEwdi6Mug/8w5p2HpMPjL4PfviDOjoy/M4GF4j7+5g49NwVzom/GT44tJy/782mU1Anbu17a5Oek5iYyK233kpwcDCjR49m9OjRHDlyhK1b1fV6Y8aM4e9//zsjR47kzjvv5JJLLuHBBx905bfBrF6z+PDQh5wsOMl7B97j0eGPuvT1WmT7P9XrEXepLTkuxj8cJj8FlzyoTodu/hvkp8B389UClnGPwog7wTfQtXELIeoliZoQ7lZeoP5B3PImlGSq9wXFqgUCI+aAJaj55xz2G/j5z5BxAM5sh65j6j3MYDAQ4Ove//aVtko+PfoRAA8MeQCfJkypWa1WDh48SN++fevcv3fvXq688koA/vjHP/LCCy8wfvx4goKCXJ6kAZiMJh4Z9gjz1s3j0yOfcu+gewnw8aBN7zMOqYUCRrP6b6k5LMHqGsjR98Puf8MvS6EwFVYvUBO2MQ+oHwgCIlwRuRCiATL1KYS7FKXDmj/BawPVNUQlmRDaFWa+Cr/bq05TtSRJA3VUpP916u2DXzktZGdYnbyanPIcov2jmdmjaevLjhw5Qnl5Oc8//zx79uzh6NGjzJs3j6SkJO677z4Arr76ak6dOsXq1at5/fXXXfkt1HFp10uJD4mnqKqIb09+67bXbZID1YUWva9ofLq8MT7+MOZ+eDQRrvmrWjValgvrXoDXBsD3T0P+GWdFLIS4CI9N1BYvXozBYGDevHmO+xRFYdGiRXTs2BF/f3+mTJnCwYMH9QtSiKbIPgHfPgJLB8Evr0NFIUT1gevehEd3q2vMfJywmfbA2er1wa/VylEP8dFhdTTt5r43N7nDf2JiInFxcQQGBjJx4kQmTZrEmTNnWLt2LXFxagKyfft28vPzCQsLw2x23yih0WDklr63AOr3pigN76rgVooCB1eot7V/C61h9lWnPB/eBTe8C7GDoaoUti2Dvw6FFQ9A5uHWv44QolEemajt2LGDt99+m8GDB9e5/6WXXmLJkiW88cYb7Nixg9jYWC6//HKKiop0ilSIRqTugs9uV4sEdn+g7iTQZQz8+hOYuxWG3ebcyroel4IlFIrTa/qu6exo7lEO5hzEbDRzQ8INTX5eYmIiY8aMYc2aNRQXF5ORkcGXX37pmApNTU3l3nvvZe3atRw/fpzDh92bMFzf63r8zf4kFyazN2uvW1+7QVnHIPckmP0gwYnrEE1mGPgr+O0GtdVH90lgt8LeT+DNS+DjX0OKZ/x7E6I98rhErbi4mNtuu41//vOfhIeHO+5XFIWlS5eycOFCZs+ezcCBA3n//fcpLS3l448/1jFiIWrRmtS+dzX8c6pagYcCCVfCXavUHQT6XuWa5qJmX/XcAIf/5/zzt8D/TqlxTO48mQi/pq9tSkxMvOCDmqasrIwbbriBN954g+7du/PUU0/x/PPPOyXepgr0CeTy+MsBPGf6M2mdet3rMnW9mbMZDNBrGtz5X7jvZ+h3LWCAY9/Du1fAu1fC0VUeNZorRHvgcYnaQw89xMyZM7nsssvq3J+UlER6ejrTp0933GexWJg8eTKbN29u8HwVFRUUFhY6LjL6JlzCZoX9X8BbE9WO78kb1QXdQ26BB7fArZ9B/FjXx6GNpJz8yfWvdRE2u43vTn0HwDU9r2nWc/fu3dtgoubv78+WLVuYNGkSALfccgsfffRR64JtgWt7XgvAquRVVNg8oI3F6S3qdcKVrn+tTiPg5n/Dwzth+B1qQ+aULfDJzbBsHOz9VO3nJoRoNY+q+vz000/ZvXs3O3bsuOCx9PR0AGJiYurcHxMTw+nTpxs85+LFi3n22WedG6gQmspSSPyouqVB9b9Dn0B1bc8lcyGsi3vj6TEFDEa1F1tRuntf+zy7MnaRVZZFqCWUSZ0mNeu5WVlZLorKeUbFjiImIIaM0gw2pW5iWtdp+gVjt0PmIfV2z6nue92oXnDt32DK72Hrm7Bzubql2Yrfqg2YxzygJnJ+Ie6LSYh2xmNG1M6cOcPvfvc7PvzwQ/z8Gl5YbTivP5SiKBfcV9uCBQsoKChwXA4dOuS0mIUXK8pQ/xC9NgBWPqEmaQGRauPQxw7AlYvdn6SBWv3ZaaR6O2WL+1+/lh9TfgRgapepTWrJ0dYYDUbH9OfPKT/rG4y1HLBDdH91twp3C4mD6f+n/tuf9icIjFab7v6wUP0/snohFJx1f1xCtAMek6jt2rWLzMxMRowYgdlsxmw2s379ev76179iNpsdI2nayJomMzPzglG22iwWCyEhIY5LcLAL1m4I75FxEL5+CJYOVHtLleWquwJc9Yq6i8Dkp/TvM9WremQnZZtuIdgVOz+lqNOvl8VfdpGj2y5tFG3tmbVU2XWc6rOWq9fuHE2rj3+YugXVvP1wzesQlaBWOW95A5YOhi/uUfcXFUI0mcckatOmTWP//v0kJiY6LiNHjuS2224jMTGRHj16EBsby5o1axzPqaysZP369Y59AIVwCa1A4N+z1PU3iR+qFZydR8NNH8Cje9RGoI3sselW3Ser1zr+QTyQfYDM0kwCfQIZE1d/8932YFj0MCL8IiiqLGJH+oVLNtxG2+qpxxT9YqjNx09tuDt3G9z6OXSbCIoNDnwBb0+B5TOl8ECIJvKYNWrBwcEMHDiwzn2BgYFERkY67p83bx4vvPACvXv3pnfv3rzwwgsEBARw661N25JGiGaxVsD+/6gbV2vrfwxG6HeNukl6l9H6xteQTsPBZIGyHN0WdK87sw6ACZ0mYDFZdInBHUxGE1O6TOGr41+x4ewGxnXU4UOjrRLsVYDB8/5NGo1qgUvCFXAuUf2/dPArOL1JvUT2hrEPwZBfN227KyG8kMckak3x1FNPUVZWxty5c8nLy2PMmDH88MMPMp0pnKskR93iafvbNVs8+QbBsNvhkgfUTu2ezGyBziMhJwV0qkb85dwvAEzsNFGX13eniZ0m8tXxr/gl9Rd9AqgqU6+jEsAvVJ8YmqLjUPjVP+GyRbDtH7Drfcg5Dv+bBz//n9r4edR9ENRB50CF8CwenaitW7euztcGg4FFixaxaNEiXeIR7Vz2Cdj6d0j8BKzVf/yCO6rJ2fA7m75JuifoOlZN1KzuT9RyynI4lKOOQI7vNN7tr+9uY+LGYDaYSS5M5kzRGboEu7mIpLJUve44zL2v21KhndTCg8lPqXuKbl0GBSmw/i+waSkMvkndID5mgN6RCuERPGaNmhC6sNvh+I/w4Q3wxgh1JM1apm6XM/ufMG+fulF1W0rSAOKrp+B0SNQ2n1P7GvaL6EeUf5TbX9/dgn2DGRI9BECfUTVtRC1uqPtfuzUswTB2rrrG84blam82WwXs+be6FvS9q9XGzXab3pEKoSuPHlETwmUqitSRs+1vQc6J6jsN6lqasQ9DtwlqJ/a2qvNIwKBu9WOrApywl2gTaYmaN4ymaSZ0msCujF1sPreZX/f9tfte2G4DW3XFZ8ch7ntdZzKZ1b1JB8yCM9vUEbbD/1WbRidvVKuqR98Pw37T9j4wCeEEkqgJ75JzEnb8C/Z8qLYNALCEqH8ERt0LkT31jc9Z/EIhrJt621oOuGcdp6IobE/fDtCuqz3PNyZW/V53ZuzEZrdhMprc88LaaJrRDIFtfG2XwQBdL1Ev+Wdg5zuw6z21R+EPC2HtCzD0Fhj9W+iQoHe0QriNJGqi/VMUOLUWtr0Fx1YDinp/ZC/1TX/oLa7ZG1Fv2hof7Y+5G6QUpZBZmomP0YehHYa67XX11i+yH4E+gRRVFnE07yj9I/u754WrStRrk697Xs9dwrqoRQeTnlIrr7f9Q6283vEv9dJzmrqOrec01+ybK4QHkX/hov2qKFbf1P8+Ru2BdmwVoECvy+G2L+GhHTDm/vaZpAHEVCcLbkzUtqWpTXYHdxiMn9k5063vv/8+/fv3JyAggL59+/K//3nGhvO1mY1mRsSMAGB72nb3vbBWSNDeEjWNb4C6HduDm+GOb6HPTMCg7mX70Q3w91Gw7W11KYMQ7ZQkaqL9yU1St6xZ0h++exyyj6rtNUb/Fh7eBb/5Anpf1v4/icdW9yWsKldHFd1Aa/o6OtY5/bxWrFjBQw89xB/+8AcOHDjAjBkzeOCBB5xybmfTvmdt6tctqqoTNXM7TdQ0BgP0mAy3fKwWH4x9GCyh6vrS759U/6+vfAqyjuodqRBOJ1Ofon2w2+D4GnUE7cSPOKY3w7vDmN/C0Nu8b2PoiF6Qmg3Y1KaoZtc2nlUUhd0ZuwF1w3JnePXVV5k/f76jqfVVV13F8uXLnXJuZxsZq+6xmpiZiF2xYzS4+IOArUr9vUL7HVGrT0R3uOLPMGUB7P1EXdKQc1wtDNr+FnSfpK437XMVtMM9ZoX3kURNtG3FWbDnA9j5ntqLSdNzKox5QJ3mbO8jZw0x+9b8oaoqdXmillGaQWZZJiaDiQGRre+BVVRUxJYtW3j11Vcd961atYqhQ4e2+tyu0Ce8D/5mf4qqikgqSKJnmIsLUxyFBL7qjhnexhKkbt028h51DeqOd+DY95C0Qb0Ex6nbWA2/U900Xog2ShI10fYoilrGv+NfcPDr6u1zAP9wtXpzxF3tp3qztbSRlqoy9eejKDXTZU6WWL0+LSGsFwGKApUldQ/wCWhWy5O9e/diMBgYPHgwpaWlfPTRR/ztb3/jyy+/dGbYTmM2mhkQOYCdGTvZm7XX9YmathG72QJYXftansxohF7T1Ev+GbVSdPf7UJQG6xbD+peg39XqKFu3iW277Y7wSpKoibajogj2fa42pc04UHN/pxHqm/CAWbJf4PkcI2rVoy9VpfBCR5e81N6IMAgNYcjpnfW/xu/PgW9gk8+XmJhI3759SUxMZNw4tYHvrFmzmDlzppMidr4hHYY4ErXZvWe79sW036mPlydqtYV1gWl/hMn/Dw5/q36YS9kCh75RL1F91PeKITd79nZbQtQiiZrwfJmH1WmNvZ9CZXV1l9kfBt0Ao+5pO1vn6MHkC9jdUvm5z6JOrQ4ud85uCImJiQwbNoyBAweybds2tmzZwsKFC3nmmWf4v//7P6e8hrMN6aA2nd2Xtc/1L6b9Tk1+QEmjh3ods6/6/jDoBkg/oPZk2/uZWlj0/ZPw4yJ1q6pR90DsIL2jFaJRkqgJz1RVrn4i3vUenK61LU9kL3VNytBb1Kk80TiTD1ChTg/bqtTpx9+fc/rLVNoqOfzFNLBXMfTudRDc+cKDfAKadc7ExERuvfVWgoODGT16NKNHj+bIkSNs3boVgIkTJ1JUpCbu+/fvZ/fu3QwZom93/sEdBgNwMv8kRZVFBPu6qPWLotSa+nTfrhNtUuxAuPo1uOxZ2PeZOsqWdQR2LVcvnUaoa9kGzFbXvQnhYSRRE54l8zDsel+t5irPV+8zmKDvVeqURffJssakOQxGdbE5VeoIjF9Is6Yfm+pQ5nGq7FWEW8LpHJHQ6t+R1Wrl4MGD9O3bt879e/fu5corrwRg48aNAPzhD39g6tSpuidpAJH+kXQO6szZ4rPsz9rPuE7jXPNC1nJAUX+/UtnYNH4havHBqHvVD3/b/wlH/gepu9TLqt/D4BvV4oOOQ/WOVggHSdSE/ipL4eAKdfTsbK0eVKFdYNjtaoFAaCfdwmvzzH7qiJq1HHBNixJtqm9IhyEYnJBIHzlyhPLycp5//nni4uIICAhg2bJlJCUlcd999zmOW7JkCampqbz77rutfk1nGRI9hLPFZ9mbvdd1iZo27Wn2lw8uzWUwqHv5dpsAxZmQ+LFafJB7Sl3/uvNddYP7EXPUqdP22hBbtBmSqAn9pO1T3yD3fV6z76bBBH1mqJWbPS8Fd+2Z2J6ZfaGSmqkyF9ibtRdQkxRnSExMJC4ujsDAQCZOnEhgYCATJkxg7dq1xMWprRaWL1/OL7/8wueff+6U5NBZBkcN5rtT3zl+Ji6h/S6leKZ1gqJhwjwY9yic3qR+WDz0LaQlwv/mqY2zB92gJm0dh0lSLHQhiZpwr4oiOPClOr15bnfN/eHdYPgdamPa4FjdwmuXzBY1UXNhQYGWlAyOGuyU8yUmJjJmzBhWrFhR7+MrVqzg008/5dtvv8Vk8qxkXktW92Xtc13jW0fFp6xPcwqjUW2U230SlGSrSy92vafufLD7ffUSO6h6lO1GqRgVbiWJmnCPvGTYuERN0iqL1fuMPmp/oxFzoNsk721M62qm6ka31gp1EbqTRwXSS9LJKM3AaDAyMGqgU86ZmJjI+PHjG3z87rvvpkOHDowZMwaAxYsXM2PGDKe8dmslhCfgZ/KjqLKI5IJkeoT1cP6L1J76dM/uYN4jMArGPaJuU3V6c/Uo2zeQvl/dku6HP6qtgCbMh6heekcrvIAkasL1dv8bVj4J1uo/LpG91ORsyC3qm6JwLW0fSMWmrlVz8nZDB3MOAtArrBcBzazsbMjevXt58MEHG3w8Ly/PKa/jCj5GH/pH9md35m4O5hx0fqJms9Y0efbxh8oq555fqAwG6DZevcz4i9oeaNd7aouPxI9g/39g+vPqFnVCuJAkasK19n8B3z6s3u42Ud2fL36crPVwJ4NRnf60VqhtT5ycqB3JPQJAv4h+TjtnVlaW086lh36R/diduZtDOYe4puc1zj259oHH5Fu9hlMSNZcLiICxc+GSB+HMdtjwkrqn8PdPqf+3RszRO0LRjslck3Cd7BPwzUPq7dH3w53/VT+dSpLmflqvLRcUFGiJWt+Ivhc50ntoPwvtZ+NUtac9hXsZDNB1DNz2hTr1Cep0aJobGhwLryWJmnANux2+fURNDHpcClf+RRI0PWl/1CVRcwttdPFo7lEUxcmLyKzVOz9IIYF+DAaY9ifoezXYreqsgU228RKuIYmacI3D30LKZvAJhGtel0IBvZmrCwqqnJuo5Zfnk16SDkCfiD5OPXdb1iOsBz5GH4qqijhbfNa5J6+zGbvQjcEAM5eAXxik7YV9n+odkWin5K+ncD67Hdb/Rb097mEIj9c3HlHTb8tarlZ+OsmRPHU0rXNQZ9dtl9QG+Rh96B3eG3DB9Kc2oiZbR+kvOAYmPq7e3vCyuk2bEE4miZpwvqPfQeYhsISoi2+F/rTRF63y00mO5FQXEkQ6r5CgvdCmPw/nHHbeSe21fn8mGVHzCKPugcAOagui/V/oHY1ohyRRE863/Z/q9ah7ZON0T2Ew1vxhd+L05+FcNQmR9WkXcklBga16NM1gApMU7XsE38CaD6Q7/qlvLKJeb775Jt27d8fPz48RI0Y49gmuz7p16zAYDBdcjhxxQWFQE0miJpwr+wQkrQcM6jZQwnP4OL/y82juUUAStfq4JFGTaU/PNOwOtYF36i44l6h3NKKWzz77jHnz5rFw4UL27NnDxIkTmTFjBikpKY0+7+jRo6SlpTkuvXv3dlPEF5JETTjX7vfU64QrZG2ap3Fyi44yaxlJhUmAJGr1SQhPwICBrLIsssuynXNSR6Im054eJagD9L9Ovb1rub6xiDqWLFnCPffcw7333ku/fv1YunQpXbp0YdmyZY0+Lzo6mtjYWMdFz63qJFETzmO3w/4v1dvDbtc3FnEhJydqx/OOY1fsRPhF0MG/g1POeTFTpkxh3rx5AHTr1o2lS5e65XVbIsAnAEuJmlA5bZ2aJGqea/gd6vXBr8FaqWso7V1RURGFhYWOS0VFRb3HVVZWsmvXLqZPn17n/unTp7N58+ZGX2PYsGHExcUxbdo01q5d67TYW0ISNeE8KZuh6Jy6YXHvy/WORpzPkajV/6bWXLV3JDDo0CNvx44d3H///W5/3eaY0GcC4MTpT2nN4bm6TYCgWCjPh5M/6x1Nu9a/f39CQ0Mdl8WLF9d7XHZ2NjabjZiYmDr3x8TEkJ6eXu9z4uLiePvtt/nyyy/56quv6NOnD9OmTWPDhg1O/z6aSlajCufRKp76XSN/SDyR9juxW9WLsXX//bXkQ6/+aR06uGcUryFVVVX4+Pg0eszgmMH8ePZHR9FFqyiKrFHzZEaTuln7tmVw4Avoc6XeEbVbhw4dolOnTo6vLZbG/96c/0FSUZQGP1z26dOHPn1q3tPGjh3LmTNneOWVV5g0aVIrom45GVETzmG3w5H/qbcH/krfWET9jKaa5MwJo2qu2OOztpKSEu644w6CgoKIi4vj1VdfrfP4+VOfixYtomvXrlgsFjp27Mijjz5a59j/+7//49ZbbyUoKIiOHTvyt7/9rc75CgoKuP/++4mOjiYkJISpU6eyd+/eOucfOnQo7777Lj169MBisaAoCl988QWDBg3C39+fyMhILrvsMkpKSgD47zv/BWp+VhUVFTz66KNER0fj5+fHhAkT2LFjh+M1tIqzn376iZEjRxIQEMC4ceM4evSo2ppDsakHSmsOz6S99x1dJdOfLhQcHExISIjj0lCiFhUVhclkumD0LDMz84JRtsZccsklHD9+vFUxt4ZHJWrLli1j8ODBjh/+2LFj+f777x2Pz5kz54KS2UsuuUTHiIVD6i4oyQJLqLr5uvBIislCqa2C0vJ8SqtKW3wprCjkWN4xALqFdGvSc5q7ldKTTz7J2rVrWbFiBT/88APr1q1j165d9R77xRdf8Nprr/HWW29x/Phxvv76awYNGlTnmJdffpnBgweze/duFixYwGOPPcaaNWvUn4uiMHPmTNLT01m5ciW7du1i+PDhTJs2jdzcXMc5Tpw4weeff86XX35JYmIi6enp3HLLLdx9990cPnyYdevWMXv2bMf3GlAUAMCZojMUVRbx1FNP8eWXX/L++++ze/duevXqxRVXXFHnNQAWLlzIq6++ys6dOzGbzdx99901054mX9npw1N1GgFBMVBZBKc36R2N1/P19WXEiBGO/+eaNWvWMG7cuCafZ8+ePcTFxTk7vCbzqKnPzp078+KLL9KrVy8A3n//fa677jr27NnDgAEDALjyyitZvrymqsbX11eXWMV5jq5Ur3tNA1Pj00FCP2UGGPPzfU49543/u7FJx227dRsBPgFNOra4uJh33nmHDz74gMsvV9c7vv/++3Tu3Lne41NSUoiNjeWyyy7Dx8eHrl27Mnr06DrHjB8/nqeffhqAhIQEfvnlF1577TUuv/xy1q5dy/79+8nMzHR8On/llVf4+uuv+eKLLxxr4SorK/n3v//tmHbdvXs3VquV2bNnEx+vVjnXThDNVjPmUjPWACt7z+1l2bJlvPfee8yYMQOAf/7zn6xZs4Z33nmHJ5980vG8P//5z0yePBmAp59+mpkzZ1JeUoAfyGiaJzMa1Yr33R/A0e+h51S9I/J68+fP5/bbb2fkyJGMHTuWt99+m5SUFB544AEAFixYQGpqKh988AEAS5cupVu3bgwYMIDKyko+/PBDvvzyS7788kvdvgeP+lh2zTXXcNVVV5GQkEBCQgJ//vOfCQoKYuvWrY5jLBZLnZLZiIgIHSMWDkerRz77XKVvHKJx5rbxwebkyZNUVlYyduxYx30RERF11o7UduONN1JWVkaPHj247777WLFiBVZr3U2ya59L+/rwYXXt2K5duyguLiYyMpKgoCDHJSkpiZMnTzqeEx8fX2dt3JAhQ5g2bRqDBg3ixhtv5J///Cd5eXl1Xsc3X/2Zbz6xmaqqKsaPH+94zMfHh9GjRzvi0AwePNhxW/skn5l2Tr1D1n96Nu098Oj3Tt2uTbTMzTffzNKlS3nuuecYOnQoGzZsYOXKlY4PVmlpaXV6qlVWVvLEE08wePBgJk6cyKZNm/juu++YPXu2Xt+CZ42o1Waz2fjPf/5DSUlJnTfYdevWER0dTVhYGJMnT+bPf/4z0dHRDZ6noqKiTuluUVGRS+P2SgVnIeuw2v2+1zS9oxGN8PcNY9vUf4LJDzoktPg8r+9+nY+PfMwNvW/gyVFPXvwJgL/Zv8nnb+40aZcuXTh69Chr1qzhxx9/ZO7cubz88susX7++0QX/2oJiu91OXFwc69atu+CYsLAwx+3AwMA6j5lMJtasWcPmzZv54Ycf+Nvf/sbChQvZtm0b3bt3B8BSYKG0YynJpcl1XrP293r+fbVjdsRYVQYES6Lm6bpPVos9Cs5A1lGIlh6Deps7dy5z586t97H33nuvztdPPfUUTz31lBuiajqPGlED2L9/P0FBQVgsFh544AFWrFhB//79AZgxYwYfffQRP//8M6+++io7duxg6tSpDfZQAVi8eHGdMl7tXMKJTlb3mOk0AgJkhNOTGXz8CDBZCDAYCDD7E+AT0KLLyQJ1lGlg1MAmP6c5LTx69eqFj49PndH0vLw8jh071uBz/P39ufbaa/nrX//KunXr2LJlC/v373c8Xvtc2td9+6p/RIcPH056ejpms5levXrVuURFRTX+MzUYGD9+PM8++yx79uzB19eXFStWOB635KuJVZo9DV9fXzZtqlm7VFVVxc6dO+nXrwkFGdridKn49Gy+AdC1enDhlL79t0T74HEjan369CExMZH8/Hy+/PJL7rzzTtavX0///v25+eabHccNHDiQkSNHEh8f3+iw5IIFC5g/f77j69TUVEnWnE17M+oxRdcwRBNoU5+KXd3c29T8qVBFURxVjH0jXTNaEBQUxD333MOTTz5JZGQkMTExLFy4EGMDi+jfe+89bDYbY8aMISAggH//+9/4+/s7pjcAfvnlF1566SWuv/561qxZw3/+8x++++47AC677DLGjh3L9ddfz1/+8hf69OnDuXPnWLlyJddffz0jR46s93W3bdvGTz/9xPTp04mOjmbbtm1kZWXVSbwsBWqillyYzG/n/pYnn3ySiIgIunbtyksvvURpaSn33HPPxX8oNi1RkxE1j9fzUvV98eTamn1AhWghj0vUfH19HcUEI0eOZMeOHbz++uu89dZbFxwbFxdHfHx8o2WzFoulTuluYWGh84P2ZnY7nFqv3u5xqb6xiIvTNme3VagtOlqQqKWXpFNQUYDZYKZXWC8XBKl6+eWXKS4u5tprryU4OJjHH3+cgoKCeo8NCwvjxRdfZP78+dhsNgYNGsR///tfIiMjHcc8/vjj7Nq1i2effZbg4GBeffVVrrjiCkAdFVu5ciULFy7k7rvvJisri9jYWCZNmtRoGX9ISAgbNmxg6dKlFBYWEh8fz6uvvuooFgAwlZkIs4SRX5HPXU/eBTa4/fbbKSoqYuTIkaxevZrw8PAm/EQUwNCi35lwM+1Da/ImdSS0jawNFZ7JoDR3MYibTZs2jS5dulwwjwyQk5NDp06dePvtt7njjjuadL6zZ8/SpUsXzpw502AFmWiG9P3wjwngEwj/L1nekDxIeXk5SUlJdO/eHT+/WtNlOSehohBCu0Bg49N69VmbspZH1z5K7/DefHXtV06M2HW6devGvHnzHNtPudt9P9zH1rStLBq7iF8ltKDPYHkh5J5Upz2j606TNvh7Fvqx2+GV3lCaDXd9D/FNbwUhGuatf789ao3a73//ezZu3EhycjL79+9n4cKFrFu3jttuu43i4mKeeOIJtmzZQnJyMuvWreOaa64hKiqKWbNm6R269zq9Rb3ueokkaW2FNnXWwqa3rm502x5pP6sWbyUle3y2LUYjdKuu7j3d+J6SQlyMR019ZmRkcPvtt5OWlkZoaCiDBw9m1apVXH755ZSVlbF//34++OAD8vPziYuL49JLL+Wzzz4jODhY79C915nqBdpdxzZ+nPAcjkStZZuza9sh9Y2Qaram0rbZanGiZpNErc3pOhYOfQNntukdiWjjPCpRe+eddxp8zN/fn9WrV7sxGtEkKVqiNkbfOETTtXJz9qO5R4G2laglJyfr+vraiNrRvKPY7DZMRlPzTuDYlUAStTajS/V74plt6lSo7CYhWkj+5YiWyz8DhalgMKmtOUTboP2xt1Wq1Z/NUFBRwLkStfGqXpuxt0XxIfH4mfwos5aRUpRy8SecTzZjb3tiB4FPAJQXQFYLR1KFQBI10RrakH7cEPANbPxYoZsL6oVMPmr1J0pNy4cm0qbuOgV1IsQ3xEkRtn8mo4mEcLXBsDYi2WSKvdHWHB5eD+a9TD7Qubqty5mtjR8rRCMkURMtl1KrkEB4HK27fWlpad0HDIaaUbVmTn9KIUHLaVPF2hq/JtN+RwYTGC9craL9fhvbgUHopEv1e2OKJGqi5TxqjZpoY1KqR9QkUfNIJpOJsLAwMjMzAQgIqLU7gN0MVgVKioGmr3s6mHUQgJ4hPSkvb1kxgrfqGdITgEPZh5r3sysvUn9XZh+otQuLoiiUlpaSmZlJWFgYJlMz170J1+sqiZpoPUnURMuUF0DGAfV2F0nUPFVsbCyAI1lzKC9QL75lEND0JtAHMtXfeVhFGElJSU6L0xsEl6rV6YeyD3Hq1Kmmb6lVXgjl+erygnr6/YaFhTl+z8LDdB6lLjPIPw2FaRASp3dEog2SRE20zNkdgALh3SC44c7tQl8Gg4G4uDiio6OpqqqqeeDId/DLM9BpJMz6R5POVW4t59wOtZBgUt9JRAdEuyLkdivOGofpsIlCayHBccF08O/QtCf+9Bwc/hZG/xYG3FfnIR8fHxlJ82R+IRA9ADL2q+vUBkjPT9F8kqiJlnFMe0r/tLbAZDLV/YMeFQ/FZ+CcDZrYzf5E9glsio1wSzhdwrs0a5N1AX740T20OyfyT5BUkkSX8C5Ne2LGbvV3FR7X5N+V8CBdL1ETtZRtkqiJFpFiAtEyZ3eo151H6RuHaJmIHup10TmoKG7SU2o3upUkrWUcBQU5zSgoyDmhXke6bl9V4UJaPzXtPVOIZpJETTSfokDaXvV2x2H6xiJaJiACAqo3LM892aSnHMlRKz77RradRreeRkvUjuY1sUVHWT6UZKm3JVFrmzoOVa8zDoDNqmsoom2SRE00X8EZKMsFow/EDNA7GtFSkb3Va23E5iKO5ElrjtZq9ohaTnUSHRwHliAXRSVcKqIn+Aaru0tkN7OHnhBIoiZa4lyieh3dT/YebMu0EZqci4+o2ew2jucdB2RHgtbQErWzxWcpqiy6+BNk2rPtMxohbrB6W3vvFKIZJFETzZeWqF5rQ/qibYpU+3o1ZUTtdOFpyqxl+Jv9iQ+Od3Fg7VeoJZSOgR2BJm7Q7kjUerowKuFycUPVa23JiBDNIImaaD7tzSZuiL5xiNbRRmmyj1/0UC2pSAhPaP6G4qIOxzq1pmwlJSNq7YP2Xql9yBWiGSRRE82jKDXD93FSSNCm1Z76vMh+kVqipiUZouWatZVUTnUSLYla26bNPqTvB7tN11BE2yOJmmiewlQozVb3HZRCgrYtogdggIoCKMlu9NDarTlE62g/w4tOfdrtNesHtcIP0TZF9gKfQKgqbdIIthC1SaImmqd2IYGPNN9s03z8IKy66Woj69QURXFM00nFZ+v1i1R/hqfyT1Fpq2z4wKJz6h92oxnCZV1gm2Y0Qewg9bZMf4pmkkRNNI9jfdpQXcMQTuKY/mw4UcsozSCvIg+TwUSvcJmCa62YgBhCLaFYFSsn8hsp5NB+J+HdweTjnuCE62jTn1L5KZpJEjXRPFLx2b44ErWGp2O0Kbruod2xmKQdS2sZDIamTX9qU2RRMu3ZLkjlp2ghSdRE09UpJBiqZyTCWZrQS01bnybTns6j/SwbbXwrrTnaF0dBwT51/aEQTSSJmmi64gwoyQSDUQoJ2osmTH1q69Ok0a3zNGtETQoJ2ofI3mD2h8riJm/bJgRIoiaaI+OAeh3ZC3wD9I1FOIeWqOWearBtgJZMyIia89Te89OuNDC6kiNTn+2KyQwx/dXb2nupEE0giZpouoxD6nV0f33jEM4T2hlMFrBVqnu4nqegooDU4lRARtScqVtIN/xMfpRZy0gpTLnwgKoyyK/+fciIWvuhzUSkS6Immk4SNdF0GQfV65iB+sYhnMdoqu6nBmRfOP15LO8YAJ2COhFqCXVnZO2ayWgiITwBaGD6M/cUoIBfKARGuTc44Tox1S06tPdSIZpAEjXRdJlaoibr09qVRvb81Ba79wmX0TRna3SHgtrr0wwGN0YlXEp775SpT9EMkqiJprFVQVb13oQxMvXZrmhroOpJ1BxbR0XKjgTOpk0l17vnp6xPa5+0RK3gDJTl6RuLaDMkURNNk3NSXcfkGwyhXfWORjhTI5WfR/KkkMBVHC06cg+jnL/XarZsxt4u+YdBaPVuINqaXyEuQhI10TTaUH10PzDKP5t2pYFeahW2Ck7lnwJkj09X6B3eG5PBRG55LlllWXUflBG19ktb4yvTn6KJ5C+uaJrM6k9/sj6t/dEStYIzarVhtRN5J7ApNsIsYcQExOgUXPvlZ/aje2h34LyCAkWpNaImiVq7EyuJmmgeSdRE02RIIUG7FRCpVheiVFcbqhzr0yL6YpAF7S6hrVOrk6iVZEFFAWCoqcgV7Ye06BDNJImaaJoMGVFrtwyGmpGbWuvUtGpEmfZ0HW2dWp1ETav4DOsKPn46RCVcSmvRkXm4wSbTQtQmiZq4uPICKKhuyinNbtunegoKao+oCddwtOioveenrE9r3yK6q1tJWcvqjGAL0RCPStSWLVvG4MGDCQkJISQkhLFjx/L99987HlcUhUWLFtGxY0f8/f2ZMmUKBw9K40CXy6z+IxLSWa1aEu3PeQUFNrvN0exWKj5dR0vUzhafpaiySL1T9vhs34ymmhZH6fv1jUW0CR6VqHXu3JkXX3yRnTt3snPnTqZOncp1113nSMZeeukllixZwhtvvMGOHTuIjY3l8ssvp6ioSOfI2zlt0atMe7ZfWtPb6iQhpSiFMmsZfiY/4kPidQysfQu1hBIXGAfU6qemjWpGSWuOdsvR+FYGGsTFeVSids0113DVVVeRkJBAQkICf/7znwkKCmLr1q0oisLSpUtZuHAhs2fPZuDAgbz//vuUlpby8ccf6x16++YoJJBpz3brvKlPbdozITwBk9GkV1ReQRtVc6xTkxG19s+xlZQUFIiL86hErTabzcann35KSUkJY8eOJSkpifT0dKZPn+44xmKxMHnyZDZv3qxjpF5Aq06SPT7bL21ErSwXSnOlkMCNaje+xVoJecnqA7JGrf1ytOiQETVxcWa9Azjf/v37GTt2LOXl5QQFBbFixQr69+/vSMZiYur2c4qJieH06dMNnq+iooKKigrH1zJN2kx2e82bSewgfWMRruMbCCGdoDAVck46puFk6yjXq9OiI/80KDbwDYLgOJ0jEy6jFWVpW0n5h+sbj/BoHjei1qdPHxITE9m6dSsPPvggd955J4cO1Wy1cX4/J0VRGu3xtHjxYkJDQx2X/v1l+q5Z8pOhqgRMFojoqXc0wpWqR9WU7OM1FZ/hkqi5mjaidir/FJVa4U5kT9mMvT3zD6vZik+2khIX4XGJmq+vL7169WLkyJEsXryYIUOG8PrrrxMbGwtAenp6neMzMzMvGGWrbcGCBRQUFDgutZM+0QTptbaOMnncAKxwpup1aplZ+8ktz8VkMNE7XKbfXC02MJZQSyhWxcqJtB3qnbI+rf1zFBTIOjXROI9L1M6nKAoVFRV0796d2NhY1qxZ43issrKS9evXM27cuAafb7FYHO0+QkJCCA4OdkfY7Yf2JhIr69PavepE7WiO+mGme2h3/MzScNXVDAZDTUFB9c9e1qd5Ae09VVp0iIvwqCGS3//+98yYMYMuXbpQVFTEp59+yrp161i1ahUGg4F58+bxwgsv0Lt3b3r37s0LL7xAQEAAt956q96ht1+Oik9J1Nq96lGcw8Vnwbdm7ZRwvb7hfdmWto3DJanqHZHSmqPdkxYdook8akQtIyOD22+/nT59+jBt2jS2bdvGqlWruPzyywF46qmnmDdvHnPnzmXkyJGkpqbyww8/yCiZK2mf9iRRa/+q+3YdsRYC0ujWnbSijaPVP3uiEnSMRriFbCXlNm+++Sbdu3fHz8+PESNGsHHjxiY975dffsFsNjN06FDXBngRHjWi9s477zT6uMFgYNGiRSxatMg9AXm78kK1Cg2k2a03CIsHk4UjPmrfNGnN4T5aUnzUbMCOAaNMfbZ/Ed3BJwCqStWtpOR37hKfffYZ8+bN480332T8+PG89dZbzJgxg0OHDtG1a9cGn1dQUMAdd9zBtGnTyMjIcGPEF/KoETXhYTKr18uEdIKACH1jEa5nNFEU1YuzPj6AJGru1C2kG35GH0qNRlIiuoCPv94hCVczmtQiLZB1ai60ZMkS7rnnHu6991769evH0qVL6dKlC8uWLWv0eb/97W+59dZbGTt2rJsibZgkaqJhMu3pdY5EdAQgzhxIqCVU52i8h8loorev+mHoSHgnnaMRbhMjjW9boqioiMLCQseldq/U2iorK9m1a1edRvkA06dPb7RR/vLlyzl58iTPPPOMU+NuKUnURMMchQQy7ektjvqr6z37ItWe7tYXXwCO+AfoHIlwG0eiJi06mqN///51+qMuXry43uOys7Ox2Wz1Nso/v9WX5vjx4zz99NN89NFHmM2esTrMM6IQnklac3idw0YrAP3Ky3WOxPv0LS8D4IjBqnMkwm0cLTokUWuOQ4cO0alTzcizxWJp9PimNsq32WzceuutPPvssyQkeE5BjyRqon52e03H7BjZOspbHKnMBaBPYQYoinTHd6N+BRkQauJwRc5Fd1wR7YS2lVThWdlKqhmCg4MJCQm56HFRUVGYTKYmN8ovKipi586d7Nmzh4cffhgAu92OoiiYzWZ++OEHpk6d6pxvohlk6lPULy9J3TrK7AcRPfSORrhBpa2SU8VqH69+xQVQVP/UgHCB8kJ65Z3DqCjkVhWSXZatd0TCHepsJSXr1JzN19eXESNG1GmUD7BmzZp6G+WHhISwf/9+EhMTHZcHHnjAsbXlmDFj3BV6HTKiJuqXIVtHeZsT+SewKjZC7RBrs0H2UQiRjcHdIvs4/opCd5vCSbOBw7mH6RDQQe+ohDvEDoSCFDVR6zZB72janfnz53P77bczcuRIxo4dy9tvv01KSgoPPPAAoG4zmZqaygcffIDRaGTgwLpLfaKjo/Hz87vgfneSETVRP23NhBQSeA3HRuymQAwAWUd1jcerZKs/675mtZhD+10IL6C9x0qLDpe4+eabWbp0Kc899xxDhw5lw4YNrFy5kvj4eADS0tJISUnROcrGSaIm6ueo+JT1ad7icM5hAPoGqi06JFFzo+qfdd8AdYG0JGpeRFp0uNzcuXNJTk6moqKCXbt2MWnSJMdj7733HuvWrWvwuYsWLSIxMdH1QTZCEjVRv4zqT3dS8ek1juZVJwva1lHZx3SMxstU/6z7RqmjK5KoeREtUZOtpEQDJFETFyovgPzqoWCZ+vQKdsXO0dzqRK1j9YJZGVFznyw1MevX8RIAzhSdoaiySM+IhLtoW0lZyyDnpN7RCA8kiZq4kNaWI6SzlIt7iZTCFEqtpVhMFrp1najeWZKptgwQrlVVDnnJAIR2HE5coFrAoSXOop2rvZWUNL4V9ZBETVxIGt16nSN56ohO77DemP3D1SQdIEumP10u9yQodvALhaAY+kT0AWT606vIDgWiEZKoiQs59viUaU9vcSSnuuIzsnoj9g7VXbmzJFlwOW2KOaoPGAz0q14jKImaF4mtLtqSggJRD0nUxIUcFZ8youYttKRASxKIUkd1pKDADbSfcXVy3DdCTZYlUfMijhYdMqImLiSJmqjLboNMbesoSdS8haOHWsT5I2qyTsrltFHL6uRYS5ZP5p+k0lapV1TCnbRETdtKSohaJFETdeUmQVUpmP0hsqfe0Qg3yCrNIqc8B6PBSO/w3uqdjhE1SdRcTlsH2EH9mccGxhLiG4JVsXIi/4SOgQm38QuVraREg2RvIFGX1j8tuq9ajSTavcO5aqPbbiHd8Df7q3dWJw3kn4HKUvAN0Cm6ds5ug5zqZCxKHcU0VK9T25a+jaO5R+kf2V/HAIXbaFtJpR+QraTakIiIiGYdbzAY2L17t2NnhKaQRE3UlbZPvY4drG8cwm0c/dO0aU+AwCgIiITSHMg5DnFDdIqunctLBluFOoId1tVxd9+IvmxL38bh3MPMYpZ+8Qn3iRkAR1dK5Wcbk5+fz9KlSwkNDb3osYqiMHfuXGy25jU2lkRN1JVenajJH2avoY2oOQoJNFF9IGWzuk5N/j24hlZIENWrzgi2Vn0rBQVeRFp0tFm//vWviY6ObtKxjzzySLPPL4maqKEokLZXvS1/mL2Glgxo/bscOiTUJGrCNc4rJND0DVcTtaO5R7ErdowGWU7c7mktOrStpGTpSZtgt9ubdXxRUfN3HJH//aJGUTqUZIHBCNGyLsYbFFcWc6boDNDAiBpIQYErnVdIoOkW2g2LyUKptdTx+xHtXHi36q2kymUrKVGHjKiJGtq0Z1QfWTzuJbSN2GMDYwnzC6v7oKNFh/RScxktCa4uJNCYjWYSwhPYn72fw7mHiQ9p+sJj0UYZTeoH5NSd6vRnh4SLP0d4nNTUVH755RcyMzMvGG179NFHW3ROSdREDce0pxQSeAtH/7Twvhc+qI2o5Z4EWxWYfNwYmRdQlAZH1EAtKNifvZ8jOUe4stuVbg5O6CJmQE2iNnC23tGIZlq+fDkPPPAAvr6+REZGYjAYHI8ZDAZJ1IQTyPo0r+NI1CLrSdRCO4NvEFQWq/315BO+cxWlQWURGEwQcWHPQtmhwAtp69S06nvRpvzpT3/iT3/6EwsWLMBodN7KMlmjJmpIaw6vc8GOBLUZDBBV3QBX9vx0Pu1nGtEDzL4XPCyJmheKG6pepyWqI66iTSktLeXXv/61U5M0kERNaEpz1WaLUPOpTrRrVbYqR+f7ehM1gA7V90vlp/NpP9N6pj0Beof3xmgwklOeQ1ZplhsDE7qJGaAWc5VkqcVdok255557+M9//uP088rUp1BphQTh3cA/TM9IhJucLDiJ1W4lxDeEjoEd6z8ouroSVNv/VTiP9jNtoMLa3+xPt5BunCo4xeHcw3QI6ODG4IQufAPUtaFZh9WlKCFxekckmmHx4sVcffXVrFq1ikGDBuHjU3dd75IlS1p0XknUhEqmPb3O4Ry10W3fiL51Fr3W0UFL1A67KSovov1MoxsYzUT93ZwqOMWR3CNM6jzJTYEJXXUcWpOo9ZEikrbkhRdeYPXq1fTpo46Sn19M0FKSqAmV7EjgdRpsdFubNqKWcxyslfWupRItoCiQWb32rJGehf0i+rEyaaWsU/MmcUNg7yc1xV2izViyZAnvvvsuc+bMcep5ZY2aUEnFp9fR/vhf0Oi2ttDO4BsMdqvapkM4R8FZteLTaK634lMjW0l5Ie09WBK1NsdisTB+/Hinn9ejErXFixczatQogoODiY6O5vrrr+fo0bqLmOfMmYPBYKhzueSSS3SKuJ2oLIHs4+ptSdS8gl2xO5rdNlhIAGrlpzY1J9OfzqNVfEb2bnSUUutvd6boDEWVzd96RrRBWjFX4VkoydY3FtEsv/vd7/jb3/7m9PN61NTn+vXreeihhxg1ahRWq5WFCxcyffp0Dh06RGBgoOO4K6+8kuXLlzu+9vWV6ZhWST8AKBAUC0FN21hWtG1ni85SUlWCr9GXbqHdGj+4Q184u0MSNWdyFBI0kiQDYX5hxAbGkl6SztHco4yMHemG4ISuLMEQ2QtyTqhtOnpdpndEoom2b9/Ozz//zP/+9z8GDBhwQTHBV1991aLzelSitmrVqjpfL1++nOjoaHbt2sWkSTULaS0WC7Gxse4Or/2S9Wle53CumnT1Du+Nj/EiOw5oa6iyJFFzmiasT9P0jeirJmp5kqh5jbgh1YnaXknU2pCwsDBmz3b+jhIelaidr6CgAICIiIg6969bt47o6GjCwsKYPHkyf/7zn4mOlpGgFktLVK9l6yivcTS3CdOeGpn6dD5tRK3DxX/+/SL6se7MOkeVrvACcUPhwJeyTq2NqT3T50wem6gpisL8+fOZMGECAwcOdNw/Y8YMbrzxRuLj40lKSuKPf/wjU6dOZdeuXVgslgvOU1FRQUVFheProiJZ53EBac3hdbQRtUYLCTTaqE/uKagqBx8/F0bmBez2mma3TRhR06pypaDAi0hBgajFYxO1hx9+mH379rFp06Y69998882O2wMHDmTkyJHEx8fz3Xff1TvkuHjxYp599lmXx+ss5VU2CsqqKCyrUq/L1euC0ioKy61Y7Qo9ogKZPiCGAF8n/PqslTUjJTL16TWa1JpDExQD/uFQlgfZx2TktbXyk8FaBiYLRHS/6OFaMn2y4CRVtip8TBeZqhZtn/Z/LC9Z/X/nH97qU5ZX2VhzKIOTWcUYMBDibybU34cQPx9C/H3U2/5mQvx8CPA1tarvlzcZPnw4P/30E+HhTfsdTZgwgc8++4xOnTo1+TU8MlF75JFH+Pbbb9mwYQOdO3du9Ni4uDji4+M5fvx4vY8vWLCA+fPnO75OTU2lf/+Lf4ptiM2uUGm1U2m1U2GzUVFlp9Jmr7nPaqfCaqOkwkZppZWSShulFbWvrTWPVV8XV1gpKLNSWF5FpdXepDhiQ/x48VeDmNKnlVO+WYfBXgV+YRDWtXXnEm1Cdlk22WXZGDCQEN6EjdYNBrXxbcpmNamXRK11tA9GHRLAaLro4XGBcYT4hlBYWciJ/BP0i2zCKKho2/zDISwe8k9D+n7o3rpmx1tP5fDEf/ZyNq+sScebjYaa5M3PTJCfGX8fM4EWEwG+ZgJ8TQT6mgiwqLcDfM0E+prw9zURaDHjZzbhazbiazbiYzLgazZiMZnwMRvwNRkxmzyq4USrJCYmsnfv3guWaDV2fO1ZvqbwqERNURQeeeQRVqxYwbp16+je/eKfNnNycjhz5gxxcfVvtWGxWOpMiRYWFgJw+zvb8A05hV1Rqi9gVxRsdgWl1m27AlZ7TSJmtbt+o1yjAUKqP+mE1vqkE+qvfpLecCyb1Pwy7vtgJ//4zQim9Ytp+Ytp055xg9U/yKLd00bTuoV2I8AnoGlPiq5O1KSgoPUcOxI07QOjwWCgX0Q/tqVv40juEUnUvEXcEDVRS9vbqkRt84ls7npvBxVWO7Ehfkzp0wGDwUBhuTpzU1imztZoMzlWu4LVrpBbUkluSaUTv6EaRgP4mNREzmI2YjYaMRrAaDRgNBjU2wYDBgOYqu8zGAxUFGS6JJ7WmjZtGorStNygJSOVHpWoPfTQQ3z88cd88803BAcHk56ubkobGhqKv78/xcXFLFq0iF/96lfExcWRnJzM73//e6Kiopg1a1azXut4RjHmstattTEYwNek/kPzNZuqr9WvAy3apw4zAZbzrqs/ddR+vCYh8yHI14zR2PAvs7zKxuP/2ct3+9J4+OM9fP+7iXSLCmzw+EZpayBkfZrX0BI1rUdXk0TLVlJO4xhRa/rPv09EH7alb+Nw7mFm0bz3OtFGxQ2Bw9/CucQWnyKtoIwHPtxFhdXO1L7RvHHrsEaXzCiKQplj+Y2avBWUVdWZASqttFFSaaWs0lbnvtrHVFhrzTJVzzjVZleonn2y05xV49bC4hb+JFwnKSmp2c+52Ezh+TwqUVu2bBkAU6ZMqXP/8uXLmTNnDiaTif379/PBBx+Qn59PXFwcl156KZ999hnBwcHNeq3XbxlKbFynmuy9ViZfk8Grt00GA5ZaQ7laQmY2GnSZx/fzMfH6zUPJLa5ky6kcHvs8kS8eGIepkeSuQY7WHEOdGqPwXI5ELbIliZpszt5qzRxRg5rqXK1aV3iBjkPV6xYWFCiKwhP/2UthuZUhnUNZ9pvhWMyNT7UbDIbqqU0zcaEtetkGY7HWWjZUZVOTNG3ZkNWmoFAzi6XUmuWyKzWzXOnnUrlpmfPicob4+HiXv4ZHJWoXGzr09/dn9erVTnmtMd0j6dw5yinn0oPZZOSVm4Zw5dIN7EnJ56vdZ7lxZJfmncRuU9c/gKw78iKORK0prTk02ubs+SlQUQyWIBdE5gVsVeq+qXDRZre1aQUFR3KPYFfsGA3tZ42PaEBsdXFXzgmoKFIb4TbDqgPp/HIiBz8fI6/dPPSiSZorGQwGfEwGfExGAi9sztBkZ/2bt7arvZD/7W1YpzB/Hp3aG4Ala45RXmVr3glyTkJVKfgEqJ2wRbtXUlXC6cLTQDMTtcBICKwuXMmSUZ0Wyz0FtkrwCYTQphfvdAvthsVkodRaypmiMy4MUHiMoA4Q0glQqnePaboqm52XV6v/T387qSc9OsgHq7ZMErU27vax8XQM9SOtoJzPdzbzDfzcHvU6dnCTqs9E23cs7xgA0QHRRPg1rUrJQRsBkoKClnOsT+sDxqa//ZqNZnqHqR/KtB54wgu0sJ/at4nnOJVdQmSgL/dN6uGCwIQ7SaLWxvn5mHhgSk8A3t2UhL05ValaotZxmAsiE55I627fpEa359PWVElBQcu1YH2aRltTKOvUvEgLEjVFUXhnk7rA/e4J3QmyeNQKJ9ECkqi1A78a3pkQPzPJOaX8dKQZ5cuSqHmdZjW6PV8H2Uqq1bTRyGasT9NoybWMqHmRFiRqW0/lciitED8fI7eNkd6YeqisrOTs2bOkpKTUubSUJGrtQKDFzC3V/yE/3na6aU+yWWsqPiVR8xpaota6ETWp/Gwxx9Rn83/+jq2kcmQrKa+hVeNnHYGqpjWr/Xi7mhDMHt6ZsABfFwUm6nP8+HEmTpyIv78/8fHxdO/ene7du9OtW7cm9YVtSLPGRL/99ttmv8Dll1+Ov79/s58nmufmkV14a/0p1h/LIrOwnOiQi/SIyz6mFhL4BkkhgZeosldxIv8E0MxCAo02ClSUBqW5ENDMNW7erqpMreADiBnQ7KcnhCdgNBjJKc8hqzSLDgEdnByg8DjBsWoRT0kmZByEziMbPbygrIrVB9X+o7eMktE0d5szZw5ms5n//e9/xMXFOa19V7MSteuvv75ZJzcYDBw/fpwePWQxo6v16BDEiPhwdp3OY8WeVH47uWfjTzi3W72OG9qsRc2i7TqVf4oqexXBPsF0Cmr6PnMOfqHqNmP5KeqoWrcJzg+yPcs6Cood/CPUP8DN5G/2p1tIN04VnOJI7hFJ1LyBwaBOf55Yoy5VuUii9r9956i02ukbG8zATiFuClJoEhMT2bVrF337tuCDcCOa/Rc6PT0du93epEtAQBO3pxFOccMItdvxij2pFz/YsT5tqOsCEh5FW9vUJ6JPyz/pxQxUrzMOOikqL6L9zGIGtHi7Nm0kVJvCFl5Ae49uwg4FK3ar7/2/Gt5ZNlXXQf/+/cnOznb6eZuVqN15553Nmsb8zW9+Q0iIZPXuMmNgLGajgSPpRZzKushWG1qi1mm46wMTHuFgtpooDIhs/rSbgzZll9G8vk6CWonawBafQkvUpKDAi3Ssfo/WZkEakF5Qzs7TeQBcM6Sjq6MS9fjLX/7CU089xbp168jJyaGwsLDOpaWaNfW5fPnyZp1c2xJKuEdYgC/jekWx4VgW3x9I56FLG1h7Zq2saaAohQRe41COWgQwIMoZiZqMqDWblty2YH2aRkbUvJD2YTrrCFSWgG/9+zpra9NGxIcTG9q6faxFy1x22WWAukl7bYqiYDAYsNma2ZS+mjRYaWeuGhjLhmNZrNyf1nCilnUYbBXqmqPwlleiiLajyl7l+OPeP7L5PbwcoquTjMzD6hZk0ii5aRSlVqLW8p+/Vq17pugMxZXFBPlKx/l2LzgWgjtC0Tm1TUf8uHoPW7k/DVBnVoQ+1q5d65LztipRKy8vZ9++fWRmZmK32+s8du2117YqMNEy0wfE8vsV+zl4rpDU/DI6hdUzVV27f5qsY/AKp/JPUWmvJNgnmC7BzdwTtraIHmD2UyuG85Ih8iJFK0JVnAmlOYChRa05NGF+YcQGxpJeks7RvKOMiBnhvBiF5+o0HI6cg9Td9SZqBaVV7EjOBeCKAZKo6WXy5MkuOW+LE7VVq1Zxxx131LtwrjVDfKJ1IgJ9GdZVrf5ceyST31wSf+FB0ujW6xzMUacq+0f2b92G3iaz2vg2LVGd/pRErWkyq6eKI3uCb+uKrPqG9yW9JJ0juUckUfMWHYfBkf81uE5t04ls7Ar0ig6iS4QU8ekpPz+fd955h8OHD2MwGOjfvz933303oaGhLT5ni9+xH374YW688UbS0tIuqPaUJE1fU/uqm2evO9rALgWp1f/ZJVHzGlohQf+oVkx7aqTys/lqV3y2kraVlLbmUHgBbZ1aav2J2oZjWQBM6i0tW/S0c+dOevbsyWuvvUZubi7Z2dksWbKEnj17snt348UgjWlxopaZmcn8+fOJiYlp8YsL17i0j5qo/XIih/Kq85LmqvKazvKSqHkNbUStVRWfGqn8bD4nVHxqBkaq59CSb+EFtPfqvCS12XQtiqKw4biaqE3uI4lafd588026d++On58fI0aMYOPGjQ0eu2nTJsaPH09kZCT+/v707duX1157rUmv89hjj3HttdeSnJzMV199xYoVK0hKSuLqq69m3rx5LY6/xYnaDTfcwLp161r8wsJ1+sUFExviR1mVzbFuwSHjINitEBAFoa1YqyTajEpbJUfz1I28nZuoSaLQZE6o+NRoVbunCk5RUlXS6vOJNsA/vKbwS1u6Uu14ZjFpBeVYzEbGdJfdQs732WefMW/ePBYuXMiePXuYOHEiM2bMaHDvzcDAQB5++GE2bNjA4cOH+cMf/sAf/vAH3n777Yu+1s6dO/l//+//YTbXrCozm8089dRT7Ny5s8XfQ4vXqL3xxhvceOONbNy4kUGDBuHj41Pn8UcffbTFQYnWMRgMjOsZyVd7UtlyMoeJtYfDz9Wa9pRCAq9wPP84VruVUEtoy3YkOJ+WbOQlQUUxWKTysFG2KnVXAnBKohblH0VcYBxpJWkcyjnEqNhRrT6naAM6DVf/z53bDb1q2j9o056ju0fg5yNV2OdbsmQJ99xzD/feey8AS5cuZfXq1SxbtozFixdfcPywYcMYNqxmtqlbt2589dVXbNy4kfvvv7/R1woJCSElJeWCnQnOnDlDcHBwi7+HFidqH3/8MatXr8bf359169bV6YJsMBgkUdPZJVqidiqn7gNad2uZ9vQajvVpEf2d0608MAqCYqE4XW3T0UUShUblnABbJfgGQ6hz9l8cGDWQtJI09mfvl0TNW3QcDge+hNS6I2rrqxO1yQneM+1ZVFRUp4GsxWLBYrFccFxlZSW7du3i6aefrnP/9OnT2bx5c5Nea8+ePWzevJnnn3/+osfefPPN3HPPPbzyyiuMGzcOg8HApk2bePLJJ7nlllua9Hr1aXGi9oc//IHnnnuOp59+GqPsFelxxvaIBGDf2QKKK6wEWap/1Y4RtaH6BCbczimNbs8XM6A6UTsoidrFONan9XfavroDoway5vQaDmTLOkGv0enCHQrKq2xsT1KXt3hTota/f92iqGeeeYZFixZdcFx2djY2m+2CtfQxMTGkp6c3+hqdO3cmKysLq9XKokWLHCNyjXnllVcwGAzccccdWK1WAHx8fHjwwQd58cUXL/r8hrQ4UausrOTmm2+WJM1DdYkIoHO4P2fzytiRnKsWGFQUqSMgAJ0a39xXtB/aH3OnrE/TxPSHkz/JOrWm0H5G0U6ouK02KGoQgCRq3iRuCBiMUJQGhWkQEse2pFwqrHbiQv3oFe09SxAOHTpEp041yzjqG02r7fyZBG2ngMZs3LiR4uJitm7dytNPP02vXr0uOirm6+vL66+/zuLFizl58iSKotCrV69W73ve4izrzjvv5LPPPmvViwvX0kbVtp6snv5M3Q0oahFBsFTreoPSqlKO5x8Hav64O4W06Gg6J7bm0PSP7I8BA2klaWSXOX8TaOGBfAPVHobgGFXbnqS+t4/rGeVVm7AHBwcTEhLiuDSUqEVFRWEymS4YPcvMzLxox4ru3bszaNAg7rvvPh577LF6R+waEhAQwKBBgxg8eHCrkzRoxYiazWbjpZdeYvXq1QwePPiCYoIlS5a0OjjROmN7RvKfXWdr1qmlVleddJbRNG9xMOcgdsVOdEA0MYFOTM5rt+hQFClMaYwTW3NoAn0C6RHag5MFJzmYfZDJXVzTEV14mI7D1fZKqbuh70x2JKmbsI/uHq5zYJ7J19eXESNGsGbNGmbNmuW4f82aNVx33XVNPo+iKFRUVNT72OzZs3nvvfcICQlh9uzZjZ7nq6++avJr1tbiRG3//v2OyogDB+oOv3tTZu/JxvZUR9QOpBZQWF5FyNld6gMy7ek19mfvB2Bw1GDnnjgqAYxmKC+AwlQI7ezc87cXZXlQeFa93Yo9PuszIGoAJwtOciDngCRq3qLTMEj8EM7tpsJqI/FsPgCjuklbjobMnz+f22+/nZEjRzJ27FjefvttUlJSeOCBBwBYsGABqampfPDBBwD8/e9/p2vXro7KzU2bNvHKK6/wyCOP1Hv+0NBQR87Tmt0HGtPiRM1Vm48K54kL9ad7VCBJ2SVsP5nDZWd3qA/IiJrX2J9Vnah1cHKiZraoyVrmIXXESBK1+mVUN5cO7Qp+zn0THxQ1iG9PfutIxoUX6KgVFOzhwNl8Kq12IgN96R4VqG9cHuzmm28mJyeH5557jrS0NAYOHMjKlSuJj1e3V0xLS6vTU81ut7NgwQKSkpIwm8307NmTF198kd/+9rf1nn/58uX13namZiVq+/btY+DAgU0uIDh48CB9+vSp0/xNuNclPSJJyi7h0JGDXFaSqY6CxA3ROyzhJvuy9gFOXp+miRmgJmrp+yHhCuefvz2oXfHpZAOjanYoaMriaNEOxAwEky+U5XH0sPp/e2S3cPndX8TcuXOZO3duvY+99957db5+5JFHGhw9u5iysjIURXGsSzt9+jQrVqygf//+TJ8+vUXnhGYWEwwbNoycnJyLH1ht7NixDXb/Fe6hdaquOL1dvSNmIPj46xiRcJf0knQyyzIxGUz0j3R+okBsdfKXLiM6DUrfq17HOnlEE+gT3gdfoy/5FfmkFMn7rFcw+zo+aJee3ALItKcnue666xxTqPn5+YwePZpXX32V6667jmXLlrX4vM0a6lIUhT/+8Y9NrmKorKxsUVDCeYZ1DQMgKm8fmJBpTy+iTYn1Du9NgE/rK48uoCUfaXudf+72Ik0d9SDO+Ymaj8mH/pH9ScxKZG/WXuJD4p3+GsIDdRkDZ3cQkr0HGMJISdQ8xu7dux37gn7xxRfExsayZ88evvzyS/70pz/x4IMPtui8zUrUJk2axNGjR5t8/NixY/H3l9EbPXWNCCAi0JdBVSfUO6SQwGu4dNoTaqbQ85LUogInr8Fq86yVNX0LXTCiBjCkwxA1Ucvcy7U9r3XJawgP01ltMD3AfhQ/HyMDOoboHJDQlJaWOraK+uGHH5g9ezZGo5FLLrmE06dPt/i8zUrUZBP2tsdgMDCycyADk5PUOzpLF3lv4fJELSACQjqrVY3pB6DbeNe8TluVdQTsVeAXBmHO2TrqfEOih8Ah2Jslo5peo8toAPoaUrikox8+Jmk67yl69erF119/zaxZs1i9ejWPPfYYoPZtCwlpeUItv2EvcFlkNn6GKkqMwRDZU+9whBtY7VbH1lFOr/isTZvSS9/nutdoq7SfSewgl/WZG9JBHdU8nn+ckqoSl7yG8DAhHckzR2MyKMyMTNU7GlHLn/70J5544gm6devGmDFjGDt2LKCOrtXe6L25JFHzAqNQp18SSZDGpF7ieN5xym3lBPkE0T20u+teyLFOTRK1CzjWp7muyjo6IJqOgR2xK3Zp0+FFdil9ABhlbPpSJOF6N9xwAykpKezcuZNVq1Y57p82bZpj7VpLSKLmBboUqduNrK9IILOwXOdohDvsydwDqKNpRoML/5vLiFrDHCNqLhzRpGZUbW+mTH96g7ySStaW9wagU8Huixwt3MVqtWI2m8nOzmbYsGF12piNHj3a0UC3JTwqUVu8eDGjRo0iODiY6Ohorr/++guKFxRFYdGiRXTs2BF/f3+mTJnCwYOy32CD7HbMZ7YCsM3ej90p+frGI9wiMTMRgGHRLR9ubxItCck6Atb6t1jxSnZ7TdsSF1R81jYkWk3UErMSXfo6wjPsPZvPVns/AHzO7ZT/dx7CbDYTHx+PzWZz+rk9KlFbv349Dz30EFu3bmXNmjVYrVamT59OSUnN2ouXXnqJJUuW8MYbb7Bjxw5iY2O5/PLLKSoq0jFyD5Z5EMrzqTD6c0Dpzp4zeXpHJNxgd6b6SdvliVpoZ/APB7tVbX4rVHlJUFkMZj+I7O3Sl9JG1PZl7cOu2F36WkJ/+84WcFLpSJEpHKzl6r6fwiP84Q9/YMGCBeTm5jr1vM1K1L777ju6du1KREQEU6dOZeXKlQA888wzXHHFFTz//PNkZGS0OJhVq1YxZ84cBgwYwJAhQ1i+fDkpKSns2qXuUakoCkuXLmXhwoXMnj2bgQMH8v7771NaWsrHH3/c4tdt15I3AZAbORwbJvbIiFq7l1acRkZpBiaDyXUVnxqDQdap1UfrLRczAEyu3ZmlT0Qf/Ex+FFYWklyY7NLXEvrbeyYfMJAdOUK9o/o9Xujvr3/9Kxs3bqRjx4706dOH4cOH17m0VLPeQZ544gluuOEGrrrqKr7//ntmz57N1VdfzerVq7n99tv5/vvvWbZsGWvXriUhIaHFQWkKCgoAiIhQG/olJSWRnp5eZysGi8XC5MmT2bx5c717cVVUVNTZ9d7rRt5OqnuymntOgTOw72w+VTa7lHS3Y9r6tD4RfVzT6PZ8cYMhab2sU6vNTevTAHyMauPb3Zm72Zu5lx6hPVz+mkIfiqKwt3ojdlOvKZD5I5xaC5Of1DUuobr++utdct5mJWopKSk8+uijdOvWjcsuu4y+ffvywAMPsHTpUsfeWPPmzWPhwoX85z//aVVgiqIwf/58JkyYwMCB6p526enpAMTExNQ5NiYmpsFmcosXL+bZZ59tVSxtlrUCkjcCEDn4SoK3pFFUYeVYRhEDOkpz0vZKS9RcPu2pia2uapQRtRou3JGgPkOjh7I7cze7M3czq/cst7ymcL/U/DKyiysxGw3EDL0KNv8BzmyDiiKwBOsdntd75plnXHLeZg2rdOvWjW3btjm+/s1vfoOiKI5eIaBufrppU+uHYh9++GH27dvHJ598csFj529A29iGxAsWLKCgoMBxOXTIi9bRnNkOVaUQGI0xdiCDu6jJWeKZfH3jEi6lLSofGj3UPS/Ysfp10veBrco9r+nJFAXOVa8bcmFrjtpGxKjTYLszZL1Se7b3jDrL1C8uBEt0Twjvrq4PTdqoc2RCk5+fz7/+9a86a9V2795NamrLe941K1F76qmnuPfee3n22WfZsWMHRqORzZs3069fP8cxpaWldRb/t8QjjzzCt99+y9q1a+ncubPj/tjYWKBmZE2TmZl5wSibxmKxEBIS4rho2zt4hZM/q9c9LwWjkaFdwgBtjYNoj0qqSjiWdwyAYR3cNKIW0VPtvm8tlw3aAXJOQlmeWkgQ4+I1gtWGRg/FgIGUohSyy7Ld8prC/bRpzyHVH7rpOVW9PvmTPgGJOvbt20dCQgJ/+ctfeOWVV8jPzwdgxYoVLFiwoMXnbVaiduedd/LBBx/w448/MnbsWIKDg7n//vuZO3cuS5cuZdWqVTz88MN1RtiaQ1EUHn74Yb766it+/vlnunev26ize/fuxMbGsmbNGsd9lZWVrF+/nnHjxrXoNdu1Y6vV657TABjSOQyo+VQm2p+9WXuxK3Y6BnYkJrD+Dy9OZzRC5+o9ZM/udM9rerKzO9TruKFg9nXLS4b4htA7XK0u3ZWxyy2vKdxPmw0ZXP1eTi/1vZ3jP6gjuUJX8+fPZ86cORw/fhw/Pz/H/TNmzGDDhg0tPm+zV5TPmjWLjRs3kp+fz9q1a/ntb3+Lr68vH330EbNnz2bz5s0cPHiQX/3qVzz77LOsWLGiyed+6KGH+PDDD/n4448JDg4mPT2d9PR0ysrKAHXKc968ebzwwgusWLGCAwcOMGfOHAICArj11lub+620b3nJamsOgwl6Xw7gGFE7lllEcYVVv9iEyzj6p8W4aTRN01ndf9CRpHgz7WfQxb376sr0Z/tmtdnZf1b9kK29l9Njijpym58CGdJPVG87duyot6ixU6dOF8wENkeL68aDgoIYP34848fXbMRss9k4cuQIiYmJJCYmsmnTJt58801mzWra4tZly5YBMGXKlDr3L1++nDlz5gDq9GtZWRlz584lLy+PMWPG8MMPP3jXlGZTHP1evY4fp26eDUSH+NEx1I9zBeXsP1vA2J6ROgYoXEEbTXHbtKfGMaImiRpnt6vXnd2bqA2PGc4nRz5x9NAT7cuJrGLKqmwE+pro2SFIvdM3EHpcCse+V9/zYwfqG6SX8/Pzo7Cw8IL7jx49SocOHVp8Xqc2+DGZTAwYMIABAwZw2223Nfv5ShOGbg0GA4sWLWLRokUtiNCLHPlOve4zo87dQ7qEca4gnb1n8yVRa2cqbZXszVL7d42KdW+SQKcRgEFt9FqcCUHR7n19T1FRBBnVBUtuTtRGRKsjakdzj1JUWUSwr3x4bU8Sq3tgDuocislYq3iuz4zqRO07adOhs+uuu47nnnuOzz//HFDzlZSUFJ5++ml+9atftfi80kyrPSrOhNO/qLf7XFXnoSFSUNBuHcg+QIWtggi/CNduxF4f/zC1uSvA6c3ufW1PcmYbKDYIi4eQjm596Q4BHegS3AUFxTEFLtoPrVn5sK7hdR/oMwMMRji3B3KT3B+YcHjllVfIysoiOjqasrIyJk+eTK9evQgODubPf/5zi88riVp7dPBrUOzqKEdE3T/Y2toGadHR/uzMUBfyj4gZ0WC7GpeKr14GoX1I8EbJ1d97/PjGj3OR4dFq93OZ/mx/tPdsx/o0TVA0dJuo3j7wpVtjEnWFhISwadMmvvzyS1588UUefvhhVq5cyfr16wkMDGzxeV27t4nQh/afdeANFzw0qFMoRgOkFZSTUVhOTIjfBceItmlnupqojYwZqU8A8eNg+1s1yYo30kYTu+mTqI2IGcE3J7+Rys92prjCyrFMdVedYecnagCDblB3BznwFUx6wr3BiQtMnTqVqVOnOu18MqLW3uQmwZmtgAEGXH/Bw4EWMwkx6toVmf5sP6rsVY5Gt25fn6bRRpEyD0KpczclbhMqSyG1OkGK16ddkFb5uT97P2XWMl1iEM6372w+igKdwvyJru/Ddb9rwOij/t+TXoa6+umnn7j66qvp2bMnvXr14uqrr+bHH39s1TklUWtvdn+gXve8tME1Mlo/NZn+bD8OZh+kzFpGmCWMnmE99QkiqANE9VFvJ3thp/Qz28BeBcEd1Y7xOugS3IWYgBisdqusU2tHtPVpF0x7avzDoW/1euRd77slJnGhN954gyuvvJLg4GB+97vf8eijjxISEsJVV13FG2+80eLzSqLWntiqIPEj9faIOQ0e5igoqO5yLdq+2uvTjAYd/1v3vFS91nbF8CZad/iel4IeawRRq8xGx6o97banb9clBuF82ofqYV3DGj5o+J3q9b7P1dFd4XaLFy/mtdde45NPPuHRRx/l0Ucf5eOPP+a1117jhRdeaPF5JVFrTw7/F4ozILADJMxo8DDtU9m+MwXY7dLNuj3QEjXd1qdptC1tTvzsfZ3ST65Vr3s6b21KS2hT35KotQ+KojRcSFBbj0shrCtUFMCBL9wSm6irsLCQK6+88oL7p0+fXm9/taaSRK29UBTY/Ff19oi7Gt26JiEmCD8fI0UVVk5lF7spQOEqtae5RsbqnKh1m6CulSlIUfe89BZF6ZBxADCofzB1NCZuDKBOh5dUtW7fZaG/1PwysooqMBsNDOwU2vCBRiOMuk+9vflvYLe7J0DhcO2119a7G9M333zDNddc0+LzStVne5G8Se2jY/aDMRduYVGb2WRkUKdQdiTnkXimgF7R0hizLTuYo/5BDrWE0just77B+AZC10vUNWonfoSoXvrG4y7aVG/HoRCobyPpjkEd6RTUidTiVHZn7GZi54m6xiNaRxtN6xcXgp+PqfGDR8yBDS9D9jE4tqpm3Zpwi379+vHnP/+ZdevWOfY837p1K7/88guPP/44f/3rXx3HPvroo00+ryRq7YGiwM/Pq7eH/QYCoy76lKFdwqoTtTxuGNHZxQEKV9p6bisAo2NHYzJe5I3cHRKuUBO1oyvhkgf0jsY9tJ1Aek/XN45qo2NHs+LECnak75BErY1LvFghQW1+ITDybvhlKax9ARKuVEfahFu88847hIeHc+jQIQ4dOuS4PywsjHfeecfxtcFgkETN6xz5Tm3JYfaHiU3roTO0SziQ5KgmEm3XtvRtAFwSd4nOkVTrcxX88Ad1lLcsT61Ia88qS+FEdSFB36v1jaXaqNhRrDixwvFvQ7Rde5pSSFDb+N/BzuWQsR/2fQZDb3FZbKKupCTX7AwhqXZbV1EMqxeot8fOhZC4Jj1teHwYAEfSiyipsLooOOFqZdYyx/o0bW2S7iJ7QnR/dSulY6v1jsb1Tq0FaxmEdoXYQXpHA+Co/DySe4TCypYvYhb6qrLZOZBaADRxRA0gIAImzFNv//iMd/Y09BA2m43ExETy8vJadR5J1Nq6H5+B/BT1j8SEx5r8tLhQfzqG+mGzK9Kmow3bk7GHKnsVcYFxdA3uqnc4NfrOVK8PfatvHO5w+L/qdd+ZurXlOF9MYAzdQrphV+yOHStE23MkrYgKq51Qfx+6RzVjC6JL5kJkb7ULwKqnva8CWyfz5s1zTHHabDYmTZrE8OHD6dKlC+vWrWvxeSVRa8v2fAQ7/qXevvZ1sDSvKGBYvDolJdOfbdfWdHV92pi4Mfrs79mQAbPU6xNr2vcn+srSmkStnp1A9KSNsG45t0XnSERL7TmjjsQM7RLWvP/fPn5w/ZuAQZ3+3P62awIUdXzxxRcMGTIEgP/+978kJydz5MgR5s2bx8KFC1t8XknU2qrET+C/1YsRJz3Zot5NI7qqidqu060blhX60QoJPGbaUxMzAGIGgq0SDn2jdzSuc3QlVBZDWDx08azfwbiO6jZWW9IkUWurmlVIcL4uo+Hy59Tbq56G7f90WlyiftnZ2cTGxgKwcuVKbrzxRhISErjnnnvYv7/lW3tJotZWWCuh4Cwc/xE+ux2+fgDsVhhyC0z5fYtOObx6RG13Sh6KDI23OQUVBRzJPQJ4UCFBbYNvUq/3faZvHK6091P1evDNHjPtqRkVOwqTwcTpwtOkFqfqHY5oAa2QYGhTCwnON+4RtbeaYoeVT8BHN8HRVepyGWuF0+IUqpiYGA4dOoTNZmPVqlVcdtllAJSWlmIytbwiX6o+9VRVDqU5UJarXpfmQHGm2jyzOKPuddl500cGI0yYD5cubHH5df+4ECxmI/mlVZzKLqFnhyAnfFPCXbanb0dBoVdYL6L8L96Sxe0G3Qg/LoKULZB5GKL76R2Rc+WdVnvFgZqoeZhg32AGdxjMnsw9bDm3hRsSbtA7JNEMOcUVJGWrDYuHd2lh5bTBAFe9rBaZrX0Bjq9WLxq/MAiOhaAY9RJcfR0UC0HREBCpFif4R6jTqaJRd911FzfddBNxcXEYDAYuv/xyALZt20bfvn1bfF5J1FrKZgVrOVSVQUUhVBSddznvvvL86mQst/qSA83tGm70gdDOavf3Sx5Up5dawddsZHBntfHt7tN5kqi1Mb+k/gJ46GgaQEhHdYH94f+q0y5XL9E7Iufa+Q6gqDsReGhj37Edx7Incw+bz22WRK2N0ZakJMQEERrg0/ITGQww8XHody1s+bva4zA/RV2WUJ6vXrKOXPw8PgFqwhYQXn1dncD5h4MlCHyDwBJS63awetFu+/iDJ/R5dKFFixYxcOBAzpw5w4033ojFYgHAZDLx9NNPt/i83puo/fd3EO6nDgnbbWorAe1aUdTbtgp11Mta+1KhJmeKzTlxGM3V/+irP7kERdd8mtE+6QTHqvcFRDh9emV4fLiaqKXkc+PILk49t3AdRVHYlLoJgAmdJugcTSNG368mans/hWl/bD891SpLYPe/1duj79M3lkaM6ziONxPfZFvaNmx2m2c0RBZNoiVqI+Kd9H8mqjdcs1S9rShqglaUAcXpdWdyHLM5mdWzPbnq37uqUvVSeLblMRh91N1zzL7V1xb12uRbc7/RrM4YGUzqtdGk/t0zmCC3zBk/CZe64YYLPxDdeeedrTqn9yZqx3+AECct0av96cESUv9tvxAIiKpJyAKqkzNLiK5rW4ZXFxTsloKCNuVE/gkySjOwmCyMiBmhdzgN6zZRLSrIOABbl8GlLVtP6XF2vKP+EQvvpnZ/91ADIgcQ7BNMYWUhh3IOMaiDZ/R5ExdXk6hFOP/kBoP6ock/HKIvMiWnKOoMUWludeKWV5PAleVCWb5aUFNRqPb1rCiq/lq7XaQOiADYq6CyCipbGHeh5+1f+te//pX7778fPz+/OltE1ac5uxHU5r2J2qV/hNjI6my9duZuUtd8GYy1Mn7/mszfx6/6/lqXNrxFh5aoHcssorC8ihC/VgyxC7fRpj1HxY7Cz+zBa0cMBpj8FHx+h5qojXlA/ZDSllWWwC+vq7cnPenR0zlmo5kxcWP4MeVHNp/bLIlaG1FhtbGvutHtSGeNqLWUwQB+oeqF7s1/vqJUj8ZVz0rZKtSZKW2Gylrra1tlrZktbbbLXjPTlZ4Nr3nWh73XXnuN2267DT8/P1577bUGj2vutlG1eW+iNuxW6Cx7XHYIttA1IoCU3FISU/KZlNBB75BEE7SJaU9N32tqRtXWvgAzX9E7otbZ8DKUZkN4dxj8a72juaixHcc6ErXfDvmt3uGIJjiQWkCl1U5koC/xkQF6h9M6BgP4BqqX1jp7FvCsRK32tlGyhZRwmRG12nQIz1daVcquzF1AG0nUjEa44gX19o5/wdk23Ck/4xBs/pt6+4oXwOT5n3W1fyOJWYkUVBToHI1oitrr0zyqkbXQhee/ywiXG941jBV7UqXxbRuxLW0bVruVLsFdiA+J1zucpukxWW1hse8z+OIuuH9925sCLS9Up3DtVnXj+b5X6R1Rk3QM6kivsF6cyD/BlnNbuLK7566pE6qdyU4uJBAuM3/+/CYfu2RJyyrfJVETjsa3iSn52O0KRqN8gvNk2rTn+I7jdY6kmWb8Bc5sg7xk+PgmuPXztpOsVRTBZ7dBznEI7gjXvK53RM0ysdNETuSfYGPqRknUPJyiKI4PzSO7SaLm6fbs2VPn6127dmGz2ejTpw8Ax44dw2QyMWJEy4u+JFET9IkJJsDXRFGFleOZxfSJbd6eocJ9FEXhl3NqIcHEzhN1jqaZ/MPh5o/gvavg7A54e4paBdp1bE2fJbOf/h3+FaV6cXOZWrl2djusXawmaT6BcPO/1fY5bcjEzhNZfnA5m1I3YVfsGA2y6sVTnc4pJaekEl+TkYGdQvUOR1zE2rVrHbeXLFlCcHAw77//PuHhapKdl5fHXXfdxcSJLX+/lkRNYDYZGdoljM0nc9h5OlcSNQ+WVJhEanEqPkYfRsaM1Duc5osdCHetgo9ugPzTsKKexe1aNbWWuGnXZr/qyuzaFdq1K7Wrv8ZQqy9iPX0Stfut5dWVaGXnXZcD9WypFtgBbv0MOnlwO5QGDI0eSpBPELnluRzMPijVnx5sZ/Vo2qDOoVjMnltRLC706quv8sMPPziSNIDw8HCef/55pk+fzuOPP96i80qiJgAY2S2CzSdz2JGUy21j2si6Jy+kteUYGTOSAJ82Wg0W0x8e2g5b3lCb4WYdUdd9abTm0uX5uoXoYDBBVAL0mQHjfwf+YXpH1CI+Rh/GdhzLmtNr2Ji6URI1D7brtLpdoO5tOUSzFRYWkpGRwYABdXcNyszMpKioqMXnlURNADC6m7pWaEeyFBR4Msf6tE5tbH3a+SxBMOVp9QJgq1J3/NC2ZTv/Wrtde4TsgtGy6q9Rao221Tf6Zqrpk+jjp/ZJrH3tE1AzkmdqP30FJ3aaqCZqZzcyd+hcvcMRDXD6jgSCN998k5dffpm0tDQGDBjA0qVLG5yK/Oqrr1i2bBmJiYlUVFQwYMAAFi1axBVXXHHR15k1axZ33XUXr776Kpdcom7tt3XrVp588klmz57d4vglURMADOsahsloIDW/jNT8MjqF+esdkjhPaVUpO9PV1hYTO7Wx9WkXY/KpTopC9I6k3dLadBzIOUB2WTZR/lE6RyTOV1BaxbGMYqCmyEu0zmeffca8efN48803GT9+PG+99RYzZszg0KFDdO3a9YLjN2zYwOWXX84LL7xAWFgYy5cv55prrmHbtm0MGzas0df6xz/+wRNPPMFvfvMbqqqqADCbzdxzzz28/PLLLf4eZEWpACDQYnYsXN2RlKtzNKI+29K2UWmvpFNQJ7qHtqBDuPBqHQI60C+iH1AzhS48i9bLsntUIFFBFp2jaR+WLFnCPffcw7333ku/fv1YunQpXbp0YdmyZfUev3TpUp566ilGjRpF7969eeGFF+jduzf//e9/L/paAQEBvPnmm+Tk5LBnzx52795Nbm4ub775JoGBLW/461GJ2oYNG7jmmmvo2LEjBoOBr7/+us7jc+bMwWAw1Llow4ui9UZXl4Jvk0TNI21I3QDApM6TpAmmaJFJnScBsDF1o86RiPrsrF6fpm3tJ1qnsrKSXbt2MX369Dr3T58+nc2bNzfpHHa7naKiIiIimt5KKDAwkMGDBzNkyJBWJWgaj0rUSkpKGDJkCG+88UaDx1x55ZWkpaU5LitXrnRjhO3bKMc6NUnUPI2iKGw4W5OoCdESWkuXzambsdYu4BAeYdsp9b13TPc20l9QJ0VFRRQWFjouFRUV9R6XnZ2NzWYjJiamzv0xMTGkp6c36bVeffVVSkpKuOmmm1odd0t51Bq1GTNmMGPGjEaPsVgsxMbGuiki76Ilaicyi8ktqSQi0FfniITmaN5RMksz8Tf7Myp2lN7hiDZqYORAwixh5FfkszdrLyNi2l6rkfaqvMrG3rP5AIzpIYlaY/r371/n62eeeYZFixY1ePz5MxCKojRpVuKTTz5h0aJFfPPNN0RH69c70aNG1Jpi3bp1REdHk5CQwH333UdmZmajx1dUVNTJvFtTItvehQf60js6CJBRNU+jjaaNiR2DxSRrV0TLmIwmR8Ww9m9KeIY9KflU2RRiQix0jWijrXfc5NChQxQUFDguCxYsqPe4qKgoTCbTBaNnmZmZF4yyne+zzz7jnnvu4fPPP+eyyy5zWuwt0aYStRkzZvDRRx/x888/8+qrr7Jjxw6mTp3a4LAnwOLFiwkNDXVczs/ERV2jqofcpaDAs2h/VNvcbgTC40zqJOvUPNH26vfc0d0jZQ3qRQQHBxMSEuK4WCz1f3j19fVlxIgRrFmzps79a9asYdy4cQ2e/5NPPmHOnDl8/PHHzJw506mxt0SbStRuvvlmZs6cycCBA7nmmmv4/vvvOXbsGN99912Dz1mwYEGdzPvQoUNujLjtGS3r1DxOXnke+7L2AbI+TbTeuI7jMBqMHM87TnpJ09bpCNfblpQDyPo0Z5s/fz7/+te/ePfddzl8+DCPPfYYKSkpPPDAA4CaI9xxxx2O4z/55BPuuOMORy+09PR00tPTKSgo0OtbaFuJ2vni4uKIj4/n+PHjDR5jsVjqZN7BwbI9UmO0EbUD5wopqZDFxp5gU+omFBQSwhOIDZT1maJ1wvzCGBw1GJBRNU9RabU7WnNIouZcN998M0uXLuW5555j6NChbNiwgZUrVxIfr+7Ak5aWRkpKiuP4t956C6vVykMPPURcXJzj8rvf/U6vb8GzigmaKycnhzNnzhAXF6d3KO1GpzB/OoX5k5pfxp6UfCb0lqaYett4Vv1jKqNpwlkmdp5IYlYiG85u4MaEG/UOx+vtTy2gvMpORKAvvarXCQvnmTt3LnPn1r8bx3vvvVfn63Xr1rk+oGbyqBG14uJiEhMTSUxMBCApKYnExERSUlIoLi7miSeeYMuWLSQnJ7Nu3TquueYaoqKimDVrlr6BtzOjqvupbZfpT91Z7VY2nVO3jZJETTiLtrPFtrRtVNoqdY5GaNOeo7tFyPo0cQGPStR27tzJsGHDHNs0zJ8/n2HDhvGnP/0Jk8nE/v37ue6660hISODOO+8kISGBLVu2yHSmk0lBgefYm7WXosoiQi2hjukqIVqrb0RfOvh3oMxaxs6MnXqH4/VqCglk2lNcyKOmPqdMmYKiKA0+vnr1ajdG4720goLdKXlUWG1YzCadI/JeWrXn+I7jMRnl9yCcw2AwMLHzRL46/hUbz25kXMeGK+CEa9nsCjuT1fVpkqiJ+njUiJrwDL2ig4gK8qXCaicxJV/vcLya7EYgXEWb/tyUuknnSLzboXOFFFdYCfYz0y8uRO9whAeSRE1cwGAwMKZHJABbTuXoHI33SitO40T+CYwGIxM6TdA7HNHOXBJ3CWajmeTCZJILkvUOx2tp69NGdYvAZJT1aeJCkqiJeo3VErWTkqjpRRtNG9JhCKGWUJ2jEe1NkG8QI2NGArD+7Hqdo/Fesj5NXIwkaqJeY3uqidqelHzKq2w6R+OdNqTKtKdwrSldpgCw9sxafQPxUna74qiul/5poiGSqIl69YgKJDrYQqXNzu7TeXqH43XKreVsT9sO1KwlEsLZLu1yKQB7MveQX56vbzBe6GhGEfmlVfj7mBjYSUbNRf0kURP1MhgMjlE1WafmftvTt1NuKycmIIaE8AS9wxHtVMegjvQJ74NdscsuBTrYXL20ZHT3CHxM8udY1E/+ZYgGyTo1/fyc8jOgTk1JA0zhSjL9qZ/NJ7IBGN8rUudIhCeTRE00aFxPdfuovWfzKa2UfT/dxWa3Of5oTu0yVedoRHunTX/+kvqL7FLgRlabnW3VhQTae60Q9ZFETTSoS4S672eVraYho3C9/dn7yS3PJcgniFGxo/QOR7Rz/SL7Ee0fTam1lB3pO/QOx2vsSy2guMJKqL8P/aV/mmiEJGqiQQaDgUukn5rb/XxGnfac2HkiPiYfnaMR7Z3RYGRyl8mATH+6kzbtObZHJEbpnyYaIYmaaJSjoEDWqbmFoiiO9WlTu8q0p3CP2uvUGtvGTziPVkgg69PExUiiJhqlJWr7q4fphWslFSRxuvA0ZqOZCR1lNwLhHmPixuBv9iezNJPDuYf1DqfdK6+ysbO67dFYWZ8mLkISNdGoTmH+dI0IwGZX2FG98FW4jjbtOSZuDEG+QTpHI7yFxWRhfMfxAKw7s07XWLzB7tN5VFrtxIRY6NkhUO9whIeTRE1clNamY/PJbJ0jaf/Wpki1p9CHNv2pTb0L1/ml+r10fM8oab8jLkoSNXFR46rXUGw8LomaK2WWZrIvex9Q0zJBCHeZ3HkyJoOJo3lHOVN4Ru9w2jVtfZq2tESIxkiiJi5qQi91DcWR9CIyi8p1jqb90qacBkcNpkNAB11jEd4nzC/M0Q5mTcoanaNpv4rKq9h3tgCAcb1kfZq4OEnUxEVFBlkY0FHt8/PLCRlVcxVtyunSrjKaJvRxefzlAPx4+kedI2m/tiflYrMrdIsMoFOYv97hiDZAEjXRJBN7qyM8Mv3pGoWVhWxL3wbI+jShn6ldp2LAwP7s/aSXpOsdTrv0ywl12lNG00RTSaImmmRSb/VNZdPxbOmz5ALrzqzDarfSM7QnPcJ66B2O8FJR/lEMix4GyKiaq2w8ngXAOFmfJppIEjXRJCO6hePnYySzqIJjGcV6h9Pu/JD8AwDTu03XORLh7bR/g2tOyzo1Z0vNL+N4ZjFGA0zsJetQRdNIoiaaxGI2Maa7Vv2ZpXM07UtRZRGbz20GYHq8JGpCX9O6TgNgT+YesstkqYMzrTuaCcDwruGEBsj2cKJpJFETTTaxevpT1qk517oz66iyV9EjtAe9wnvpHY7wcrGBsQyOGoyCwk+nf9I7nHZl7RH1Q+6UPjKaJppOEjXRZFpBwbakHMqrbDpH037ItKfwNJfFXwZImw5nqrDaHE3Dp/SJ1jka0ZZIoiaaLCEmiI6hfpRX2WWXAicpqizil3O/AHBF/BU6RyOESkvUdqbvJK88T+do2oedyXmUVtroEFzT7kiIppBETTSZwWDgsv4xAKw5lKFzNO2DTHsKT9QluAv9IvphU2yypZSTrD2irk+bktBBto0SzSKJmmiWy/qpidqPhzOx26VNR2v9cFqmPYVn0v5NrkpepXMk7cO6Y9r6NJn2FM0jiZpolkt6RBJkMZNVVMG+1AK9w2nTiiqL+CVVnfaUak/haa7opk7Fb0/fLtWfrXQmt5QTmcWYjAYm9JZGt6J5JFETzeJrNjK5umJpzSHpXN4a2rRn99Du9AqTaU/hWboEd2Fw1GDsip3Vyav1DqdNW3VAfa8c1S2cUH9pyyGaRxI10WyXa9OfhzJ1jqRtc1R7xk/3yjUrReVVHMso4kRmEcnZJWQVVVBeZdN15wtFUSivspFdXEFydgn7zuZz8FwBBWVVusWkpxndZwDwfdL3OkfStq08kAbAVYPidI5EtEVmvQMQbc+lfaIxGQ0czSgiJaeUrpEBeofU5uSX57MpdRNQ88fQGyiKwvpjWby1/hTbk9XNqc9nMhoIsphrLn5mAnxN+JqM+JrVi492u/q6oTRXASqtdqpsdiqtdiqrr6tsdiqsdsoqbRRXWGsu5Vas9cRkNKhNSu+f1IPL+8d4TWJ9RbcreHnny+zN2svZorN0Du6sd0htTlpBGXtS8jEY4IoBsXqHI9ogSdREs4UG+DC6WwRbTuWw+mA6902SvSmb64fTP2BVrPSL6EfPsJ56h+MWBWVVLFyxn//tS3PcF+rvg8EAVVY7pVU2FAVsdoWCsirdR7ECfU2E+PtQZVPILq5g5+k8dv57F5f1i+GlGwYTEeira3zu0CGgA6NiRrEtfRurkldx76B79Q6pzdGmPUd0DScmxE/naERb5FGJ2oYNG3j55ZfZtWsXaWlprFixguuvv97xuKIoPPvss7z99tvk5eUxZswY/v73vzNgwAD9gvZSVw2KZcupHP6775wkai3w3anvAJjZY6bOkbhHRmE5d767nSPpRZiMBu4c2427xnejS0TNaKzdrlBaZaO4vO4IV3FFFaWVtjojYdrImHZfY7TRNx+TEYu57khcgK+JwOqRu2A/s+N2oK8Zo7Fm1CytoIwPtpzmXxtP8ePhDG5Ytpn37x5dJ/72akb3GWxL38bKpJWSqLXA99WJ2gyZ9hQt5FGJWklJCUOGDOGuu+7iV7/61QWPv/TSSyxZsoT33nuPhIQEnn/+eS6//HKOHj1KcHCwDhF7r6sGxbHov4fYd7aApOwSukcF6h1Sm5FanMruzN0YMHBltyv1Dsfl8koqufWfWzmZVUKHYAtv3z6CYV3DLzjOWGvK09PEhfrz/67syzWDO3LfBzs5lV3CLf/cyldzxxEd3L5HSS6Lv4zntz3P8bzjnMg7If3+miGzqJwdybkAXDlQpj1Fy3hUMcGMGTN4/vnnmT179gWPKYrC0qVLWbhwIbNnz2bgwIG8//77lJaW8vHHH+sQrXeLDLIwvpdaZv5t4jmdo2lbVp5aCcDouNHEBMboHI1rVdns3P/vnZzMKiEu1I8vHxhXb5LWVvTvGMKXD44jPjKAs3ll3P3ejna/nVqoJZQJHScAsDJppc7RtC0/HMxAUWBIlzA6hfnrHY5oozwqUWtMUlIS6enpTJ9e02/KYrEwefJkNm/e3ODzKioqKCwsdFyKiorcEa5XuG5IRwC+3Zuqa6VeW6IoCv879T8AZnZv/9Oef/n+CDuS8wj2M/P+3aPbReFJbKgfH9w9mshAXw6kFvLsfw/qHZLL1a7+lP/rTfdNYioAV8lommiFNpOopaer8/wxMXVHIGJiYhyP1Wfx4sWEhoY6Lv3793dpnN5k+oAYLGYjJ7NKOJRWqHc4bcKR3COcKjiFr9HXsZ9ie7XhWBb/2pQEwCs3DiEhpv0sT4iPDOT1Xw/DYIBPtp9h1YG0iz+pDZvSZQr+Zn/OFp9lX/Y+vcNpE5KzS9iRnIfRANcN7aR3OKINazOJmub8snhFURotlV+wYAEFBQWOy6FDh1wdotcI9vNhal91O5Rv98r0Z1NoRQSTu0wm2Lf9JC7nK66wsuCr/QDcMTa+XbYlmNA7igcnqxW7f/j6AHkllTpH5DoBPgFM6zoNgG9PfKtzNG3DV7vPAjChdwdiQ9v3OkbhWm0mUYuNVd/ozx89y8zMvGCUrTaLxUJISIjjIkUHznWtNv2ZeK7enliihs1uczQOvbrH1TpH41p/++k4qflldIlQF+G3V7+7rDe9o4PILq7klR+O6h2OS13X6zpAnf6ssFXoHI1ns9sVvtytTnveMEJ6z4nWaTOJWvfu3YmNjWXNmjWO+yorK1m/fj3jxo3TMTLvNrVfNOEBPqQVlLPuqOxU0JgdGTvILMskxDeEiZ0m6h2Oy5zJLWX5L8kALLpmAIEeWMXpLBazieevHwjAJ9tTOJbRftfAjo4dTWxgLEVVRaxNWat3OB5ta1IOqfllBPuZmd6/fRcMCdfzqEStuLiYxMREEhMTAbWAIDExkZSUFAwGA/PmzeOFF15gxYoVHDhwgDlz5hAQEMCtt96qb+BezGI2OT4xfrI9RedoPNs3J74B1G7vPqb2u9/fi6uOUGmzM6FXlGNqvD0b0yOSKwbEYFfghZWH9Q7HZYwGI9f2vBaAr09+rW8wHu7LXepo2tWD4/DzMekcjWjrPCpR27lzJ8OGDWPYsGEAzJ8/n2HDhvGnP/0JgKeeeop58+Yxd+5cRo4cSWpqKj/88INMZ+rs16O7AvDzkUzSCsp0jsYzFVYWsua0Oho8q9csnaNxnV2n8/huXxoGAyyc2c9rtlp6ekY/fEwG1h3NYv2xLL3DcZnreqrTn1vObSGzVEbQ61NYXsX31cUlMu0pnMGjErUpU6agKMoFl/feew9QCwkWLVpEWloa5eXlrF+/noEDB+obtKBnhyDGdI/ArsDnO87qHY5HWpW0igpbBb3CejEwqv3+m/3L90cAuGlEF/rFhegcjft0jwrkjrHdAFi88nC7bWHRNaQrw6KHYVfsjjYzoq4vdp6ltNJG7+gghrfhnoHCc3hUoibarlvHqKNqn+1IkaKCeqw4vgJQR9Pa6yjTnpQ8tifn4mMy8NjlCXqH43aPTO1FoK+JI+lF/Hyk/Y42aaNq35z4pt0mpC1ltyt8sCUZgDvHdWu3/9eFe0miJpziigGxhAX4cK6gnJ8OZ+gdjkc5lneMAzkHMBvNXN2z/VZ7aj3Trh3SySvbEYQF+PKbsfEA/H3tiXabxEzvNh0/kx+nCk5xIPuA3uF4lPXHs0jOKSXYz8ysYdI7TTiHJGrCKfx8TPx6lDqq9s+Np3SOxrNoo2mXdrmUCL8InaNxjTO5pXy/X12Xc+/E7jpHo597JnTH12xkd0o+25Jy9Q7HJYJ9g/9/e/cdHlWZ/n/8fWbSK5AeCEnoLfQaBAuCoqIIIoIL2FDERZH154r6XdDdta0VBRsqWGhSRAQElKpUQwkkoRNCICGkkJ6ZzMz5/TEQDQQIyUzOzOR+7XWuNZMpn+HkzNznOU9hQLR1TrXlx5ZrnMaxzLkw2vn+7lEuPdrZ2cyaNYvY2Fi8vLzo1q0bW7ZsueJ9MzIyGD16NK1bt0an0zF58uS6C3oFUqgJm3m4bwzueoVdqXkknMzTOo5DKDeXV/TlGdpiqLZh7GjO1lQsKvRrGVyv+qZdKtTfi/u7WzuQz9xwVOM09nPx8ueqE6soNckAIoDj54rYdPgcimKd5Fk4hoULFzJ58mReeukl9uzZQ79+/Rg8eDBpaVXPUmAwGAgJCeGll16iU6dOdZy2alKoCZsJC/Bi6IWlUj7bfEzjNI5hw6kNnDecJ9Q7lPhI15zvr6CsnIW7TgHWFqX67on+zdHrFLYcyebA6Xyt49hFr4heNPZrTKGxkDWpa7SO4xAuXkm4pXUo0UG+GqcRF7377rs8+uijPPbYY7Rt25b333+fqKgoPv744yrvHxMTwwcffMDYsWMJDAys47RVk0JN2NTj/ZsBsDb5LMfPFWmcRnvLjlove97T4h7cdK55KWThzlMUGUy0DPXjxlYhWsfRXFQjH+7qGAHAlxf67bkanaLjvlb3AfD94e81TqO90+dLWZxgHfE+8ebmGqdxfYWFhRQUFFRsBkPVK2UYjUYSEhIYNGhQpdsHDRrE1q1b6yKqTUihJmyqZZg/A9qEoqrw2eb63VctoyiDrWesHwauetmz3Gzhq9+txchj/WJllNsFF1sWVySeIaugTOM09jG0xVDcFDcSzyVyKNe1l8+6lk82HqPcrBLfPIhu0a7ZD9WRtGvXjsDAwIrt9ddfr/J+2dnZmM3my5aZDAsLu2w5SkcmhZqwuSdvsp5Rfp+QzonsYo3TaOf7w99jUS30DO9J04CmWsexi9UHMjmTX0awnwf3dJZRbhd1bNKA7tENKTerfLP9pNZx7CLYO7hiUEF9blXLzC+ruPT/9ICWGqepH5KTk8nPz6/Ypk6detX7X3oCqaqqU51USqEmbK57TCNubh2C2aLy7rrDWsfRhNFsZMmRJQA80OYBjdPYh6qqzL7QL2dM7xhZKucSF1vVvtuRRlm5WeM09nF/q/sBWHFsBcXl9fOk7JNNxzCaLfSMbUTvZkFax6kX/P39CQgIqNg8PT2rvF9wcDB6vf6y1rOsrKzLWtkcmRRqwi6eu601ACv2nXHZDtVXs+7kOnLLcgn1DuXmqJu1jmMXu1LzSEzPx9NNx996u2aLYW0MbBdG4wbe5BYb+WHPaa3j2EWP8B7EBMRQYiph1YlVWsepc6nZxXy3w9pi+oy0pjkcDw8PunXrxrp16yrdvm7dOuLjnWdwlxRqwi7aRwYypFMkAG+vrX/9VxYeWgjAfa3vc9lBBBdHuQ3r2oQgv6rPaOszN72Oh+JjAPjy9xMuOQGuoih/Dio49L1LvsereX11CuVmlRtbhdC3RbDWcUQVpkyZwuzZs/nyyy9JSUnh2WefJS0tjQkTJgAwdepUxo4dW+kxe/fuZe/evRQVFXHu3Dn27t1LcnKyFvEBKdSEHf1jYCvcdNaFqjccct0ldS51KPcQe7L24Ka4cV/L+7SOYxcnsov55cIKFDIlx5WN7BmFr4eew2eL+P1ojtZx7OKe5vfgofMgJTeFpJwkrePUma3HslmTdBa9TuHlO9tqHUdcwciRI3n//fd59dVX6dy5M5s3b2bVqlVER1vnusvIyLhsTrUuXbrQpUsXEhISmDdvHl26dOGOO+7QIj4ghZqwo5hgX8ZdaFGYtjzJZfvpXGrBoQUADIgeQIiPa05X8eVvJ1BVuKVNKC1C/bSO47ACvNwZ0T0KgC9+c81R0A28GjAoxjr9wfyD8zVOUzfMFpV//5QCwIO9mtIyzF/jROJqJk6cSGpqKgaDgYSEBPr371/xuzlz5rBx48ZK91dV9bItNTW1bkP/hRRqwq6eHdiK8AAv0nJLmOXCM7VfVGAsYOXxlQA80No1BxGcLzHyfYJ1lFt9Xi6quh6Kj0FRYMOhcxxz0bkFLw6YWX1iNdml2Rqnsb+5W1NJySggwMuNybe20jqOcHFSqAm78vN0Y9qQdgB8vOmYy35RXfTj0R8pNZXSokELuoV10zqOXVhHMVpoFxFAHxnldk0xwb4MaGMdYXZxLUhX0ymkEx1DOlJuKa/on+mqTmQX89aagwA8f3sbGvl6aJxIuDop1ITd3d4hnJtah1BuVnl+cSJmi2t2ODZbzBWXPR9o/YBTzdNTXQaTmTlbUwEY318muK2uR26IAWBxQjrnS4zahrGTMe3GALDo0CIM5qpnind2FovK84v3UVZuIb55EA/2ktHOwv6kUBN2pygK/xnaAT9PNxJO5rnsigUbT23kZMFJAjwCGNJ8iNZx7GLZ7tOcKzQQEejFnXGRWsdxGn2aBdEm3J/ScjMLLkyO6mpubXorEb4R5JblVlz+dzVzt6WyKzUPHw89bw7vKCcqok5IoSbqRJOGPvzrwiXQ99YdJiWjQONEtjcnaQ4AI1uPxMfdR9swdmC2qHx6och+9IZYPNzk46O6FEWpGB07d2sq5WaLxolsz03nxug2owH4Jvkbl5uqIzW7mDd/tl7ynHpHW6Iaud4xLhyTfNKKOjOiWxNubRuG0WxhyqJ9GE2u82W1N2sve8/txV3nzqg2o7SOYxdrkjI5kV1MoLc7o3rKJZ/rNaRTJMF+HmTkl/FT4hmt49jFsFbD8Hbz5uj5o2zL2KZ1HJsxW6zdNsrKLfRpFsSD8vcv6pAUaqLOKIrC68PiaOTrQUpGAR/86jrLS11sTRvSfIhLTsmhqiqfbDoGwLj4GHw9XXMSX3vyctfzcF9rq9qsDcewuGBfzQCPAO5tcS9gbVVzFZ9sOsbO1Fx8PPS8dV9HdDq55CnqjhRqok6F+Hvy36EdAPh44zF2peZqnKj2ThacZH3aegDGtht7jXs7p63HckhMz8fL/c/Z9sX1G9MnGn8vN45kFbE2+azWcezib23/hoLCb6d/4/h55++PuvfUed67sGbxK3e3l0ueos5JoSbq3OC4CIZ1bYxFhWfm7yG/pFzrSLXyddLXqKj0b9Kf5g2aax3HLj7eaG1Ne6BHU5mOoBYCvNwZ1ycGgJkbjrpcPy6AqICoivVtvzjwhcZpaqfYYGLygj2YLCp3dozgvm5NtI4k6iEp1IQmXr2nAzFBPpzJL+OFpYlO+4WVW5bL8mPLAXio/UPahrGT/en5/HY0G71OkQlubeDhvjF4u+vZfzqfzUdcc3LY8R3HA7Dy+EpOFTrvKNdXViSRmlNCRKAXrw2Nk1GeQhNSqAlN+Hm68eGorrjrFVYfyGTezrRrP8gBzUuZh8FsoH1Qe7qHddc6jl3MWH8EgLs7RdKkoVz2qa0gP8+KwRgz17vmah0dgjvQN7IvZtXMlwe+1DpOjaxMzGDRH+koCrw3sjOBPu5aRxL1lBRqQjNxTQJ5/rY2ALy6IpnDZws1TnR9CowFzEuZB8AjHR5xybPt/en5rEs+i06Bp25uoXUcl/F4/2a46xV2puay84Tz99OsyuMdHwfgh6M/kFmcqXGa65OaXcw/lyQC8OSNzektK3AIDUmhJjT16A2x9G8VgsFk4anvdlNsMGkdqdq+S/mOwvJCWjRowa3Rt2odxy7e/8Xaifqezo1l8XUbCg/0qujv9OGFFktX0zWsK93DumOymCpGRTuDsnIzE7/bTZHBRI+Yhjw7UNbyFNqSQk1oSqdTeGdEJ0L9PTmSVcTUpfudor9akbGoYvqBJzo+gU5xvUNp36nz/HowC50Ck26R1jRbe/LGFrjpFLYcyWbH8Ryt49jFxVa1xYcXO81i7a+sSCY5o4AgX48L3TNc79gWzkX+AoXmQvw9mflgV9x0Cj/uO8PcC2tJOrL5B+dTaCwkNjCWgdEDtY5jF+9daE0b2qUxzUKkNc3Wmgb5cH+PKADeXnvIKU5QrlfviN50DO6IwWzg6+SvtY5zTcv2pDN/ZxqKAh880IXwQC+tIwkhhZpwDD1iGjH1jrYA/GdlCgkn8zROdGWFxkLmJs8FrC0Gep1e40S2tzstj42HzqHXKTx9S0ut47isSbe0wMNNx67UPDYdPqd1HJtTFKWiVW3BwQXkljluf7yDmQW8uPQAAM8MaMkNLYM1TiSElRRqwmE80jeGOztGYLKoPPXdbs4VGrSOVKW5SXPJN+QTExDD7TG3ax3HLi5O8DmsS2Nign01TuO6IgK9GdM7GoB31h52yVa1/k360y6oHaWmUj5P/FzrOFXKKzYy/us/KC03069lMJPk5EQ4ECnUhMNQFIU3h3ekeYgvmQVlPPltAgaTWetYleSU5lRcwnm669O46VxvKaVtx3LYcsQ6b5p8Ydnfkzc1x8fDOq/amiTnGh1ZHYqi8EyXZwBYeGghGUUZGieqzGS28NS83ZzKLaVpIx8+HNUFvSwRJRyIUxVq06dPR1GUSlt4eLjWsYQN+Xm68dnY7vh7ufHHyTxeXnbAoVoZZu+fTamplPZB7bm1qeuN9LRYVF5fnQLA6J5NaRok86bZW7CfJ49cWAP0nbWHMbvgGqB9IvvQI7wH5ZZyPt73sdZxKvnvqhS2HsvBx0PP52O708BHVt4QjsWpCjWA9u3bk5GRUbHt379f60jCxpqH+PHR6K7oFPg+IZ3ZW05oHQmAjKIMFh5aCFhb01xx3rSf9meQmJ6Pr4eepwdIa1pdGd+/GQEX1gBdujtd6zg2pygKz3S1tqotP7ac4/mOsQbooj9O8dXvqQC8e39nWof7axtIiCo4XaHm5uZGeHh4xRYSEqJ1JGEHN7YK4eU72wHw2uoUNhzM0jgRzNgzg3JLOT3De9Inoo/WcWzOYDLzvzUHAXjixuaE+HtqnKj+CPR2Z+KFCYXfXnuIEqPzzCdYXZ1COnFT1E1YVAvvJ7yvdRy2Hs3mpWXWE/1nBrTk9g5ydUY4Jqcr1I4cOUJkZCSxsbE88MADHD9+9TMzg8FAQUFBxVZY6Fyz39dnD/eNYVTPKFQVJs3fQ9KZfM2y7D+3n5+O/4SCwpTuU1yyNe3b7Wmcyi0lxN9T1vTUwEPxMTRp6M3ZAgOfbXaMFidbe7brs+gVPRtObWBHxg7Nchw+W8gT3yZQbla5My6CZ6T1WDgwpyrUevXqxddff82aNWv4/PPPyczMJD4+npycK08W+frrrxMYGFixtWvXrg4Ti9pQFIVX7u5An2ZBFBlMPPTVLk7lltR5DlVVeXPXmwDc3fxu2ge1r/MM9pZfWl4xQ/6Uga3w8XC9QRKOzstdzwuDrUuqfbrpOGcLyjROZHvNGjRjZOuRALy16y3MlrofLJRVUMbDX+2isMxE9+iGvHN/J3QyeEA4MKcq1AYPHszw4cOJi4vj1ltvZeXKlQDMnTv3io+ZOnUq+fn5FVtycnJdxRU24OGm45Mx3WgT7s+5QgPjvtpJXrGxTjP8nPoz+87tw9vNm6e7Pl2nr11X3lt3mPMl5bQI9WPEhaWNRN27My6Crk0bUFpu5u01h7SOYxdPdnqSAI8ADucdZtnRZXX62sUGE4/M3cXp86XEBvvy+djueLm73jyIwrU4VaF2KV9fX+Li4jhy5Mpr5Xl6ehIQEFCx+ftLZ1FnE+jtzpyHexIZ6MXxc8U8OncXpca6ORMvKS/h3YR3AXi0w6OE+oTWyevWpYOZBXyz/SQA04a0w02WzNGMoii8fJe11X/x7nT2p2t3ud9eGng14MlOTwLw4Z4PyTfUzXs0mMxM+DaBA6cLaOTrwZyHe9DQV0Z4Csfn1J/IBoOBlJQUIiIitI4i7Cw80Iu5j/Qk0Nud3WnneWrebowmi91f95N9n5BZnEljv8aMbT/W7q9X11RVZdryJMwWldvbh9OvpQzO0VrXpg25p3MkqgovLz+AxQWn6xjZZiTNApuRW5bLjN0z7P56JrOFp+fvYcuRbHw89HwxrjvRQTKRs3AOTlWoPffcc2zatIkTJ06wY8cO7rvvPgoKChg3bpzW0UQdaBnmz+xx3fF007H+YBbPLNiDyWy/Yu1w3uGKyW1f7PUi3m7ednstrfyUmMGOE7l4uul4+a62WscRF7x0R1v8PN3Yd+o8C3ad0jqOzbnr3Hm598sAfH/4exLPJdrttSwWlecXJ7Im6Sweeh2fj+1Ol6YN7fZ6QtiaUxVq6enpjBo1itatWzNs2DA8PDzYvn070dHRWkcTdaRHTCM+H9sdD72O1Qcy+cf3++wyQahFtfCf7f/BrJoZ0HQA/Zv0t/lraK3YYOK/K62T2068qQVNGsrkto4iNMCLfwxqBcCbPx8kp8gxl1OrjR7hPbi7+d2oqPx7+78xWWw/JYmqqkxfkcTSPafR6xQ+Gt2Fvi1kDU/hXJyqUFuwYAFnzpzBaDRy+vRplixZIqM466H+rUKY9WBX3HQKy/ee4YUliTa/PLT48GL2ZO3B282bF3q+YNPndhT/W3OIzIIyohp588SNzbSOIy4xpnc07SICyC8t543VB7WOYxdTuk0hwCOAg7kH+Tb5W5s+t6qqvLIima+3nURR4J0RnRjUXuZKE87HqQo1IS66tV0YHzzQpWL1gn8uSbRZy9rpotO888c7AEzqMolwX9f7cE84mcfcbakA/HdonIx8c0Bueh3/HtoBsP6Nbzt25WmInFWQdxD/6P4PwDqwwFYrFlgsKi//cIA5W1NRFHjt3jiGdmlsk+cWoq5JoSac1p0dI3j3/s4VxdrTC/bUeoCBRbUw7fdplJhK6BraldFtRtsoreMwmiy8sCQRVYVhXRvTv5UMIHBU3aIbMrpXUwCeX7KPYoPrrVhwb4t76RvZF6PFyMu/vVzrS6Bmi8oLSxP5bkcaigJvDe/IqJ5NbZRWiLonhZpwakO7NGbm6K646xVWJmYw4dsEysprPnXHokOL2JG5Ay+9F//u+2/0Otdrafp44zGOZBUR5OvB/90pXQcc3dTBbWjcwJtTuaW8+bPrXQJVFIXp8dPxd/dnf/Z+5iTNqfFzGU0W/rFoL4v+SEenwHv3d2ZE9yjbhRVCA1KoCac3OC6Cz8f+ORr04a92UVBWft3PczTvaMUlz8ndJtM0wPXOwpPO5PPRBuu8g9Pubi/zSDkBfy933hgeB8DX206y9Vi2xolsL9w3nOd7Pg/AzL0zScpOuu7nKDKYeHTuLn7Yewa9TmHGqC5yuVO4BCnUhEu4qXUocx/pia+Hnm3Hcxjx8TZOny+t9uNLTaU8t+k5ysxlxEfGM6rNKDum1UaJ0cSk+XsoN6sMbBfGkI4y/6Cz6NcypOLy3fOLE13yEug9ze9hYPRATBYTz216jkJj9ddlziosY+Sn29hyJBtvdz2zx3Xnro6RdkwrRN2RQk24jN7Nglj4RB9C/T05dLaQoTN/r/bM7m/ufJNj+ccI9g7mtRteQ6e43qHxyo/JHD9XTFiAJ28O7+iSC8u7shfvsF4CTc8r5cVl+1FV15oI9+Il0EjfSNKL0nl126vVeo9Hs4oY/vFWks4UEOTrwYLHe3Nza9dbQUTUX673bSTqtQ6NA/nhqb4Va4Pe/+k21iRlXvUxy48uZ8mRJSgovNHvDYK8g+oobd1Zvvc0C/84haLAeyM700gueTodfy933hvZGf2FaWnmbk3VOpLNBXgE8NaNb+GmuPFz6s/MPzj/qvf/NeUs9878nVO5pUQH+bB0YjydohrUTVgh6ogUasLlRDbw5vsJfejfKoTScjNPfJPA22sOVTl9x75z+3hl2yuAdbHoXhG96jqu3e1Jy+P5xdaZ3yfe1Jz45jLhp7PqGduIF++wriDxn5Up7ErN1TiR7XUK6cTkbpMBeGvXW+zI2HHZfVRV5aP1R3js6z8oNJjoEdOQJU/Gy7JQwiVJoSZckr+XO1+M685D8TEAfLThKA99tZPcYmPFfTKLM5m8YTLllnIGNB3AE52e0Cit/aTnlTD+6z8wmCwMaBPKlIGttY4kaumRvjHc1TECk0XliW8SOHauSOtINje23ViGNBuCWTXzj03/4FTBn8toFZaV89S83by99jCqap0Y+LvHehPs56lhYiHsRwo14bLc9Tqm392eDx7ojLe7ni1HsrlrxhYSTuZSaCxk0vpJZJdm07JhS5fsl5ZTZOCRObvILjLSJtyfD0Z1Qa+TfmnOTlEU3hzekbjGgeQWGxn7xU4y8qs/cMYZKIrCtPhpxAXHkW/IZ+KvE8kty2V3Wh53zNjCqv2ZuOsV3hgWx7+HdsDDzbWOXSH+SlFdrUfqNaSnpxMVFcWpU6do0qSJ1nFEHTmUWciT3yZwPLsYna6c2A7zyCpPoZFXI7674zua+LvW30JOkYEHZ+/gYGYhof6eLHuqL40buN6i8vVZTpGBEZ9s43h2MS1C/Zg3vheh/l5ax7KprJIsHlz1IJnFmYS4N+dk0jjMZg+aNPRmxqgudJXF1euV+vr9Lachol5oHe7P8r/3ZWiXMDwjrUWaonoxtcu7LlekZRWWVSrS5j/eW4o0FxTk58nXj/YkPMCLo1lFjPhkG2k5JVrHsqlQn1Be6voeetWPc+XH8Gg8lzs7BrPqmX5SpIl6Qwo1V6KqYK75rPyuzt3NTHnwV7j5p4DFjeKT43h6bhbvrD1EqdE1/t2SzxQw9KPfKxVpzUP8tA1lcr05vypo/N6aNPRhweO9iWrkzcmcEoZ/spUDp6s3JY2jM5osfPDLER7/4hQFqQ+hWjxx8z1GWdBnuOmvf0LresNstn4XCJchhZqrUFVYuxbmzoWyMq3TOJyS8hKe+vUpNqdvxlPvyRv93uWm6F4YzRY+XH+Uge9t4pfks1rHrJVV+zO475OtnMkvo1mwL4ue6KN9kXbsGMyYAWlp2uawh4wM+PBDOKjtsk4xwb4smRBfMSXN8I+3snBXmlPPs7btWA53ztjCe78cxmi20D+6C2/d8AE+bj7szNzJ+HXjyTe4RkFqU0YjfPcd/PQTWGq37rFwHNJHzRVYLNYDc88e689hYTBmDPjKUHWAjKIMntnwDCm5Kfi6+/LRLR/RPbw7qqqyJimTV1ckcybfWtze1DqE/3dba9pHBmqcuvoKysp55cdkluxOB+CGFsHMHN2VQB93bYOlpMCSJdYzfHd3GDkSmjfXNpOtnDwJ8+eDwQCKAkOHQseOmkbKLy1n8oI9bDh0DoB7uzRm2pB2NPBxnjnzDmUW8ubPB1l/MAuAYD8Ppg1pz10dI1AUhf3n9jPhlwkUGAtoHticGbfMcMml3mqktBTmzYN06+cA7dvDvfeC3nXWK3bJ7+9qkELN2ZnNsHQpJCdXvj0oyFqsBTpPwWEPu8/u5tmNz5JblktDz4bMHDCTuJC4SvcpMZqY8etRZm85junCXGt3xkXw7MCWtAj11yJ2tVgsKisSz/Dm6oOcyS9DUeCJ/s35x6BWuOs1bizfuxd+/LHyJRi9HoYPh7ZtNYtlE0ePwsKFl1/2vOMO6NFDm0wXWCwqH286xjtrD2FRoZGvBy/d0ZZhXRs79EoUJ3OKmbnhKIsT0rGo4KZTGN2rKVMGtrqs0Dycd5gn1z1JVmkW/h7+vN3/beIbx2uU3EEUFcE330BWVuXbW7aEESOsJ0ouwOW+v6tJCjVnVl4OixZZvziqEhAAY8dai7Z6ptxSzuzE2XyW+Bkm1UTrhq2ZccsMIv2uvP7fiexi3lt3mBWJZ1BV0CkwuEMED/eNoVt0Q4f5orNYVDYezuKDX46w78ISWU0b+fDO/Z3oEdNI43TAjh3w889V/05R4O67oXPnOo1kM0lJ1hOjK11WuuUW6NevbjNVIeFkLi8uPcChs9b1MttGBDDplhbc3j4cnQNN0ZKYfp5PNx9n9f4MLs5HPbhDOM/f3obY4CtfEcgqyeLZDc+SmJ2ITtHxUPuHeKrzU3jonaf10GbOn7cWablXmPw4OhpGjQJP559nzqW+v6+DFGrOqqzMeunlWn1/fH3hb3+D8PC6yeUAknOSmb51Oim5KQAMjhnM9Pjp+Lj7VOvxBzMLeHftYdb+pc9aXONAxsXHMLhDOL6ebnbJfS3nS4wsTkjnm+0nOXlhdJ+vh54JNzbn0X6x+Hhok6uCqsKWLbBhw7Xve/vt0MvJVoHYvdvaxeBaH5l9+8KAAdaiVEPlZguzt5zgo/VHKL4wWCY22JeRPaIY3rUJIf7afHEXG0z8fCCTRX+cYseJP4uLG1uF8PSAFnSLrt7JhsFs4L/b/8uyo8sAaNGgBdP6TKNzaGd7xHZM2dnWIq2g4Or3i4yEBx8En+p9Bjoql/n+vk5SqDmj4mL49lvIvPoalhW8vGD0aIiKsm8ujaUXpvPhng9ZdWIVAIGegbzU6yVuj7m9Rq1hKRkFzPk9lR/2nsZgsrageLvrGdA2lCGdIrmxVQhe7vbt/1FkMPFL8llW7DvD5iPnKDdbD9cALzdG9oji8f7NNfvCrURVYd062Lat+o+56Sbo31/zgqZatm2zDtaprm7drJdCddqP1zpfYuTL31P56vcTFJZZL9e66RRubBXCbe3DubVdmN3Xfi0rN7PteA4rEzNYtT+DkguFo5tO4e5OkYzv34y2EQE1eu5f037l1W2vkltmLfoGRg9kUpdJxAbG2iy/Q8rIsH4PlFRzSpaQEOtJe0DN/p0dQU2/v2fNmsX//vc/MjIyaN++Pe+//z79rtLyvWnTJqZMmUJSUhKRkZE8//zzTJgwwRZvoUakUHM2BQXWM6js7Ot7nLs7PPAANGtmn1waMVlMbM/YzqJDi9iUvgmLai2o7oi9g+e6P0eIT0itXyO32Mj8nWks+uNURUsWWIu2HrGN6NMsiPjmQbSLDKh137CycjOJ6fn8fjSbrcey2ZN2vqLfHFgvYY3pHc3QLpHat6BddOlgluvRuzcMGuS4xZqqwsaNsHnz9T+2QwfrIAMH6cxdbDDxU+IZ5u88xd5T5ytu1ynQPaYRvWMb0T2mEV2aNsDfq3Z9mgwmM4cyC9l9Mo+Nh8+x7VhOxckOQEyQD/d1a8Lwbk2ICKz9HH95ZXm8l/Aey48tx6JaUFDo27gv97e6nxsa34C73jX6aFVIS7MOHDAYru9xDRpYu8M0dM456Gry/b1w4ULGjBnDrFmz6Nu3L59++imzZ88mOTmZpk0vH4hy4sQJOnTowPjx43niiSf4/fffmThxIvPnz2f48OG2fkvVUm8LtT8O/UF45NUvB1b3n0almv+E1b7bVe644kdIPXldr1txL70eJjwBV1gq6ZrPl5dn/f+GDa//PZeXw9lMaFJ1q151nm/WLDArRkrczlDkdoocr91kee3CpPtzrcOw0ng65D1DQ2O76uW7DqqqkqPmc9x8hhPmDErUytOg6FAIVPxoqPMnUPHDR/HCS/HAW/HAnYtfFNb3aVRNlGKgVLVueZZC8tRCCtXiy/4lAhRfHro5giGdImkZdmFww8GD0KZNzd5IbR5blb17Yfnymj9+5Mir5jnPedawhhIqtxy4487N3ExjGl/16U9wgs1sxkLlfmWBBDKIQfhxlSlMjh+3nhjVlK0v8dpovx85W8jqA5nM+SWTXLXyZTMFCFD8CFR8CdD5Eqj44qV44oEbHoo7buixoGLBghkLRrWcYrWUYrWMYrWUXEsBeWohlkv+kn0UL6J0oTTXNyZUZ58+n/nuRzjQcAYZPhsrbtNbvAkp60FwWVf8TE3xNTVGr3rx9N/16BQdOkWHwnVmSU+3tlDVpN9XQYG1wAqpxUnkxx9ff5F2UePG1gEGTigzI5NurbpdV6HWq1cvunbtyscff1xxW9u2bRk6dCivv/76Zff/5z//yY8//khKSkrFbRMmTGDfvn1su54rBjbkIKfkdW/M+jHovR3jTPe61aYhcPkqm8WokYRaPPYK38ce5gY0LbqLZkUjCCi3X4uhoigEKw0I1jWgh1tbzqtFZFiyyTDnkGnJwYiJPLWQPHNhrV7HG0/C9Y2I0AUTqQvGX+fDlEGX3Gn9ejhzBm6++fpao7Zvt/Yjs2WhVttJX6/y+EQSWcUqDFT9pXSc4/SnP/3oh57Kx7MZM+tZz1a2XvH5j3KUu7iLdlyhsK/tBNK2nhB37VrryL5+/a5vv//+O+zcWbHfW4b50zLMn7zfWlJoKeG05RxZljzOWnIpUkvJV4vIV4ugFlNxeeJOkC6QSF0wTfShNFD87D4gJ7C8JX2zPqTILY3j/os56bccgz6XTJ/NZPpUbhVdu8yuUewrtJaPXzLbJjHqmrnUejwWFhZS8Jd+eZ6ennhWUTQbjUYSEhJ44YUXKt0+aNAgtm6t+nNh27ZtDBpU+QP3tttu44svvqC8vBx3DUbQ1ttCzVPviZv+2m/f1h8s1T1zu+LrlpdXGnFW3XQVr+t5jbUAr/aEFgsYjNYvCA93FF01Cl1VRTEawaKCu9tVh4lf69+mpAQUdPiYIvA1RRFobEVYaTwNjW1QqNuiW1EUGir+NNT5084tFlVVKVZLrYWapYgCtYhS1UCZaqQMI0bVVOnduStueOOJl+KJt+JR0RLXUOePN57V+7vbssV6Vn377df+0lZV6+W7jRudokNxGWWsYhX72X/V+6mobGITRzjCvdxLMMEAZJPNUpaSQcZVH19KKd/zPR3pyGAG44UTrJW5YYN1MNHAgdXb7+vXw2+/XbFvkr/Ohza6aNoQDUCxWsZ5SyH5ahEFlhIK1GIMqhEjJspVE+WY0KFDj7U1yh03fBUvfBVvfBUvGuj8CFIC8VO8NRsp7WdqSse8KcTlTSbf4zBnvbZy3uMgRe7plLidwUI5nl4WzKq5ZhMDW8xgtlj//d30VOuTWFXBbLI2qrvpr3hlo1rKa7Eyg6KAm3N+9ZfrrO+7XbvKJ1bTpk1j+vTpl90/Ozsbs9lMWFhYpdvDwsLIvEIf78zMzCrvbzKZyM7OJiIiohbvoGacc2/ZwIrBK5yzj9rXX0PaiZo//v/+r+YdnE+ehDlzrP9dnQlMLx023r+/tQWohl55pcYPtTtFUfBTfPDDhyh92LUfYCs7d1qLtbvvvvJ+vbhqxfbtVf8atVKRfOnPdS2NNJaylHyqP/P8Gc7wKZ9yK7eiR88a1mCi+q1ZiSSSSipDGUos2nVCr/a+2LbNut/vvPPq+33VKvjjj+vK4Kt44av3ojG179+pNQUdDYxtaGC8vAV52rRaPPHWrdbBM2Cdq3LMmKtPg/TXCZLBOl1Gq1Y1f/3XXqt5sRYZCQ+Nr/lrayg9PZ0ookhOTqZx4z8vsVTVmvZXl54wqKp61ZOIqu5f1e11RfshScI5lZdbO7NeOtHuRdnZ8NVXV57bR9jOvn3w/fdVX2azWKwTz16hSANrH7C/9v86wxl7pKy2zWy+riLtIhMmfr7wv+sp0i4qoID1rL/ux9lSJn+e5Rsxks1VBg3t3m2d062qy7NmMyxbdt1FmqiB/HzrZ93ZKyxBd/SodXRmTfuUicv4+/sTEBBQsV2pUAsODkav11/WepaVlXVZq9lF4eHhVd7fzc2NII3mJJVCTdScxQKLF1s7k/9VZqb1g+tac/sI2zl40HrGbjT+eZvZbF3C6dL9cwkLFlL4s+NsIol2Cimu5a+XelNIoZxrtJokJVlXSfhr64rJZC3c91/9srGwoeJi69WGU6cq356UZD0ubd1XUVSLh4cH3bp1Y93F1s8L1q1bR3x81atZ9OnT57L7r127lu7du2vSPw2kUBO1parWEX8XW2zS0qwfWNWd20fYzsURiqWl1i/uBQuu3OJ5iYsFQg45pJNuz5TiKjLJJAvrMkDVLpiPHLEuxG0wWLd58+DQITumFFUqK7Mef8ePW3/es8d6oiSLo2tqypQpzJ49my+//JKUlBSeffZZ0tLSKuZFmzp1KmPHjq24/4QJEzh58iRTpkwhJSWFL7/8ki+++ILnnntOq7dQf/uoCRtbs8ba9J+UVLuOrqJ20tNh7lzrtAHXWrXiL05ykj/4gzSq/xhhH5vZTCyxHOc4AxhQvQedPGnd7zodnD5t34Diyi52CenYsWbzCgqbGzlyJDk5Obz66qtkZGTQoUMHVq1aRXS0dfBMRkYGaX/5rIyNjWXVqlU8++yzzJw5k8jISGbMmKHZHGoghZqwpWtcYhN15Ep9Za5hJSsBiOTK66EK+0u68L/rlnH1Ea6ijpjNUqQ5mIkTJzJx4sQqfzfn4gC5v7jxxhvZvXu3nVNVn1z6FEIIIYRwUFKoCSGEEEI4KKcs1GbNmkVsbCxeXl5069aNLVu2aB1JCCGEEMLmnK5QW7hwIZMnT+all15iz5499OvXj8GDB1fqDCiEEEII4QqcrlB79913efTRR3nsscdo27Yt77//PlFRUZUWXBVC1E8HFh3gzYg3Sfq+Bp3xhRDCATlVoXZxgdVLF0y92gKrQoj6oSiriJ+e+ImizCJWPL6CoqwirSMJIUStOVWhVpMFVg0GAwUFBRVbYWFhXUQVQtQhVVX5acJPGAqty/QYCg2sfHKlxqmEEKL2nKpQu+h6Flh9/fXXCQwMrNjatWtXFxGFEHUoaVESB5cdRDVbF09WzSopS1M4sOiAxsmEEKJ2nKpQq8kCq1OnTiU/P79iS67mkjpCCOdQlFXETxN+gkvP1RSsl0LlEqgQwok51coEf11g9d577624fd26ddxzzz1VPsbT0xNPT8+Kn8+fPw9Yl41wSu7u0LBhzR+fnm5dZqYmcnNr99rl5dbXr6H8/Jq/tLO77J/N27vm+8LDo9ITFlJIQ/58Li+8rm+9z5KS2v1dFBZWyuOGW6U8V6OqKkvHL6UsvwzUS38JZfllrB23lkc/f7Raz+eBR+X3np9fu/dmMFzX37w77pXeew45WPjLWpG+vjXP4u19WRY5pmqorKx2fxf5+bULEBBQ8zVEvbxq+ea1c/F721Lf1k9VncyCBQtUd3d39YsvvlCTk5PVyZMnq76+vmpqamq1Hv/bb7+pWD/SZZNNNtlkk002J9t27txp50rDsThVixpce4HVa2nbti0ABw4cIDAw0J5RRQ0VFhbSrl07kpOT8ff31zqOqILsI8cn+8jxyT66PhaLhbNnz9KlSxeto9QpRVVVVesQdamgoIDAwEDy8/MJCAjQOo6oguwjxyf7yPHJPnJ8so9EdTjVYAIhhBBCiPpECjUhhBBCCAdV7wo1T09Ppk2bVmkkqHAsso8cn+wjxyf7yPHJPhLVUe/6qAkhhBBCOIt616ImhBBCCOEspFATQgghhHBQUqgJIYQQQjgoKdSEEEIIIRxUvSrUZs2aRWxsLF5eXnTr1o0tW7ZoHUn8xfTp01EUpdIWHh6udax6bfPmzQwZMoTIyEgUReGHH36o9HtVVZk+fTqRkZF4e3tz0003kZSUpE3Yeupa++ihhx667Ljq3bu3NmHroddff50ePXrg7+9PaGgoQ4cO5dChQ5XuI8eRuJp6U6gtXLiQyZMn89JLL7Fnzx769evH4MGDSUtL0zqa+Iv27duTkZFRse3fv1/rSPVacXExnTp14qOPPqry92+99RbvvvsuH330Ebt27SI8PJyBAwdSWFhYx0nrr2vtI4Dbb7+90nG1atWqOkxYv23atImnnnqK7du3s27dOkwmE4MGDaK4uLjiPnIciavScqHRutSzZ091woQJlW5r06aN+sILL2iUSFxq2rRpaqdOnbSOIa4AUJctW1bxs8ViUcPDw9U33nij4raysjI1MDBQ/eSTTzRIKC7dR6qqquPGjVPvueceTfKIy2VlZamAumnTJlVV5TgS11YvWtSMRiMJCQkMGjSo0u2DBg1i69atGqUSVTly5AiRkZHExsbywAMPcPz4ca0jiSs4ceIEmZmZlY4rT09PbrzxRjmuHMzGjRsJDQ2lVatWjB8/nqysLK0j1Vv5+fkANGrUCJDjSFxbvSjUsrOzMZvNhIWFVbo9LCyMzMxMjVKJS/Xq1Yuvv/6aNWvW8Pnnn5OZmUl8fDw5OTlaRxNVuHjsyHHl2AYPHsx3333H+vXreeedd9i1axe33HILBoNB62j1jqqqTJkyhRtuuIEOHToAchyJa3PTOkBdUhSl0s+qql52m9DO4MGDK/47Li6OPn360Lx5c+bOncuUKVM0TCauRo4rxzZy5MiK/+7QoQPdu3cnOjqalStXMmzYMA2T1T9///vfSUxM5Lfffrvsd3IciSupFy1qwcHB6PX6y85OsrKyLjuLEY7D19eXuLg4jhw5onUUUYWLI3LluHIuERERREdHy3FVxyZNmsSPP/7Ihg0baNKkScXtchyJa6kXhZqHhwfdunVj3bp1lW5ft24d8fHxGqUS12IwGEhJSSEiIkLrKKIKsbGxhIeHVzqujEYjmzZtkuPKgeXk5HDq1Ck5ruqIqqr8/e9/Z+nSpaxfv57Y2NhKv5fjSFxLvbn0OWXKFMaMGUP37t3p06cPn332GWlpaUyYMEHraOKC5557jiFDhtC0aVOysrL4z3/+Q0FBAePGjdM6Wr1VVFTE0aNHK34+ceIEe/fupVGjRjRt2pTJkyfz2muv0bJlS1q2bMlrr72Gj48Po0eP1jB1/XK1fdSoUSOmT5/O8OHDiYiIIDU1lRdffJHg4GDuvfdeDVPXH0899RTz5s1j+fLl+Pv7V7ScBQYG4u3tjaIochyJq9N0zGkdmzlzphodHa16eHioXbt2rRgeLRzDyJEj1YiICNXd3V2NjIxUhw0bpiYlJWkdq17bsGGDCly2jRs3TlVV69QC06ZNU8PDw1VPT0+1f//+6v79+7UNXc9cbR+VlJSogwYNUkNCQlR3d3e1adOm6rhx49S0tDStY9cbVe0bQP3qq68q7iPHkbgaRVVVte7LQyGEEEIIcS31oo+aEEIIIYQzkkJNCCGEEMJBSaEmhBBCCOGgpFATQgghhHBQUqgJIYQQQjgoKdSEEEIIIRyUFGpCCCGEEA5KCjUhhFPauHEjiqKgKApDhw6t1XOlpqZWPFfnzp1tkk8IIWyh3iwhJYRwTYcOHSI0NLRWzxEVFUVGRgZvv/02v/zyi42SCSFE7UmLmhDCqYWGhtKgQYNaPYderyc8PBw/Pz/bhBJCCBuRQk0I4TAWL15MXFwc3t7eBAUFceutt1JcXHxdz3HTTTcxadIkJk+eTMOGDQkLC+Ozzz6juLiYhx9+GH9/f5o3b87q1avt9C6EEMJ2pFATQjiEjIwMRo0axSOPPEJKSgobN25k2LBh1GQ54rlz5xIcHMzOnTuZNGkSTz75JCNGjCA+Pp7du3dz2223MWbMGEpKSuzwToQQwnakUBNCOISMjAxMJhPDhg0jJiaGuLg4Jk6cWKPLkZ06deLll1+mZcuWTJ06FW9vb4KDgxk/fjwtW7bkX//6Fzk5OSQmJtrhnQghhO1IoSaEcAidOnViwIABxMXFMWLECD7//HPy8vJq9FwdO3as+G+9Xk9QUBBxcXEVt4WFhQGQlZVVu9BCCGFnUqgJIRyCXq9n3bp1rF69mnbt2vHhhx/SunVrTpw4cd3P5e7uXulnRVEq3aYoCgAWi6V2oYUQws6kUBNCOAxFUejbty+vvPIKe/bswcPDg2XLlmkdSwghNCPzqAkhHMKOHTv49ddfGTRoEKGhoezYsYNz587Rtm1braMJIYRmpFATQjiEgIAANm/ezPvvv09BQQHR0dG88847DB48WOtoQgihGSnUhBAOoW3btvz888+1fp6NGzdedltqauplt9Vk2g8hhKhr0kdNCOHUmjRpwqhRo2r1HGlpafj5+fHaa6/ZKJUQQtiGospppRDCCZWWlnL69GkA/Pz8CA8Pr/FzmUymilY3T09PoqKibBFRCCFqTQo1IYQQQggHJZc+hRBCCCEclBRqQgghhBAOSgo1IYQQQggHJYWaEEIIIYSDkkJNCCGEEMJBSaEmhBBCCOGgpFATQgghhHBQUqgJIYQQQjgoKdSEEEIIIRzU/wdYqI/bhAF/bAAAAABJRU5ErkJggg==", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring.plot_beta()\n", + "arc.plot_beta()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications:\n", + "> 1. sbreak\n", + "> 2. slice\n", + "> 3. insert\n", + "> 4. remove\n", + "> 5. append\n", + "> 6. pop\n", + "> 7. repeat\n", + "> 8. reduce \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## sbreak" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msbreak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbreak_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbreak_elems\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Insert elements at selected locations in the lattice\n", + "\n", + "Parameters:\n", + " break_s: location or array of locations of breakpoints\n", + " break_elems: elements to be inserted at breakpoints (array of\n", + " elements as long as break_s or single element\n", + " duplicated as necessary). Default: Marker('sbreak')\n", + "Returns:\n", + " newring: A new lattice with new elements inserted at breakpoints\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring.sbreak?" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Drift('DR_01', 2.25)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring_tmp = ring.deepcopy()\n", + "ring_tmp[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 0.2000000000000003\n", + "\tPassMethod : DriftPass \n", + " Marker:\n", + "\tFamName : hello\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass \n", + " Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 2.05\n", + "\tPassMethod : DriftPass\n" + ] + } + ], + "source": [ + "ring_tmp = ring_tmp.sbreak(0.2, at.Marker('hello'))\n", + "print(ring_tmp[0],'\\n', ring_tmp[1],'\\n', ring_tmp[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QF1\n", + "\tLength : 0.5499999999999998\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [0. 0.38046583]\n", + "\tEnergy : 3000000000.0\n", + "\tK : 0.3804658324164645 \n", + " Marker:\n", + "\tFamName : QuadSplit\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass \n", + " Quadrupole:\n", + "\tFamName : QF1\n", + "\tLength : 0.20000000000000018\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [0. 0.38046583]\n", + "\tEnergy : 3000000000.0\n", + "\tK : 0.3804658324164645\n" + ] + } + ], + "source": [ + "ring_tmp = ring_tmp.sbreak(2.8, at.Marker('QuadSplit'))\n", + "print(ring_tmp[3],'\\n', ring_tmp[4],'\\n', ring_tmp[5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For quadrupoles, there is an flag for the inclusion or exclusion of fringe fields at the entrance and exit of the quadrupoles. When you split the quadrupole, the internal fringe fields are disabled, and the outer fringe fields are kept. Similarly when you split a dipole, the exit and entrance angles are modified to ensure a continuous bend. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## slice / divide / merge" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You slice a lattice, you divide an element" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.75\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579574214106 \n", + "\n", + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.375\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579574214106 \n", + " Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.30000000000000004\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579574214106\n" + ] + } + ], + "source": [ + "quad = ring_tmp[3]\n", + "print(quad, '\\n')\n", + "quad_div = quad.divide([0.5, 0.4])\n", + "print(quad_div[0], '\\n', quad_div[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It may be useful to make nice smooth plots (for example of optics functions in the middle of elements and not just at the edges). For this you can use slice." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mring_tmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mslice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[float]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mslices\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[int]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m'Lattice'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Create a new lattice by slicing the range of interest into small\n", + "elements\n", + "\n", + "Keyword arguments:\n", + " size=None: Length of a slice. Default: computed from the\n", + " range and number of points: ``size = (s_max-s_min)/slices``.\n", + " slices=1: Number of slices in the specified range. Ignored if\n", + " size is specified. Default: no slicing\n", + "\n", + "Returns:\n", + " newring: New Lattice object\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring_tmp.slice?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "new_ring_tmp = ring_tmp.slice(slices=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "700\n", + "2300\n" + ] + } + ], + "source": [ + "msk = at.get_value_refpts(ring_tmp, np.arange(len(ring_tmp)), 'Length') == 0\n", + "print(len(ring_tmp) - np.sum(msk))\n", + "\n", + "msk = at.get_value_refpts(new_ring_tmp, np.arange(len(new_ring_tmp)), 'Length') == 0\n", + "print(len(new_ring_tmp) - np.sum(msk))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zero length elements are of course not touched, but one can also specify a dz too" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also do the opposite of split, which is to merge two identical and adjacent elements" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "q = ring_tmp[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 0.75\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579574214106\n" + ] + } + ], + "source": [ + "print(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "q.merge(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quadrupole:\n", + "\tFamName : QD2\n", + "\tLength : 1.5\n", + "\tPassMethod : StrMPoleSymplectic4RadPass\n", + "\tNumIntSteps : 10\n", + "\tMaxOrder : 1\n", + "\tPolynomA : [0. 0.]\n", + "\tPolynomB : [ 0. -0.2709458]\n", + "\tEnergy : 3000000000.0\n", + "\tK : -0.27094579574214106\n" + ] + } + ], + "source": [ + "print(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 2.25\n", + "\tPassMethod : DriftPass\n" + ] + } + ], + "source": [ + "dr = ring_tmp[0]\n", + "print(dr)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drift:\n", + "\tFamName : DR_01\n", + "\tLength : 4.5\n", + "\tPassMethod : DriftPass\n" + ] + } + ], + "source": [ + "dr.merge(dr)\n", + "print(dr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## insert / append / pop / remove" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lattice objects are fundamentally lists. Which means that all of the standard python operations that can be performed on lists are valid for a lattice object" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp.insert(4, at.Marker('insert_test'))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marker:\n", + "\tFamName : insert_test\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass\n" + ] + } + ], + "source": [ + "print(ring_tmp[4])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Append puts elements automatically at the end. It is equivalent to insert with an index of -1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marker:\n", + "\tFamName : append_test\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass\n" + ] + } + ], + "source": [ + "ring_tmp.append(at.Marker('append_test'))\n", + "print(ring_tmp[-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pop removes and returns the element at the specified index" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "mark = ring_tmp.pop(-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marker:\n", + "\tFamName : append_test\n", + "\tLength : 0.0\n", + "\tPassMethod : IdentityPass\n", + "Corrector:\n", + "\tFamName : Corrector\n", + "\tLength : 0.0\n", + "\tPassMethod : CorrectorPass\n", + "\tKickAngle : [0. 0.]\n" + ] + } + ], + "source": [ + "print(mark)\n", + "print(ring_tmp[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "mrk = at.Marker('ahoyhoy')\n", + "ring_tmp.append(mrk)\n", + "ring_tmp.remove(mrk)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([], dtype=uint32)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "at.get_uint32_index(ring_tmp, 'ahoy*')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## repeat" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "arc_tmp = arc.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0marc_tmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrepeat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'int'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy_elements\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "This method allows to repeat the lattice `n` times.\n", + "If `n` does not divide `ring.periodicity`, the new ring\n", + "periodicity is set to 1, otherwise it is et to\n", + "`ring.periodicity /= n`.\n", + "\n", + "Equivalents syntaxes:\n", + ">>> newring = ring.repeat(n)\n", + ">>> newring = ring * n\n", + "\n", + "Parameters:\n", + " n (int): number of repetition\n", + " copy_elements(bool): Default :py:obj:`True`.\n", + " If :py:obj:`True` deepcopies of the\n", + " lattice are used for the repetition\n", + "\n", + "Returns:\n", + " newring (Lattice): the new repeated lattice\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "arc_tmp.repeat?" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arc_tmp.periodicity" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = arc_tmp.repeat(arc_tmp.periodicity)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "29 725 825\n" + ] + } + ], + "source": [ + "ring_tmp.periodicity\n", + "print(len(arc_tmp), len(ring_tmp), 33*25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## reduce" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Very important and useful function! This function will remove all irrelevant elements from your lattice, and merge compatible adjacent elements. For example, say you have split a quadrupole in the center and put a marker there. The marker has an 'IdentityPass', pass method which means it will be removed. The now adjacent quadrupoles will be merged. Very useful for reducing as much as possible the number of elements that need to be actively tracked in your lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring.deepcopy()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mring_tmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m'Lattice'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Removes all elements with an ``IdentityPass`` PassMethod and merges\n", + "compatible consecutive elements.\n", + "\n", + "The \"reduced\" lattice has the same optics as the original one, but\n", + "fewer elements. Compatible elements must have the same ``PolynomA``,\n", + "``PolynomB`` and bending radius, so that the optics is preserved. But\n", + "magnet misalignments are not preserved, so this method should be\n", + "applied to lattices without errors.\n", + "\n", + "Keyword Args:\n", + " keep (Refpts): Keep the selected elements, even with\n", + " ``IdentityPass`` PassMethod. Default: keep :py:class:`.Monitor`\n", + " and :py:class:`.RFCavity` elements\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py\n", + "\u001b[0;31mType:\u001b[0m method" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring_tmp.reduce?" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "776" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ring_tmp)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "ring_tmp = ring_tmp.reduce()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "776" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ring_tmp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### masks / refpts" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "776" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ring_tmp = ring.deepcopy()\n", + "len(ring)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You have a ring. It has for example, 876 elements. There are a variety of different ways to select the desired elements in the list." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Drift('DR_06', 0.5625), Quadrupole('QF4', 0.75, 0.45885583241646444, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 1.195344261281964), Monitor('BPM_CellCenter'), Sextupole('SF', 0.75, 1.195344261281964), Drift('DR_07', 0.1875), Quadrupole('QF4', 0.75, 0.45885583241646444, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Drift('DR_06', 0.5625), Sextupole('SD', 0.1875, -5.12864683798499)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=1, harmonic_number=992, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "msk = np.zeros(len(ring_tmp), dtype=bool)\n", + "msk[10:20] = True\n", + "ring_tmp[msk]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Quadrupole('QF1', 0.75, 0.3804658324164645, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Drift('DR_02', 0.75), Quadrupole('QD2', 0.75, -0.27094579574214106, Energy=3000000000.0, PassMethod='StrMPoleSymplectic4RadPass'), Dipole('Bend', 3.0, 0.12566370614359174, 0.0, Energy=3000000000.0, PassMethod='BndMPoleSymplectic4RadPass'), Drift('DR_04', 0.1875), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 1.195344261281964)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=1, harmonic_number=992, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "args = np.array([1,2,3,5,6,234,450])\n", + "ring_tmp[args]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we have already seen. We have the function 'get_uint32_index' to get the indexes of elements matching a certain criteria. We also have 'get_bool_index' in order to obtain a mask for the same values." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "msk = at.get_bool_index(ring,'BPM*')\n", + "inds = at.get_uint32_index(ring,'BPM*')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 14 29 45 60 76 92 108 123 139 154 170 185 201 216 232 247 263 278\n", + " 294 309 325 340 356 371 387 402 418 433 449 464 480 495 511 526 542 557\n", + " 573 588 604 619 635 650 666 681 697 712 728 743 759 774]\n", + "[ 14 29 45 60 76 92 108 123 139 154 170 185 201 216 232 247 263 278\n", + " 294 309 325 340 356 371 387 402 418 433 449 464 480 495 511 526 542 557\n", + " 573 588 604 619 635 650 666 681 697 712 728 743 759 774]\n" + ] + } + ], + "source": [ + "print(np.where(msk)[0])\n", + "print(inds)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/esrfworkshop/2_LatticeManipulations.py b/esrfworkshop/2_LatticeManipulations.py new file mode 100644 index 0000000..a666e49 --- /dev/null +++ b/esrfworkshop/2_LatticeManipulations.py @@ -0,0 +1,324 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +import at +import at.plot +import numpy as np +import matplotlib.pyplot as aplt + +ring = at.load_mat('./dba.mat', mat_key='RING') +arc = at.load_mat('./arc.mat', mat_key='ARC') + + +# In[2]: + + +ring.plot_beta() +arc.plot_beta() + + +# There are many other handy functions for modifying the lattice in this way including a lot of the standard python list modifications: +# > 1. sbreak +# > 2. slice +# > 3. insert +# > 4. remove +# > 5. append +# > 6. pop +# > 7. repeat +# > 8. reduce +# + +# ## sbreak + +# In[3]: + + +get_ipython().run_line_magic('pinfo', 'ring.sbreak') + + +# In[4]: + + +ring_tmp = ring.deepcopy() +ring_tmp[0] + + +# In[5]: + + +ring_tmp = ring_tmp.sbreak(0.2, at.Marker('hello')) +print(ring_tmp[0],'\n', ring_tmp[1],'\n', ring_tmp[2]) + + +# In[6]: + + +ring_tmp = ring_tmp.sbreak(2.8, at.Marker('QuadSplit')) +print(ring_tmp[3],'\n', ring_tmp[4],'\n', ring_tmp[5]) + + +# For quadrupoles, there is an flag for the inclusion or exclusion of fringe fields at the entrance and exit of the quadrupoles. When you split the quadrupole, the internal fringe fields are disabled, and the outer fringe fields are kept. Similarly when you split a dipole, the exit and entrance angles are modified to ensure a continuous bend. + +# ## slice / divide / merge + +# You slice a lattice, you divide an element + +# In[7]: + + +ring_tmp = ring.deepcopy() + + +# In[8]: + + +quad = ring_tmp[3] +print(quad, '\n') +quad_div = quad.divide([0.5, 0.4]) +print(quad_div[0], '\n', quad_div[1]) + + +# It may be useful to make nice smooth plots (for example of optics functions in the middle of elements and not just at the edges). For this you can use slice. + +# In[9]: + + +get_ipython().run_line_magic('pinfo', 'ring_tmp.slice') + + +# In[10]: + + +new_ring_tmp = ring_tmp.slice(slices=2000) + + +# In[11]: + + +msk = at.get_value_refpts(ring_tmp, np.arange(len(ring_tmp)), 'Length') == 0 +print(len(ring_tmp) - np.sum(msk)) + +msk = at.get_value_refpts(new_ring_tmp, np.arange(len(new_ring_tmp)), 'Length') == 0 +print(len(new_ring_tmp) - np.sum(msk)) + + +# Zero length elements are of course not touched, but one can also specify a dz too + +# We can also do the opposite of split, which is to merge two identical and adjacent elements + +# In[12]: + + +q = ring_tmp[3] + + +# In[13]: + + +print(q) + + +# In[14]: + + +q.merge(q) + + +# In[15]: + + +print(q) + + +# In[16]: + + +dr = ring_tmp[0] +print(dr) + + +# In[17]: + + +dr.merge(dr) +print(dr) + + +# ## insert / append / pop / remove + +# Lattice objects are fundamentally lists. Which means that all of the standard python operations that can be performed on lists are valid for a lattice object + +# In[18]: + + +ring_tmp = ring.deepcopy() + + +# In[19]: + + +ring_tmp.insert(4, at.Marker('insert_test')) + + +# In[20]: + + +print(ring_tmp[4]) + + +# Append puts elements automatically at the end. It is equivalent to insert with an index of -1 +# + +# In[21]: + + +ring_tmp.append(at.Marker('append_test')) +print(ring_tmp[-1]) + + +# Pop removes and returns the element at the specified index + +# In[22]: + + +mark = ring_tmp.pop(-1) + + +# In[23]: + + +print(mark) +print(ring_tmp[-1]) + + +# In[24]: + + +mrk = at.Marker('ahoyhoy') +ring_tmp.append(mrk) +ring_tmp.remove(mrk) + + +# In[25]: + + +at.get_uint32_index(ring_tmp, 'ahoy*') + + +# ## repeat + +# In[26]: + + +arc_tmp = arc.deepcopy() + + +# In[27]: + + +get_ipython().run_line_magic('pinfo', 'arc_tmp.repeat') + + +# In[28]: + + +arc_tmp.periodicity + + +# In[29]: + + +ring_tmp = arc_tmp.repeat(arc_tmp.periodicity) + + +# In[30]: + + +ring_tmp.periodicity +print(len(arc_tmp), len(ring_tmp), 33*25) + + +# ## reduce + +# Very important and useful function! This function will remove all irrelevant elements from your lattice, and merge compatible adjacent elements. For example, say you have split a quadrupole in the center and put a marker there. The marker has an 'IdentityPass', pass method which means it will be removed. The now adjacent quadrupoles will be merged. Very useful for reducing as much as possible the number of elements that need to be actively tracked in your lattice. + +# In[31]: + + +ring_tmp = ring.deepcopy() + + +# In[32]: + + +get_ipython().run_line_magic('pinfo', 'ring_tmp.reduce') + + +# In[33]: + + +len(ring_tmp) + + +# In[34]: + + +ring_tmp = ring_tmp.reduce() + + +# In[35]: + + +len(ring_tmp) + + +# ### masks / refpts + +# In[36]: + + +ring_tmp = ring.deepcopy() +len(ring) + + +# You have a ring. It has for example, 876 elements. There are a variety of different ways to select the desired elements in the list. + +# In[37]: + + +msk = np.zeros(len(ring_tmp), dtype=bool) +msk[10:20] = True +ring_tmp[msk] + + +# In[38]: + + +args = np.array([1,2,3,5,6,234,450]) +ring_tmp[args] + + +# As we have already seen. We have the function 'get_uint32_index' to get the indexes of elements matching a certain criteria. We also have 'get_bool_index' in order to obtain a mask for the same values. + +# In[39]: + + +msk = at.get_bool_index(ring,'BPM*') +inds = at.get_uint32_index(ring,'BPM*') + + +# In[40]: + + +print(np.where(msk)[0]) +print(inds) + + +# In[ ]: + + + + diff --git a/esrfworkshop/3_SimpleOptics.ipynb b/esrfworkshop/3_SimpleOptics.ipynb new file mode 100644 index 0000000..8a3ab38 --- /dev/null +++ b/esrfworkshop/3_SimpleOptics.ipynb @@ -0,0 +1,1764 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/home/claudio/src/gitlab/dt/exercises/pyatworkshop/dba.mat'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:39\u001b[0m, in \u001b[0;36m_open_file\u001b[0;34m(file_like, appendmat, mode)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfile_like\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# Probably \"not found\"\u001b[39;00m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/claudio/src/gitlab/dt/exercises/pyatworkshop/dba.mat'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m ring \u001b[38;5;241m=\u001b[39m \u001b[43mat\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload_mat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m./dba.mat\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmat_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mRING\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m arc \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mload_mat(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m./arc.mat\u001b[39m\u001b[38;5;124m'\u001b[39m, mat_key\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mARC\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/load/matfile.py:169\u001b[0m, in \u001b[0;36mload_mat\u001b[0;34m(filename, **kwargs)\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mkey\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m kwargs: \u001b[38;5;66;03m# process the deprecated 'key' keyword\u001b[39;00m\n\u001b[1;32m 168\u001b[0m kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmat_key\u001b[39m\u001b[38;5;124m'\u001b[39m, kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mkey\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[0;32m--> 169\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mLattice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mringparam_filter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmatfile_generator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mabspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 170\u001b[0m \u001b[43m \u001b[49m\u001b[43miterator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams_filter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py:186\u001b[0m, in \u001b[0;36mLattice.__init__\u001b[0;34m(self, iterator, scan, *args, **kwargs)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 184\u001b[0m elems \u001b[38;5;241m=\u001b[39m iterator(kwargs, \u001b[38;5;241m*\u001b[39margs)\n\u001b[0;32m--> 186\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mLattice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43melems\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;66;03m# removing excluded attributes\u001b[39;00m\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m attr \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_excluded_attributes:\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/lattice/lattice_object.py:1474\u001b[0m, in \u001b[0;36mparams_filter\u001b[0;34m(params, elem_filter, *args)\u001b[0m\n\u001b[1;32m 1471\u001b[0m cavities \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 1472\u001b[0m cell_length \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[0;32m-> 1474\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, elem \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(elem_filter(params, \u001b[38;5;241m*\u001b[39margs)):\n\u001b[1;32m 1475\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(elem, elt\u001b[38;5;241m.\u001b[39mRFCavity):\n\u001b[1;32m 1476\u001b[0m cavities\u001b[38;5;241m.\u001b[39mappend(elem)\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/load/matfile.py:115\u001b[0m, in \u001b[0;36mringparam_filter\u001b[0;34m(params, elem_iterator, *args)\u001b[0m\n\u001b[1;32m 113\u001b[0m ringparams \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 114\u001b[0m radiate \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m elem \u001b[38;5;129;01min\u001b[39;00m elem_iterator(params, \u001b[38;5;241m*\u001b[39margs):\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (elem\u001b[38;5;241m.\u001b[39mPassMethod\u001b[38;5;241m.\u001b[39mendswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRadPass\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[1;32m 117\u001b[0m elem\u001b[38;5;241m.\u001b[39mPassMethod\u001b[38;5;241m.\u001b[39mendswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mCavityPass\u001b[39m\u001b[38;5;124m'\u001b[39m)):\n\u001b[1;32m 118\u001b[0m radiate \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/.local/lib/python3.10/site-packages/at/load/matfile.py:67\u001b[0m, in \u001b[0;36mmatfile_generator\u001b[0;34m(params, mat_file)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 64\u001b[0m \u001b[38;5;66;03m# Remove any surplus dimensions in arrays.\u001b[39;00m\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m numpy\u001b[38;5;241m.\u001b[39msqueeze(data)\n\u001b[0;32m---> 67\u001b[0m m \u001b[38;5;241m=\u001b[39m \u001b[43mscipy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mio\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloadmat\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetdefault\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmat_file\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmat_file\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 68\u001b[0m matvars \u001b[38;5;241m=\u001b[39m [varname \u001b[38;5;28;01mfor\u001b[39;00m varname \u001b[38;5;129;01min\u001b[39;00m m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m varname\u001b[38;5;241m.\u001b[39mstartswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__\u001b[39m\u001b[38;5;124m'\u001b[39m)]\n\u001b[1;32m 69\u001b[0m default_key \u001b[38;5;241m=\u001b[39m matvars[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m (\u001b[38;5;28mlen\u001b[39m(matvars) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRING\u001b[39m\u001b[38;5;124m'\u001b[39m\n", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:224\u001b[0m, in \u001b[0;36mloadmat\u001b[0;34m(file_name, mdict, appendmat, **kwargs)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;124;03mLoad MATLAB file.\u001b[39;00m\n\u001b[1;32m 89\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;124;03m 3.14159265+3.14159265j])\u001b[39;00m\n\u001b[1;32m 222\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 223\u001b[0m variable_names \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mvariable_names\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 224\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m _open_file_context(file_name, appendmat) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 225\u001b[0m MR, _ \u001b[38;5;241m=\u001b[39m mat_reader_factory(f, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 226\u001b[0m matfile_dict \u001b[38;5;241m=\u001b[39m MR\u001b[38;5;241m.\u001b[39mget_variables(variable_names)\n", + "File \u001b[0;32m/usr/lib/python3.10/contextlib.py:135\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 135\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgen\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerator didn\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt yield\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28mNone\u001b[39m\n", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:17\u001b[0m, in \u001b[0;36m_open_file_context\u001b[0;34m(file_like, appendmat, mode)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;129m@contextmanager\u001b[39m\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_open_file_context\u001b[39m(file_like, appendmat, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrb\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[0;32m---> 17\u001b[0m f, opened \u001b[38;5;241m=\u001b[39m \u001b[43m_open_file\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile_like\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mappendmat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m f\n", + "File \u001b[0;32m/usr/lib/python3/dist-packages/scipy/io/matlab/_mio.py:45\u001b[0m, in \u001b[0;36m_open_file\u001b[0;34m(file_like, appendmat, mode)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m appendmat \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m file_like\u001b[38;5;241m.\u001b[39mendswith(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.mat\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 44\u001b[0m file_like \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.mat\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 45\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfile_like\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mOSError\u001b[39;00m(\n\u001b[1;32m 48\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mReader needs file name or open file-like object\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 49\u001b[0m ) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/claudio/src/gitlab/dt/exercises/pyatworkshop/dba.mat'" + ] + } + ], + "source": [ + "import at\n", + "import at.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "ring = at.load_mat('./dba.mat', mat_key='RING')\n", + "arc = at.load_mat('./arc.mat', mat_key='ARC')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple Tracking, Optics and Orbit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will do some simple tracking through the lattice, and also show how to compute the optics and the orbit. \n", + "\n", + "First we need some particles to track, these must be in the format of ((6,N)) where 6 is the number of dimensions of AT (x,x',y,y',delta,ct) and N is the number of particles. This array can be manually created, but it is also desirable to generate a beam that is matched to the lattice. We can do this by generating the sigma correlation matrix using 'sigma_matrix'. The function will return a correlation matrix that can be used to generate a matched beam for the lattice you provide it. However there are some interesting things to be aware of, e.g." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "ring.disable_6d()\n", + "#sig_mat = at.sigma_matrix(ring)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have give a lattice with radiation off and asked for a correlation matrix. However, the emittances of a lattice with no radiation are 0 in x and y. Therefore we must provide the emittances that we want." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/tracking/particles.py:107: AtWarning: Monochromatic beam: no energy spread\n", + " warn(AtWarning('Monochromatic beam: no energy spread'))\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[ 2.45937189e-09, -2.37902221e-21, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [-2.37902221e-21, 4.06607883e-12, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, 1.67372947e-11,\n", + " -4.04065923e-23, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, -4.04065923e-23,\n", + " 5.97468119e-14, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sig_mat = at.sigma_matrix(ring, emitx=100e-12, emity=1e-12)\n", + "sig_mat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to the fact that the rad is off. We only have correlations for x,x' and y,y' and nothing in the longitudinal plane. But we can switch rad on and compare the difference. Here you may notice that we don't need to give the emittances, that is because if radiation is on and no emittances are specified, it will take the result from envelope_parameters. If you want a beam with veritcal emittance, you can also still specify it. There are many different cases that can be seen in the help, but the exception that is raised if something is missing is quite explanatory. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.82796706e-07, 8.80029073e-13, -9.03634961e-27,\n", + " -2.23193015e-27, -6.45406656e-12, -1.10736402e-11],\n", + " [ 8.80029502e-13, 3.02682564e-10, -3.93185281e-28,\n", + " 4.28789015e-29, -1.37026502e-12, 1.60304356e-13],\n", + " [ 1.14458611e-27, 2.36795948e-28, 1.67373110e-10,\n", + " 2.00352563e-16, -4.85449966e-23, -1.27782072e-23],\n", + " [-1.30926147e-28, -2.70856465e-29, 2.00352563e-16,\n", + " 5.97467540e-13, 5.55276393e-24, 1.46211048e-24],\n", + " [-6.45942538e-12, -1.35267982e-12, 8.54658540e-23,\n", + " -5.46753954e-24, 2.76400648e-07, 3.98317397e-08],\n", + " [-1.17777339e-11, 1.84183232e-13, 1.67970673e-21,\n", + " 7.49294951e-23, 3.98317397e-08, 6.20209387e-06]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sig_mat_rad_on = at.sigma_matrix(ring.radiation_on(copy=True), emity=10e-12)\n", + "sig_mat_rad_on" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the matrix we can generate a beam using 'beam'." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h, v, delta\n", + "(6, 50000)\n" + ] + } + ], + "source": [ + "nparts = 50000\n", + "parts = at.beam(nparts, sig_mat_rad_on)\n", + "print(parts.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.002487854833857263\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([1.000e+00, 0.000e+00, 1.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,\n", + " 1.000e+00, 2.000e+00, 2.000e+00, 2.000e+00, 0.000e+00, 7.000e+00,\n", + " 7.000e+00, 6.000e+00, 1.400e+01, 1.500e+01, 2.100e+01, 2.500e+01,\n", + " 3.000e+01, 3.800e+01, 4.800e+01, 6.100e+01, 8.600e+01, 1.060e+02,\n", + " 1.140e+02, 1.380e+02, 1.610e+02, 2.000e+02, 2.480e+02, 2.620e+02,\n", + " 2.870e+02, 4.030e+02, 4.050e+02, 5.020e+02, 5.850e+02, 6.510e+02,\n", + " 6.930e+02, 7.780e+02, 8.890e+02, 1.040e+03, 1.057e+03, 1.107e+03,\n", + " 1.237e+03, 1.334e+03, 1.365e+03, 1.459e+03, 1.560e+03, 1.528e+03,\n", + " 1.664e+03, 1.636e+03, 1.627e+03, 1.630e+03, 1.614e+03, 1.719e+03,\n", + " 1.676e+03, 1.674e+03, 1.593e+03, 1.507e+03, 1.470e+03, 1.334e+03,\n", + " 1.241e+03, 1.242e+03, 1.103e+03, 1.065e+03, 9.680e+02, 8.730e+02,\n", + " 7.920e+02, 6.810e+02, 6.450e+02, 5.470e+02, 4.930e+02, 4.520e+02,\n", + " 3.750e+02, 3.170e+02, 2.880e+02, 2.610e+02, 2.070e+02, 1.760e+02,\n", + " 1.490e+02, 9.900e+01, 7.700e+01, 7.100e+01, 5.500e+01, 4.900e+01,\n", + " 4.000e+01, 2.400e+01, 1.700e+01, 1.800e+01, 1.700e+01, 5.000e+00,\n", + " 1.200e+01, 5.000e+00, 5.000e+00, 4.000e+00, 3.000e+00, 2.000e+00,\n", + " 0.000e+00, 0.000e+00, 1.000e+00, 1.000e+00]),\n", + " array([-1.09313451e-02, -1.07209302e-02, -1.05105153e-02, -1.03001004e-02,\n", + " -1.00896855e-02, -9.87927058e-03, -9.66885567e-03, -9.45844075e-03,\n", + " -9.24802584e-03, -9.03761093e-03, -8.82719602e-03, -8.61678110e-03,\n", + " -8.40636619e-03, -8.19595128e-03, -7.98553637e-03, -7.77512145e-03,\n", + " -7.56470654e-03, -7.35429163e-03, -7.14387671e-03, -6.93346180e-03,\n", + " -6.72304689e-03, -6.51263198e-03, -6.30221706e-03, -6.09180215e-03,\n", + " -5.88138724e-03, -5.67097233e-03, -5.46055741e-03, -5.25014250e-03,\n", + " -5.03972759e-03, -4.82931268e-03, -4.61889776e-03, -4.40848285e-03,\n", + " -4.19806794e-03, -3.98765303e-03, -3.77723811e-03, -3.56682320e-03,\n", + " -3.35640829e-03, -3.14599338e-03, -2.93557846e-03, -2.72516355e-03,\n", + " -2.51474864e-03, -2.30433373e-03, -2.09391881e-03, -1.88350390e-03,\n", + " -1.67308899e-03, -1.46267408e-03, -1.25225916e-03, -1.04184425e-03,\n", + " -8.31429338e-04, -6.21014426e-04, -4.10599513e-04, -2.00184601e-04,\n", + " 1.02303120e-05, 2.20645225e-04, 4.31060137e-04, 6.41475050e-04,\n", + " 8.51889962e-04, 1.06230487e-03, 1.27271979e-03, 1.48313470e-03,\n", + " 1.69354961e-03, 1.90396452e-03, 2.11437944e-03, 2.32479435e-03,\n", + " 2.53520926e-03, 2.74562418e-03, 2.95603909e-03, 3.16645400e-03,\n", + " 3.37686891e-03, 3.58728383e-03, 3.79769874e-03, 4.00811365e-03,\n", + " 4.21852856e-03, 4.42894348e-03, 4.63935839e-03, 4.84977330e-03,\n", + " 5.06018821e-03, 5.27060313e-03, 5.48101804e-03, 5.69143295e-03,\n", + " 5.90184786e-03, 6.11226278e-03, 6.32267769e-03, 6.53309260e-03,\n", + " 6.74350751e-03, 6.95392243e-03, 7.16433734e-03, 7.37475225e-03,\n", + " 7.58516716e-03, 7.79558208e-03, 8.00599699e-03, 8.21641190e-03,\n", + " 8.42682681e-03, 8.63724173e-03, 8.84765664e-03, 9.05807155e-03,\n", + " 9.26848646e-03, 9.47890138e-03, 9.68931629e-03, 9.89973120e-03,\n", + " 1.01101461e-02]),\n", + " <BarContainer object of 100 artists>)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "coord=5\n", + "print(np.std(parts[coord,:]))\n", + "plt.hist(parts[coord,:], bins=100)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's do some tracking. but to make it easier we can start with only a single particle." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6,)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_in = np.array([1e-3, 0., 0., 0., 0., 0.]) #must be floats not ints\n", + "p_in.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "We need to use the function track. We must define the refpts in the lattice where we want to save the output. And we also want to specify nturns. There are two ways of tracking, either you use nturns=1 within a for loop, this has the benefit of allowing you to perform your own TbT analysis and save relevant parameters only. Or you can tracking for many turns, look at the full coordinates of the whole tracking, and perform the post processing later." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mr_in\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnturns\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'int'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Refpts'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEnd\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'End'\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0min_place\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'bool'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + ":py:func:`track_function` tracks particles through each element of a\n", + "lattice or throught a single Element calling the element-specific\n", + "tracking function specified in the Element's *PassMethod* field.\n", + "\n", + "Usage:\n", + " >>> lattice_track(lattice, r_in)\n", + " >>> lattice.track(r_in)\n", + "\n", + "Parameters:\n", + " lattice: list of elements\n", + " r_in: (6, N) array: input coordinates of N particles.\n", + " *r_in* is modified in-place only if *in_place* is \n", + " :py:obj:`True` and reports the coordinates at\n", + " the end of the element. For the best efficiency, *r_in*\n", + " should be given as F_CONTIGUOUS numpy array.\n", + "\n", + "Keyword arguments:\n", + " nturns: number of turns to be tracked\n", + " refpts: Selects the location of coordinates output.\n", + " See \":ref:`Selecting elements in a lattice <refpts>`\"\n", + " in_place (bool): If True *r_in* is modified in-place and\n", + " reports the coordinates at the end of the element.\n", + " (default: False)\n", + " keep_lattice (bool): Use elements persisted from a previous\n", + " call. If :py:obj:`True`, assume that the lattice has not changed\n", + " since the previous call.\n", + " keep_counter (bool): Keep the turn number from the previous\n", + " call.\n", + " turn (int): Starting turn number. Ignored if\n", + " *keep_counter* is :py:obj:`True`. The turn number is necessary to\n", + " compute the absolute path length used in RFCavityPass.\n", + " losses (bool): Boolean to activate loss maps output\n", + " omp_num_threads (int): Number of OpenMP threads\n", + " (default: automatic)\n", + "\n", + "The following keyword arguments overload the lattice values\n", + "\n", + "Keyword arguments:\n", + "\n", + " particle (Optional[Particle]): circulating particle.\n", + " Default: :code:`lattice.particle` if existing,\n", + " otherwise :code:`Particle('relativistic')`\n", + " energy (Optiona[float]): lattice energy. Default 0.\n", + " unfold_beam (bool): Internal beam folding activate, this\n", + " assumes the input particles are in bucket 0, works only\n", + " if all bucket see the same RF Voltage.\n", + " Default: :py:obj:`True`\n", + "\n", + "If *energy* is not available, relativistic tracking if forced,\n", + "*rest_energy* is ignored.\n", + "\n", + "Returns:\n", + " r_out: (6, N, R, T) array containing output coordinates of N particles\n", + " at R reference points for T turns\n", + " trackparam: A dictionary containing tracking input parameters with the\n", + " following keys:\n", + "\n", + " ============== ===================================================\n", + " **npart** number of particles\n", + " **rout** final particle coordinates\n", + " **turn** starting turn\n", + " **refpts** array of index where particle coordinate are saved\n", + " (only for lattice tracking)\n", + " **nturns** number of turn\n", + "\n", + " trackdata: A dictionary containinf tracking data with the following\n", + " keys:\n", + "\n", + " ============== ===================================================\n", + " **loss_map**: recarray containing the loss_map (only for lattice\n", + " tracking)\n", + "\n", + "\n", + " The **loss_map** is filled only if *losses* is :py:obj:`True`,\n", + " it contains the following keys:\n", + " ============== ===================================================\n", + " **islost** (npart,) bool array indicating lost particles\n", + " **turn** (npart,) int array indicating the turn at\n", + " which the particle is lost\n", + " **element** ((npart,) int array indicating the element at\n", + " which the particle is lost\n", + " **coord** (npart, 6) float array giving the coordinates at\n", + " which the particle is lost (zero for surviving\n", + " particles)\n", + " ============== ===================================================\n", + "\n", + "\n", + ".. note::\n", + "\n", + " * :pycode:`track_function(lattice, r_in, refpts=len(line))` is the same\n", + " as :pycode:`track_function(lattice, r_in)` since the reference point\n", + " len(line) is the exit of the last element.\n", + " * :pycode:`track_function(lattice, r_in, refpts=0)` is a copy of *r_in*\n", + " since the reference point 0 is the entrance of the first element.\n", + " * To resume an interrupted tracking (for instance to get intermediate\n", + " results), one must use one of the *turn* or *keep_counter*\n", + " keywords to ensure the continuity of the turn number.\n", + " * For multiparticle tracking with large number of turn the size of\n", + " *r_out* may increase excessively. To avoid memory issues\n", + " :pycode:`track_function(lattice, r_in, refpts=None, in_place=True)`\n", + " can be used. An empty list is returned and the tracking results of\n", + " the last turn are stored in *r_in*.\n", + " * To model buckets with different RF voltage :pycode:`unfold_beam=False`\n", + " has to be used. The beam can be unfolded using the function\n", + " :py:func:`.unfold_beam`. This function takes into account\n", + " the true voltage in each bucket and distributes the particles in the\n", + " bunches defined by :code:`ring.fillpattern` using a 6D orbit search.\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/tracking/track.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ring.track?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Method 1, the output of the tracking is a big array with shape (6, N, R, T)\n", + "# where 6 is the particle coordinate, N is the particle index, R is the element index, \n", + "# and T is the turn number\n", + "pout, *_ = ring.track(p_in, refpts=np.arange(len(ring)), nturns=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tunex, tuney = ring.get_tune()\n", + "xdat = pout[0,0,0,:]\n", + "fig, (ax1,ax2) = plt.subplots(2,1)\n", + "ax1.plot(xdat)\n", + "ax2.plot(np.fft.rfftfreq(len(xdat)), np.abs(np.fft.rfft(xdat)))\n", + "ax2.axvline(tunex, color='r', linestyle='dashed')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An important note, back to pointers again! If you prefer to use them in a turn by turn way, you can go like this" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "p_in = np.zeros((6,3))\n", + "p_in[0,:] = np.array([1e-4,1e-3,3e-3])\n", + "n_turns=200\n", + "x_data = np.zeros((p_in.shape[1], n_turns))\n", + "xp_data = np.zeros((p_in.shape[1], n_turns))\n", + "for i in np.arange(n_turns):\n", + " _ = ring.track(p_in, nturns=1, in_place=True, refpts=None) #in_place means modify input particle, refpts=None stops the track function from generating big arrays for unneeded output\n", + " x_data[:, i] = p_in[0,:]\n", + " xp_data[:, i] = p_in[1,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'xp')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_data[0,:], xp_data[0,:], linestyle='None', marker='.', label='1e-4')\n", + "plt.plot(x_data[1,:], xp_data[1,:], linestyle='None', marker='.', label='1e-3')\n", + "plt.plot(x_data[2,:], xp_data[2,:], linestyle='None', marker='.', label='3e-3')\n", + "plt.legend()\n", + "plt.xlabel('x [m]')\n", + "plt.ylabel('xp')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following section is very important. As we saw, we have the ability to enable or disable 6d motion. When computing the linear optics or the orbit, the 'get_optics' and 'find_orbit' functions will automatically select the most appropriate method to use out of the methods available. \n", + "\n", + "> at.linopt2\n", + "\n", + "> at.linopt4 / at.find_orbit4\n", + "\n", + "> at.linopt6 / at.find_orbit6\n", + "\n", + "for 2, 4 and 6 dimensional tracking respectively. One can also specifically call other methods in order to speed up computation (for example if you are doing uncoupled matching, it is faster to call at.linopt2 rather than do the full 6d computation)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(776, 6)\n" + ] + } + ], + "source": [ + "ring.disable_6d()\n", + "s_positions = ring.get_s_pos(refpts=np.arange(len(ring)))\n", + "orbit0_4, orbit_4 = ring.find_orbit(refpts=np.arange(len(ring)))\n", + "ring.enable_6d()\n", + "orbit0_6, orbit_6 = ring.find_orbit(refpts=np.arange(len(ring)))\n", + "print(orbit_4.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(s_positions, orbit_4[:,0], label='find_orbit4')\n", + "plt.plot(s_positions, orbit_6[:,0], label='find_orbit6')\n", + "plt.legend()\n", + "plt.xlabel('s [m]')\n", + "plt.ylabel('x [m]')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_optics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Lattice'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Refpts'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'float'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Callable'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mfunction\u001b[0m \u001b[0mlinopt6\u001b[0m \u001b[0mat\u001b[0m \u001b[0;36m0x15213c1bcd30\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Linear analysis of a fully coupled lattice\n", + "\n", + "Parameters:\n", + " ring: Lattice description.\n", + " refpts: Elements at which data is returned.\n", + " It can be:\n", + "\n", + " 1. an integer in the range [-len(ring), len(ring)-1]\n", + " selecting the element according to python indexing rules.\n", + " As a special case, len(ring) is allowed and refers to the end\n", + " of the last element,\n", + " 2. an ordered list of such integers without duplicates,\n", + " 3. a numpy array of booleans of maximum length len(ring)+1,\n", + " where selected elements are :py:obj:`True`.\n", + " dp: Momentum deviation.\n", + " method (Callable): Method for linear optics:\n", + "\n", + " :py:obj:`~.linear.linopt2`: no longitudinal motion, no H/V coupling,\n", + "\n", + " :py:obj:`~.linear.linopt4`: no longitudinal motion, Sagan/Rubin\n", + " 4D-analysis of coupled motion,\n", + "\n", + " :py:obj:`~.linear.linopt6` (default): with or without longitudinal\n", + " motion, normal mode analysis\n", + "\n", + "Keyword Args:\n", + " dct (float): Path lengthening. Defaults to :py:obj:`None`\n", + " df (float): Deviation of RF frequency. Defaults to\n", + " :py:obj:`None`\n", + " orbit (Orbit): Avoids looking for the closed orbit if it is\n", + " already known ((6,) array)\n", + " get_chrom (bool): Compute chromaticities. Needs computing\n", + " the tune at 2 different momentum deviations around the central one.\n", + " get_w (bool): Computes chromatic amplitude functions\n", + " (W) [4]_. Needs to compute the optics at 2 different momentum\n", + " deviations around the central one.\n", + " keep_lattice (bool): Assume no lattice change since the\n", + " previous tracking. Defaults to :py:obj:`False`\n", + " XYStep (float): Step size.\n", + " Default: :py:data:`DConstant.XYStep <.DConstant>`\n", + " DPStep (float): Momentum step size.\n", + " Default: :py:data:`DConstant.DPStep <.DConstant>`\n", + " twiss_in: Initial conditions for transfer line optics.\n", + " Record array as output by :py:func:`.linopt6`, or dictionary. Keys:\n", + "\n", + " R or alpha, beta\n", + " mandatory (2,) arrays\n", + " closed_orbit\n", + " Optional (6,) array, default 0\n", + " dispersion\n", + " Optional (6,) array, default 0\n", + "\n", + " If present, the attribute **R** will be used, otherwise the\n", + " attributes **alpha** and **beta** will be used. All other attributes\n", + " are ignored.\n", + "\n", + "Returns:\n", + " elemdata0: Linear optics data at the entrance of the ring\n", + " ringdata: Lattice properties\n", + " elemdata: Linear optics at the points refered to by *refpts*,\n", + " if refpts is :py:obj:`None` an empty lindata structure is returned.\n", + "\n", + "Warning:\n", + " The format of output record arrays depends on the selected method.\n", + " See :py:func:`linopt2`, :py:func:`linopt4`, :py:func:`linopt6`.\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/linear.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.get_optics?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "ring.disable_6d()\n", + "ld0_4d, bd_4d, ld_4d = at.get_optics(ring, refpts=np.arange(len(ring)), method=at.linopt2)\n", + "ring.enable_6d()\n", + "ld0_6d, bd_6d, ld_6d = at.get_optics(ring, refpts=np.arange(len(ring)))\n", + "ld0_6db, bd_6db, ld_6db = at.get_optics(ring, refpts=np.arange(len(ring)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(ld_4d.beta[:,1])\n", + "plt.plot(ld_6d.beta[:,1])\n", + "plt.show()\n", + "fig, ax = plt.subplots()\n", + "axb = ax.twinx()\n", + "ax.plot(s_positions, ld_6d.beta[:,1] - ld_4d.beta[:,1], color='r')\n", + "axb.plot(s_positions, orbit_6[:,0], label='find_orbit6', color='b')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_orbit4\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLattice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdct\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0morbit\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mkeep_lattice\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Gets the 4D closed orbit for a given dp\n", + "\n", + "Finds the closed orbit in the 4-d transverse phase space by numerically\n", + "solving for a fixed point of the one turn map M calculated with\n", + ":py:func:`.internal_lpass`.\n", + "\n", + ".. math:: \\begin{pmatrix}x \\\\ p_x \\\\ y \\\\ p_y \\\\ dp \\\\ c\\tau_2\\end{pmatrix}\n", + " =\\mathbf{M} \\cdot\n", + " \\begin{pmatrix}x \\\\ p_x \\\\ y \\\\ p_y \\\\ dp \\\\ c\\tau_1\\end{pmatrix}\n", + "\n", + "under the **CONSTANT MOMENTUM** constraint **dp** and with **NO**\n", + "constraint on the 6-th coordinate :math:`c\\tau`\n", + "\n", + "Important:\n", + " :py:func:`find_orbit4` imposes a constraint on *dp* and relaxes the\n", + " constraint on the revolution frequency. A physical storage ring does\n", + " exactly the opposite: the momentum deviation of a particle on the\n", + " closed orbit settles at the value such that the revolution is\n", + " synchronous with the RF cavity: :math:`f_{RF} = h*f_{rev}`\n", + "\n", + "To impose this artificial constraint in :py:func:`find_orbit4`,\n", + "the ``PassMethod`` used for any element **SHOULD NOT**:\n", + "\n", + "1. Change the longitudinal momentum *dp* (cavities ,\n", + " magnets with radiation)\n", + "2. Have any time dependence (localized impedance, fast kickers etc)\n", + "\n", + "Parameters:\n", + " ring: Lattice description (:py:attr:`~.Lattice.is_6d` must be\n", + " :py:obj:`False`)\n", + " dp: Momentum deviation. Defaults to 0\n", + " refpts: Observation points.\n", + " See \":ref:`Selecting elements in a lattice <refpts>`\"\n", + " dct: Path lengthening. If specified, *dp* is ignored and\n", + " the off-momentum is deduced from the path lengthening.\n", + " df: Deviation from the nominal RF frequency. If specified,\n", + " *dp* is ignored and the off-momentum is deduced from the frequency\n", + " deviation.\n", + " orbit: Avoids looking for initial the closed orbit if it is\n", + " already known ((6,) array). :py:func:`find_orbit4` propagates it to\n", + " the specified *refpts*.\n", + " keep_lattice: Assume no lattice change since the previous tracking.\n", + " Default: False\n", + "\n", + "Keyword Args:\n", + " guess (Orbit): (6,) initial value for the\n", + " closed orbit. It may help convergence. Default: (0, 0, 0, 0, 0, 0)\n", + " convergence (float): Convergence criterion.\n", + " Default: :py:data:`DConstant.OrbConvergence <.DConstant>`\n", + " max_iterations (int): Maximum number of iterations.\n", + " Default: :py:data:`DConstant.OrbMaxIter <.DConstant>`\n", + " XYStep (float): Step size.\n", + " Default: :py:data:`DConstant.XYStep <.DConstant>`\n", + "\n", + "Returns:\n", + " orbit0: (6,) closed orbit vector at the entrance of the\n", + " 1-st element (x,px,y,py,dp,0)\n", + " orbit: (Nrefs, 6) closed orbit vector at each location\n", + " specified in *refpts*\n", + "\n", + "See also:\n", + " :py:func:`find_sync_orbit`, :py:func:`find_orbit6`\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/orbit.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.find_orbit4?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Orbit Correction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By now we are basically experts. What we will now do is show how to use what we have learned and do some orbit correction.\n", + "First we need to get the orbit response matrix. This is a big matrix showing the orbit response from each steerer action." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "ring.disable_6d()\n", + "corrector_refpts = at.get_uint32_index(ring, 'Corr*')\n", + "bpm_refpts = at.get_uint32_index(ring, 'BPM*')\n", + "\n", + "orm = np.zeros((len(bpm_refpts), len(corrector_refpts)))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "kickang = 1e-6\n", + "for ic, corrector_ind in enumerate(corrector_refpts):\n", + " #init_steer_value = ring[corrector_ind].KickAngle[1]\n", + " #_, ref_orbit = ring.find_orbit(refpts=bpm_refpts)\n", + " ring[corrector_ind].KickAngle[1] += kickang\n", + " _, pos_orbit = ring.find_orbit(refpts=bpm_refpts)\n", + " ring[corrector_ind].KickAngle[1] -= 2*kickang\n", + " _, neg_orbit = ring.find_orbit(refpts=bpm_refpts)\n", + " ring[corrector_ind].KickAngle[1] += kickang\n", + " orm[:, ic] = (pos_orbit[:,2] - neg_orbit[:,2])/kickang" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'bpm #')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(orm)\n", + "plt.xlabel('corrector #')\n", + "plt.ylabel('bpm #')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can put a bad orbit, we can do this by introducing a misalignment on a couple of quadrupoles. Possible functions for this are 'set_shift' and 'set_tilt'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "ring_err = ring.deepcopy()\n", + "'''\n", + "at.set_shift?\n", + "quad_msk = at.get_bool_index(ring_err, at.Quadrupole)\n", + "shift_vals = np.zeros(quad_msk.shape[0]-1)\n", + "shift_vals[np.where(quad_msk)[0][0]] = 1e-6\n", + "shift_vals[np.where(quad_msk)[0][3]] = 5e-6\n", + "shift_vals[np.where(quad_msk)[0][4]] = -2e-6\n", + "shift_vals[np.where(quad_msk)[0][9]] = 3e-6\n", + "shift_vals[np.where(quad_msk)[0][11]] = 10e-6\n", + "shift_vals[np.where(quad_msk)[0][17]] = 0.5e-6\n", + "at.set_shift(ring_err, np.zeros(len(shift_vals)), shift_vals)\n", + "'''\n", + "all_corr_vals = at.get_value_refpts(ring_err, 'Corr*', 'KickAngle', 1)\n", + "all_corr_vals[0] = 2e-6\n", + "all_corr_vals[4] = -3.5e-5\n", + "all_corr_vals[7] = 6e-6\n", + "\n", + "at.set_value_refpts(ring_err, 'Corr*', 'KickAngle', all_corr_vals, 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "orb0, orb_bad = ring_err.find_orbit(refpts=bpm_refpts)\n", + "plt.plot(orb_bad[:,2])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "U,W,V = np.linalg.svd(orm, full_matrices=False)\n", + "Utran = np.transpose(U)\n", + "Winv = np.linalg.inv(np.diag(W))\n", + "Vtran = np.transpose(V)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3498502803537367e-05\n", + "6.74906454546305e-06\n", + "-3.3745090918992327e-06\n", + "1.6872517373670612e-06\n", + "-8.436255621495507e-07\n", + "4.2181276502819965e-07\n", + "-2.109063916433719e-07\n", + "1.0545320253039905e-07\n", + "-5.272660488756557e-08\n", + "2.6363304288466877e-08\n" + ] + } + ], + "source": [ + "niters = 10\n", + "orb_to_correct = orb_bad\n", + "for it in np.arange(niters):\n", + " dk = np.dot(Vtran, np.dot(Winv, np.dot(Utran, orb_to_correct[:,2])))\n", + " print(np.sum(dk))\n", + " at.set_value_refpts(ring_err, 'Corr*', 'KickAngle', -dk, 1)\n", + " orb0, orb_to_correct = ring_err.find_orbit(refpts=bpm_refpts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGsCAYAAAAGzwdbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvsklEQVR4nO3de3xU9Z3/8fdkQoaEXJAQgUgIBAyiCOKFiIrFhUroimKtS5U1QKm3gjfABbYPQdSW1suuu9buVrsG26qoFaWtrqsPFKgW0aIsskiE/LBBLgIqCQkhCTPn98dxkgwkITNzzpyTOa/n4zGPOTNz5pzvHEfmne/3c77HZxiGIQAAAJdIcboBAAAArRFOAACAqxBOAACAqxBOAACAqxBOAACAqxBOAACAqxBOAACAqxBOAACAqxBOAACAqxBOAACAq3SZcLJu3TpNnjxZ+fn58vl8euWVV2zd37333iufzxdxO+OMM2zdJwAA6ELhpK6uTiNHjtTjjz+esH2eddZZ2rt3b/PtnXfeSdi+AQDwqlSnG9BZkyZN0qRJk9p9vaGhQT/+8Y/13HPP6dChQxo+fLh+/vOfa9y4cTHvMzU1VX379o35/QAAIHpdpufkZObMmaP169drxYoV2rx5s6699lqVlpZq+/btMW9z+/btys/PV1FRkaZNm6aqqioLWwwAANriMwzDcLoR0fL5fHr55Zc1ZcoUSVJVVZWKiopUVVWl/Pz85vUmTJig0aNH66c//WnU+/jv//5v1dbWaujQodq7d6+WLl2q3bt3a8uWLcrKyrLqowAAgON0mWGdjnz88ccKBoMqLi6OeL6hoUG5ubmSpG3btmnYsGEdbmfBggX62c9+JkkRQ0gjRoxQSUmJCgsL9cILL2jWrFkWfwIAABCWFOGktrZWfr9fGzdulN/vj3gtMzNTklRUVKRPPvmkw+2Eg0xbevbsqeLiYu3YsSP+BgMAgHYlRTgZNWqUgsGg9u/fr7Fjx7a5TlpaWlynAtfW1qqyslI33HBDzNsAAAAn12XCSW1tbUSvxc6dO7Vp0yb16tVLxcXFmjZtmsrKyvTII49o1KhROnDggFavXq0RI0bo7//+76Pe3/z58zV58mQVFhZqz549WrJkifx+v6677jorPxYAADhOlymIXbNmjS677LITnp8+fbqWL1+upqYmPfDAA/rNb36j3bt3q3fv3rrwwgu1dOlSnX322VHv7/vf/77WrVunL7/8Unl5ebrkkkv0k5/8RIMHD7bi4wAAgHZ0mXACAAC8IWnmOQEAAMmBcAIAAFzF1QWxoVBIe/bsUVZWlnw+n9PNAQAAnWAYhg4fPqz8/HylpETfD+LqcLJnzx4VFBQ43QwAABCDXbt2qX///lG/z9XhJDxN/K5du5Sdne1wawAAQGfU1NSooKAg5su9uDqchIdysrOzCScAAHQxsZZkUBALAABchXACAABchXACAABcxdU1JwAAdIZhGDp27JiCwaDTTfGMbt26ye/327JtwgkAoEtrbGzU3r17deTIEaeb4ik+n0/9+/dXZmam5dsmnAAAuqxQKKSdO3fK7/crPz9faWlpTNqZAIZh6MCBA/r88891+umnW96DQjgBAHRZjY2NCoVCKigoUEZGhtPN8ZS8vDx99tlnampqsjycUBALAOjyYpkiHfGxs4eK/5oAAMBVCCcAAMBVCCcAADhg3LhxuvPOO+PaxiuvvKIhQ4bI7/fHvS03oSAWAIAu6uabb9bMmTN1++23x3yRPTei5wTYskX6t3+Tjh1zuiUA0Gm1tbXav3+/Jk6cqPz8/JjDSWNjo8Utix/hBN5mGNK110p33in9+tdOtwaAFQxDqqtz5mYYUTX12LFjmjNnjnJyctS7d2/dc889Mr7ZRkNDg+bPn6/TTjtNPXr0UElJidasWSNJWrNmTXMY+bu/+zv5fL7m11566SWdddZZCgQCGjhwoB555JGIfQ4cOFD333+/ysrKlJ2drZtuukmS9M4772js2LFKT09XQUGBbr/9dtXV1cXxHyIOhotVV1cbkozq6mqnm4Jk9e67hmH+c2IYF1zgdGsARKm+vt7YunWrUV9f3/JkbW3L/9eJvtXWdrrt3/rWt4zMzEzjjjvuMLZt22b87ne/MzIyMownnnjCMAzD+OEPf2hcdNFFxrp164wdO3YYDz30kBEIBIxPP/3UaGhoMCoqKgxJxksvvWTs3bvXaGhoMP76178aKSkpxn333WdUVFQY5eXlRnp6ulFeXt6838LCQiM7O9t4+OGHjR07djTfevToYfzrv/6r8emnnxrvvvuuMWrUKGPGjBnRHftvxPv7TTiBt82aFfkPy+bNTrcIQBS6ejgZNmyYEQqFmp9bsGCBMWzYMONvf/ub4ff7jd27d0e8Z/z48caiRYsMwzCMr7/+2pBkvP32282vX3/99ca3v/3tiPfcfffdxplnntn8uLCw0JgyZUrEOrNmzTJuuummiOf+/Oc/GykpKW2GD8OwN5xQEAvvqquTnn/eXB48WKqslMrLpX/5F2fbBSA+GRlSba1z+47ChRdeGDGZ2ZgxY/TII4/o448/VjAYVHFxccT6DQ0Nys3NbXd7n3zyia666qqI5y6++GI9+uijCgaDzTO5nn/++RHr/O///q82b96sZ555pvk5wzCaLw8wbNiwqD5XvAgn8K7f/978B2zIEDOQXHml9LvfST/7mZSW5nTrAMTK55N69HC6FXGpra2V3+/Xxo0bT5ga3ooL7fU47vjU1tbq5ptv1u23337CugMGDIh7f9EinMC7nnrKvJ85U5o0SerbV9q3T3r1Venqq51tGwBP2LBhQ8Tj9957T6effrpGjRqlYDCo/fv3a+zYsZ3e3rBhw/Tuu+9GPPfuu++quLi4w+vfnHvuudq6dauGDBkS3QewCWfrwJu2b5fWrZNSUqSyMik11byXWkILANisqqpKc+fOVUVFhZ577jk99thjuuOOO1RcXKxp06aprKxMK1eu1M6dO/X+++9r2bJlevXVV9vd3rx587R69Wrdf//9+vTTT/X000/rF7/4hebPn99hOxYsWKC//OUvmjNnjjZt2qTt27dr1apVmjNnjtUfuVMIJ/Cm5cvN+4kTpf79zeWZM837116T9uxxpFkAvKWsrEz19fUaPXq0Zs+erTvuuKP51N7y8nKVlZVp3rx5Gjp0qKZMmaIPPvigw2GWc889Vy+88IJWrFih4cOHa/Hixbrvvvs0Y8aMDtsxYsQIrV27Vp9++qnGjh2rUaNGafHixcrPz7fy43aazzCiPCk7gWpqapSTk6Pq6mplZ2c73Rwki2BQGjDADCAvvih973str118sfSXv5h1JwsWONdGAJ1y9OhR7dy5U4MGDVL37t2dbo6ndHTs4/39pucE3vPGG2Ywyc2VJk+OfO0HPzDvn3oq6smUAADWIJzAe8rLzftp06RAIPK1f/gH81TATz+V1q9PfNsAAIQTeMzBg9Irr5jL4V6S1rKyzOnsJQpjAcAhhBN4y7PPSk1N0rnnSiNHtr1OOLQ8/7xzEzkBgIcRTuAdhiH913+Zy231moSNHWtOzFZba07UBgBIKMIJvOOjj6TNm806k+uua389n6/ltGKGdgAg4Qgn8I5wIeyUKVKvXh2vW1ZmTtD25z+bE7YBABKGcAJvOHpUCl/QqqMhnbD+/aXLLzeXwxO2AQASgnACb1i1Svr6a6mgQBo/vnPvCYeY5cvNidsAAAlBOIE3hGtHZsyQOrj4VYQrrzSHf/bsMSduA4AE27Ztmy688EJ1795d55xzjtPNSRjCCZJfVZX05pvm8kmuLxEhEJD+8R/NZQpjAThgyZIl6tGjhyoqKrR69WotX75cPXv2dLpZtiOcIPn95jfmacTjxklFRdG9Nzy0s2qVOYEbACRQZWWlLrnkEhUWFio3N9ey7QaDQYVCIcu2ZzXCCZJbKNRylk5nCmGPN3KkOWFbU5M5gRsA1zMMqa7OmVu0l+R6/fXXdckll6hnz57Kzc3VFVdcocrKSkmSz+fTxo0bdd9998nn82ncuHGaOXOmqqur5fP55PP5dO+990qSGhoaNH/+fJ122mnq0aOHSkpKtGbNmub9hHtc/vCHP+jMM89UIBBQVVWVRUfceqlONwCw1bp10v/7f+a09NdcE9s2Zs6UPvzQnMDtttvMeVAAuNaRI1JmpjP7rq2VevTo/Pp1dXWaO3euRowYodraWi1evFhXX321Nm3apL1792rChAkqLS3V/PnzlZGRofLyci1evFgVFRWSpMxvPuicOXO0detWrVixQvn5+Xr55ZdVWlqqjz/+WKeffrok6ciRI/r5z3+uX//618rNzdWpp55q+ee3CuEEyS1cK3LddeYF/WJx/fXSvHnmBG4ffWT2pACABa457o+mp556Snl5edq6dauGDx+u1NRUZWZmqm/fvpKknJwc+Xy+5seSVFVVpfLyclVVVSk/P1+SNH/+fL3++usqLy/XT3/6U0lSU1OTfvnLX2pke5fucBHCCZJXdXXL9POxDOmE9eolXX21ea2dp54inAAul5Hh3GWxov0baPv27Vq8eLE2bNiggwcPNteBVFVVafjw4Z3axscff6xgMKji4uKI5xsaGiLqVNLS0jRixIjoGugQwgmS1/PPS/X10rBh0ujR8W3rBz8wt/fMM9LDD0vdu1vTRgCW8/miG1px0uTJk1VYWKgnn3xS+fn5CoVCGj58uBobGzu9jdraWvn9fm3cuFH+46ZKyGw1vpWeni5fFxmWJpwgebUuhI33f8jx480J3HbtMs/cmTo1/vYB8LQvv/xSFRUVevLJJzV27FhJ0jvvvNPhe9LS0hQ8blLIUaNGKRgMav/+/c3b6eo4WwfJaetW6b33zAnXbrgh/u35/dL06eYyc54AsMApp5yi3NxcPfHEE9qxY4feeustzZ07t8P3DBw4ULW1tVq9erUOHjyoI0eOqLi4WNOmTVNZWZlWrlypnTt36v3339eyZcv06quvJujTWItwguQU7jW54gqpTx9rthmewO3NN82J3QAgDikpKVqxYoU2btyo4cOH66677tJDDz3U4Xsuuugi3XLLLZo6dary8vL04IMPSpLKy8tVVlamefPmaejQoZoyZYo++OADDRgwIBEfxXI+w4j2rOzEqampUU5Ojqqrq5Wdne10c9BVNDWZF+7bv98cgrnySuu2fdll0po10n33SffcY912AcTk6NGj2rlzpwYNGqTu1IIlVEfHPt7fb3pOkHxee80MJqeeKk2aZO22w2f9lJebE7wBACzn3XDi1HlmsF94SKesTOrWzdptX3ONOaHbzp3mBG8AAMt5M5x88YU0YoR0//3RzzUMd9u3T/rTn8zlmTOt335Ghjmhm0RhLADYxJvh5KWXzL98Fy+WfvhDs0YByeF3v5OCQenCC6Uzz7RnH+HQ8/vfmxO9AQAs5c1w8qMfSb/8pZSSYv71e8UVUk2N061CvAyjpTcjnhlhT6akxJzYrb7enJgNgONcfG5H0rLzmHsznEjSrbeaZ3JkZEhvvCGNHSt9/rnTrUI8NmyQPvlESk+3d5I0n68l/DC0Aziq2zd1ZUeOHHG4Jd4TnsX2+FlpreDtGWKvuEJau9a837zZHAp47TWzHgVdTzgofO97kt2nnt9wg7RwoRmItm61bwgJQIf8fr969uyp/fv3S5IyMjK6zBTtXVkoFNKBAweUkZGh1FTro4S3w4kknX++OZPod75j/tV9ySVmLcHllzvdMkTjyBFpxQpz2c4hnbA+fcxQu2qVeXbQSSZOAmCf8BV6wwEFiZGSkqIBAwbYEgaZhC3s66/NK8+uXSulpkq/+lVifuRgjd/+1jx1uKhI2r7drCey2x/+IF11lTmfyuefW3/aMoCoBINBNXGCQ8KkpaUppZ1/a+P9/abnJOyUU6T/+R8zkDz7rDRrlvTZZ9LSpfFfNA72Cw/pzJyZmGAimRO8nXqqOeHba6+ZQQWAY/x+vy31D0g87xbEtiUQME9F/fGPzcf3329e7C2KS1fDAZWV5pTyPl/LxfkSoVs3s7dGojAWACxEODmezyc98ID05JPmlWh/+1uptFQ6dMjplqE9y5eb99/+tlRQkNh9h+c8efVVcwI4AEDcCCft+eEPzZlGMzOlt982C2X/9jenW4XjBYPS00+by07UCJ15pnmWVzBo9roBAOJGOOlIaan05z9L+fnS//2f+SP04YdOtwqtrV4t7dpl1gw5VfPRes4T99aXA0CXQTg5mXPOMU81Hj7c7La/9FKz+BHuEK71mDZNcupy6VOnmhO/ffKJOe8JACAuhJPOKCiQ3nlHmjBBqquTrrzSPNUYzvrqK+nll81lOy7y11nZ2ebEbxKFsQBggYSEk8cff1wDBw5U9+7dVVJSovfffz8Ru7VWTo5Z9DhjhllfcMst0qJFUijkdMu869lnzTOpRo6URo1yti3hoZ0VK8wACwCIme3h5Pnnn9fcuXO1ZMkSffjhhxo5cqQmTpzYNWfyS0sz/zJeutR8/LOfmcMJDQ3OtsurysvN+x/8wPm5aC691JwA7vBhaeVKZ9sCAF2c7TPElpSU6IILLtAvfvELSeZ8/AUFBbrtttu0cOHCDt9r1wyxu3aZJ+Icr63ft3afW/8X6Te/lUJBacjp8o0psax9VvH166vUYcXy+81Jb4+/RfO8YUjHjpmdRseOnXjr1PNNho599LFUfSj+D1d3RMbKlZI/VcbPH5TRI1OS2c7wN/r45Y5ebz5mvpb71sttPXfC8muvyfeHV6SCAfKNuzT+zwgACdB/SLomLb7A0m3G+/ttazhpbGxURkaGfv/732vKlCnNz0+fPl2HDh3SqlWrItZvaGhQQ6teiJqaGhUUFFgeTt54Q5o40bLNAQDQZU3M/ateP3i+pdt09fT1Bw8eVDAYVJ8+fSKe79Onj7Zt23bC+suWLdPS8JCJjU49VbrmmpbHx8ezqB4frpHx6Xaza8BNDhxUKBhS8MKLdSyr1wk9G231dLS3TlOTOSP88T0qbfWwdLjOnir5t2ySL5BmnvobL79fvjPOkC/L7DU5ac9Gq+W2Xuuod+VkPS/Nyzt3yuiKQ5YAPGvU0Hqnm3ACV11bZ9GiRZo7d27z43DPidXOOce88LA1siWdZ9XGrHPBBdJf/yr9+I/m1XPd4MEV0oIF0tSylonTks6gb24AgFjZGk569+4tv9+vL774IuL5L774ovkS160FAgEFAgE7m+QdPXua919/7WgzIoTbEm4bAABtsPVsnbS0NJ133nlavXp183OhUEirV6/WmDFj7Nw1wsMmbgwnVgzpAACSlu3DOnPnztX06dN1/vnna/To0Xr00UdVV1enmU5OmuUF4QDgpgsWhttCOAEAdMD2cDJ16lQdOHBAixcv1r59+3TOOefo9ddfP6FIFhaj5wQA0EUlpCB2zpw5mjNnTiJ2hTDCCQCgi+LaOsmKglgAQBdFOElW1JwAALoowkmyctuwjmEwrAMA6BTCSbJyWziprTWnnJUIJwCADhFOkpXbak7C7ejWTUpPd7YtAABXI5wkq3DvRF2deXEcp7Ue0mnrUs8AAHyDcJKsWp8R44aiWIphAQCdRDhJVn6/FL5MtRuGdiiGBQB0EuEkmbmp7oQ5TgAAnUQ4SWZuOmOHnhMAQCcRTpKZmyZio+YEANBJhJNkRs8JAKALIpwkMzfWnBBOAAAnQThJZm7sOaEgFgBwEoSTZEbNCQCgCyKcJDM39pwQTgAAJ0E4SWaEEwBAF0Q4SWZuLIil5gQAcBKEk2TmlpqT+nqpocFcpucEAHAShJNk5pZhnXA4SkmRsrIcbQoAwP0IJ8ksHE6qq6VQyLl2tB7SSeErBwDoGL8UySxc32EYZkBxCvUmAIAoEE6SWSAgpaeby04O7XCmDgAgCoSTZOeGolgmYAMARIFwkuzcUBRLzwkAIAqEk2TnhrlOCCcAgCgQTpKdm3pOKIgFAHQC4STZUXMCAOhiCCfJzk09J4QTAEAnEE6SHeEEANDFEE6SnZsKYqk5AQB0AuEk2bmh5oSeEwBAFAgnyc4NwzoUxAIAokA4SXZOh5OmJqm2NrItAAB0gHCS7JyuOWk9nJST40wbAABdCuEk2bWuOTGMxO8/HIqysqTU1MTvHwDQ5RBOkl04nBw7JtXVJX7/1JsAAKJEOEl2GRlSt27mshNDO5ypAwCIEuEk2fl8ztadEE4AAFEinHiBk2fsMAEbACBKhBMvcHIiNmpOAABRIpx4gRt6TggnAIBOIpx4AeEEANCFEE68wA0FsdScAAA6iXDiBU7WnNBzAgCIEuHEC5wc1qEgFgAQJcKJF1BzAgDoQggnXuCGmhPCCQCgkwgnXuBUzUkoJFVXm8sUxAIAOolw4gVODevU1LRcCZmeEwBAJxFOvMCpcBLeX3q6FAgkdt8AgC6LcOIF4SGVo0fNW6JQbwIAiAHhxAuys82rE0uJrTthAjYAQAwIJ16QkuLMGTvMcQIAiAHhxCucqDthWAcAEAPCiVc40XNCOAEAxIBw4hVO9pxQcwIAiALhxCucmIiNnhMAQAwIJ17hRM8JBbEAgBgQTryCglgAQBdBOPEKCmIBAF0E4cQrnKw5oSAWABAFwolXUHMCAOgiCCdekehwYhgM6wAAYkI48YpE15zU1UnHjpnLhBMAQBQIJ16R6JqTcAhKTZUyMhKzTwBAUiCceEU4nBw+3NKjYafWQzrhKyIDANAJhBOvaH3GTCJ6TyiGBQDEiHDiFampUmamuZyIuhOKYQEAMSKceEkiz9hhjhMAQIwIJ16SyKJYek4AADGyLZz85Cc/0UUXXaSMjAz15K9nd0hkzwk1JwCAGNkWThobG3Xttdfq1ltvtWsXiJYTwzqEEwBAlFLt2vDSpUslScuXL7drF4hWIidiI5wAAGJkWziJRUNDgxoaGpof19TUONiaJOREzQlDegCAKLmqIHbZsmXKyclpvhUUFDjdpORCzQkAoAuIKpwsXLhQPp+vw9u2bdtibsyiRYtUXV3dfNu1a1fM20IbqDkBAHQBUQ3rzJs3TzNmzOhwnaKiopgbEwgEFAgEYn4/ToKaEwBAFxBVOMnLy1NeXp5dbYHdqDkBAHQBthXEVlVV6auvvlJVVZWCwaA2bdokSRoyZIgyw9OoI7ESNaxz9Kh5a71PAAA6ybZwsnjxYj399NPNj0eNGiVJevvttzVu3Di7douOJCqchHtmfD4pO9vefQEAko5tZ+ssX75chmGccCOYOCg8xHLokBQK2bef1kM6Ka46IQwA0AXwy+El4Z4Tw5AOH7ZvP9SbAADiQDjxku7dzZtk79AOZ+oAAOJAOPGaRNSdMAEbACAOhBOvScRcJ/ScAADiQDjxmkT0nBBOAABxIJx4TSImYqMgFgAQB8KJ11BzAgBwOcKJ1zCsAwBwOcKJ11AQCwBwOcKJ11BzAgBwOcKJ1zCsAwBwOcKJ11AQCwBwOcKJ19hdc3LsWMt1ewgnAIAYEE68xu6ak9bbpeYEABADwonXtB7WMQzrtx/ukcnMlFJTrd8+ACDpEU68JhxOmpqkI0es3z71JgCAOBFOvKZHD8nvN5ftqDvhTB0AQJwIJ17j89l7xg7hBAAQJ8KJF9lZFMsEbACAOBFOvMjOnhNqTgAAcSKceBHDOgAAFyOceJGdE7ERTgAAcSKceBE1JwAAFyOceBHDOgAAFyOceBEFsQAAFyOceBE1JwAAFyOceFEiak4IJwCAGBFOvMiuYZ1QqCXwUBALAIgR4cSL7Aonhw+3XOmYnhMAQIwIJ15kV81JeHvdu5s3AABiQDjxonCvRn291NBg3XapNwEAWIBw4kU5OebViSVri2KZgA0AYAHCiRelpJgBRbJ2aIc5TgAAFiCceJUdRbEM6wAALEA48So7imIJJwAACxBOvMqOidioOQEAWIBw4lUM6wAAXIpw4lV2hBMKYgEAFiCceBU1JwAAlyKceJWdNSeEEwBAHAgnXmVnzQkFsQCAOBBOvIqaEwCASxFOvMrqmhPDYFgHAGAJwolXWV1zcuSI1NQUuW0AAGJAOPEqq4d1wtvx+6UePazZJgDAkwgnXhUOJzU1UjAY//Za15uEr3gMAEAMCCde1fqMGiuGdqg3AQBYhHDiVd26tQy/WDG0QzgBAFiEcOJlVhbFMscJAMAihBMvs7Iolp4TAIBFCCdeZmU4YQI2AIBFCCdeZuVEbPScAAAsQjjxMjtqTggnAIA4EU68zI6aEwpiAQBxIpx4GTUnAAAXIpx4GTUnAAAXIpx4GTUnAAAXIpx4GTUnAAAXIpx4mVXhpKFBqq+P3CYAADEinHiZVTUn4WEhn0/KyYlvWwAAzyOceFnrmhPDiH074XCTkyOl8JUCAMSHXxIvC4eTUEg6fDj27VAMCwCwEOHEy9LTpUDAXI5naIdiWACAhQgnXmdFUSwTsAEALEQ48TorimIZ1gEAWIhw4nVWTMRGOAEAWIhw4nVWDOtQcwIAsBDhxOuoOQEAuAzhxOuoOQEAuAzhxOuoOQEAuAzhxOuoOQEAuIxt4eSzzz7TrFmzNGjQIKWnp2vw4MFasmSJGhsb7dolYmFlOKHnBABggVS7Nrxt2zaFQiH96le/0pAhQ7RlyxbdeOONqqur08MPP2zXbhEtK2pOKIgFAFjItnBSWlqq0tLS5sdFRUWqqKjQf/zHfxBO3CTempNgUKqpidwWAABxsC2ctKW6ulq9evVq9/WGhgY1NDQ0P64J/+jBPvEO67QONdScAAAskLCC2B07duixxx7TzTff3O46y5YtU05OTvOtoKAgUc3zrtbhxDCif3841PToIXXrZl27AACeFXU4WbhwoXw+X4e3bdu2Rbxn9+7dKi0t1bXXXqsbb7yx3W0vWrRI1dXVzbddu3ZF/4kQnXBvR2OjVF8f/fupNwEAWCzqYZ158+ZpxowZHa5TVFTUvLxnzx5ddtlluuiii/TEE090+L5AIKBAIBBtkxCPrCzJ7zdrR77+WsrIiO79nKkDALBY1OEkLy9PeXl5nVp39+7duuyyy3TeeeepvLxcKSlMq+I6Pp/Ze/Lll2YvyGmnRfd+wgkAwGK2FcTu3r1b48aNU2FhoR5++GEdOHCg+bW+ffvatVvE4pRTzHASS1EsE7ABACxmWzh58803tWPHDu3YsUP9+/ePeM2IpfAS9onnjB1qTgAAFrNtnGXGjBkyDKPNG1wmnonYGNYBAFiMIhDENxEb4QQAYDHCCeIb1qHmBABgMcIJrAkn9JwAACxCOEF8NScUxAIALEY4ATUnAABXIZyAYR0AgKsQThB7OAmFWnpbKIgFAFiEcILYa05qa82AItFzAgCwDOEEsdechMNMICClp1vaJACAdxFO0BJO6uqkpqbOv496EwCADQgnkHJyWpajGdphAjYAgA0IJ5D8/paAEk04YY4TAIANCCcwxVIUy7AOAMAGhBOYYimKJZwAAGxAOIEplrlOqDkBANiAcAJTPOGEnhMAgIUIJzDFUnNCQSwAwAaEE5ioOQEAuAThBCaGdQAALkE4gYmCWACASxBOYKLmBADgEoQTmKKtOTEMhnUAALYgnMAU7bBOfb3U2Bj5XgAALEA4gSnacBJez++XMjPtaRMAwJMIJzCFw0l1tRQMnnz98PBPz56Sz2dXqwAAHkQ4gan1GTfV1Sdfn3oTAIBNCCcwpaVJGRnmcmeKYgknAACbEE7QIpq6E8IJAMAmhBO0iCWcMAEbAMBihBO0iGYiNiZgAwDYhHCCFtFMxMawDgDAJoQTtKDmBADgAoQTtKDmBADgAoQTtKDmBADgAoQTtKDmBADgAoQTtKDmBADgAoQTtKDmBADgAoQTtOhszUljo3TkiLlMzwkAwGKEE7TobM1J69dzcuxqDQDAowgnaNF6WMcw2l8v3LOSkyP5/fa3CwDgKYQTtAiHk2BQqq1tfz2KYQEANiKcoEV6upSWZi53VHdCMSwAwEaEE7Tw+TpXFMsEbAAAGxFOEKkzRbEM6wAAbEQ4QaTOzHVCOAEA2IhwgkjRhBNqTgAANiCcIBI1JwAAhxFOEImaEwCAwwgniETNCQDAYYQTRKLmBADgMMIJIlFzAgBwGOEEkag5AQA4jHCCSCcb1gkGperqyHUBALAQ4QSRThZOwsFEouYEAGALwgkinSychJ/PyGi5SCAAABYinCBSuDekoUGqrz/xdYphAQA2I5wgUlaWlPLN16KtoliKYQEANiOcIFJKSsenExNOAAA2I5zgRB3VnTABGwDAZoQTnKijnhNqTgAANiOc4EQdTcTGsA4AwGaEE5yoM8M6hBMAgE0IJzgRNScAAAcRTnAiztYBADiIcIITdVRzQkEsAMBmhBOciJoTAICDCCc4EeEEAOAgwglO1F44MYyWYR0KYgEANiGc4ETh4HF8zUltrRQMmsv0nAAAbEI4wYna6zkJP05Lk9LTE9smAIBn2BpOrrzySg0YMEDdu3dXv379dMMNN2jPnj127hJWCIeT2lqpqanl+db1Jj5f4tsFAPAEW8PJZZddphdeeEEVFRV66aWXVFlZqe9973t27hJWyMlpWW49tMMEbACABEi1c+N33XVX83JhYaEWLlyoKVOmqKmpSd26dbNz14hHaqqUlSUdPmwGkrw883nmOAEAJEDCak6++uorPfPMM7rooosIJl1BWxOxcRoxACABbA8nCxYsUI8ePZSbm6uqqiqtWrWq3XUbGhpUU1MTcYND2iqKJZwAABIg6nCycOFC+Xy+Dm/btm1rXv/uu+/WRx99pDfeeEN+v19lZWUyDKPNbS9btkw5OTnNt4KCgtg/GeLTUTih5gQAYKOoa07mzZunGTNmdLhOUVFR83Lv3r3Vu3dvFRcXa9iwYSooKNB7772nMWPGnPC+RYsWae7cuc2Pa2pqCChOaevif/ScAAASIOpwkpeXp7xwgWSUQqGQJHP4pi2BQECBQCCmbcNibdWcUBALAEgA287W2bBhgz744ANdcsklOuWUU1RZWal77rlHgwcPbrPXBC5DzQkAwCG2FcRmZGRo5cqVGj9+vIYOHapZs2ZpxIgRWrt2Lb0jXQHhBADgENt6Ts4++2y99dZbdm0eduuo5oSCWACAjbi2DtpGzQkAwCGEE7SNYR0AgEMIJ2jb8eGkvl4Kn2VFOAEA2IhwgrYdH07C9ykpUmamM20CAHgC4QRtCxe9VldLoVBLvUnPnmZAAQDAJvzKoG3hnhPDkGpqqDcBACQM4QRtCwSk9HRz+euvCScAgIQhnKB9retOCCcAgAQhnKB9rSdiYwI2AECCEE7QvtYTsTEBGwAgQQgnaB/DOgAABxBO0D7CCQDAAYQTtI+aEwCAAwgnaB81JwAABxBO0D6GdQAADiCcoH2EEwCAAwgnaF9b4YSaEwCAzQgnaF84iBw4INXVmcv0nAAAbEY4QfvCQWTXrpbn6DkBANiMcIL2hcPJsWPmfXa25Pc71x4AgCcQTtC+44dwGNIBACQA4QTty8iQUlNbHjOkAwBIAMIJ2ufzRfaW0HMCAEgAwgk6RjgBACQY4QQdI5wAABKMcIKOta4zoeYEAJAAhBN0jJ4TAECCEU7QMcIJACDBCCfoGOEEAJBghBN0jJoTAECCEU7QMXpOAAAJRjhBxwgnAIAEI5ygY4QTAECCEU7QsdaBhJoTAEACpJ58FXhav37mNXZyc6VAwOnWAAA8gHCCjvXtK734opSX53RLAAAeQTjByV1zjdMtAAB4CDUnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVQgnAADAVVx9VWLDMCRJNTU1DrcEAAB0Vvh3O/w7Hi1Xh5PDhw9LkgoKChxuCQAAiNbhw4eVk5MT9ft8RqyxJgFCoZD27NmjrKws+Xw+S7ddU1OjgoIC7dq1S9nZ2ZZuG+3juDuD4+4MjrszOO6Jd/wxNwxDhw8fVn5+vlJSoq8gcXXPSUpKivr372/rPrKzs/nyOoDj7gyOuzM47s7guCde62MeS49JGAWxAADAVQgnAADAVTwbTgKBgJYsWaJAIOB0UzyF4+4MjrszOO7O4LgnntXH3NUFsQAAwHs823MCAADciXACAABchXACAABchXACAABcxZPh5PHHH9fAgQPVvXt3lZSU6P3333e6SUnt3nvvlc/ni7idccYZTjcr6axbt06TJ09Wfn6+fD6fXnnllYjXDcPQ4sWL1a9fP6Wnp2vChAnavn27M41NIic77jNmzDjh+19aWupMY5PIsmXLdMEFFygrK0unnnqqpkyZooqKioh1jh49qtmzZys3N1eZmZm65ppr9MUXXzjU4uTQmeM+bty4E77zt9xyS1T78Vw4ef755zV37lwtWbJEH374oUaOHKmJEydq//79TjctqZ111lnau3dv8+2dd95xuklJp66uTiNHjtTjjz/e5usPPvig/v3f/13/+Z//qQ0bNqhHjx6aOHGijh49muCWJpeTHXdJKi0tjfj+P/fccwlsYXJau3atZs+erffee09vvvmmmpqadPnll6uurq55nbvuukt//OMf9eKLL2rt2rXas2ePvvvd7zrY6q6vM8ddkm688caI7/yDDz4Y3Y4Mjxk9erQxe/bs5sfBYNDIz883li1b5mCrktuSJUuMkSNHOt0MT5FkvPzyy82PQ6GQ0bdvX+Ohhx5qfu7QoUNGIBAwnnvuOQdamJyOP+6GYRjTp083rrrqKkfa4yX79+83JBlr1641DMP8fnfr1s148cUXm9f55JNPDEnG+vXrnWpm0jn+uBuGYXzrW98y7rjjjri266mek8bGRm3cuFETJkxofi4lJUUTJkzQ+vXrHWxZ8tu+fbvy8/NVVFSkadOmqaqqyukmecrOnTu1b9++iO9+Tk6OSkpK+O4nwJo1a3Tqqadq6NChuvXWW/Xll1863aSkU11dLUnq1auXJGnjxo1qamqK+M6fccYZGjBgAN95Cx1/3MOeeeYZ9e7dW8OHD9eiRYt05MiRqLbr6gv/We3gwYMKBoPq06dPxPN9+vTRtm3bHGpV8ispKdHy5cs1dOhQ7d27V0uXLtXYsWO1ZcsWZWVlOd08T9i3b58ktfndD78Ge5SWluq73/2uBg0apMrKSv3zP/+zJk2apPXr18vv9zvdvKQQCoV055136uKLL9bw4cMlmd/5tLQ09ezZM2JdvvPWaeu4S9L111+vwsJC5efna/PmzVqwYIEqKiq0cuXKTm/bU+EEzpg0aVLz8ogRI1RSUqLCwkK98MILmjVrloMtA+z3/e9/v3n57LPP1ogRIzR48GCtWbNG48ePd7BlyWP27NnasmULtWwJ1t5xv+mmm5qXzz77bPXr10/jx49XZWWlBg8e3Klte2pYp3fv3vL7/SdUa3/xxRfq27evQ63ynp49e6q4uFg7duxwuimeEf5+8913XlFRkXr37s333yJz5szRn/70J7399tvq379/8/N9+/ZVY2OjDh06FLE+33lrtHfc21JSUiJJUX3nPRVO0tLSdN5552n16tXNz4VCIa1evVpjxoxxsGXeUltbq8rKSvXr18/ppnjGoEGD1Ldv34jvfk1NjTZs2MB3P8E+//xzffnll3z/42QYhubMmaOXX35Zb731lgYNGhTx+nnnnadu3bpFfOcrKipUVVXFdz4OJzvubdm0aZMkRfWd99ywzty5czV9+nSdf/75Gj16tB599FHV1dVp5syZTjctac2fP1+TJ09WYWGh9uzZoyVLlsjv9+u6665zumlJpba2NuIvk507d2rTpk3q1auXBgwYoDvvvFMPPPCATj/9dA0aNEj33HOP8vPzNWXKFOcanQQ6Ou69evXS0qVLdc0116hv376qrKzUP/3TP2nIkCGaOHGig63u+mbPnq1nn31Wq1atUlZWVnMdSU5OjtLT05WTk6NZs2Zp7ty56tWrl7Kzs3XbbbdpzJgxuvDCCx1ufdd1suNeWVmpZ599Vt/5zneUm5urzZs366677tKll16qESNGdH5HcZ3r00U99thjxoABA4y0tDRj9OjRxnvvved0k5La1KlTjX79+hlpaWnGaaedZkydOtXYsWOH081KOm+//bYh6YTb9OnTDcMwTye+5557jD59+hiBQMAYP368UVFR4Wyjk0BHx/3IkSPG5ZdfbuTl5RndunUzCgsLjRtvvNHYt2+f083u8to65pKM8vLy5nXq6+uNH/3oR8Ypp5xiZGRkGFdffbWxd+9e5xqdBE523KuqqoxLL73U6NWrlxEIBIwhQ4YYd999t1FdXR3Vfnzf7AwAAMAVPFVzAgAA3I9wAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXIVwAgAAXOX/A8o4cLHLm76gAAAAAElFTkSuQmCC\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(orb_bad[:,2], 'r', label='before')\n", + "plt.plot(orb_to_correct[:,2], 'b', label='after')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(all_corr_vals, 'r', label='before')\n", + "plt.plot(at.get_value_refpts(ring_err, 'Corr*', 'KickAngle', 1), 'b', label='after')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MATCHING" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So we want to do some matching! The final piece of the introductory puzzle. Lets some back to our arc cell. Then lets ruin it a bit for fun in order to give us something to match back to." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arc.plot_beta()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can put some errors to make it a bit messy, then rematch to these values. However, we can use transfer line mode to speed up the matching and use only half of the cell as it is symmetric. First we need to save the initial optics, which we can use as input into the matching" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "ld0, bd, ld = at.get_optics(arc)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "rec.array(([-2.46666011e-15, -7.38098906e-15], [24.58333148, 16.86095871], [0., 0.], [[[2.45833315e+01, 2.46666011e-15, 0.00000000e+00, 0.00000000e+00], [2.46666011e-15, 4.06779692e-02, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]], [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 1.68609587e+01, 7.38098906e-15], [0.00000000e+00, 0.00000000e+00, 7.38098906e-15, 5.93086086e-02]]], [[4.95815807e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [4.97495253e-16, 2.01687801e-01, 0.00000000e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 4.10620977e+00, 0.00000000e+00], [0.00000000e+00, 0.00000000e+00, 1.79751875e-15, 2.43533588e-01]], [-1.76362232e-06, 3.02779028e-18, 0.00000000e+00, 0.00000000e+00], [0., 0., 0., 0., 0., 0.], [[ 0.17496079, -24.20414349, 0. , 0. ], [ 0.04005053, 0.17496079, 0. , 0. ], [ 0. , 0. , 0.57269249, 13.82211287], [ 0. , 0. , -0.04861943, 0.57269249]], 23.625),\n", + " dtype=[('alpha', '<f8', (2,)), ('beta', '<f8', (2,)), ('mu', '<f8', (2,)), ('R', '<f8', (2, 4, 4)), ('A', '<f8', (4, 4)), ('dispersion', '<f8', (4,)), ('closed_orbit', '<f8', (6,)), ('M', '<f8', (4, 4)), ('s_pos', '<f8')])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ld0" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.76362232e-06 3.02779028e-18 0.00000000e+00 0.00000000e+00]\n", + "[-1.76362232e-06 3.02779028e-18 0.00000000e+00 0.00000000e+00]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "half_arc = arc[:at.get_uint32_index(arc, 'BPM_CellCenter')[0]]\n", + "print(ld0.dispersion)\n", + "#ld0.dispersion[0] = 1e-1\n", + "print(ld0.dispersion)\n", + "\n", + "#This uses plot_beta in transfer_line mode. When you provide twiss_in, you set\n", + "# the initial optics functions and then progress them in one pass through your lattice\n", + "arc.plot_beta(twiss_in=ld0)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Lattice([Drift('DR_01', 2.25), Quadrupole('QF1', 0.75, 0.38041), Drift('DR_02', 0.75), Quadrupole('QD2', 0.75, -0.2708), Drift('DR_03', 0.75), Dipole('Bend', 3.0, 0.12566370614359174, 0.0), Drift('DR_04', 0.1875), Quadrupole('QD3', 0.75, -0.33319), Drift('DR_05', 0.1875), Sextupole('SD', 0.1875, -0.1), Drift('DR_06', 0.5625), Quadrupole('QF4', 0.75, 0.4588), Drift('DR_07', 0.1875), Sextupole('SF', 0.75, 0.1)], name='', energy=3000000000.0, particle=Particle('relativistic'), periodicity=25, beam_current=0.0, nbunch=1)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "half_arc" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "quad_refs = at.get_uint32_index(half_arc, at.Quadrupole)\n", + "sext_refs = at.get_uint32_index(half_arc, at.Sextupole)\n", + "for quad_ind in quad_refs: \n", + " half_arc[quad_ind].K *= 1 - random.randint(-50,50)/100\n", + " \n", + "for sext_ind in sext_refs: \n", + " half_arc[sext_ind].H *= 1 - random.randint(-50,50)/100" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/linear.py:128: AtWarning: Unstable ring\n", + " warnings.warn(AtWarning('Unstable ring'))\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "half_arc.plot_beta(twiss_in=ld0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have a messed up lattice, some initial optics parameters, and a rough idea on what we want it to look like again. So lets try and match it.\n", + "\n", + "We must define our Constraints (or Goals) and our Variables.\n", + "\n", + "Possible Constraint containers:\n", + "\n", + "Constraints - Generic container for user defined functions<br>\n", + "ElementConstraints - Constraints related to attributes of lattice elements <br>\n", + "EnvelopeConstraints - Constraints for values that can be found with envelope_parameters <br>\n", + "LinoptConstraints - Constraints for values that can be found with linopt output <br>\n", + "OrbitConstraints - Constraints relating to the orbit\n", + "\n", + "Possible Variable containers:\n", + "\n", + "Variable - Generic container for user defined variables <br>\n", + "ElementVariable - Variable related to attributes of lattice elements <br> \n", + "\n", + "We can start with some simple linear optics constraints, which we can recover using the quadrupoles and sextupoles strengths" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mVariable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msetfun\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Callable'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgetfun\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Callable'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'str'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'tuple[float, float]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfun_args\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'tuple'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfun_kwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "A :py:class:`Variable` is a scalar value acting on a lattice through the\n", + "user-defined functions setfun and getfun\n", + "\n", + "Parameters:\n", + " setfun: User-defined function for setting the Variable. Called as:\n", + "\n", + " :code:`setfun(ring, value, *args, **kwargs)`\n", + "\n", + " where :code:`value` is the scalar value to apply\n", + "\n", + " The positional and keyword parameters come from the\n", + " :py:class:`Variable` initialisation\n", + " getfun: User-defined function for retrieving the actual value of\n", + " the variable: Called as:\n", + "\n", + " :code:`value = getfun(ring, *args, **kwargs)`\n", + "\n", + " The positional and keyword parameters come from the\n", + " :py:class:`Variable` initialisation\n", + " name: Name of the Variable; Default: ``''``\n", + " bounds: Lower and upper bounds of the variable value\n", + " fun_args: Positional arguments transmitted to ``setfun`` and\n", + " ``getfun`` functions\n", + "\n", + "Keyword Args:\n", + " **fun_kwargs: Keyword arguments transmitted to ``setfun``and\n", + " ``getfun`` functions\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/matching/matching.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m ElementVariable\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.Variable?" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# First we initialise the constraint type by passing the ring and information about the setup\n", + "# These are the arguments that are passed to linopt when computing the optics\n", + "constr = at.LinoptConstraints(half_arc, dp=0.0, coupled=False, twiss_in=ld0)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "#Now we can add our optics constraints.\n", + "# Weights can also be applied here. See the help of constr.add. Also if phase advance is\n", + "# being used. UseInteger should be True. \n", + "constr.add('beta', 15, refpts=len(half_arc), index=0) #beta_x at end of half_cell = 15m\n", + "constr.add('beta', 10, refpts=len(half_arc), index=1) # beta_y at end of half_cell = 10m\n", + "constr.add('dispersion', 0.6, refpts=len(half_arc), index=0) # dispersion_x at end of half cell is 0.6m\n", + "constr.add('dispersion', 0., refpts=len(half_arc), index=1, weight=1/10000) # dispersion_x prime at end of half cell is 0\n", + "constr.add('alpha', 0, refpts=len(half_arc), index=0, weight=1/1000) #alpha_x is 0 at end of cell\n", + "constr.add('alpha', 0, refpts=len(half_arc), index=1, weight=1/1000) #alpha_y is 0 at end of cell" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "all_constraints = [constr]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "all_quad_vars = ['QF1','QD2', 'QD3', 'QF4'] #Quadrupole names that we want to add\n", + "all_sext_vars = ['SF','SD'] #Sextupole names that we want to do\n", + "all_vars = []\n", + "\n", + "# For each quadrupole family, create an element variable for the strength \n", + "# and add it to our list of variables\n", + "for var in all_quad_vars:\n", + " all_vars.append(at.ElementVariable(at.get_uint32_index(half_arc, var), 'K'))\n", + " \n", + "# Similarly for sextupole\n", + "for var in all_sext_vars:\n", + " all_vars.append(at.ElementVariable(at.get_uint32_index(half_arc, var), 'H'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/physics/linear.py:128: AtWarning: Unstable ring\n", + " warnings.warn(AtWarning('Unstable ring'))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "6 constraints, 6 variables, using method lm\n", + "\n", + "`ftol` termination condition is satisfied.\n", + "Function evaluations 343, initial cost 2.9883e+07, final cost 4.7169e+01, first-order optimality 4.05e+01.\n", + "\n", + " Name Initial Final Target Residual\n", + "\n", + " beta_0 4.064947e+00 1.498141e+01 1.500000e+01 -1.858826e-02\n", + " beta_1 3.456260e+01 2.875505e-01 1.000000e+01 -9.712450e+00\n", + "dispersion_0 4.303153e-01 6.786836e-01 6.000000e-01 7.868357e-02\n", + "dispersion_1 -7.522413e-02 1.647641e-06 0.000000e+00 1.647641e-06\n", + " alpha_0 7.121116e-01 7.723382e-06 0.000000e+00 7.723382e-06\n", + " alpha_1 -7.661102e+00 7.427885e-07 0.000000e+00 7.427885e-07\n", + "\n", + " Name Initial Final Variation\n", + "\n", + " 3.766059e-01 3.594445e-01 -1.716137e-02\n", + " -3.141280e-01 -2.125521e-01 1.015759e-01\n", + " -1.765907e-01 -6.090772e-01 -4.324865e-01\n", + " 6.285560e-01 5.152221e-01 -1.133339e-01\n", + " 1.230000e-01 9.704217e+01 9.691917e+01\n", + " -1.170000e-01 -1.421718e+02 -1.420548e+02\n" + ] + } + ], + "source": [ + "new_lat = at.match(half_arc, all_vars, all_constraints)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(<AxesSubplot:title={'center':'Optical functions'}, xlabel='s [m]', ylabel='$\\\\beta$ [m]'>,\n", + " <AxesSubplot:ylabel='dispersion [m]'>,\n", + " <AxesSubplot:>)" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_lat.plot_beta(twiss_in=ld0)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mconstr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mparam\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[Refpts]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[Union[int, slice]]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'Optional[str]'\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Add a target to the LinoptConstraints container\n", + "\n", + "Parameters:\n", + " param: 2 possibilities:\n", + "\n", + " * parameter name: see :py:func:`.linopt6` for the\n", + " name of available parameters. In addition to local\n", + " optical parameters, ``'tunes'`` and ``'chroms'``\n", + " are allowed.\n", + " * user-supplied parameter evaluation function:\n", + "\n", + " :code:`value = param(lindata, tune, chrom)`\n", + "\n", + " ``lindata`` contains the optics parameters at all the\n", + " specified refpoints\n", + " ``value`` is the constrained parameter value\n", + " (scalar or array).\n", + " target: desired value.\n", + " refpts: location of the constraint. Several locations may be\n", + " given to apply the same constraint at several points.\n", + " index: index in the parameter array. If :py:obj:`None`,\n", + " the full array is used.\n", + " name: name of the constraint. If :py:obj:`None`, name is\n", + " generated from ``param`` and ``index``.\n", + "\n", + "Keyword Args:\n", + " weight: Weight factor: the residual is\n", + " :code:`(value-target)/weight`\n", + " bounds: lower and upper bounds. The parameter is constrained\n", + " in the interval [target-low_bound target+up_bound]\n", + " UseInteger: Match integer part of mu, much slower as the optics\n", + " calculation is done for all refpts\n", + "\n", + "The target, weight and bounds values must be broadcastable to the shape\n", + "of value.\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/matching/matching.py\n", + "\u001b[0;31mType:\u001b[0m method\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "constr.add?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dynamic Aperture" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have several build in functions for the computation of the DA and lifetime. " + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_acceptance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mring\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice_object\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLattice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mplanes\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnpoints\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mamplitudes\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mnturns\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1024\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrefpts\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlattice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRefptsCode\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0moffset\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgrid_mode\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macceptance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mboundary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGridMode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mGridMode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRADIAL\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0muse_mp\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mdivider\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mshift_zero\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1e-06\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mstart_method\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNoneType\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Computes the acceptance at ``repfts`` observation points\n", + "\n", + "Parameters:\n", + " ring: Lattice definition\n", + " planes: max. dimension 2, Plane(s) to scan for the acceptance.\n", + " Allowed values are: ``'x'``, ``'xp'``, ``'y'``,\n", + " ``'yp'``, ``'dp'``, ``'ct'``\n", + " npoints: (len(planes),) array: number of points in each\n", + " dimension\n", + " amplitudes: (len(planes),) array: set the search range:\n", + "\n", + " * :py:attr:`GridMode.CARTESIAN/RADIAL <.GridMode.RADIAL>`:\n", + " max. amplitude\n", + " * :py:attr:`.GridMode.RECURSIVE`: initial step\n", + " nturns: Number of turns for the tracking\n", + " refpts: Observation points. Default: start of the machine\n", + " dp: static momentum offset\n", + " offset: initial orbit. Default: closed orbit\n", + " bounds: defines the tracked range: range=bounds*amplitude.\n", + " It can be use to select quadrants. For example, default values are:\n", + "\n", + " * :py:attr:`.GridMode.CARTESIAN`: ((-1, 1), (0, 1))\n", + " * :py:attr:`GridMode.RADIAL/RECURSIVE <.GridMode.RADIAL>`: ((0, 1),\n", + " (:math:`\\pi`, 0))\n", + " grid_mode: defines the evaluation grid:\n", + "\n", + " * :py:attr:`.GridMode.CARTESIAN`: full [:math:`\\:x, y\\:`] grid\n", + " * :py:attr:`.GridMode.RADIAL`: full [:math:`\\:r, \\theta\\:`] grid\n", + " * :py:attr:`.GridMode.RECURSIVE`: radial recursive search\n", + " use_mp: Use python multiprocessing (:py:func:`.patpass`,\n", + " default use :py:func:`.lattice_pass`).\n", + " verbose: Print out some information\n", + " divider: Value of the divider used in\n", + " :py:attr:`.GridMode.RECURSIVE` boundary search\n", + " shift_zero: Epsilon offset applied on all 6 coordinates\n", + " start_method: Python multiprocessing start method. The default\n", + " ``None`` uses the python default that is considered safe.\n", + " Available parameters: ``'fork'``, ``'spawn'``, ``'forkserver'``.\n", + " The default for linux is ``'fork'``, the default for MacOS and\n", + " Windows is ``'spawn'``. ``'fork'`` may used for MacOS to speed-up\n", + " the calculation or to solve runtime errors, however it is\n", + " considered unsafe.\n", + "\n", + "Returns:\n", + " boundary: (2,n) array: 2D acceptance\n", + " survived: (2,n) array: Coordinates of surviving particles\n", + " tracked: (2,n) array: Coordinates of tracked particles\n", + "\n", + "In case of multiple refpts, return values are lists of arrays, with one\n", + "array per ref. point.\n", + "\n", + "Examples:\n", + "\n", + " >>> bf,sf,gf = ring.get_acceptance(planes, npoints, amplitudes)\n", + " >>> plt.plot(*gf,'.')\n", + " >>> plt.plot(*sf,'.')\n", + " >>> plt.plot(*bf)\n", + " >>> plt.show()\n", + "\n", + ".. note::\n", + "\n", + " * When``use_mp=True`` all the available CPUs will be used.\n", + " This behavior can be changed by setting\n", + " ``at.DConstant.patpass_poolsize`` to the desired value\n", + "\u001b[0;31mFile:\u001b[0m /mnt/multipath-shares/machfs/carver/pyat_dev/at/pyat/at/acceptance/acceptance.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "at.get_acceptance?" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "56 cpu found for acceptance calculation\n", + "Single process acceptance calculation selected...\n", + "Consider use_mp=True for parallelized computations\n", + "The estimated load for grid mode is 121.0\n", + "The estimated load for recursive mode is 88.0\n", + "GridMode.RECURSIVE is recommended\n", + "\n", + "Running grid boundary search:\n", + "Element DR_01, obspt=0\n", + "The grid mode is GridMode.RADIAL\n", + "The planes are ['x' 'y']\n", + "Number of steps are [11 11]\n", + "The maximum amplitudes are [0.12 0.06]\n", + "The maximum boundaries are ((1e-06, 1.0), (3.141592653589793, 0.0))\n", + "The initial offset is [ 1.41249135e-08 -6.35644289e-08 0.00000000e+00 0.00000000e+00\n", + " -3.86596572e-05 1.51902323e-06] with dp=None\n", + "Calculation took 97.75581359863281\n" + ] + } + ], + "source": [ + "ring.enable_6d()\n", + "bound, surv, track = at.get_acceptance(ring, ('x','y'), (11,11), (120e-3,60e-3), nturns=4000)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(*bound,marker='.', color='r')\n", + "plt.plot(*surv,marker='.',linestyle='None', color='b')\n", + "plt.plot(*track, color='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/esrfworkshop/3_SimpleOptics.py b/esrfworkshop/3_SimpleOptics.py new file mode 100644 index 0000000..f2b9adf --- /dev/null +++ b/esrfworkshop/3_SimpleOptics.py @@ -0,0 +1,497 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +import at +import at.plot +import numpy as np +import matplotlib.pyplot as plt + +ring = at.load_mat('./dba.mat', mat_key='RING') +arc = at.load_mat('./arc.mat', mat_key='ARC') + + +# ## Simple Tracking, Optics and Orbit + +# Now we will do some simple tracking through the lattice, and also show how to compute the optics and the orbit. +# +# First we need some particles to track, these must be in the format of ((6,N)) where 6 is the number of dimensions of AT (x,x',y,y',delta,ct) and N is the number of particles. This array can be manually created, but it is also desirable to generate a beam that is matched to the lattice. We can do this by generating the sigma correlation matrix using 'sigma_matrix'. The function will return a correlation matrix that can be used to generate a matched beam for the lattice you provide it. However there are some interesting things to be aware of, e.g. + +# In[2]: + + +ring.disable_6d() +#sig_mat = at.sigma_matrix(ring) + + +# We have give a lattice with radiation off and asked for a correlation matrix. However, the emittances of a lattice with no radiation are 0 in x and y. Therefore we must provide the emittances that we want. + +# In[3]: + + +sig_mat = at.sigma_matrix(ring, emitx=100e-12, emity=1e-12) +sig_mat + + +# Due to the fact that the rad is off. We only have correlations for x,x' and y,y' and nothing in the longitudinal plane. But we can switch rad on and compare the difference. Here you may notice that we don't need to give the emittances, that is because if radiation is on and no emittances are specified, it will take the result from envelope_parameters. If you want a beam with veritcal emittance, you can also still specify it. There are many different cases that can be seen in the help, but the exception that is raised if something is missing is quite explanatory. + +# In[4]: + + +sig_mat_rad_on = at.sigma_matrix(ring.radiation_on(copy=True), emity=10e-12) +sig_mat_rad_on + + +# Now that we have the matrix we can generate a beam using 'beam'. + +# In[5]: + + +nparts = 50000 +parts = at.beam(nparts, sig_mat_rad_on) +print(parts.shape) + + +# In[6]: + + +coord=5 +print(np.std(parts[coord,:])) +plt.hist(parts[coord,:], bins=100) + + +# Now let's do some tracking. but to make it easier we can start with only a single particle. + +# In[7]: + + +p_in = np.array([1e-3, 0., 0., 0., 0., 0.]) #must be floats not ints +p_in.shape + + +# We need to use the function lattice_pass. We must define the refpts in the lattice where we want to save the output. And we also want to specify nturns. There are two ways of tracking, either you use nturns=1 within a for loop, this has the benefit of allowing you to perform your own TbT analysis and save relevant parameters only. Or you can tracking for many turns, look at the full coordinates of the whole tracking, and perform the post processing later. + +# In[8]: + + +get_ipython().run_line_magic('pinfo', 'ring.track') + + +# In[9]: + + +# Method 1, the output of the tracking is a big array with shape (6, N, R, T) +# where 6 is the particle coordinate, N is the particle index, R is the element index, +# and T is the turn number +pout, *_ = ring.track(p_in, refpts=np.arange(len(ring)), nturns=200) + + +# In[10]: + + +tunex, tuney = ring.get_tune() +xdat = pout[0,0,0,:] +fig, (ax1,ax2) = plt.subplots(2,1) +ax1.plot(xdat) +ax2.plot(np.fft.rfftfreq(len(xdat)), np.abs(np.fft.rfft(xdat))) +ax2.axvline(tunex, color='r', linestyle='dashed') +plt.show() + + +# An important note, back to pointers again! If you prefer to use them in a turn by turn way, you can go like this + +# In[11]: + + +p_in = np.zeros((6,3)) +p_in[0,:] = np.array([1e-4,1e-3,3e-3]) +n_turns=200 +x_data = np.zeros((p_in.shape[1], n_turns)) +xp_data = np.zeros((p_in.shape[1], n_turns)) +for i in np.arange(n_turns): + _ = ring.track(p_in, nturns=1, in_place=True, refpts=None) #in_place means modify input particle, refpts=None stops the track function from generating big arrays for unneeded output + x_data[:, i] = p_in[0,:] + xp_data[:, i] = p_in[1,:] + + +# In[12]: + + +plt.plot(x_data[0,:], xp_data[0,:], linestyle='None', marker='.', label='1e-4') +plt.plot(x_data[1,:], xp_data[1,:], linestyle='None', marker='.', label='1e-3') +plt.plot(x_data[2,:], xp_data[2,:], linestyle='None', marker='.', label='3e-3') +plt.legend() +plt.xlabel('x [m]') +plt.ylabel('xp') + + +# The following section is very important. As we saw, we have the ability to enable or disable 6d motion. When computing the linear optics or the orbit, the 'get_optics' and 'find_orbit' functions will automatically select the most appropriate method to use out of the methods available. +# +# > at.linopt2 +# +# > at.linopt4 / at.find_orbit4 +# +# > at.linopt6 / at.find_orbit6 +# +# for 2, 4 and 6 dimensional tracking respectively. One can also specifically call other methods in order to speed up computation (for example if you are doing uncoupled matching, it is faster to call at.linopt2 rather than do the full 6d computation) + +# In[13]: + + +ring.disable_6d() +s_positions = ring.get_s_pos(refpts=np.arange(len(ring))) +orbit0_4, orbit_4 = ring.find_orbit(refpts=np.arange(len(ring))) +ring.enable_6d() +orbit0_6, orbit_6 = ring.find_orbit(refpts=np.arange(len(ring))) +print(orbit_4.shape) + + +# In[14]: + + +plt.plot(s_positions, orbit_4[:,0], label='find_orbit4') +plt.plot(s_positions, orbit_6[:,0], label='find_orbit6') +plt.legend() +plt.xlabel('s [m]') +plt.ylabel('x [m]') +plt.show() + + +# In[15]: + + +get_ipython().run_line_magic('pinfo', 'at.get_optics') + + +# In[16]: + + +ring.disable_6d() +ld0_4d, bd_4d, ld_4d = at.get_optics(ring, refpts=np.arange(len(ring)), method=at.linopt2) +ring.enable_6d() +ld0_6d, bd_6d, ld_6d = at.get_optics(ring, refpts=np.arange(len(ring))) +ld0_6db, bd_6db, ld_6db = at.get_optics(ring, refpts=np.arange(len(ring))) + + +# In[17]: + + +plt.plot(ld_4d.beta[:,1]) +plt.plot(ld_6d.beta[:,1]) +plt.show() +fig, ax = plt.subplots() +axb = ax.twinx() +ax.plot(s_positions, ld_6d.beta[:,1] - ld_4d.beta[:,1], color='r') +axb.plot(s_positions, orbit_6[:,0], label='find_orbit6', color='b') + +plt.show() + + +# In[18]: + + +get_ipython().run_line_magic('pinfo', 'at.find_orbit4') + + +# # Orbit Correction + +# By now we are basically experts. What we will now do is show how to use what we have learned and do some orbit correction. +# First we need to get the orbit response matrix. This is a big matrix showing the orbit response from each steerer action. + +# In[19]: + + +ring.disable_6d() +corrector_refpts = at.get_uint32_index(ring, 'Corr*') +bpm_refpts = at.get_uint32_index(ring, 'BPM*') + +orm = np.zeros((len(bpm_refpts), len(corrector_refpts))) + + +# In[20]: + + +kickang = 1e-6 +for ic, corrector_ind in enumerate(corrector_refpts): + #init_steer_value = ring[corrector_ind].KickAngle[1] + #_, ref_orbit = ring.find_orbit(refpts=bpm_refpts) + ring[corrector_ind].KickAngle[1] += kickang + _, pos_orbit = ring.find_orbit(refpts=bpm_refpts) + ring[corrector_ind].KickAngle[1] -= 2*kickang + _, neg_orbit = ring.find_orbit(refpts=bpm_refpts) + ring[corrector_ind].KickAngle[1] += kickang + orm[:, ic] = (pos_orbit[:,2] - neg_orbit[:,2])/kickang + + +# In[21]: + + +plt.pcolormesh(orm) +plt.xlabel('corrector #') +plt.ylabel('bpm #') + + +# Now we can put a bad orbit, we can do this by introducing a misalignment on a couple of quadrupoles. Possible functions for this are 'set_shift' and 'set_tilt' + +# In[22]: + + +ring_err = ring.deepcopy() +''' +at.set_shift? +quad_msk = at.get_bool_index(ring_err, at.Quadrupole) +shift_vals = np.zeros(quad_msk.shape[0]-1) +shift_vals[np.where(quad_msk)[0][0]] = 1e-6 +shift_vals[np.where(quad_msk)[0][3]] = 5e-6 +shift_vals[np.where(quad_msk)[0][4]] = -2e-6 +shift_vals[np.where(quad_msk)[0][9]] = 3e-6 +shift_vals[np.where(quad_msk)[0][11]] = 10e-6 +shift_vals[np.where(quad_msk)[0][17]] = 0.5e-6 +at.set_shift(ring_err, np.zeros(len(shift_vals)), shift_vals) +''' +all_corr_vals = at.get_value_refpts(ring_err, 'Corr*', 'KickAngle', 1) +all_corr_vals[0] = 2e-6 +all_corr_vals[4] = -3.5e-5 +all_corr_vals[7] = 6e-6 + +at.set_value_refpts(ring_err, 'Corr*', 'KickAngle', all_corr_vals, 1) + + +# In[23]: + + +orb0, orb_bad = ring_err.find_orbit(refpts=bpm_refpts) +plt.plot(orb_bad[:,2]) +plt.show() + + +# In[24]: + + +U,W,V = np.linalg.svd(orm, full_matrices=False) +Utran = np.transpose(U) +Winv = np.linalg.inv(np.diag(W)) +Vtran = np.transpose(V) + + +# In[25]: + + +niters = 10 +orb_to_correct = orb_bad +for it in np.arange(niters): + dk = np.dot(Vtran, np.dot(Winv, np.dot(Utran, orb_to_correct[:,2]))) + print(np.sum(dk)) + at.set_value_refpts(ring_err, 'Corr*', 'KickAngle', -dk, 1) + orb0, orb_to_correct = ring_err.find_orbit(refpts=bpm_refpts) + + +# In[26]: + + +plt.plot(orb_bad[:,2], 'r', label='before') +plt.plot(orb_to_correct[:,2], 'b', label='after') +plt.legend() +plt.show() + +plt.plot(all_corr_vals, 'r', label='before') +plt.plot(at.get_value_refpts(ring_err, 'Corr*', 'KickAngle', 1), 'b', label='after') +plt.legend() +plt.show() + + +# ### MATCHING + +# So we want to do some matching! The final piece of the introductory puzzle. Lets some back to our arc cell. Then lets ruin it a bit for fun in order to give us something to match back to. + +# In[27]: + + +arc.plot_beta() + + +# We can put some errors to make it a bit messy, then rematch to these values. However, we can use transfer line mode to speed up the matching and use only half of the cell as it is symmetric. First we need to save the initial optics, which we can use as input into the matching + +# In[28]: + + +ld0, bd, ld = at.get_optics(arc) + + +# In[29]: + + +ld0 + + +# In[30]: + + +half_arc = arc[:at.get_uint32_index(arc, 'BPM_CellCenter')[0]] +print(ld0.dispersion) +#ld0.dispersion[0] = 1e-1 +print(ld0.dispersion) + +#This uses plot_beta in transfer_line mode. When you provide twiss_in, you set +# the initial optics functions and then progress them in one pass through your lattice +arc.plot_beta(twiss_in=ld0) + + +# In[31]: + + +half_arc + + +# In[32]: + + +import random +quad_refs = at.get_uint32_index(half_arc, at.Quadrupole) +sext_refs = at.get_uint32_index(half_arc, at.Sextupole) +for quad_ind in quad_refs: + half_arc[quad_ind].K *= 1 - random.randint(-50,50)/100 + +for sext_ind in sext_refs: + half_arc[sext_ind].H *= 1 - random.randint(-50,50)/100 + + +# In[33]: + + +half_arc.plot_beta(twiss_in=ld0) + + +# Now we have a messed up lattice, some initial optics parameters, and a rough idea on what we want it to look like again. So lets try and match it. +# +# We must define our Constraints (or Goals) and our Variables. +# +# Possible Constraint containers: +# +# Constraints - Generic container for user defined functions<br> +# ElementConstraints - Constraints related to attributes of lattice elements <br> +# EnvelopeConstraints - Constraints for values that can be found with envelope_parameters <br> +# LinoptConstraints - Constraints for values that can be found with linopt output <br> +# OrbitConstraints - Constraints relating to the orbit +# +# Possible Variable containers: +# +# Variable - Generic container for user defined variables <br> +# ElementVariable - Variable related to attributes of lattice elements <br> +# +# We can start with some simple linear optics constraints, which we can recover using the quadrupoles and sextupoles strengths + +# In[34]: + + +get_ipython().run_line_magic('pinfo', 'at.Variable') + + +# In[35]: + + +# First we initialise the constraint type by passing the ring and information about the setup +# These are the arguments that are passed to linopt when computing the optics +constr = at.LinoptConstraints(half_arc, dp=0.0, coupled=False, twiss_in=ld0) + + +# In[36]: + + +#Now we can add our optics constraints. +# Weights can also be applied here. See the help of constr.add. Also if phase advance is +# being used. UseInteger should be True. +constr.add('beta', 15, refpts=len(half_arc), index=0) #beta_x at end of half_cell = 15m +constr.add('beta', 10, refpts=len(half_arc), index=1) # beta_y at end of half_cell = 10m +constr.add('dispersion', 0.6, refpts=len(half_arc), index=0) # dispersion_x at end of half cell is 0.6m +constr.add('dispersion', 0., refpts=len(half_arc), index=1, weight=1/10000) # dispersion_x prime at end of half cell is 0 +constr.add('alpha', 0, refpts=len(half_arc), index=0, weight=1/1000) #alpha_x is 0 at end of cell +constr.add('alpha', 0, refpts=len(half_arc), index=1, weight=1/1000) #alpha_y is 0 at end of cell + + +# In[37]: + + +all_constraints = [constr] + + +# In[38]: + + +all_quad_vars = ['QF1','QD2', 'QD3', 'QF4'] #Quadrupole names that we want to add +all_sext_vars = ['SF','SD'] #Sextupole names that we want to do +all_vars = [] + +# For each quadrupole family, create an element variable for the strength +# and add it to our list of variables +for var in all_quad_vars: + all_vars.append(at.ElementVariable(at.get_uint32_index(half_arc, var), 'K')) + +# Similarly for sextupole +for var in all_sext_vars: + all_vars.append(at.ElementVariable(at.get_uint32_index(half_arc, var), 'H')) + + +# In[39]: + + +new_lat = at.match(half_arc, all_vars, all_constraints) + + +# In[40]: + + +new_lat.plot_beta(twiss_in=ld0) + + +# In[41]: + + +get_ipython().run_line_magic('pinfo', 'constr.add') + + +# ## Dynamic Aperture + +# In[ ]: + + + + + +# We have several build in functions for the computation of the DA and lifetime. + +# In[42]: + + +get_ipython().run_line_magic('pinfo', 'at.get_acceptance') + + +# In[43]: + + +ring.enable_6d() +bound, surv, track = at.get_acceptance(ring, ('x','y'), (11,11), (120e-3,60e-3), nturns=4000) + + +# In[44]: + + +plt.plot(*bound,marker='.', color='r') +plt.plot(*surv,marker='.',linestyle='None', color='b') +plt.plot(*track, color='g') +plt.show() + + +# In[ ]: + + + + + +# In[ ]: + + + + diff --git a/esrfworkshop/PyAT_Installation.pdf b/esrfworkshop/PyAT_Installation.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9f10d3183157c0b8cc08ac3e36ad30c3c5bf0371 GIT binary patch literal 282486 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%0ATIWtukZ&jcxZ5BTbV1}fSsPITc}2juTe8MOam7i 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�`m?<<iqHl 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 literal 0 HcmV?d00001 diff --git a/esrfworkshop/arc.mat b/esrfworkshop/arc.mat new file mode 100644 index 0000000000000000000000000000000000000000..7ceb1515a1cbe75bf0f00731e42d2c7b1a65c4f4 GIT binary patch literal 18336 zcmeHP&2QsG6rX-96c*54&{iCf4=X@ufqwGQ12`WoRBXE0ra}lIRo-NpT5{~jaZvgP z@CU#Ru3V7dAK=tI!jS_K9N@qK_1H7wz<Xm)^WycU$xOPNx--($9>;Gy@6CI^`OSFT zN@4F#p=hnYxnxxedv6@L9=EEV6CDI$Yr|>>9k+MeDuvvMc*6?(4QsE<t-JNevR19- zwT<=FjpcP~Woc!VDWsY0$_pU2_#tCY!EpidOj6CYr2KMnZHCRU!fuJ-{U>w%`)5=4 zqrA-c(=|5Fo=>iI;kf0rcAOT+pBTHt{bqC+pR=md=~Q@h7&PEQ)d?fF?#1_2dFTcW zx9&zqj1{@l+Anp(koytax!?8cvVu*YhfTOcq>=~KCFgj+b}vDedd}lTNK((Z)Ytz; zaslPug)HUph)K#xU8UWgf#1-MGNHT;S<0uMi*nCFmh$*qEN?eJKTsI00!7jO*We~u z&nR}6_1*$`|IFx&g}f8(^VnMTLnmw|-65Z2!-;&(sO=3oIIa7I+ktMA_2}A7UH<e~ zuixIY_2lFJ(rEt&8qa@l{j+}xqxc>AD)l=o@49{yg3oDTCqlw{+GG0Nb&$b&Z$l>W zPNJQ}dMZ%UdT03`#vW}qmdm^QOUrOf%a0eYv!dT^sArh}XW6YBx(AUA){J(HtOwSU z$S;hEvohX2kSBH@fLUUBw$p8G`%x|8?GCFry}Mz9hak$Tfp_EwtpYhO;`zt;CrPPp z6Lueluh?Ip4(Yc!c5iE0v%gM6oO}fJ4(qR*1J7j)%e5%1fS$Z|)M|UY4yd&zdQZ=P zZVCU<jeDEuljXmN{nG!@7v)$5r)LTEupvvkj9bs^UzOkb?$h6uafr&(c4WoDv(Qed z59)&DdtIjycH7WHP=JK`ToxQ!N!qLK2eDt<P><}tEV~&TVr(KfR9-PS1iseit*0XH zssD|OA5fi0x;W$pr(gcE_v^7LE>n3MS~M)4@`gh=CsehY=sY%EICMHDA41)6T=^a{ z<wL27=itl}CYXK$NN~Y#;@Gq4N1@}_d0gD=xl!^1)Jgdh8(>g_9O|qjSkxeoN+TGy z`8*zlV?lqsoEI(D>*oc*TU2;d(QizYN4@mw&99GNe4xxbz%(N1*+VyOba`O>d>b^8 zc=e?4H@2p(Jz{xPzrHNIZw-v4=XXCpH0~PSC+4CTGyg2FYWA0ze_qu5^RFL1dF8*| z-;{YDm8UqG6;FBNed{^Hp~W$I-$k#3Ay1M?W&TOmZ*H(zRx3|t+)&|f)42}D9^#`} z{D-b5A`UIePRTgpxJ>P%THm+dVERcJm#DlAZIb*h3zxFicWS&Bk!3M4eq9!R^fu_L z$B+It{0MCL_}1swH2cf&ql@B4@1Okf<G-K(DdIt8otes?heLVeNAGCk&~(kya?g*p zbjOXn;n39cBV}Al_>uBBpT&=QuvjX27IJS)xMyGiGOnY_45wnhlJ5Qm8|snI%i?v& zf%@yWv2PcvmHiU;yb^5t!ME^wJSmnxuN`up1kDlekg=S#?}&~sS^7K;a#SBIR|4OS zf>7vT@Tu=((oV<=(Es9O@aZwn-=+$mF3bEaZ@el0`>V|SZ4hUtXI}%If6?(3c>|_L z@e`>JmAB#kVSFQR^S8XMBjuhSne}ZZ;}&BZl0B*Q=(xI=@0<1Q$;{s<9%s#W5St~B z$Nj2U#{K7cd+(Neeq`SNr*LU{_z``7Pvdb^enjPMh|jCUkMgz;$?W@##~U1r`s0q- z_X*}m;n!r=O;zv)+rpUH_nG3kV*NMo`#$rw&p!XW&wTGQ7^l<2`{?&NDmYB#Z9wF! z#QV&5hcQ1g-#-toADi!=V;n$+M%UHpK3v2@T+5M(e!r}OLsZ^|O0N<Q<>~)0{11^{ By%PWc literal 0 HcmV?d00001 diff --git a/esrfworkshop/dba.mat b/esrfworkshop/dba.mat new file mode 100644 index 0000000000000000000000000000000000000000..c2a13cc9f3999ad899ca83291a6bc6c15c7510d1 GIT binary patch literal 472424 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 literal 0 HcmV?d00001 -- GitLab