From b500a4a64b26e7c127e242594eed9bd02ae27515 Mon Sep 17 00:00:00 2001 From: Ilya Antonov Date: Mon, 1 Nov 2021 17:57:39 +0000 Subject: [PATCH] New simulations for thesis plots --- entrypoint_cuda.ipynb | 703 +++++++++++++++++++++++++++--------------- 1 file changed, 447 insertions(+), 256 deletions(-) diff --git a/entrypoint_cuda.ipynb b/entrypoint_cuda.ipynb index f09fb2f..68a6420 100644 --- a/entrypoint_cuda.ipynb +++ b/entrypoint_cuda.ipynb @@ -7,6 +7,22 @@ "https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Development for photon source" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NUMBER_OF" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -21,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -59,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -86,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -124,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -155,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -356,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -387,8 +403,56 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 7, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzcAAAJvCAYAAABGey/0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAewgAAHsIBbtB1PgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeZxkdX3v/9epnn1hhtlFhn33CwqC4GUR3LmKRuMNLrjiglturppoYoyguEazuUW5ivAzxjUaDbiwiKLGCwFFvoAjIjuzwDDMvnbX74+qcYrJ9HRP1+f06T71evKoB6eqvvU+3+7p6elPf+r7PUWz2USSJEmSxrtG1ROQJEmSpAgWN5IkSZJqweJGkiRJUi1Y3EiSJEmqBYsbSZIkSbVgcSNJkiSpFixuJEmSJNWCxY0kSZKkWrC4kSRJklQLFjeSJEmSasHiRpIkSVItWNxIkiRJqgWLG0mSJEm1YHEjSZIkqRYsbiRJkiTVgsWNJEmSpFqwuJEkSZJUCxY3kiRJkmrB4kaSJElSLVjcSJIkSaqFCWWGp5ROAJ4EnAA8DpgPzAMmAo8AtwE/Ar6Yc757mJmPAd4AnAUcAEwFlgLXAl/IOf8k9qOQJEmS6iWl9EXglR0PXZBzPr+a2cQpms1maeEppXXA9GEM3UzrE/qhIfKeD1wM7L2bYZ8F3pxz7h/2RCVJkqQekVI6E7h8p4drUdyU2rlpWwFcB9wE3AmsptW5OQB4DnAyMBn4YEppYs75fbsKSSmdAXwNmNR+6DLgO8B64DjgXGAWra5OE3hjOR+OJEmSND6llPai1QyA1s/Rw2lEjBtld24ScEvOedCTpJReAXwRKIBtwP455wd2GjMZ+A2tggjgrTnnT+405jDgx8Ci9kNPyzlfHfBhSJIkSbWQUvos8HrgXuDrwNvaT9Wic1PqhgK5ZbfVU875UuA/2ncnAM/exbDXsKOw+e7OhU0757fAmzseunCPJyxJkiTVVErpqcDr2nffBKytcDqlGCu7pd3ScbxoF8+/uOP473aT823grvbxk1NK+3c5L0mSJGncSylNAy6i9W6pr+ac/2OIl4xLY6W4OaTjeFnnEymlmcAp7btrae2Ktks55wHg+x0PnRk1QUmSJGkc+xBwEPAw8L8rnktpKi9uUkpnAS9o391Ea6OATkexY56/HMYuaNd3HB/d/QwlSZKk8Sul9D+At7TvviPnvLzK+ZRpNHZLAyCldBowp313ErAYeGb7Bq3NBM7bxSf78I7jO4dxqs4xhw86avB57jvEkEnAEbR2gXsQcMtpSZJUd320rlcIcHPOeXOVkxmplNIEdr0EokqLGMbPlDnn+0YSnlKaAnyBVrPgqpzzxSPJGS9GrbgBPgqcuIvHm7R2OXvvIBfgnN1x/NAwzrNykNcO170jeI0kSVKvOAH4r6onMUKLGL8/6xUjfN37aP3CfyOtS6bUWuVvSwPuB64Abh/k+Rkdx5uGkbex43jmSCclSZIkjWcppRPYsdXze3POd1Q5n9Ewap2bnPNJ249TStNpbSLwPODtwAeAt6WUXpxzvnK05jSIxUM8/1jgFwD/evFnmD9vbvdn3Lpx6DHD9PWXnByWdegHfh6WBTBr1pSwrAPnDafOHaYirsYfeOCGsCw2rIrLApiyV1jUj+4/KizrjNvfHpbVeGVcp/2nN8bujnny4RvCsm5bEfB9p+2I334oLKs49bywLID1k+I2vOzr6wvLmrLmtrCsDdP3+N3Tg5p680VhWQC37PWisKy0YOXQg4apecXHwrKK014blsWMx8RlAav6F4Zlzb6s+1/WP7i+n5f924N/uNt14Bgw647TaWyL+9lkTw1M2MTqg6/ZfvcEdtpUq1sppUm03o7WB9zI7nccro3RfFvaH+Sc1wM3ATellL4E/BTYB7gspXR8zvnmjuHrOo6H8xU4teN4j386Ger9jK3rkrbMnzeXRQsX7Okp/rst67vPaJtZbAvLmjNn/tCD9sDee08detAwLVoQVxCGFjeb4woIpmyNywKYGje32evifrheOD3u898X8fexbfbsyWFZAIvmx/09X9Ef93dz0V6TwrKK+XFfFwBrJ8f9cDdhQlxxM3Vy3DrcdTPiPsbpe08LywJYOivw62x+3AXDmzPifnQp5u0dlsVe8+KygAnb4r6fzZ0R9/XfVov1xo1tU+jbFvv3pgvLRrqmZjf+Gki0/rxeN4xNuWqh8rel5ZzvBN7VvjsJePdOQx7pOB7Od47Of10fGXSUJEmSelbRKCq/lSWl9Hh2/Hz9dznnG0s72RhTSedmF77XcXz6Ts8t6Tg+cBhZnWOWDDpKkiRJqqdXAROBAWBrSumvBxl3Wudxx7glOeevlzi/0oyV4qbz7WM794hvpfUH0wCOTSn1DdFWO6HjOAfNT5IkSTXS6CtoNMvrngyl2VfqubeHN4C/GuZrzmjfAP4dGJfFTeVvS2s7tOP4UYvUcs5rgZ+1784EThksJKXUAJ7V8dD3BhsrSZIkqV7GSuemc4udn+3i+a8Ap7aP307ruji78kfseFvaL3LOd4XMTpIkSbVSFOWuexnO+cuSc/4z4M+GGpdSOh94b/vuBTnn80ub1CgprXOTUjovpXRGSmnQP7mUUl9K6V3Amzoe/vQuhn4BuKd9fFZK6c27yDoU+FTHQ+8ZwbQlSZIkjVNldm5OAj4D3JtSugK4GVgBbAFm09qa7vnAAR2v+VDO+b91ZXLOm1JK5wKX01oc9cmU0rOB7wDrgeOA1wKz2i+5aAxcL0eSJEljVNHXoKhwhUbRN1ZWh9TLaLwtbTHwmiHGrAb+Muf8mcEG5JyvTCmdTauLMxt4bvu2s4uAN45wrpIkSZLGqTKLmz+ltdPCacCxwMG0rlMzkdaFOZcDvwZ+AHw957x6qMCc87dSSr+gVbycRavrMwVYSutCoJ/fVedHkiRJ6tRoVLxbWoXrfeqstOIm57wG+Fb7Fpm7FPib9k2SJEnSCLQ3EDi/4mmEGiu7pUmSJEmjp6+goMLuSbnXuelZrmSSJEmSVAt2biRJktRz6nydm15m50aSJElSLdi5kSRJUs9p9BU0KuyeNNwtrRQWN10Y+Mk/MDBrStc518z6s4DZtMw//+awrOPv+3BYFsC6S74WlrX54w+EZTUacQ3Mjfvu6tJLIzNhQl9YFsD3vvebwLStYUmNl/xDWNanP78kLOu8M9eGZQHQd0BY1DH7rArLYkHc95/frV4UlgUwZfLmsKx9i1vDsm58cP+wrH374v4u/X7Oq8OyAI697+/CsprLA3/ceMq5cVmT9gqL+qcvLgvLAnjrUReHZX19zke6zlgzYSXwv7ufjFQyixtJkiT1nKJBpbulFS4OKYWfVkmSJEm1YOdGkiRJPadoFJXuWOZuaeWwcyNJkiSpFuzcSJIkqec0GgWNZoW7pdm5KYWdG0mSJEm1YOdGkiRJPadoNCia1f2ev3C7tFL4WZUkSZJUC3ZuJEmS1Hv6CooK19zgmptS2LmRJEmSVAt2biRJktRzGkVR6Y5lDezclMHOjSRJkqRasHMjSZKknlP0FRQVdk+qPHed2bmRJEmSVAt2biRJktRzioadmzqycyNJkiSpFuzcSJIkqec0+qrdscwOQzksbrqw9Sl/w5aFC7vOOePhmwJmE2/lxI+E5s2ZtSgsa1N/Myzr4s//v7Cs8159WFjWNdevDcsCmLX39LCsJz4h7s+y+dDVYVlvOieFZTW3bQzLAlg7Yf+wrJn994Zl5YfmhGU9buM3wrIAbp78/LCsDVMODcs6du3FYVkDc98elxX4fRGAiSeFRTX2Ozksa93A7LCsX+flYVlvPfm7YVkA1/HGsKyTjprZdcZDD00NmIlUPosbSZIk9Zyi0aAoquufFM0GBP9OQnbEJEmSJNWExY0kSZKkWvBtaZIkSeo5RaOgKCrcCrpZQH9lp68tOzeSJEmSasHOjSRJknpO0VfQsHNTO3ZuJEmSJNWCnRtJkiT1nKJRUDQq7NwMVHfuOrNzI0mSJKkW7NxIkiSp5xSNBkWjwot42mMohZ9VSZIkSbVg50aSJEk9p9FX0KhwzU2VO7XVmZ0bSZIkSbVg50aSJEk9p2hQ7W5plZ253uzcSJIkSaoFOzeSJEnqOY1GQaOvwjU39m5KYXHThclbljNlc3/XOc1tmwJm0xa4peHGTdvCsgB47NFhUcuXrwvLesPzwqJobngoLOvkkw4JywLo++5bwrKKdeeEZa1Z8LSwrKt/9PuwrAMOmhOWBbDPori/T/eunBWWtfiTR4ZlXXrC98OyAF51dlzWT3+9Pixr1eQXh2WduObOsKy5cw8IywIots4Ly2o+cndY1rR7vhqW9eT9TgrLghMCs+DESWvCsn58W/c/q6xaFTcfqUwWN5IkSeo9fQ2KvipXaLg6pAwWN5IkSVINpZROAJ5Eq7X4OGA+MA+YCDwC3Ab8CPhizjmuxVohixtJkiT1nKJRVLtbWnNUzv0jYPogzy1o354C/GVK6YKc84dGY1JlsriRJEmS6msFcB1wE3AnsJpW5+YA4DnAycBk4IMppYk55/dVNM8QFjeSJEnqOZXvljY6nZuTgFtyzs1Bnv9QSukVwBdpXXrnPSml/5tzfmA0JlcGVzJJkiRJNZRbBitsto+5FPiP9t0JwLNLn1iJ7NxIkiSp5xQV75ZWNMdUj+EW4Kz28aIqJ9KtMfVZlSRJkjTqOi+ut6yyWQSwcyNJkqSe02gUNCrcLa3Kc3dKKZ0FvKB9dxNwWYXT6ZrFjSRJklRzKaXTgDntu5OAxcAz2zeAbcB5OeflFUwvjMWNJEmSek7RB0WFu6UVj17mvyiltNvxOef7ujzlR4ETd/F4E/gx8N6c80+6PEflLG4kSZKkal0/jDFlVWL3A1cAt5eUP6rcUECSJEk9p2gUFH0V3kZ5zU3O+aScc5FzLoAZwBOAvwFmAh8Abk4pPX1UJ1UCOzeSJElStU5gFHcpyzmvB24CbkopfQn4KbAPcFlK6fic882jNZdoFjeSJEnqOUWjQaNR4XVuHn3uZQFrakYk53xnSuldwKW0Nhp4N/DiKuYSwbelSZIkSb3tex3Hp1c1iQh2brqwZfJCNk9Z2HXO5VevDZhNy3Ofc0RY1uJNS8OyANbvfWZYVuPhDWFZyxq7351kT+w1eXJY1rSHfhWWBbD5prgNUB468cNhWasfiPv6P+3UA8OyJk/uC8sC6O8fCMuaM3tqWNbqv7ojLOsVqy8PywJ4+TNuDMu65LXfD8va8rKvh2Xdcf/qsKypG9eHZQE8vPbwsKy0z5qwrOLw54Rl0dwWFvVwc3FYFsC6DVvCsvaevanrjIH+uH/fxorta18qO//A2LjOTVvnP8Z7VzaLAHZuJEmSpN52aMfxg5XNIoCdG0mSJPWcRqNBo6+63/M3+sdUj+G8juOfVTaLABY3kiRJUs2klM4DlgDX5Jybg4zpA/4ceFPHw58ehemVxuJGkiRJPafyNTfln/sk4DPAvSmlK4CbgRXAFmA2kIDnAwd0vOZDOecflz2xMlncSJIkSfW1GHjNEGNWA3+Zc/7MKMynVBY3kiRJ6jmtzk2F17kpv3Pzp8C/A6cBxwIHA/OAicA6YDnwa+AHwNdzznHbN1ao1OImpTQTeCZwBnAcrZ0YZgMbgQeA64AvAz8Y7L2A7ZxXARfvwakvyDmfP7JZS5IkSeNbznkN8K32rWeUVtyklN4GfACYsounZwKHt28vB65NKZ2Tc76nrPlIkiRJ2zWKgkajujU3jWJMXeemNsrs3BzGjsLmfuBK4AZaC5mm0FrkdA4wAzgVuCaldFLOecUQuZ8Arh5izG9GOmlJkiRJ41OZxU0T+CHwMeCqnPPOl+e+JKX0YVrv8zscOBD4MEMveLox5/zt6MlKkiSph/Q1Kl1zQ5XnrrEyP6vvzjk/K+d8xS4KGwByzncDZ3c8dHZKaVqJc5IkSZJUU6UVNznnh4c57iZaFxgCmAYcUtacJEmSJNhxnZsqb4o3VvphazqOp1Y2C0mSJEnjVuXXuUkpTaK1+cB2dw/xkjellN5J64JEDeAh4FfA94BLcs4bSpmoJEmSaqPRKGhU2D2pcqe2Oqu8uAFeCsxqH9+Yc142xPgTdrq/uH07C7ggpfSanPN/jHQyKaV9hxiyaKTZkiRJkspTaXGTUpoPfKTjoQt3M7wf+E/gWuC3tK6sOht4IvAnwBxgPvCdlNLLcs7/OsJp3TvC10mSJEmqUGXFTfvtaN8EFrQf+nbOebArqP4UOCDnfN8unvu/KaW/AC6itfNaAXwhpfQzLwoqSZKkXSkaDYpGdcvPqzx3nVVS3KSUGsAXaF28E+AOdnN9m5zz73aXl3Nem1J6GbAQOJ3WRULfCbx5BNNbPMTzi4DrAdat28K0qZtHcIpH2++AvbvO2O7an8fVc6dP/m5YFsDUBYeHZe2/4OiwrIEbLgnLWrLotWFZR8zYEpYFsORFV4VlHb30K2FZj33s8WFZ9E8Mi/rd8seGZQEcvP7ysKyJXz4/LOuOl/88LKtx0NPCsgAuvXx9WNZqXhGWNXNiX1jWIfM3hmVt6JsZlgWwYePWsKzm7T8My2LS9LCoxoGnh2XNbQxrk9hhazbjfjZYvOmnXWcsm7I6YCZS+Ua9uEkpFcA/Ay9rP3QP8PSc86pucnPO/Smlv6bV5QF4LiMobgbpDv1BSmkEs5MkSdJY0uireEMBt4Iuxaj2w9qFzaeB17Ufug94as75rqBT/CewqX28nxcElSRJknrHqHVu2oXNp4Dz2g/dD5yRc74j6hw554GU0sPAPu2HZgNuDS1JkqRHaV1Is8I1N3ZuSjEqf6Idhc0b2w89QKuw2e1amhGcpwF0vkn1kch8SZIkSWNX6Z2bXRQ2S2kVNreXcLqTgKnt4/u8oKckSZJ2pWgUlXZPCi/iWYrR6Nx8kh2FzTJahc1vo0/S7tq8r+OhEV/IU5IkSdL4U2rnJqX0CeBN7bvLgNNzzkv2MOPJwNHApTnnTYOMmQ58Fti+D+lmHn1xUEmSJOkPikaDhte5qZ3SipuU0oXAW9p3m8A/AkemlI4c4qU37nTxzYW0CpePp5SuAG4A7gXWA7OA44AXA3M7zvXawB3YJEmSJI0DZXZuTuk4LoAPDfN1rwa+uIvHZwAvaN8Gs4xWYXPZMM8lSZKkHtTaLa3CNTfullaKUb+I5whcCTwfOBF4ErCYVpdm+zbPK4AbgcuArw321jVJkiRJ9VZacZNzPj0oZx3wnfZNkiRJ6lqjUdCosHvScLe0UriSSZIkSVItjIe3pUmSJEmhGo2i0u6JnZty2LmRJEmSVAt2biRJktRziqKgKCrcLa3Cc9eZnRtJkiRJtWDnpgtzpm5k3vQNXefM3W9twGxabrxnZlgW0w+KywKeeujPw7K+dM9JYVn7LF0SlnXEEfeHZS0nhWUBHN3/zbCs4pBnhGU1778+LOvOaXHzOnSf/rAsgC19Lw3L+ukznhyWdeq/nDL0oGFqvvnSsCyAYu5hYVl73fW9sKz3vH9yWNa7zn96WNbMYnVYFsDUKZPiwh64LSyqeMr/CcvaOm1xWNbmzdvCsgDmrr02LOvWbU/qOmPltgcDZjK2NBrVrntp2GIohZ9WSZIkSbVg50aSJEk9p6h4t7TC3dJKYedGkiRJUi3YuZEkSVLPaRQVX+fG3dJKYedGkiRJUi3YuZEkSVLPaVS85qbKc9eZnRtJkiRJtWDnRpIkST2nURSVrntxzU057NxIkiRJqgU7N5IkSeo5RQMaFf6av7DFUAo/rZIkSZJqwc6NJEmSeo67pdWTnRtJkiRJtWDnRpIkST2nUVTcuXG3tFLYuZEkSZJUC3ZuJEmS1HOKRkFRYedmNM6dUpoJPBM4AzgOOBSYDWwEHgCuA74M/CDn3Cx9QqPAzo0kSZJUMymltwErgG8AbwaeDMyj1dyYCRwOvBz4HvDjlNJ+FU01lJ2bbjT7YaC/+5iVtwdMpmXSxBPCsrbs9+ywLIAfLT8wLOtfvve7sKxznnd+WNZty6aHZS1fsTIsC6D/4BeGZU3YEvd7kb6Fzw3LWrzXlLCsn1x/b1gWwGlP6P57xXbPOOiusKyBM34blsXSX8RlAUvujfsl4oKFcd/PLnzLz8OyeDgua+Cu2M//6gXnhmVNOeUjYVmf/qf/DMt6x58vDsua0bcmLAugOSnu35MH79vQdcaqVRsDZjK29MBuaYcB2/9hvB+4EriBVsEzBTgJOAeYAZwKXJNSOinnvKLsiZXJ4kaSJEmqnybwQ+BjwFU554Gdnr8kpfRh4Ae0ujgHAh8GXjOqswxmcSNJkqSeUxTV7lg2Cqd+d8754d0NyDnfnVI6G/hV+6GzU0pvyTl33+6riGtuJEmSpJoZqrDpGHcTsKR9dxpwSGmTGgV2biRJktRzemDNzZ7oXDQ2tbJZBLBzI0mSJPWolNIkWpsPbHd3VXOJYOdGkiRJPadRVNy5efSim0Uppd2OzznfV9JUXgrMah/fmHNeVtJ5RoXFjSRJklSt64cxJrwSSynNBzr3ar8w+hyjzbelSZIkST2m/Xa0bwIL2g99O+f8rQqnFMLOjSRJknrOGNtQ4ARg1N4OllJqAF+gdfFOgDsY59e32c7iRpIkSarWshLX1DxKSqkA/hl4Wfuhe4Cn55xXjcb5y2ZxI0mSpJ4zxjo3o6Jd2HwaeF37ofuAp+ac7xr1yZTENTeSJElSzbULm08B57Ufuh84I+d8R3WzimfnRpIkST2n6Cto9FXXuSlG8dwdhc0b2w89QKuw+d2oTWKU2LmRJEmSamoXhc1SWoXN7dXNqjx2biRJktRzxthFPMv0SXYUNstoFTa/Ha2TjzY7N5IkSVINpZQ+AbypfXcZcHrOeUmFUyqdnZsubCz2ZkNjbtc5P7r9kIDZtJy54NthWY0tzwnLAhh45J6wrHNeeGxY1sDSX4ZlHf7Lr8ZlrYrd7r447MNhWWunHhGWNeO2z4dlLV/8irCsU9Z8OiwLYEPjA2FZU/c+KCxr2bK1YVlz5h4flgVw6G/iPmfFrBeGZTVXxq29bRz5/LAsps2LywKOzJ8Ly1q/75+HZf3Z204Jy1r58MawrEmP6f7ngU5rp00Py3p86j5jxYpm9yFjTKPRoNGo7vf8ZZ87pXQh8Jb23Sbwj8CRKaUjh3jpjTnnuB/aRpnFjSRJklQ/nb8JKIAPDfN1rwa+GD6bUWJxI0mSpJ5TNKCocM1N4eKQUljcSJIkSTWTcz696jlUweJGkiRJPafRqHi3tArPXWc2xCRJkiTVgp0bSZIk9ZyiUdDoq3LNjZ2bMti5kSRJklQLdm4kSZLUc+p+nZte5WdVkiRJUi3YuZEkSVLPcbe0erJzI0mSJKkW7NxIkiSp59i5qSc7N5IkSZJqwc6NJEmSek5RcefG69yUw86NJEmSpFqwcyNJkqSe02g0aPR5nZu68bMqSZIkqRbs3HQh37qc+5f2d52zetWGgNm0NJ/9+risVb8JywL46fIjw7JOnX5/WNbSaSeHZT32uY8Py6LRF5cF3LF8YljWgb96X1jW8mP+Mixr85ZtYVkPPvFvwrIArvnOrWFZf/SCx4Vl7bPhxrCsh9ensCyAyfsdH5bV/N2VYVnFwU8Ny3po48ywrKKxV1gWwN6PPTosa/2GLWFZ8+fPCMvaq7kiLGvg99eGZQE8MjHu36b91/xH1xkbV64NmMnY0mhUu2OZjZty+GmVJEmSVAt2biRJktRzikZR6Y5l7pZWDjs3kiRJkmrBzo0kSZJ6TqPRqHTHMndLK4efVUmSJEm1UGrnJqU0E3gmcAZwHHAoMBvYCDwAXAd8GfhBzrk5zMxDgDcAZwKLgT7gfuBK4KKc86+CPwxJkiTVTFEUle6WVhSuuSlDaZ2blNLbgBXAN4A3A08G5tEqqGYChwMvB74H/DiltN8wMl8P/Bp4B/A4YC9gOnAY8Cbgv1JKsfu3SpIkSRoXyuzcHAZMaR9v76zcQKvgmQKcBJwDzABOBa5JKZ2Uc97lpvMppXOAz7bvDgBfAa4CtgEnA68EJgMXpJQ255w/UsYHJUmSpPGv0ai2c1PlueuszOKmCfwQ+BhwVc55YKfnL0kpfRj4Aa0uzoHAh4HX7ByUUpoPfKp9dwB4Qc75Ox1DLk0pXUyr2JkGXJhS+nbOeUnkByRJkiRp7CpzQ4F355yflXO+YheFDQA557uBszseOjulNG0XQ99B6y1oAJ/aqbDZnvUL4D3tuxOA94586pIkSaqzRqP6m+KV9mnNOT88zHE3Ads7LNOAQ3YxrLMA+vvdxF0ErG8fPy+lNHU4c5AkSZI0/o2VmnFNx/GjCpKU0lHA/u27t+Wc7xwsJOe8Fri2fXc68JTISUqSJKketq+5qfKmeJUXNymlSbQ2H9ju7p2GHN1xfP0wIjvHHD3oKEmSJEm1Uup1bobppcCs9vGNOedlOz1/eMfxoF2bQcYcPugoSZIk9axGUdCo8FozVZ67ziotbtq7oHVu2XzhLobN7jh+aBixKwd57XDntO8QQxbtaaYkSZKk8lVW3LTfjvZNYEH7oW/nnL+1i6EzOo43DSN6Y8fxzBFM7d4RvEaSJEnjSFFUu+6lsHNTikqKm5RSA/gCrYt3AtzBLq5vM9Ydf/AWFi3Y0nXOyfusDphNS/O6T4RlXdv/vLAsgNOeMGXoQcN03yO72lRvZB5YumboQcOUb9k49KBh+tF3bwvLAnj3B54VllXw1LCsRVMfDMuiEfdnuX7akWFZAGefFdf0XbW+++872/3DpRvCsv48vWfoQXug/1kfDctaNvXUoQcN02MfvCwsa07f78KyinnB78See9jQY4Zp0aTAf+dW3hWWxdS5YVHFvNjvGfsvuyos63M/6/7fzHXrVgXMRCrfqBc3KaUC+GfgZe2H7gGennMe7G/Nuo7j4fx03Lnb2to9nyGLh3h+EcPb2ECSJEljVOtaMxWuual8W696GtXipl3YfBp4Xfuh+4Cn5pzv2s3LHuk4njeM03T+GuaRQUcNIud83+6eTyntaaQkSZKkUTBqNWO7sPkUcF77ofuBM3LOdwzx0iUdxwcO41SdYz17NUIAACAASURBVJYMOkqSJElSrYxK56ajsHlj+6EHaBU2w3mz8c0dxycMY3znmDy8GUqSJKmXFI2CosoNBbyIZylK79zsorBZSquwuX04r88530prXQ7AkSmlA3Zzrhns2KRgA/DjkcxZkiRJ0vgzGm9L+yQ7CptltAqb3+5hxlc7jt+2m3GvB6a3j7+Tc47bBkiSJEm10WgUld8Ur9TiJqX0CeBN7bvLgNNzziNZB/Mxdux89uaU0n/bozildCLw/vbdbcAFIziPJEmSpHGqtDU3KaULgbe07zaBf6T1trKhNoK/Med8T+cDOecVKaW3Al+kVZB9K6X0FeAKoB84GXglO7aKfm/O+TchH4gkSZJqp1HxRTwbXsSzFGVuKHBKx3EBfGiYr3s1rSLmUXLOl6SUpgF/R6uIeWn71qkf+EDO+YN7PFtJkiRJ49qoX8SzGznnz6SUrqS1nfSzaV1ws0Fr97WrgM/lnH9Z4RQlSZI0DhRFUWn3pLBzU4rSipuc8+kl5d4OvL19kyRJkrQLKaU+4EjgeOCJ7f8/HpjaHnJJzvlV1cyuHOOqcyNJkiRFqHrHslE699eAF47GicaK0dgKWpIkSdLo69vp/sPAsK41OV7ZuZEkSVLP6ZHOzXXAbcANwA055ztTSq8CLh6Nk1fB4kaSJEmqoV7cQdjiRpIkST2nRzo3Pcc1N5IkSZJqwc5NF/L903hg4/Sucw496MkBs2n5r7sOCMt66hPCogBoblkflnXf/VvDsubNmxaWNX9e918P2z39H84KywJoPHxrXNjeB4VF/ct3V4VlveyUuKyBqc2wLIDNk+aGZc26/m/Dst7y1rhd9ZeuPi4sC2B+4B/BvtMfCsu6Y8uzwrL2njV16EHDdM/9q8OyAI46Yn5Y1tYt/XFZE+aEZc269/KwrKWznhmWBTB5/plhWee9elPXGcuWr+CL/1/AZMYQOzf1ZHEjSZIkVWtRSmm3A3LO943SXMY1ixtJkiT1nKKotntSPPrU1w/nJeXMpF5ccyNJkiSpFuzcSJIkqecUxX/rnoz6+TucACyrZib1YnEjSZIkVWuZa2piWNxIkiSp5xRFQVFh66bKc9eZa24kSZIk1YKdG0mSJPWcRlHQqLB7UuW568zOjSRJkqRasHMjSZKknjPGdktTEDs3kiRJkmrBzo0kSZJ6TtEoKBoV7pY2CudOKR0InLvTw8d0HB+bUrpwp+evzjlfXe7MymNxI0mSJNXT/sC7d/P8MTy62AHYBljcSJIkSeNFUfFuaV7nphwWN5IkSVIN5ZyvAXqqirK4kSRJUs8pqHi3tOpOXWsWN12YP3c68+fP6Dpn8pS4P4Yz0qawrCUr5odlAey/3+ywrCft9Z2wrK37Pi8sqwj8VvXja+8KywI47JB9w7L2+f2XwrKee9ZrwrKKyevCsmbcfXlYFsDvJz0lLOvgg04Ly+r76LFhWZc95vNhWQDPe8HjwrJWr5kVlnX/A2vCsn74vSVhWW969cFhWQBrNm8Ly5o4sS8s66tndP/v7nav/uh7w7L2mXNIWBbA2klHhGU9smla1xlrNk8NmIlUPosbSZIk9ZyiKCpd9+Kam3J4nRtJkiRJtWDnRpIkST2nUfFuaVWeu87s3EiSJEmqBTs3kiRJ6jlFo3Wr8vyK56dVkiRJUi3YuZEkSVLPcbe0erJzI0mSJKkW7NxIkiSp5zSK1q3K8yuenRtJkiRJtWDnRpIkSb2n4jU3uOamFHZuJEmSJNWCxY0kSZKkWvBtaZIkSeo5RVHtdsy+K60cdm4kSZIk1YKdG0mSJPWcRgGNCn/N71bQ5bC46cJtv3mQpcsGus55dloZMJuWtTOPDctatKAZlgUw6e7LwrK2HfT8sKxJG+4Oy/rXyx4Jy3rx0beEZQH8/J7TwrLmHfeGsKzbb1kelnX8vnF/l4r5R4ZlARy87tdhWQ9POzEsa+a74+b1uvV3hWUBLNsUl/XYx8yMCwu0/36zwrLWbJsWlgVw7U/vCst60gn7hmW9+oPvCsu6Y783hmXtMyP2a2zrpm1hWZs2d5+1YWPcfKQyWdxIkiSp5xQVbwVd6TbUNeaaG0mSJEm1YOdGkiRJPae1W1q151c8OzeSJEmSasHOjSRJknqOa27qyc6NJEmSpFqwcyNJkqTeU7RvVZ5f4ezcSJIkSaoFOzeSJEnqOUX7vyrPr3h2biRJkiTVgp0bSZIk9Ryvc1NPdm4kSZIk1YKdG0mSJPWeiq9zY+umHHZuJEmSJNWCnRtJkiT1HNfc1JOdG0mSJEm1YOdGkiRJPaji1o3XuSmFxU0XznjSDBYt2KvrnFVb9g2YTcuMqRPDsiYs+0VYFkBzy/qwrG3b+sOyJlx/cVjWqU95R1gWD98SlwVs2LA1LGvjhi1hWcfP/W1Y1u/XPz4sa96cqWFZAHsVD4Zlzdnwy7Csb187Oyzr+Y3PhWUBzHr634ZlTbnhH8OyDksvDMtiy9qwqOayu8OyAJ71rLPCsi69+L/Csl70J+8Oy5q9eVtY1vd/sCQsC+CFJ64Ly3qgeFxYljTWWdxIkiSp57jmpp5ccyNJkiSpFuzcSJIkqecUFV/nptJr7NSYnRtJkiRJtWDnRpIkST3HNTf1ZOdGkiRJUi2U2rlJKfUBRwLHA09s///xwPY9Vi/JOb9qGDmvAvZkv94Lcs7n78lcJUmS1DuK9n9Vnn+0pJSeB7wcOAFYBKwBfgd8C/hsznnNqE2mZGW/Le1rQOAFASRJkiQNR0ppBvAvwPN2emp++/Zk4K0ppT/JOcde4LAiZRc3fTvdfxhYCRzaReYngKuHGPObLvIlSZJUc3Vfc9N+B9XXgWe3H1oOXATcCswBXgKcDCwGLk8pnZxzvq3cWZWv7OLmOuA24AbghpzznSN4i9nObsw5fzticpIkSVJNvZYdhc2twFNzzss7nv9USuljwNuBvYHPAqeN7hTjlVrc5Jw/WGa+JEmSNCI1bt20uzbv7Xjo5TsVNtu9E3ga8ATg1JTSM3POPyxtYqPA3dIkSZKkejkNeEz7+Mc55xt3NSjn3A/8U8dDLyl7YmXzOjeSJEnqOTVu3ACc2XF8+RBjvzfI68al8VjcvCml9E5ai58awEPAr2j9wVySc95Q5eQkSZKkih3dcXz97gbmnJellO6l9bP1wpTS/Jzzg6XOrkTjsbg5Yaf7i9u3s4ALUkqvyTn/x0jDU0r7DjFk0UizJUmSNDa0OjcVXufm0adelFLa7fic8317EH94x/Gdwxh/J62fp7e/1uJmFPQD/wlcC/wWWAfMpnVx0D+htaXdfOA7KaWX5Zz/dYTnuTdgrpIkSdJw7ba70rYnldjsjuOHhjF+5SCvHXfGS3HzU+CAQSrW/5tS+gta+3afTesP/gsppZ/lnO8pc1IDd1zJwKqZXed84DNzAmbT8tE/2xqWxZxD4rKAL//y8KEHDdOZj9kWljXtxNeFZe276e6wrK1HvDQsC+DE/beEZc0q4n6h05y5T1jWgT98W1hW8Yx3hmUBXL/ioLCs446N+5w9f+lnwrKY/dS4LGDKxc8Jy9r2uu+HZW3aFPd9dubALWFZ37zpwLAsgP+1z7KwrFfNuzQsi2/cHxY182l/Gpb1x8/o5hJ+/91Pft39zxfbHfypxww9aChb+4D9u88ZQxpbHqFvy6RKz1+iGR3Hm4YxfmPHcdwXXwXGRXGTc/7dEM+vTSm9DFgInA5MobW13ZtHcLrFQzy/iOFV15IkSdJwnADE/Uahh42L4mY4cs79KaW/ptXlAXguIyhuhno/41Dvh5QkSdI40GxCc6Da8++wbA/X1AxlHa0Lc0Lrl/7rhhg/teN4beA8Rl3drnPzn+xove2XUppW5WQkSZKkCnS+523eMMbPHeS1406tipuc8wDwcMdD43pBlCRJksoy0OrcVHWj1K7Rko7j4SzI6xyzZNBR40CtipuUUoMdLTgY55WnJEmSNAI3dxzvfBmVR0kpLWTHmvMV4/kaN1Cz4gY4iR3vGbzPC3pKkiRpl5rN6m/l6dwi8swhxv7PjuPLS5jLqKpNcdPu2ryv46ERX8hTkiRJGsd+zI7d105PKR23q0EppT6gc0/0r5Q9sbKN+eImpfTklNLrU0pTdjNmOnAp8LT2Q5uBj4zG/CRJkqSxJOfcz6N/6X9pSmnBLoZ+GHhC+/hnOecflD65kpW6FXRK6UDg3J0ePqbj+NiU0oU7PX91zvnqjvsLgc8CH08pXQHcANwLrAdmAccBL2bHLg9N4LU557tCPghJkiTVzx8W9ld4/nJdBLwAeAbwOOCmlNJFwK3AHOAlwCntsY8Abyh7QqOh7Ovc7A+8ezfPH8Ojix2AbcDVuxg7g9Yf0At2k7eMVmFz2Z5MUpIkSaqTnPO2lNIfA1+mdf3HRcB7djH0PuDsnPMtozm/soyHi3heCTwfOBF4Eq3dHObS2uZ5A7ACuBG4DPhaznnTIDmSJElSS/07N+Sc1wJnpZSeD7yC1s5pC2hdqPMO4N+Az+acV5c+mVFSanGTc74GKLrMWAd8p32TJEmStAdyzv8O/HvV8xgN46FzI0mSJMVqNivu3JS6FXTPGvO7pUmSJEnScNi5kSRJUu/pgTU3vcjOjSRJkqRasHMjSZKkntNsDtCssHtS5bnrzOKmC42Dnkpjwfyuc/7PBTMCZtN25evCoppPeG5YFsAL//jssKxVj8Tt+P2lyx8My3rJy44Ly5q0cXlYFsCElTeFZW1d/PSwrN/ftSos68AXfj4s67YlcV8XAOmoOWFZjRs+E5eVXhSW1dy8LiwLoHnmO8KyJm2J+/s0ce3dYVn9i04My/rjAy8KywK4b/WLw7JmP/3jYVmbN/eHZa1avTEs66Dl14VlATzhmDPCsqZeurbrjOby5XDmMwNmI5XL4kaSJEm9p9msdscyd0srhWtuJEmSJNWCnRtJkiT1oIH2rcrzK5qdG0mSJEm1YOdGkiRJvafZrPg6N665KYOdG0mSJEm1YOdGkiRJPWig2s6Na25KYedGkiRJUi3YuZEkSVLvaVbcuam0a1Rfdm4kSZIk1YKdG0mSJPUeOze1ZOdGkiRJUi3YuZEkSVLvaTarvdaM17kphZ0bSZIkSbVg50aSJEm9p9mseM2NnZsy2LmRJEmSVAt2broRtMvGtv643xo0/uhvw7JuvndyWBZAWn1zWNa0mQvDss550X5hWc2lvwjLYu+D4rKA/v2eEZa1ft3msKy773kkLOuwSXFfY48/+KiwLIB/v/J3YVlnHbl/WNbAPT8Ly+o/5I/CsgAmbFkblnX+R28Jy3rvn8V9z9iypT8s6+6ZLwzLAjiiWBKW9avfLw7LenzfT8Ky9r7tqrCs5Sd/PCwLYOH9l8eF3XpF1xGN1XHf98eMgf7WrcrzK5ydG0mSJEm1YOdGkiRJvafZ37pVeX6Fs3MjSZIkqRbs3EiSJKn3NAcq7txUuFNbjdm5kSRJklQLdm4kSZLUe5oDMFDldW7s3JTBzo0kSZKkWrBzI0mSpN7jbmm1ZOdGkiRJUi3YuZEkSVLvsXNTS3ZuJEmSJNWCnRtJkiT1noEBGKiwe1LlTm01ZudGkiRJUi3YuZEkSVLPaTb7aVa47qXKc9eZnRtJkiRJtWDnRpIkSb1nYKDadS+uuSmFnRtJkiRJtWDnpgv/77Z+9l62reucU/f9ZcBs2vqODIs6ev/Y94LetfKgsKzJ6+K+dBf+2wvDsjj2zLCotXsdG5YFMOOKd4Vl3bvf28OyFu87KyyrufX2sKyf3bQpLAvgrENvDctav+issKxPfuLnYVnvPOpPw7IAmtP3Dst6x1/8dVhWc8U1YVkDkw4Iy5r1/gPDsgBWf/LBsKxpU9eHZd3O08KyDjvjmLCsRn8RlgWw9aDnhWUtnXpG1xkPPbQCeFH3k5FKZnEjSZKkHjRQ8YU0fVtaGSxuJEmSJI1ISmku8ETg+I7/79cx5MCc812jNR+LG0mSJPWeZn+1nZsabAWdUjoa+HXV8+jkhgKSJEmSRqJvp/v9wC3AxgrmAti5kSRJUi8a6G/dqjz/+LcWuBS4Afgv4Fc55w0ppbuA/auYkMWNJEmSpD2Wc74DeGXV8+hkcSNJkqTe02xCs8Idy5rN6s5dY665kSRJklQLdm4kSZLUe1xzU0sWN5IkSVK1FqWUdjsg53zfKM1lXLO4kSRJUu8ZW9e5uX4YryhKmkmtuOZGkiRJUi3YuZEkSVLvGRioeM3No3ZqOwFYFn2KlNI1wFOC4l6Sc/5KUFZpLG4kSZKkai1zTU0MixtJkiT1nmbFu6WNznqfbwC/CspaEpRTKosbSZIkqYZyzp+seg6jzeKmC8ekRSxcuLDrnKI5NWA228Pi9ojY9MHTw7IA9jvxOWFZxYmviss6N+7towN3/igsa+mydWFZAIufcmFY1uN+++WwrMa+p4dl3fXISWFZ/+PB88OyAIpDXhuW9dOf3x2W9c7nBr4Lou/UuCxg+Zz/GZb1X9f8PizrOff+fVjWpHOfHpY17wurw7IAli5fG5Y1e9aUsKxZgVlsiPucPXB/3OcLYMGkFWFZq1Z3/3PG6jWbA2Yyxgxsa92qPL/CuVuaJEmSpFqwcyNJkqTeM7Z2S1MQOzeSJEmSasHOjSRJknqPa25CpJTOBQ7c6eHZHcdvTyk9aoFbzvmvy5qPxY0kSZKkkXo5u79Q6Ft28ZjFjSRJkhSmN65z03NKLW5SSn3AkcDxwBPb/388sH1Pwktyzq/aw8xDgDcAZwKLgT7gfuBK4KKcc9SFiiRJkiTtRs759Krn0Knszs3XgBdGhaWUXg/8AzuKo+0Oa9/ekFJ6X875fVHnlCRJUg0N9Fe85sbOTRnK3i2tb6f7DwO3jyQopXQO8Flahc0A8GXgXOCVwOeAze3zXZBSeudIJyxJkiRpfCq7c3MdcBtwA3BDzvnOlNKrgIv3JCSlNB/4VPvuAPCCnPN3OoZcmlK6GLgKmAZcmFL6ds55SbcfgCRJkmqov791q/L8CldqcZNz/mBQ1DuAvdrHn9qpsNl+rl+klN4DfJzWx/Ve4KVB55ckSZI0xo2Xi3ie3XH897sZdxGwvn38vJTSzmtzJEmSpB1rbiq72bkpw5gvblJKRwH7t+/elnO+c7CxOee1wLXtu9PZ/Z7bkiRJkmpkPFzn5uiO4+uHMf564Nkdr/1++IwkSZI0vnmdm1oaD8XN4R3Hg3ZtBhlz+KCjBpFS2neIIYv2NFOSJElS+cZDcTO74/ihYYxfOchrh+veEbxGkiRJ48n2tS9Vnl/hxvyaG2BGx/GmYYzf2HE8M3gukiRJksao8dC5GW2Lh3h+Ee21PwP9A/RvG+j+jAMbhx4zTEs3zA3LWnDBbWFZAF//+q/Dsv7XVR8Py9r2x58Py5q470lhWQu2TQvLAtjWH/C1ut2MhWFRA7/617CsCYe8KSyLfY6KywKaq34flnX6U/5nWNaW4qCwrAkTYn9ftmjtXWFZzz1ubVhW/5mXh2VNDPwY2Rb3bwnAXjMODMvq72+GZU1eG3cJu8uv2/la4yOXjo7doHX1iN58smvpqMldZyxfHjCRsWZgoNo1NwOB/y7rD8ZDcbOu43jKMMZ3fnfZ43/Ncs737e75lNKeRkqSJEkaBeOhuHmk43jeMMZ3ti4eGXSUJEmSetdAxbuleZ2bUoyHNTed/efh9Mg7x8T1riVJkiSNaeOhc3Nzx/EJwxjfOSYHz0WSJEl14G5ptTTmOzc551uBe9p3j0wpHTDY2JTSDODU9t0NwI/LnZ0kSZKksWLMFzdtX+04fttuxr0emN4+/k7OeUN5U5IkSdK4NTAA/f3V3dwtrRTjpbj5GDt2PntzSul5Ow9IKZ0IvL99dxtwwSjNTZIkSdIYUOqam5TSgcC5Oz18TMfxsSmlC3d6/uqc89WdD+ScV6SU3gp8kVZB9q2U0leAK4B+4GTglezYKvq9OeffxHwUkiRJqh3X3NRS2RsK7A+8ezfPH8Ojix1odV2u3nlgzvmSlNI04O9oFTEvbd869QMfyDl/cMQzliRJkjQujYfd0v4g5/yZlNKVwHnAs4HFtDo5DwBXAZ/LOf+ywilKkiRpPBgYqPg6N665KUOpxU3O+RqgCM68HXh7+yZJkiRJwPjZUECSJEmSdmtcvS1NkiRJCjHQX/Hb0io8d43ZuZEkSZJUC3ZuJEmS1HuaFXdumnZuymDnRpIkSVIt2LnpwtLl69iybWrXOYff9bmA2bTsffr7wrK2vX/nSxB158RX/SQs68s/eWtY1kn3PhKWte9jF4Vlzd5ye1gWQPPBe8KyirmHhGUNHPTssKzpqzeGZf1k47PCsgAmbYv7XdKT5/4uLKuYPCss6/pbmmFZAEcc+tiwrOk//3BY1rqnHx2Wtdf1F4dl/XL+G8OyAI5tfDMsa/NhLw7LKrbtHZZ15pKzw7IuG4j7txzgqMctDMsaeGf3f5fWbW4Aj+l+MmOJW0HXkp0bSZIkSbVg50aSJEm9x93SasnOjSRJkqRasHMjSZKk3mPnppbs3EiSJEmqBTs3kiRJ6j3NindLa7pbWhns3EiSJEmqBTs3kiRJ6j0D/TBQ4e/5XXNTCjs3kiRJkmrBzo0kSZJ6j52bWrJzI0mSJKkW7NxIkiSp9wxUvFvagLullcHOjSRJkqRasHMjSZKk3jPQD/1FtedXODs3kiRJkmrBzo0kSZJ6z0A/DNi56VZK6RjgmcDJQAL2ASYCq4BbgSuBL+Scl47GfCxuunDwXstYNHtL1znFKX8aMJt2VuDf0Umv+ee4MOCAud1/rra7Ze70sKzpUyeFZW3dEveNqjHzsLAsgObMQ8OyJm9bGZbVuPuqsKzfrz4qLOuIw+aGZQEsuPPisKy1E18fljVz/W/Csg4/5IiwLIBHVm8Ky/qXB18dlvXisCT459+eGZb1xqPuDssC+Pxlcd+DXnvYmrCs716zOizroGd/MyzrqCmxP1IdNOP+uLALf9x1xOYHV8KL3xowGdVFSmk2cB0w2A8YC9q304G/Sin9Rc75U2XPy+JGkiRJvcfd0ro1hR2FTT9wbfv2e2A9sD/wv4AnAdOAT6aUpuacP1bmpCxuJEmSJI3ESuDvGfxtZx9LKb0L+FD7/gdSSt/OOf+urAlZ3EiSJKn3DPRDlc2T8b/mZiVwQM553e4G5Zw/nFI6EfgjYBJwDnB+WZOyuJEkSZK0R3LOW4Gtwxz+VVrFDcAx5cyoxeJGkiRJvcfOzWjq3FVkapkn8jo3kiRJksp0dMdx7NaOO7FzI0mSpN7THKi2c9N81MkXpZR2OzznfF+p8ylJSmkicG7HQ5eVeT6LG0mSJKla1w9jTIVXHO3KX7Jjy+hfYXEjSZIkBRuouHMz/q9zM6SU0nOA97bvbgVen3Mu9QO3uJEkSZKqdQKwLDo0pXQN8JSguJfknL+yB+c+HvhXdqzxf3vOeTgdqq5Y3EiSJKn3DPTTHGhWeP5HNTCWjdc1NbuSUjoG+AEws/3Q+3POnxiNc1vcSJIkSfX0DVrrXCIsGc6glNLRwFXAnPZDH8o5/03QHIZkcSNJkqSe0+wfoFnhpWaa/eWvuck5f7L0k3ToKGzmtR/6SM75r0ZzDl7nRpIkSVJXOgqb+e2HPpZzftdoz8POjSRJknpOszlQ6ZqbZrPC9T7BdlHY/F3O+c+rmIudG0mSJEkjklJ6HI8ubP4+5/z2quZj50aSJEm9Z6AfBiq8LmaVO7UFSSkdBVzNowubt1U4JYubbhQzH0Mxa0HXOf2T5gw9aJgm3hF30dfm5jVhWQCbF5wYlnXmhveEZfXP/+ewrG3b4lYm3rbkwbAsgPS4hWFZA7/6RlhWsfCosKxjV30hLAv2DcyCex/7irCsxb/5fFjW2iPPDctavmJ9WBbAI2+M+5p9w5duDMv6/v+7NyzrZeccG5a16SPHhGUBnPt//i0sa+De/wzLeu4pcd8zYF1Y0rbp+4dlAbBuZVhU8/Yfdp/xcNznSvWQUtqXVmGz/YfhXwI/SSn90RAv3ZBz7v6LchAWN5IkSeo5zYEBmhV2biq9xk6MQ4DO30IdC3xrGK+7GzigjAmBa24kSZIk1YSdG0mSJPWc6q9zU925I+ScrwEqXLS0a3ZuJEmSJNWCxY0kSZKkWvBtaZIkSeo5rYt4Vnl+sM8Qz8+oJEmSpFqwcyNJkqTeM9APFXZuWue2zxDNz6gkSZKkWrBzI0mSpJ7T7O8fA1tBT6xuAjVl50aSJElSLdi5kSRJUs9pDjRpDjQrPP+Yu/5lLdi5kSRJklQLdm4kSZLUc5rN/mo7N007N2WwcyNJkiSpFuzcSJIkqfcMDECFnRtcc1MKi5subJswm60T9u46Z8LKHDCbttn7x2VtWReXBaxdsyksa+7K+8Oyli1bG5a1Zu3msKwD958dlgWwefO2sKwp1387LGvL694QlvVA8wlhWQc0bg7LAth/3tawrGbjuLCsmVvvDssamLtfWBbAvK+uCcsamDU1LOvMU5aHZS1bF/f38oZn/TAsC+CgDXHfg265PW6722cddEBYVuOrrwzLmnDm+WFZAMWEuK/ZPP1FXWes3PQg8KXuJyOVzOJGkiRJvae/n2Z/hZ2bfjs3ZXDNjaT/v707D7OkKg8//u0ZGIZlAgRmGFQQooLAq0YUwQ1ENIIKakwkENFocIvR3/PEPDFE/Rl3TYxJXH6GYHBJNBoX1CAGN0CDGAQUeQFBEJRtWIYZRhhGnL7390dVpy9t731uV9+638/z3GfqVp1663TNud313lN1jiRJUivYcyNJkqShU81z02nw+PYx9INnVZIkSVIr2HMjSZKkoVPNc9Ngz023wed9WsyeG0mSJEmtMFA9NxFxLnDEHHbZNzOv709tJEmSNKi6nU7Dz9w0duhWs+dGkiRJUisMVM/NBM+bRZnb+l4LSZIkDZxqtLTmnntp8thtQV0t3gAAHK9JREFUNrDJTWaWmyJdkiRJ0sAb2ORGkiRJmq9Op0unwd6TJo/dZj5zI0mSJKkV7LmRJEnS0Ol2oDva5DM3jR261QY2uYmIM4FHA6uBe4Cbge8Cn8rMc5qsmyRJkqTFN7DJDfCsnuVd6teBwMkR8S3ghZl5y1yDRsSDZiiydq4xJUmStLR0G37mxtHS+mMQk5sNwNeBi4CbgFHggcBRwDHACPBU4IKIOCwz180x/g0F6ypJkiRpkQxacnMKcHFm3jfJtvdFxGOBzwN7Aw8GTgeeuYj1kyRJ0gBwtLR2GqjkJjMvmGH7RRFxNPADYDvgmIg4JDO/P4fD7DXD9rXA9wHOPfdadt554xxCT+5xj9t3wTHG7LHTPcVidb75d8ViAXDUB8vFOvwlxULtusvKYrHW7rFTsVg33rSpWCyA3Xbbvlis237vC8VirR3dUCzWLjvvWCzWyPYHFYsF0PnOPxSLNfLYFxWLde97ji4Wa+OrLioWC+DBI5cVi9W9slzdOqOjxWKt2WO/YrFGDjiqWCyAZSPlYj3ykXsWizU6Wu4p7EsPfE+xWI++6dxisQC6K3ctFuuKfMCCY2zatL5ATaT+G6jkZjYy88qI+Ffg5HrVs6mTkVnuf+N02yNiAbWTJEnSUtDtdOh2mhuyrNsp+A2C/ldb57npHS3tgMZqIUmSJGnRtK7npnZ7z/IujdVCkiRJS5LP3LRTW3tudu9ZXvhDMZIkSZKWvLb23BzZs3xVY7WQJEnSktTtdhuda6bbteemH1rXcxMR+wEn9aw6s6m6SJIkSVo8A9NzExGvBS7KzO9OU+bRwBeAsbF9v5aZ/7MY9ZMkSdLg8JmbdhqY5AZ4KvCPEXEt8A0ggfXAKPAA4CiqCTvHeqN+BpSbDEWSJEnSkjZIyc2Yh9Sv6ZwNvDQzb16E+kiSJGnQdJp95gZ7bvpikJKb1wH/CRwKPApYQzUq2nbAXcD1wAXAJ70VTZIkSRo+A5PcZOa1wLXAvzRdF0mSJA22TqfZ5146ncYOXUxE7AYcDhwCPAbYi6rzYVfgXuBm4GLgs8CXM7PvP/XAJDeSJEmSlpSXAH87xbZVwP7160Tgkog4PjOv6WeFTG4kSZI0dJznpphR4FLgIuBq4BbgPqrem8cAxwO7AAcD34mIR2Xmbf2qjMmNJEmSpPn4DPCRzNw4xfbTIuINwFnA44C1wJuBV/erQiY3kiRJGjrOc7NwmXnDLMqsj4hXUT17A3AsfUxuls1cRJIkSZLm7fKe5bX9PJA9Nwtw1EGbWLt6+YLjdHZ/eIHaVLq3XFYs1q1HfKBYLIAdtyvX3G5a9fRisdau3LZYrNG3HFgu1kvOLxYLYKdL/r5crC2/KBbrviPfVizWTqtGisX6yc/uLRYL4KH7l2uzbL6jWKgd/uqcYrEefM9Pi8UCOOsHa4rFetYRJxaL1fn2+4rF+vneJxeLtc8Om4rFAujeV+5z3nnAfsViLd9S7lb9HbYv9/t/0x7PKxYL4Jxzy32eXnD4lgXHWHf7KP9Y9rJAw+WhPcvr+nkgkxtJkiQNnW6nQ7fB8ZibPPZiioidgN7U+HP9PJ7JjSRJktSstRExbYHMvHGR6jIvEbEGeEL9dhmwM/BI4A8YvxXtYuCv+1kPkxtJkiQNnSU2oMD3Z7FLuXuv++Ng4Iwptt0OfBR4c2Yu/D7JaTiggCRJkqR++jbw7X4nNmDPjSRJkoZQtwNNPvbSvf+xD6EPD9pHxLnAEYXCnZCZn55qY2b+F3XvUkQsB1YDhwKvAZ4PPD8i/h04OTM3F6rTrzG5kSRJkpq1bqk/UzMXmTlKlax9CfhSRLwTOAU4oS5SbgjLCUxuJEmSNHS2AlsbnEdz6+Ic5nPADwvFumoB+74J+D3gYcAJEfHWzPxxmWrdn8mNJEmS1EKZ+cGm6wBVT05EfI0quQF4CmByI0mSJJUw2q1eTR5/yPTODLxrvw7iaGmSJEmS+u1hPcu39+sg9txIkiRp6HQa7rlpcIqdRRcRewPH9Kw6v1/HMrmRJEmSNCcRsRZ4BfCBzLxzmnL7AV8AdqhXnZOZV/arXiY3kiRJGjqj3RFGuyONHn/ArQT+GnhjPZ/OhcC1wCZgBfAg4MnAM4Bt631uAk7uZ6VMbiRJkiTN1zbA0+rXdL4GvDwzf9bvykiSJElDZbQDow12nox2mjt2CZl5fUQ8iiqpORQ4kKq3ZhXwK+Au4CdUPTqfycwLF6NeJjeSJEmS5iwzfwT8qOl69DK5kSRJ0tAZ7cJW57lpHZObJeBrX/9JsVhHH7pHsVh7nHtKsVgAy57+xmKxuqt2LhZrm5vOKxZry19cWizWb131sWKxALjhsmKhRp799nKxlpW7J2D5j04vFmufR7ykWCyA7tW3FIvVefjvF4u1fH0Wi/U/N6wpFgvgSU/cvVis7m0FRx1dscPMZWZp9e47FovV/dWGYrEA7hh9YLFYu13yz8VibT7opcViPfQhy4vFWn7hPxSLBfCch+9TLNbILk9eeIxfbl+gJlL/mdxIkiRp6Iw2PM+NPTf9sazpCkiSJElSCfbcSJIkaejYc9NO9txIkiRJagV7biRJkjR0OjTbezLg09wsWfbcSJIkSWoFe24kSZI0dLY2PM9Nk8duM3tuJEmSJLWCPTeSJEkaOp2GR0vr2HPTF/bcSJIkSWoFe24kSZI0dEa7I4x2Rxo9vsqz50aSJElSK9hzI0mSpKEz2oHRho+v8uy5kSRJktQK9txIkiRp6DhaWjvZcyNJkiSpFey5WYCRXfdlZLc1C47zhMN2KFCbys33/KpYrD1vuaZYLAC65W4u/Y0tVxWLtW7FY4vFuu7yW4vFOmD/k4rFAtj1Yc8oFuvWX+5eLNaa239QLBYPelyxUPfdV/ZO7Kv+7MRisX77z7NYrJHHv6pYrMMevrVYLAC2vbtYqM9cuLpYrGc965RisZYvLzda0jkXlR15aevWdcViPW3nYqFYv35zsVgrViwvFqv7kJcViwWw5up/Khbrn87Zc8Ex7r57Q4GaLC1bu9WryeOrPHtuJEmSJLWCPTeSJEkaOp1us8+9+MxNf9hzI0mSJKkV7LmRJEnS0OnQ8GhpzR261ey5kSRJktQK9txIkiRp6HS6zfae+MxNf9hzI0mSJKkV7LmRJEnS0BntQtkZzeZ+fJVnz40kSZKkVjC5kSRJktQK3pYmSZKkoeOAAu1kz40kSZKkVrDnRpIkSUOn23DPTdeem76w50aSJElSK9hzI0mSpKEzSsNDQTd47Daz50aSJElSK9hzI0mSpKHjaGntZHKzAD+9Be66b+Etc+XKXxaoTeU3dlpRLNaX9vy7YrEAnrvhunLBtltVLNTGTVuKxVqzZsdisXZef16xWACdW7JYrHNufHqxWMcfvUuxWDdt3r1YrD2337ZYLIAHfGJjsVjf/emdxWI94YozisX66h1HFYsFsPOu5f7yP+e5BxWLteKazxeL9ZMV5c7ZkQdtLhYLgE65m2ZGVv1usVgPvPzTxWJx76Zyse6+vVws4KLVry0W6xW/e8eCY6y7/V4+9q8FKiP1mcmNJEmShs5od4RRRho9vsrzmRtJkiRJrWDPjSRJkoaO89y0kz03kiRJklrBnhtJkiQNndFuw/Pc2HPTFwOb3ETEccBJwCHAWmATcA1wBnBqZhYcAkWSJEnSbEXEw4EfACvH1mVm30dRGLjkJiJ2Aj4JHDdh0+r69XjgNRHxgsz83mLXT5IkSUtfh2bnmmnyeZ9+i4hlwOn0JDaLZaCeuYmI5cBnGU9sbgXeDpwI/Clwfr1+L+CsiDhg0SspSZIkDbf/Q9XhcM9iH3jQem5OBo6ul68AnpqZt/Zs/1BEvBd4HbArcCpw+OJWUZIkSUtdp+FnbjpAg9Ps9E1EPISq8wHgjcDfL+bxB6bnpu61eXPPqpMmJDZjXg/8sF5+ckT8Tt8rJ0mSJA25iBgBPgLsAFwIvH+x6zAwyQ1VD8ye9fJ5mXnJZIUyc5T7n8gT+l0xSZIkDZZOt/lXC70SeArwK+DkzFz0R4sGKbk5pmf5rBnKfnWK/SRJkiQVFhF7A++p3/5tZl7WRD0GKbl5RM/y96crmJnrgBvqt3tExOq+1UqSJEkDZ7Tb/Ktl/hlYBVwNvLWpSgxScrN/z/J1syjfW2b/KUtJkiRJmreIeAnwDKALvCwzf9lUXQZptLRdepbvmEX59VPsO62IeNAMRR44trBhw/rpys3adtstLxIHYMvmbYvFuuuuMj/fmHV3FJxXdcV9xUKtv6vcx2CbbcoNe7JDZ2OxWABsKDca46ZNdxaLte62cr//br+33K29y5ZtLhYLYP36cvE2bCjXNtYtu7tYrI2Ff2d0Ck6PcOut5T7n264v97ts/Yrbi8Vat7Xs+adTbhypkc3lzn/nznJtli0FR6m9595ysYA7lxdsGys3LDjG7evv93un3IVLgzZ3t2l0rpkt978MXxsR05bPzBv7WqF5iogHAO+r356Wmd9usj6DlNzs1LO8ZRble3/LrJrDcW6YuUjl9a9/1RzC6r1NV0AFfb5YpPd/qFgoNe7fmq7AAFr0gYQ0MM5tugLTWQ38rOlKLNS3tnlw01XoNe0jF7WlOnD0h6k6Em4G/qLhugxUciNJkqTmrWm6ApqdiDgXOKJQuBMy89MT4p8IHFe//dPMvKvQseZtkJKbu6km5gRYWb+fzvY9y7+Yw3H2mmH73sD59fJhwE1ziK2FW8v4txuHAOsarMsw8vw3y/PfLM9/szz/zXog8L16+cdNVmSB1jHztd5iWwvcTrNzis5ZRKwB/rF+e0ZmntFkfcYMUnKzkfHkZndmTm52m7DvrMx0P+OE+yFvWqr3P7bVhPO/zvO/uDz/zfL8N8vz3yzPf7MmnP9yD74usszcCiy1ttPP+nyO8cntF+qqCe8/SHVNfhfw6kLHWLBBSm6uAvatl/cFrp+h/L49yxP/MyRJkqRWy8wP9iNuROwM/H799nLgj2caEKHe7409b0/LzFtL122QkpvLgKPr5UOAc6YqGBF7MN7leFtmlhtyRJIkSRpuvYMbPKF+zcbbepbPBIonN4M0z81/9SwfM0PZZ/Ysn9WHukiSJElaYgap5+Y8qofA1gJPiYiDM/OSiYUiYjnw2p5Vn55YRpIkSdL8ZOZGZjk0dUR0e/br+3DWA9Nzk5mjwFt7Vn2iHqVhoncDv10vn5+ZZ/e9cpIkSZIaN0g9NwCnAc8Dng4cBFwaEacBVwC/CZwAPKkuuxF4RROVlCRJkrT4Biq5ycytEfF84FPAs6luUXvTJEVvBI7PzMsXs36SJEmSmjPS7XZnLrUERcRzgBdRjZy2hmqizmuBLwCnLoUZUiVJkqRhttjP3AxsciNJkiRJvQZmQAFJkiRJmo7JjSRJkqRWMLmRJEmS1AomN5IkSZJaweRGkiRJUiuY3EiSJElqBZMbSZIkSa1gciNJkiSpFbZpugKDJCKOA04CDgHWApuAa4AzgFMzc1OD1WuliDgXOGIOu+ybmdf3pzbtERHLgQOAxwKPqf99FLB9XeTjmflHc4z5UOAVwDHAXsBy4CbgG8BpmfnDIpVvgVLnPyL+CPjoHA79lsz867nUtY0iYhXwO8CRwMHAw4BdgHuBm4ELgU8BZ2fmrGa6tv3PXqnzb/ufn4g4BHgc1bXMQcBqYHdgW2AjcCVwDvCxzPzZLGPuSdX+jwX2ofpddgvwHeD0zPx22Z9CmprJzSxExE7AJ4HjJmxaXb8eD7wmIl6Qmd9b7PpJ8/AfwO+WChYRLwf+gfGL8zH71a9XRMRbM/OtpY454Iqef81eRPwZ8A5g5SSbVwH716+TgO9ExAsz8+czxLT9z1I/zr/m7Bxgxym2ralfRwCnRMRbMvNd0wWLiOdQJZm7Ttj0W/XrxRFxKvDqzBxdUM2lWTC5mUH9DetngaPrVbcCpwFXAL8JnAA8keqburMi4omZeWUTdR0Cz5tFmdv6Xot2WD7h/Z3AeqpvUOckIl4InFq/7QCfBr4JbKX6bLwY2A54S0T8MjPfM99Kt0ix89/jA8C3Zijz4wXEb4v9GL+wHutZuZjqd8dK4DDghcBOwJOBcyPisMyc9HeL7X/Oip7/Hrb/ubmNqofsUuA64C6qnpt9gGdRtd3tgHdGxLZTJeYRcSTVlzUr6lVfAb4M3EPVK/fHwM5UvTpd4FX9+XGkcSY3MzuZ8cTmCuCpmXlrz/YPRcR7gddRfWtxKnD44lZxOGTmF5uuQ4tcSHXrwcXAxZl53Txu8SAiVgMfqt92gOdl5pd7inwiIj5KdbG3A/D2iPhiZl610B9gwBU5/xNc4mdkVrrA14D3At/MzM6E7R+PiHcDZ1P1IOwLvBt46cRAtv95KXb+J7D9z95hwOXT3PL3roh4EfAxYAR4U0R8JDNv7i0UEdsBpzOe2LwmMz/YU+STdY/NeVS38r8yIj6bmTMlodKCOKDANOpemzf3rDppQmIz5vXA2P3UT46I3+l75aQFyMx3ZuYpmfm5zLxuAaH+HPiNevlDEy7sxo71PeBN9dttuP9naigVPP+auzdk5jMy8+uTXFgDUD9ncHzPquMjYodJitr+567k+dc8ZGXaZ8ky8xPAmfXbbRj/krfXS6l6egD+c0JiMxbnauDVPavePucKS3NkcjO9w4E96+XzMvOSyQrV95C+v2fVCf2umLRE9F6A/P005U6juk0B4LiImPhsgrQoMvPOWZa7FBjrYdkBeOgkxWz/c1T4/Ku/Lu9ZXjvJ9j/oWX7fNHG+CFxfLz8+Ih68wHpJ0zK5md4xPctnzVD2q1PsJ7VSRBwIjP2RunK6HojM/AXVqDlQPcg6lxHwpKb0joB5v4TE9r8opjz/WhS9CeW63g31iHdPqt/2tu9fU/fQ/VfPKq+R1Fc+czO9R/Qsf3+6gpm5LiJuoBpYYI+IWJ2Zt/e1dkMmIs4EHk01Qt09VEOGfhf4VGae02TdhtSsPx89ZcZubXgE9/9jp4X7k4h4PdXvoGXAHVS3y36VamjpzU1WbtBExAqqh9/HTBwS1/bfR7M4/xPZ/guKiGMZH8RnC9VAAb0OZPwL8h/MYhS07wOvrJcfMV1BaaFMbqa3f8/ybO6Lv47qF+vYviY3ZT2rZ3mX+nUgcHJEfAt4YWbe0kjNhtN8Ph+T7asyDpnwfq/6dSzVSF0vzcwzf303TeFEqlGeoHpYfd2E7bb//prp/E9k+5+HiDicauRXqAYG2ItqDqKxZ4e3Aq+c5Hlj27+WLJOb6e3Ss3zHLMqvn2JfLcwG4OvARVRDh44CDwSOoureHgGeClxQDxk60x9BleHnY2kYBS6gui3kauBuqvP7GOAFVBcuq4EvR8QfZua/N1XRQVGPgtY7ZPNkD0Hb/vtklud/jO1/Yf4GOHSS9V2qUc7ePMUEnLZ/LVkmN9PbqWd5yyzK39uzvKpwXYbVKVRD5d43ybb3RcRjgc8De1Pd/3468MxFrN8w8/PRvP8G9snMGyfZ9pGI+Auqh9mPp/oS4PSION9JEadW3w71eaqJDAG+mJlnTFLU9t8Hczj/YPvvp5uovlT8yRTbbf9ashxQQEtaZl4wRWIztv0iqvvYf1mvOiYiJt6eILVSZl4zxYXd2PZfAH8InFuvWkk1dL0mERHLqL4geXK96lpmnl9Fhcz1/Nv+Fy4zD8vMkcwcoUpYfhv4v1QJyDuAyyLiaU3WUZork5vp3d2zvHLKUuN6R3P5ReG6aAqZeSXwrz2rnt1UXYaMn48BUD/o+8aeVX4+JhERI8A/UV0MA/wceFpmbphiF9t/QfM4/7Ni+5+9zLwnMy/NzLdRDd5zM7Ab8JWImDgIgO1fS5bJzfQ29izvPovyu02xr/qvd7S0AxqrxXDx8zE4LmD81pG9nRDx/uoL6/8HvKxedSPw1My8fprdbP+FzPP8z4Xtf47qoc3/sn67AnjDhCK2fy1ZJjfTu6pned9ZlO8tc9WUpdQPvSPT+bDi4vDzMSDqeSZ6J0/0M1KrL6w/xPgwtTcBR2bmtTPsavsvYAHnf9Zs//PWO3/fUyZss/1ryTK5md5lPcvTPscREXswPgz0bc5xs+h6vznyW6HFMevPxyRlsnBdNI36WYZde1b5GeF+F9avqlfdTHVhfc0sdrf9L9ACz/9cjmP7n5/e28d2nbDtCqBTLz86IpbPEMv2r0VjcjO9ucyo2ztC11l9qIumd2TPst8KLYLMvILqvniAAyJin6nKRsROjD8kvJlqiFEtnsMYv+f9Ric0nPTC+haqC+upRoe6H9v/wiz0/M+R7X9+HtazfL8vbOvBGs6v364CnjRVkDq5fEbPqq9OVVYqweRmeucBY3OmPCUiDp6sUP2NxWt7Vn263xXTuIjYDzipZ5UTtS2ez/Qs/9k05V4O7Fgvf9mLi8VTX1i8tWeVn4/KBxm/sF5HdWF99Rxj2P7nr8T5n5Htf0Fe2bN8/iTbe691XjdNnOcyflva9wo+SyVNyuRmGvUoK72/FD8REWsmKfpuquETAc7PzLP7XrkhEBGvjYgnzFDm0cDZjI/W8rXM/J++V05j3sv4rQuvjojjJhaIiEOBt9VvtwJvWaS6tVpEPD4iXh4RU45UFBE7Ap+gmvAWqiHT3zNV+WERER8A/qR+uw54SmbOp8fX9j8PJc6/7X9+IuKVEXFk3XM2VZnlEfGXjP8fQTXgw0SnM957eWxEvHqSWA+j6qEb86Z5VFuak5Fut9t0HZa0iNiG6jazp9er1lFNCnYF1czHJzDeHbsReFJmXr7Y9WyjiPgi8ByquQ6+QXWf7nqqGakfQPUH65mMJ+k/A56QmTcvfm0HS0TsC/zxhNWPBI6tl38E/OeE7d/KzG9NEuvFwMfqtx2qb/O+TvX/9ETgxYwnn2/IzHcutP6DrsT5j4jnAmdQDcn6deBi4AbgHmBn4GDgDxgfpagLvCgz/63cTzJ4IuLtjI/81AX+CvjxLHa9ZLLJH23/c1Pq/Nv+5yciPkbVJm+gOm+XAbcB91ENtBBUf3f36dntXZn5V1PEexrVNdK29aozgS9T/T8cDJxM9f8BcFpmvrzcTyNNbpumK7DUZebWiHg+8Cmq8fHXMvk3DzcCx5vY9MVD6td0zgZeamIzaw/m14f27PXI+tVrK/BryU1mfrweWvV9VBdxJ9avXqPAO4b9wq5HsfNPNfHe8+rXVNYBJ2fmV+ZSyZbqfTZgBHjXLPd7CeNJzP+y/c9Z0fOP7X++9mLmCWrvAk7JzA9PVSAzvxERx1P14uxCdZ002VxCpzF+G6LUVyY3s1A/OHdsRDwHeBHVqB9rqG5HuBb4AnBqZt7VXC1b6XVU314fCjyK6pzvDmxH9Uv3eqr5Cz7prWjNyswPR8Q3qO7RPprqD+cyqtGPvgn8c2b+oMEqttE3qL5hPRR4HNU5343qAmMz1bexlwBfAf4jM7dMEUcLZPtvhO1/fl4LfAk4nGqizodQ/V3dlqoX7FaqnuOzgc/O5romM8+IiO9RJS/HUvX6rKQaJOK/gX/JzKEfREOLx9vSJEmSJLWCAwpIkiRJagWTG0mSJEmtYHIjSZIkqRVMbiRJkiS1gsmNJEmSpFYwuZEkSZLUCiY3kiRJklrB5EaSJElSK5jcSJIkSWoFkxtJkiRJrWByI0mSJKkVTG4kSZIktYLJjSRJkqRWMLmRJEmS1AomN5IkSZJaweRGkiRJUiuY3EiSJElqBZMbSZIkSa1gciNJkiSpFUxuJEmSJLWCyY0kSZKkVjC5kSRJktQKJjeSJEmSWsHkRpIkSVIrmNxIkiRJaoX/DzKjsU+fj7W1AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap\n", + "def plot_examples(colormaps):\n", + " \"\"\"\n", + " Helper function to plot data with associated colormap.\n", + " \"\"\"\n", + " np.random.seed(19680801)\n", + " data = np.random.randn(30, 30)\n", + " n = len(colormaps)\n", + " fig, axs = plt.subplots(1, n, figsize=(n * 2 + 2, 3),\n", + " constrained_layout=True, squeeze=False)\n", + " for [ax, cmap] in zip(axs.flat, colormaps):\n", + " psm = ax.pcolormesh(data, cmap=cmap, rasterized=True, vmin=-4, vmax=4)\n", + " fig.colorbar(psm, ax=ax)\n", + " plt.show() \n", + "\n", + "top = cm.get_cmap('Oranges_r', 128)\n", + "bottom = cm.get_cmap('Purples', 128)\n", + "\n", + "newcolors = np.vstack((top(np.linspace(0, 1, 128)),\n", + " bottom(np.linspace(0, 1, 128))))\n", + "orange_cm = ListedColormap(newcolors, name='OrangeBlue')\n", + "plot_examples([orange_cm])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": false + }, "outputs": [ { "data": { @@ -1170,7 +1234,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -1178,42 +1242,185 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, '$\\\\varphi_l/2\\\\pi$')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import cm\n", - "from matplotlib.colors import ListedColormap, LinearSegmentedColormap\n", - "def plot_examples(colormaps):\n", - " \"\"\"\n", - " Helper function to plot data with associated colormap.\n", - " \"\"\"\n", - " np.random.seed(19680801)\n", - " data = np.random.randn(30, 30)\n", - " n = len(colormaps)\n", - " fig, axs = plt.subplots(1, n, figsize=(n * 2 + 2, 3),\n", - " constrained_layout=True, squeeze=False)\n", - " for [ax, cmap] in zip(axs.flat, colormaps):\n", - " psm = ax.pcolormesh(data, cmap=cmap, rasterized=True, vmin=-4, vmax=4)\n", - " fig.colorbar(psm, ax=ax)\n", - " plt.show() \n", + "%matplotlib notebook\n", + "fig, ax = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(6, 5))\n", + "plt.subplots_adjust(\n", + " left=0.12,\n", + " bottom=None, \n", + " right=0.9,\n", + " top=None, \n", + " wspace=None, \n", + " hspace=None)\n", + "cb = defaultdict(lambda: defaultdict(int))\n", + "im = defaultdict(lambda: defaultdict(int))\n", "\n", - "top = cm.get_cmap('Oranges_r', 128)\n", - "bottom = cm.get_cmap('Purples', 128)\n", + "im[0][0] = ax[0][0].imshow(result[\"potential\"],\n", + " extent=[LOWER, UPPER, LOWER, UPPER],\n", + " origin='lower',\n", + " #cmap='viridis',\n", + " interpolation='bessel',\n", + " vmin=0, vmax=2.2)\n", + "ax[0][0].set_title(r\"$U_{min}/E_J$\", fontsize=14, loc=\"left\")\n", "\n", - "newcolors = np.vstack((top(np.linspace(0, 1, 128)),\n", - " bottom(np.linspace(0, 1, 128))))\n", - "orange_cm = ListedColormap(newcolors, name='OrangeBlue')\n", - "plot_examples([orange_cm])" + "im[0][1] = ax[0][1].imshow(result[\"phi02\"],\n", + " extent=[LOWER, UPPER, LOWER, UPPER],\n", + " origin='lower',\n", + " cmap=orange_cm,\n", + " interpolation='bessel',\n", + " vmin=-0.5, vmax=0.5)\n", + "ax[0][1].set_title(r\"$\\varphi_{02}$\", fontsize=14)\n", + "\n", + "im[1][0] = ax[1][0].imshow(result[\"phi01\"] + result[\"phi01\"],\n", + " extent=[LOWER, UPPER, LOWER, UPPER],\n", + " origin='lower',\n", + " cmap=orange_cm,\n", + " interpolation='bessel',\n", + " vmin=-0.5, vmax=0.5)\n", + "ax[1][0].set_title(r\"$\\varphi_{01} + \\varphi_{12}$\", fontsize=14)\n", + "\n", + "im[1][1] = ax[1][1].imshow(result[\"phi03\"] + result[\"phi03\"],\n", + " extent=[LOWER, UPPER, LOWER, UPPER],\n", + " origin='lower',\n", + " cmap=orange_cm,\n", + " interpolation='bessel',\n", + " vmin=-0.5, vmax=0.5)\n", + "ax[1][1].set_title(r\"$\\varphi_{03} + \\varphi_{32}$\", fontsize=14)\n", + "\n", + "# Colorbars\n", + "for (i, j) in list(itertools.product([0, 1], [0, 1])):\n", + " if i == 0 and j == 0:\n", + " cb[i][j] = fig.colorbar(im[i][j], ax=ax[i][j],\n", + " fraction=0.046, pad=0.04)\n", + " cb[i][j].ax.set_ylabel(\n", + " r\"$\\frac{U_{min}}{E_J}$\", fontsize=14, rotation=0, ha=\"left\", labelpad=-20, y=1.15)\n", + " cb[i][j].set_ticks([0, 0.5, 1, 1.5, 2])\n", + " else:\n", + " cb[i][j] = fig.colorbar(im[i][j], ax=ax[i][j],\n", + " fraction=0.046, pad=0.04)\n", + " cb[i][j].ax.set_ylabel(\n", + " r\"$\\frac{\\varphi}{2\\pi}$\", fontsize=12, rotation=0, ha=\"left\", labelpad=-40, y=1.15)\n", + " cb[i][j].set_ticks([-0.5, 0, 0.5])\n", + " cb[i][j].ax.tick_params(labelsize=12)\n", + "\n", + "# X ticks\n", + "ax[0][0].set_xticks([-0.5, 0, 0.5, 1, 1.5])\n", + "# Axes Labels\n", + "ax[0][0].set_ylabel(r\"$\\varphi_r/2\\pi$\", fontsize=14)\n", + "ax[1][0].set_xlabel(r\"$\\varphi_l/2\\pi$\", fontsize=14)\n", + "ax[1][0].set_ylabel(r\"$\\varphi_r/2\\pi$\", fontsize=14)\n", + "ax[1][1].set_xlabel(r\"$\\varphi_l/2\\pi$\", fontsize=14)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Supplementary points" ] }, { "cell_type": "code", - "execution_count": 89, - "metadata": { - "scrolled": false - }, + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Degeneracy\n", + "phiT0 = 2 * math.acos(math.sqrt(float(ALPHA ** 2 + 1)) - ALPHA) / (2 * math.pi)\n", + "phiT1 = (2 * pi - 2 *\n", + " math.acos(math.sqrt(float(ALPHA ** 2 + 1)) - ALPHA)) / (2 * math.pi)\n", + "ax[0][0].scatter(float(phiT0), float(phiT0), marker='D', color='red', s=15)\n", + "ax[0][0].scatter(float(phiT1), float(phiT1), marker='D', color='red', s=15)\n", + "ax[0][0].scatter(float(0.5), float(0.5), marker='D', color='C9', s=15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Supplementary lines" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ax[0][0].arrow(0.25, 0.25,\n", + " 0.5, 0.5,\n", + " color='red', head_width=0.1, head_starts_at_zero=False, linewidth=0.8)\n", + "ax[0][0].arrow(0.25, 0.75,\n", + " 0.5, -0.5,\n", + " color='yellow', head_width=0.12, head_starts_at_zero=False, \n", + " linestyle=(0, (2,5)),\n", + " linewidth=1)\n", + "\n", + "# curve2_coords = evaluate_endpoints_for_2d_phi_plus_slice(0.6, 0.2)\n", + "# ax_2d.plot([curve2_coords[\"x0\"], curve2_coords[\"x1\"]],\n", + "# [curve2_coords[\"y0\"], curve2_coords[\"y1\"]])\n", + "# curve3_coords = evaluate_endpoints_for_2d_phi_plus_slice(0.55, 0.2)\n", + "# ax_2d.plot([curve3_coords[\"x0\"], curve3_coords[\"x1\"]],\n", + "# [curve3_coords[\"y0\"], curve3_coords[\"y1\"]])\n", + "# curve4_coords = evaluate_endpoints_for_2d_phi_plus_slice(0.5, 0.2)\n", + "# ax_2d.plot([curve4_coords[\"x0\"], curve4_coords[\"x1\"]],\n", + "# [curve4_coords[\"y0\"], curve4_coords[\"y1\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "plotter.save_onto_white_background(ax, \"./output/potential_minimum_diamonds\", \"svg\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Individual plots" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, "outputs": [ { "data": { @@ -1995,7 +2202,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -2003,185 +2210,87 @@ }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, '$\\\\varphi_l/2\\\\pi$')" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ "%matplotlib notebook\n", - "fig, ax = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(6, 5))\n", - "plt.subplots_adjust(\n", - " left=0.12,\n", - " bottom=None, \n", - " right=0.9,\n", - " top=None, \n", - " wspace=None, \n", - " hspace=None)\n", - "cb = defaultdict(lambda: defaultdict(int))\n", - "im = defaultdict(lambda: defaultdict(int))\n", + "fig, ax = plt.subplots(1, 1, sharex=True, sharey=True, figsize=(4, 3))\n", + "# plt.subplots_adjust(\n", + "# left=0.12,\n", + "# bottom=None, \n", + "# right=0.9,\n", + "# top=None, \n", + "# wspace=None, \n", + "# hspace=None)\n", + "# cb = defaultdict(lambda: defaultdict(int))\n", + "# im = defaultdict(lambda: defaultdict(int))\n", "\n", - "im[0][0] = ax[0][0].imshow(result[\"potential\"],\n", + "im= ax.imshow(result[\"potential\"],\n", " extent=[LOWER, UPPER, LOWER, UPPER],\n", " origin='lower',\n", " #cmap='viridis',\n", " interpolation='bessel',\n", " vmin=0, vmax=2.2)\n", - "ax[0][0].set_title(r\"$U_{min}/E_J$\", fontsize=14, loc=\"left\")\n", - "\n", - "im[0][1] = ax[0][1].imshow(result[\"phi02\"],\n", - " extent=[LOWER, UPPER, LOWER, UPPER],\n", - " origin='lower',\n", - " cmap=orange_cm,\n", - " interpolation='bessel',\n", - " vmin=-0.5, vmax=0.5)\n", - "ax[0][1].set_title(r\"$\\varphi_{02}$\", fontsize=14)\n", - "\n", - "im[1][0] = ax[1][0].imshow(result[\"phi01\"] + result[\"phi01\"],\n", - " extent=[LOWER, UPPER, LOWER, UPPER],\n", - " origin='lower',\n", - " cmap=orange_cm,\n", - " interpolation='bessel',\n", - " vmin=-0.5, vmax=0.5)\n", - "ax[1][0].set_title(r\"$\\varphi_{01} + \\varphi_{12}$\", fontsize=14)\n", - "\n", - "im[1][1] = ax[1][1].imshow(result[\"phi03\"] + result[\"phi03\"],\n", - " extent=[LOWER, UPPER, LOWER, UPPER],\n", - " origin='lower',\n", - " cmap=orange_cm,\n", - " interpolation='bessel',\n", - " vmin=-0.5, vmax=0.5)\n", - "ax[1][1].set_title(r\"$\\varphi_{03} + \\varphi_{32}$\", fontsize=14)\n", "\n", "# Colorbars\n", - "for (i, j) in list(itertools.product([0, 1], [0, 1])):\n", - " if i == 0 and j == 0:\n", - " cb[i][j] = fig.colorbar(im[i][j], ax=ax[i][j],\n", - " fraction=0.046, pad=0.04)\n", - " cb[i][j].ax.set_ylabel(\n", - " r\"$\\frac{U_{min}}{E_J}$\", fontsize=14, rotation=0, ha=\"left\", labelpad=-20, y=1.15)\n", - " cb[i][j].set_ticks([0, 0.5, 1, 1.5, 2])\n", - " else:\n", - " cb[i][j] = fig.colorbar(im[i][j], ax=ax[i][j],\n", - " fraction=0.046, pad=0.04)\n", - " cb[i][j].ax.set_ylabel(\n", - " r\"$\\frac{\\varphi}{2\\pi}$\", fontsize=12, rotation=0, ha=\"left\", labelpad=-40, y=1.15)\n", - " cb[i][j].set_ticks([-0.5, 0, 0.5])\n", - " cb[i][j].ax.tick_params(labelsize=12)\n", + "cb = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)\n", + "cb.ax.set_ylabel(\n", + " r\"$\\frac{U_{min}}{E_J}$\", fontsize=14, rotation=0, ha=\"left\", labelpad=-20, y=1.15)\n", + "cb.set_ticks([0, 0.5, 1, 1.5, 2])\n", + "# cb.ax.tick_params(labelsize=12)\n", "\n", "# X ticks\n", - "ax[0][0].set_xticks([-0.5, 0, 0.5, 1, 1.5])\n", + "ax.set_xticks([-0.5, 0, 0.5, 1, 1.5])\n", + "ax.set_yticks([-0.5, 0, 0.5, 1, 1.5])\n", + "\n", "# Axes Labels\n", - "ax[0][0].set_ylabel(r\"$\\varphi_r/2\\pi$\", fontsize=14)\n", - "ax[1][0].set_xlabel(r\"$\\varphi_l/2\\pi$\", fontsize=14)\n", - "ax[1][0].set_ylabel(r\"$\\varphi_r/2\\pi$\", fontsize=14)\n", - "ax[1][1].set_xlabel(r\"$\\varphi_l/2\\pi$\", fontsize=14)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Supplementary points" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 90, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ + "ax.set_ylabel(r\"$\\varphi_r/2\\pi$\", fontsize=14)\n", + "ax.set_xlabel(r\"$\\varphi_l/2\\pi$\", fontsize=14)\n", + "\n", "# Degeneracy\n", "phiT0 = 2 * math.acos(math.sqrt(float(ALPHA ** 2 + 1)) - ALPHA) / (2 * math.pi)\n", "phiT1 = (2 * pi - 2 *\n", " math.acos(math.sqrt(float(ALPHA ** 2 + 1)) - ALPHA)) / (2 * math.pi)\n", - "ax[0][0].scatter(float(phiT0), float(phiT0), marker='D', color='red', s=15)\n", - "ax[0][0].scatter(float(phiT1), float(phiT1), marker='D', color='red', s=15)\n", - "ax[0][0].scatter(float(0.5), float(0.5), marker='D', color='C9', s=15)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Supplementary lines" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ax[0][0].arrow(0.25, 0.25,\n", + "ax.scatter(float(phiT0), float(phiT0), marker='D', color='red', s=15)\n", + "ax.scatter(float(phiT1), float(phiT1), marker='D', color='red', s=15)\n", + "ax.scatter(float(0.5), float(0.5), marker='D', color='C9', s=15)\n", + "\n", + "ax.arrow(0.25, 0.25,\n", " 0.5, 0.5,\n", " color='red', head_width=0.1, head_starts_at_zero=False, linewidth=0.8)\n", - "ax[0][0].arrow(0.25, 0.75,\n", + "ax.arrow(0.25, 0.75,\n", " 0.5, -0.5,\n", " color='yellow', head_width=0.12, head_starts_at_zero=False, \n", " linestyle=(0, (2,5)),\n", " linewidth=1)\n", "\n", - "# curve2_coords = evaluate_endpoints_for_2d_phi_plus_slice(0.6, 0.2)\n", - "# ax_2d.plot([curve2_coords[\"x0\"], curve2_coords[\"x1\"]],\n", - "# [curve2_coords[\"y0\"], curve2_coords[\"y1\"]])\n", - "# curve3_coords = evaluate_endpoints_for_2d_phi_plus_slice(0.55, 0.2)\n", - "# ax_2d.plot([curve3_coords[\"x0\"], curve3_coords[\"x1\"]],\n", - "# [curve3_coords[\"y0\"], curve3_coords[\"y1\"]])\n", - "# curve4_coords = evaluate_endpoints_for_2d_phi_plus_slice(0.5, 0.2)\n", - "# ax_2d.plot([curve4_coords[\"x0\"], curve4_coords[\"x1\"]],\n", - "# [curve4_coords[\"y0\"], curve4_coords[\"y1\"]])" + "plt.tight_layout()" ] }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 148, "metadata": {}, "outputs": [], "source": [ - "plotter.save_onto_white_background(ax, \"./output/potential_minimum_diamonds\", \"svg\")" + "plotter.save_onto_white_background(ax, \"./output/potential_minimum_energy\", \"svg\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "## 3D Plot of potential" ] }, { "cell_type": "code", - "execution_count": 140, - "metadata": {}, + "execution_count": 20, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -2963,7 +3072,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -2975,10 +3084,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 140, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -2994,8 +3103,9 @@ " result[\"potential\"],\n", " #result[\"phi02\"], \n", " #quadrants[\"potential\"][0][0],\n", - " cmap=cm.coolwarm,\n", + " cmap=cm.viridis,\n", " linewidth=0, antialiased=True)\n", + "ax.plot\n", "fig.colorbar(surf, shrink=0.5, aspect=10)" ] }, @@ -3010,7 +3120,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "### Naive approximation\n", "Just immediately expand the cosines, no thinking about if it is valid\n", @@ -3020,9 +3132,10 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 12, "metadata": { - "cell_style": "split" + "cell_style": "split", + "hidden": true }, "outputs": [], "source": [ @@ -3039,9 +3152,10 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 13, "metadata": { - "cell_style": "split" + "cell_style": "split", + "hidden": true }, "outputs": [], "source": [ @@ -3074,8 +3188,10 @@ }, { "cell_type": "code", - "execution_count": 101, - "metadata": {}, + "execution_count": 14, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -3857,7 +3973,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -3903,7 +4019,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 15, "metadata": { "cell_style": "split" }, @@ -3921,7 +4037,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 16, "metadata": { "cell_style": "split" }, @@ -3966,7 +4082,7 @@ }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 154, "metadata": {}, "outputs": [ { @@ -4749,7 +4865,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -4761,35 +4877,69 @@ ], "source": [ "%matplotlib notebook\n", - "fig, ax = plt.subplots(1, 1, figsize=(4, 1.5))\n", + "fig, ax = plt.subplots(1, 1, figsize=(4, 3))\n", "plt.subplots_adjust(left=None, bottom=0.2, right=None, top=None, wspace=1, hspace=None)\n", "\n", - "ax.plot(potential_slice[\"potential_phi_approximation_01\"], color='red')\n", - "ax.plot(potential_slice[\"potential_phi_approximation_10\"], color='red')\n", - "ax.plot(potential_slice[\"potential_phi_approximation\"], color='red')\n", - "ax.plot(potential_slice[\"potential_phi_plus\"], linewidth=3)\n", + "ax.plot(potential_slice[\"potential_phi_approximation_01\"], color='red', linestyle=\"--\")\n", + "ax.plot(potential_slice[\"potential_phi_approximation_10\"], color='red', linestyle=\"--\")\n", + "# ax.plot(potential_slice[\"potential_phi_approximation\"], color='red')\n", + "y1 = potential_slice[\"potential_phi_plus\"]\n", + "\n", + "# For some reason, raw point cannot be plotted\n", + "y = np.ones(len(y))\n", + "for i in range(0, len(y)):\n", + " y[i] = y1[i]\n", + "x = np.arange(0, len(y))\n", + "\n", + "# Create a set of line segments so that we can color them individually\n", + "# This creates the points as a N x 1 x 2 array so that we can stack points\n", + "# together easily to get the segments. The segments array for line collection\n", + "# needs to be numlines x points per line x 2 (x and y)\n", + "points = np.array([x, y]).T.reshape(-1, 1, 2)\n", + "segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + "lc = LineCollection(segments, \n", + " cmap=plt.get_cmap('viridis'),\n", + " norm=plt.Normalize(0, 1)\n", + " )\n", + "\n", + "# Set the data that the cmap will be applied according to\n", + "lc.set_array(y)\n", + "lc.set_linewidth(5)\n", + "# Add to axes - need to set limits as well\n", + "ax.add_collection(lc)\n", + "ax.set_xlim([0, len(x)])\n", "\n", + "ax.set_xlabel(r\"$\\varphi_-=(\\varphi_l - \\varphi_r)/2$\", fontsize=14)\n", + "ax.set_ylabel(r\"${U_{min}}/{E_J}$\",\n", + " fontsize=14\n", + "# , fontsize=14, rotation=0, ha=\"left\", labelpad=-20, y=1.15\n", + " )\n", "\n", "# X ticks\n", "ax.set_xticks(np.linspace(0, NUMBER_OF_FIELD_POINTS, 5))\n", "ax.set_ylim([0, 3])\n", "ax.set_xticklabels([-0.5, 0, 0.5, 1, 1.5])\n", - "ax.set_yticklabels([])\n", - "ax.tick_params(labelsize=22)" + "# ax.set_yticklabels([])\n", + "ax.tick_params(labelsize=14)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 155, "metadata": {}, "outputs": [], "source": [ - "plotter.save_onto_white_background(ax, \"./output/potential_minimum_diamonds_inset\", \"svg\")" + "plotter.save_onto_white_background(ax, \"./output/potential_minimum_cross_section\", \"svg\")" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "# 2D Plot of potential\n", "Investigate region around the degenreacy point" @@ -4797,15 +4947,19 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Parameters" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": 13, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "from kernels.potential_evaluated_in_phi02_phi01_plane import PotentialEvaluatedInPhi02Phi02Plane\n", @@ -4825,15 +4979,19 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Kernel creation" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": 14, + "metadata": { + "hidden": true + }, "outputs": [ { "name": "stdout", @@ -4854,15 +5012,19 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Array allocation on GPU" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "execution_count": 15, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "DEVICE_phi01_array = cuda.to_device(phi01_array)\n", @@ -4877,15 +5039,19 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Running" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": 16, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "output_2d_plot = {}\n", @@ -4904,7 +5070,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Post processing\n", "Now minimise $U(\\varphi_{01}, \\varphi_{02})$ with respect to $\\varphi_{01}$\n" @@ -4912,7 +5080,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "### Warning\n", "Remember! Matplotlib is retarded!\n", @@ -4927,8 +5097,10 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, + "execution_count": 20, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "def reflect_in_line(x_array: List[float], y_array: List[float],\n", @@ -4957,22 +5129,11 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "execution_count": 21, + "metadata": { + "hidden": true + }, + "outputs": [], "source": [ "plt.contourf(\n", " phi02_array / (2 * pi),\n", @@ -4995,15 +5156,19 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "### Run the search" ] }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": 22, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "potential_minimised_wrt_phi01_phi03 = defaultdict(lambda: defaultdict(int))\n", @@ -5021,7 +5186,9 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Plotting\n", "**Note that in the array**\n", @@ -5031,8 +5198,10 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, + "execution_count": 38, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -5814,7 +5983,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -5829,7 +5998,7 @@ "Text(0, 0.5, '$U_{min}/E_J$')" ] }, - "execution_count": 23, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -5837,6 +6006,8 @@ "source": [ "%matplotlib notebook\n", "\n", + "FONTSIZE = 17\n", + "\n", "fig = plt.figure(figsize=(9,5))\n", "ax = defaultdict(lambda: defaultdict(int))\n", "ax[0][0] = fig.add_subplot(2,3,1)\n", @@ -5867,7 +6038,7 @@ " potential_minimised_wrt_phi01_phi03[\"0.8\"][\"phi01_plot\"][1:-1] / (2 * pi),\n", " color='C2', marker='.', alpha=0.05\n", ")\n", - "ax[1][0].set_title(r\"$\\alpha=0.8$\", fontsize=14)\n", + "ax[1][0].set_title(r\"$\\alpha=0.8$\", fontsize=FONTSIZE)\n", "ax[1][0].plot(\n", " phi02_array / (2 * pi), \n", " potential_minimised_wrt_phi01_phi03[\"0.8\"][\"potential\"],\n", @@ -5883,7 +6054,7 @@ " potential_minimised_wrt_phi01_phi03[\"1\"][\"phi01_plot\"][1:-1] / (2 * pi),\n", " color='C2', marker='.', alpha=0.05\n", ")\n", - "ax[1][1].set_title(r\"$\\alpha=1.0$\", fontsize=14)\n", + "ax[1][1].set_title(r\"$\\alpha=1.0$\", fontsize=FONTSIZE)\n", "ax[1][1].plot(\n", " phi02_array / (2 * pi), \n", " potential_minimised_wrt_phi01_phi03[\"1\"][\"potential\"],\n", @@ -5899,7 +6070,7 @@ " potential_minimised_wrt_phi01_phi03[\"1.2\"][\"phi01_plot\"][1:-1] / (2 * pi),\n", " color='C2', marker='.', alpha=0.05\n", ")\n", - "ax[1][2].set_title(r\"$\\alpha=1.2$\", fontsize=14)\n", + "ax[1][2].set_title(r\"$\\alpha=1.2$\", fontsize=FONTSIZE)\n", "ax[1][2].plot(\n", " phi02_array / (2 * pi), \n", " potential_minimised_wrt_phi01_phi03[\"1.2\"][\"potential\"],\n", @@ -5915,21 +6086,26 @@ " fraction=1\n", " )\n", "cb.ax.set_ylabel(\n", - " r\"$\\frac{U_{min}}{E_J}$\", fontsize=12, rotation=0, ha=\"left\", labelpad=-20, y=1.15)\n", - "cb.ax.tick_params(labelsize=12)\n", + " r\"$\\frac{U_{min}}{E_J}$\", fontsize=FONTSIZE, rotation=0, ha=\"left\", labelpad=-30, y=1.25)\n", + "cb.ax.tick_params(labelsize=FONTSIZE)\n", "cb.set_ticks([3, 4, 5, 6])\n", "\n", "# Axes labels\n", "for i in range(0, 3):\n", " ax[1][i].set_xticks([0, 0.5, 1.0])\n", - " ax[1][i].set_xlabel(r\"$\\varphi_{02}/2\\pi$\", fontsize=14)\n", - "ax[0][0].set_ylabel(r\"$\\varphi_{01}/2\\pi$\", fontsize=14)\n", - "ax[1][0].set_ylabel(r\"$U_{min}/E_J$\", fontsize=14)" + " ax[1][i].set_xlabel(r\"$\\varphi_{02}/2\\pi$\", fontsize=FONTSIZE)\n", + " ax[1][i].tick_params(axis='both', which='major', labelsize=FONTSIZE)\n", + " ax[0][i].tick_params(axis='both', which='major', labelsize=FONTSIZE)\n", + "\n", + "ax[0][0].set_ylabel(r\"$\\varphi_{01}/2\\pi$\", fontsize=FONTSIZE)\n", + "ax[1][0].set_ylabel(r\"$U_{min}/E_J$\", fontsize=FONTSIZE)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "### Add the potential dips in double well\n", "\\begin{equation}\n", @@ -5939,8 +6115,10 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, + "execution_count": 35, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "def dip_evaluator() -> List[Dict]:\n", @@ -5967,16 +6145,18 @@ }, { "cell_type": "code", - "execution_count": 25, - "metadata": {}, + "execution_count": 36, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 25, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -5997,19 +6177,30 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "## Save" ] }, { "cell_type": "code", - "execution_count": 26, - "metadata": {}, + "execution_count": 37, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "plotter.save_onto_white_background(ax, \"./output/potential_inspection\", \"svg\")" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rabi oscillations" + ] } ], "metadata": {