From 91e5631ee326d83f89a24ffe33b5ad8c9cef9866 Mon Sep 17 00:00:00 2001 From: Christopher Kung Date: Mon, 13 May 2024 10:20:21 -0400 Subject: [PATCH] Updated notebooks with Quantity --- ....ipynb => 01_serialize_fortran_data.ipynb} | 166 +++++- ...b => 02_read_serialized_data_python.ipynb} | 70 ++- ...{01_basics.ipynb => 01_gt4py_basics.ipynb} | 437 +++++++-------- examples/NDSL/02_NDSL_basics.ipynb | 512 ++++++++++++++++++ examples/NDSL/NDSL_basics.ipynb | 353 ------------ 5 files changed, 940 insertions(+), 598 deletions(-) rename examples/Fortran_porting/{01.ipynb => 01_serialize_fortran_data.ipynb} (78%) rename examples/Fortran_porting/{02.ipynb => 02_read_serialized_data_python.ipynb} (83%) rename examples/NDSL/{01_basics.ipynb => 01_gt4py_basics.ipynb} (70%) create mode 100644 examples/NDSL/02_NDSL_basics.ipynb delete mode 100644 examples/NDSL/NDSL_basics.ipynb diff --git a/examples/Fortran_porting/01.ipynb b/examples/Fortran_porting/01_serialize_fortran_data.ipynb similarity index 78% rename from examples/Fortran_porting/01.ipynb rename to examples/Fortran_porting/01_serialize_fortran_data.ipynb index f8df3489..743d15ee 100644 --- a/examples/Fortran_porting/01.ipynb +++ b/examples/Fortran_porting/01_serialize_fortran_data.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## **Serialbox Tutorial : Extracting Data from Fortran**\n", + "## **Serialbox Tutorial : Serializing Fortran Data**\n", "\n", "This notebook will cover the basics on extracting data within a Fortran program using [Serialbox](https://gridtools.github.io/serialbox/).\n", "\n", @@ -53,22 +53,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: SERIALBOX_EXAMPLE_PATH=/home/ckung/Documents/Code/SMT-Nebulae-Tutorial/tutorial/Fortran_porting\n", + "env: SERIALBOX_INSTALL_PATH=/home/ckung/Documents/Code/SMT-Nebulae/sw_stack_path/install/serialbox/\n" + ] + } + ], "source": [ "# Change SERIALBOX_EXAMPLE_PATH and SERIALBOX_INSTALL_PATH to appropriate paths\n", - "%env SERIALBOX_EXAMPLE_PATH=/home/ckung/Documents/Code/NDSL/examples/serialbox\n", + "%env SERIALBOX_EXAMPLE_PATH=/home/ckung/Documents/Code/SMT-Nebulae-Tutorial/tutorial/Fortran_porting\n", "%env SERIALBOX_INSTALL_PATH=/home/ckung/Documents/Code/SMT-Nebulae/sw_stack_path/install/serialbox/" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "vscode": { "languageId": "shellscript" @@ -99,13 +108,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing testSerialBox.F90\n" + ] + } + ], "source": [ "%%writefile testSerialBox.F90\n", "\n", @@ -181,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "vscode": { "languageId": "shellscript" @@ -217,13 +234,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file testSerialBox.F90\n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -247,13 +272,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 16\n", + "drwxrwxr-x 2 ckung ckung 4096 May 13 10:08 .\n", + "drwxrwxr-x 3 ckung ckung 4096 May 13 10:08 ..\n", + "-rw-rw-r-- 1 ckung ckung 5033 May 13 10:08 testSerialBox.F90\n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -284,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "vscode": { "languageId": "shellscript" @@ -317,13 +353,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sum(Qin_out) = 58.7446289 \n", + " sum(MASS) = 62.1698570 \n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " >>> WARNING: SERIALIZATION IS ON <<<\n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " sum(Qin_out) = 58.7851906 \n", + " sum(FILLQ_out) = 0.252184689 \n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -340,13 +390,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 1028\n", + "drwxrwxr-x 2 ckung ckung 4096 May 13 10:08 .\n", + "drwxrwxr-x 3 ckung ckung 4096 May 13 10:08 ..\n", + "-rw-rw-r-- 1 ckung ckung 872 May 13 10:08 ArchiveMetaData-FILLQ2ZERO_InOut.json\n", + "-rw-rw-r-- 1 ckung ckung 100 May 13 10:08 FILLQ2ZERO_InOut_fq_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 100 May 13 10:08 FILLQ2ZERO_InOut_fq_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_m_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_m_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_q_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 500 May 13 10:08 FILLQ2ZERO_InOut_q_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 7157 May 13 10:08 MetaData-FILLQ2ZERO_InOut.json\n", + "-rwxrwxr-x 1 ckung ckung 997608 May 13 10:08 testSerialBox.bin\n", + "-rw-rw-r-- 1 ckung ckung 5033 May 13 10:08 testSerialBox.F90\n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -373,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { "vscode": { "languageId": "shellscript" @@ -395,13 +465,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing testSerialBox_ts.F90\n" + ] + } + ], "source": [ "%%writefile testSerialBox_ts.F90\n", "\n", @@ -482,13 +560,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "vscode": { "languageId": "shellscript" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing file testSerialBox_ts.F90\n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " >>> WARNING: SERIALIZATION IS ON <<<\n", + " >>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<\n", + " sum(Qin_out) = 61.9121895 \n", + " sum(MASS) = 59.9121780 \n", + " sum(Qin_out) = 56.1568756 \n", + " sum(MASS) = 64.7800751 \n", + " sum(Qin_out) = 61.0407639 \n", + " sum(MASS) = 63.4687958 \n", + " sum(Qin_out) = 58.9772873 \n", + " sum(MASS) = 62.4764175 \n", + " sum(Qin_out) = 62.8103752 \n", + " sum(MASS) = 63.0623398 \n", + " sum(Qin_out) = 64.0034027 \n", + " sum(MASS) = 59.7669296 \n", + " sum(Qin_out) = 66.0840454 \n", + " sum(MASS) = 58.6753502 \n", + " sum(Qin_out) = 60.5121956 \n", + " sum(MASS) = 62.7025185 \n", + " sum(Qin_out) = 65.6868591 \n", + " sum(MASS) = 70.1329956 \n", + " sum(Qin_out) = 60.6698227 \n", + " sum(MASS) = 63.8359032 \n", + "total 1052\n", + "drwxrwxr-x 2 ckung ckung 4096 May 13 10:08 .\n", + "drwxrwxr-x 3 ckung ckung 4096 May 13 10:08 ..\n", + "-rw-rw-r-- 1 ckung ckung 6457 May 13 10:08 ArchiveMetaData-FILLQ2ZERO_InOut.json\n", + "-rw-rw-r-- 1 ckung ckung 1000 May 13 10:08 FILLQ2ZERO_InOut_fq_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 1000 May 13 10:08 FILLQ2ZERO_InOut_fq_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_m_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_m_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_q_in.dat\n", + "-rw-rw-r-- 1 ckung ckung 5000 May 13 10:08 FILLQ2ZERO_InOut_q_out.dat\n", + "-rw-rw-r-- 1 ckung ckung 9456 May 13 10:08 MetaData-FILLQ2ZERO_InOut.json\n", + "-rwxrwxr-x 1 ckung ckung 997648 May 13 10:08 testSerialBox_ts.bin\n", + "-rw-rw-r-- 1 ckung ckung 5117 May 13 10:08 testSerialBox_ts.F90\n" + ] + } + ], "source": [ "%%bash\n", "\n", diff --git a/examples/Fortran_porting/02.ipynb b/examples/Fortran_porting/02_read_serialized_data_python.ipynb similarity index 83% rename from examples/Fortran_porting/02.ipynb rename to examples/Fortran_porting/02_read_serialized_data_python.ipynb index a2aeb381..01223d8a 100644 --- a/examples/Fortran_porting/02.ipynb +++ b/examples/Fortran_porting/02_read_serialized_data_python.ipynb @@ -42,9 +42,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of Qin_out = 58.74463748931885\n", + "Sum of mass = 62.169867515563965\n", + "Sum of fq_out = 0.0\n" + ] + } + ], "source": [ "import sys\n", "# Appends the Serialbox python path to PYTHONPATH. If needed, change to appropriate path containing serialbox installation\n", @@ -75,9 +85,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of Qin_out = 58.78519535064697\n", + "Sum of fq_out = 0.25218469463288784\n", + "True\n", + "True\n" + ] + } + ], "source": [ "def fillq2zero1(Q, MASS, FILLQ):\n", " IM = Q.shape[0]\n", @@ -121,9 +142,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current savepoint = sp1 {\"timestep\": 1}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 2}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 3}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 4}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 5}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 6}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 7}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 8}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 9}\n", + "True\n", + "True\n", + "Current savepoint = sp1 {\"timestep\": 10}\n", + "True\n", + "True\n" + ] + } + ], "source": [ "# If needed, change the path in second parameter of ser.Serializer to appropriate path that contains Fortran data via Serialbox from 01.ipynb\n", "serializer = ser.Serializer(ser.OpenModeKind.Read,\"./Fortran_ts/sb/\",\"FILLQ2ZERO_InOut\")\n", diff --git a/examples/NDSL/01_basics.ipynb b/examples/NDSL/01_gt4py_basics.ipynb similarity index 70% rename from examples/NDSL/01_basics.ipynb rename to examples/NDSL/01_gt4py_basics.ipynb index bbe36207..06530007 100755 --- a/examples/NDSL/01_basics.ipynb +++ b/examples/NDSL/01_gt4py_basics.ipynb @@ -36,29 +36,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-05-09 16:09:06|INFO|rank 0|ndsl.logging:Constant selected: ConstantVersions.GFS\n" - ] - } - ], + "outputs": [], "source": [ "from gt4py.cartesian.gtscript import PARALLEL, computation, interval, stencil\n", "from ndsl.dsl.typing import FloatField\n", @@ -76,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -111,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -160,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -243,7 +223,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing `copy_stencil`\")\n", - "copy_stencil(qty_in.data, qty_out.data)\n", + "copy_stencil(qty_in, qty_out)\n", "print(\"Plotting qty_out from `copy_stencil` at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Plotting qty_out from `copy_stencil` at K = 1\")\n", @@ -254,20 +234,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### **Choosing subsets (or offsets) to perform stencil calculations**\n", + "### **Setting domain subsets in a stencil call**\n", "\n", - "GT4Py also allows a subset of the `IJ` plane to be specified and executed in a fashion similar to using `interval(...)` in the K interval. This is done by setting `origin` and `domain` when executing the stencil.\n", + "GT4Py also allows a subset to be specified from a stencil call and executed in a fashion similar to using `interval(...)` in the K interval. This is done by setting the stencil call's `origin` and `domain` argument.\n", "\n", - "- `origin` : This specifies the \"starting\" coordinate to perform computations in the `IJ` plane. \n", + "- `origin` : This specifies the \"starting\" coordinate to perform computations. \n", "\n", "- `domain` : This specifies the range of the stencil computation based on `origin` as the \"starting\" coordinate (Note: May need to check whether this affects `interval()`)\n", "\n", - "If these two parameters are not set, the GT4py stencil by default will iterate over the entire input domain. The following demonstrates the effect of specifying different `origin` and `domain`." + "If these two parameters are not set, the stencil call by default will iterate over the entire input domain. The following demonstrates the effect of specifying different `origin` and `domain`." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -526,7 +506,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing `copy_stencil` with origin=(1,0,0)\")\n", - "copy_stencil(qty_in.data, qty_out.data,origin=(1,0,0))\n", + "copy_stencil(qty_in, qty_out,origin=(1,0,0))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(1,0,0)\")\n", "plot_field_at_kN(qty_out.data)\n", "\n", @@ -540,7 +520,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing `copy_stencil` with origin=(0,1,0)\")\n", - "copy_stencil(qty_in.data, qty_out.data,origin=(0,1,0))\n", + "copy_stencil(qty_in, qty_out,origin=(0,1,0))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,1,0)\")\n", "plot_field_at_kN(qty_out.data)\n", "\n", @@ -554,7 +534,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing `copy_stencil` with origin = (0,0,1)\")\n", - "copy_stencil(qty_in.data, qty_out.data,origin=(0,0,1))\n", + "copy_stencil(qty_in, qty_out,origin=(0,0,1))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin=(0,0,1)\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Plotting qty_out at K = 1 based on `copy_stencil` with origin=(0,0,1)\")\n", @@ -571,7 +551,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing `copy_stencil` with domain=(2,2,nz)\")\n", - "copy_stencil(qty_in.data, qty_out.data, domain=(2,2,nz))\n", + "copy_stencil(qty_in, qty_out, domain=(2,2,nz))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with domain = (2,2,nz)\")\n", "plot_field_at_kN(qty_out.data)\n", "\n", @@ -584,7 +564,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing `copy_stencil` with origin = (2,2,0), domain=(2,2,nz)\")\n", - "copy_stencil(qty_in.data, qty_out.data, origin=(2,2,0), domain=(2,2,nz))\n", + "copy_stencil(qty_in, qty_out, origin=(2,2,0), domain=(2,2,nz))\n", "print(\"Plotting qty_out at K = 0 based on `copy_stencil` with origin = (2,2,0), domain = (2,2,nz)\")\n", "plot_field_at_kN(qty_out.data)" ] @@ -593,14 +573,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### **`FORWARD` and `BACKWARD` `computation` keywords**\n", + "### **`FORWARD` and `BACKWARD` `computation` keywords and Offset Indexing within a stencil call**\n", + "\n", + "Besides `PARALLEL`, the developer can specify `FORWARD` or `BACKWARD` as the iteration policy in `K` for a stencil. Essentially, the `FORWARD` policy has `K` iterating consecutively starting from the lowest vertical index to the highest, while the `BACKWARD` policy performs the reverse.\n", + "\n", + "An array-based stencil variable can also have an integer dimensional offset if the array variable is on the right hand side of the `=` for the computation. When a computation is performed at a particular point, an offset variable's coordinate is based on that particular point plus (or minus) the offset in the offset dimension.\n", "\n", - "Besides `PARALLEL`, the developer can specify `FORWARD` or `BACKWARD` as the iteration policy in `K`. Essentially, the `FORWARD` policy has `K` iterating consecutively starting from the lowest vertical index to the highest, while the `BACKWARD` policy performs the reverse. The following examples demonstrate the use of these two iteration policies." + "The following examples demonstrate the use of these two iteration policies and also offset indexing in the `K` dimension. Note that offsets can also be applied to the `I` or `J` dimension." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -625,32 +609,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Plotting values of qty_out at K = 0\n", - "Min and max values: 0.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing 'copy_stencil' with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", - "Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", - "Min and max values: 10.0 0.0\n" + "Plotting values of qty_in at K = 1\n", + "Min and max values: 13.0 1.0\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAHHCAYAAABEJtrOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAArhklEQVR4nO3dfXQVdX7H8c8lkJsISUgigWQJgVUUeRQIUEAFJKvNAZT21AcauhG3at2wPORYWU4VEFcudluLCg0P2wJrRXBdeVhcoCyPR1cWApsetC2CRo2yAbWaJ03Ae6d/KPdwTYDkztzMnZn365zfOd7JzJ3v4IFvvt/fb2Z8hmEYAgAAjtTB7gAAAED0SOQAADgYiRwAAAcjkQMA4GAkcgAAHIxEDgCAg5HIAQBwMBI5AAAORiIHAMDBSOTwtP3798vn82n//v12hwIAUSGRw5XWrVsnn88XHklJSbruuus0c+ZMnTlzxpJz/Pa3v9WiRYss+a6LbdiwQcuWLWv1/r1799bkyZObbX/hhReUkJCgP//zP1djY6OFEV7aiRMnNHfuXI0ZM0ZJSUny+Xx6//332+XcgFeRyOFqixcv1gsvvKDly5drzJgxKisr0+jRo/Xll1+a/u7f/va3euKJJyyIMlJbE3lLXnzxRd13330qKCjQli1blJSUZE1wV/Dmm2/queeeU11dnW644YZ2OSfgdR3tDgCIpcLCQuXn50uS/vZv/1aZmZl65plntHXrVk2bNs3m6GJj48aNKi4u1q233qqtW7e2WxKXpDvuuENffPGFUlJS9E//9E+qqKhot3MDXkVFDk+59dZbJUmVlZWX3e9Xv/qVhg8fruTkZF199dWaPn26Pv744/DP77vvPq1YsUKSIlr4l7N161ZNmjRJOTk58vv9uuaaa/Tkk08qGAyG9xk/frxee+01ffDBB+Hv7N27d6uv7+WXX9b06dM1fvx4bdu2rV2TuCRlZGQoJSWlXc8JeB0VOTzl3XfflSRlZmZecp9169ZpxowZGjFihAKBgM6cOaNnn31Wb7zxhv74xz+qa9eueuihh3T69Gnt3r1bL7zwQqvOvW7dOnXp0kWlpaXq0qWL9u7dqwULFqi2tlY///nPJUn/8A//oJqaGn300Uf6l3/5F0lSly5dWvX9v/71r1VUVKRbbrlFv/nNb5ScnNyq4+rr61s1h96pUyelpaW16jsBtCMDcKG1a9cakozf/e53xieffGJUVVUZGzduNDIzM43k5GTjo48+MgzDMPbt22dIMvbt22cYhmGcO3fOyMrKMgYOHGh89dVX4e/bvn27IclYsGBBeFtJSYnRlr9CX375ZbNtDz30kHHVVVcZjY2N4W2TJk0y8vLyWv29eXl5Rk5OjtGxY0dj/PjxRkNDQ6uPNQzDKC4uNiRdcYwbN65N3/vzn//ckGRUVla26TgAbUNFDlcrKCiI+JyXl6cXX3xR3/ve91rcv7y8XGfPntWiRYsi2tKTJk1Sv3799Nprr0W9wO3iCrmurk5NTU26+eabtWrVKv3v//6vhgwZEtX3StL//d//6euvv1bPnj1bXYlf8Oijj2r69OlX3C89PT3a8ADEEIkcrrZixQpdd9116tixo7p3767rr79eHTpcemnIBx98IEm6/vrrm/2sX79+ev3116OO5e2339Zjjz2mvXv3qra2NuJnNTU1UX+vJE2cOFG9evVSWVmZMjIy9Oyzz7b62P79+6t///6mzg/APiRyuNrIkSPDq9bt9MUXX2jcuHFKTU3V4sWLdc011ygpKUnHjh3TvHnzFAqFTJ9j+fLl+vzzz/Xcc88pPT291fe419TU6KuvvrrifomJicrIyDAZJQCrkciBi+Tl5Un65sEmF1a4X3DixInwzyVdcZX6xfbv36/PPvtMr776qm655Zbw9pZWz7fley/WoUMH/fKXv1RNTY2eeOIJZWRkaNasWVc8bvbs2Vq/fv0V9xs3bhxPwAPiEIkcuEh+fr6ysrK0cuVK3X///fL7/ZKkHTt26H/+53+0YMGC8L6dO3eW9E213bVr18t+b0JCgiTJMIzwtnPnzulf//Vfm+3buXPnqFvtnTp10iuvvKLbbrtNc+bMUXp6uv7mb/7msscwRw44G4kcuEinTp309NNPa8aMGRo3bpymTZsWvv2sd+/emjt3bnjf4cOHS5JmzZql22+/XQkJCbr33ntb/N4xY8YoPT1dxcXFmjVrlnw+n1544YWIxH7x927atEmlpaUaMWKEunTpoilTprT6Gq666iq99tprGjdunO6//36lpaXpjjvuuOT+Vs6R19TU6Pnnn5ckvfHGG5K+afl37dpVXbt21cyZMy05D4CL2L1sHoiFC7efHTly5LL7fff2sws2bdpkDB061PD7/UZGRoZRVFQUvmXtgq+//tr4yU9+YnTr1s3w+XxXvBXtjTfeMP7sz/7MSE5ONnJycoxHH33U2LVrV7Pz19fXG3/9139tdO3a1ZB0xVvR8vLyjEmTJjXbXl1dbVx77bVGUlJSs+uLlcrKykvevtaWW+oAtJ7PMFooCQAAgCPwiFYAAByMRA4AgIORyAEAcDASOQAADkYiBwDAwUjkAAA4mKMfCBMKhXT69GmlpKRE/VhLAIB9DMNQXV2dcnJyLvtCI7MaGxt17tw509+TmJgY8WbEeODoRH769Gnl5ubaHQYAwKSqqir17NkzJt/d2NioPnldVH02aPq7evToocrKyrhK5o5O5CkpKZKknoseU4c4+kM1LaPJ7ggsd3VGvd0hWOq69LN2h2C5G1M+sjsEy+Unv2d3CJYb7u9kdwiWqq0PKW/Y++F/z2Ph3Llzqj4b1AdHeys1Jfqqv7YupLzh7+vcuXMkcqtcaKd3SEpyVyK/yn3TBAmdz9sdgqUSuyTaHYLlkro4+p+DFnW+yn3LgFL97rsmKfq3/rVFlxSfuqREf56Q4vPfZvf9zQUAoAVBI6SgiYeSB42QdcFYiEQOAPCEkAyFFH0mN3NsLLmzRwMAgEdQkQMAPCGkkMw0x80dHTskcgCAJwQNQ0ETb+42c2ws0VoHAMDBqMgBAJ7g1sVuJHIAgCeEZCjowkROax0AAAejIgcAeAKtdQAAHIxV6wAAIO5QkQMAPCH07TBzfDwikQMAPCFoctW6mWNjiUQOAPCEoCGTbz+zLhYrMUcOAICDUZEDADyBOXIAABwsJJ+C8pk6Ph7RWgcAwMFsT+Qff/yxpk+frszMTCUnJ2vQoEEqLy+3OywAgMuEDPMjHtnaWv/88881duxYTZgwQTt27FC3bt108uRJpaen2xkWAMCFgiZb62aOjSVbE/nTTz+t3NxcrV27NrytT58+NkYEAICz2Npa37Ztm/Lz83XXXXcpKytLQ4cO1Zo1a+wMCQDgUhcqcjMjHtmayN977z2VlZWpb9++2rVrlx5++GHNmjVL69evb3H/pqYm1dbWRgwAAFojZPhMj3hkayIPhUIaNmyYlixZoqFDh+rBBx/UAw88oJUrV7a4fyAQUFpaWnjk5ua2c8QAALTOwYMHNWXKFOXk5Mjn82nLli3hn50/f17z5s3ToEGD1LlzZ+Xk5OiHP/yhTp8+3ebz2JrIs7Oz1b9//4htN9xwgz788MMW958/f75qamrCo6qqqj3CBAC4QHu31hsaGjRkyBCtWLGi2c++/PJLHTt2TI8//riOHTumV199VSdOnNAdd9zR5uuydbHb2LFjdeLEiYht77zzjvLy8lrc3+/3y+/3t0doAACXCaqDgibq12Ab9y8sLFRhYWGLP0tLS9Pu3bsjti1fvlwjR47Uhx9+qF69erX6PLYm8rlz52rMmDFasmSJ7r77bh0+fFirV6/W6tWr7QwLAOBChsl5buPbY7+7PsuqIrOmpkY+n09du3Zt03G2ttZHjBihzZs366WXXtLAgQP15JNPatmyZSoqKrIzLAAALik3NzdivVYgEDD9nY2NjZo3b56mTZum1NTUNh1r+7PWJ0+erMmTJ9sdBgDA5ax6IExVVVVEsjVbjZ8/f1533323DMNQWVlZm4+3PZEDANAegkYHBQ0Tc+TfPqI1NTW1zVXzpVxI4h988IH27t0b1feSyAEAsMGFJH7y5Ent27dPmZmZUX0PiRwA4Akh+RQysTQspLa9NaW+vl6nTp0Kf66srFRFRYUyMjKUnZ2tv/qrv9KxY8e0fft2BYNBVVdXS5IyMjKUmJjY6vOQyAEAntDeL00pLy/XhAkTwp9LS0slScXFxVq0aJG2bdsmSbrxxhsjjtu3b5/Gjx/f6vOQyAEAiIHx48fLMC5dxV/uZ21BIgcAeIL5xW7x+UJyEjkAwBO+mSOPvrVu5thYsvWBMAAAwBwqcgCAJ4RMPmu9ravW2wuJHADgCcyRAwDgYCF1aNf7yNsLc+QAADgYFTkAwBOChk9BE68xNXNsLJHIAQCeEDS52C1Iax0AAFiNihwA4Akho4NCJlath1i1DgCAfWitAwCAuENFDgDwhJDMrTwPWReKpUjkAABPMP9AmPhsYrsikfs/7aAEf3z+AUejUX67Q7DcJ3YHALjGKbsDsFRDU7zWuc7hikQOAMCVmH/WenwWjCRyAIAnuPV95CRyAIAnuLUij8+oAABAq1CRAwA8wfwDYeKz9iWRAwA8IWT4FDJzH3mcvv0sPn+9AAAArUJFDgDwhJDJ1joPhAEAwEbm334Wn4k8PqMCAACtQkUOAPCEoHwKmnioi5ljY4lEDgDwBFrrAAAg7lCRAwA8IShz7fGgdaFYikQOAPAEt7bWSeQAAE/gpSkAACDuUJEDADzBMPk+coPbzwAAsA+tdQAAEHeoyAEAnsBrTGNg0aJF8vl8EaNfv352hgQAcKngt28/MzPike0V+YABA/S73/0u/LljR9tDAgDAMWzPmh07dlSPHj3sDgMA4HK01mPk5MmTysnJ0fe//30VFRXpww8/vOS+TU1Nqq2tjRgAALRGSB1Mj3hka1SjRo3SunXrtHPnTpWVlamyslI333yz6urqWtw/EAgoLS0tPHJzc9s5YgAA4outrfXCwsLwfw8ePFijRo1SXl6eXn75Zf3oRz9qtv/8+fNVWloa/lxbW0syBwC0StDwKWiiPW7m2FiyfY78Yl27dtV1112nU6dOtfhzv98vv9/fzlEBANyAOfJ2UF9fr3fffVfZ2dl2hwIAcBnj27efRTsMnuzW3COPPKIDBw7o/fff1+9//3v9xV/8hRISEjRt2jQ7wwIAwDFsba1/9NFHmjZtmj777DN169ZNN910kw4dOqRu3brZGRYAwIWC8ilo4sUnZo6NJVsT+caNG+08PQDAQ0KGuXnukGFhMBaKz4Y/AABolbhatQ4AQKxcWLRm5vh4FJ9RAQBgsZB8pkdbHDx4UFOmTFFOTo58Pp+2bNkS8XPDMLRgwQJlZ2crOTlZBQUFOnnyZJuvi0QOAEAMNDQ0aMiQIVqxYkWLP//Hf/xHPffcc1q5cqX+8Ic/qHPnzrr99tvV2NjYpvPQWgcAeEJ7P9mtsLAw4gmmFzMMQ8uWLdNjjz2mO++8U5L0y1/+Ut27d9eWLVt07733tvo8VOQAAE8w8zAYs/Pr31VZWanq6moVFBSEt6WlpWnUqFF688032/RdVOQAALTBd9+8Gc3jw6urqyVJ3bt3j9jevXv38M9ai4ocAOAJIfnCz1uPany72C03NzfiTZyBQMDW66IiBwB4ghHFyvPvHi9JVVVVSk1NDW+P5mVePXr0kCSdOXMm4v0iZ86c0Y033tim76IiBwB4gqlq/KI3p6WmpkaMaBJ5nz591KNHD+3Zsye8rba2Vn/4wx80evToNn0XFTkAADFQX18f8VruyspKVVRUKCMjQ7169dKcOXP0s5/9TH379lWfPn30+OOPKycnR1OnTm3TeUjkAABPaO8nu5WXl2vChAnhz6WlpZKk4uJirVu3To8++qgaGhr04IMP6osvvtBNN92knTt3KikpqU3nIZEDADzh4vZ4tMe3xfjx42UYl37Tis/n0+LFi7V48eKoY5KYIwcAwNGoyAEAnhDN89K/e3w8IpEDADyhvVvr7YXWOgAADkZFDgDwBLdW5CRyAIAnuDWR01oHAMDBXFGRJ31mKCHx0vfqOY/7fr9qVNsfYRjPPrE7AMAlGr/6WlJVu5zLrRW5KxI5AABXYsjcLWTxWi6SyAEAnuDWitx9PVwAADyEihwA4AlurchJ5AAAT3BrIqe1DgCAg1GRAwA8wa0VOYkcAOAJhuGTYSIZmzk2lmitAwDgYFTkAABP4H3kAAA4mFvnyGmtAwDgYFTkAABPcOtiNxI5AMAT3NpaJ5EDADzBrRU5c+QAADgYFTkAwBMMk631eK3ISeQAAE8wJBmGuePjEa11AAAcjIocAOAJIfnk48luAAA4E6vWY2zp0qXy+XyaM2eO3aEAAOAYcVGRHzlyRKtWrdLgwYPtDgUA4FIhwyefCx8IY3tFXl9fr6KiIq1Zs0bp6el2hwMAcCnDMD/ike2JvKSkRJMmTVJBQcEV921qalJtbW3EAADAy2xtrW/cuFHHjh3TkSNHWrV/IBDQE088EeOoAABuxGI3i1VVVWn27Nl68cUXlZSU1Kpj5s+fr5qamvCoqqqKcZQAALe4kMjNjHhkW0V+9OhRnT17VsOGDQtvCwaDOnjwoJYvX66mpiYlJCREHOP3++X3+9s7VACAC7h1sZttiXzixIk6fvx4xLYZM2aoX79+mjdvXrMkDgAAmrMtkaekpGjgwIER2zp37qzMzMxm2wEAMMvsyvN4XbUeF/eRAwAQa98kcjOL3SwMxkJxlcj3799vdwgAADhKXCVyAABixa23n5HIAQCeYMjcO8XjtLNu/5PdAABA9KjIAQCeQGsdAAAnc2lvnUQOAPAGs49ZjdOKnDlyAAAcjIocAOAJPNkNAAAHc+tiN1rrAAA4GBU5AMAbDJ+5BWtU5AAA2OfCHLmZ0RbBYFCPP/64+vTpo+TkZF1zzTV68sknZVg82U5FDgBADDz99NMqKyvT+vXrNWDAAJWXl2vGjBlKS0vTrFmzLDsPiRwA4A3t/ECY3//+97rzzjs1adIkSVLv3r310ksv6fDhwyaCaI7WOgDAEy6sWjczJKm2tjZiNDU1tXi+MWPGaM+ePXrnnXckSf/1X/+l119/XYWFhZZeFxU5AABtkJubG/F54cKFWrRoUbP9fvrTn6q2tlb9+vVTQkKCgsGgnnrqKRUVFVkaD4kcAOAdFqwzq6qqUmpqaviz3+9vcb+XX35ZL774ojZs2KABAwaooqJCc+bMUU5OjoqLi80H8i0SOQDAE6x6IExqampEIr+Uv//7v9dPf/pT3XvvvZKkQYMG6YMPPlAgECCRAwDQZu282O3LL79Uhw6RS9ESEhIUCoVMBNEciRwAgBiYMmWKnnrqKfXq1UsDBgzQH//4Rz3zzDO6//77LT2PKxJ58qchdexk7W849nLjzQTuuqZGtTwn5mSf2B0APOlc/bl2PJvv22Hm+NZ7/vnn9fjjj+vHP/6xzp49q5ycHD300ENasGCBiRiac0UiBwDgitq5tZ6SkqJly5Zp2bJlJk56Ze4qkwAA8BgqcgCAN7RzRd5eSOQAAG/g7WcAACDeUJEDADwhmleRfvf4eEQiBwB4g0vnyGmtAwDgYFTkAABvcOliNxI5AMATfMY3w8zx8YhEDgDwBubIAQBAvKEiBwB4A3PkAAA4GK11AAAQb6jIAQDe4NKKnEQOAPAGlyZyWusAADgYFTkAwBtYtQ4AgHO59clutNYBAHAwWxN5WVmZBg8erNTUVKWmpmr06NHasWOHnSEBANzKsGDEIVsTec+ePbV06VIdPXpU5eXluvXWW3XnnXfq7bfftjMsAAAcw9Y58ilTpkR8fuqpp1RWVqZDhw5pwIABNkUFAHAjn0zOkVsWibValcj/8i//8spf1LGjevTooR/84AfNEnRrBINB/epXv1JDQ4NGjx7d4j5NTU1qamoKf66trW3zeQAAcJNWJfK0tLQr7hMKhXTy5En94he/0COPPKLFixe3KoDjx49r9OjRamxsVJcuXbR582b179+/xX0DgYCeeOKJVn0vAAARvHz72dq1a1v9hdu3b9ePf/zjVify66+/XhUVFaqpqdErr7yi4uJiHThwoMVkPn/+fJWWloY/19bWKjc3t9WxAQA8zKVPdrN8jvymm25Sfn5+q/dPTEzUtddeK0kaPny4jhw5omeffVarVq1qtq/f75ff77csVgAAnM7yRN61a1e9+uqrUR8fCoUi5sEBALAEFbn15s+fr8LCQvXq1Ut1dXXasGGD9u/fr127dtkZFgDAhdz6ZDdbE/nZs2f1wx/+UH/605+UlpamwYMHa9euXfrBD35gZ1gAADiGrYn83/7t3+w8PQDAS2itAwDgYC5N5Lw0BQAAB6MiBwB4AovdAABwMi8/2Q0AAMdjjhwAAMQbKnIAgCcwRw4AgJPRWgcAAPGGihwA4A0mW+vxWpGTyAEA3kBrHQAAxBsqcgCAN7i0IieRAwA8wa23n9FaBwDAwUjkAAA4GK11AIA3MEcOAIBzMUcOAADiDokcAOAdhokRhY8//ljTp09XZmamkpOTNWjQIJWXl5u9igiuaK1fVf2VOnaM055HVJLtDiAG3PY7o9uuR2qU3+4QLPeJ3QHgioINTe13snaeI//88881duxYTZgwQTt27FC3bt108uRJpaenmwiiOVckcgAA4s3TTz+t3NxcrV27NrytT58+lp/HfWUFAAAtuLDYzcxoi23btik/P1933XWXsrKyNHToUK1Zs8by6yKRAwC8wcz8+EVt+dra2ojR1NTy9MB7772nsrIy9e3bV7t27dLDDz+sWbNmaf369ZZeFokcAIA2yM3NVVpaWngEAoEW9wuFQho2bJiWLFmioUOH6sEHH9QDDzyglStXWhoPc+QAAE+w6j7yqqoqpaamhrf7/S0vFM3Ozlb//v0jtt1www369a9/HX0QLSCRAwC8waJV66mpqRGJ/FLGjh2rEydORGx75513lJeXZyKI5mitAwAQA3PnztWhQ4e0ZMkSnTp1Shs2bNDq1atVUlJi6XlI5AAAb7BosVtrjRgxQps3b9ZLL72kgQMH6sknn9SyZctUVFRkzfV8i9Y6AMAT7HjW+uTJkzV58uToT9oKJHIAgDe49O1ntNYBAHAwKnIAgDe4tCInkQMAPIH3kQMAgLhDRQ4A8AZa6wAAOBetdQAAEHeoyAEA3kBrHQAAB3NpIqe1DgCAg9mayAOBgEaMGKGUlBRlZWVp6tSpzV75BgCAFXwWjHhkayI/cOCASkpKdOjQIe3evVvnz5/XbbfdpoaGBjvDAgC4UTu//ay92DpHvnPnzojP69atU1ZWlo4ePapbbrnFpqgAAG7E7WftoKamRpKUkZFhcyQAADhD3KxaD4VCmjNnjsaOHauBAwe2uE9TU5OamprCn2tra9srPACA07FqPbZKSkr01ltvaePGjZfcJxAIKC0tLTxyc3PbMUIAgOO5bH5cipNEPnPmTG3fvl379u1Tz549L7nf/PnzVVNTEx5VVVXtGCUAAPHH1ta6YRj6yU9+os2bN2v//v3q06fPZff3+/3y+/3tFB0AwE3cutjN1kReUlKiDRs2aOvWrUpJSVF1dbUkKS0tTcnJyXaGBgBwG+bIrVdWVqaamhqNHz9e2dnZ4bFp0yY7wwIAwDFsb60DANAeaK0DAOBktNYBAEC8oSIHAHgCrXUAAJzMpa11EjkAwBtcmsiZIwcAwMGoyAEAnsAcOQAATkZrHQAAxBsqcgCAJ/gMQz4TTxQ1c2wskcgBAN5Aax0AAMQbKnIAgCewah0AACejtQ4AAOINFTkAwBNorQMA4GQuba2TyAEAnuDWipw5cgAAHIyKHADgDbTW41fHP32ujh38dodhmauUYXcIMZBsdwAWc2Mzy33X1Cj3/LtwwSd2B2Cx0Jed2vV88doeN8N9f3MBAPAQV1TkAABckWF8M8wcH4dI5AAAT2DVOgAAiDtU5AAAb2DVOgAAzuULfTPMHB+PaK0DAOBgVOQAAG9waWudihwA4AkXVq2bGdFaunSpfD6f5syZY9n1XEBFDgDwBpvuIz9y5IhWrVqlwYMHR3/uy6AiBwAgRurr61VUVKQ1a9YoPT09JucgkQMAPMGq1nptbW3EaGpquuQ5S0pKNGnSJBUUFMTsukjkAABvMCwYknJzc5WWlhYegUCgxdNt3LhRx44du+TPrcIcOQAAbVBVVaXU1NTwZ7+/+Vv2qqqqNHv2bO3evVtJSUkxjYdEDgDwBKuetZ6amhqRyFty9OhRnT17VsOGDQtvCwaDOnjwoJYvX66mpiYlJCREH8xFSOQAAG9ox1XrEydO1PHjxyO2zZgxQ/369dO8efMsS+ISiRwAAMulpKRo4MCBEds6d+6szMzMZtvNIpEDADzBra8xJZEDALzB5ke07t+/39wXXAK3nwEA4GBU5AAAT3Bra93WivzgwYOaMmWKcnJy5PP5tGXLFjvDAQC4WcgwP+KQrYm8oaFBQ4YM0YoVK+wMAwDgBRY92S3e2NpaLywsVGFhoZ0hAADgaMyRAwA8wSeTc+SWRWItRyXypqamiLfM1NbW2hgNAMBRbHofeaw56vazQCAQ8caZ3Nxcu0MCAMBWjkrk8+fPV01NTXhUVVXZHRIAwCGseh95vHFUa93v97f4ujgAAK7I5ie7xYqtiby+vl6nTp0Kf66srFRFRYUyMjLUq1cvGyMDAMAZbE3k5eXlmjBhQvhzaWmpJKm4uFjr1q2zKSoAgBv5DEM+EwvWzBwbS7Ym8vHjx8uI0z8YAIDLhL4dZo6PQ45a7AYAACI5arEbAADRorUOAICTsWodAAAH48luAAAg3lCRAwA8wezT2XiyGwAAdqK1DgAA4g0VOQDAE3yhb4aZ4+MRiRwA4A201gEAQLyhIgcAeAMPhAEAwLnc+ohWWusAADgYFTkAwBtcutiNRA4A8AZD5t4pHp95nEQOAPAG5sgBAEDcoSIHAHiDIZNz5JZFYikSOQDAG1jsFr++/ui05OtkdxiWccX/lO+4Shl2h2CxZLsDiAE3zrS575oa5bc7BGs1xmdydBI35gwAAJoLSfKZPD4OkcgBAJ7AqnUAABB3qMgBAN7AYjcAABzMpYmc1joAAA5GRQ4A8AaXVuQkcgCAN3D7GQAAzsXtZwAAIO5QkQMAvIE5cgAAHCxkSD4TyTgUn4mc1joAAA5GRQ4A8AZa6wAAOJnJRK74TOS01gEAcDAqcgCAN7i0tU5FDgDwhpBhfrRBIBDQiBEjlJKSoqysLE2dOlUnTpyw/LJI5AAAxMCBAwdUUlKiQ4cOaffu3Tp//rxuu+02NTQ0WHoeWusAAG8wQt8MM8e3wc6dOyM+r1u3TllZWTp69KhuueWW6OP4DhI5AMAbLJojr62tjdjs9/vl9/uveHhNTY0kKSMjI/oYWhAXrfUVK1aod+/eSkpK0qhRo3T48GG7QwIAuI1Fc+S5ublKS0sLj0AgcOVTh0KaM2eOxo4dq4EDB1p6WbZX5Js2bVJpaalWrlypUaNGadmyZbr99tt14sQJZWVl2R0eAAARqqqqlJqaGv7cmmq8pKREb731ll5//XXL47G9In/mmWf0wAMPaMaMGerfv79Wrlypq666Sv/+7/9ud2gAADe50Fo3MySlpqZGjCsl8pkzZ2r79u3at2+fevbsafll2ZrIz507p6NHj6qgoCC8rUOHDiooKNCbb77ZbP+mpibV1tZGDAAAWsWQyUTextMZhmbOnKnNmzdr79696tOnT0wuy9ZE/umnnyoYDKp79+4R27t3767q6upm+wcCgYh5idzc3PYKFQCANikpKdF//Md/aMOGDUpJSVF1dbWqq6v11VdfWXoe21vrbTF//nzV1NSER1VVld0hAQCcwqLWemuVlZWppqZG48ePV3Z2dnhs2rTJ0suydbHb1VdfrYSEBJ05cyZi+5kzZ9SjR49m+7d2iT8AAM2EQpJM3EceatuxRjs90tXWijwxMVHDhw/Xnj17wttCoZD27Nmj0aNH2xgZAADOYPvtZ6WlpSouLlZ+fr5GjhypZcuWqaGhQTNmzLA7NACAm7j0pSm2J/J77rlHn3zyiRYsWKDq6mrdeOON2rlzZ7MFcAAAmEIij52ZM2dq5syZdocBAIDjxEUiBwAg5kKG2nwzeLPj4w+JHADgCYYRkmHi7Wdmjo0lEjkAwBsMw1xVHadz5I56IAwAAIhERQ4A8AbD5Bx5nFbkJHIAgDeEQpLPxDx3nM6R01oHAMDBqMgBAN5Aax0AAOcyQiEZJlrr8Xr7Ga11AAAcjIocAOANtNYBAHCwkCH53JfIaa0DAOBgVOQAAG8wDElm7iOPz4qcRA4A8AQjZMgw0Vo3SOQAANjICMlcRc7tZwAAwGJU5AAAT6C1DgCAk7m0te7oRH7ht6Ovdd7UPf5xJ9RkdwSW+/rrRrtDsNTX5312h2C54Dn3zbQFm9z3/ynUGJ/JJFqhxm/+bWiPatdsrvha560LxkKOTuR1dXWSpNf1W5sjsdhHdgcQA268JgCWqaurU1paWky+OzExUT169NDr1eZzRY8ePZSYmGhBVNbxGfHa9G+FUCik06dPKyUlRT5fbH/zrq2tVW5urqqqqpSamhrTc7UHt12PxDU5BdcU/9rzegzDUF1dnXJyctShQ+y6Qo2NjTp37pzp70lMTFRSUpIFEVnH0RV5hw4d1LNnz3Y9Z2pqqiv+ol7gtuuRuCan4JriX3tdT6wq8YslJSXFXQK2ivsmxQAA8BASOQAADkYibyW/36+FCxfK7/fbHYol3HY9EtfkFFxT/HPb9bidoxe7AQDgdVTkAAA4GIkcAAAHI5EDAOBgJHIAAByMRN4KK1asUO/evZWUlKRRo0bp8OHDdocUtYMHD2rKlCnKycmRz+fTli1b7A7JtEAgoBEjRiglJUVZWVmaOnWqTpw4YXdYppSVlWnw4MHhB3KMHj1aO3bssDssyyxdulQ+n09z5syxO5SoLVq0SD6fL2L069fP7rBM+/jjjzV9+nRlZmYqOTlZgwYNUnl5ud1h4TJI5FewadMmlZaWauHChTp27JiGDBmi22+/XWfPnrU7tKg0NDRoyJAhWrFihd2hWObAgQMqKSnRoUOHtHv3bp0/f1633XabGhoa7A4taj179tTSpUt19OhRlZeX69Zbb9Wdd96pt99+2+7QTDty5IhWrVqlwYMH2x2KaQMGDNCf/vSn8Hj99dftDsmUzz//XGPHjlWnTp20Y8cO/fd//7f++Z//Wenp6XaHhssxcFkjR440SkpKwp+DwaCRk5NjBAIBG6OyhiRj8+bNdodhubNnzxqSjAMHDtgdiqXS09ONX/ziF3aHYUpdXZ3Rt29fY/fu3ca4ceOM2bNn2x1S1BYuXGgMGTLE7jAsNW/ePOOmm26yOwy0ERX5ZZw7d05Hjx5VQUFBeFuHDh1UUFCgN99808bIcDk1NTWSpIyMDJsjsUYwGNTGjRvV0NCg0aNH2x2OKSUlJZo0aVLE3yknO3nypHJycvT9739fRUVF+vDDD+0OyZRt27YpPz9fd911l7KysjR06FCtWbPG7rBwBSTyy/j0008VDAbVvXv3iO3du3dXdXW1TVHhckKhkObMmaOxY8dq4MCBdodjyvHjx9WlSxf5/X793d/9nTZv3qz+/fvbHVbUNm7cqGPHjikQCNgdiiVGjRqldevWaefOnSorK1NlZaVuvvnm8OuVnei9995TWVmZ+vbtq127dunhhx/WrFmztH79ertDw2U4+u1nwHeVlJTorbfecvxcpSRdf/31qqioUE1NjV555RUVFxfrwIEDjkzmVVVVmj17tnbv3u2aN1AVFhaG/3vw4MEaNWqU8vLy9PLLL+tHP/qRjZFFLxQKKT8/X0uWLJEkDR06VG+99ZZWrlyp4uJim6PDpVCRX8bVV1+thIQEnTlzJmL7mTNn1KNHD5uiwqXMnDlT27dv1759+9r99baxkJiYqGuvvVbDhw9XIBDQkCFD9Oyzz9odVlSOHj2qs2fPatiwYerYsaM6duyoAwcO6LnnnlPHjh0VDAbtDtG0rl276rrrrtOpU6fsDiVq2dnZzX5RvOGGGxw/ZeB2JPLLSExM1PDhw7Vnz57wtlAopD179jh+rtJNDMPQzJkztXnzZu3du1d9+vSxO6SYCIVCampqsjuMqEycOFHHjx9XRUVFeOTn56uoqEgVFRVKSEiwO0TT6uvr9e677yo7O9vuUKI2duzYZrduvvPOO8rLy7MpIrQGrfUrKC0tVXFxsfLz8zVy5EgtW7ZMDQ0NmjFjht2hRaW+vj6iYqisrFRFRYUyMjLUq1cvGyOLXklJiTZs2KCtW7cqJSUlvH4hLS1NycnJNkcXnfnz56uwsFC9evVSXV2dNmzYoP3792vXrl12hxaVlJSUZmsWOnfurMzMTMeuZXjkkUc0ZcoU5eXl6fTp01q4cKESEhI0bdo0u0OL2ty5czVmzBgtWbJEd999tw4fPqzVq1dr9erVdoeGy7F72bwTPP/880avXr2MxMREY+TIkcahQ4fsDilq+/btMyQ1G8XFxXaHFrWWrkeSsXbtWrtDi9r9999v5OXlGYmJiUa3bt2MiRMnGv/5n/9pd1iWcvrtZ/fcc4+RnZ1tJCYmGt/73veMe+65xzh16pTdYZn2m9/8xhg4cKDh9/uNfv36GatXr7Y7JFwBrzEFAMDBmCMHAMDBSOQAADgYiRwAAAcjkQMA4GAkcgAAHIxEDgCAg5HIAQBwMBI5AAAORiIH4th9992nqVOn2h0GgDhGIgcAwMFI5AAAOBiJHAAAByORAwDgYCRyAAAcjEQOAICDkcgBAHAwEjkAAA5GIgcAwMF8hmEYdgcBAACiQ0UOAICDkcgBAHAwEjkAAA5GIgcAwMFI5AAAOBiJHAAAByORAwDgYCRyAAAcjEQOAICDkcgBAHAwEjkAAA5GIgcAwMH+H9VB5WY9+z31AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -662,13 +627,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\n", - "Min and max values: 11.0 0.0\n" + "Plotting values of qty_in at K = 2\n", + "Min and max values: 14.0 2.0\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -682,12 +647,12 @@ "text": [ "Executing 'mult_upward' with origin=(nhalo,nhalo,0),domain=(nx,ny,2)\n", "Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 10.0 0.0\n" + "Min and max values: 0.0 0.0\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -718,12 +683,12 @@ "output_type": "stream", "text": [ "Plotting values of qty_out at K = 2 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 40.0 0.0\n" + "Min and max values: 22.0 0.0\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -736,12 +701,12 @@ "output_type": "stream", "text": [ "Plotting values of qty_out at K = 3 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\n", - "Min and max values: 13.0 0.0\n" + "Min and max values: 0.0 0.0\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhMAAAHHCAYAAAAF5NqAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABDq0lEQVR4nO3de1xVVf7/8fcB5OANEBWQxNtUiuUVArGLJhSW0+RkM+rQNzVGm0ZMpZs2jtjlGzaVqWWSlVqNjmbT1YwiTJuSvGD8Jk2damwk9aBlgmJc5OzfH47n24mDApvjEfbr+Xisx8A+a+392Twe0/m4PmvtbTMMwxAAAEAD+fk6AAAA0LSRTAAAAFNIJgAAgCkkEwAAwBSSCQAAYArJBAAAMIVkAgAAmEIyAQAATCGZAAAAppBMwNI2bNggm82mDRs2+DoUAGiySCbQLC1fvlw2m83VgoKCdPHFFys9PV3FxcWNco1169Zpzpw5jXKun1q5cqXmz59f5/7dunXTL3/5yxrHX375Zfn7+2v48OEqLy9vxAhr9/rrryslJUVRUVGy2+3q3Lmzbr75Zu3YseOcXB+AbwT4OgDAmx588EF1795d5eXl+vjjj7V48WKtW7dOO3bsUKtWrUyde926dVq0aFGjJxQrV67Ujh07NG3atAafY8WKFRo/frySk5P1xhtvKCgoqPECPIPPP/9c7dq109SpU9WhQwc5HA4tXbpU8fHxys/PV79+/c5JHADOLZIJNGvXXXed4uLiJEm///3v1b59e82bN09vvvmmxo4d6+PovGPVqlUaN26chg0bpjfffPOcJRKSNHv27BrHfv/736tz585avHixsrOzz1ksAM4dyhywlGHDhkmS9u7de8Z+a9asUWxsrFq2bKkOHTrolltu0f79+12fjx8/XosWLZIkt3LKmbz55psaMWKEqwTwi1/8Qg899JCqq6tdfYYOHap33nlH//nPf1zn7NatW53v75VXXtEtt9yioUOH6q233jqniURtwsPD1apVKx09etTXoQDwEmYmYClff/21JKl9+/a19lm+fLkmTJigyy67TFlZWSouLtaCBQv0ySef6LPPPlNoaKhuv/12HThwQLm5uXr55ZfrdO3ly5erTZs2ysjIUJs2bbR+/XrNnj1bpaWleuyxxyRJf/rTn1RSUqJvv/1WTz75pCSpTZs2dTr/3//+d6Wmpuqqq67S22+/rZYtW9Zp3PHjx+u0pqJFixYKCQmp0zmPHj2qqqoqORwOzZ8/X6WlpUpKSqrTWABNkAE0Q8uWLTMkGR988IFx+PBho6ioyFi1apXRvn17o2XLlsa3335rGIZhfPjhh4Yk48MPPzQMwzAqKyuN8PBw49JLLzV+/PFH1/nWrl1rSDJmz57tOjZ58mSjPv8XOnHiRI1jt99+u9GqVSujvLzcdWzEiBFG165d63zerl27GlFRUUZAQIAxdOhQo6ysrM5jDcMwxo0bZ0g6axsyZEidz9mzZ0/XuDZt2hizZs0yqqur6xUXgKaDmQk0a8nJyW6/d+3aVStWrNAFF1zgsf+2bdt06NAhzZkzx61EMGLECPXq1UvvvPOOHnjggQbF8tOZgmPHjqmiokJXXnmlnn32We3evdvU4sQjR47o5MmT6ty5c51nJE679957dcstt5y1X7t27ep8zmXLlqm0tFT//ve/tWzZMv3444+qrq6Wnx+VVaA5IplAs7Zo0SJdfPHFCggIUEREhHr27HnGL7T//Oc/kqSePXvW+KxXr176+OOPGxzLzp07NWvWLK1fv16lpaVun5WUlDT4vJKUlJSkLl26aPHixQoLC9OCBQvqPLZ3797q3bu3qev/XGJiouvnMWPGKCYmRpL0+OOPN+p1AJwfSCbQrMXHx7t2c/jS0aNHNWTIEAUHB+vBBx/UL37xCwUFBWn79u2677775HQ6TV/j6aef1g8//KCFCxeqXbt2dd6yWlJSoh9//PGs/QIDAxUWFlbvuNq1a6dhw4ZpxYoVJBNAM0UyAfxE165dJUl79uxx7fw4bc+ePa7PJZ1198ZPbdiwQd9//71ee+01XXXVVa7jnnaV1Oe8P+Xn56eXXnpJJSUleuCBBxQWFqY777zzrOOmTp2qF1988az9hgwZ0uAnhf7444+mZ18AnL9IJoCfiIuLU3h4uLKzs3XbbbfJbrdLkt59913t2rXL7TkKrVu3lnRq1iE0NPSM5/X395ckGYbhOlZZWalnnnmmRt/WrVs3+Iu3RYsWevXVV3Xttddq2rRpateunf7nf/7njGMac83EoUOHFB4e7nbsm2++UV5e3nkxQwTAO0gmgJ9o0aKFHn30UU2YMEFDhgzR2LFjXVtDu3XrpunTp7v6xsbGSpLuvPNOpaSkyN/fX2PGjPF43sGDB6tdu3YaN26c7rzzTtlsNr388stuycVPz7t69WplZGTosssuU5s2bXTDDTfU+R5atWqld955R0OGDNFtt92mkJAQ/epXv6q1f2OumejTp4+SkpLUv39/tWvXTl9++aVeeOEFVVVVae7cuY1yDQDnIV9vJwG84fTW0K1bt56x38+3hp62evVqY8CAAYbdbjfCwsKM1NRU13bS006ePGlMmTLF6Nixo2Gz2c66TfSTTz4xBg0aZLRs2dKIiooy7r33XuO9996rcf3jx48bv/vd74zQ0FBD0lm3iXbt2tUYMWJEjeMOh8O48MILjaCgoBr35y2ZmZlGXFyc0a5dOyMgIMCIiooyxowZY/zzn/88J9cH4Bs2w/DwTyMAAIA6YtM3AAAwhWQCAACYQjIBAABMIZkAAMCLFi1apG7duikoKEgJCQnasmVLrX137typUaNGqVu3brLZbJo/f36DzlleXq7Jkyerffv2atOmjUaNGqXi4uLGvC03JBMAAHjJ6W3emZmZ2r59u/r166eUlBQdOnTIY/8TJ06oR48emjt3riIjIxt8zunTp+vtt9/WmjVrtHHjRh04cEA33XSTV+5RktjNAQCAlyQkJOiyyy7T008/LUlyOp2Kjo7WlClTNGPGjDOO7datm6ZNm6Zp06bV65wlJSXq2LGjVq5cqZtvvlmStHv3bsXExCg/P1+DBg1q9Pts0g+tcjqdOnDggNq2bdvgRxADAHzHMAwdO3ZMUVFRXn2rbHl5uSorK02fxzCMGt83drvd9bTcn6qsrFRBQYFmzpzpOubn56fk5GTl5+c36Pp1OWdBQYGqqqrc3prcq1cvdenShWTCkwMHDig6OtrXYQAATCoqKlLnzp29cu7y8nJ179pGjkPVps/Vpk0bHT9+3O1YZmamxxfrfffdd6qurlZERITb8YiICO3evbtB16/LOR0OhwIDA2s85j8iIkIOh6NB1z2bJp1MtG3bVpLUec4s+QUF+TgaAEB9OcvL9e2ch13/PfeGyspKOQ5V6z8F3RTctuGzH6XHnOoa+42KiooUHBzsOu5pVsJqmnQycXqqyS8oiGQCAJqwc1GqbtPWpjZtG34dp06NDQ4OdksmatOhQwf5+/vX2EVRXFxc6+LKxjhnZGSkKisra7yE0Mx1z4bdHAAAS6g2nKZbfQQGBio2NlZ5eXmuY06nU3l5eUpMTGzQPdTlnLGxsWrRooVbnz179mjfvn0Nvu7ZNOmZCQAA6sopQ041fANjQ8ZmZGRo3LhxiouLU3x8vObPn6+ysjJNmDBBknTrrbfqggsuUFZWlqRTJZkvvvjC9fP+/ftVWFioNm3a6MILL6zTOUNCQpSWlqaMjAyFhYUpODhYU6ZMUWJiolcWX0okEwAAeM3o0aN1+PBhzZ49Ww6HQ/3791dOTo5rAeW+ffvcdrEcOHBAAwYMcP3++OOP6/HHH9eQIUO0YcOGOp1Tkp588kn5+flp1KhRqqioUEpKip555hmv3WeTfs5EaWmpQkJC1GXuw6yZAIAmyFlern0zZqmkpKRO6xAa4vR3xYE9nU0vwIzq+a1XY22qmJkAAFhCtWGo2sS/n82Mbe5YgAkAAExhZgIAYAm+WIBpFSQTAABLcMpQNcmEV1DmAAAApjAzAQCwBMoc3kMyAQCwBHZzeA9lDgAAYAozEwAAS3D+t5kZD89IJgAAllBtcjeHmbHNHckEAMASqo1Tzcx4eMaaCQAAYAozEwAAS2DNhPeQTAAALMEpm6plMzUenlHmAAAApvg8mdi/f79uueUWtW/fXi1btlSfPn20bds2X4cFAGhmnIb5Bs98Wub44YcfdPnll+vqq6/Wu+++q44dO+rLL79Uu3btfBkWAKAZqjZZ5jAztrnzaTLx6KOPKjo6WsuWLXMd6969uw8jAgAA9eXTMsdbb72luLg4/eY3v1F4eLgGDBig5557zpchAQCaqdMzE2YaPPNpMvHvf/9bixcv1kUXXaT33ntPd9xxh+688069+OKLHvtXVFSotLTUrQEAUBdOw2a6wTOfljmcTqfi4uL0yCOPSJIGDBigHTt2KDs7W+PGjavRPysrSw888MC5DhMAAJyBT2cmOnXqpN69e7sdi4mJ0b59+zz2nzlzpkpKSlytqKjoXIQJAGgGKHN4j09nJi6//HLt2bPH7di//vUvde3a1WN/u90uu91+LkIDADQz1fJTtYl/Q1c3YizNjU+TienTp2vw4MF65JFH9Nvf/lZbtmzRkiVLtGTJEl+GBQBohgyT6x4M1kzUyqdljssuu0yvv/66/va3v+nSSy/VQw89pPnz5ys1NdWXYQEAgHrw+bs5fvnLX+qXv/ylr8MAADRzPLTKe3yeTAAAcC5UG36qNkysmeBx2rXy+bs5AABA08bMBADAEpyyyWni39BOMTVRG5IJAIAlsGbCeyhzAAAAU5iZAABYgvkFmJQ5akMyAQCwhFNrJhpeqjAztrmjzAEAAExhZgIAYAlOk+/mYDdH7ZiZAABYwuk1E2ZaQyxatEjdunVTUFCQEhIStGXLljP2X7NmjXr16qWgoCD16dNH69atc/vcZrN5bI899pirT7du3Wp8Pnfu3AbFXxckEwAAS3DKz3Srr9WrVysjI0OZmZnavn27+vXrp5SUFB06dMhj/02bNmns2LFKS0vTZ599ppEjR2rkyJHasWOHq8/Bgwfd2tKlS2Wz2TRq1Ci3cz344INu/aZMmVLv+OuKZAIAAC+ZN2+eJk6cqAkTJqh3797Kzs5Wq1attHTpUo/9FyxYoOHDh+uee+5RTEyMHnroIQ0cOFBPP/20q09kZKRbe/PNN3X11VerR48ebudq27atW7/WrVt77T5JJgAAllBt2Ew3SSotLXVrFRUVHq9XWVmpgoICJScnu475+fkpOTlZ+fn5Hsfk5+e79ZeklJSUWvsXFxfrnXfeUVpaWo3P5s6dq/bt22vAgAF67LHHdPLkyTr9nRqCBZgAAEuoNrkAs/q/CzCjo6PdjmdmZmrOnDk1+n/33Xeqrq5WRESE2/GIiAjt3r3b4zUcDofH/g6Hw2P/F198UW3bttVNN93kdvzOO+/UwIEDFRYWpk2bNmnmzJk6ePCg5s2bd8Z7bCiSCQAA6qGoqEjBwcGu3+12u89iWbp0qVJTUxUUFOR2PCMjw/Vz3759FRgYqNtvv11ZWVleiZdkAgBgCU7DT04TT8B0/vcJmMHBwW7JRG06dOggf39/FRcXux0vLi5WZGSkxzGRkZF17v+Pf/xDe/bs0erVq88aS0JCgk6ePKlvvvlGPXv2PGv/+mLNBADAEk6XOcy0+ggMDFRsbKzy8vJcx5xOp/Ly8pSYmOhxTGJiolt/ScrNzfXY/4UXXlBsbKz69et31lgKCwvl5+en8PDwet1DXTEzAQCAl2RkZGjcuHGKi4tTfHy85s+fr7KyMk2YMEGSdOutt+qCCy5QVlaWJGnq1KkaMmSInnjiCY0YMUKrVq3Stm3btGTJErfzlpaWas2aNXriiSdqXDM/P1+bN2/W1VdfrbZt2yo/P1/Tp0/XLbfconbt2nnlPkkmAACW4JRcOzIaOr6+Ro8ercOHD2v27NlyOBzq37+/cnJyXIss9+3bJz+//5vxGDx4sFauXKlZs2bp/vvv10UXXaQ33nhDl156qdt5V61aJcMwNHbs2BrXtNvtWrVqlebMmaOKigp1795d06dPd1tH0dhshtF0X4NWWlqqkJAQdZn7sPx+tvgEAHD+c5aXa9+MWSopKanTOoSGOP1dsXj7ZWrZpuH/hv7x+EndMXCrV2NtqlgzAQAATKHMAQCwBDPv1zg9Hp6RTAAALMEpm5wys2ai4WObO5IJAIAlMDPhPfxlAACAKcxMAAAswfy7Ofj3d21IJgAAluA0bHKaec6EibHNHWkWAAAwhZkJAIAlOE2WOZz8+7tWJBMAAEsw/9ZQkona8JcBAACmMDMBALCEatlUbeLBU2bGNnckEwAAS6DM4T38ZQAAgCnMTAAALKFa5koV1Y0XSrNDMgEAsATKHN5DMgEAsARe9OU9/GUAAIApzEwAACzBkE1OE2smDLaG1opkAgBgCZQ5vIe/DAAAMIWZCQCAJfAKcu/x6czEnDlzZLPZ3FqvXr18GRIAoJmq/u9bQ800eObzmYlLLrlEH3zwgev3gACfhwQAAOrB59/cAQEBioyM9HUYAIBmjjKH9/h8zubLL79UVFSUevToodTUVO3bt6/WvhUVFSotLXVrAADUhVN+phs88+lfJiEhQcuXL1dOTo4WL16svXv36sorr9SxY8c89s/KylJISIirRUdHn+OIAQDAz/m0zHHddde5fu7bt68SEhLUtWtXvfLKK0pLS6vRf+bMmcrIyHD9XlpaSkIBAKiTasOmahOlCjNjmzufr5n4qdDQUF188cX66quvPH5ut9tlt9vPcVQAgOaANRPec14VgI4fP66vv/5anTp18nUoAIBmxvjvW0Mb2gyegFkrn/5l7r77bm3cuFHffPONNm3apF//+tfy9/fX2LFjfRkWAACoB5+WOb799luNHTtW33//vTp27KgrrrhCn376qTp27OjLsAAAzVC1bKo28bIuM2ObO58mE6tWrfLl5QEAFuI0zK17cBqNGEwzQwEIAACYcl7t5gAAwFtOL6Q0Mx6e8ZcBAFiCUzbTrSEWLVqkbt26KSgoSAkJCdqyZcsZ+69Zs0a9evVSUFCQ+vTpo3Xr1rl9Pn78+BovyRw+fLhbnyNHjig1NVXBwcEKDQ1VWlqajh8/3qD464JkAgAAL1m9erUyMjKUmZmp7du3q1+/fkpJSdGhQ4c89t+0aZPGjh2rtLQ0ffbZZxo5cqRGjhypHTt2uPUbPny4Dh486Gp/+9vf3D5PTU3Vzp07lZubq7Vr1+qjjz7SpEmTvHafJBMAAEs4/QRMM62+5s2bp4kTJ2rChAnq3bu3srOz1apVKy1dutRj/wULFmj48OG65557FBMTo4ceekgDBw7U008/7dbPbrcrMjLS1dq1a+f6bNeuXcrJydHzzz+vhIQEXXHFFXrqqae0atUqHThwoN73UBckEwAASzDzwKqGrLeorKxUQUGBkpOTXcf8/PyUnJys/Px8j2Py8/Pd+ktSSkpKjf4bNmxQeHi4evbsqTvuuEPff/+92zlCQ0MVFxfnOpacnCw/Pz9t3ry5XvdQVyzABACgHn7+xuraXvXw3Xffqbq6WhEREW7HIyIitHv3bo/ndjgcHvs7HA7X78OHD9dNN92k7t276+uvv9b999+v6667Tvn5+fL395fD4VB4eLjbOQICAhQWFuZ2nsZEMgEAsASnTL6b478LMH/+gsnMzEzNmTPHTGj1MmbMGNfPffr0Ud++ffWLX/xCGzZsUFJS0jmL46dIJgAAlmCY2JFxerwkFRUVKTg42HW8thdQdujQQf7+/iouLnY7XlxcrMjISI9jIiMj69Vfknr06KEOHTroq6++UlJSkiIjI2ss8Dx58qSOHDlyxvOYwZoJAIAlnH5rqJkmScHBwW6ttmQiMDBQsbGxysvL+78YnE7l5eUpMTHR45jExES3/pKUm5tba3/p1Kspvv/+e9dLMhMTE3X06FEVFBS4+qxfv15Op1MJCQl1+2PVE8kEAABekpGRoeeee04vvviidu3apTvuuENlZWWaMGGCJOnWW2/VzJkzXf2nTp2qnJwcPfHEE9q9e7fmzJmjbdu2KT09XdKpt2vfc889+vTTT/XNN98oLy9PN954oy688EKlpKRIkmJiYjR8+HBNnDhRW7Zs0SeffKL09HSNGTNGUVFRXrlPyhwAAEvwxRMwR48ercOHD2v27NlyOBzq37+/cnJyXIss9+3bJz+//zvv4MGDtXLlSs2aNUv333+/LrroIr3xxhu69NJLJUn+/v765z//qRdffFFHjx5VVFSUrr32Wj300ENuMyQrVqxQenq6kpKS5Ofnp1GjRmnhwoUNvvezsRmG0WRfXVJaWqqQkBB1mfuw/IKCfB0OAKCenOXl2jdjlkpKStzWITSm098VN75/m1q0DmzwearKKvXmtUu9GmtTRZkDAACYQpkDAGAJZt6vcXo8PCOZAABYwk93ZDR0PDyjzAEAAExhZgIAYAnMTHgPyQQAwBJIJryHMgcAADCFmQkAgCUwM+E9JBMAAEswZG57Z5N9wuM5QDIBALAEZia8hzUTAADAFGYmAACWwMyE95BMAAAsgWTCeyhzAAAAU5iZAABYAjMT3kMyAQCwBMOwyTCREJgZ29xR5gAAAKYwMwEAsASnbKYeWmVmbHNHMgEAsATWTHgPZQ4AAGAKMxMAAEtgAab3kEwAACyBMof3kEwAACyBmQnvYc0EAAAwhZkJAIAlGCbLHMxM1I5kAgBgCYYkwzA3Hp5R5gAAAKYwMwEAsASnbLLxBEyvIJkAAFgCuzm857wpc8ydO1c2m03Tpk3zdSgAAKAezouZia1bt+rZZ59V3759fR0KAKCZcho22XholVf4fGbi+PHjSk1N1XPPPad27dr5OhwAQDNlGOYbPPN5MjF58mSNGDFCycnJZ+1bUVGh0tJStwYAAHzLp2WOVatWafv27dq6dWud+mdlZemBBx7wclQAgOaIBZje47OZiaKiIk2dOlUrVqxQUFBQncbMnDlTJSUlrlZUVOTlKAEAzcXpZMJMg2c+SyYKCgp06NAhDRw4UAEBAQoICNDGjRu1cOFCBQQEqLq6usYYu92u4OBgtwYAQF2cfmuomdYQixYtUrdu3RQUFKSEhARt2bLljP3XrFmjXr16KSgoSH369NG6detcn1VVVem+++5Tnz591Lp1a0VFRenWW2/VgQMH3M7RrVs32Ww2tzZ37twGxV8XPksmkpKS9Pnnn6uwsNDV4uLilJqaqsLCQvn7+/sqNAAAGsXq1auVkZGhzMxMbd++Xf369VNKSooOHTrksf+mTZs0duxYpaWl6bPPPtPIkSM1cuRI7dixQ5J04sQJbd++XX/+85+1fft2vfbaa9qzZ49+9atf1TjXgw8+qIMHD7ralClTvHafPlsz0bZtW1166aVux1q3bq327dvXOA4AgFlmd2Q0ZOy8efM0ceJETZgwQZKUnZ2td955R0uXLtWMGTNq9F+wYIGGDx+ue+65R5L00EMPKTc3V08//bSys7MVEhKi3NxctzFPP/204uPjtW/fPnXp0sV1vG3btoqMjKx/0A3g890cAACcC6eSCTNrJup3vcrKShUUFLjtVvTz81NycrLy8/M9jsnPz6+xuzElJaXW/pJUUlIim82m0NBQt+Nz585V+/btNWDAAD322GM6efJk/W6gHs6Lh1adtmHDBl+HAADAGf38sQR2u112u71Gv++++07V1dWKiIhwOx4REaHdu3d7PLfD4fDY3+FweOxfXl6u++67T2PHjnVbR3jnnXdq4MCBCgsL06ZNmzRz5kwdPHhQ8+bNq9M91td5lUwAAOAtjbU1NDo62u14Zmam5syZYya0BqmqqtJvf/tbGYahxYsXu32WkZHh+rlv374KDAzU7bffrqysLI+Jj1kkEwAASzD+28yMl0492uCnswC1fTl36NBB/v7+Ki4udjteXFxc61qGyMjIOvU/nUj85z//0fr168+6uzEhIUEnT57UN998o549e56xb0OwZgIAgHr4+SMKaksmAgMDFRsbq7y8PNcxp9OpvLw8JSYmehyTmJjo1l+ScnNz3fqfTiS+/PJLffDBB2rfvv1ZYy4sLJSfn5/Cw8Prcov1xswEAMASfPEEzIyMDI0bN05xcXGKj4/X/PnzVVZW5trdceutt+qCCy5QVlaWJGnq1KkaMmSInnjiCY0YMUKrVq3Stm3btGTJEkmnEombb75Z27dv19q1a1VdXe1aTxEWFqbAwEDl5+dr8+bNuvrqq9W2bVvl5+dr+vTpuuWWW7z2DiySCQCANTRWnaMeRo8ercOHD2v27NlyOBzq37+/cnJyXIss9+3bJz+//ysSDB48WCtXrtSsWbN0//3366KLLtIbb7zhemTC/v379dZbb0mS+vfv73atDz/8UEOHDpXdbteqVas0Z84cVVRUqHv37po+fbrbOorGZjOMpvsetNLSUoWEhKjL3IflV8dHcgMAzh/O8nLtmzFLJSUlXnuq8envih7L/yS/Vg3/rnCeKNe/x/+vV2NtqlgzAQAATKHMAQCwBF88AdMqSCYAAJbAK8i9hzIHAAAwhZkJAIA1GLZTzcx4eEQyAQCwBNZMeA9lDgAAYAozEwAAa/DBQ6usgmQCAGAJ7ObwHsocAADAFGYmAADWQanCK0gmAACWQJnDe0gmAADWwAJMr2HNBAAAMIWZCQCARdj+28yMhyckEwAAa6DM4TWUOQAAgCnMTAAArIGZCa8hmQAAWANvDfUayhwAAMAUZiYAAJbAK8i9h2QCAGANrJnwGsocAADAFGYmAADWwAJMryGZAABYgs041cyMh2ckEwAAa2DNhNewZgIAAJjCzAQAwBpYM+E1JBMAAGugzOE1lDkAAIApzEwAAKyBmQmvIZkAAFgDyYTXUOYAAACmMDMBALAGdnN4DckEAMASeAKm91DmAAAApvg0mVi8eLH69u2r4OBgBQcHKzExUe+++64vQwIANFdGI7QGWLRokbp166agoCAlJCRoy5YtZ+y/Zs0a9erVS0FBQerTp4/WrVvnfhuGodmzZ6tTp05q2bKlkpOT9eWXX7r1OXLkiFJTUxUcHKzQ0FClpaXp+PHjDbuBOvBpMtG5c2fNnTtXBQUF2rZtm4YNG6Ybb7xRO3fu9GVYAAA0itWrVysjI0OZmZnavn27+vXrp5SUFB06dMhj/02bNmns2LFKS0vTZ599ppEjR2rkyJHasWOHq89f/vIXLVy4UNnZ2dq8ebNat26tlJQUlZeXu/qkpqZq586dys3N1dq1a/XRRx9p0qRJXrtPm2EY51UVKCwsTI899pjS0tLO2re0tFQhISHqMvdh+QUFnYPoAACNyVlern0zZqmkpETBwcFeucbp74quj5r7rnCWl+s/99Uv1oSEBF122WV6+umnT53D6VR0dLSmTJmiGTNm1Og/evRolZWVae3ata5jgwYNUv/+/ZWdnS3DMBQVFaW77rpLd999tySppKREERERWr58ucaMGaNdu3apd+/e2rp1q+Li4iRJOTk5uv766/Xtt98qKiqqwX+D2tRpAeZNN9109hMFBCgyMlLXXHONbrjhhnoHUl1drTVr1qisrEyJiYke+1RUVKiiosL1e2lpab2vAwCAGT//7rHb7bLb7TX6VVZWqqCgQDNnznQd8/PzU3JysvLz8z2eOz8/XxkZGW7HUlJS9MYbb0iS9u7dK4fDoeTkZNfnISEhSkhIUH5+vsaMGaP8/HyFhoa6EglJSk5Olp+fnzZv3qxf//rX9b7ns6lTmSMkJOSsrWXLlvryyy81evRozZ49u84BfP7552rTpo3sdrv+8Ic/6PXXX1fv3r099s3KynK7ZnR0dJ2vAwCwuNNbQ800SdHR0W7fRVlZWR4v991336m6uloRERFuxyMiIuRwODyOcTgcZ+x/+n/P1ic8PNzt84CAAIWFhdV6XbPqNDOxbNmyOp9w7dq1+uMf/6gHH3ywTv179uypwsJClZSU6NVXX9W4ceO0ceNGjwnFzJkz3TK20tJSEgoAQN000hMwi4qK3MocnmYlrKbRnzNxxRVXuE2tnE1gYKAuvPBCSVJsbKy2bt2qBQsW6Nlnn63Rt7apJAAAzpXTOxDPpkOHDvL391dxcbHb8eLiYkVGRnocExkZecb+p/+3uLhYnTp1cuvTv39/V5+fL/A8efKkjhw5Uut1zWr03RyhoaF67bXXGjze6XS6rYsAAKBRnOOtoYGBgYqNjVVeXp7rmNPpVF5eXq1rAxMTE936S1Jubq6rf/fu3RUZGenWp7S0VJs3b3b1SUxM1NGjR1VQUODqs379ejmdTiUkJNTvJurIp0/AnDlzpq677jp16dJFx44d08qVK7Vhwwa99957vgwLANAM+eIJmBkZGRo3bpzi4uIUHx+v+fPnq6ysTBMmTJAk3Xrrrbrgggtc6y6mTp2qIUOG6IknntCIESO0atUqbdu2TUuWLDkVg82madOm6eGHH9ZFF12k7t27689//rOioqI0cuRISVJMTIyGDx+uiRMnKjs7W1VVVUpPT9eYMWO8spND8nEycejQId166606ePCgQkJC1LdvX7333nu65pprfBkWAACNYvTo0Tp8+LBmz54th8Oh/v37Kycnx7WAct++ffLz+78iweDBg7Vy5UrNmjVL999/vy666CK98cYbuvTSS1197r33XpWVlWnSpEk6evSorrjiCuXk5CjoJ9teV6xYofT0dCUlJcnPz0+jRo3SwoULvXaf591zJuqD50wAQNN2Lp8z0e3h/zX9nIlvZv3Jq7E2VbzoCwBgDY20mwM18aIvAABgCjMTAABL4BXk3kMyAQCwhp88xbLB4+ERyQQAwBpYM+E1rJkAAACmMDMBALAE1kx4D8kEAMAaKHN4DWUOAABgCjMTAABrMFnmYGaidiQTAABroMzhNZQ5AACAKcxMAACsgZkJryGZAABYAltDvYcyBwAAMIVkAgAAmEKZAwBgDayZ8BqSCQCAJbBmwnsocwAAAFOYmQAAWAezC15BMgEAsAbWTHgNZQ4AAGAKMxMAAEtgAab3kEwAAKyBMofXUOYAAACmMDMBALAEyhzeQzIBALAGyhxeQ5kDAACYwswEAMAamJnwGpIJAIAlsGbCe0gmAADWwMyE17BmAgAAmMLMBADAGpiZ8BqSCQCAJbBmwnsocwAAAFNIJgAA1mA0QvOSI0eOKDU1VcHBwQoNDVVaWpqOHz9+xjHl5eWaPHmy2rdvrzZt2mjUqFEqLi52ff7//t//09ixYxUdHa2WLVsqJiZGCxYscDvHhg0bZLPZajSHw1Gv+ClzAAAs4Xwuc6SmpurgwYPKzc1VVVWVJkyYoEmTJmnlypW1jpk+fbreeecdrVmzRiEhIUpPT9dNN92kTz75RJJUUFCg8PBw/fWvf1V0dLQ2bdqkSZMmyd/fX+np6W7n2rNnj4KDg12/h4eH1yt+kgkAAHxo165dysnJ0datWxUXFydJeuqpp3T99dfr8ccfV1RUVI0xJSUleuGFF7Ry5UoNGzZMkrRs2TLFxMTo008/1aBBg3Tbbbe5jenRo4fy8/P12muv1UgmwsPDFRoa2uB7oMwBALCGRipzlJaWurWKigpTYeXn5ys0NNSVSEhScnKy/Pz8tHnzZo9jCgoKVFVVpeTkZNexXr16qUuXLsrPz6/1WiUlJQoLC6txvH///urUqZOuueYa18xGfZBMAACsoZGSiejoaIWEhLhaVlaWqbAcDkeNskJAQIDCwsJqXbvgcDgUGBhYYzYhIiKi1jGbNm3S6tWrNWnSJNexTp06KTs7W3//+9/197//XdHR0Ro6dKi2b99er3ugzAEAQD0UFRW5rS+w2+0e+82YMUOPPvroGc+1a9euRo2tNjt27NCNN96ozMxMXXvtta7jPXv2VM+ePV2/Dx48WF9//bWefPJJvfzyy3U+v0+TiaysLL322mvavXu3WrZsqcGDB+vRRx91uzEAABqD7b/NzHhJCg4OdksmanPXXXdp/PjxZ+zTo0cPRUZG6tChQ27HT548qSNHjigyMtLjuMjISFVWVuro0aNusxPFxcU1xnzxxRdKSkrSpEmTNGvWrLPGHR8fr48//vis/X7Kp8nExo0bNXnyZF122WU6efKk7r//fl177bX64osv1Lp1a1+GBgBobs7xEzA7duyojh07nrVfYmKijh49qoKCAsXGxkqS1q9fL6fTqYSEBI9jYmNj1aJFC+Xl5WnUqFGSTu3I2LdvnxITE139du7cqWHDhmncuHH63//93zrFXVhYqE6dOtWp72k+TSZycnLcfl++fLnCw8NVUFCgq666ykdRAQCao/N1a2hMTIyGDx+uiRMnKjs7W1VVVUpPT9eYMWNcOzn279+vpKQkvfTSS4qPj1dISIjS0tKUkZGhsLAwBQcHa8qUKUpMTNSgQYMknSptDBs2TCkpKcrIyHCtpfD393clOfPnz1f37t11ySWXqLy8XM8//7zWr1+v999/v173cF6tmSgpKZEkjytNAQBorlasWKH09HQlJSXJz89Po0aN0sKFC12fV1VVac+ePTpx4oTr2JNPPunqW1FRoZSUFD3zzDOuz1999VUdPnxYf/3rX/XXv/7Vdbxr16765ptvJEmVlZW66667tH//frVq1Up9+/bVBx98oKuvvrpe8dsMwzgvnjbudDr1q1/9SkePHq21VlNRUeG2Bae0tFTR0dHqMvdh+QUFnatQAQCNxFlern0zZqmkpKRO6xAaorS0VCEhIbrk9kfkb2/4d0V1Rbl2Pnu/V2Ntqs6braGTJ0/Wjh07tGrVqlr7ZGVluW3HiY6OPocRAgCavPPwUdrNwXmRTKSnp2vt2rX68MMP1blz51r7zZw5UyUlJa5WVFR0DqMEAACe+HTNhGEYmjJlil5//XVt2LBB3bt3P2N/u91e635eAADO5HxdgNkc+DSZmDx5slauXKk333xTbdu2da00DQkJUcuWLX0ZGgCguTnHW0OtxKdljsWLF6ukpERDhw5Vp06dXG316tW+DAsAANSDz8scAACcC5Q5vOe8es4EAABeQ5nDa86L3RwAAKDpYmYCAGAJlDm8h2QCAGANlDm8hmQCAGANJBNew5oJAABgCjMTAABLYM2E95BMAACsgTKH11DmAAAApjAzAQCwBJthyGbiyctmxjZ3JBMAAGugzOE1lDkAAIApzEwAACyB3RzeQzIBALAGyhxeQ5kDAACYwswEAMASKHN4D8kEAMAaKHN4DckEAMASmJnwHtZMAAAAU5iZAABYA2UOryGZAABYBqUK76DMAQAATGFmAgBgDYZxqpkZD49IJgAAlsBuDu+hzAEAAExhZgIAYA3s5vAakgkAgCXYnKeamfHwjDIHAAAwhZkJAIA1UObwGmYmAACWcHo3h5nmLUeOHFFqaqqCg4MVGhqqtLQ0HT9+/IxjysvLNXnyZLVv315t2rTRqFGjVFxc7H7PNluNtmrVKrc+GzZs0MCBA2W323XhhRdq+fLl9Y6fZAIAYA2nnzNhpnlJamqqdu7cqdzcXK1du1YfffSRJk2adMYx06dP19tvv601a9Zo48aNOnDggG666aYa/ZYtW6aDBw+62siRI12f7d27VyNGjNDVV1+twsJCTZs2Tb///e/13nvv1St+yhwAAPjQrl27lJOTo61btyouLk6S9NRTT+n666/X448/rqioqBpjSkpK9MILL2jlypUaNmyYpFNJQ0xMjD799FMNGjTI1Tc0NFSRkZEer52dna3u3bvriSeekCTFxMTo448/1pNPPqmUlJQ63wMzEwAAS2isMkdpaalbq6ioMBVXfn6+QkNDXYmEJCUnJ8vPz0+bN2/2OKagoEBVVVVKTk52HevVq5e6dOmi/Px8t76TJ09Whw4dFB8fr6VLl8r4yQxLfn6+2zkkKSUlpcY5zoZkAgBgDUYjNEnR0dEKCQlxtaysLFNhORwOhYeHux0LCAhQWFiYHA5HrWMCAwMVGhrqdjwiIsJtzIMPPqhXXnlFubm5GjVqlP74xz/qqaeecjtPREREjXOUlpbqxx9/rPM9UOYAAKAeioqKFBwc7Prdbrd77Ddjxgw9+uijZzzXrl27GjW2n/vzn//s+nnAgAEqKyvTY489pjvvvLNRr0MyAQCwhMZ6N0dwcLBbMlGbu+66S+PHjz9jnx49eigyMlKHDh1yO37y5EkdOXKk1rUOkZGRqqys1NGjR91mJ4qLi2sdI0kJCQl66KGHVFFRIbvdrsjIyBo7QIqLixUcHKyWLVue+QZ/gmQCAGAN5/itoR07dlTHjh3P2i8xMVFHjx5VQUGBYmNjJUnr16+X0+lUQkKCxzGxsbFq0aKF8vLyNGrUKEnSnj17tG/fPiUmJtZ6rcLCQrVr1841m5KYmKh169a59cnNzT3jOTwhmQAAwIdiYmI0fPhwTZw4UdnZ2aqqqlJ6errGjBnj2smxf/9+JSUl6aWXXlJ8fLxCQkKUlpamjIwMhYWFKTg4WFOmTFFiYqJrJ8fbb7+t4uJiDRo0SEFBQcrNzdUjjzyiu+++23XtP/zhD3r66ad177336rbbbtP69ev1yiuv6J133qnXPZBMAAAs4Xx+BfmKFSuUnp6upKQk+fn5adSoUVq4cKHr86qqKu3Zs0cnTpxwHXvyySddfSsqKpSSkqJnnnnG9XmLFi20aNEiTZ8+XYZh6MILL9S8efM0ceJEV5/u3bvrnXfe0fTp07VgwQJ17txZzz//fL22hUqSzTC8+BQOLystLVVISIi6zH1YfkFBvg4HAFBPzvJy7ZsxSyUlJXVah9AQp78rEoc/qIAWDf+uOFlVrvyc2V6NtaliaygAADCFMgcAwBLO5zJHU+fTmYmPPvpIN9xwg6KiomSz2fTGG2/4MhwAQHPmNMw3eOTTZKKsrEz9+vXTokWLfBkGAMAKGukJmKjJp2WO6667Ttddd50vQwAAACaxZgIAYAk2mVwz0WiRND9NKpmoqKhweztbaWmpD6MBADQp5/gJmFbSpLaGZmVlub2pLTo62tchAQBgeU0qmZg5c6ZKSkpcraioyNchAQCaiNNbQ800eNakyhx2u73WV70CAHBGZndkkEzUyqfJxPHjx/XVV1+5ft+7d68KCwsVFhamLl26+DAyAABQVz5NJrZt26arr77a9XtGRoYkady4cVq+fLmPogIANEc2w5DNxCJKM2ObO58mE0OHDlUTfs8YAKApcf63mRkPj5rUAkwAAHD+aVILMAEAaCjKHN5DMgEAsAZ2c3gNyQQAwBp4AqbXsGYCAACYwswEAMASzD7Fkidg1o5kAgBgDZQ5vIYyBwAAMIWZCQCAJdicp5qZ8fCMZAIAYA2UObyGMgcAADCFmQkAgDXw0CqvIZkAAFgCj9P2HsocAADAFGYmAADWwAJMryGZAABYgyHJzPZOcolakUwAACyBNRPew5oJAABgCjMTAABrMGRyzUSjRdLskEwAAKyBBZheQ5kDAACYwswEAMAanJJsJsfDI2YmAACWcHo3h5nmLUeOHFFqaqqCg4MVGhqqtLQ0HT9+/IxjysvLNXnyZLVv315t2rTRqFGjVFxc7Pp8+fLlstlsHtuhQ4ckSRs2bPD4ucPhqFf8JBMAAPhYamqqdu7cqdzcXK1du1YfffSRJk2adMYx06dP19tvv601a9Zo48aNOnDggG666SbX56NHj9bBgwfdWkpKioYMGaLw8HC3c+3Zs8et388/PxvKHAAAazhPF2Du2rVLOTk52rp1q+Li4iRJTz31lK6//no9/vjjioqKqjGmpKREL7zwglauXKlhw4ZJkpYtW6aYmBh9+umnGjRokFq2bKmWLVu6xhw+fFjr16/XCy+8UON84eHhCg0NbfA9MDMBALCG08mEmeYF+fn5Cg0NdSUSkpScnCw/Pz9t3rzZ45iCggJVVVUpOTnZdaxXr17q0qWL8vPzPY556aWX1KpVK9188801Puvfv786deqka665Rp988km974GZCQAA6qG0tNTtd7vdLrvd3uDzORyOGmWFgIAAhYWF1bp2weFwKDAwsMZsQkRERK1jXnjhBf3ud79zm63o1KmTsrOzFRcXp4qKCj3//PMaOnSoNm/erIEDB9b5HpiZAABYQyPNTERHRyskJMTVsrKyPF5uxowZtS6APN127959Tm49Pz9fu3btUlpamtvxnj176vbbb1dsbKwGDx6spUuXavDgwXryySfrdX5mJgAA1tBIW0OLiooUHBzsOlzbrMRdd92l8ePHn/GUPXr0UGRkpGt3xWknT57UkSNHFBkZ6XFcZGSkKisrdfToUbfZieLiYo9jnn/+efXv31+xsbFnjEeS4uPj9fHHH5+130+RTAAALKGxXvQVHBzslkzUpmPHjurYseNZ+yUmJuro0aMqKChwfdmvX79eTqdTCQkJHsfExsaqRYsWysvL06hRoySd2pGxb98+JSYmuvU9fvy4XnnllVpnUH6usLBQnTp1qlPf00gmAADwoZiYGA0fPlwTJ05Udna2qqqqlJ6erjFjxrh2cuzfv19JSUl66aWXFB8fr5CQEKWlpSkjI0NhYWEKDg7WlClTlJiYqEGDBrmdf/Xq1Tp58qRuueWWGteeP3++unfvrksuuUTl5eV6/vnntX79er3//vv1ugeSCQCANZynW0MlacWKFUpPT1dSUpL8/Pw0atQoLVy40PV5VVWV9uzZoxMnTriOPfnkk66+FRUVSklJ0TPPPFPj3C+88IJuuukmj1s/Kysrddddd2n//v1q1aqV+vbtqw8++EBXX311veK3GUbTfXNJaWmpQkJC1GXuw/ILCvJ1OACAenKWl2vfjFkqKSmpU+mgIU5/VyT/YpoC/Bu+6+JkdYU++Hq+V2NtqtjNAQAATKHMAQCwhvO4zNHUkUwAACzC7FMsSSZqQ5kDAACYwswEAMAaKHN4DckEAMAanIZMlSqcJBO1ocwBAABMYWYCAGANhvNUMzMeHpFMAACsgTUTXnNelDkWLVqkbt26KSgoSAkJCdqyZYuvQwIANDdOw3yDRz5PJlavXq2MjAxlZmZq+/bt6tevn1JSUmq8jhUAAJyffJ5MzJs3TxMnTtSECRPUu3dvZWdnq1WrVlq6dKmvQwMANCenyxxmGjzyaTJRWVmpgoICJScnu475+fkpOTlZ+fn5NfpXVFSotLTUrQEAUCeGTCYTvr6B85dPk4nvvvtO1dXVioiIcDseEREhh8NRo39WVpZCQkJcLTo6+lyFCgAAauHzMkd9zJw5UyUlJa5WVFTk65AAAE0FZQ6v8enW0A4dOsjf31/FxcVux4uLixUZGVmjv91ul93e8HfRAwAszOmUZOJZEU6eM1Ebn85MBAYGKjY2Vnl5ea5jTqdTeXl5SkxM9GFkAACgrnz+0KqMjAyNGzdOcXFxio+P1/z581VWVqYJEyb4OjQAQHPCQ6u8xufJxOjRo3X48GHNnj1bDodD/fv3V05OTo1FmQAAmEIy4TU+TyYkKT09Xenp6b4OAwAANMB5kUwAAOB1vILca0gmAACWYBhOGSbe/GlmbHNHMgEAsAbD5Mu6WDNRqyb10CoAAHD+YWYCAGANhsk1E8xM1IpkAgBgDU6nZDOx7oE1E7WizAEAAExhZgIAYA2UObyGZAIAYAmG0ynDRJmDraG1o8wBAABMYWYCAGANlDm8hmQCAGANTkOykUx4A2UOAABgCjMTAABrMAxJZp4zwcxEbUgmAACWYDgNGSbKHAbJRK0ocwAArMFwmm9ecuTIEaWmpio4OFihoaFKS0vT8ePHzzhmyZIlGjp0qIKDg2Wz2XT06NEGnfef//ynrrzySgUFBSk6Olp/+ctf6h0/yQQAAD6WmpqqnTt3Kjc3V2vXrtVHH32kSZMmnXHMiRMnNHz4cN1///0NPm9paamuvfZade3aVQUFBXrsscc0Z84cLVmypF7xU+YAAFjC+Vrm2LVrl3JycrR161bFxcVJkp566ildf/31evzxxxUVFeVx3LRp0yRJGzZsaPB5V6xYocrKSi1dulSBgYG65JJLVFhYqHnz5p01mfkpZiYAANZwnpY58vPzFRoa6vrCl6Tk5GT5+flp8+bNXj1vfn6+rrrqKgUGBrr6pKSkaM+ePfrhhx/qfK0mPTNxOkt0lpf7OBIAQEOc/u/3uVjceFJVpp5ZdVJVkk6VBn7KbrfLbrc3+LwOh0Ph4eFuxwICAhQWFiaHw+HV8zocDnXv3t2tT0REhOuzdu3a1elaTTqZOHbsmCTp2zkP+zgSAIAZx44dU0hIiFfOHRgYqMjISH3sWGf6XG3atFF0dLTbsczMTM2ZM6dG3xkzZujRRx894/l27dplOqbzQZNOJqKiolRUVKS2bdvKZrN59VqlpaWKjo5WUVGRgoODvXqtc6G53Y/EPTUV3NP571zej2EYOnbsWK3rAhpDUFCQ9u7dq8rKStPnMgyjxvdNbbMSd911l8aPH3/G8/Xo0UORkZE6dOiQ2/GTJ0/qyJEjioyMbHCsdTlvZGSkiouL3fqc/r0+127SyYSfn586d+58Tq8ZHBzcLP5jcVpzux+Je2oquKfz37m6H2/NSPxUUFCQgoKCvH6dn+rYsaM6dux41n6JiYk6evSoCgoKFBsbK0lav369nE6nEhISGnz9upw3MTFRf/rTn1RVVaUWLVpIknJzc9WzZ886lzgkFmACAOBTMTExGj58uCZOnKgtW7bok08+UXp6usaMGeOasdm/f7969eqlLVu2uMY5HA4VFhbqq6++kiR9/vnnKiws1JEjR+p83t/97ncKDAxUWlqadu7cqdWrV2vBggXKyMio1z2QTAAA4GMrVqxQr169lJSUpOuvv15XXHGF27MeqqqqtGfPHp04ccJ1LDs7WwMGDNDEiRMlSVdddZUGDBigt956q87nDQkJ0fvvv6+9e/cqNjZWd911l2bPnl2vbaFSEy9znEt2u12ZmZmmVuyeT5rb/UjcU1PBPZ3/mtv9NAVhYWFauXJlrZ9369atxo6XOXPmeFz4WZ/zSlLfvn31j3/8o86xemIzeNg4AAAwgTIHAAAwhWQCAACYQjIBAABMIZkAAACmkEzUwaJFi9StWzcFBQUpISHBbZ9vU/PRRx/phhtuUFRUlGw2m9544w1fh2RaVlaWLrvsMrVt21bh4eEaOXKk9uzZ4+uwTFm8eLH69u3remhQYmKi3n33XV+H1Wjmzp0rm83meuthUzRnzhzZbDa31qtXL1+HZdr+/ft1yy23qH379mrZsqX69Omjbdu2+TosnOdIJs5i9erVysjIUGZmprZv365+/fopJSWlxiNKm4qysjL169dPixYt8nUojWbjxo2aPHmyPv30U+Xm5qqqqkrXXnutysrKfB1ag3Xu3Flz585VQUGBtm3bpmHDhunGG2/Uzp07fR2aaVu3btWzzz6rvn37+joU0y655BIdPHjQ1T7++GNfh2TKDz/8oMsvv1wtWrTQu+++qy+++EJPPPFEvZ6ECIsycEbx8fHG5MmTXb9XV1cbUVFRRlZWlg+jahySjNdff93XYTS6Q4cOGZKMjRs3+jqURtWuXTvj+eef93UYphw7dsy46KKLjNzcXGPIkCHG1KlTfR1Sg2VmZhr9+vXzdRiN6r777jOuuOIKX4eBJoiZiTOorKxUQUGBkpOTXcf8/PyUnJys/Px8H0aGMykpKZF06mEtzUF1dbVWrVqlsrIyJSYm+jocUyZPnqwRI0a4/X+qKfvyyy8VFRWlHj16KDU1Vfv27fN1SKa89dZbiouL029+8xuFh4drwIABeu6553wdFpoAkokz+O6771RdXe16t/tpERERpt4xD+9xOp2aNm2aLr/8cl166aW+DseUzz//XG3atJHdbtcf/vAHvf766+rdu7evw2qwVatWafv27crKyvJ1KI0iISFBy5cvV05OjhYvXqy9e/fqyiuv1LFjx3wdWoP9+9//1uLFi3XRRRfpvffe0x133KE777xTL774oq9Dw3mOx2mjWZk8ebJ27NjR5GvXktSzZ08VFhaqpKREr776qsaNG6eNGzc2yYSiqKhIU6dOVW5u7jl/c6O3XHfdda6f+/btq4SEBHXt2lWvvPKK0tLSfBhZwzmdTsXFxemRRx6RJA0YMEA7duxQdna2xo0b5+PocD5jZuIMOnToIH9/f4/vejfzjnl4R3p6utauXasPP/zwnL+a3hsCAwN14YUXKjY2VllZWerXr58WLFjg67AapKCgQIcOHdLAgQMVEBCggIAAbdy4UQsXLlRAQICqq6t9HaJpoaGhuvjii11vcGyKOnXqVCNZjYmJafLlG3gfycQZBAYGKjY2Vnl5ea5jTqdTeXl5Tb523ZwYhqH09HS9/vrrWr9+vbp37+7rkLzC6XSqoqLC12E0SFJSkuv1yKdbXFycUlNTVVhYKH9/f1+HaNrx48f19ddfq1OnTr4OpcEuv/zyGtuq//Wvf6lr164+ighNBWWOs8jIyNC4ceMUFxen+Ph4zZ8/X2VlZZowYYKvQ2uQ48ePu/3Lae/evSosLFRYWJi6dOniw8gabvLkyVq5cqXefPNNtW3b1rWeJSQkRC1btvRxdA0zc+ZMXXfdderSpYuOHTumlStXasOGDXrvvfd8HVqDtG3btsYaltatW6t9+/ZNdm3L3XffrRtuuEFdu3bVgQMHlJmZKX9/f40dO9bXoTXY9OnTNXjwYD3yyCP67W9/qy1btmjJkiVur6wGPPL1dpKm4KmnnjK6dOliBAYGGvHx8cann37q65Aa7MMPPzQk1Wjjxo3zdWgN5ul+JBnLli3zdWgNdttttxldu3Y1AgMDjY4dOxpJSUnG+++/7+uwGlVT3xo6evRoo1OnTkZgYKBxwQUXGKNHjza++uorX4dl2ttvv21ceumlht1uN3r16mUsWbLE1yGhCeAV5AAAwBTWTAAAAFNIJgAAgCkkEwAAwBSSCQAAYArJBAAAMIVkAgAAmEIyAQAATCGZAAAAppBMAOex8ePHa+TIkb4OAwDOiGQCAACYQjIBAABMIZkAAACmkEwAAABTSCYAAIApJBMAAMAUkgkAAGAKyQQAADCFZAIAAJhiMwzD8HUQAACg6WJmAgAAmEIyAQAATCGZAAAAppBMAAAAU0gmAACAKSQTAADAFJIJAABgCskEAAAwhWQCAACYQjIBAABMIZkAAACmkEwAAABT/j99fHhdg7duGAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -753,33 +718,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Executing 'copy_stencil' to copy qty_out to qty_in\n", + "Resetting qty_out to zeros\n", + "Executing 'copy_downward' with origin=(1,1,0), domain=(nx,ny,nz-1)\n", "***\n", - "Plotting values of qty_in at K = 0\n", - "Min and max values: 10.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 1\n", - "Min and max values: 20.0 0.0\n" + "Plotting values of qty_out at K = 0\n", + "Min and max values: 11.0 0.0\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAHHCAYAAACx2FF+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3vklEQVR4nO3de3hV1Z3/8c9JAicRknDLVUIABSIiAbnEAApIBFNKAVtKMziEi7Z1EgUzVkvHAl7G2Dr1VmhQpxJqpaCdAhY1DKAJYwEl0DwjTqWAgQQhQfhJQlIJmLN/f2hOOOZCTvZJdnL2+/U863k8++y19/f4tH6zvmvttR2GYRgCAAC2EWB1AAAAoH2R/AEAsBmSPwAANkPyBwDAZkj+AADYDMkfAACbIfkDAGAzJH8AAGyG5A8AgM2Q/GFr+fn5cjgcys/PtzoUAGg3JH/4pdzcXDkcDncLDg7W4MGDlZmZqfLycp/c46233tLKlSt9cq3LrV+/Xs8++2yLz+/fv7++/e1vNzj+yiuvKDAwULfffrsuXLjgwwibdujQId1///0aN26cgoOD5XA4dOzYsXa5N4CWI/nDrz366KN65ZVXtGrVKo0bN045OTlKTk7WP/7xD9PXfuutt/TII4/4IEpP3ib/xrz66qtasGCBUlJStHnzZgUHB/smuCvYs2ePnn/+eZ0/f17XXXddu9wTgPeCrA4AaEupqakaPXq0JOmuu+5S79699fTTT2vLli1KS0uzOLq2sWHDBqWnp+vWW2/Vli1b2i3xS9J3vvMdnTt3TqGhofqP//gPFRUVtdu9AbQcI3/Yyq233ipJKi4ubva8119/XaNGjVJISIj69OmjO++8U59++qn7+wULFmj16tWS5DG90JwtW7Zo+vTpio2NldPp1DXXXKPHHntMtbW17nMmTZqkN998U8ePH3dfs3///i3+fa+99pruvPNOTZo0SW+88Ua7Jn5J6tWrl0JDQ9v1ngC8x8gftnL06FFJUu/evZs8Jzc3VwsXLtSYMWOUnZ2t8vJyPffcc/rLX/6iv/71r+rRo4d+9KMf6eTJk9q+fbteeeWVFt07NzdX3bt3V1ZWlrp376533nlHy5cvV2VlpZ566ilJ0r/927+poqJCJ06c0DPPPCNJ6t69e4uu/1//9V+aN2+ebrnlFv35z39WSEhIi/pVVVW1aE1Aly5dFB4e3qJrAujgDMAPrV271pBk7Nixw/jss8+M0tJSY8OGDUbv3r2NkJAQ48SJE4ZhGMa7775rSDLeffddwzAM4+LFi0ZkZKQxbNgw44svvnBfb+vWrYYkY/ny5e5jGRkZhjf/F/rHP/7R4NiPfvQj46qrrjIuXLjgPjZ9+nQjPj6+xdeNj483YmNjjaCgIGPSpElGdXV1i/sahmGkp6cbkq7YJk6c6NV1n3rqKUOSUVxc7FU/AG2PkT/8WkpKisfn+Ph4vfrqq7r66qsbPb+wsFCnT5/WypUrPUrm06dPV0JCgt58881WL/K7fCR+/vx51dTU6Oabb9YLL7ygjz/+WImJia26riT9v//3//Tll1+qb9++LR7x13nwwQd15513XvG8nj17tjY8AB0MyR9+bfXq1Ro8eLCCgoIUFRWlIUOGKCCg6aUux48flyQNGTKkwXcJCQl67733Wh3LRx99pIcffljvvPOOKisrPb6rqKho9XUlacqUKerXr59ycnLUq1cvPffccy3uO3ToUA0dOtTU/QF0LiR/+LWxY8e6V/tb6dy5c5o4caLCwsL06KOP6pprrlFwcLAOHDighx56SC6Xy/Q9Vq1apc8//1zPP/+8evbs2eI9CCoqKvTFF19c8byuXbuqV69eJqME0BGQ/IHLxMfHS/pqs5q6JwPqHDp0yP29pCuu7r9cfn6+zp49qz/96U+65ZZb3Mcbe+rAm+teLiAgQL/73e9UUVGhRx55RL169dJ99913xX5LlizRunXrrnjexIkT2QkR8BMkf+Ayo0ePVmRkpNasWaNFixbJ6XRKkt5++2397W9/0/Lly93nduvWTdJXo/oePXo0e93AwEBJkmEY7mMXL17Ub37zmwbnduvWrdXTAF26dNEf//hHTZ06VUuXLlXPnj31z//8z832Yc4fsB+SP3CZLl266Be/+IUWLlyoiRMnKi0tzf2oX//+/XX//fe7zx01apQk6b777tO0adMUGBioH/zgB41ed9y4cerZs6fS09N13333yeFw6JVXXvH4Y+Dy627cuFFZWVkaM2aMunfvrhkzZrT4N1x11VV68803NXHiRC1atEjh4eH6zne+0+T5vpzzr6io0K9//WtJ0l/+8hdJX01H9OjRQz169FBmZqZP7gPAJKsfNwDaQt2jfvv27Wv2vG8+6ldn48aNxsiRIw2n02n06tXLmDdvnvvxwDpffvmlce+99xoRERGGw+G44mN/f/nLX4ybbrrJCAkJMWJjY40HH3zQ2LZtW4P7V1VVGf/0T/9k9OjRw5B0xcf+4uPjjenTpzc4XlZWZlx77bVGcHBwg9/XVoqLi5t8VNCbxxcBtC2HYTQy9AAAAH6L7X0BALAZkj8AADZD8gcAwGZI/gAAtIHs7GyNGTNGoaGhioyM1KxZs3To0CGPcy5cuKCMjAz17t1b3bt313e/+12Vl5c3e13DMLR8+XLFxMQoJCREKSkpOnz4sFexkfwBAGgDBQUFysjI0N69e7V9+3ZdunRJU6dOVXV1tfuc+++/X3/+85/1+uuvq6CgQCdPntQdd9zR7HV/+ctf6vnnn9eaNWv0/vvvq1u3bpo2bVqL3s5Zh9X+AAC0g88++0yRkZEqKCjQLbfcooqKCkVERGj9+vX63ve+J0n6+OOPdd1112nPnj266aabGlzDMAzFxsbqX//1X/XAAw9I+mp/jaioKOXm5ja518g3depNflwul06ePKnQ0NBWb4kKALCOYRg6f/68YmNjm33pllkXLlzQxYsXTV/HMIwG+cbpdLp3A21O3c6dde/I2L9/vy5duuTx9tGEhAT169evyeRfXFyssrIyjz7h4eFKSkrSnj177JH8T548qbi4OKvDAACYVFpaqr59+7bJtS9cuKAB8d1VdrrW9LW6d++uqqoqj2MrVqy44ou0XC6Xli5dqvHjx2vYsGGSpLKyMnXt2rXB9uBRUVEqKytr9Dp1x6OiolrcpzGdOvmHhoZKkiboWwpSF4ujAQB460td0nt6y/3f87Zw8eJFlZ2u1fH9/RUW2vrqQuV5l+JHHVNpaanCwsLcx1sy6s/IyNDBgwdNvRbclzp18q8rvQSpi4IcJH8A6HS+XnXWHlO33UMd6h7a+vu49FXfsLAwj+R/JZmZmdq6dat27drlUd2Ijo7WxYsXG7wcrLy8XNHR0Y1eq+54eXm5YmJiPPqMGDGixTGx2h8AYAu1hst084ZhGMrMzNSmTZv0zjvvaMCAAR7fjxo1Sl26dNHOnTvdxw4dOqSSkhIlJyc3es0BAwYoOjrao09lZaXef//9Jvs0plOP/AEAaCmXDLnU+gfcvO2bkZGh9evXa8uWLQoNDXXPyYeHhyskJETh4eFavHixsrKy1KtXL4WFhenee+9VcnKyx2K/hIQEZWdna/bs2XI4HFq6dKkef/xxDRo0SAMGDNDPf/5zxcbGatasWS2OjeQPAEAbyMnJkSRNmjTJ4/jatWu1YMECSdIzzzyjgIAAffe731VNTY2mTZum3/zmNx7nHzp0yP2kgCQ9+OCDqq6u1g9/+EOdO3dOEyZMUF5enoKDg1scW6d+zr+yslLh4eGapJnM+QNAJ/SlcUn52qKKigqv5tG9UZcrTh7qa3rBX+yQE20aa3th5A8AsIVaw1CtifGumb4dDQv+AACwGUb+AABbaO8Ffx0ZyR8AYAsuGaol+Uui7A8AgO0w8gcA2AJl/3okfwCALbDavx5lfwAAbIaRPwDAFlxfNzP9/QXJHwBgC7UmV/ub6dvRkPwBALZQa3zVzPT3F8z5AwBgM4z8AQC2wJx/PZI/AMAWXHKoVg5T/f0FZX8AAGzG8uT/6aef6s4771Tv3r0VEhKiG264QYWFhVaHBQDwMy7DfPMXlpb9P//8c40fP16TJ0/W22+/rYiICB0+fFg9e/a0MiwAgB+qNVn2N9O3o7E0+f/iF79QXFyc1q5d6z42YMAACyMCAMD/WVr2f+ONNzR69GjNmTNHkZGRGjlypF566SUrQwIA+Km6kb+Z5i8sTf6ffPKJcnJyNGjQIG3btk333HOP7rvvPq1bt67R82tqalRZWenRAABoCZfhMN38haVlf5fLpdGjR+uJJ56QJI0cOVIHDx7UmjVrlJ6e3uD87OxsPfLII+0dJgAAfsXSkX9MTIyGDh3qcey6665TSUlJo+cvW7ZMFRUV7lZaWtoeYQIA/ABl/3qWjvzHjx+vQ4cOeRz7+9//rvj4+EbPdzqdcjqd7REaAMDP1CpAtSbGvLU+jMVqlib/+++/X+PGjdMTTzyh73//+/rggw/04osv6sUXX7QyLACAHzJMztsbfjTnb2nZf8yYMdq0aZP+8Ic/aNiwYXrsscf07LPPat68eVaGBQCAX7N8b/9vf/vb+va3v211GAAAP8cmP/UsT/4AALSHWiNAtYaJOX8/2t7X8r39AQBA+2LkDwCwBZcccpkY87rkP0N/kj8AwBaY869H2R8AAJth5A8AsAXzC/4o+wMA0Kl8Neff+tK9mb4dDWV/AABshpE/AMAWXCb39ven1f6M/AEAtlA352+meWPXrl2aMWOGYmNj5XA4tHnzZo/vHQ5Ho+2pp55q8porV65scH5CQoLX/y4Y+QMAbMGlgHZ9zr+6ulqJiYlatGiR7rjjjgbfnzp1yuPz22+/rcWLF+u73/1us9e9/vrrtWPHDvfnoCDvUznJHwCANpCamqrU1NQmv4+Ojvb4vGXLFk2ePFkDBw5s9rpBQUEN+nqL5A8AsIVaw6FaE6/lretbWVnpcdzpdMrpdJqKrby8XG+++abWrVt3xXMPHz6s2NhYBQcHKzk5WdnZ2erXr59X92POHwBgC7VfL/gz0yQpLi5O4eHh7padnW06tnXr1ik0NLTR6YHLJSUlKTc3V3l5ecrJyVFxcbFuvvlmnT9/3qv7MfIHAMALpaWlCgsLc382O+qXpJdfflnz5s1TcHBws+ddPo0wfPhwJSUlKT4+Xq+99poWL17c4vuR/AEAtuAyAuQyscOf6+sd/sLCwjySv1n/8z//o0OHDmnjxo1e9+3Ro4cGDx6sI0eOeNWPsj8AwBZ8Vfb3td/+9rcaNWqUEhMTve5bVVWlo0ePKiYmxqt+JH8AANpAVVWVioqKVFRUJEkqLi5WUVGRSkpK3OdUVlbq9ddf11133dXoNaZMmaJVq1a5Pz/wwAMqKCjQsWPHtHv3bs2ePVuBgYFKS0vzKjbK/gAAW3BJplb7u7w8v7CwUJMnT3Z/zsrKkiSlp6crNzdXkrRhwwYZhtFk8j569KjOnDnj/nzixAmlpaXp7NmzioiI0IQJE7R3715FRER4FZvDMDrva4oqKysVHh6uSZqpIEcXq8MBAHjpS+OS8rVFFRUVPp1Hv1xdrsg5MEYh3Vs/5v2i6kvdc+O+No21vTDy74A+WT/C6hB8bmDUmSuf1ImM6X3c6hB8LiX0I6tD8LlJId6O1Tq+abEjrA4BfoDkDwCwhdbsz//N/v6C5A8AsAWXHHLJzJx/6/t2NCR/AIAtMPKv5z+/BAAAtAgjfwCALZjdqKetNvmxAskfAGALLsMhl5nn/E307Wj8588YAADQIoz8AQC24DJZ9nf50XiZ5A8AsAXzb/Xzn+TvP78EAAC0CCN/AIAt1MqhWhMb9Zjp29GQ/AEAtkDZv57//BIAANAijPwBALZQK3Ol+1rfhWI5kj8AwBYo+9cj+QMAbIEX+9Tzn18CAABahJE/AMAWDDnkMjHnb/CoHwAAnQtl/3r+80sAAECLMPIHANgCr/StZ+nIf+XKlXI4HB4tISHBypAAAH6q9uu3+plp/sLykf/111+vHTt2uD8HBVkeEgAAfs3yTBsUFKTo6GirwwAA+DnK/vUsr2EcPnxYsbGxGjhwoObNm6eSkpImz62pqVFlZaVHAwCgJVwKMN38haW/JCkpSbm5ucrLy1NOTo6Ki4t188036/z5842en52drfDwcHeLi4tr54gBAOj8LC37p6amuv95+PDhSkpKUnx8vF577TUtXry4wfnLli1TVlaW+3NlZSV/AAAAWqTWcKjWROneTN+OxvI5/8v16NFDgwcP1pEjRxr93ul0yul0tnNUAAB/wJx/vQ41gVFVVaWjR48qJibG6lAAAH7G+Pqtfq1tBjv8+cYDDzyggoICHTt2TLt379bs2bMVGBiotLQ0K8MCAMCvWVr2P3HihNLS0nT27FlFRERowoQJ2rt3ryIiIqwMCwDgh2rlUK2Jl/OY6dvRWJr8N2zYYOXtAQA24jLMzdu7DB8GYzH/mcAAAAAt0qFW+wMA0FbqFu6Z6e8v/OeXAADQDJccpps3du3apRkzZig2NlYOh0ObN2/2+H7BggUNXm53++23X/G6q1evVv/+/RUcHKykpCR98MEHXsUlkfwBAGgT1dXVSkxM1OrVq5s85/bbb9epU6fc7Q9/+EOz19y4caOysrK0YsUKHThwQImJiZo2bZpOnz7tVWyU/QEAttDeO/ylpqZ67GTbGKfT6dXL7Z5++mndfffdWrhwoSRpzZo1evPNN/Xyyy/rpz/9aYuvw8gfAGALZjb4MbteoCn5+fmKjIzUkCFDdM899+js2bNNnnvx4kXt379fKSkp7mMBAQFKSUnRnj17vLovI38AALzwzTfKtnbr+dtvv1133HGHBgwYoKNHj+pnP/uZUlNTtWfPHgUGBjY4/8yZM6qtrVVUVJTH8aioKH388cde3ZvkDwCwBZdM7u3/9YK/b75QbsWKFVq5cqXX1/vBD37g/ucbbrhBw4cP1zXXXKP8/HxNmTKl1XG2BMkfAGALRitW7H+zvySVlpYqLCzMfdxXL5wbOHCg+vTpoyNHjjSa/Pv06aPAwECVl5d7HC8vL/dq3YDEnD8AwCbq3upnpklSWFiYR/NV8j9x4oTOnj3b5MvtunbtqlGjRmnnzp31v8nl0s6dO5WcnOzVvUj+AAC0gaqqKhUVFamoqEiSVFxcrKKiIpWUlKiqqko/+clPtHfvXh07dkw7d+7UzJkzde2112ratGnua0yZMkWrVq1yf87KytJLL72kdevW6W9/+5vuueceVVdXu1f/txRlfwCALbT3Dn+FhYWaPHmy+3NWVpYkKT09XTk5Ofrf//1frVu3TufOnVNsbKymTp2qxx57zKOScPToUZ05c8b9ee7cufrss8+0fPlylZWVacSIEcrLy2uwCPBKSP4AAFu4vHTf2v7emDRpkgyj6bcBbdu27YrXOHbsWINjmZmZyszM9CqWb6LsDwCAzTDyBwDYQmv25/9mf39B8gcA2EJ7l/07Msr+AADYDCN/AIAtMPKvR/IHANgCyb8eZX8AAGyGkX8H5CoPtjoEn/tEfawOAbb0kdUBoANh5F+P5A8AsAVD5h7Xa3q7ns6H5A8AsAVG/vWY8wcAwGYY+QMAbIGRfz2SPwDAFkj+9Sj7AwBgM4z8AQC2wMi/HskfAGALhuGQYSKBm+nb0VD2BwDAZhj5AwBswSWHqU1+zPTtaEj+AABbYM6/HmV/AABshpE/AMAWWPBXj+QPALAFyv71SP4AAFtg5F+POX8AAGyGkT8AwBYMk2V/fxr5k/wBALZgSDIMc/39BWV/AABshpE/AMAWXHLIwQ5/kkj+AACbYLV/vQ5T9n/yySflcDi0dOlSq0MBAMCvdYiR/759+/TCCy9o+PDhVocCAPBTLsMhB5v8SOoAI/+qqirNmzdPL730knr27Gl1OAAAP2UY5pu/sDz5Z2RkaPr06UpJSbniuTU1NaqsrPRoAADAO5aW/Tds2KADBw5o3759LTo/OztbjzzySBtHBQDwRyz4q2fZyL+0tFRLlizRq6++quDg4Bb1WbZsmSoqKtyttLS0jaMEAPiLuuRvpvkLy5L//v37dfr0ad14440KCgpSUFCQCgoK9PzzzysoKEi1tbUN+jidToWFhXk0AABaou6tfmaaN3bt2qUZM2YoNjZWDodDmzdvdn936dIlPfTQQ7rhhhvUrVs3xcbGav78+Tp58mSz11y5cqUcDodHS0hI8PrfhWVl/ylTpujDDz/0OLZw4UIlJCTooYceUmBgoEWRAQBgXnV1tRITE7Vo0SLdcccdHt/94x//0IEDB/Tzn/9ciYmJ+vzzz7VkyRJ95zvfUWFhYbPXvf7667Vjxw7356Ag71O5Zck/NDRUw4YN8zjWrVs39e7du8FxAADMMrti39u+qampSk1NbfS78PBwbd++3ePYqlWrNHbsWJWUlKhfv35NXjcoKEjR0dHeBfMNlq/2BwCgPXyV/M3M+bdtfBUVFXI4HOrRo0ez5x0+fFixsbEaOHCg5s2bp5KSEq/v1SE2+amTn59vdQgAADTrm4+ZO51OOZ1OU9e8cOGCHnroIaWlpTW7ni0pKUm5ubkaMmSITp06pUceeUQ333yzDh48qNDQ0Bbfj5E/AMAWfLXaPy4uTuHh4e6WnZ1tKq5Lly7p+9//vgzDUE5OTrPnpqamas6cORo+fLimTZumt956S+fOndNrr73m1T071MgfAIC2YnzdzPSXvnpU/fLRuZlRf13iP378uN555x2vn2Lr0aOHBg8erCNHjnjVj5E/AABe+OYj561N/nWJ//Dhw9qxY4d69+7t9TWqqqp09OhRxcTEeNWP5A8AsIX23uSnqqpKRUVFKioqkiQVFxerqKhIJSUlunTpkr73ve+psLBQr776qmpra1VWVqaysjJdvHjRfY0pU6Zo1apV7s8PPPCACgoKdOzYMe3evVuzZ89WYGCg0tLSvIqNsj8AwB58VfdvocLCQk2ePNn9OSsrS5KUnp6ulStX6o033pAkjRgxwqPfu+++q0mTJkmSjh49qjNnzri/O3HihNLS0nT27FlFRERowoQJ2rt3ryIiIryKjeQPALAHs1v0etl30qRJMpp5PrC57+ocO3bM4/OGDRu8iqEplP0BALAZRv4AAFto7x3+OjKSPwDAFnilbz3K/gAA2AwjfwCAPRgOrxftNejvJ0j+AABbYM6/HmV/AABshpE/AMAe2nmTn46M5A8AsAVW+9ej7A8AgM0w8gcA2Icfle7NIPkDAGyBsn89kj8AwB5Y8OfGnD8AADbDyL8DCinzv7/JvlCw1SH41CfqY3UIALzm+LqZ6e8fSP4AAHug7O/mf0NMAADQLEb+AAB7YOTvRvIHANgDb/Vzo+wPAIDNMPIHANgCr/StR/IHANgDc/5ulP0BALAZRv4AAHtgwZ8byR8AYAsO46tmpr+/IPkDAOyBOX835vwBALAZRv4AAHtgzt+N5A8AsAfK/m6U/QEAsBlG/gAAe2Dk70byBwDYA8nfjbI/AAA2w8gfAGAPrPZ3I/kDAGyBHf7qUfYHAMBmLE3+OTk5Gj58uMLCwhQWFqbk5GS9/fbbVoYEAPBXhg+aF3bt2qUZM2YoNjZWDodDmzdv9gzHMLR8+XLFxMQoJCREKSkpOnz48BWvu3r1avXv31/BwcFKSkrSBx984F1gsjj59+3bV08++aT279+vwsJC3XrrrZo5c6Y++ugjK8MCAMC06upqJSYmavXq1Y1+/8tf/lLPP/+81qxZo/fff1/dunXTtGnTdOHChSavuXHjRmVlZWnFihU6cOCAEhMTNW3aNJ0+fdqr2CxN/jNmzNC3vvUtDRo0SIMHD9a///u/q3v37tq7d6+VYQEA/JBD9fP+rWpe3i81NVWPP/64Zs+e3eA7wzD07LPP6uGHH9bMmTM1fPhw/e53v9PJkycbVAgu9/TTT+vuu+/WwoULNXToUK1Zs0ZXXXWVXn75Za9ia9GCvzvuuOPKFwoKUnR0tG677TbNmDHDqyAkqba2Vq+//rqqq6uVnJzc6Dk1NTWqqalxf66srPT6PgAAmPHN3ON0OuV0Or26RnFxscrKypSSkuI+Fh4erqSkJO3Zs0c/+MEPGvS5ePGi9u/fr2XLlrmPBQQEKCUlRXv27PHq/i0a+YeHh1+xhYSE6PDhw5o7d66WL1/e4gA+/PBDde/eXU6nUz/+8Y+1adMmDR06tNFzs7OzPe4ZFxfX4vsAAGyu7lE/M01SXFycRy7Kzs72OpSysjJJUlRUlMfxqKgo93ffdObMGdXW1nrVpyktGvmvXbu2xRfcunWr/uVf/kWPPvpoi84fMmSIioqKVFFRoT/+8Y9KT09XQUFBo38ALFu2TFlZWe7PlZWV/AEAAGgZH+3wV1paqrCwMPdhb0f9HYHPn/OfMGGCRo8e3eLzu3btqmuvvVaSNGrUKO3bt0/PPfecXnjhhQbntqa0AgCAL9U9oWZGdHS0JKm8vFwxMTHu4+Xl5RoxYkSjffr06aPAwECVl5d7HC8vL3dfr6V8vuCvR48e+tOf/tTq/i6Xy2NeHwAAn2jnR/2aM2DAAEVHR2vnzp3uY5WVlXr//febXPfWtWtXjRo1yqOPy+XSzp07m+zTFEt3+Fu2bJlSU1PVr18/nT9/XuvXr1d+fr62bdtmZVgAAD/U3jv8VVVV6ciRI+7PxcXFKioqUq9evdSvXz8tXbpUjz/+uAYNGqQBAwbo5z//uWJjYzVr1ix3nylTpmj27NnKzMyUJGVlZSk9PV2jR4/W2LFj9eyzz6q6uloLFy70KjZLk//p06c1f/58nTp1SuHh4Ro+fLi2bdum2267zcqwAAAwrbCwUJMnT3Z/rluzlp6ertzcXD344IOqrq7WD3/4Q507d04TJkxQXl6egoOD3X2OHj2qM2fOuD/PnTtXn332mZYvX66ysjKNGDFCeXl5DRYBXonDMIxOu1txZWWlwsPDNUkzFeToYnU4PvPpQ+OsDsHnvoh2WR2CTwVENb0JR2c1MOrMlU/qZMb0Pm51CD63b0Sg1SH41JfGJeVriyoqKkzPozelLlf0f/zfFXBZYvWW68IFHXv439o01vbCi30AAPbgo9X+/oAX+wAAYDOM/AEAtsArfeuR/AEA9nDZLn2t7u8nSP4AAHtgzt+NOX8AAGyGkT8AwBaY869H8gcA2ANlfzfK/gAA2AwjfwCAPZgs+/vTyJ/kDwCwB8r+bpT9AQCwGUb+AAB7YOTvRvIHANgCj/rVo+wPAIDNkPwBALAZyv4AAHtgzt+N5A8AsAXm/OtR9gcAwGYY+QMA7MOPRu9mkPw7oG4n/fF/nf5VZPpCwVaH4HOfqI/VIaBFTlgdQOfFnL+bf/0XGQAAXBEjfwCALbDgrx7JHwBgD5T93Sj7AwBgM4z8AQC2QNm/HskfAGAPlP3dKPsDAGAzjPwBAPbAyN+N5A8AsAXm/OuR/AEA9sDI3405fwAAbIaRPwDAHhj5u5H8AQC2wJx/Pcr+AADYDMkfAGAPhg+aF/r37y+Hw9GgZWRkNHp+bm5ug3ODg9vm9eGU/QEAttDeZf99+/aptrbW/fngwYO67bbbNGfOnCb7hIWF6dChQ/X3dDi8jrMlSP4AALSBiIgIj89PPvmkrrnmGk2cOLHJPg6HQ9HR0W0dGmV/AIBN+KjsX1lZ6dFqamqueOuLFy/q97//vRYtWtTsaL6qqkrx8fGKi4vTzJkz9dFHH7X21zaL5A8AsAcfJf+4uDiFh4e7W3Z29hVvvXnzZp07d04LFixo8pwhQ4bo5Zdf1pYtW/T73/9eLpdL48aN04kTJ1r5g5tG2R8AAC+UlpYqLCzM/dnpdF6xz29/+1ulpqYqNja2yXOSk5OVnJzs/jxu3Dhdd911euGFF/TYY4+ZC/obLB35Z2dna8yYMQoNDVVkZKRmzZrlsdABAABfcfigSV8tyru8XSn5Hz9+XDt27NBdd93lVbxdunTRyJEjdeTIEa/6tYSlyb+goEAZGRnau3evtm/frkuXLmnq1Kmqrq62MiwAgD9q50f96qxdu1aRkZGaPn26V/1qa2v14YcfKiYmpnU3boalZf+8vDyPz7m5uYqMjNT+/ft1yy23WBQVAMAfWbHDn8vl0tq1a5Wenq6gIM+UO3/+fF199dXuNQOPPvqobrrpJl177bU6d+6cnnrqKR0/ftzrikFLdKg5/4qKCklSr169LI4EAADzduzYoZKSEi1atKjBdyUlJQoIqC/Af/7557r77rtVVlamnj17atSoUdq9e7eGDh3q87g6TPJ3uVxaunSpxo8fr2HDhjV6Tk1NjccjFZWVle0VHgCgs7PgxT5Tp06VYTTeMT8/3+PzM888o2eeeaYVgXmvwzzql5GRoYMHD2rDhg1NnpOdne3xeEVcXFw7RggA6PTaeb6/o+oQyT8zM1Nbt27Vu+++q759+zZ53rJly1RRUeFupaWl7RglAAD+wdKyv2EYuvfee7Vp0ybl5+drwIABzZ7vdDpb9DwlAADfxCt961ma/DMyMrR+/Xpt2bJFoaGhKisrkySFh4crJCTEytAAAP7Ggjn/jsrSsn9OTo4qKio0adIkxcTEuNvGjRutDAsAAL9medkfAID2QNm/Xod51A8AgDZF2d+tQ6z2BwAA7YeRPwDAFij71yP5AwDsgbK/G8kfAGAPJH835vwBALAZRv4AAFtgzr8eyR8AYA+U/d0o+wMAYDOM/AEAtuAwDDlM7Cxrpm9HQ/IHANgDZX83yv4AANgMI38AgC2w2r8eyR8AYA+U/d0o+wMAYDOM/AEAtkDZvx7JHwBgD5T93Uj+AABbYORfjzl/AABshpE/AMAeKPu7kfw7oO6fXrQ6hDbQ1eoAfMz/imZfKNjqEHzuE/WxOgSfG6gTVofQqflT6d4M//svGAAAaBYjfwCAPRjGV81Mfz9B8gcA2AKr/etR9gcAwGYY+QMA7IHV/m4kfwCALThcXzUz/f0FZX8AAGyGkT8AwB4o+7sx8gcA2ELdan8zzRsrV66Uw+HwaAkJCc32ef3115WQkKDg4GDdcMMNeuutt0z84qaR/AEA9lD3nL+Z5qXrr79ep06dcrf33nuvyXN3796ttLQ0LV68WH/96181a9YszZo1SwcPHjTzqxtF8gcAoI0EBQUpOjra3fr0aXrL6eeee0633367fvKTn+i6667TY489phtvvFGrVq3yeVwkfwCALfiq7F9ZWenRampqmrzn4cOHFRsbq4EDB2revHkqKSlp8tw9e/YoJSXF49i0adO0Z88en/z+y5H8AQD2YPigSYqLi1N4eLi7ZWdnN3q7pKQk5ebmKi8vTzk5OSouLtbNN9+s8+fPN3p+WVmZoqKiPI5FRUWprKzM1M9uDKv9AQDwQmlpqcLCwtyfnU5no+elpqa6/3n48OFKSkpSfHy8XnvtNS1evLjN42wOyR8AYAu+2ts/LCzMI/m3VI8ePTR48GAdOXKk0e+jo6NVXl7ucay8vFzR0dFe3+tKKPsDAOzBgtX+l6uqqtLRo0cVExPT6PfJycnauXOnx7Ht27crOTnZ1H0bQ/IHAKANPPDAAyooKNCxY8e0e/duzZ49W4GBgUpLS5MkzZ8/X8uWLXOfv2TJEuXl5elXv/qVPv74Y61cuVKFhYXKzMz0eWyU/QEAttDer/Q9ceKE0tLSdPbsWUVERGjChAnau3evIiIiJEklJSUKCKgfg48bN07r16/Xww8/rJ/97GcaNGiQNm/erGHDhrU+6CaQ/AEA9tDO2/tu2LCh2e/z8/MbHJszZ47mzJnj3Y1agbI/AAA2w8gfAGAL7V3278gsHfnv2rVLM2bMUGxsrBwOhzZv3mxlOAAAf+YyzDc/YWnyr66uVmJiolavXm1lGAAAO/DRDn/+wNKyf2pqqscOSAAAoO0x5w8AsAWHTM75+ywS63Wq5F9TU+Px9qTKykoLowEAdCpmd+kzucNfR9KpHvXLzs72eJNSXFyc1SEBANDpdKrkv2zZMlVUVLhbaWmp1SEBADqJukf9zDR/0anK/k6ns8lXJwIA0Kx23uGvI7M0+VdVVXm82rC4uFhFRUXq1auX+vXrZ2FkAAD4L0uTf2FhoSZPnuz+nJWVJUlKT09Xbm6uRVEBAPyRwzDkMLFoz0zfjsbS5D9p0iQZfvQvEwDQgbm+bmb6+4lOteAPAACY16kW/AEA0FqU/euR/AEA9sBqfzeSPwDAHtjhz405fwAAbIaRPwDAFszu0scOfwAAdDaU/d0o+wMAYDOM/AEAtuBwfdXM9PcXJH8AgD1Q9nej7A8AgM0w8gcA2AOb/LiR/AEAtsD2vvUo+wMAYDOM/AEA9sCCPzeSPwDAHgxJZh7X85/cT/IHANgDc/71mPMHAMBmGPkDAOzBkMk5f59FYjmSPwDAHljw50by74CC3tlvdQg+18PqAHysh9UBAIAJJH8AgD24JDlM9vcTLPgDANhC3Wp/M80b2dnZGjNmjEJDQxUZGalZs2bp0KFDzfbJzc2Vw+HwaMHBwWZ+dqNI/gAAtIGCggJlZGRo79692r59uy5duqSpU6equrq62X5hYWE6deqUux0/ftznsVH2BwDYQzsv+MvLy/P4nJubq8jISO3fv1+33HJLk/0cDoeio6NbFWJLMfIHANhDXfI300yoqKiQJPXq1avZ86qqqhQfH6+4uDjNnDlTH330kan7NobkDwCAFyorKz1aTU3NFfu4XC4tXbpU48eP17Bhw5o8b8iQIXr55Ze1ZcsW/f73v5fL5dK4ceN04sQJX/4Ekj8AwCZ8NPKPi4tTeHi4u2VnZ1/x1hkZGTp48KA2bNjQ7HnJycmaP3++RowYoYkTJ+pPf/qTIiIi9MILL/jkX0Ed5vwBAPbgo0f9SktLFRYW5j7sdDqb7ZaZmamtW7dq165d6tu3r1e37NKli0aOHKkjR454HW5zSP4AAFvw1Yt9wsLCPJJ/UwzD0L333qtNmzYpPz9fAwYM8PqetbW1+vDDD/Wtb33L677NIfkDANAGMjIytH79em3ZskWhoaEqKyuTJIWHhyskJESSNH/+fF199dXuqYNHH31UN910k6699lqdO3dOTz31lI4fP6677rrLp7GR/AEA9tDOj/rl5ORIkiZNmuRxfO3atVqwYIEkqaSkRAEB9cvvPv/8c919990qKytTz549NWrUKO3evVtDhw5tfdyNIPkDAOzBZUgOE8nf5V1fowV/LOTn53t8fuaZZ/TMM894dZ/WYLU/AAA2w8gfAGAPvNLXjeQPALAJs7v0+U/yp+wPAIDNMPIHANgDZX83kj8AwB5chkyV7r1c7d+RUfYHAMBmGPkDAOzBcH3VzPT3EyR/AIA9MOfv1iHK/qtXr1b//v0VHByspKQkffDBB1aHBADwNy7DfPMTlif/jRs3KisrSytWrNCBAweUmJioadOm6fTp01aHBgCAX7I8+T/99NO6++67tXDhQg0dOlRr1qzRVVddpZdfftnq0AAA/qSu7G+m+QlLk//Fixe1f/9+paSkuI8FBAQoJSVFe/bsaXB+TU2NKisrPRoAAC1iyGTyt/oH+I6lyf/MmTOqra1VVFSUx/GoqCj3e48vl52drfDwcHeLi4trr1ABAPAblpf9vbFs2TJVVFS4W2lpqdUhAQA6C8r+bpY+6tenTx8FBgaqvLzc43h5ebmio6MbnO90OuV0OtsrPACAP3G5JJl4Vt/lP8/5Wzry79q1q0aNGqWdO3e6j7lcLu3cuVPJyckWRgYAgP+yfJOfrKwspaena/To0Ro7dqyeffZZVVdXa+HChVaHBgDwJ2zy42Z58p87d64+++wzLV++XGVlZRoxYoTy8vIaLAIEAMAUkr+b5clfkjIzM5WZmWl1GAAA2EKHSP4AALQ5XunrRvIHANiCYbhkmHgzn5m+HQ3JHwBgD4bJl/P40Zx/p9rkBwAAmMfIHwBgD4bJOX8/GvmT/AEA9uBySQ4T8/Z+NOdP2R8AAJth5A8AsAfK/m4kfwCALRgulwwTZX9/etSPsj8AADbDyB8AYA+U/d1I/gAAe3AZkoPkL1H2BwDAdhj5AwDswTAkmXnO339G/iR/AIAtGC5Dhomyv+FHyZ+yPwDAHgyX+dYKq1evVv/+/RUcHKykpCR98MEHzZ7/+uuvKyEhQcHBwbrhhhv01ltvteq+zSH5AwDQRjZu3KisrCytWLFCBw4cUGJioqZNm6bTp083ev7u3buVlpamxYsX669//atmzZqlWbNm6eDBgz6Ny2F04jpGZWWlwsPDNUkzFeToYnU4AAAvfWlcUr62qKKiQmFhYW1yD3eucMw2lSu+NC4p39jkVaxJSUkaM2aMVq1aJUlyuVyKi4vTvffeq5/+9KcNzp87d66qq6u1detW97GbbrpJI0aM0Jo1a1od+zcx8gcA2EM7l/0vXryo/fv3KyUlxX0sICBAKSkp2rNnT6N99uzZ43G+JE2bNq3J81urUy/4qytafKlLpvZtAABY40tdktQ+i+nM5oq6WCsrKz2OO51OOZ3OBuefOXNGtbW1ioqK8jgeFRWljz/+uNF7lJWVNXp+WVlZ6wNvRKdO/ufPn5ckvSffL4YAALSf8+fPKzw8vE2u3bVrV0VHR+u9MvO5onv37oqLi/M4tmLFCq1cudL0tdtTp07+sbGxKi0tVWhoqBwOR5veq7KyUnFxcSotLW2zean25G+/R+I3dRb8po6vPX+PYRg6f/68YmNj2+wewcHBKi4u1sWLF01fyzCMBvmmsVG/JPXp00eBgYEqLy/3OF5eXq7o6OhG+0RHR3t1fmt16uQfEBCgvn37tus9w8LC/OL/3HX87fdI/KbOgt/U8bXX72mrEf/lgoODFRwc3Ob3uVzXrl01atQo7dy5U7NmzZL01YK/nTt3KjMzs9E+ycnJ2rlzp5YuXeo+tn37diUnJ/s0tk6d/AEA6MiysrKUnp6u0aNHa+zYsXr22WdVXV2thQsXSpLmz5+vq6++WtnZ2ZKkJUuWaOLEifrVr36l6dOna8OGDSosLNSLL77o07hI/gAAtJG5c+fqs88+0/Lly1VWVqYRI0YoLy/PvaivpKREAQH1D96NGzdO69ev18MPP6yf/exnGjRokDZv3qxhw4b5NC6Sfws5nU6tWLGiybmdzsbffo/Eb+os+E0dn7/9HqtlZmY2WebPz89vcGzOnDmaM2dOm8bUqTf5AQAA3mOTHwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/JvAW/fxdyR7dq1SzNmzFBsbKwcDoc2b95sdUimZWdna8yYMQoNDVVkZKRmzZqlQ4cOWR2WKTk5ORo+fLh7k5Xk5GS9/fbbVoflM08++aQcDofHRiadzcqVK+VwODxaQkKC1WGZ9umnn+rOO+9U7969FRISohtuuEGFhYVWhwUfI/lfgbfvYu7oqqurlZiYqNWrV1sdis8UFBQoIyNDe/fu1fbt23Xp0iVNnTpV1dXVVofWan379tWTTz6p/fv3q7CwULfeeqtmzpypjz76yOrQTNu3b59eeOEFDR8+3OpQTLv++ut16tQpd3vvvfesDsmUzz//XOPHj1eXLl309ttv6//+7//0q1/9Sj179rQ6NPiagWaNHTvWyMjIcH+ura01YmNjjezsbAuj8g1JxqZNm6wOw+dOnz5tSDIKCgqsDsWnevbsafznf/6n1WGYcv78eWPQoEHG9u3bjYkTJxpLliyxOqRWW7FihZGYmGh1GD710EMPGRMmTLA6DLQDRv7NaM27mGG9iooKSVKvXr0sjsQ3amtrtWHDBlVXV/t8f+/2lpGRoenTpzd4X3lndfjwYcXGxmrgwIGaN2+eSkpKrA7JlDfeeEOjR4/WnDlzFBkZqZEjR+qll16yOiy0AZJ/M5p7F7Ov360M33C5XFq6dKnGjx/v8+0w29uHH36o7t27y+l06sc//rE2bdqkoUOHWh1Wq23YsEEHDhxw72He2SUlJSk3N1d5eXnKyclRcXGxbr75ZverxjujTz75RDk5ORo0aJC2bdume+65R/fdd5/WrVtndWjwMbb3hV/JyMjQwYMHO/3cqyQNGTJERUVFqqio0B//+Eelp6eroKCgU/4BUFpaqiVLlmj79u3t/ma1tpKamur+5+HDhyspKUnx8fF67bXXtHjxYgsjaz2Xy6XRo0friSeekCSNHDlSBw8e1Jo1a5Senm5xdPAlRv7NaM27mGGdzMxMbd26Ve+++267v+q5LXTt2lXXXnutRo0apezsbCUmJuq5556zOqxW2b9/v06fPq0bb7xRQUFBCgoKUkFBgZ5//nkFBQWptrbW6hBN69GjhwYPHqwjR45YHUqrxcTENPjj8rrrruv00xloiOTfjMvfxVyn7l3MnX3u1Z8YhqHMzExt2rRJ77zzjgYMGGB1SG3C5XKppqbG6jBaZcqUKfrwww9VVFTkbqNHj9a8efNUVFSkwMBAq0M0raqqSkePHlVMTIzVobTa+PHjGzwm+/e//13x8fEWRYS2Qtn/Cq70LubOpqqqymNkUlxcrKKiIvXq1Uv9+vWzMLLWy8jI0Pr167VlyxaFhoa612OEh4crJCTE4uhaZ9myZUpNTVW/fv10/vx5rV+/Xvn5+dq2bZvVobVKaGhogzUY3bp1U+/evTvt2owHHnhAM2bMUHx8vE6ePKkVK1YoMDBQaWlpVofWavfff7/GjRunJ554Qt///vf1wQcf6MUXX/T5u+TRAVj9uEFn8Otf/9ro16+f0bVrV2Ps2LHG3r17rQ6p1d59911DUoOWnp5udWit1tjvkWSsXbvW6tBabdGiRUZ8fLzRtWtXIyIiwpgyZYrx3//931aH5VOd/VG/uXPnGjExMUbXrl2Nq6++2pg7d65x5MgRq8My7c9//rMxbNgww+l0GgkJCcaLL75odUhoA7zSFwAAm2HOHwAAmyH5AwBgMyR/AABshuQPAIDNkPwBALAZkj8AADZD8gcAwGZI/gAA2AzJH+jAFixYoFmzZlkdBgA/Q/IHAMBmSP4AANgMyR8AAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/IHAMBmHIZhGFYHAQAA2g8jfwAAbIbkDwCAzZD8AQCwGZI/AAA2Q/IHAMBmSP4AANgMyR8AAJsh+QMAYDMkfwAAbIbkDwCAzZD8AQCwGZI/AAA28/8BdMJM42GGXEkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -791,13 +739,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Plotting values of qty_in at K = 2\n", - "Min and max values: 40.0 0.0\n" + "Plotting values of qty_out at K = 1\n", + "Min and max values: 12.0 0.0\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAHHCAYAAABEJtrOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxc0lEQVR4nO3dfXBUZZr//09DSAdIOpBAnoYQURBEDKMBMaKAEIEMMqKUgwhrQEZHN6CQtaCy65cnR4O7tQquMaDLgFpkUFkRRSGLaMIyEoUwrKAOAjJDFBIcVxKIEjB9fn8o/aMFoTunk9Onz/tVdVfRp8/D1VXixXWd+9zHZRiGIQAAYEttrA4AAAA0H4kcAAAbI5EDAGBjJHIAAGyMRA4AgI2RyAEAsDESOQAANkYiBwDAxkjkAADYGIkcjlZeXi6Xy6Xy8nKrQwGAZiGRIyKtXLlSLpfLN2JiYnT55Zdr+vTpqq2tDck13n77bc2fPz8k5zpbaWmpFi9eHPD+l1xyiW655ZZztr/00ktq27atRo8erZMnT4Ywwp/32muvacKECbr00kvVoUMH9e7dW//0T/+kY8eOtcr1AScikSOiLVy4UC+99JKeeeYZXX/99SopKVF2dra+/fZb0+d+++23tWDBghBE6S/YRH4+q1at0pQpU5STk6PXX39dMTExoQnuIu677z59+umnmjx5sp5++mmNHj1azzzzjLKzs/Xdd9+1SgyA00RZHQDQknJzczVgwABJ0m9/+1slJibqySef1Lp16zRx4kSLo2sZq1evVl5enoYPH65169a1WhKXpDVr1mjYsGF+27KyspSXl6dVq1bpt7/9bavFAjgFFTkcZfjw4ZKkgwcPXnC/V199VVlZWWrfvr26dOmiyZMn68svv/R9P2XKFBUXF0uSXwv/QtatW6cxY8YoLS1Nbrdbl112mR599FE1NTX59hk2bJjeeust/e1vf/Od85JLLgn4973yyiuaPHmyhg0bpjfeeKNVk7ikc5K4JN12222SpE8//bRVYwGcgoocjnLgwAFJUmJi4s/us3LlSk2dOlUDBw5UUVGRamtrtWTJEv3pT3/Sn//8Z3Xq1Em/+93vdPjwYW3atEkvvfRSQNdeuXKlYmNjVVBQoNjYWL377ruaO3eu6uvr9W//9m+SpH/5l39RXV2dvvjiCz311FOSpNjY2IDO/1//9V+aNGmShgwZojfffFPt27cP6LgTJ04EdA+9Xbt2io+PD+icZ6upqZEkdenSJehjAQTAACLQihUrDEnGO++8Y3z11VdGdXW1sXr1aiMxMdFo37698cUXXxiGYRjvvfeeIcl47733DMMwjFOnThlJSUlGv379jO+++853vvXr1xuSjLlz5/q25efnG8H8Ffr222/P2fa73/3O6NChg3Hy5EnftjFjxhgZGRkBnzcjI8NIS0szoqKijGHDhhkNDQ0BH2sYhpGXl2dIuugYOnRoUOc9Y9q0aUbbtm2Nzz77rFnHA7gwKnJEtJycHL/PGRkZWrVqlX7xi1+cd/8dO3bo6NGjmj9/vl9besyYMerTp4/eeuutZk9wO7tCPn78uBobG3XjjTdq2bJl+stf/qL+/fs367yS9H//93/6/vvv1a1bt4Ar8TNmz56tyZMnX3S/zp07Bx1XaWmpli9frtmzZ6tXr15BHw/g4kjkiGjFxcW6/PLLFRUVpeTkZPXu3Vtt2vz81JC//e1vkqTevXuf812fPn20devWZsfy8ccf65FHHtG7776r+vp6v+/q6uqafV5JGjFihLp3766SkhIlJCRoyZIlAR/bt29f9e3b19T1z+d//ud/NG3aNI0aNUqPPfZYyM8P4AckckS0a6+91jdr3UrHjh3T0KFD5fF4tHDhQl122WWKiYnRzp07NWfOHHm9XtPXeOaZZ/TNN9/o6aefVufOnQN+xr2uri6gR8Oio6OVkJAQ0Dn/93//V7/+9a/Vr18/rVmzRlFR/K8GaCn87QLOkpGRIUnau3evb4b7GXv37vV9L+mis9TPVl5erq+//lqvvfaahgwZ4tt+vtnzwZz3bG3atNGLL76ouro6LViwQAkJCXrwwQcvetxDDz2kF1544aL7DR06NKAV8A4cOKDRo0crKSlJb7/9dsCT9QA0D4kcOMuAAQOUlJSkpUuX6p577pHb7ZYkbdiwQZ9++qnmzp3r27djx46Sfqi2O3XqdMHztm3bVpJkGIZv26lTp/Tss8+es2/Hjh2b3Wpv166d1qxZo5EjR2rmzJnq3Lmz/uEf/uGCx4TyHnlNTY1GjhypNm3aqKysTF27dg04dgDNQyIHztKuXTs98cQTmjp1qoYOHaqJEyf6Hj+75JJLNGvWLN++WVlZkqQHH3xQo0aNUtu2bXXnnXee97zXX3+9OnfurLy8PD344INyuVx66aWX/BL72ed9+eWXVVBQoIEDByo2NlZjx44N+Dd06NBBb731loYOHap77rlH8fHx+vWvf/2z+4fyHvno0aP1+eefa/bs2dq6davfnILk5GTdfPPNIbkOgLNYPW0eaAlnHj/bvn37Bff76eNnZ7z88svG1VdfbbjdbiMhIcGYNGmS75G1M77//ntjxowZRteuXQ2Xy3XRR9H+9Kc/Gdddd53Rvn17Iy0tzZg9e7ZRVlZ2zvVPnDhh3HXXXUanTp0MSRd9FC0jI8MYM2bMOdtramqMnj17GjExMef8vpaiFnh8DcCFuQzjPCUBAACwBZZoBQDAxkjkAADYGIkcAAAbI5EDANDCFi1aJJfLpZkzZ/q2nTx5Uvn5+UpMTFRsbKzGjx+v2traoM9NIgcAoAVt375dy5YtU2Zmpt/2WbNm6c0339Srr76qiooKHT58WLfffnvQ5yeRAwDQQk6cOKFJkybp+eef91tUqa6uTsuXL9eTTz6p4cOHKysrSytWrND777+vysrKoK5h6wVhvF6vDh8+rLi4uGYvawkAsI5hGDp+/LjS0tIu+EIjs06ePKlTp06ZPo9hGOfkG7fb7VsF8qfy8/M1ZswY5eTk6Pe//71ve1VVlU6fPu33hsY+ffqoe/fu2rZtm6677rqAY7J1Ij98+LDS09OtDgMAYFJ1dbW6devWIuc+efKkemTEquZok+lzxcbG6sSJE37b5s2bd96XFK1evVo7d+7U9u3bz/mupqZG0dHR5yzvnJycrJqamqBisnUij4uLkyTdoF8pSu0sjgYAEKzvdVpb9bbv/+ct4dSpU6o52qS/VV0iT1zzq/76415lZP1V1dXV8ng8vu3nq8arq6v10EMPadOmTYqJiWn2NQNh60R+pr0RpXaKcpHIAcB2flxbtDVuj8bGuRQb1/zrePXDsR6Pxy+Rn09VVZWOHj2qa665xretqalJW7Zs0TPPPKOysjKdOnXqnJcu1dbWKiUlJai4bJ3IAQAIVJPhVZOJRcmbDG/A+44YMUK7d+/22zZ16lT16dNHc+bMUXp6utq1a6fNmzdr/Pjxkn54VfKhQ4eUnZ0dVFwkcgCAI3hlyKvmZ/Jgjo2Li1O/fv38tnXs2FGJiYm+7dOmTVNBQYESEhLk8Xg0Y8YMZWdnBzXRTSKRAwBgiaeeekpt2rTR+PHj1djYqFGjRunZZ58N+jwkcgCAI3jlVeDN8fMfb0Z5ebnf55iYGBUXF6u4uNjUeUnkAABHaDIMNZl4c7eZY1sSK7sBAGBjVOQAAEdozclurYlEDgBwBK8MNUVgIqe1DgCAjVGRAwAcgdY6AAA2xqx1AAAQdqjIAQCO4P1xmDk+HJHIAQCO0GRy1rqZY1sSiRwA4AhNhky+/Sx0sYQS98gBALAxKnIAgCNwjxwAABvzyqUmuUwdH45orQMAYGOWJ/Ivv/xSkydPVmJiotq3b6+rrrpKO3bssDosAECE8RrmRziytLX+zTffaPDgwbrpppu0YcMGde3aVfv27VPnzp2tDAsAEIGaTLbWzRzbkixN5E888YTS09O1YsUK37YePXpYGBEAAPZiaWv9jTfe0IABA3THHXcoKSlJV199tZ5//nkrQwIARKgzFbmZEY4sTeSff/65SkpK1KtXL5WVlemBBx7Qgw8+qBdeeOG8+zc2Nqq+vt5vAAAQCK/hMj3CkaWtda/XqwEDBujxxx+XJF199dXas2ePli5dqry8vHP2Lyoq0oIFC1o7TAAAwpalFXlqaqr69u3rt+2KK67QoUOHzrt/YWGh6urqfKO6uro1wgQARIBIba1bWpEPHjxYe/fu9dv22WefKSMj47z7u91uud3u1ggNABBhmtRGTSbq16YQxhJKlibyWbNm6frrr9fjjz+u3/zmN/rwww/13HPP6bnnnrMyLABABDJM3uc2wvQeuaWt9YEDB2rt2rX64x//qH79+unRRx/V4sWLNWnSJCvDAgDANixfa/2WW27RLbfcYnUYAIAIx4IwAADYWJPRRk2GiXvkYbpEq+VrrQMAgOajIgcAOIJXLnlN1K9ehWdJTiIHADhCpN4jp7UOAICNUZEDABzB/GQ3WusAAFjmh3vkzW+Pmzm2JdFaBwDAxqjIAQCO4DW51nq4zlqnIgcAOMKZe+RmRjBKSkqUmZkpj8cjj8ej7Oxsbdiwwff9sGHD5HK5/Mb9998f9O+iIgcAOIJXbVr1OfJu3bpp0aJF6tWrlwzD0AsvvKBbb71Vf/7zn3XllVdKku69914tXLjQd0yHDh2CjotEDgBACxg7dqzf58cee0wlJSWqrKz0JfIOHTooJSXF1HVorQMAHKHJcJkeklRfX+83GhsbL37tpiatXr1aDQ0Nys7O9m1ftWqVunTpon79+qmwsFDffvtt0L+LihwA4AhNJie7Nf3YWk9PT/fbPm/ePM2fP/+8x+zevVvZ2dk6efKkYmNjtXbtWvXt21eSdNdddykjI0NpaWn66KOPNGfOHO3du1evvfZaUHGRyAEACEJ1dbU8Ho/vs9vt/tl9e/furV27dqmurk5r1qxRXl6eKioq1LdvX913332+/a666iqlpqZqxIgROnDggC677LKA4yGRAwAcwWu0kdfEym7eH1d2OzMLPRDR0dHq2bOnJCkrK0vbt2/XkiVLtGzZsnP2HTRokCRp//79JHIAAH4qVK11M7xe78/eU9+1a5ckKTU1NahzksgBAGgBhYWFys3NVffu3XX8+HGVlpaqvLxcZWVlOnDggEpLS/WrX/1KiYmJ+uijjzRr1iwNGTJEmZmZQV2HRA4AcASv5Jt53tzjg3H06FHdfffdOnLkiOLj45WZmamysjLdfPPNqq6u1jvvvKPFixeroaFB6enpGj9+vB555JGg4yKRAwAcwfyCMMEdu3z58p/9Lj09XRUVFc2O5Wwk8jD0eekvrQ4h5C5N/rvVIYTUwMS/WR1CyOXEfWx1CCE3rH2wNVT4G5X2S6tDQJghkQMAHMH8+8jDcw01EjkAwBEi9X3kJHIAgCNEakUenlEBAICAUJEDABzB/IIw4Vn7ksgBAI7gNVzymnmO3MSxLSk8/3kBAAACQkUOAHAEr8nWupnFZFoSiRwA4Ajm334Wnok8PKMCAAABoSIHADhCk1xqMrGoi5ljWxKJHADgCLTWAQBA2KEiBwA4QpPMtcebQhdKSJHIAQCOEKmtdRI5AMAReGkKAAAIO1TkAABHMEy+j9zg8TMAAKxDax0AAIQdKnIAgCPwGtMWMH/+fLlcLr/Rp08fK0MCAESoph/ffmZmhCPLK/Irr7xS77zzju9zVJTlIQEAYBuWZ82oqCilpKRYHQYAIMLRWm8h+/btU1pami699FJNmjRJhw4d+tl9GxsbVV9f7zcAAAiEV21Mj3BkaVSDBg3SypUrtXHjRpWUlOjgwYO68cYbdfz48fPuX1RUpPj4eN9IT09v5YgBAAgvlrbWc3NzfX/OzMzUoEGDlJGRoVdeeUXTpk07Z//CwkIVFBT4PtfX15PMAQABaTJcajLRHjdzbEuy/B752Tp16qTLL79c+/fvP+/3brdbbre7laMCAEQC7pG3ghMnTujAgQNKTU21OhQAQIQxfnz7WXOHwcpu53r44YdVUVGhv/71r3r//fd12223qW3btpo4caKVYQEAYBuWtta/+OILTZw4UV9//bW6du2qG264QZWVleratauVYQEAIlCTXGoy8eITM8e2JEsT+erVq628PADAQbyGufvcXiOEwYRQeDb8AQBAQMJq1joAAC3lzKQ1M8eHo/CMCgCAEPPKZXoEo6SkRJmZmfJ4PPJ4PMrOztaGDRt83588eVL5+flKTExUbGysxo8fr9ra2qB/F4kcAIAW0K1bNy1atEhVVVXasWOHhg8frltvvVUff/yxJGnWrFl688039eqrr6qiokKHDx/W7bffHvR1aK0DAByhtVd2Gzt2rN/nxx57TCUlJaqsrFS3bt20fPlylZaWavjw4ZKkFStW6IorrlBlZaWuu+66gK9DRQ4AcAQzi8GYvb/e1NSk1atXq6GhQdnZ2aqqqtLp06eVk5Pj26dPnz7q3r27tm3bFtS5qcgBAAjCT9+8eaHlw3fv3q3s7GydPHlSsbGxWrt2rfr27atdu3YpOjpanTp18ts/OTlZNTU1QcVDRQ4AcASvXL711ps1fpzslp6e7vcmzqKiop+9Zu/evbVr1y598MEHeuCBB5SXl6dPPvkkpL+LihwA4AhGM2ae//R4SaqurpbH4/Ftv9DLvKKjo9WzZ09JUlZWlrZv364lS5ZowoQJOnXqlI4dO+ZXldfW1iolJSWouKjIAQCOYKoaP+vNaWceJzszgnkrp9frVWNjo7KystSuXTtt3rzZ993evXt16NAhZWdnB/W7qMgBAGgBhYWFys3NVffu3XX8+HGVlpaqvLxcZWVlio+P17Rp01RQUKCEhAR5PB7NmDFD2dnZQc1Yl0jkAACHaO2V3Y4ePaq7775bR44cUXx8vDIzM1VWVqabb75ZkvTUU0+pTZs2Gj9+vBobGzVq1Cg9++yzQcdFIgcAOMLZ7fHmHh+M5cuXX/D7mJgYFRcXq7i4uNkxSdwjBwDA1qjIAQCO0Jz10n96fDgikQMAHKG1W+uthdY6AAA2RkUOAHCESK3ISeQAAEeI1EROax0AABujIg9D3toYq0MIuc/VxeoQ4EgfWx0AwkikVuQkcgCAIxgy9wiZEbpQQopEDgBwhEityLlHDgCAjVGRAwAcIVIrchI5AMARIjWR01oHAMDGqMgBAI4QqRU5iRwA4AiG4ZJhIhmbObYl0VoHAMDGqMgBAI7A+8gBALCxSL1HTmsdAAAboyIHADhCpE52I5EDABwhUlvrJHIAgCNEakXOPXIAAGyMihwA4AiGydZ6uFbkJHIAgCMYkgzD3PHhiNY6AAA2RkUOAHAEr1xysbIbAAD2xKz1FrZo0SK5XC7NnDnT6lAAALCNsKjIt2/frmXLlikzM9PqUAAAEcpruOSKwAVhLK/IT5w4oUmTJun5559X586drQ4HABChDMP8CEeWJ/L8/HyNGTNGOTk5F923sbFR9fX1fgMAACeztLW+evVq7dy5U9u3bw9o/6KiIi1YsKCFowIARCImu4VYdXW1HnroIa1atUoxMTEBHVNYWKi6ujrfqK6ubuEoAQCR4kwiNzPCkWWJvKqqSkePHtU111yjqKgoRUVFqaKiQk8//bSioqLU1NR0zjFut1sej8dvAAAQiDNvPzMzglFUVKSBAwcqLi5OSUlJGjdunPbu3eu3z7Bhw+RyufzG/fffH9R1LGutjxgxQrt37/bbNnXqVPXp00dz5sxR27ZtLYoMAADzKioqlJ+fr4EDB+r777/XP//zP2vkyJH65JNP1LFjR99+9957rxYuXOj73KFDh6CuY1kij4uLU79+/fy2dezYUYmJiedsBwDALLMzz4M9duPGjX6fV65cqaSkJFVVVWnIkCG+7R06dFBKSkqz47J81joAAK3hh0Ru5h65uevX1dVJkhISEvy2r1q1Sl26dFG/fv1UWFiob7/9NqjzhsWCMGeUl5dbHQIAABf000ef3W633G73BY/xer2aOXOmBg8e7Nd1vuuuu5SRkaG0tDR99NFHmjNnjvbu3avXXnst4HjCKpEDANBSQvX4WXp6ut/2efPmaf78+Rc8Nj8/X3v27NHWrVv9tt93332+P1911VVKTU3ViBEjdODAAV122WUBxUUiBwA4giFz7xQ/c2x1dbXfU1MXq8anT5+u9evXa8uWLerWrdsF9x00aJAkaf/+/SRyAABaQqCPPxuGoRkzZmjt2rUqLy9Xjx49LnrMrl27JEmpqakBx0MiBwA4Qmuv7Jafn6/S0lKtW7dOcXFxqqmpkSTFx8erffv2OnDggEpLS/WrX/1KiYmJ+uijjzRr1iwNGTIkqJeIkcgBAM4Qqt56gEpKSiT9sOjL2VasWKEpU6YoOjpa77zzjhYvXqyGhgalp6dr/PjxeuSRR4K6DokcAOAMZpdZDfJY4yLPq6Wnp6uioqL58fyI58gBALAxKnIAgCO09spurYVEDgBwBF5jCgAAwg4VOQDAGQxX0BPWzjk+DJHIAQCOEKn3yGmtAwBgY1TkAABnaOUFYVoLiRwA4AjMWgcAAGGHihwA4Bxh2h43g0QOAHCESG2tk8gBAM4QoZPduEcOAICNUZGHofY1kffvq+8UY3UIIfW5ulgdAoCguX4cZo4PPyRyAIAz0FoHAADhhoocAOAMEVqRk8gBAM4QoW8/o7UOAICNUZEDABwhUl9jSiIHADhDhN4jp7UOAICNUZEDAJwhQie7kcgBAI7gMn4YZo4PRyRyAIAzcI8cAACEGypyAIAzcI8cAAAbo7UOAADCDRU5AMAZIrQiJ5EDAJwhQhM5rXUAAGyMihwA4AzMWgcAwL4idWU3WusAANiYpYm8pKREmZmZ8ng88ng8ys7O1oYNG6wMCQAQqYwQjCAUFRVp4MCBiouLU1JSksaNG6e9e/f67XPy5Enl5+crMTFRsbGxGj9+vGpra4O6jqWJvFu3blq0aJGqqqq0Y8cODR8+XLfeeqs+/vhjK8MCAMC0iooK5efnq7KyUps2bdLp06c1cuRINTQ0+PaZNWuW3nzzTb366quqqKjQ4cOHdfvttwd1HUvvkY8dO9bv82OPPaaSkhJVVlbqyiuvtCgqAEAkcsnkPfIg99+4caPf55UrVyopKUlVVVUaMmSI6urqtHz5cpWWlmr48OGSpBUrVuiKK65QZWWlrrvuuoCuE1AiD+RfB1FRUUpJSdHNN998ToIORFNTk1599VU1NDQoOzv7vPs0NjaqsbHR97m+vj7o6wAAYMZPc4/b7Zbb7b7ocXV1dZKkhIQESVJVVZVOnz6tnJwc3z59+vRR9+7dtW3btoATeUCt9fj4+IuO9u3ba9++fZowYYLmzp0b0MUlaffu3YqNjZXb7db999+vtWvXqm/fvufdt6ioyO+a6enpAV8HAOBwZx4/MzMkpaen++WioqKii17a6/Vq5syZGjx4sPr16ydJqqmpUXR0tDp16uS3b3JysmpqagL+WQFV5CtWrAj4hOvXr9c//uM/auHChQHt37t3b+3atUt1dXVas2aN8vLyVFFRcd5kXlhYqIKCAt/n+vp6kjkAIDAhWtmturpaHo/HtzmQajw/P1979uzR1q1bTQRwfiG/R37DDTdowIABAe8fHR2tnj17SpKysrK0fft2LVmyRMuWLTtn30DbFwAAtJQzT1oFavr06Vq/fr22bNmibt26+banpKTo1KlTOnbsmF9VXltbq5SUlIDPH/JZ6506ddJrr73W7OO9Xq/ffXAAAEKilR8/MwxD06dP19q1a/Xuu++qR48eft9nZWWpXbt22rx5s2/b3r17dejQoZ+dK3Y+ls5aLywsVG5urrp3767jx4+rtLRU5eXlKisrszIsAEAEau2V3fLz81VaWqp169YpLi7Od9/7zLyy+Ph4TZs2TQUFBUpISJDH49GMGTOUnZ0d8EQ3yeJEfvToUd199906cuSI4uPjlZmZqbKyMt18881WhgUAgGklJSWSpGHDhvltX7FihaZMmSJJeuqpp9SmTRuNHz9ejY2NGjVqlJ599tmgrmNpIl++fLmVlwcAOEkrv8bUMC5+QExMjIqLi1VcXNzMoHhpCgDAKXgfOQAACDdU5AAAR4jU15iSyAEAznDW6mzNPj4MkcgBAM7APXIAABBuqMgBAI7APXIAAOyM1joAAAg3VOQAAGcw2VoP14qcRA4AcAZa6wAAINxQkQMAnCFCK3ISOQDAESL18TNa6wAA2BiJHAAAG6O1DgBwBu6RAwBgX9wjBwAAYYeKHADgHGFaVZtBIg9DHQ9H4H9pEdb8+U4xVocQcp+ri9UhICBfWB2AfUXoPfLI+r8rAAAOQ0UOAHCESJ3sRiIHADgDrXUAABBuqMgBAI5Aax0AADujtQ4AAMINFTkAwBkitCInkQMAHIF75AAA2FmEVuTcIwcAwMaoyAEAzhChFTmJHADgCJF6j5zWOgAANkYiBwA4gxGCEYQtW7Zo7NixSktLk8vl0uuvv+73/ZQpU+RyufzG6NGjg/5ZJHIAgCOcaa2bGcFoaGhQ//79VVxc/LP7jB49WkeOHPGNP/7xj0H/Lu6RAwDQAnJzc5Wbm3vBfdxut1JSUkxdh4ocAOAMIWqt19fX+43GxsZmh1ReXq6kpCT17t1bDzzwgL7++uugz0EiBwA4Q4gSeXp6uuLj432jqKioWeGMHj1aL774ojZv3qwnnnhCFRUVys3NVVNTU1DnobUOAEAQqqur5fF4fJ/dbnezznPnnXf6/nzVVVcpMzNTl112mcrLyzVixIiAz2NpRV5UVKSBAwcqLi5OSUlJGjdunPbu3WtlSACACOUKwZAkj8fjN5qbyH/q0ksvVZcuXbR///6gjrM0kVdUVCg/P1+VlZXatGmTTp8+rZEjR6qhocHKsAAAkaiVHz8L1hdffKGvv/5aqampQR1naWt948aNfp9XrlyppKQkVVVVaciQIRZFBQCIRK29stuJEyf8quuDBw9q165dSkhIUEJCghYsWKDx48crJSVFBw4c0OzZs9WzZ0+NGjUqqOuE1T3yuro6SVJCQoLFkQAAYM6OHTt00003+T4XFBRIkvLy8lRSUqKPPvpIL7zwgo4dO6a0tDSNHDlSjz76aNCt+rBJ5F6vVzNnztTgwYPVr1+/8+7T2NjoN82/vr6+tcIDANhdK780ZdiwYTKMnz+orKzMRDD/v7B5/Cw/P1979uzR6tWrf3afoqIivyn/6enprRghAMD2wvT+uBlhkcinT5+u9evX67333lO3bt1+dr/CwkLV1dX5RnV1dStGCQBA+LG0tW4YhmbMmKG1a9eqvLxcPXr0uOD+brc7ZNP8AQDOEqmvMbU0kefn56u0tFTr1q1TXFycampqJEnx8fFq3769laEBACJNK98jby2WttZLSkpUV1enYcOGKTU11TdefvllK8MCAMA2LG+tAwDQGmitAwBgZ7TWAQBAuKEiBwA4Aq11AADsLEJb6yRyAIAzRGgi5x45AAA2RkUOAHAE7pEDAGBntNYBAEC4oSIHADiCyzDkMrGiqJljWxKJHADgDLTWAQBAuKEiBwA4ArPWAQCwM1rrAAAg3FCRAwAcgdY6AAB2FqGtdRI5AMARIrUi5x45AAA2RkUOAHAGWutoLbFfnrI6hBYQbXUAIRZ5zazvFGN1CCH3ubpYHULIXaovrA7B1sK1PW5G5P3fCAAAB6EiBwA4g2H8MMwcH4ZI5AAAR2DWOgAACDtU5AAAZ2DWOgAA9uXy/jDMHB+OaK0DAGBjVOQAAGeI0NY6FTkAwBHOzFo3M4KxZcsWjR07VmlpaXK5XHr99df9vjcMQ3PnzlVqaqrat2+vnJwc7du3L+jfRSIHADjDmefIzYwgNDQ0qH///iouLj7v9//6r/+qp59+WkuXLtUHH3ygjh07atSoUTp58mRQ16G1DgBAC8jNzVVubu55vzMMQ4sXL9YjjzyiW2+9VZL04osvKjk5Wa+//rruvPPOgK9DRQ4AcIRQtdbr6+v9RmNjY9CxHDx4UDU1NcrJyfFti4+P16BBg7Rt27agzkUiBwA4gxGCISk9PV3x8fG+UVRUFHQoNTU1kqTk5GS/7cnJyb7vAkVrHQCAIFRXV8vj8fg+u91uC6OhIgcAOESoWusej8dvNCeRp6SkSJJqa2v9ttfW1vq+CxSJHADgDK08a/1CevTooZSUFG3evNm3rb6+Xh988IGys7ODOhetdQAAWsCJEye0f/9+3+eDBw9q165dSkhIUPfu3TVz5kz9/ve/V69evdSjRw/9v//3/5SWlqZx48YFdR0SOQDAEVr7NaY7duzQTTfd5PtcUFAgScrLy9PKlSs1e/ZsNTQ06L777tOxY8d0ww03aOPGjYqJiQnqOiRyAIAztPISrcOGDZNxgXa8y+XSwoULtXDhQhNBcY8cAABboyIHADhCa7fWW4ulFfnFFpQHACBkvIb5EYYsTeQXW1AeAICQCdHKbuHG0tb6hRaUBwAAF8c9cgCAI7hk8h55yCIJLVsl8sbGRr+3zNTX11sYDQDAVsyuzhbCld1CyVaPnxUVFfm9cSY9Pd3qkAAAsJStEnlhYaHq6up8o7q62uqQAAA2EaqXpoQbW7XW3W635a+LAwDYVCuv7NZaLE3kF1tQHgAAXJilifxiC8oDABAqLsOQy8SENTPHtiRLE/nFFpQHACBkvD8OM8eHIVtNdgMAAP5sNdkNAIDmorUOAICdMWsdAAAbY2U3AAAQbqjIAQCOYHZ1NlZ2AwDASrTWAQBAuKEiBwA4gsv7wzBzfDgikQMAnIHWOgAACDdU5AAAZ2BBGAAA7CtSl2iltQ4AgI1RkQMAnCFCJ7uRyAEAzmDI3DvFwzOPk8gBAM7APXIAABB2qMgBAM5gyOQ98pBFElIkcgCAMzDZDa0l6t0qq0MIuU5WBxBinawOAAB+RCIHADiDV5LL5PFhiMluAABHODNr3cwIxvz58+VyufxGnz59Qv67qMgBAGghV155pd555x3f56io0KddEjkAwBksmOwWFRWllJSU5l8zALTWAQDOcCaRmxlB2rdvn9LS0nTppZdq0qRJOnToUMh/FhU5AABBqK+v9/vsdrvldrvP2W/QoEFauXKlevfurSNHjmjBggW68cYbtWfPHsXFxYUsHipyAIAzhKgiT09PV3x8vG8UFRWd93K5ubm64447lJmZqVGjRuntt9/WsWPH9Morr4T0Z1GRAwCcIUSPn1VXV8vj8fg2n68aP59OnTrp8ssv1/79+00EcS4qcgCAI4Tq8TOPx+M3Ak3kJ06c0IEDB5SamhrS30UiBwCgBTz88MOqqKjQX//6V73//vu67bbb1LZtW02cODGk16G1DgBwhlZ+/OyLL77QxIkT9fXXX6tr16664YYbVFlZqa5duzY/hvMgkQMAnMFrSC4Tidwb3LGrV69u/rWCQGsdAAAboyIHADgDrzEFAMDOTCZyhWcip7UOAICNUZEDAJyB1joAADbmNWSqPR7krPXWQmsdAAAboyIHADiD4f1hmDk+DJHIAQDOEKH3yMOitV5cXKxLLrlEMTExGjRokD788EOrQwIARBqvYX6EIcsT+csvv6yCggLNmzdPO3fuVP/+/TVq1CgdPXrU6tAAAAh7lifyJ598Uvfee6+mTp2qvn37aunSperQoYP+8Ic/WB0aACCSnGmtmxlhyNJEfurUKVVVVSknJ8e3rU2bNsrJydG2bdvO2b+xsVH19fV+AwCAgBgymcit/gHnZ2ki//vf/66mpiYlJyf7bU9OTlZNTc05+xcVFSk+Pt430tPTWytUAADCkuWt9WAUFhaqrq7ON6qrq60OCQBgFxHaWrf08bMuXbqobdu2qq2t9dteW1urlJSUc/Z3u91yu92tFR4AIJJ4vZJMPAvuDc/nyC2tyKOjo5WVlaXNmzf7tnm9Xm3evFnZ2dkWRgYAgD1YviBMQUGB8vLyNGDAAF177bVavHixGhoaNHXqVKtDAwBEkghdEMbyRD5hwgR99dVXmjt3rmpqavTLX/5SGzduPGcCHAAAppDIW8706dM1ffp0q8MAAMB2wiKRAwDQ4iL0NaYkcgCAIxiGV4aJN5iZObYlkcgBAM5gmHzxSZjeI7fVgjAAAMAfFTkAwBkMk/fIw7QiJ5EDAJzB65VcJu5zh+k9clrrAADYGBU5AMAZaK0DAGBfhtcrw0RrPVwfP6O1DgCAjVGRAwCcgdY6AAA25jUkV+QlclrrAADYGBU5AMAZDEOSmefIw7MiJ5EDABzB8BoyTLTWjTBN5LTWAQDOYHjNj2YoLi7WJZdcopiYGA0aNEgffvhhSH8WiRwAgBby8ssvq6CgQPPmzdPOnTvVv39/jRo1SkePHg3ZNUjkAABHMLyG6RGsJ598Uvfee6+mTp2qvn37aunSperQoYP+8Ic/hOx3kcgBAM7Qyq31U6dOqaqqSjk5Ob5tbdq0UU5OjrZt2xayn2XryW5nJh58r9OmnvEHAFjje52W1DoTyczmijOx1tfX+213u91yu93n7P/3v/9dTU1NSk5O9tuenJysv/zlL80P5CdsnciPHz8uSdqqty2OBABgxvHjxxUfH98i546OjlZKSoq21pjPFbGxsUpPT/fbNm/ePM2fP9/0uZvL1ok8LS1N1dXViouLk8vlatFr1dfXKz09XdXV1fJ4PC16rdYQab9H4jfZBb8p/LXm7zEMQ8ePH1daWlqLXSMmJkYHDx7UqVOnTJ/LMIxz8s35qnFJ6tKli9q2bava2lq/7bW1tUpJSTEdyxm2TuRt2rRRt27dWvWaHo8nIv6inhFpv0fiN9kFvyn8tdbvaalK/GwxMTGKiYlp8eucLTo6WllZWdq8ebPGjRsnSfJ6vdq8ebOmT58esuvYOpEDABDOCgoKlJeXpwEDBujaa6/V4sWL1dDQoKlTp4bsGiRyAABayIQJE/TVV19p7ty5qqmp0S9/+Utt3LjxnAlwZpDIA+R2uzVv3ryfvRdiN5H2eyR+k13wm8JfpP0eq02fPj2krfSfchnhungsAAC4KBaEAQDAxkjkAADYGIkcAAAbI5EDAGBjJPIAtPS7ZFvTli1bNHbsWKWlpcnlcun111+3OiTTioqKNHDgQMXFxSkpKUnjxo3T3r17rQ7LlJKSEmVmZvoW5MjOztaGDRusDitkFi1aJJfLpZkzZ1odSrPNnz9fLpfLb/Tp08fqsEz78ssvNXnyZCUmJqp9+/a66qqrtGPHDqvDwgWQyC+iNd4l25oaGhrUv39/FRcXWx1KyFRUVCg/P1+VlZXatGmTTp8+rZEjR6qhocHq0JqtW7duWrRokaqqqrRjxw4NHz5ct956qz7++GOrQzNt+/btWrZsmTIzM60OxbQrr7xSR44c8Y2tW7daHZIp33zzjQYPHqx27dppw4YN+uSTT/Tv//7v6ty5s9Wh4UIMXNC1115r5Ofn+z43NTUZaWlpRlFRkYVRhYYkY+3atVaHEXJHjx41JBkVFRVWhxJSnTt3Nv7zP//T6jBMOX78uNGrVy9j06ZNxtChQ42HHnrI6pCabd68eUb//v2tDiOk5syZY9xwww1Wh4EgUZFfQGu9SxahVVdXJ0lKSEiwOJLQaGpq0urVq9XQ0KDs7GyrwzElPz9fY8aM8fs7ZWf79u1TWlqaLr30Uk2aNEmHDh2yOiRT3njjDQ0YMEB33HGHkpKSdPXVV+v555+3OixcBIn8Ai70LtmamhqLosKFeL1ezZw5U4MHD1a/fv2sDseU3bt3KzY2Vm63W/fff7/Wrl2rvn37Wh1Ws61evVo7d+5UUVGR1aGExKBBg7Ry5Upt3LhRJSUlOnjwoG688Ubf65Xt6PPPP1dJSYl69eqlsrIyPfDAA3rwwQf1wgsvWB0aLoAlWhFR8vPztWfPHtvfq5Sk3r17a9euXaqrq9OaNWuUl5eniooKWybz6upqPfTQQ9q0aVOrv4GqpeTm5vr+nJmZqUGDBikjI0OvvPKKpk2bZmFkzef1ejVgwAA9/vjjkqSrr75ae/bs0dKlS5WXl2dxdPg5VOQX0FrvkkVoTJ8+XevXr9d7773X6q+3bQnR0dHq2bOnsrKyVFRUpP79+2vJkiVWh9UsVVVVOnr0qK655hpFRUUpKipKFRUVevrppxUVFaWmpiarQzStU6dOuvzyy7V//36rQ2m21NTUc/6heMUVV9j+lkGkI5FfwNnvkj3jzLtk7X6vMpIYhqHp06dr7dq1evfdd9WjRw+rQ2oRXq9XjY2NVofRLCNGjNDu3bu1a9cu3xgwYIAmTZqkXbt2qW3btlaHaNqJEyd04MABpaamWh1Ksw0ePPicRzc/++wzZWRkWBQRAkFr/SJa412yrenEiRN+FcPBgwe1a9cuJSQkqHv37hZG1nz5+fkqLS3VunXrFBcX55u/EB8fr/bt21scXfMUFhYqNzdX3bt31/Hjx1VaWqry8nKVlZVZHVqzxMXFnTNnoWPHjkpMTLTtXIaHH35YY8eOVUZGhg4fPqx58+apbdu2mjhxotWhNdusWbN0/fXX6/HHH9dvfvMbffjhh3ruuef03HPPWR0aLsTqafN28B//8R9G9+7djejoaOPaa681KisrrQ6p2d577z1D0jkjLy/P6tCa7Xy/R5KxYsUKq0NrtnvuucfIyMgwoqOjja5duxojRoww/vu//9vqsELK7o+fTZgwwUhNTTWio6ONX/ziF8aECROM/fv3Wx2WaW+++abRr18/w+12G3369DGee+45q0PCRfAaUwAAbIx75AAA2BiJHAAAGyORAwBgYyRyAABsjEQOAICNkcgBALAxEjkAADZGIgcAwMZI5EAYmzJlisaNG2d1GADCGIkcAAAbI5EDAGBjJHIAAGyMRA4AgI2RyAEAsDESOQAANkYiBwDAxkjkAADYGIkcAAAbcxmGYVgdBAAAaB4qcgAAbIxEDgCAjZHIAQCwMRI5AAA2RiIHAMDGSOQAANgYiRwAABsjkQMAYGMkcgAAbIxEDgCAjZHIAQCwMRI5AAA29v8BTeVn4/5UNFQAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -809,87 +757,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Plotting values of qty_in at K = 3\n", + "Plotting values of qty_out at K = 2\n", "Min and max values: 13.0 0.0\n" ] }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 4\n", - "Min and max values: 14.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing 'copy_downward' on qty_in with origin=(1,1,0), domain=(nx,ny,nz-1)\n", - "***\n", - "Plotting values of qty_in at K = 0\n", - "Min and max values: 14.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 1\n", - "Min and max values: 14.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Plotting values of qty_in at K = 2\n", - "Min and max values: 14.0 0.0\n" - ] - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -924,24 +798,18 @@ "\n", "print(\"Plotting values of qty_in at K = 0\")\n", "plot_field_at_kN(qty_in.data,0)\n", - "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_kN(qty_out.data,0)\n", - "\n", - "print(\"Executing 'copy_stencil' with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "copy_stencil(qty_in.data,qty_out.data,origin=(nhalo,nhalo,0),domain=(nx,ny,5))\n", - "\n", - "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "plot_field_at_kN(qty_out.data,0)\n", - "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "plot_field_at_kN(qty_out.data,1)\n", + "print(\"Plotting values of qty_in at K = 1\")\n", + "plot_field_at_kN(qty_in.data,1)\n", + "print(\"Plotting values of qty_in at K = 2\")\n", + "plot_field_at_kN(qty_in.data,2)\n", "\n", "@stencil(backend=backend)\n", - "def mult_upward(qty_in: FloatField):\n", + "def mult_upward(qty_in: FloatField, qty_out: FloatField):\n", " with computation(FORWARD), interval(...):\n", - " qty_in = qty_in[0,0,-1] * 2.0\n", + " qty_out = qty_in[0,0,-1] * 2.0\n", "\n", "print(\"Executing 'mult_upward' with origin=(nhalo,nhalo,0),domain=(nx,ny,2)\")\n", - "mult_upward(qty_out.data, origin=(nhalo,nhalo,1), domain=(nx,ny,2))\n", + "mult_upward(qty_in, qty_out, origin=(nhalo,nhalo,1), domain=(nx,ny,2))\n", "print(\"Plotting values of qty_out at K = 0 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", "plot_field_at_kN(qty_out.data,0)\n", "print(\"Plotting values of qty_out at K = 1 with origin=(nhalo,nhalo,1),domain=(nx,ny,2)\")\n", @@ -952,34 +820,169 @@ "plot_field_at_kN(qty_out.data,3)\n", "\n", "@stencil(backend=backend)\n", - "def copy_downward(qty_in: FloatField):\n", + "def copy_downward(qty_in: FloatField, qty_out: FloatField):\n", " with computation(BACKWARD), interval(...):\n", - " qty_in = qty_in[0,0,1]\n", + " qty_out = qty_in[0,0,1]\n", "\n", - "print(\"Executing 'copy_stencil' to copy qty_out to qty_in\")\n", - "copy_stencil(qty_out, qty_in)\n", + "print(\"Resetting qty_out to zeros\")\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", "\n", + "print(\"Executing 'copy_downward' with origin=(1,1,0), domain=(nx,ny,nz-1)\")\n", + "copy_downward(qty_in, qty_out, origin=(1,1,0), domain=(nx,ny,nz-1))\n", "print(\"***\")\n", - "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data,0)\n", - "print(\"Plotting values of qty_in at K = 1\")\n", - "plot_field_at_kN(qty_in.data,1)\n", - "print(\"Plotting values of qty_in at K = 2\")\n", - "plot_field_at_kN(qty_in.data,2)\n", - "print(\"Plotting values of qty_in at K = 3\")\n", - "plot_field_at_kN(qty_in.data,3)\n", - "print(\"Plotting values of qty_in at K = 4\")\n", - "plot_field_at_kN(qty_in.data,4)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_kN(qty_out.data,0)\n", + "print(\"Plotting values of qty_out at K = 1\")\n", + "plot_field_at_kN(qty_out.data,1)\n", + "print(\"Plotting values of qty_out at K = 2\")\n", + "plot_field_at_kN(qty_out.data,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Regarding offsets, GT4Py does not allow offsets to variables in the left hand side of the `=`. Uncomment and execute the below code to see the error `Assignment to non-zero offsets is not supported.`." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "ename": "GTScriptSyntaxError", + "evalue": "Assignment to non-zero offsets is not supported.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mGTScriptSyntaxError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_14884/476100164.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m@\u001b[0m\u001b[0mstencil\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmult_upward_error\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFloatField\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFloatField\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mcomputation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFORWARD\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterval\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\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mqty_in\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36m_decorator\u001b[0;34m(definition_func)\u001b[0m\n\u001b[1;32m 304\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 305\u001b[0m \u001b[0moriginal_annotations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_set_arg_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m \u001b[0;32mor\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\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m out = gt_loader.gtscript_loader(\n\u001b[0m\u001b[1;32m 307\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 308\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mgtscript_loader\u001b[0;34m(definition_func, backend, build_options, externals, dtypes)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{definition_func.__name__}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m stencil_class = load_stencil(\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0;34m\"gtscript\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m )\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mload_stencil\u001b[0;34m(frontend_name, backend_name, definition_func, externals, dtypes, build_options)\u001b[0m\n\u001b[1;32m 58\u001b[0m )\n\u001b[1;32m 59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 60\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mbuild\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;34mf\"The stencil {self._definition.__name__} is not up to date in the cache\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m )\n\u001b[0;32m---> 93\u001b[0;31m \u001b[0mstencil_class\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mstencil_class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_impl_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"disable-code-generation\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0msrc_dir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparents\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexist_ok\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;32m--> 110\u001b[0;31m \u001b[0mrecursive_write\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_computation\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\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_module\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate_computation\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mignore_np_errstate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore_np_errstate\"\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;32m---> 95\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNpirCodegen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnpir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_source\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat_source\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"python\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mnpir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gtcnumpy:npir\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_backend_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_npir\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\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36m_make_npir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_make_npir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnpir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 114\u001b[0;31m \u001b[0mbase_oir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTIRToOIR\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 115\u001b[0m oir_pipeline = self.builder.options.backend_opts.get(\n\u001b[1;32m 116\u001b[0m \u001b[0;34m\"oir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStencil\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir_pipeline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 292\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir_pipeline\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;34m\"gtir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 283\u001b[0m GtirPipeline(\n\u001b[0;32m--> 284\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrontend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 285\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstencil_id\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 286\u001b[0m ),\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(cls, definition, externals, dtypes, options)\u001b[0m\n\u001b[1;32m 2124\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprepare_stencil_definition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2125\u001b[0m \u001b[0mtranslator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTScriptParser\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m \u001b[0mdefinition_ir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtranslator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2128\u001b[0m \u001b[0;31m# GTIR only supports LatLonGrids\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2058\u001b[0m \u001b[0;31m# Generate definition IR\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2059\u001b[0m \u001b[0mdomain\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLatLonGrid\u001b[0m\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;32m-> 2060\u001b[0;31m computations = IRMaker(\n\u001b[0m\u001b[1;32m 2061\u001b[0m \u001b[0mfields\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfields_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2062\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, ast_root)\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0mfunc_ast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mast_root\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\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\u001b[0m\n\u001b[1;32m 781\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 782\u001b[0;31m \u001b[0mcomputations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc_ast\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 783\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcomputations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\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;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_FunctionDef\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1595\u001b[0m \u001b[0mblocks\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\u001b[0m\n\u001b[1;32m 1596\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mast\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAnnAssign\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\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;32m-> 1597\u001b[0;31m \u001b[0mblocks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1599\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputationBlock\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mitem\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mblocks\u001b[0m\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;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\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;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_With\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1587\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcompute_blocks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1588\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1589\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_visit_computation_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1590\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1591\u001b[0m \u001b[0;31m# Mixing nested `with` blocks with stmts not allowed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m_visit_computation_node\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 977\u001b[0m \u001b[0mstmts\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\u001b[0m\n\u001b[1;32m 978\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 979\u001b[0;31m \u001b[0mstmts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\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\u001b[0m\n\u001b[0m\u001b[1;32m 980\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 981\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\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;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_Assign\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1444\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mspatial_offset\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moffset\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moffset\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mspatial_offset\u001b[0m\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;32m-> 1446\u001b[0;31m raise GTScriptSyntaxError(\n\u001b[0m\u001b[1;32m 1447\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Assignment to non-zero offsets is not supported.\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1448\u001b[0m \u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLocation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_ast_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\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;31mGTScriptSyntaxError\u001b[0m: Assignment to non-zero offsets is not supported." + ] + } + ], + "source": [ + "# @stencil(backend=backend)\n", + "# def mult_upward_error(qty_in: FloatField, qty_out: FloatField):\n", + "# with computation(FORWARD), interval(...):\n", + "# qty_out[0,-1,-1] = qty_in * 2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Limits to offset : Cannot set offset outside of usable domain**\n", "\n", - "print(\"Executing 'copy_downward' on qty_in with origin=(1,1,0), domain=(nx,ny,nz-1)\")\n", - "copy_downward(qty_in.data, origin=(1,1,0), domain=(nx,ny,nz-1))\n", - "print(\"***\")\n", - "print(\"Plotting values of qty_in at K = 0\")\n", - "plot_field_at_kN(qty_in.data,0)\n", - "print(\"Plotting values of qty_in at K = 1\")\n", - "plot_field_at_kN(qty_in.data,1)\n", - "print(\"Plotting values of qty_in at K = 2\")\n", - "plot_field_at_kN(qty_in.data,2)" + "Note that there are limits to the offsets that can be applied in the stencil. An error will result if the specified shift results attemps to read data that is not available or allocated. In the example below, a shift of -2 in the `J` axis will shift `field_in` out of its possible range in `J`." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing 'copy_stencil' with origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\n", + "Executing 'copy_stencil' where qty_out is copied back to qty_in\n", + "Min and max values: 10.0 0.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfIAAAHHCAYAAABEJtrOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqp0lEQVR4nO3de3RV9Zn/8c8hkJNALpBIQlJCiIogV5EEBlEBSXX4ASMzy0sZmInQ6TgahJgyKjNTLjISnFmlaKXh0ilhXEagThGLAqXIZdGKkFBmwBkRhGoEA7Zjz0lSCXrO/v2hOUNMgHD2Sfbt/Vrru1bPPnuf/ey2+uR5vt+9t88wDEMAAMCROlkdAAAAiB6JHAAAByORAwDgYCRyAAAcjEQOAICDkcgBAHAwEjkAAA5GIgcAwMFI5AAAOBiJHJ62Z88e+Xw+7dmzx+pQACAqJHK4UkVFhXw+X2QkJCTopptu0uzZs3Xu3LmYnOONN97QokWLYvJbl6qsrNSKFSvavH/fvn01efLkFttffPFFxcXF6U//9E914cKFGEZ4ZWfOnNEDDzyg7t27KyUlRffee69OnTrVYecHvKaz1QEA7enpp59WXl6eLly4oP3796u8vFxvvPGGjh07pq5du5r67TfeeEMrV66MeTKvrKzUsWPHVFJSEvVvvPTSS3rooYdUWFioV199VQkJCbEL8Arq6+s1fvx4BQIB/cM//IO6dOmiH/zgBxo7dqyOHDmi9PT0DokD8BISOVxt4sSJys/PlyT9zd/8jdLT07V8+XJt2bJF06ZNszi69rFhwwYVFRXprrvu0pYtWzosiUvSj370I504cUIHDx5UQUGBpC//Nxg8eLC+//3va+nSpR0WC+AVtNbhKXfddZck6fTp01fc76c//alGjBihxMREXXfddZoxY4bOnDkT+f6hhx7SypUrJalZC/9KtmzZokmTJik7O1t+v1833HCDlixZolAoFNln3Lhxev311/XBBx9EfrNv375tvr5NmzZpxowZGjdunF577bUOTeKS9Morr6igoCCSxCVpwIABmjBhgjZt2tShsQBeQUUOT3n//fcl6Yot3oqKCs2cOVMFBQUqKyvTuXPn9Nxzz+lXv/qVfvOb36h79+56+OGHdfbsWe3cuVMvvvhim85dUVGhpKQklZaWKikpSW+++aYWLFigYDCof/3Xf5Uk/eM//qMCgYA++ugj/eAHP5AkJSUlten3/+M//kPTp0/XnXfeqZ///OdKTExs03H19fVtmkPv0qWLUlNTL/t9OBzWf/3Xf2nWrFktvhs5cqR+8YtfqK6uTsnJyW2KC0AbGYALrVu3zpBk/PKXvzQ++eQTo6amxtiwYYORnp5uJCYmGh999JFhGIaxe/duQ5Kxe/duwzAM4+LFi0ZGRoYxePBg47PPPov83tatWw1JxoIFCyLbiouLjWv5R+iPf/xji20PP/yw0bVrV+PChQuRbZMmTTJyc3Pb/Lu5ublGdna20blzZ2PcuHFGQ0NDm481DMMoKioyJF11jB079oq/88knnxiSjKeffrrFdytXrjQkGe++++41xQbg6qjI4WqFhYXNPufm5uqll17SN77xjVb3r6qq0vnz57Vo0aJmbelJkyZpwIABev3117V48eKoYrm0Qq6rq1NjY6PuuOMOrV69Wu+++66GDRsW1e9K0v/+7//qiy++UO/evdtciTd54oknNGPGjKvu16NHjyt+/9lnn0mS/H5/i++a/rts2gdA7JDI4WorV67UTTfdpM6dOyszM1P9+/dXp06XXxrywQcfSJL69+/f4rsBAwZo//79Ucfyzjvv6J/+6Z/05ptvKhgMNvsuEAhE/buSNGHCBPXp00fl5eVKS0vTc8891+ZjBw4cqIEDB5o6v/R/f6g0Nja2+K6pdX+tf2QAuDoSOVxt5MiRkVXrVvrDH/6gsWPHKiUlRU8//bRuuOEGJSQk6PDhw3ryyScVDodNn+OFF17Qp59+queff149evRo821xgUCgTZVyfHy80tLSLvt9Wlqa/H6/Pv744xbfNW3Lzs5uU0wA2o5EDlwiNzdXknT8+PHICvcmx48fj3wv6aqr1C+1Z88e/f73v9fPfvYz3XnnnZHtra2ev5bfvVSnTp307//+7woEAlq8eLHS0tI0Z86cqx43d+5crV+//qr7jR079opPwOvUqZOGDBmiqqqqFt+9/fbbuv7661noBrQDEjlwifz8fGVkZGjVqlWaNWtWZL5327Zt+p//+R8tWLAgsm+3bt0kfVltd+/e/Yq/GxcXJ0kyDCOy7eLFi/rRj37UYt9u3bpF3Wrv0qWLXnnlFd19990qKSlRjx499Fd/9VdXPCZWc+SSdN999+mpp55SVVVVpBNy/Phxvfnmm5o3b17bLgLANSGRA5fo0qWLnn32Wc2cOVNjx47VtGnTIref9e3bV48//nhk3xEjRkiS5syZo3vuuUdxcXH61re+1erv3nbbberRo4eKioo0Z84c+Xw+vfjii80S+6W/u3HjRpWWlqqgoEBJSUmaMmVKm6+ha9euev311zV27FjNmjVLqamp+rM/+7PL7h+rOXJJevTRR7V27VpNmjRJ8+bNU5cuXbR8+XJlZmbqu9/9bkzOAeBrrF42D7SHptvPDh06dMX9vn77WZONGzcaw4cPN/x+v5GWlmZMnz49cstaky+++MJ47LHHjJ49exo+n++qt6L96le/Mv7kT/7ESExMNLKzs40nnnjC2LFjR4vz19fXG3/5l39pdO/e3ZB01VvRcnNzjUmTJrXYXltba9x4441GQkJCi+trTzU1NcZ9991npKSkGElJScbkyZONEydOdNj5Aa/xGUYrJQEAAHAEHtEKAICDkcgBAHAwEjkAAA5GIgcAoB3s27dPU6ZMUXZ2tnw+n1599dVm3xuGoQULFigrK0uJiYkqLCzUiRMnrvk8JHIAANpBQ0ODhg0bFnnl8df9y7/8i55//nmtWrVKb7/9trp166Z77rmnTW8jvBSr1gEAaGc+n0+bN2/W1KlTJX1ZjWdnZ+u73/1u5GFJgUBAmZmZqqiouOwzKVrj6AfChMNhnT17VsnJyVE/1hIAYB3DMFRXV6fs7OwrvtDIrAsXLujixYumf8cwjBb5xu/3t/rWvys5ffq0amtrm72hMTU1VaNGjdJbb73lnUR+9uxZ5eTkWB0GAMCkmpoa9e7du11++8KFC8rLTVLt+ZDp30pKSlJ9fX2zbQsXLmzzS4qa1NbWSpIyMzObbc/MzIx811aOTuRNL2C4Xf9PndXF4mgAANfqC32u/XqjXV+oc/HiRdWeD+mD6r5KSY6+6g/WhZU74reqqalRSkpKZPu1VuOx5uhE3tTe6Kwu6uwjkQOA43y1SqsjpkeTkn1KSo7+PGF9eWxKSkqzRB6NXr16SZLOnTunrKysyPZz587plltuuabfYtU6AMATQkbY9IiVvLw89erVS7t27YpsCwaDevvttzV69Ohr+i1HV+QAALRVWIbCiv5GrWs9tr6+XidPnox8Pn36tI4cOaK0tDT16dNHJSUl+ud//mf169dPeXl5+t73vqfs7OzIyva2IpEDANAOqqqqNH78+Mjn0tJSSVJRUZEqKir0xBNPqKGhQX/7t3+rP/zhD7r99tu1fft2JSQkXNN5HH0feTAYVGpqqsbpXubIAcCBvjA+1x5tUSAQMD3vfDlNueLs8d6mF7tl9/+oXWONBhU5AMATQoahkIna1cyx7YnFbgAAOBgVOQDAEzp6sVtHIZEDADwhLEMhFyZyWusAADgYFTkAwBNorQMA4GCsWgcAALZDRQ4A8ITwV8PM8XZEIgcAeELI5Kp1M8e2JxI5AMATQsaXw8zxdsQcOQAADkZFDgDwBObIAQBwsLB8Csln6ng7orUOAICDWZ7Iz5w5oxkzZig9PV2JiYkaMmSIqqqqrA4LAOAyYcP8sCNLW+uffvqpxowZo/Hjx2vbtm3q2bOnTpw4oR49elgZFgDAhUImW+tmjm1PlibyZ599Vjk5OVq3bl1kW15enoURAQDgLJa21l977TXl5+fr/vvvV0ZGhoYPH661a9daGRIAwKWaKnIzw44sTeSnTp1SeXm5+vXrpx07duiRRx7RnDlztH79+lb3b2xsVDAYbDYAAGiLsOEzPezI0tZ6OBxWfn6+li5dKkkaPny4jh07plWrVqmoqKjF/mVlZVq8eHFHhwkAgG1ZWpFnZWVp4MCBzbbdfPPN+vDDD1vdf/78+QoEApFRU1PTEWECAFzAra11SyvyMWPG6Pjx4822vffee8rNzW11f7/fL7/f3xGhAQBcJqROCpmoX0MxjCWWLE3kjz/+uG677TYtXbpUDzzwgA4ePKg1a9ZozZo1VoYFAHAhw+Q8t2HTOXJLW+sFBQXavHmzXn75ZQ0ePFhLlizRihUrNH36dCvDAgDAMSx/1vrkyZM1efJkq8MAALgcD4QBAMDBQkYnhQwTc+Q2fUSr5c9aBwAA0aMiBwB4Qlg+hU3Ur2HZsyQnkQMAPMGtc+S01gEAcDAqcgCAJ5hf7EZrHQAAy3w5Rx59e9zMse2J1joAAA5GRQ4A8ISwyWets2odAAALMUcOAICDhdXJlfeRM0cOAICDUZEDADwhZPgUMvEqUjPHticSOQDAE0ImF7uFaK0DAIBYoyIHAHhC2OiksIlV62FWrQMAYB1a6wAAwHaoyAEAnhCWuZXn4diFElMkcgCAJ5h/IIw9m9gkchs6VXmL1SHE3PWZv7M6hJgqSP/A6hBirjD5HatDiLlxiXatoaJ3T/YtVocAmyGRAwA8wfyz1qnIAQCwjFvfR04iBwB4glsrcntGBQAA2oSKHADgCeYfCGPP2pdEDgDwhLDhU9jMfeQ2ffuZPf+8AAAAbUJFDgDwhLDJ1joPhAEAwELm335mz0Ruz6gAAECbUJEDADwhJJ9CJh7qYubY9kQiBwB4Aq11AABgO1TkAABPCMlcezwUu1BiikQOAPAEt7bWSeQAAE/gpSkAAKDNQqGQvve97ykvL0+JiYm64YYbtGTJEhmGEdPzUJEDADzBMPk+cuMaj3322WdVXl6u9evXa9CgQaqqqtLMmTOVmpqqOXPmRB3H15HIAQCe0NGt9V//+te69957NWnSJElS37599fLLL+vgwYNRx9AaWusAAFyDYDDYbDQ2Nra632233aZdu3bpvffekyT953/+p/bv36+JEyfGNB4qcgCAJ8TqNaY5OTnNti9cuFCLFi1qsf9TTz2lYDCoAQMGKC4uTqFQSM8884ymT58edQytsTSRL1q0SIsXL262rX///nr33XctiggA4FYhk28/azq2pqZGKSkpke1+v7/V/Tdt2qSXXnpJlZWVGjRokI4cOaKSkhJlZ2erqKgo6ji+zvKKfNCgQfrlL38Z+dy5s+UhAQBwWSkpKc0S+eX8/d//vZ566il961vfkiQNGTJEH3zwgcrKytyVyDt37qxevXpZHQYAwOVi1Vpvqz/+8Y/q1Kl5ByAuLk7hcDjqGFpjeSI/ceKEsrOzlZCQoNGjR6usrEx9+vRpdd/GxsZmiwqCwWBHhQkAcLiwOilsorV+rcdOmTJFzzzzjPr06aNBgwbpN7/5jZYvX65Zs2ZFHUNrLF21PmrUKFVUVGj79u0qLy/X6dOndccdd6iurq7V/cvKypSamhoZX19wAACAXfzwhz/Ufffdp0cffVQ333yz5s2bp4cfflhLliyJ6XksrcgvXYI/dOhQjRo1Srm5udq0aZO+/e1vt9h//vz5Ki0tjXwOBoMkcwBAm4QMn0ImWuvXemxycrJWrFihFStWRH3OtrC8tX6p7t2766abbtLJkydb/d7v9192dSAAAFfS0XPkHcVWD4Spr6/X+++/r6ysLKtDAQC4jPHV28+iHQYvTWlp3rx52rt3r37729/q17/+tf78z/9ccXFxmjZtmpVhAQDgGJa21j/66CNNmzZNv//979WzZ0/dfvvtOnDggHr27GllWAAAFwrJp5CJl6aYObY9WZrIN2zYYOXpAQAeEjbMzXOHY/v20ZixZ8MfAAC0ia1WrQMA0F6aFq2ZOd6OSOQAAE8Iy6ewiXluM8e2J3v+eQEAANqEihwA4Akd/WS3jkIiBwB4glvnyO0ZFQAAaBMqcgCAJ4Rl8lnrNl3sRiIHAHiCYXLVukEiBwDAOrz9DAAA2A4VOQDAE9y6ap1EDgDwBFrrAADAdqjIAQCe4NZnrZPIAQCeQGsdAADYDhU5AMAT3FqRk8gBAJ7g1kROax0AAAejIreh8LkEq0OIuVO6zuoQ4EnvWB0AbMStFTmJHADgCYbM3UJmxC6UmCKRAwA8wa0VOXPkAAA4GBU5AMAT3FqRk8gBAJ7g1kROax0AAAejIgcAeIJbK3ISOQDAEwzDJ8NEMjZzbHuitQ4AgINRkQMAPIH3kQMA4GBunSOntQ4AgINRkQMAPMGti91I5AAAT3Bra51EDgDwBLdW5MyRAwDgYFTkAABPMEy21u1akZPIAQCeYEgyDHPH2xGtdQAAHIyKHADgCWH55OPJbgAAOBOr1tvZsmXL5PP5VFJSYnUoAAA4hi0q8kOHDmn16tUaOnSo1aEAAFwqbPjkc+EDYSyvyOvr6zV9+nStXbtWPXr0sDocAIBLGYb5YUeWJ/Li4mJNmjRJhYWFV923sbFRwWCw2QAAwMssba1v2LBBhw8f1qFDh9q0f1lZmRYvXtzOUQEA3IjFbjFWU1OjuXPn6qWXXlJCQkKbjpk/f74CgUBk1NTUtHOUAAC3aErkZoYdWVaRV1dX6/z587r11lsj20KhkPbt26cXXnhBjY2NiouLa3aM3++X3+/v6FABAC7g1sVuliXyCRMm6OjRo822zZw5UwMGDNCTTz7ZIokDAICWLEvkycnJGjx4cLNt3bp1U3p6eovtAACYZXbluV1XrdviPnIAANrbl4nczGK3GAYTQ7ZK5Hv27LE6BAAAHMVWiRwAgPbi1tvPSOQAAE8wZO6d4jbtrFv/ZDcAABA9KnIAgCfQWgcAwMlc2luntQ4A8Aazj2eNoiI/c+aMZsyYofT0dCUmJmrIkCGqqqqK6WVRkQMA0A4+/fRTjRkzRuPHj9e2bdvUs2dPnThxIuav7CaRAwA8oaOf7Pbss88qJydH69ati2zLy8uLPoDLoLUOAPCEWL39LBgMNhuNjY2tnu+1115Tfn6+7r//fmVkZGj48OFau3ZtzK+LRA4AwDXIyclRampqZJSVlbW636lTp1ReXq5+/fppx44deuSRRzRnzhytX78+pvHQWgcAeEOUC9aaHS+ppqZGKSkpkc2Xe712OBxWfn6+li5dKkkaPny4jh07plWrVqmoqCj6OL6GihwA4AlNc+RmhiSlpKQ0G5dL5FlZWRo4cGCzbTfffLM+/PDDmF4XiRwAgHYwZswYHT9+vNm29957T7m5uTE9D4kcAOANRgzGNXj88cd14MABLV26VCdPnlRlZaXWrFmj4uLi2FzPV0jkAABPiNWq9bYqKCjQ5s2b9fLLL2vw4MFasmSJVqxYoenTp8f0uljsBgBAO5k8ebImT57crucgkQMAvMOmz0s3g0QOAPAE3n4GAICT8fYzAABgN1TkNpRY676/rz5TgtUhxNQpXWd1CACume+rYeZ4+yGRAwC8gdY6AACwGypyAIA3uLQiJ5EDALwhRm8/sxta6wAAOBgVOQDAEy59FWm0x9sRiRwA4A0unSOntQ4AgINRkQMAvMGli91I5AAAT/AZXw4zx9sRiRwA4A3MkQMAALuhIgcAeANz5AAAOBitdQAAYDdU5AAAb3BpRU4iBwB4g0sTOa11AAAcjIocAOANrFoHAMC53PpkN1rrAAA4mKWJvLy8XEOHDlVKSopSUlI0evRobdu2zcqQAABuZcRg2JClibx3795atmyZqqurVVVVpbvuukv33nuv3nnnHSvDAgDAMSydI58yZUqzz88884zKy8t14MABDRo0yKKoAABu5JPJOfKYRRJbbUrkf/EXf3H1H+rcWb169dI3v/nNFgm6LUKhkH7605+qoaFBo0ePbnWfxsZGNTY2Rj4Hg8FrPg8AAG7SpkSempp61X3C4bBOnDihH//4x5o3b56efvrpNgVw9OhRjR49WhcuXFBSUpI2b96sgQMHtrpvWVmZFi9e3KbfBQCgGS/ffrZu3bo2/+DWrVv16KOPtjmR9+/fX0eOHFEgENArr7yioqIi7d27t9VkPn/+fJWWlkY+B4NB5eTktDk2AICHufTJbjGfI7/99tuVn5/f5v3j4+N14403SpJGjBihQ4cO6bnnntPq1atb7Ov3++X3+2MWKwAAThfzRN69e3f97Gc/i/r4cDjcbB4cAICYoCKPvfnz52vixInq06eP6urqVFlZqT179mjHjh1WhgUAcCG3PtnN0kR+/vx5/fVf/7U+/vhjpaamaujQodqxY4e++c1vWhkWAACOYWki/7d/+zcrTw8A8BJa6wAAOJhLEzkvTQEAwMGoyAEAnsBiNwAAnMzLT3YDAMDxmCMHAAB2Q0UOAPAE5sgBAHAyWusAAMBuqMgBAN5gsrVu14qcRA4A8AZa6wAAwG6oyAEA3uDSipxEDgDwBLfefkZrHQAAByORAwDgYLTWAQDewBw5AADOxRw5AACwHSpyAIB32LSqNoNEbkPdzrrw/2kua/58pgSrQ4i5U7rO6hDQJh9ZHYBzuXSO3F3/dgUAwGOoyAEAnuDWxW4kcgCAN9BaBwAAdkNFDgDwBLe21qnIAQDeYMRgRGnZsmXy+XwqKSmJ/kcug0QOAEA7OnTokFavXq2hQ4e2y++TyAEA3mBBRV5fX6/p06dr7dq16tGjh/lraAWJHADgCU1z5GaGJAWDwWajsbHxsucsLi7WpEmTVFhY2G7XRSIHAHhDjCrynJwcpaamRkZZWVmrp9uwYYMOHz582e9jhVXrAABcg5qaGqWkpEQ++/3+VveZO3eudu7cqYSE9n2kM4kcAOANMXogTEpKSrNE3prq6mqdP39et956a2RbKBTSvn379MILL6ixsVFxcXEmgvk/JHIAgCd05H3kEyZM0NGjR5ttmzlzpgYMGKAnn3wyZklcIpEDABBzycnJGjx4cLNt3bp1U3p6eovtZpHIAQDe4NJnrZPIAQCeYPUjWvfs2WPuBy6D288AAHAwKnIAgDfQWgcAwMFcmshprQMA4GCWJvKysjIVFBQoOTlZGRkZmjp1qo4fP25lSAAAl/LFYNiRpYl87969Ki4u1oEDB7Rz5059/vnnuvvuu9XQ0GBlWAAAN7LwfeTtydI58u3btzf7XFFRoYyMDFVXV+vOO++0KCoAgBtZfftZe7HVHHkgEJAkpaWlWRwJAADOYJtV6+FwWCUlJRozZsxlH1/X2NjY7L2vwWCwo8IDADgdq9bbV3FxsY4dO6YNGzZcdp+ysrJm74DNycnpwAgBAI7nsvlxySaJfPbs2dq6dat2796t3r17X3a/+fPnKxAIREZNTU0HRgkAgP1Y2lo3DEOPPfaYNm/erD179igvL++K+/v9/lZf4A4AwNW4dbGbpYm8uLhYlZWV2rJli5KTk1VbWytJSk1NVWJiopWhAQDchjny2CsvL1cgENC4ceOUlZUVGRs3brQyLAAAHMPy1joAAB2B1joAAE5Gax0AANgNFTkAwBNorQMA4GQuba2TyAEA3uDSRM4cOQAADkZFDgDwBObIAQBwMlrrAADAbqjIAQCe4DMM+Uw8UdTMse2JRA4A8AZa6wAAwG6oyAEAnsCqdQAAnIzWOgAAsBsqcgCAJ9BaBwDAyVzaWieRAwA8wa0VOXPkAAA4GBU5AMAbaK2joySduWh1CO0g3uoAYsx9zazPlGB1CDF3StdZHULMXa+PrA7B0ezaHjfDff82AgDAQ6jIAQDeYBhfDjPH2xCJHADgCaxaBwAAtkNFDgDwBlatAwDgXL7wl8PM8XZEax0AAAejIgcAeAOtdQAAnMutq9ZJ5AAAb3DpfeTMkQMA4GBU5AAAT6C1DgCAk7l0sRutdQAAHIyKHADgCbTWAQBwMlatAwAAu6EiBwB4Aq11AACcjFXrAADAbqjIAQCe4NbWuqUV+b59+zRlyhRlZ2fL5/Pp1VdftTIcAICbhQ3zw4YsTeQNDQ0aNmyYVq5caWUYAAAvMGIwbMjS1vrEiRM1ceJEK0MAAMDRmCMHAHiCTybnyGMWSWw5KpE3NjaqsbEx8jkYDFoYDQDAUXiym/XKysqUmpoaGTk5OVaHBACApRyVyOfPn69AIBAZNTU1VocEAHCIptvPzIxrUVZWpoKCAiUnJysjI0NTp07V8ePHY35djkrkfr9fKSkpzQYAAG3SwavW9+7dq+LiYh04cEA7d+7U559/rrvvvlsNDQ2xuZ6vWDpHXl9fr5MnT0Y+nz59WkeOHFFaWpr69OljYWQAAJizffv2Zp8rKiqUkZGh6upq3XnnnTE7j6WJvKqqSuPHj498Li0tlSQVFRWpoqLCoqgAAG7kMwz5TCxYazr26wut/X6//H7/VY8PBAKSpLS0tKhjaI2liXzcuHEybLoKEADgMuGvhpnjpRYLrRcuXKhFixZd+dBwWCUlJRozZowGDx5sIoiWHHX7GQAAVqupqWm2Rqst1XhxcbGOHTum/fv3xzweEjkAwBNi1Vq/1sXWs2fP1tatW7Vv3z717t076vNfDokcAOANHfw+csMw9Nhjj2nz5s3as2eP8vLyTJz88kjkAABv6OAnuxUXF6uyslJbtmxRcnKyamtrJUmpqalKTEyMPo6vcdR95AAAOEV5ebkCgYDGjRunrKysyNi4cWNMz0NFDgDwhGiezvb1469FR92VRSIHAHgDL00BAAB2Q0UOAPAEX/jLYeZ4OyKRAwC8gdY6AACwGypyAIA3dPADYToKiRwA4AmxekSr3dBaBwDAwajIAQDe4NLFbiRyAIA3GDL3PnJ75nESOQDAG5gjBwAAtkNFDgDwBkMm58hjFklMkcgBAN7AYjd0lM5vVlsdQsx1tzqAGOtudQAA8BUSOQDAG8KSfCaPtyESOQDAE1i1DgAAbIeKHADgDSx2AwDAwVyayGmtAwDgYFTkAABvcGlFTiIHAHgDt58BAOBc3H4GAABsh4ocAOANzJEDAOBgYUPymUjGYXsmclrrAAA4GBU5AMAbaK0DAOBkJhO57JnIaa0DAOBgVOQAAG+gtQ4AgIOFDZlqj7NqHQAAxBoVOQDAG4zwl8PM8TZEIgcAeINL58ht0VpfuXKl+vbtq4SEBI0aNUoHDx60OiQAgNuEDfPDhixP5Bs3blRpaakWLlyow4cPa9iwYbrnnnt0/vx5q0MDAMD2LE/ky5cv13e+8x3NnDlTAwcO1KpVq9S1a1f95Cc/sTo0AICbNLXWzQwbsjSRX7x4UdXV1SosLIxs69SpkwoLC/XWW2+12L+xsVHBYLDZAACgTQyZTORWX0DrLE3kv/vd7xQKhZSZmdlse2Zmpmpra1vsX1ZWptTU1MjIycnpqFABALAly1vr12L+/PkKBAKRUVNTY3VIAACncGlr3dLbz6677jrFxcXp3LlzzbafO3dOvXr1arG/3++X3+/vqPAAAG4SDksycS942J73kVtakcfHx2vEiBHatWtXZFs4HNauXbs0evRoCyMDAMAZLH8gTGlpqYqKipSfn6+RI0dqxYoVamho0MyZM60ODQDgJi59IIzlifzBBx/UJ598ogULFqi2tla33HKLtm/f3mIBHAAAppDI28/s2bM1e/Zsq8MAAMBxbJHIAQBody59jSmJHADgCYYRlmHiDWZmjm1PJHIAgDcYJl98YtM5ckc9EAYAADRHRQ4A8AbD5By5TStyEjkAwBvCYclnYp7bpnPktNYBAHAwKnIAgDfQWgcAwLmMcFiGida6XW8/o7UOAICDUZEDALyB1joAAA4WNiSf+xI5rXUAAByMihwA4A2GIcnMfeT2rMhJ5AAATzDChgwTrXXDpomc1joAwBuMsPkRhZUrV6pv375KSEjQqFGjdPDgwZheFokcAIB2snHjRpWWlmrhwoU6fPiwhg0bpnvuuUfnz5+P2TlI5AAATzDChulxrZYvX67vfOc7mjlzpgYOHKhVq1apa9eu+slPfhKz6yKRAwC8oYNb6xcvXlR1dbUKCwsj2zp16qTCwkK99dZbMbssRy92a1p48IU+N3WPPwDAGl/oc0kds5DMbK5oijUYDDbb7vf75ff7W+z/u9/9TqFQSJmZmc22Z2Zm6t13340+kK9xdCKvq6uTJO3XGxZHAgAwo66uTqmpqe3y2/Hx8erVq5f215rPFUlJScrJyWm2beHChVq0aJHp346WoxN5dna2ampqlJycLJ/P167nCgaDysnJUU1NjVJSUtr1XB3BbdcjcU1OwTXZX0dej2EYqqurU3Z2drudIyEhQadPn9bFixdN/5ZhGC3yTWvVuCRdd911iouL07lz55ptP3funHr16mU6liaOTuSdOnVS7969O/ScKSkprvgHtYnbrkfimpyCa7K/jrqe9qrEL5WQkKCEhIR2P8+l4uPjNWLECO3atUtTp06VJIXDYe3atUuzZ8+O2XkcncgBALCz0tJSFRUVKT8/XyNHjtSKFSvU0NCgmTNnxuwcJHIAANrJgw8+qE8++UQLFixQbW2tbrnlFm3fvr3FAjgzSORt5Pf7tXDhwsvOhTiN265H4pqcgmuyP7ddj9Vmz54d01b61/kMuz48FgAAXBUPhAEAwMFI5AAAOBiJHAAAByORAwDgYCTyNmjvd8l2pH379mnKlCnKzs6Wz+fTq6++anVIppWVlamgoEDJycnKyMjQ1KlTdfz4cavDMqW8vFxDhw6NPJBj9OjR2rZtm9VhxcyyZcvk8/lUUlJidShRW7RokXw+X7MxYMAAq8My7cyZM5oxY4bS09OVmJioIUOGqKqqyuqwcAUk8qvoiHfJdqSGhgYNGzZMK1eutDqUmNm7d6+Ki4t14MAB7dy5U59//rnuvvtuNTQ0WB1a1Hr37q1ly5apurpaVVVVuuuuu3TvvffqnXfesTo00w4dOqTVq1dr6NChVodi2qBBg/Txxx9Hxv79+60OyZRPP/1UY8aMUZcuXbRt2zb993//t77//e+rR48eVoeGKzFwRSNHjjSKi4sjn0OhkJGdnW2UlZVZGFVsSDI2b95sdRgxd/78eUOSsXfvXqtDiakePXoYP/7xj60Ow5S6ujqjX79+xs6dO42xY8cac+fOtTqkqC1cuNAYNmyY1WHE1JNPPmncfvvtVoeBa0RFfgUd9S5ZxFYgEJAkpaWlWRxJbIRCIW3YsEENDQ0aPXq01eGYUlxcrEmTJjX7Z8rJTpw4oezsbF1//fWaPn26PvzwQ6tDMuW1115Tfn6+7r//fmVkZGj48OFau3at1WHhKkjkV3Cld8nW1tZaFBWuJBwOq6SkRGPGjNHgwYOtDseUo0ePKikpSX6/X3/3d3+nzZs3a+DAgVaHFbUNGzbo8OHDKisrszqUmBg1apQqKiq0fft2lZeX6/Tp07rjjjsir1d2olOnTqm8vFz9+vXTjh079Mgjj2jOnDlav3691aHhCnhEK1yluLhYx44dc/xcpST1799fR44cUSAQ0CuvvKKioiLt3bvXkcm8pqZGc+fO1c6dOzv8DVTtZeLEiZH/PHToUI0aNUq5ubnatGmTvv3tb1sYWfTC4bDy8/O1dOlSSdLw4cN17NgxrVq1SkVFRRZHh8uhIr+CjnqXLGJj9uzZ2rp1q3bv3t3hr7dtD/Hx8brxxhs1YsQIlZWVadiwYXruueesDisq1dXVOn/+vG699VZ17txZnTt31t69e/X888+rc+fOCoVCVodoWvfu3XXTTTfp5MmTVocStaysrBZ/KN58882OnzJwOxL5FVz6LtkmTe+SdfpcpZsYhqHZs2dr8+bNevPNN5WXl2d1SO0iHA6rsbHR6jCiMmHCBB09elRHjhyJjPz8fE2fPl1HjhxRXFyc1SGaVl9fr/fff19ZWVlWhxK1MWPGtLh187333lNubq5FEaEtaK1fRUe8S7Yj1dfXN6sYTp8+rSNHjigtLU19+vSxMLLoFRcXq7KyUlu2bFFycnJk/UJqaqoSExMtji468+fP18SJE9WnTx/V1dWpsrJSe/bs0Y4dO6wOLSrJyckt1ix069ZN6enpjl3LMG/ePE2ZMkW5ubk6e/asFi5cqLi4OE2bNs3q0KL2+OOP67bbbtPSpUv1wAMP6ODBg1qzZo3WrFljdWi4EquXzTvBD3/4Q6NPnz5GfHy8MXLkSOPAgQNWhxS13bt3G5JajKKiIqtDi1pr1yPJWLdundWhRW3WrFlGbm6uER8fb/Ts2dOYMGGC8Ytf/MLqsGLK6befPfjgg0ZWVpYRHx9vfOMb3zAefPBB4+TJk1aHZdrPf/5zY/DgwYbf7zcGDBhgrFmzxuqQcBW8xhQAAAdjjhwAAAcjkQMA4GAkcgAAHIxEDgCAg5HIAQBwMBI5AAAORiIHAMDBSOQAADgYiRywsYceekhTp061OgwANkYiBwDAwUjkAAA4GIkcAAAHI5EDAOBgJHIAAByMRA4AgIORyAEAcDASOQAADkYiBwDAwXyGYRhWBwEAAKJDRQ4AgIORyAEAcDASOQAADkYiBwDAwUjkAAA4GIkcAAAHI5EDAOBgJHIAAByMRA4AgIORyAEAcDASOQAADkYiBwDAwf4/abgEttcv/LsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_14884/2175782849.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mplot_field_at_kN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\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\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m \u001b[0mcopy_stencil_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnhalo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnhalo\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 34\u001b[0m \u001b[0mplot_field_at_kN\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_out\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\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\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_000000/py311_1013/numpy/__main__/copy_stencil_offset/m_copy_stencil_offset__numpy_ef139435cf.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[0;31m# assert that all required values have been provided\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 101\u001b[0;31m self._call_run(\n\u001b[0m\u001b[1;32m 102\u001b[0m \u001b[0mfield_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfield_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_call_run\u001b[0;34m(self, field_args, parameter_args, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidate_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray_infos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 585\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_domain_origin_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcache_key\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_validate_args\u001b[0;34m(self, arg_infos, param_args, domain, origin)\u001b[0m\n\u001b[1;32m 466\u001b[0m )\n\u001b[1;32m 467\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfield_domain_origin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_origin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;34mf\"Origin for field {name} too small. Must be at least {min_origin}, is {field_domain_origin}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)" + ] + } + ], + "source": [ + "# nx = 5\n", + "# ny = 5\n", + "# nz = 5\n", + "# nhalo = 1\n", + "# backend=\"numpy\"\n", + "\n", + "# shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", + "\n", + "# qty_out = Quantity(data=np.zeros(shape),\n", + "# dims=[\"I\", \"J\", \"K\"],\n", + "# units=\"m\",\n", + "# gt4py_backend=backend\n", + "# )\n", + "\n", + "# arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "# qty_in = Quantity(data=arr,\n", + "# dims=[\"I\", \"J\", \"K\"],\n", + "# units=\"m\",\n", + "# gt4py_backend=backend\n", + "# )\n", + "\n", + "# @stencil(backend=backend)\n", + "# def copy_stencil_offset(field_in: FloatField, field_out: FloatField):\n", + "# with computation(PARALLEL), interval(...):\n", + "# field_out = field_in[0,-2,0]\n", + "\n", + "# print(\"Executing 'copy_stencil' with origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\")\n", + "# copy_stencil(qty_in, qty_out, origin=(nhalo, nhalo,0), domain=(nx, ny, nz))\n", + "# print(\"Executing 'copy_stencil' where qty_out is copied back to qty_in\")\n", + "# copy_stencil(qty_out, qty_in)\n", + "# plot_field_at_kN(qty_in.data,0)\n", + "# print(\"Executing 'copy_stencil_offset' where origin=(nhalo, nhalo,0), domain=(nx, ny, nz)\")\n", + "# copy_stencil_offset(qty_in, qty_out, origin=(nhalo, nhalo,0), domain=(nx, ny, nz))\n", + "# plot_field_at_kN(qty_out.data,0)" ] }, { @@ -993,7 +996,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1126,7 +1129,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data,0)\n", "print(\"Running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", - "copy_stencil(qty_in.data,qty_out.data,origin=(nhalo,nhalo,0),domain=(nx,ny,5))\n", + "copy_stencil(qty_in,qty_out,origin=(nhalo,nhalo,0),domain=(nx,ny,5))\n", "print(\"Plotting values of qty_out at K = 0 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", "plot_field_at_kN(qty_out.data,0)\n", "print(\"Plotting values of qty_out at K = 1 based on running copy_stencil with origin=(nhalo,nhalo,0),domain=(nx,ny,5)\")\n", @@ -1140,7 +1143,7 @@ " else:\n", " in_out_field = 10\n", "print(\"Running 'stencil_if_zero' on qty_out\")\n", - "stencil_if_zero(qty_out.data)\n", + "stencil_if_zero(qty_out)\n", "print(\"Plotting values of qty_out at K = 0 based on running stencil_if_zero\")\n", "plot_field_at_kN(qty_out.data,0)\n", "print(\"Plotting values of qty_out at K = 1 based on running stencil_if_zero\")\n", @@ -1160,7 +1163,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1191,7 +1194,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1205,12 +1208,12 @@ "text": [ "Executing 'field_plus_one'\n", "Plotting values of qty_out at K = 0 after executing 'field_plus_one'\n", - "Min and max values: 9.0 1.0\n" + "Min and max values: 13.0 1.0\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHHCAYAAACbaKDRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAApRUlEQVR4nO3df3RU9Z3/8dckwCSQmUCQoClJoFjJAkYFIhuxgBJwcyILZ0+rZXENoe26NYhp1lbZbQG1GtyetbALRupxwWVNQa1IF4UsQgOHbilJMFtwK8WWrx0VCO3a/FIGmbnfPzBTY/hxZ+5k7p3c5+Oce07nzv3c+2Z65M37/fncez2GYRgCAACOk2J3AAAA4MJI0gAAOBRJGgAAhyJJAwDgUCRpAAAciiQNAIBDkaQBAHAokjQAAA5FkgYAwKFI0nC1hoYGeTweNTQ02B0KAPRCkka/tHHjRnk8nsiWlpama665RkuWLNGpU6fico3XXntNK1eujMu5Pq2urk6rV682ffzo0aN1++2399q/adMmpaam6i/+4i905syZOEZ4ae+9957uuOMODR06VH6/X/PmzdNvf/vbhF0f6E8G2B0A0JceeeQRjRkzRmfOnNH+/ftVW1ur1157TUeOHNHgwYMtnfu1117TunXr4p6o6+rqdOTIEVVVVcV8jueff16LFi1SSUmJXnnlFaWlpcUvwEvo7OzULbfcora2Nv3DP/yDBg4cqB/84AeaMWOGWlpaNHz48ITEAfQXJGn0a6WlpZoyZYok6Wtf+5qGDx+uJ598Utu2bdOCBQtsjq5vbN68WeXl5br11lu1bdu2hCVoSXrqqad07NgxHTx4UEVFRZLO/38wceJE/fM//7Mef/zxhMUC9Ae0u+Eqt956qyTp+PHjlzzuxRdf1OTJk5Wenq4rrrhCd911l957773I94sWLdK6deskqUdb/VK2bdumsrIy5eTkyOv1auzYsXr00UcVCoUix8ycOVOvvvqq3nnnncg5R48ebfrP98ILL+iuu+7SzJkz9ZOf/CShCVqSXnrpJRUVFUUStCQVFBRo1qxZeuGFFxIaC9AfUEnDVX7zm99I0iXbrhs3blRFRYWKiopUU1OjU6dOac2aNfrZz36mN954Q0OHDtU999yj999/X7t27dKmTZtMXXvjxo3KyMhQdXW1MjIytGfPHi1fvlzt7e36/ve/L0n6x3/8R7W1tendd9/VD37wA0lSRkaGqfP/+Mc/1sKFCzV9+nT953/+p9LT002N6+zsNDVnPXDgQGVmZl70+3A4rF/+8pdavHhxr+9uvPFG/dd//Zc6Ojrk8/lMxQVAkgH0Qxs2bDAkGa+//rpx+vRpIxAIGJs3bzaGDx9upKenG++++65hGIbx05/+1JBk/PSnPzUMwzDOnj1rZGdnGxMnTjQ++uijyPm2b99uSDKWL18e2VdZWWlE85/Qhx9+2GvfPffcYwwePNg4c+ZMZF9ZWZmRn59v+rz5+flGTk6OMWDAAGPmzJlGV1eX6bGGYRjl5eWGpMtuM2bMuOR5Tp8+bUgyHnnkkV7frVu3zpBkvPXWW1HFBrgdlTT6tZKSkh6f8/Pz9fzzz+tzn/vcBY9vampSa2urVq5c2aNVXFZWpoKCAr366qt6+OGHY4rl05VtR0eHgsGgvvjFL2r9+vV66623dN1118V0Xkn6v//7P507d06jRo0yXUF3+/a3v6277rrrsscNGzbskt9/9NFHkiSv19vru+7fsvsYAOaQpNGvrVu3Ttdcc40GDBigkSNHaty4cUpJufhSjHfeeUeSNG7cuF7fFRQUaP/+/THH8uabb+o73/mO9uzZo/b29h7ftbW1xXxeSZo1a5by8vJUW1urrKwsrVmzxvTY8ePHa/z48ZauL/3pHyHBYLDXd93t9Gj/AQG4HUka/dqNN94YWd1tpz/+8Y+aMWOG/H6/HnnkEY0dO1ZpaWk6dOiQHnzwQYXDYcvXWLt2rT744AP9y7/8i4YNG2b61rC2tjZTFe6gQYOUlZV10e+zsrLk9Xp14sSJXt9178vJyTEVE4DzSNLAp+Tn50uSjh49GlkJ3u3o0aOR7yVddjX3pzU0NOgPf/iDXn75ZU2fPj2y/0KrzKM576elpKTo3//939XW1qaHH35YWVlZWrp06WXH3X///Xruuecue9yMGTMu+WS2lJQUXXvttWpqaur13S9+8Qt9/vOfZ9EYECWSNPApU6ZMUXZ2tp5++mktXrw4Mr+6Y8cO/epXv9Ly5csjxw4ZMkTS+Sp56NChlzxvamqqJMkwjMi+s2fP6qmnnup17JAhQ2Jufw8cOFAvvfSS5syZo6qqKg0bNkx/8zd/c8kx8ZqTlqQvfelLeuihh9TU1BTpYBw9elR79uzRAw88YO4PASCCJA18ysCBA/XEE0+ooqJCM2bM0IIFCyK3YI0ePVrf/OY3I8dOnjxZkrR06VLddtttSk1N1Ve+8pULnvemm27SsGHDVF5erqVLl8rj8WjTpk09kvanz7tlyxZVV1erqKhIGRkZmjt3ruk/w+DBg/Xqq69qxowZWrx4sTIzM/WXf/mXFz0+XnPSknTvvffqmWeeUVlZmR544AENHDhQTz75pEaOHKm///u/j8s1AFexe3k50Be6b8FqbGy85HGfvQWr25YtW4wbbrjB8Hq9RlZWlrFw4cLIbVvdzp07Z9x3333GiBEjDI/Hc9nbsX72s58Zf/7nf26kp6cbOTk5xre//W2jvr6+1/U7OzuNv/7rvzaGDh1qSLrs7Vj5+flGWVlZr/0nT540rr76aiMtLa3Xn68vBQIB40tf+pLh9/uNjIwM4/bbbzeOHTuWsOsD/YnHMC7wT3kAAGA7HgsKAIBDkaQBAHAokjQAAA5FkgYAoI90dHSoqqpK+fn5Sk9P10033aTGxkbT40nSAAD0ka997WuRt+UdPnxYc+bMUUlJSY9X314Kq7sBAOgDH330kXw+X+Rd8t0mT56s0tJSfe9737vsOZL6YSbhcFjvv/++fD5fzI9SBADYxzAMdXR0KCcn55Ivv7HqzJkzOnv2rOXzGIbRK994vd4Lvv3t3LlzCoVCPd6oJ51/0Yzpl/XYeZO2VYFAwNR7cNnY2NjYnL0FAoE+yxUfffSRcWV2alzizMjI6LVvxYoVF712cXGxMWPGDOO9994zzp07Z2zatMlISUkxrrnmGlOxJ3Ul3f2w/lErv6OUz/xLBT15R3XaHUJSmHxVwO4QkkJZ1i/tDiEp3D6ky+4QHK+9M6z8Sf+vT1++cvbsWZ1sDemd5tHy+2Kv1ts7wsqf/P8UCATk9/sj+y9URXfbtGmTFi9erM997nNKTU3VpEmTtGDBAjU3N5u6ZlIn6e6WQ0paGkn6MlIHf2x3CElhUMYgu0NICoN9qXaHkBT8Q1iba1YipiwzfB5l+GK/Tljnx/r9/h5J+lLGjh2rvXv3qqurS+3t7brqqqt055136vOf/7yp8UmdpAEAMCtkhBUyrI2P1ZAhQzRkyBB98MEHqq+v1z/90z+ZGkeSBgC4QliGwoo9S8cytr6+XoZhaNy4cXr77bf1rW99SwUFBaqoqDA1nl4MAAB9pK2tTZWVlSooKNDdd9+tm2++WfX19Ro4cKCp8VTSAABXCCus2BvWimn0HXfcoTvuuCPma5KkAQCuEDIMhSw8v8vK2FjR7gYAwKGopAEArmDHwjGrSNIAAFcIy1AoyZI07W4AAByKShoA4Aq0uwEAcChWdwMAgLihkgYAuEL4k83K+EQjSQMAXCFkcXW3lbGxIkkDAFwhZMjiW7DiF4tZzEkDAOBQVNIAAFdgThoAAIcKy6OQPJbGJxrtbgAAHIpKGgDgCmHj/GZlfKKRpAEArhCy2O62MjZWtLsBAHAoKmkAgCskYyVNkgYAuELY8ChsWFjdbWFsrGh3AwDgUFTSAABXoN0NAIBDhZSikIUGciiOsZhFkgYAuIJhcU7aYE4aAAB0o5IGALhCMs5JO6aSXrVqlTwej6qqquwOBQDQD4WMFMtbojkiSTc2Nmr9+vUqLCy0OxQAABzD9iTd2dmphQsX6plnntGwYcPsDgcA0E+F5VFYKRY2F7a7KysrVVZWppKSksseGwwG1d7e3mMDAMCM7jlpK1ui2bpwbPPmzTp06JAaGxtNHV9TU6OHH364j6MCAMAZbKukA4GA7r//fj3//PNKS0szNWbZsmVqa2uLbIFAoI+jBAD0F8m4cMy2Srq5uVmtra2aNGlSZF8oFNK+ffu0du1aBYNBpaam9hjj9Xrl9XoTHSoAoB84Pydt4QUbbmp3z5o1S4cPH+6xr6KiQgUFBXrwwQd7JWgAANzGtiTt8/k0ceLEHvuGDBmi4cOH99oPAIBVYYvP7g7LiGM05ti+uhsAgERI9Jx0KBTSd7/7XY0ZM0bp6ekaO3asHn30URmG+WTvqMeCNjQ02B0CAKCf6r7fOfbx0VXSTzzxhGpra/Xcc89pwoQJampqUkVFhTIzM7V06VJT53BUkgYAoL/47//+b82bN09lZWWSpNGjR+tHP/qRDh48aPoctLsBAK4QMjyWN0m9HqoVDAYveL2bbrpJu3fv1q9//WtJ0v/8z/9o//79Ki0tNR0zlTQAwBVCFheOhT5pd+fm5vbYv2LFCq1cubLX8Q899JDa29tVUFCg1NRUhUIhPfbYY1q4cKHpa5KkAQCIQiAQkN/vj3y+2PM7XnjhBT3//POqq6vThAkT1NLSoqqqKuXk5Ki8vNzUtUjSAABXCBspClt4alj4k1XZfr+/R5K+mG9961t66KGH9JWvfEWSdO211+qdd95RTU0NSRoAgE+LV7vbrA8//FApKT2vl5qaqnA4bPocJGkAAPrA3Llz9dhjjykvL08TJkzQG2+8oSeffFKLFy82fQ6SNADAFcJSZIV2rOOj8a//+q/67ne/q3vvvVetra3KycnRPffco+XLl5s+B0kaAOAK1h9mEt1Yn8+n1atXa/Xq1TFfk/ukAQBwKCppAIArWH0ntKveJw0AQCLxPmkAABwqGStp5qQBAHAoKmkAgCtYf5gJc9IAAPSJsOFR2Mp90hbGxop2NwAADkUlDQBwhbDFdreVB6HEiiQNAHAF62/BYnU3AAD4BJU0AMAVQvIoZOGBJFbGxookDQBwBdrdAAAgbqikAQCuEJK1lnUofqGYRpIGALhCMra7SdIAAFfgBRsAACBuqKQBAK5gWHyftMEtWAAA9A3a3QAAIG76RSU9JJCiVC//3riUTvnsDiEpHFSe3SGgX3nD7gAc78OuxN3YlIyvquwXSRoAgMsJWXwLlpWxsaL8BADAoaikAQCuQLsbAACHCitFYQsNZCtjY0W7GwAAh6KSBgC4QsjwKGShZW1lbKxI0gAAV2BOGgAAhzIsvgXL4IljAACgG5U0AMAVQvIoZOElGVbGxookDQBwhbBhbV45bMQxGJNodwMA4FBU0gAAVwhbXDhmZWysqKQBAK4QlsfyFo3Ro0fL4/H02iorK02fg0oaAIA+0NjYqFDoT6/iPHLkiGbPnq0vf/nLps9BkgYAuEKinzg2YsSIHp9XrVqlsWPHasaMGabPQZIGALiCnXPSZ8+e1X/8x3+ourpaHo/5ZE+SBgAgCu3t7T0+e71eeb3eS4555ZVX9Mc//lGLFi2K6losHAMAuEJYnsjzu2PaPlk4lpubq8zMzMhWU1Nz2Ws/++yzKi0tVU5OTlQxU0kDAFzBiGGF9mfHS1IgEJDf74/sv1wV/c477+j111/Xyy+/HPU1SdIAAFeI11uw/H5/jyR9ORs2bFB2drbKysqivibtbgAA+kg4HNaGDRtUXl6uAQOir4uppAEArmDH6u7XX39dv/vd77R48eKYrkmSBgC4Qrza3dGYM2eODCP2N3PQ7gYAwKGopAEArhDL87c/Oz7RSNIAAFewo91tFe1uAAAcikoaAOAKyVhJk6QBAK6QjEmadjcAAA5FJQ0AcAUq6SjV1taqsLAw8hzU4uJi7dixw86QAAD9lKE/3YYVyxb7I0liZ2slPWrUKK1atUpf+MIXZBiGnnvuOc2bN09vvPGGJkyYYGdoAIB+JhkraVuT9Ny5c3t8fuyxx1RbW6sDBw6QpAEArueYOelQKKQXX3xRXV1dKi4uvuAxwWBQwWAw8rm9vT1R4QEAkhyVdAwOHz6s4uJinTlzRhkZGdq6davGjx9/wWNramr08MMPJzhCAEB/kIxJ2vZbsMaNG6eWlhb94he/0De+8Q2Vl5frf//3fy947LJly9TW1hbZAoFAgqMFACBxbK+kBw0apKuvvlqSNHnyZDU2NmrNmjVav359r2O9Xq+8Xm+iQwQA9APJWEnbnqQ/KxwO95h3BgAgHgzDI8NCorUyNla2Jully5aptLRUeXl56ujoUF1dnRoaGlRfX29nWAAAOIKtSbq1tVV33323Tpw4oczMTBUWFqq+vl6zZ8+2MywAQD/E+6Sj9Oyzz9p5eQCAiyTjnLTtq7sBAMCFOW7hGAAAfYGFYwAAOFQytrtJ0gAAV0jGSpo5aQAAHIpKGgDgCobFdjdz0gAA9BFDkmFYG59otLsBAHAoKmkAgCuE5ZGHJ44BAOA8rO4GAABxQyUNAHCFsOGRh4eZAADgPIZhcXW3Dcu7aXcDAOBQVNIAAFdIxoVjJGkAgCskY5Km3Q0AcIXut2BZ2aL13nvv6a677tLw4cOVnp6ua6+9Vk1NTabHU0kDANAHPvjgA02bNk233HKLduzYoREjRujYsWMaNmyY6XOQpAEArpDo1d1PPPGEcnNztWHDhsi+MWPGRHUO2t0AAFc4n6Q9FrborveTn/xEU6ZM0Ze//GVlZ2frhhtu0DPPPBPVOUjSAABEob29vccWDAYveNxvf/tb1dbW6gtf+ILq6+v1jW98Q0uXLtVzzz1n+lokaQCAK1irov+0Mjw3N1eZmZmRraam5oLXC4fDmjRpkh5//HHdcMMN+tu//Vt9/etf19NPP206ZuakAQCuYMjaO6G7xwYCAfn9/sh+r9d7weOvuuoqjR8/vse+P/uzP9OPf/xj09ckSQMAEAW/398jSV/MtGnTdPTo0R77fv3rXys/P9/0tUjSAABXSPTDTL75zW/qpptu0uOPP6477rhDBw8e1A9/+EP98Ic/NH0O5qQBAO5gxGGLQlFRkbZu3aof/ehHmjhxoh599FGtXr1aCxcuNH0OKmkAgDtYrKQVw9jbb79dt99+e8yXpJIGAMChqKQBAK6QjO+TJkkDAFwhGd+C1S+StO93IQ0YGLI7DIdLtTuApNApn90hJIWDyrM7BPQTZzvPSjpsdxiO1S+SNAAAl2V4Ylr81WN8gpGkAQCukIxz0qzuBgDAoaikAQDuEK+HdycQSRoA4ArJuLqbdjcAAA5FJQ0AcA8bWtZWkKQBAK6QjO1ukjQAwB2ScOEYc9IAADgUlTQAwCU8n2xWxicWSRoA4A60uwEAQLxQSQMA3CEJK2mSNADAHZLwLVi0uwEAcCgqaQCAKyTjqypJ0gAAd0jCOWna3QAAOBSVNADAHZJw4RhJGgDgCh7j/GZlfKKRpAEA7sCcNAAAiBcqaQCAOzAnDQCAQ9HuBgAA8UIlDQBwhySspEnSAAB3SMIkTbsbAACHopIGALgDq7sBAHCmZHziGO1uAAAcytYkXVNTo6KiIvl8PmVnZ2v+/Pk6evSonSEBAPorIw5bFFauXCmPx9NjKygoiOoctibpvXv3qrKyUgcOHNCuXbv08ccfa86cOerq6rIzLAAA4mLChAk6ceJEZNu/f39U422dk965c2ePzxs3blR2draam5s1ffp0m6ICAPRHHlmck45hzIABA3TllVfGfE1TSfqv/uqvTAcye/ZszZ07N6Zg2traJElZWVkX/D4YDCoYDEY+t7e3x3QdAABi9dnc4/V65fV6L3jssWPHlJOTo7S0NBUXF6umpkZ5eXmmr2Wq3Z2ZmXnZLT09XceOHdOdd96p5cuXmw6gWzgcVlVVlaZNm6aJEyde8Jiampoe18zNzY36OgAAl+q+BcvKJik3N7dHLqqpqbng5aZOnaqNGzdq586dqq2t1fHjx/XFL35RHR0dpkM2VUlv2LDB9Am3b9+ue++9V4888ojpMZJUWVmpI0eOXLJfv2zZMlVXV0c+t7e3k6gBAObE6YljgUBAfr8/svtiVXRpaWnkfxcWFmrq1KnKz8/XCy+8oK9+9aumLhn3Oembb75ZU6ZMiWrMkiVLtH37du3bt0+jRo266HGXaikAAJAIfr+/R5I2a+jQobrmmmv09ttvmx4T99XdQ4cO1csvv2zqWMMwtGTJEm3dulV79uzRmDFj4h0OAADnJfgWrM/q7OzUb37zG1111VWmx9i6uruyslJ1dXXatm2bfD6fTp48KUmROW4AAOIl0U8ce+CBBzR37lzl5+fr/fff14oVK5SamqoFCxaYPoetSbq2tlaSNHPmzB77N2zYoEWLFiU+IAAA4uTdd9/VggUL9Ic//EEjRozQzTffrAMHDmjEiBGmz2FrkjYMGx6ECgBwpwS/qnLz5s0WLnYeL9gAALgD75MGAADxQiUNAHCFZHxVJUkaAOAOn3pqWMzjE4wkDQBwB+akAQBAvFBJAwBcgTlpAACcinY3AACIFyppAIA7WGx321FJk6QBAO5AuxsAAMQLlTQAwB2SsJImSQMAXCEZb8Gi3Q0AgEORpAEAcCja3QAAd2BOGgAAZ2JOGgAAxA2VNADAPWyohq0gSQMA3CEJ56RpdwMA4FBU0gAAV0jGhWMkaQCAO9DuBgAA8UIlDQBwBdrdAAA4Fe1uAAAQL1TSAAB3SMJKmiQNAHAF5qRt4nu7TQNSz9gdhsMNtTuAJJFqdwBJoVM+u0NICgeVZ3cIjhf6MJi4iyVhJc2cNAAADtUvKmkAAC4rCStpkjQAwBWScU6adjcAAA5FkgYAuIMRhy1Gq1atksfjUVVVVVTjaHcDAFzBrnZ3Y2Oj1q9fr8LCwqjHUkkDANBHOjs7tXDhQj3zzDMaNmxY1ONJ0gAAd4hTu7u9vb3HFgxe/F7vyspKlZWVqaSkJKaQSdIAAHeIU5LOzc1VZmZmZKupqbng5TZv3qxDhw5d9HszmJMGACAKgUBAfr8/8tnr9V7wmPvvv1+7du1SWlpazNciSQMAXMHzyWZlvCT5/f4eSfpCmpub1draqkmTJkX2hUIh7du3T2vXrlUwGFRq6uUfQ0ySBgC4QwKfODZr1iwdPny4x76KigoVFBTowQcfNJWgJZI0AMAlEnkLls/n08SJE3vsGzJkiIYPH95r/6WwcAwAAIeikgYAuIPNL9hoaGiIegxJGgDgHja8JMMK2t0AADgUlTQAwBWS8VWVJGkAgDvYPCcdC9rdAAA4FJU0AMAVaHcDAOBUtLsBAEC8UEkDAFyBdjcAAE6VhO1ukjQAwB2SMEkzJw0AgENRSQMAXIE5aQAAnIp2NwAAiBcqaQCAK3gMQx4j9nLYythYkaQBAO5Auzs6+/bt09y5c5WTkyOPx6NXXnnFznAAAHAUW5N0V1eXrrvuOq1bt87OMAAALtC9utvKlmi2trtLS0tVWlpqZwgAALdIwnZ3Us1JB4NBBYPByOf29nYbowEAoG8l1S1YNTU1yszMjGy5ubl2hwQASBLJ2O5OqiS9bNkytbW1RbZAIGB3SACAZGHEYUuwpGp3e71eeb1eu8MAACShZHwsaFJV0gAAuImtlXRnZ6fefvvtyOfjx4+rpaVFWVlZysvLszEyAEC/w+ru6DQ1NemWW26JfK6urpYklZeXa+PGjTZFBQDor+xoWVtha5KeOXOmDBuehQoAQDJIqoVjAADEzDDOb1bGJxhJGgDgCqzuBgAAcUMlDQBwB1Z3AwDgTJ7w+c3K+ESj3Q0AgENRSQMA3CEJ291U0gAAV0j0W7Bqa2tVWFgov98vv9+v4uJi7dixI6pzkKQBAO7QfZ+0lS0Ko0aN0qpVq9Tc3Kympibdeuutmjdvnt58803T56DdDQBAH5g7d26Pz4899phqa2t14MABTZgwwdQ5SNIAAFeI18NM2tvbe+w38xrlUCikF198UV1dXSouLjZ9TdrdAAB3MOKwScrNzVVmZmZkq6mpueglDx8+rIyMDHm9Xv3d3/2dtm7dqvHjx5sOmUoaAIAoBAIB+f3+yOdLVdHjxo1TS0uL2tra9NJLL6m8vFx79+41nahJ0gAAV4hXu7t7tbYZgwYN0tVXXy1Jmjx5shobG7VmzRqtX7/e1HiSNADAHRzwFqxwOKxgMGj6eJI0AAB9YNmyZSotLVVeXp46OjpUV1enhoYG1dfXmz4HSRoA4AqJflVla2ur7r77bp04cUKZmZkqLCxUfX29Zs+ebfocJGkAgDsk+LGgzz77rIWLncctWAAAOBSVNADAFRLd7o4HkjQAwB3CxvnNyvgEI0kDANyBV1UCAIB4oZIGALiCRxbnpOMWiXkkaQCAOzjgiWPRot0NAIBDUUkDAFyBW7AAAHAqVncDAIB4oZIGALiCxzDksbD4y8rYWPWLJB361TF5PAPtDsPRfBpndwhJYqjdASSJVLsDSAqd8tkdguOFzyTw7+7wJ5uV8QlGuxsAAIfqF5U0AACXQ7sbAACnSsLV3SRpAIA78MQxAAAQL1TSAABX4IljAAA4Fe1uAAAQL1TSAABX8ITPb1bGJxpJGgDgDrS7AQBAvFBJAwDcgYeZAADgTMn4WFDa3QAAOBSVNADAHZJw4RhJGgDgDoasvROaOWkAAPoGc9IAACBuqKQBAO5gyOKcdNwiMY0kDQBwhyRcOEa7GwAAh6KSBgC4Q1iSx+L4BKOSBgC4QvfqbitbNGpqalRUVCSfz6fs7GzNnz9fR48ejeocJGkAAPrA3r17VVlZqQMHDmjXrl36+OOPNWfOHHV1dZk+B+1uAIA7JHjh2M6dO3t83rhxo7Kzs9Xc3Kzp06ebOgdJGgDgDjav7m5ra5MkZWVlmR5DkgYAIArt7e09Pnu9Xnm93kuOCYfDqqqq0rRp0zRx4kTT12JOGgDgDt2VtJVNUm5urjIzMyNbTU3NZS9dWVmpI0eOaPPmzVGFTCUNAHCHON2CFQgE5Pf7I7svV0UvWbJE27dv1759+zRq1KioLkmSBgC4QrxesOH3+3sk6YsxDEP33Xeftm7dqoaGBo0ZMybqa5KkAQDoA5WVlaqrq9O2bdvk8/l08uRJSVJmZqbS09NNncMRc9Lr1q3T6NGjlZaWpqlTp+rgwYN2hwQA6G/iNCdtVm1trdra2jRz5kxdddVVkW3Lli2mz2F7Jb1lyxZVV1fr6aef1tSpU7V69WrddtttOnr0qLKzs+0ODwDQX4QNyWPhNqpwdGONOLyQw/ZK+sknn9TXv/51VVRUaPz48Xr66ac1ePBg/du//ZvdoQEAYCtbk/TZs2fV3NyskpKSyL6UlBSVlJTo5z//uY2RAQD6nQS3u+PB1nb373//e4VCIY0cObLH/pEjR+qtt97qdXwwGFQwGIx8/uwN5QAAXJzVRMv7pC+ppqamxw3kubm5docEAECfsTVJX3HFFUpNTdWpU6d67D916pSuvPLKXscvW7ZMbW1tkS0QCCQqVABAskvCdretSXrQoEGaPHmydu/eHdkXDoe1e/duFRcX9zre6/VGbiI3ezM5AACSzq/OtrolmO23YFVXV6u8vFxTpkzRjTfeqNWrV6urq0sVFRV2hwYAgK1sT9J33nmnTp8+reXLl+vkyZO6/vrrtXPnzl6LyQAAsMQIn9+sjE8w25O0dP7h40uWLLE7DABAf2bz+6Rj4YgkDQBAnwsbsnQblQ1z0kl1CxYAAG5CJQ0AcAfa3QAAOJQhi0k6bpGYRrsbAACHopIGALgD7W4AABwqHJZk4V7ncOLvk6bdDQCAQ1FJAwDcgXY3AAAOlYRJmnY3AAAORSUNAHCHJHwsKEkaAOAKhhGWYeFNVlbGxookDQBwB8OwVg0zJw0AALpRSQMA3MGwOCfNLVgAAPSRcFjyWJhXtmFOmnY3AAAORSUNAHAH2t0AADiTEQ7LsNDutuMWLNrdAAA4FJU0AMAdaHcDAOBQYUPyJFeSpt0NAIBDUUkDANzBMCRZuU+adjcAAH3CCBsyLLS7DdrdAAD0ESNsfYvCvn37NHfuXOXk5Mjj8eiVV16JOmSSNAAAfaCrq0vXXXed1q1bF/M5aHcDAFwh0e3u0tJSlZaWxnw9iSQNAHALIyxrC8cS/8SxpE7S3f+qOaePLd2f7gZGKGh3CEnh3Mdn7A4hKYSCqXaHkBTCZxL/l3qyCZ85/99cIhZlWc0V5/SxJKm9vb3Hfq/XK6/XayW0i0rqJN3R0SFJ2q/XbI4kCfzK7gCSBL8TYIuOjg5lZmb2ybkHDRqkK6+8UvtPWs8VGRkZys3N7bFvxYoVWrlypeVzX0hSJ+mcnBwFAgH5fD55PB67w5F0/l9Yubm5CgQC8vv9dofjWPxO5vA7mcPvZI4TfyfDMNTR0aGcnJw+u0ZaWpqOHz+us2fPWj6XYRi98k1fVdFSkifplJQUjRo1yu4wLsjv9zvmPwIn43cyh9/JHH4nc5z2O/VVBf1paWlpSktL6/PrxFtSJ2kAAJyqs7NTb7/9duTz8ePH1dLSoqysLOXl5Zk6B0kaAIA+0NTUpFtuuSXyubq6WpJUXl6ujRs3mjoHSTrOvF6vVqxY0adzFP0Bv5M5/E7m8DuZw++UWDNnzrS8at1j2PEwUgAAcFk8FhQAAIciSQMA4FAkaQAAHIokDQCAQ5Gk42zdunUaPXq00tLSNHXqVB08eNDukBwlHu9XdYOamhoVFRXJ5/MpOztb8+fP19GjR+0Oy3Fqa2tVWFgYeThHcXGxduzYYXdYjrZq1Sp5PB5VVVXZHQpMIEnH0ZYtW1RdXa0VK1bo0KFDuu6663TbbbeptbXV7tAcIx7vV3WDvXv3qrKyUgcOHNCuXbv08ccfa86cOerq6rI7NEcZNWqUVq1apebmZjU1NenWW2/VvHnz9Oabb9odmiM1NjZq/fr1KiwstDsUmMQtWHE0depUFRUVae3atZKkcDis3Nxc3XfffXrooYdsjs55PB6Ptm7dqvnz59sdiuOdPn1a2dnZ2rt3r6ZPn253OI6WlZWl73//+/rqV79qdyiO0tnZqUmTJumpp57S9773PV1//fVavXq13WHhMqik4+Ts2bNqbm5WSUlJZF9KSopKSkr085//3MbI0B+0tbVJOp+AcGGhUEibN29WV1eXiouL7Q7HcSorK1VWVtbj7yg4H08ci5Pf//73CoVCGjlyZI/9I0eO1FtvvWVTVOgPwuGwqqqqNG3aNE2cONHucBzn8OHDKi4u1pkzZ5SRkaGtW7dq/PjxdoflKJs3b9ahQ4fU2NhodyiIEkkacLjKykodOXJE+/fvtzsURxo3bpxaWlrU1taml156SeXl5dq7dy+J+hOBQED333+/du3alZRvgXI7knScXHHFFUpNTdWpU6d67D916pSuvPJKm6JCsluyZIm2b9+uffv2Ofa1rHYbNGiQrr76aknS5MmT1djYqDVr1mj9+vU2R+YMzc3Nam1t1aRJkyL7QqGQ9u3bp7Vr1yoYDCo1NdXGCHEpzEnHyaBBgzR58mTt3r07si8cDmv37t3MjyFqhmFoyZIl2rp1q/bs2aMxY8bYHVLSCIfDCgaDdofhGLNmzdLhw4fV0tIS2aZMmaKFCxeqpaWFBO1wVNJxVF1drfLyck2ZMkU33nijVq9era6uLlVUVNgdmmPE4/2qblBZWam6ujpt27ZNPp9PJ0+elCRlZmYqPT3d5uicY9myZSotLVVeXp46OjpUV1enhoYG1dfX2x2aY/h8vl5rGYYMGaLhw4ezxiEJkKTj6M4779Tp06e1fPlynTx5Utdff7127tzZazGZm8Xj/apuUFtbK+n8q+4+bcOGDVq0aFHiA3Ko1tZW3X333Tpx4oQyMzNVWFio+vp6zZ492+7QgLjgPmkAAByKOWkAAByKJA0AgEORpAEAcCiSNAAADkWSBgDAoUjSAAA4FEkaAACHIkkDAOBQJGnAwRYtWqT58+fbHQYAm5CkAQBwKJI0AAAORZIGAMChSNIAADgUSRoAAIciSQMA4FAkaQAAHIokDQCAQ5GkAQBwKI9hGIbdQQAAgN6opAEAcCiSNAAADkWSBgDAoUjSAAA4FEkaAACHIkkDAOBQJGkAAByKJA0AgEORpAEAcCiSNAAADkWSBgDAoUjSAAA41P8HkLT5AISU2sgAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1239,7 +1242,7 @@ "\n", "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", "\n", - "qty_out = Quantity(data=np.zeros([nx, ny, nz]),\n", + "qty_out = Quantity(data=np.zeros(shape),\n", " dims=[\"I\", \"J\", \"K\"],\n", " units=\"m\",\n", " gt4py_backend=backend\n", @@ -1257,7 +1260,7 @@ "print(\"Plotting values of qty_out at K = 0\")\n", "plot_field_at_kN(qty_out.data)\n", "print(\"Executing 'field_plus_one'\")\n", - "field_plus_one(qty_in.data, qty_out.data)\n", + "field_plus_one(qty_in, qty_out)\n", "print(\"Plotting values of qty_out at K = 0 after executing 'field_plus_one'\")\n", "plot_field_at_kN(qty_out.data)" ] diff --git a/examples/NDSL/02_NDSL_basics.ipynb b/examples/NDSL/02_NDSL_basics.ipynb new file mode 100644 index 00000000..0af2dfd5 --- /dev/null +++ b/examples/NDSL/02_NDSL_basics.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **NDSL Basics** #\n", + "\n", + "### **Introduction**\n", + "After establishing the basics of using GT4Py, we'll take a look at developing an object-oriented coding approach with the NDSL middleware. Much of the object-oriented work comes from the development of [Pace](https://github.com/NOAA-GFDL/pace), the implementation of the FV3GFS / SHiELD atmospheric model using GT4Py and [DaCe](https://github.com/spcl/dace). The `StencilFactory` object will be introduced and demoed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Creating the `StencilFactory` object**\n", + "\n", + "The `StencilFactory` object enables the sharing of stencil properties across multiple stencils as well as \"build and execute\" the stencil. To help ease the introduction, the [`boilerplate` module](./boilerplate.py) contains a function `get_one_tile_factory` that takes the domain size, halo size, and backend of interest and returns a `StencilFactory` object. For more details about the objects needed to create the `StencilFactory`, the reader can view the [`get_one_tile_factory`](./boilerplate.py#get_one_tile_factory) function." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-05-13 10:10:20|INFO|rank 0|ndsl.logging:Constant selected: ConstantVersions.GFS\n" + ] + }, + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from boilerplate import get_one_tile_factory, plot_field_at_k0\n", + "from ndsl import StencilFactory\n", + "\n", + "nx = 6\n", + "ny = 6\n", + "nz = 1\n", + "nhalo = 1\n", + "backend=\"numpy\"\n", + "\n", + "stencil_factory: StencilFactory = get_one_tile_factory(nx, ny, nz, nhalo, backend)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Creating the Copy stencil**\n", + "\n", + "The `NDSL` and `gt4py` module contain key terms that will be used to create the stencil. Many terms are covered in the [GT4Py basic tutorial](./01_basics.ipynb) notebook, but we'll briefly recap.\n", + "\n", + "- `FloatField` : This type can generally can be thought of as a `gt4py` 3-dimensional `numpy` array of floating point values.\n", + "\n", + "- `computation(PARALLEL)` : This keyword combination means that there is no assumed order to perform calcuations in the `k` (3rd) dimension of a `gt4py` storage. `PARALLEL` can be replaced by `FORWARD` or `BACKWARD` for serialized calculations in the `k` dimension.\n", + "\n", + "- `interval(...)` : This keyword specifies the range of computation in the `k` dimension.\n", + "\n", + "The code below contains the Copy stencil implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from ndsl.dsl.typing import FloatField\n", + "from gt4py.cartesian.gtscript import PARALLEL, computation, interval\n", + "\n", + "def copy_field_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that a decorator does not surround this stencil as shown before in the [basic tutorial](./01_basics.ipynb). Instead, we'll use the `StencilFactory` to \"initiate\" the stencil." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Creating a class that performs a stencil computation**\n", + "\n", + "Using the `StencilFactory` object created earlier, the code will now create a class `CopyField` that takes `copy_field_stencil` and defines the computation domain from the parameters `origin` and `domain` within `__init__`. `origin` indicates the \"starting\" point of the stencil calculation, and `domain` indicates the extent of the stencil calculation in the 3 dimensions. Note that when creating `stencil_factory`, a 6 by 6 by 1 sized domain surrounded with a halo layer of size 1 was defined (see the initialization of `grid_indexing` at [boilerplate.py](./boilerplate.py#get_one_tile_factory)). Thus, whenever a `CopyField` object is created, it will perform calcuations within the 6 by 6 by 1 domain (specified by `domain=grid_indexing.domain_compute()`), and the 'origin' will start at the `[0,0,0]` location of the 6 by 6 by 1 grid (specified by `origin=grid_indexing.origin_compute()`)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class CopyField:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field = stencil_factory.from_origin_domain(\n", + " copy_field_stencil, # <-- gt4py stencil function wrapped into NDSL\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__( # <-- Runtime path\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field(field_in, field_out)\n", + " \n", + " \n", + "copy_field = CopyField(stencil_factory)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Allocating Data in `NDSL`**\n", + "\n", + "The next code section will create arrays using `Quantity`. For more information about `Quantity`, see the [GT4Py Basic tutorial](./01_gt4py_basics.ipynb#Copy_Stencil_example)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting qty_in at K = 0\n", + "Min and max values: 14.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting qty_out at K = 0\n", + "Min and max values: 0.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## Change this to Quantity\n", + "\n", + "import gt4py.storage as gt_storage\n", + "from ndsl.quantity import Quantity\n", + "import numpy as np\n", + "\n", + "size = (nx + 2 * nhalo) * (ny + 2 * nhalo) * nz\n", + "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", + "\n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "\n", + "\n", + "\n", + "arr = np.indices(shape,dtype=float).sum(axis=0) # Value of each entry is sum of the I and J index at each point\n", + "\n", + "qty_in = Quantity(data=arr,\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend)\n", + "\n", + "print(\"Plotting qty_in at K = 0\")\n", + "plot_field_at_k0(qty_in.data)\n", + "print(\"Plotting qty_out at K = 0\")\n", + "plot_field_at_k0(qty_out.data)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Calling `copy_field` stencil**\n", + "\n", + "The code will call `copy_field` to execute `copy_field_stencil` using the previously defined `Quantity` data containers and plot the result at `k = 0`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Copying copy_field stencil\n", + "Plotting qty_out at K = 0\n", + "Min and max values: 12.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Copying copy_field stencil\")\n", + "copy_field(qty_in, qty_out)\n", + "print(\"Plotting qty_out at K = 0\")\n", + "plot_field_at_k0(qty_out.data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the plot, we see that the copy is only applied to the inner 6 by 6 area and not the entire domain. The stencil in this case only applies in this \"domain\" and not the \"halo\" region surrounding the domain." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Applying a J offset**\n", + "\n", + "The next example will create a stencil that takes a `Quantity` as an input, shift the input by 1 in the `-j` direction, and write it to an output `Quantity`. This stencil is defined in `copy_field_offset_stencil`.\n", + "\n", + "Note that in `copy_field_offset_stencil`, the shift in the J dimension is performed by referencing the `J` object from `gt4py.cartesian.gtscript` for simplicity. This reference will apply the shift in J to the entire input domain. Another way to perform the shift without referencing the `J` object is to write `[0,-1,0]` (assuming that the variable being modified is 3-dimensional) instead of `[J-1]`.\n", + "\n", + "With the stencil in place, a class `CopyFieldOffset` is defined using the `StencilFactory` object and `copy_field_offset_stencil`. The class is instantiated and demonstrated to shift `qty_in` by 1 in the J-dimension and write to `qty_out`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialize qty_out to zeros\n" + ] + } + ], + "source": [ + "from gt4py.cartesian.gtscript import J\n", + "\n", + "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in[J-1]\n", + " \n", + "class CopyFieldOffset:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field_offset = stencil_factory.from_origin_domain(\n", + " copy_field_offset_stencil,\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__(\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field_offset(field_in, field_out)\n", + " \n", + "copy_field_offset = CopyFieldOffset(stencil_factory)\n", + " \n", + "qty_out = Quantity(data=np.zeros(shape),\n", + " dims=[\"I\", \"J\", \"K\"],\n", + " units=\"m\",\n", + " gt4py_backend=backend\n", + " )\n", + "\n", + "print(\"Initialize qty_out to zeros\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing copy_field_offset stencil\n", + "Plotting values of qty_out at K = 0\n", + "Min and max values: 11.0 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Executing copy_field_offset stencil\")\n", + "copy_field_offset(qty_in, qty_out)\n", + "print(\"Plotting values of qty_out at K = 0\")\n", + "plot_field_at_k0(qty_out.data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Limits to offset : Cannot set offset outside of usable domain**\n", + "\n", + "Note that when the copy offset by -1 in the j-direction is performed, the 'halo' region at J = 8 is copied over due to the `J` shift. This means that there are limits to the shift amount since choosing a large shift amount may result in accessing a data region that does not exist. The following example shows this by trying to perform a shift by -2 in the j-direction." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_5109/2658447685.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mcopy_field_offset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mcopy_field_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqty_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqty_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/tmp/ipykernel_5109/2658447685.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFloatField\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m ):\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_copy_field_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mcopy_field_offset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 418\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__debug__\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m\"domain\"\u001b[0m \u001b[0;32min\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[1;32m 419\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"domain cannot be passed to FrozenStencil call\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 420\u001b[0;31m self.stencil_object(\n\u001b[0m\u001b[1;32m 421\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 422\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;32m~/Documents/Code/SMT-Nebulae-Tutorial/tutorial/NDSL/.gt_cache_000000/py311_1013/numpy/__main__/copy_field_offset_stencil/m_copy_field_offset_stencil__numpy_d84da3ed67.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, field_in, field_out, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 80\u001b[0;31m self._call_run(\n\u001b[0m\u001b[1;32m 81\u001b[0m \u001b[0mfield_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfield_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_call_run\u001b[0;34m(self, field_args, parameter_args, domain, origin, validate_args, exec_info)\u001b[0m\n\u001b[1;32m 582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidate_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 584\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray_infos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameter_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 585\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_domain_origin_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcache_key\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdomain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_object.py\u001b[0m in \u001b[0;36m_validate_args\u001b[0;34m(self, arg_infos, param_args, domain, origin)\u001b[0m\n\u001b[1;32m 466\u001b[0m )\n\u001b[1;32m 467\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfield_domain_origin\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_origin\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 468\u001b[0;31m raise ValueError(\n\u001b[0m\u001b[1;32m 469\u001b[0m \u001b[0;34mf\"Origin for field {name} too small. Must be at least {min_origin}, is {field_domain_origin}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: Origin for field field_in too small. Must be at least (0, 2, 0), is (1, 1, 0)" + ] + } + ], + "source": [ + "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out = field_in[J-2]\n", + " \n", + "class CopyFieldOffset:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field_offset = stencil_factory.from_origin_domain(\n", + " copy_field_offset_stencil,\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__(\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field_offset(field_in, field_out)\n", + " \n", + "copy_field_offset = CopyFieldOffset(stencil_factory)\n", + "\n", + "copy_field_offset(qty_in, qty_out)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **Example demonstrating error when writing to offset outputs**\n", + "\n", + "While offsets can be applied to all input `Quantity` variables in a stencil, output `Quantity` variables cannot have such offsets. When an offset is applied to an output stencil calcuation, the error `GTScriptSyntaxError: Assignment to non-zero offsets is not supported.` will be displayed." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "GTScriptSyntaxError", + "evalue": "Assignment to non-zero offsets is not supported.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mGTScriptSyntaxError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_15140/416380115.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_copy_field_offset_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfield_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfield_out\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m \u001b[0mcopy_field_offset_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCopyFieldOffsetOutput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstencil_factory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/tmp/ipykernel_15140/416380115.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, stencil_factory)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstencil_factory\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mStencilFactory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mgrid_indexing\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstencil_factory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrid_indexing\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m self._copy_field_offset_output = stencil_factory.from_origin_domain(\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mcopy_field_offset_output_stencil\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrid_indexing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morigin_compute\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\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36mfrom_origin_domain\u001b[0;34m(self, func, origin, domain, externals, skip_passes)\u001b[0m\n\u001b[1;32m 910\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 911\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFrozenStencil\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 912\u001b[0;31m return cls(\n\u001b[0m\u001b[1;32m 913\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morigin\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/NDSL/ndsl/dsl/stencil.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, func, origin, domain, stencil_config, externals, skip_passes, timing_collector, comm)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0mblock_waiting_for_compilation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mMPI\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCOMM_WORLD\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompilation_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m self.stencil_object = gtscript.stencil(\n\u001b[0m\u001b[1;32m 364\u001b[0m \u001b[0mdefinition\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36mstencil\u001b[0;34m(backend, definition, build_info, dtypes, externals, format_source, name, rebuild, cache_settings, raise_if_not_cached, **kwargs)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_decorator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 319\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_decorator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 320\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/gtscript.py\u001b[0m in \u001b[0;36m_decorator\u001b[0;34m(definition_func)\u001b[0m\n\u001b[1;32m 304\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 305\u001b[0m \u001b[0moriginal_annotations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_set_arg_dtypes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m \u001b[0;32mor\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\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m out = gt_loader.gtscript_loader(\n\u001b[0m\u001b[1;32m 307\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 308\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mgtscript_loader\u001b[0;34m(definition_func, backend, build_options, externals, dtypes)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"{definition_func.__name__}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 75\u001b[0;31m stencil_class = load_stencil(\n\u001b[0m\u001b[1;32m 76\u001b[0m \u001b[0;34m\"gtscript\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefinition_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuild_options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m )\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/loader.py\u001b[0m in \u001b[0;36mload_stencil\u001b[0;34m(frontend_name, backend_name, definition_func, externals, dtypes, build_options)\u001b[0m\n\u001b[1;32m 58\u001b[0m )\n\u001b[1;32m 59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 60\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mbuild\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;34mf\"The stencil {self._definition.__name__} is not up to date in the cache\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m )\n\u001b[0;32m---> 93\u001b[0;31m \u001b[0mstencil_class\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mstencil_class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_impl_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"disable-code-generation\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0msrc_dir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparents\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexist_ok\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;32m--> 110\u001b[0;31m \u001b[0mrecursive_write\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_computation\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\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_module\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mgenerate_computation\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mignore_np_errstate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_opts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ignore_np_errstate\"\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;32m---> 95\u001b[0;31m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNpirCodegen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnpir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mignore_np_errstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_source\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0msource\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat_source\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"python\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36mnpir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gtcnumpy:npir\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_backend_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_npir\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\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackend_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/backend/numpy_backend.py\u001b[0m in \u001b[0;36m_make_npir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_make_npir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mnpir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 114\u001b[0;31m \u001b[0mbase_oir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTIRToOIR\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 115\u001b[0m oir_pipeline = self.builder.options.backend_opts.get(\n\u001b[1;32m 116\u001b[0m \u001b[0;34m\"oir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mgtir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStencil\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgtir_pipeline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 292\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/stencil_builder.py\u001b[0m in \u001b[0;36mgtir_pipeline\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;34m\"gtir_pipeline\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 283\u001b[0m GtirPipeline(\n\u001b[0;32m--> 284\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrontend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 285\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstencil_id\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 286\u001b[0m ),\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(cls, definition, externals, dtypes, options)\u001b[0m\n\u001b[1;32m 2124\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprepare_stencil_definition\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2125\u001b[0m \u001b[0mtranslator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGTScriptParser\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefinition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexternals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexternals\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtypes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m \u001b[0mdefinition_ir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtranslator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2128\u001b[0m \u001b[0;31m# GTIR only supports LatLonGrids\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2058\u001b[0m \u001b[0;31m# Generate definition IR\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2059\u001b[0m \u001b[0mdomain\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLatLonGrid\u001b[0m\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;32m-> 2060\u001b[0;31m computations = IRMaker(\n\u001b[0m\u001b[1;32m 2061\u001b[0m \u001b[0mfields\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfields_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2062\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparameter_decls\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, ast_root)\u001b[0m\n\u001b[1;32m 780\u001b[0m \u001b[0mfunc_ast\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mast_root\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\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\u001b[0m\n\u001b[1;32m 781\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 782\u001b[0;31m \u001b[0mcomputations\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc_ast\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 783\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcomputations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\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;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_FunctionDef\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1595\u001b[0m \u001b[0mblocks\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\u001b[0m\n\u001b[1;32m 1596\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mast\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAnnAssign\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\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;32m-> 1597\u001b[0;31m \u001b[0mblocks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1598\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1599\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mComputationBlock\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mitem\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mblocks\u001b[0m\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;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\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;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_With\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1587\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcompute_blocks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1588\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1589\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_visit_computation_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1590\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1591\u001b[0m \u001b[0;31m# Mixing nested `with` blocks with stmts not allowed\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36m_visit_computation_node\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 977\u001b[0m \u001b[0mstmts\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\u001b[0m\n\u001b[1;32m 978\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstmt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 979\u001b[0;31m \u001b[0mstmts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgtc_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstmt\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\u001b[0m\n\u001b[0m\u001b[1;32m 980\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparsing_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParsingContext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCONTROL_FLOW\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 981\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/Code/SMT-Nebulae/sw_stack_path/install/python3/lib/python3.11/ast.py\u001b[0m in \u001b[0;36mvisit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 416\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'visit_'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 417\u001b[0m \u001b[0mvisitor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgeneric_visit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 418\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mvisitor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 420\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgeneric_visit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode\u001b[0m\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;32m~/Documents/Code/Python_venv/gt4py_jupyter/lib/python3.11/site-packages/gt4py/cartesian/frontend/gtscript_frontend.py\u001b[0m in \u001b[0;36mvisit_Assign\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m 1444\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mspatial_offset\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moffset\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0moffset\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mspatial_offset\u001b[0m\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;32m-> 1446\u001b[0;31m raise GTScriptSyntaxError(\n\u001b[0m\u001b[1;32m 1447\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Assignment to non-zero offsets is not supported.\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1448\u001b[0m \u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLocation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_ast_node\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\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;31mGTScriptSyntaxError\u001b[0m: Assignment to non-zero offsets is not supported." + ] + } + ], + "source": [ + "from gt4py.cartesian.gtscript import J\n", + "\n", + "def copy_field_offset_output_stencil(field_in: FloatField, field_out: FloatField):\n", + " with computation(PARALLEL), interval(...):\n", + " field_out[0,1,0] = field_in\n", + " \n", + "class CopyFieldOffsetOutput:\n", + " def __init__(self, stencil_factory: StencilFactory):\n", + " grid_indexing = stencil_factory.grid_indexing\n", + " self._copy_field_offset_output = stencil_factory.from_origin_domain(\n", + " copy_field_offset_output_stencil,\n", + " origin=grid_indexing.origin_compute(),\n", + " domain=grid_indexing.domain_compute(),\n", + " )\n", + "\n", + " def __call__(\n", + " self,\n", + " field_in: FloatField,\n", + " field_out: FloatField,\n", + " ):\n", + " self._copy_field_offset_output(field_in, field_out)\n", + " \n", + "copy_field_offset_output = CopyFieldOffsetOutput(stencil_factory)\n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gt4py_jupyter", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/NDSL/NDSL_basics.ipynb b/examples/NDSL/NDSL_basics.ipynb deleted file mode 100644 index 4757ba68..00000000 --- a/examples/NDSL/NDSL_basics.ipynb +++ /dev/null @@ -1,353 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# **Object-Oriented Stencil Development** #\n", - "\n", - "### **Introduction**\n", - "After establishing the basics of using GT4Py, we'll take a look at developing an object-oriented coding approach with GT4Py. Much of the object-oriented work comes from the development of [Pace](https://github.com/NOAA-GFDL/pace), the implementation of the FV3GFS / SHiELD atmospheric model using GT4Py and [DaCe](https://github.com/spcl/dace). The `StencilFactory` object will be introduced and demoed." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Creating the `StencilFactory` object**\n", - "\n", - "The `StencilFactory` object enables the sharing of stencil properties across multiple stencils as well as \"build and execute\" the stencil. To help ease the introduction, the [`boilerplate` module](./boilerplate.py) contains a function `get_one_tile_factory` that takes the domain size, halo size, and backend of interest and returns a `StencilFactory` object. For more details about the objects needed to create the `StencilFactory`, the reader can view the [`get_one_tile_factory`](./boilerplate.py#get_one_tile_factory) function." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from boilerplate import get_one_tile_factory, plot_field_at_k0\n", - "from ndsl import StencilFactory\n", - "\n", - "nx = 6\n", - "ny = 6\n", - "nz = 1\n", - "nhalo = 1\n", - "backend=\"numpy\"\n", - "\n", - "stencil_factory: StencilFactory = get_one_tile_factory(nx, ny, nz, nhalo, backend)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Creating the Copy stencil**\n", - "\n", - "The `NDSL` and `gt4py` module contain key terms that will be used to create the stencil. Many terms are covered in the [GT4Py basic tutorial](./01_basics.ipynb) notebook, but we'll briefly recap.\n", - "\n", - "- `FloatField` : This type can generally can be thought of as a `gt4py` 3-dimensional `numpy` array of floating point values.\n", - "\n", - "- `computation(PARALLEL)` : This keyword combination means that there is no assumed order to perform calcuations in the `k` (3rd) dimension of a `gt4py` storage. `PARALLEL` can be replaced by `FORWARD` or `BACKWARD` for serialized calculations in the `k` dimension.\n", - "\n", - "- `interval(...)` : This keyword specifies the range of computation in the `k` dimension.\n", - "\n", - "The code below contains the Copy stencil implementation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from ndsl.dsl.typing import FloatField\n", - "from gt4py.cartesian.gtscript import PARALLEL, computation, interval\n", - "\n", - "def copy_field_stencil(field_in: FloatField, field_out: FloatField):\n", - " with computation(PARALLEL), interval(...):\n", - " field_out = field_in" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that a decorator does not surround this stencil as shown before in the [basic tutorial](./01_basics.ipynb). Instead, we'll use the `StencilFactory` to \"initiate\" the stencil." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Creating a class that performs a stencil computation**\n", - "\n", - "Using the `StencilFactory` object created earlier, the code will now create a class `CopyField` that takes `copy_field_stencil` and defines the computation domain from the parameters `origin` and `domain` within `__init__`. `origin` indicates the \"starting\" point of the stencil calculation, and `domain` indicates the extent of the stencil calculation in the 3 dimensions. Note that when creating `stencil_factory`, a 6 by 6 by 1 sized domain surrounded with a halo layer of size 1 was defined (see the initialization of `grid_indexing` at [boilerplate.py](./boilerplate.py#get_one_tile_factory)). Thus, whenever a `CopyField` object is created, it will perform calcuations within the 6 by 6 by 1 domain (specified by `domain=grid_indexing.domain_compute()`), and the 'origin' will start at the `[0,0,0]` location of the 6 by 6 by 1 grid (specified by `origin=grid_indexing.origin_compute()`)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "class CopyField:\n", - " def __init__(self, stencil_factory: StencilFactory):\n", - " grid_indexing = stencil_factory.grid_indexing\n", - " self._copy_field = stencil_factory.from_origin_domain(\n", - " copy_field_stencil, # <-- gt4py stencil function wrapped into NDSL\n", - " origin=(0,2,0),#grid_indexing.origin_compute(),\n", - " domain=grid_indexing.domain_compute(),\n", - " )\n", - "\n", - " def __call__( # <-- Runtime path\n", - " self,\n", - " field_in: FloatField,\n", - " field_out: FloatField,\n", - " ):\n", - " self._copy_field(field_in, field_out)\n", - " \n", - " \n", - "copy_field = CopyField(stencil_factory)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Allocating arrays in `gt4py`**\n", - "\n", - "The next code section will create arrays using `gt_storage`. For more information about `gt_storage`, see the [GT4Py Basic tutorial](./01_basics.ipynb#Copy_Stencil_example)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "## Change this to Quantity\n", - "\n", - "import gt4py.storage as gt_storage\n", - "import numpy as np\n", - "\n", - "size = (nx + 2 * nhalo) * (ny + 2 * nhalo) * nz\n", - "shape = (nx + 2 * nhalo, ny + 2 * nhalo, nz)\n", - "\n", - "\n", - "qty_zero = gt_storage.zeros(\n", - " backend=backend,\n", - " dtype=float,\n", - " shape=shape,\n", - ")\n", - "\n", - "qty_out = gt_storage.zeros(\n", - " backend=backend,\n", - " dtype=float,\n", - " shape=shape,\n", - ")\n", - "\n", - "arr = np.zeros(shape)\n", - "qty_in = gt_storage.from_array(\n", - " data=np.indices(shape).sum(axis=0) % 2,\n", - " backend=backend,\n", - " dtype=float,\n", - ")\n", - "\n", - "print(\"Plotting qty_in at K = 0\")\n", - "plot_field_at_k0(qty_in)\n", - "print(\"Plotting qty_out at K = 0\")\n", - "plot_field_at_k0(qty_out)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Calling `copy_field` stencil**\n", - "\n", - "The code will call `copy_field` to execute `copy_field_stencil` using the previously defined `gt_storage` arrays and plot the result at `k = 0`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\"Copying copy_field stencil\")\n", - "copy_field(qty_in, qty_out)\n", - "print(\"Plotting qty_out at K = 0\")\n", - "plot_field_at_k0(qty_out)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "From the plot, we see that the copy is only applied to the inner 6 by 6 area and not the entire domain. The stencil in this case only applies in this \"domain\" and not the \"halo\" region surrounding the domain." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Applying a J offset**\n", - "\n", - "The next example will create a stencil that takes a `gt_storage` as an input, shift the input by 1 in the `-j` direction, and write it to an output `gt_storage`. This stencil is defined in `copy_field_offset_stencil`.\n", - "\n", - "Note that in `copy_field_offset_stencil`, the shift in the J dimension is performed by referencing the `J` object from `gt4py.cartesian.gtscript` for simplicity. This reference will apply the shift in J to the entire input domain. Another way to perform the shift without referencing the `J` object is to write `[0,-1,0]` (assuming that the variable being modified is 3-dimensional) instead of `[J-1]`.\n", - "\n", - "With the stencil in place, a class `CopyFieldOffset` is defined using the `StencilFactory` object and `copy_field_offset_stencil`. The class is instantiated and demonstrated to shift `qty_in` by 1 in the J-dimension and write to `qty_out`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from gt4py.cartesian.gtscript import J\n", - "\n", - "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", - " with computation(PARALLEL), interval(...):\n", - " field_out = field_in[J-1]\n", - " \n", - "class CopyFieldOffset:\n", - " def __init__(self, stencil_factory: StencilFactory):\n", - " grid_indexing = stencil_factory.grid_indexing\n", - " self._copy_field_offset = stencil_factory.from_origin_domain(\n", - " copy_field_offset_stencil,\n", - " origin=grid_indexing.origin_compute(),\n", - " domain=grid_indexing.domain_compute(),\n", - " )\n", - "\n", - " def __call__(\n", - " self,\n", - " field_in: FloatField,\n", - " field_out: FloatField,\n", - " ):\n", - " self._copy_field_offset(field_in, field_out)\n", - " \n", - "copy_field_offset = CopyFieldOffset(stencil_factory)\n", - " \n", - "copy_field(qty_zero, qty_out)\n", - "print(\"Initialize qty_out to zeros\")\n", - "plot_field_at_k0(qty_out)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\"Executing copy_field_offset stencil\")\n", - "copy_field_offset(qty_in, qty_out)\n", - "print(\"Plotting values of qty_out at K = 0\")\n", - "plot_field_at_k0(qty_out)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Limits to offset : Cannot set offset outside of usable domain**\n", - "\n", - "Note that when the copy offset by -1 in the j-direction is performed, the 'halo' region at J = 8 is copied over due to the j shift. This means that there are limits to the shift amount since choosing a large shift amount may result in accessing a data region that does not exist. The following example shows this by trying to perform a shift by -2 in the j-direction." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def copy_field_offset_stencil(field_in: FloatField, field_out: FloatField):\n", - " with computation(PARALLEL), interval(...):\n", - " field_out = field_in[J-2]\n", - " \n", - "class CopyFieldOffset:\n", - " def __init__(self, stencil_factory: StencilFactory):\n", - " grid_indexing = stencil_factory.grid_indexing\n", - " self._copy_field_offset = stencil_factory.from_origin_domain(\n", - " copy_field_offset_stencil,\n", - " origin=grid_indexing.origin_compute(),\n", - " domain=grid_indexing.domain_compute(),\n", - " )\n", - "\n", - " def __call__(\n", - " self,\n", - " field_in: FloatField,\n", - " field_out: FloatField,\n", - " ):\n", - " self._copy_field_offset(field_in, field_out)\n", - " \n", - "copy_field_offset = CopyFieldOffset(stencil_factory)\n", - "\n", - "copy_field_offset(qty_in, qty_out)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Example demonstrating error when writing to offset outputs**\n", - "\n", - "While offsets can be applied to all input `gt_storage` variables in `gt4py`, output `gt_storage` variables cannot have such offsets. When an offset is applied to an output stencil calcuation, the error `GTScriptSyntaxError: Assignment to non-zero offsets is not supported.` will be displayed." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from gt4py.cartesian.gtscript import J\n", - "\n", - "def copy_field_offset_output_stencil(field_in: FloatField, field_out: FloatField):\n", - " with computation(PARALLEL), interval(...):\n", - " field_out[0,1,0] = field_in\n", - " \n", - "class CopyFieldOffsetOutput:\n", - " def __init__(self, stencil_factory: StencilFactory):\n", - " grid_indexing = stencil_factory.grid_indexing\n", - " self._copy_field_offset_output = stencil_factory.from_origin_domain(\n", - " copy_field_offset_output_stencil,\n", - " origin=grid_indexing.origin_compute(),\n", - " domain=grid_indexing.domain_compute(),\n", - " )\n", - "\n", - " def __call__(\n", - " self,\n", - " field_in: FloatField,\n", - " field_out: FloatField,\n", - " ):\n", - " self._copy_field_offset_output(field_in, field_out)\n", - " \n", - "copy_field_offset_output = CopyFieldOffsetOutput(stencil_factory)\n", - " " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "gt4py_jupyter", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}