commit a04e7264ccc3a626df529c68707a44d6ba8c6ac5 Author: Paul Romano Date: Wed Jun 16 13:40:02 2021 +0700 Add notebooks from OpenMC documentation diff --git a/hexagonal-lattice.ipynb b/hexagonal-lattice.ipynb new file mode 100644 index 0000000..07c3ab8 --- /dev/null +++ b/hexagonal-lattice.ipynb @@ -0,0 +1,411 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modeling Hexagonal Lattices\n", + "In this example, we will create a hexagonal lattice and show how the orientation can be changed via the cell rotation property. Let's first just set up some materials and universes that we will use to fill the lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import openmc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "fuel = openmc.Material(name='fuel')\n", + "fuel.add_nuclide('U235', 1.0)\n", + "fuel.set_density('g/cm3', 10.0)\n", + "\n", + "fuel2 = openmc.Material(name='fuel2')\n", + "fuel2.add_nuclide('U238', 1.0)\n", + "fuel2.set_density('g/cm3', 10.0)\n", + "\n", + "water = openmc.Material(name='water')\n", + "water.add_nuclide('H1', 2.0)\n", + "water.add_nuclide('O16', 1.0)\n", + "water.set_density('g/cm3', 1.0)\n", + "\n", + "materials = openmc.Materials((fuel, fuel2, water))\n", + "materials.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we will set up two universes that represent pin-cells: one with a small pin and one with a big pin. Since we will be using these universes in a lattice, it's always a good idea to have an \"outer\" universe as well that is applied outside the defined lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "r_pin = openmc.ZCylinder(r=0.25)\n", + "fuel_cell = openmc.Cell(fill=fuel, region=-r_pin)\n", + "water_cell = openmc.Cell(fill=water, region=+r_pin)\n", + "pin_universe = openmc.Universe(cells=(fuel_cell, water_cell))\n", + "\n", + "r_big_pin = openmc.ZCylinder(r=0.5)\n", + "fuel2_cell = openmc.Cell(fill=fuel2, region=-r_big_pin)\n", + "water2_cell = openmc.Cell(fill=water, region=+r_big_pin)\n", + "big_pin_universe = openmc.Universe(cells=(fuel2_cell, water2_cell))\n", + "\n", + "all_water_cell = openmc.Cell(fill=water)\n", + "outer_universe = openmc.Universe(cells=(all_water_cell,))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a hexagonal lattice using the `HexLattice` class:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "lattice = openmc.HexLattice()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to set the `center` of the lattice, the `pitch`, an `outer` universe (which is applied to all lattice elements outside of those that are defined), and a list of `universes`. Let's start with the easy ones first. Note that for a 2D lattice, we only need to specify a single number for the pitch." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "lattice.center = (0., 0.)\n", + "lattice.pitch = (1.25,)\n", + "lattice.outer = outer_universe" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to set the `universes` property on our lattice. It needs to be set to a list of lists of Universes, where each list of Universes corresponds to a ring of the lattice. The rings are ordered from outermost to innermost, and within each ring the indexing starts at the \"top\". To help visualize the proper indices, we can use the `show_indices()` helper method." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " (0, 0)\n", + " (0,17) (0, 1)\n", + " (0,16) (1, 0) (0, 2)\n", + "(0,15) (1,11) (1, 1) (0, 3)\n", + " (1,10) (2, 0) (1, 2)\n", + "(0,14) (2, 5) (2, 1) (0, 4)\n", + " (1, 9) (3, 0) (1, 3)\n", + "(0,13) (2, 4) (2, 2) (0, 5)\n", + " (1, 8) (2, 3) (1, 4)\n", + "(0,12) (1, 7) (1, 5) (0, 6)\n", + " (0,11) (1, 6) (0, 7)\n", + " (0,10) (0, 8)\n", + " (0, 9)\n" + ] + } + ], + "source": [ + "print(lattice.show_indices(num_rings=4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's set up a lattice where the first element in each ring is the big pin universe and all other elements are regular pin universes. \n", + "\n", + "From the diagram above, we see that the outer ring has 18 elements, the first ring has 12, and the second ring has 6 elements. The innermost ring of any hexagonal lattice will have only a single element. \n", + "\n", + "We build these rings through 'list concatenation' as follows: " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "outer_ring = [big_pin_universe] + [pin_universe]*17 # Adds up to 18\n", + "\n", + "ring_1 = [big_pin_universe] + [pin_universe]*11 # Adds up to 12\n", + "\n", + "ring_2 = [big_pin_universe] + [pin_universe]*5 # Adds up to 6\n", + "\n", + "inner_ring = [big_pin_universe]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now assign the rings (and the universes they contain) to our lattice. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HexLattice\n", + "\tID =\t4\n", + "\tName =\t\n", + "\tOrientation =\ty\n", + "\t# Rings =\t4\n", + "\t# Axial =\tNone\n", + "\tCenter =\t(0.0, 0.0)\n", + "\tPitch =\t(1.25,)\n", + "\tOuter =\t3\n", + "\tUniverses \n", + " 2\n", + " 1 1\n", + " 1 2 1\n", + "1 1 1 1\n", + " 1 2 1\n", + "1 1 1 1\n", + " 1 2 1\n", + "1 1 1 1\n", + " 1 1 1\n", + "1 1 1 1\n", + " 1 1 1\n", + " 1 1\n", + " 1\n" + ] + } + ], + "source": [ + "lattice.universes = [outer_ring, \n", + " ring_1, \n", + " ring_2,\n", + " inner_ring]\n", + "print(lattice)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's put our lattice inside a circular cell that will serve as the top-level cell for our geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "outer_surface = openmc.ZCylinder(r=5.0, boundary_type='vacuum')\n", + "main_cell = openmc.Cell(fill=lattice, region=-outer_surface)\n", + "geometry = openmc.Geometry([main_cell])\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a plot to see what our geometry looks like." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot = openmc.Plot.from_geometry(geometry)\n", + "plot.color_by = 'material'\n", + "plot.colors = colors = {\n", + " water: 'blue',\n", + " fuel: 'olive',\n", + " fuel2: 'yellow'\n", + "}\n", + "plot.to_ipython_image()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At this point, if we wanted to simulate the model, we would need to create an instance of `openmc.Settings`, export it to XML, and run." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lattice orientation\n", + "\n", + "Now let's say we want our hexagonal lattice orientated such that two sides of the lattice are parallel to the x-axis. This can be achieved by two means: either we can rotate the cell that contains the lattice, or we can can change the `HexLattice.orientation` attribute. By default, the `orientation` is set to \"y\", indicating that two sides of the lattice are parallel to the y-axis, but we can also change it to \"x\" to make them parallel to the x-axis." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Change the orientation of the lattice and re-export the geometry\n", + "lattice.orientation = 'x'\n", + "geometry.export_to_xml()\n", + "\n", + "# Run OpenMC in plotting mode\n", + "plot.to_ipython_image()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we change the orientation to 'x', you can see that the first universe in each ring starts to the right along the x-axis. As before, the universes are defined in a clockwise fashion around each ring. To see the proper indices for a hexagonal lattice in this orientation, we can again call `show_indices` but pass an extra orientation argument:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " (0,12) (0,13) (0,14) (0,15)\n", + "\n", + " (0,11) (1, 8) (1, 9) (1,10) (0,16)\n", + "\n", + " (0,10) (1, 7) (2, 4) (2, 5) (1,11) (0,17)\n", + "\n", + "(0, 9) (1, 6) (2, 3) (3, 0) (2, 0) (1, 0) (0, 0)\n", + "\n", + " (0, 8) (1, 5) (2, 2) (2, 1) (1, 1) (0, 1)\n", + "\n", + " (0, 7) (1, 4) (1, 3) (1, 2) (0, 2)\n", + "\n", + " (0, 6) (0, 5) (0, 4) (0, 3)\n" + ] + } + ], + "source": [ + "print(lattice.show_indices(4, orientation='x'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hexagonal prisms\n", + "\n", + "OpenMC also contains a convenience function that can create a hexagonal prism representing the interior region of six surfaces defining a hexagon. This can be useful as a bounding surface of a hexagonal lattice. For example, if we wanted the outer boundary of our geometry to be hexagonal, we could change the `region` of the main cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "main_cell.region = openmc.model.hexagonal_prism(\n", + " edge_length=4*lattice.pitch[0],\n", + " orientation='x',\n", + " boundary_type='vacuum'\n", + ")\n", + "geometry.export_to_xml()\n", + "\n", + "# Run OpenMC in plotting mode\n", + "plot.color_by = 'cell'\n", + "plot.to_ipython_image()" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mdgxs-part-i.ipynb b/mdgxs-part-i.ipynb new file mode 100644 index 0000000..ea1dd7b --- /dev/null +++ b/mdgxs-part-i.ipynb @@ -0,0 +1,1495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multigroup (Delayed) Cross Section Generation Part I: Introduction\n", + "This IPython Notebook introduces the use of the `openmc.mgxs` module to calculate multi-energy-group and multi-delayed-group cross sections for an infinite homogeneous medium. In particular, this Notebook introduces the the following features:\n", + "\n", + "* Creation of multi-delayed-group cross sections for an **infinite homogeneous medium**\n", + "* Calculation of delayed neutron precursor concentrations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction to Multi-Delayed-Group Cross Sections (MDGXS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many Monte Carlo particle transport codes, including OpenMC, use continuous-energy nuclear cross section data. However, most deterministic neutron transport codes use *multi-group cross sections* defined over discretized energy bins or *energy groups*. Furthermore, kinetics calculations typically separate out parameters that involve delayed neutrons into prompt and delayed components and further subdivide delayed components by delayed groups. An example is the energy spectrum for prompt and delayed neutrons for U-235 and Pu-239 computed for a light water reactor spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": { + "image/png": { + "width": 350 + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(filename='images/mdgxs.png', width=350)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A variety of tools employing different methodologies have been developed over the years to compute multi-group cross sections for certain applications, including NJOY (LANL), MC$^2$-3 (ANL), and Serpent (VTT). The `openmc.mgxs` Python module is designed to leverage OpenMC's tally system to calculate multi-group cross sections with arbitrary energy discretizations and different delayed group models (e.g. 6, 7, or 8 delayed group models) for fine-mesh heterogeneous deterministic neutron transport applications.\n", + "\n", + "Before proceeding to illustrate how one may use the `openmc.mgxs` module, it is worthwhile to define the general equations used to calculate multi-energy-group and multi-delayed-group cross sections. This is only intended as a brief overview of the methodology used by `openmc.mgxs` - we refer the interested reader to the large body of literature on the subject for a more comprehensive understanding of this complex topic." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Introductory Notation\n", + "The continuous real-valued microscopic cross section may be denoted $\\sigma_{n,x}(\\mathbf{r}, E)$ for position vector $\\mathbf{r}$, energy $E$, nuclide $n$ and interaction type $x$. Similarly, the scalar neutron flux may be denoted by $\\Phi(\\mathbf{r},E)$ for position $\\mathbf{r}$ and energy $E$. **Note**: Although nuclear cross sections are dependent on the temperature $T$ of the interacting medium, the temperature variable is neglected here for brevity." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Spatial and Energy Discretization\n", + "The energy domain for critical systems such as thermal reactors spans more than 10 orders of magnitude of neutron energies from 10$^{-5}$ - 10$^7$ eV. The multi-group approximation discretization divides this energy range into one or more energy groups. In particular, for $G$ total groups, we denote an energy group index $g$ such that $g \\in \\{1, 2, ..., G\\}$. The energy group indices are defined such that the smaller group the higher the energy, and vice versa. The integration over neutron energies across a discrete energy group is commonly referred to as **energy condensation**.\n", + "\n", + "The delayed neutrons created from fissions are created from > 30 delayed neutron precursors. Modeling each of the delayed neutron precursors is possible, but this approach has not recieved much attention due to large uncertainties in certain precursors. Therefore, the delayed neutrons are often combined into \"delayed groups\" that have a set time constant, $\\lambda_d$. Some cross section libraries use the same group time constants for all nuclides (e.g. JEFF 3.1) while other libraries use different time constants for all nuclides (e.g. ENDF/B-VII.1). Multi-delayed-group cross sections can either be created with the entire delayed group set, a subset of delayed groups, or integrated over all delayed groups.\n", + "\n", + "Multi-group cross sections are computed for discretized spatial zones in the geometry of interest. The spatial zones may be defined on a structured and regular fuel assembly or pin cell mesh, an arbitrary unstructured mesh or the constructive solid geometry used by OpenMC. For a geometry with $K$ distinct spatial zones, we designate each spatial zone an index $k$ such that $k \\in \\{1, 2, ..., K\\}$. The volume of each spatial zone is denoted by $V_{k}$. The integration over discrete spatial zones is commonly referred to as **spatial homogenization**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### General Scalar-Flux Weighted MDGXS\n", + "The multi-group cross sections computed by `openmc.mgxs` are defined as a *scalar flux-weighted average* of the microscopic cross sections across each discrete energy group. This formulation is employed in order to preserve the reaction rates within each energy group and spatial zone. In particular, spatial homogenization and energy condensation are used to compute the general multi-group cross section. For instance, the delayed-nu-fission multi-energy-group and multi-delayed-group cross section, $\\nu_d \\sigma_{f,x,k,g}$, can be computed as follows:\n", + "\n", + "$$\\nu_d \\sigma_{n,x,k,g} = \\frac{\\int_{E_{g}}^{E_{g-1}}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r} \\nu_d \\sigma_{f,x}(\\mathbf{r},E')\\Phi(\\mathbf{r},E')}{\\int_{E_{g}}^{E_{g-1}}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\Phi(\\mathbf{r},E')}$$\n", + "\n", + "This scalar flux-weighted average microscopic cross section is computed by `openmc.mgxs` for only the delayed-nu-fission and delayed neutron fraction reaction type at the moment. These double integrals are stochastically computed with OpenMC's tally system - in particular, [filters](../usersguide/tallies.rst#filters) on the energy range and spatial zone (material, cell, universe, or mesh) define the bounds of integration for both numerator and denominator." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multi-Group Prompt and Delayed Fission Spectrum\n", + "The energy spectrum of neutrons emitted from fission is denoted by $\\chi_{n}(\\mathbf{r},E' \\rightarrow E'')$ for incoming and outgoing energies $E'$ and $E''$, respectively. Unlike the multi-group cross sections $\\sigma_{n,x,k,g}$ considered up to this point, the fission spectrum is a probability distribution and must sum to unity. The outgoing energy is typically much less dependent on the incoming energy for fission than for scattering interactions. As a result, it is common practice to integrate over the incoming neutron energy when computing the multi-group fission spectrum. The fission spectrum may be simplified as $\\chi_{n}(\\mathbf{r},E)$ with outgoing energy $E$.\n", + "\n", + "Computing the cumulative energy spectrum of emitted neutrons, $\\chi_{n}(\\mathbf{r},E)$, has been presented in the `mgxs-part-i.ipynb` notebook. Here, we will present the energy spectrum of prompt and delayed emission neutrons, $\\chi_{n,p}(\\mathbf{r},E)$ and $\\chi_{n,d}(\\mathbf{r},E)$, respectively. Unlike the multi-group cross sections defined up to this point, the multi-group fission spectrum is weighted by the fission production rate rather than the scalar flux. This formulation is intended to preserve the total fission production rate in the multi-group deterministic calculation. In order to mathematically define the multi-group fission spectrum, we denote the microscopic fission cross section as $\\sigma_{n,f}(\\mathbf{r},E)$ and the average number of neutrons emitted from fission interactions with nuclide $n$ as $\\nu_{n,p}(\\mathbf{r},E)$ and $\\nu_{n,d}(\\mathbf{r},E)$ for prompt and delayed neutrons, respectively. The multi-group fission spectrum $\\chi_{n,k,g,d}$ is then the probability of fission neutrons emitted into energy group $g$ and delayed group $d$. There are not prompt groups, so inserting $p$ in place of $d$ just denotes all prompt neutrons. \n", + "\n", + "Similar to before, spatial homogenization and energy condensation are used to find the multi-energy-group and multi-delayed-group fission spectrum $\\chi_{n,k,g,d}$ as follows:\n", + "\n", + "$$\\chi_{n,k,g',d} = \\frac{\\int_{E_{g'}}^{E_{g'-1}}\\mathrm{d}E''\\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\chi_{n,d}(\\mathbf{r},E'\\rightarrow E'')\\nu_{n,d}(\\mathbf{r},E')\\sigma_{n,f}(\\mathbf{r},E')\\Phi(\\mathbf{r},E')}{\\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\nu_{n,d}(\\mathbf{r},E')\\sigma_{n,f}(\\mathbf{r},E')\\Phi(\\mathbf{r},E')}$$\n", + "\n", + "The fission production-weighted multi-energy-group and multi-delayed-group fission spectrum for delayed neutrons is computed using OpenMC tallies with energy in, energy out, and delayed group filters. Alternatively, the delayed group filter can be omitted to compute the fission spectrum integrated over all delayed groups.\n", + "\n", + "This concludes our brief overview on the methodology to compute multi-energy-group and multi-delayed-group cross sections. The following sections detail more concretely how users may employ the `openmc.mgxs` module to power simulation workflows requiring multi-group cross sections for downstream deterministic calculations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import openmc\n", + "import openmc.mgxs as mgxs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we need to define materials that will be used in the problem. Let's create a material for the homogeneous medium." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Material and register the Nuclides\n", + "inf_medium = openmc.Material(name='moderator')\n", + "inf_medium.set_density('g/cc', 5.)\n", + "inf_medium.add_nuclide('H1', 0.03)\n", + "inf_medium.add_nuclide('O16', 0.015)\n", + "inf_medium.add_nuclide('U235', 0.0001)\n", + "inf_medium.add_nuclide('U238', 0.007)\n", + "inf_medium.add_nuclide('Pu239', 0.00003)\n", + "inf_medium.add_nuclide('Zr90', 0.002)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our material, we can now create a `Materials` object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Materials collection and export to XML\n", + "materials_file = openmc.Materials([inf_medium])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. This problem will be a simple square cell with reflective boundary conditions to simulate an infinite homogeneous medium. The first step is to create the outer bounding surfaces of the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate boundary Planes\n", + "min_x = openmc.XPlane(boundary_type='reflective', x0=-0.63)\n", + "max_x = openmc.XPlane(boundary_type='reflective', x0=0.63)\n", + "min_y = openmc.YPlane(boundary_type='reflective', y0=-0.63)\n", + "max_y = openmc.YPlane(boundary_type='reflective', y0=0.63)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now create a cell that is defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Cell\n", + "cell = openmc.Cell(cell_id=1, name='cell')\n", + "\n", + "# Register bounding Surfaces with the Cell\n", + "cell.region = +min_x & -max_x & +min_y & -max_y\n", + "\n", + "# Fill the Cell with the Material\n", + "cell.fill = inf_medium" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "openmc_geometry = openmc.Geometry([cell])\n", + "\n", + "# Export to \"geometry.xml\"\n", + "openmc_geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we must define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 2500 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 50\n", + "inactive = 10\n", + "particles = 5000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': True}\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-0.63, -0.63, -0.63, 0.63, 0.63, 0.63]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we are ready to generate multi-group cross sections! First, let's define a 100-energy-group structure and 1-energy-group structure using the built-in `EnergyGroups` class. We will also create a 6-delayed-group list." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a 100-group EnergyGroups object\n", + "energy_groups = mgxs.EnergyGroups()\n", + "energy_groups.group_edges = np.logspace(-3, 7.3, 101)\n", + "\n", + "# Instantiate a 1-group EnergyGroups object\n", + "one_group = mgxs.EnergyGroups()\n", + "one_group.group_edges = np.array([energy_groups.group_edges[0], energy_groups.group_edges[-1]])\n", + "\n", + "delayed_groups = list(range(1,7))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now use the `EnergyGroups` object and delayed group list, along with our previously created materials and geometry, to instantiate some `MGXS` objects from the `openmc.mgxs` module. In particular, the following are subclasses of the generic and abstract `MGXS` class:\n", + "\n", + "* `TotalXS`\n", + "* `TransportXS`\n", + "* `AbsorptionXS`\n", + "* `CaptureXS`\n", + "* `FissionXS`\n", + "* `NuFissionMatrixXS`\n", + "* `KappaFissionXS`\n", + "* `ScatterXS`\n", + "* `ScatterMatrixXS`\n", + "* `Chi`\n", + "* `InverseVelocity`\n", + "\n", + "A separate abstract `MDGXS` class is used for cross-sections and parameters that involve delayed neutrons. The subclasses of `MDGXS` include:\n", + "\n", + "* `DelayedNuFissionXS`\n", + "* `ChiDelayed`\n", + "* `Beta`\n", + "* `DecayRate`\n", + "\n", + "These classes provide us with an interface to generate the tally inputs as well as perform post-processing of OpenMC's tally data to compute the respective multi-group cross sections. \n", + "\n", + "In this case, let's create the multi-group chi-prompt, chi-delayed, and prompt-nu-fission cross sections with our 100-energy-group structure and multi-group delayed-nu-fission and beta cross sections with our 100-energy-group and 6-delayed-group structures. \n", + "\n", + "The prompt chi and nu-fission data can actually be gathered using the `Chi` and `FissionXS` classes, respectively, by passing in a value of `True` for the optional `prompt` parameter upon initialization." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a few different sections\n", + "chi_prompt = mgxs.Chi(domain=cell, groups=energy_groups, by_nuclide=True, prompt=True)\n", + "prompt_nu_fission = mgxs.FissionXS(domain=cell, groups=energy_groups, by_nuclide=True, nu=True, prompt=True)\n", + "chi_delayed = mgxs.ChiDelayed(domain=cell, energy_groups=energy_groups, by_nuclide=True)\n", + "delayed_nu_fission = mgxs.DelayedNuFissionXS(domain=cell, energy_groups=energy_groups, delayed_groups=delayed_groups, by_nuclide=True)\n", + "beta = mgxs.Beta(domain=cell, energy_groups=energy_groups, delayed_groups=delayed_groups, by_nuclide=True)\n", + "decay_rate = mgxs.DecayRate(domain=cell, energy_groups=one_group, delayed_groups=delayed_groups, by_nuclide=True)\n", + "\n", + "chi_prompt.nuclides = ['U235', 'Pu239']\n", + "prompt_nu_fission.nuclides = ['U235', 'Pu239']\n", + "chi_delayed.nuclides = ['U235', 'Pu239']\n", + "delayed_nu_fission.nuclides = ['U235', 'Pu239']\n", + "beta.nuclides = ['U235', 'Pu239']\n", + "decay_rate.nuclides = ['U235', 'Pu239']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each multi-group cross section object stores its tallies in a Python dictionary called `tallies`. We can inspect the tallies in the dictionary for our `Decay Rate` object as follows. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('delayed-nu-fission', Tally\n", + " \tID =\t1\n", + " \tName =\t\n", + " \tFilters =\tCellFilter, DelayedGroupFilter, EnergyFilter\n", + " \tNuclides =\tU235 Pu239 \n", + " \tScores =\t['delayed-nu-fission']\n", + " \tEstimator =\ttracklength), ('decay-rate', Tally\n", + " \tID =\t2\n", + " \tName =\t\n", + " \tFilters =\tCellFilter, DelayedGroupFilter, EnergyFilter\n", + " \tNuclides =\tU235 Pu239 \n", + " \tScores =\t['decay-rate']\n", + " \tEstimator =\ttracklength)])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decay_rate.tallies" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `Beta` object includes tracklength tallies for the 'nu-fission' and 'delayed-nu-fission' scores in the 100-energy-group and 6-delayed-group structure in cell 1. Now that each `MGXS` and `MDGXS` object contains the tallies that it needs, we must add these tallies to a `Tallies` object to generate the \"tallies.xml\" input file for OpenMC." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=4.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=6.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=5.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=8.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=14.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Instantiate an empty Tallies object\n", + "tallies_file = openmc.Tallies()\n", + "\n", + "# Add chi-prompt tallies to the tallies file\n", + "tallies_file += chi_prompt.tallies.values()\n", + "\n", + "# Add prompt-nu-fission tallies to the tallies file\n", + "tallies_file += prompt_nu_fission.tallies.values()\n", + "\n", + "# Add chi-delayed tallies to the tallies file\n", + "tallies_file += chi_delayed.tallies.values()\n", + "\n", + "# Add delayed-nu-fission tallies to the tallies file\n", + "tallies_file += delayed_nu_fission.tallies.values()\n", + "\n", + "# Add beta tallies to the tallies file\n", + "tallies_file += beta.tallies.values()\n", + "\n", + "# Add decay rate tallies to the tallies file\n", + "tallies_file += decay_rate.tallies.values()\n", + "\n", + "# Export to \"tallies.xml\"\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we a have a complete set of inputs, so we can go ahead and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2019 MIT and OpenMC contributors\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.11.0-dev\n", + " Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n", + " Date/Time | 2019-07-19 06:56:34\n", + " OpenMP Threads | 4\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading H1 from /opt/data/hdf5/nndc_hdf5_v15/H1.h5\n", + " Reading O16 from /opt/data/hdf5/nndc_hdf5_v15/O16.h5\n", + " Reading U235 from /opt/data/hdf5/nndc_hdf5_v15/U235.h5\n", + " Reading U238 from /opt/data/hdf5/nndc_hdf5_v15/U238.h5\n", + " Reading Pu239 from /opt/data/hdf5/nndc_hdf5_v15/Pu239.h5\n", + " Reading Zr90 from /opt/data/hdf5/nndc_hdf5_v15/Zr90.h5\n", + " Maximum neutron transport energy: 20000000.000000 eV for H1\n", + " Reading tallies XML file...\n", + " Writing summary.h5 file...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.21670\n", + " 2/1 1.24155\n", + " 3/1 1.21924\n", + " 4/1 1.22486\n", + " 5/1 1.21719\n", + " 6/1 1.24330\n", + " 7/1 1.22322\n", + " 8/1 1.24133\n", + " 9/1 1.21840\n", + " 10/1 1.25141\n", + " 11/1 1.21217\n", + " 12/1 1.25625 1.23421 +/- 0.02204\n", + " 13/1 1.22056 1.22966 +/- 0.01351\n", + " 14/1 1.21757 1.22664 +/- 0.01002\n", + " 15/1 1.24571 1.23045 +/- 0.00865\n", + " 16/1 1.26489 1.23619 +/- 0.00910\n", + " 17/1 1.22323 1.23434 +/- 0.00791\n", + " 18/1 1.26108 1.23768 +/- 0.00762\n", + " 19/1 1.23145 1.23699 +/- 0.00676\n", + " 20/1 1.23548 1.23684 +/- 0.00605\n", + " 21/1 1.20446 1.23390 +/- 0.00621\n", + " 22/1 1.20533 1.23152 +/- 0.00615\n", + " 23/1 1.22520 1.23103 +/- 0.00568\n", + " 24/1 1.18367 1.22765 +/- 0.00625\n", + " 25/1 1.23614 1.22821 +/- 0.00585\n", + " 26/1 1.23746 1.22879 +/- 0.00550\n", + " 27/1 1.23626 1.22923 +/- 0.00518\n", + " 28/1 1.21334 1.22835 +/- 0.00497\n", + " 29/1 1.25169 1.22958 +/- 0.00486\n", + " 30/1 1.25579 1.23089 +/- 0.00479\n", + " 31/1 1.23828 1.23124 +/- 0.00457\n", + " 32/1 1.26911 1.23296 +/- 0.00468\n", + " 33/1 1.20090 1.23157 +/- 0.00469\n", + " 34/1 1.28606 1.23384 +/- 0.00503\n", + " 35/1 1.23129 1.23374 +/- 0.00483\n", + " 36/1 1.22535 1.23341 +/- 0.00465\n", + " 37/1 1.20367 1.23231 +/- 0.00461\n", + " 38/1 1.22886 1.23219 +/- 0.00444\n", + " 39/1 1.24056 1.23248 +/- 0.00429\n", + " 40/1 1.25038 1.23307 +/- 0.00419\n", + " 41/1 1.21504 1.23249 +/- 0.00410\n", + " 42/1 1.20762 1.23171 +/- 0.00404\n", + " 43/1 1.20597 1.23093 +/- 0.00399\n", + " 44/1 1.24424 1.23133 +/- 0.00389\n", + " 45/1 1.24767 1.23179 +/- 0.00381\n", + " 46/1 1.22998 1.23174 +/- 0.00370\n", + " 47/1 1.26195 1.23256 +/- 0.00369\n", + " 48/1 1.23146 1.23253 +/- 0.00359\n", + " 49/1 1.22059 1.23222 +/- 0.00351\n", + " 50/1 1.24724 1.23260 +/- 0.00345\n", + " Creating state point statepoint.50.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 4.7388e-01 seconds\n", + " Reading cross sections = 4.4709e-01 seconds\n", + " Total time in simulation = 3.9290e+01 seconds\n", + " Time in transport only = 3.9005e+01 seconds\n", + " Time in inactive batches = 1.4079e+00 seconds\n", + " Time in active batches = 3.7882e+01 seconds\n", + " Time synchronizing fission bank = 1.8814e-02 seconds\n", + " Sampling source sites = 1.6376e-02 seconds\n", + " SEND/RECV source sites = 2.3626e-03 seconds\n", + " Time accumulating tallies = 8.3299e-04 seconds\n", + " Total time for finalization = 1.1533e-02 seconds\n", + " Total time elapsed = 3.9783e+01 seconds\n", + " Calculation Rate (inactive) = 35514.2 particles/second\n", + " Calculation Rate (active) = 5279.54 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.23256 +/- 0.00308\n", + " k-effective (Track-length) = 1.23260 +/- 0.00345\n", + " k-effective (Absorption) = 1.23111 +/- 0.00186\n", + " Combined k-effective = 1.23135 +/- 0.00184\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tally Data Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the last statepoint file\n", + "sp = openmc.StatePoint('statepoint.50.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. By default, a `Summary` object is automatically linked when a `StatePoint` is loaded. This is necessary for the `openmc.mgxs` module to properly process the tally data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by our multi-group cross sections. We simply have to load the tallies from the `StatePoint` into each object as follows and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the tallies from the statepoint into each MGXS object\n", + "chi_prompt.load_from_statepoint(sp)\n", + "prompt_nu_fission.load_from_statepoint(sp)\n", + "chi_delayed.load_from_statepoint(sp)\n", + "delayed_nu_fission.load_from_statepoint(sp)\n", + "beta.load_from_statepoint(sp)\n", + "decay_rate.load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Voila! Our multi-group cross sections are now ready to rock 'n roll!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting and Storing MGXS Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first inspect our delayed-nu-fission section by printing it to the screen after condensing the cross section down to one group." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[5.14223507e-06, 1.16426087e-06]],\n", + "\n", + " [[2.65426350e-05, 7.58220468e-06]],\n", + "\n", + " [[2.53399053e-05, 5.73796202e-06]],\n", + "\n", + " [[5.68141581e-05, 1.04757933e-05]],\n", + "\n", + " [[2.32930026e-05, 5.45658817e-06]],\n", + "\n", + " [[9.75735783e-06, 1.65150949e-06]]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "delayed_nu_fission.get_condensed_xs(one_group).get_xs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the `openmc.mgxs` module uses [tally arithmetic](tally-arithmetic.ipynb) under-the-hood, the cross section is stored as a \"derived\" `Tally` object. This means that it can be queried and manipulated using all of the same methods supported for the `Tally` class in the OpenMC Python API. For example, we can construct a [Pandas](https://pandas.pydata.org/) `DataFrame` of the multi-group cross section data." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
celldelayedgroupgroup innuclidemeanstd. dev.
198111U2359.345817e-086.616216e-08
199111Pu2391.574816e-081.114955e-08
398121U2354.824023e-073.415087e-07
399121Pu2391.025593e-077.261101e-08
598131U2354.605432e-073.260339e-07
599131Pu2397.761348e-085.494962e-08
798141U2351.032576e-067.309948e-07
799141Pu2391.416989e-071.003215e-07
998151U2354.233415e-072.996976e-07
999151Pu2397.380753e-085.225504e-08
\n", + "
" + ], + "text/plain": [ + " cell delayedgroup group in nuclide mean std. dev.\n", + "198 1 1 1 U235 9.345817e-08 6.616216e-08\n", + "199 1 1 1 Pu239 1.574816e-08 1.114955e-08\n", + "398 1 2 1 U235 4.824023e-07 3.415087e-07\n", + "399 1 2 1 Pu239 1.025593e-07 7.261101e-08\n", + "598 1 3 1 U235 4.605432e-07 3.260339e-07\n", + "599 1 3 1 Pu239 7.761348e-08 5.494962e-08\n", + "798 1 4 1 U235 1.032576e-06 7.309948e-07\n", + "799 1 4 1 Pu239 1.416989e-07 1.003215e-07\n", + "998 1 5 1 U235 4.233415e-07 2.996976e-07\n", + "999 1 5 1 Pu239 7.380753e-08 5.225504e-08" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = delayed_nu_fission.get_pandas_dataframe()\n", + "df.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
celldelayedgroupgroup innuclidemeanstd. dev.
0111U2350.0133360.000061
1111Pu2390.0132710.000053
2121U2350.0327390.000149
3121Pu2390.0308810.000123
4131U2350.1207800.000549
5131Pu2390.1133700.000451
6141U2350.3027800.001378
7141Pu2390.2925000.001163
8151U2350.8494900.003865
9151Pu2390.8574900.003411
10161U2352.8530000.012980
11161Pu2392.7297000.010858
\n", + "
" + ], + "text/plain": [ + " cell delayedgroup group in nuclide mean std. dev.\n", + "0 1 1 1 U235 0.013336 0.000061\n", + "1 1 1 1 Pu239 0.013271 0.000053\n", + "2 1 2 1 U235 0.032739 0.000149\n", + "3 1 2 1 Pu239 0.030881 0.000123\n", + "4 1 3 1 U235 0.120780 0.000549\n", + "5 1 3 1 Pu239 0.113370 0.000451\n", + "6 1 4 1 U235 0.302780 0.001378\n", + "7 1 4 1 Pu239 0.292500 0.001163\n", + "8 1 5 1 U235 0.849490 0.003865\n", + "9 1 5 1 Pu239 0.857490 0.003411\n", + "10 1 6 1 U235 2.853000 0.012980\n", + "11 1 6 1 Pu239 2.729700 0.010858" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = decay_rate.get_pandas_dataframe()\n", + "df.head(12)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each multi-group cross section object can be easily exported to a variety of file formats, including CSV, Excel, and LaTeX for storage or data processing." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "beta.export_xs_data(filename='beta', format='excel')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following code snippet shows how to export the chi-prompt and chi-delayed `MGXS` to the same HDF5 binary data store." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "chi_prompt.build_hdf5_store(filename='mdgxs', append=True)\n", + "chi_delayed.build_hdf5_store(filename='mdgxs', append=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using Tally Arithmetic to Compute the Delayed Neutron Precursor Concentrations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we illustrate how one can leverage OpenMC's [tally arithmetic](tally-arithmetic.ipynb) data processing feature with `MGXS` objects. The `openmc.mgxs` module uses tally arithmetic to compute multi-group cross sections with automated uncertainty propagation. Each `MGXS` object includes an `xs_tally` attribute which is a \"derived\" `Tally` based on the tallies needed to compute the cross section type of interest. These derived tallies can be used in subsequent tally arithmetic operations. For example, we can use tally artithmetic to compute the delayed neutron precursor concentrations using the `Beta`, `DelayedNuFissionXS`, and `DecayRate` objects. The delayed neutron precursor concentrations are modeled using the following equations:\n", + "\n", + "$$\\frac{\\partial}{\\partial t} C_{k,d} (t) = \\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r} \\beta_{k,d} (t) \\nu_d \\sigma_{f,x}(\\mathbf{r},E',t)\\Phi(\\mathbf{r},E',t) - \\lambda_{d} C_{k,d} (t) $$\n", + "\n", + "$$C_{k,d} (t=0) = \\frac{1}{\\lambda_{d}} \\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r} \\beta_{k,d} (t=0) \\nu_d \\sigma_{f,x}(\\mathbf{r},E',t=0)\\Phi(\\mathbf{r},E',t=0) $$\n", + "\n", + "First, let's investigate the decay rates for U235 and Pu235. The fraction of the delayed neutron precursors remaining as a function of time after fission for each delayed group and fissioning isotope have been plotted below." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuIAAAGHCAYAAAD1MjdLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XlcVlX+wPHPeRYWZRUQERWUHURUNM01dVrUNLNl1LKsaZq0fpo21bRoZVPNTGVljmW22qLNlDluaVZmWpoCqSiLoCIooiCyr8/znN8f9wGeh82NReu8fT0vueu593KB7z33e84RUkoURVEURVEURWlbuvY+AEVRFEVRFEX5PVKBuKIoiqIoiqK0AxWIK4qiKIqiKEo7UIG4oiiKoiiKorQDFYgriqIoiqIoSjtQgbiiKIqiKIqitAMViCuXDSHENUKI4+1Q7odCiL+3dbmKoiiKovy+qUBcaTFCiAwhRLkQolgIUSCE+FkI8YAQ4oq9z4QQM4QQUgjxWL35x4UQ17TA/p8VQnxyqfu5wDKlEKJUCFEihDghhFgkhNC35TG0tSvh3rQ+iFqs35diIUSqEOKeC9i+ze8lRVEU5dJcNn+ElN+MCVJKVyAA+AfwOPBe+x7SJcsHHhNCuLZ1wULTGj+nMVJKF2AMMA34cyNlG1qh3Ea1VFnnuF5Xwr2Zbf2+uAFzgeVCiLB2PiZFURSllahAXGkVUspCKeVa4I/A3UKI3gBCCEchxCtCiEwhxCkhxNtCCOfG9iGE+JsQ4rC1djBJCHGzdb6DECJfCBFts25nIUSZEMLHOn2jEGKvTe1nH5t1+wkhEqz7/RxwOsfpJAM7gXlNHKfO5ljPCCH+I4ToZF3WIN3GWjv7ByHEDcCTwB+ttaD7rMt/EEK8IIT4CSgDegkhugoh1lrPO10I8Web/T1rLXOF9ZwOCiEGnOOcAJBSpgDbgZrvT4YQ4nEhxH6gVAhhsJb9pRAiVwhxVAgx26ZsvRDiSZvvU7wQorsQItBa826wWfcHIcR91q9nCCF+EkK8JoQ4AzwrhAgWQmwTQhQKIfKs35uabYcIIfZYl+0RQgypt1+763WOc76oe1MIcZP1niqynu8N1vn3CCGSred/RAjxF5ttDgghJthMG63n1u8cxyillBvRHgJt7903hBBZ1mOIF0IMt85v6l5yF0K8J4Q4KbS3H38X1rcfzV1vRVEUpW2oQFxpVVLK3cBxYLh11j+AUKAvEAz4Awua2PywdTt34DngEyGEn5SyClgF3Gmz7lTgOyllrjXIeR/4C+AFLAPWWgMtB2AN8DHQCfgvcMt5nMp84OGaALue/wMmASOBrsBZ4N/n2qGUchPwIvC5lNJFShljs3g6cD/gChyznu9x6/5vBV4UQoy2WX+idR0PYC2w5DzOCSFEJNo1/tVm9lRgvHVfFmAdsA/tezUG7Tpcb113nnX9cWi1uPeiBcPnYxBwBPAFXgCeB74BPIFuwJvWY+wEbAAWo30/FwEbhBBeNvuqf73O6ULuTSHEVcAK4FG06zICyLBudxq40Xr+9wCvCSH6W5etwP4+HQeclFLaXu8GrA93EwFvIN1m0R7r8XUCPgP+K4RwauZe+hAwWc+nH3AdcJ91WaPXW1EURWk7KhBX2kI20EkIIdCCpblSynwpZTFa8DClsY2klP+VUmZLKS1Sys+BNOAq6+KPgKnWfYIWiH1s/fp+YJmU8hcppVlK+RFQCQy2fozA61LKainlF2jBTbOklHuBLWjpDPU9ADwlpTwupawEngVuFZeWbvGhlPKglNIEdAGGAo9LKSusx/IucJfN+juklBullGa06xDTcJd2EoQQZ9GC7HeBD2yWLZZSZkkpy4GBgI+UcqGUskpKeQRYTt337D7gaSllqrUWd5+U8sx5nmO2lPJNKaXJWlY1WtpIV+t57rCuNx5Ik1J+bF13JZACTLDZV+31klJWn2f5cP735p+A96WUW6z34wnr2wSklBuklIet578NLbitCe4/AcYJIdys07b3aWO6CiEKgHLgK2CebdAupfxESnnGep6vAo5Ao6krQghftMD/YSllqZTyNPCazTk1db0VRVGUNqICcaUt+KO9YvcBOgDxQksZKQA2Wec3IIS4S9SllxSgpU94A0gpf0Greb1GCBGOVuO31rppAPBIzXbWbbuj1SZ3BU5IKaVNUedVg4pWOzrTGuDYCgC+sikrGTCj1fRerCybr7sCNcFhjWNo17VGjs3XZYDTOR4E+kspPaWUQVLKp6WUlibKDsAaHNqc35PUnVt3tDcXFyOr3vRjgAB2W9Nr7rXO70rD71H986+/r/N1vvdmk+cphBgrhNgltLShArTgt+Y+zQZ+Am4RQngAY4FPmzmebCmlB1rt+mLA9q0HQoi/WtNgCq1ludeU1YgAtIfOkzbntAzobF3e1PVWFEVR2kibNcZSfp+EEAPRgp0dQB5aTV+UlPLEObYLQKt5HQPslFKahRB70QKHGh+hvfbPAb6QUlZY52cBL0gpX2hkvyMBfyGEsAnGe3AewaSUMkUIsRp4qt6iLOBeKeVPjZTXFS3Aq5nWY//gIetv08j8mlpbV5tgvAfQ7DW8BLZlZwFHpZQhTaybBQQBB+rNL7X+3wEosn7dpZlykFLmYG00KoQYBnwrhPgR7fwD6m3bAy1QbnRf5+MC782a86y/D0fgS7S3E/+TUlYLIdbQ8D69D+337c5z3fsAUspKIcTjQKoQYpKUco01H/wxtJ+Jg1JKi/WtRk1Z9a9BFtqbIG/rm5X6ZTR6vaWU6fXXVRRFUVqHqhFXWoUQwk0IcSNa3vInUspEa63rcrQc2s7W9fxt8o1tdUQLLHKt692DtUGhjU+Am9GC8RU285cDDwghBglNRyHEeKH1erITLWd2trXh3GTq0l3Ox3NoecAeNvPeBl6wPjwghPARQtxkXXYIrXZ6vBDCCDyNlk5Q4xQQKJrpGUVKmQX8DLwkhHASWsPTP1nPv7XtBoqF1oDTWWiNM3tbg1jQ0lqeF0KEWK91HyGEl5QyF+1B4U7rNvfSSCBrSwhxmxCim3XyLNr33wJsBEKFENOE1nj0j0AksP5iTugi7833gHuEEGOs+dv+1jcxDmjfz1zAJIQYi5aHbWsN0B+Yg/192ixrW4hXqWtD4Yp27+YCBiHEArSa8xp295KU8iRamsyr1nPWCSGCrA+jzV1vRVEUpY2oQFxpaeuEEMVotXFPoTWss+0L+XG0xme7hBBFwLc0kuMqpUxCC0J2ogUY0Wiv+G3XyQIS0AKI7Tbz49Bq+pagBRjpwAzrsipgsnU6H63njNXne3JSyqNoOb4dbWa/gZYW84313HehNURESlkIzEILWE+g1RTb9qLyX+v/Z4QQCc0UPRUIRKsd/gp4Rkr57fke98Wy5pzfiNZA8ChazfG7aCkRoH1//4MW8BWhBaw1PY38Ga1x4xkgCu1hojkDgV+EECVo13OOlPKINef8RuAR674eA26UUuZd4Olc9L1pbdh5D1qOdSGwDQiwvqGYbb0GZ9G6glxrs0+s+e9fAj25gHvN6n2gh9B6XtmM9hbgEFpqTgX2KTmN3Ut3oT0sJFmP7wvAz7qs0et9gcenKIqiXAJhnyqrKFcWIcT7aHm1T7f3sShKU6y116FSyjvPubKiKIryu6FyxJUrlhAiEK12u9k+mRWlPQmt+8U/ofWYoiiKoii1VGqKckUSQjyP1kDwZWu6iKJcdoQ28FIW8LWU8sf2Ph5FURTl8qJSUxRFURRFURSlHagacUVRFEVRFEVpByoQVxRFURRFUZR2cMU11vT29paBgYHtfRiKoiiK0ibi4+PzpJSNjkCsKMqV7YoLxAMDA4mLi2vvw1AURVGUNiGEONbex6AoSutQqSmKoiiKoiiK0g5UIK4oiqIoiqIo7UAF4oqiKIqiKIrSDlQgriiKoiiKoijtQAXiiqIoiqIoitIOVCCuKIqiKIqiKO1ABeKKoiiKoiiK0g5UIK4oiqIoiqIo7UAF4oqiKIqiKIrSDlotEBdCvC+EOC2EONDEciGEWCyESBdC7BdC9G+tY1EURVEURVGUy01r1oh/CNzQzPKxQIj1cz/wVisei6IoiqIoiqJcVgyttWMp5Y9CiMBmVrkJWCGllMAuIYSHEMJPSnmytY6pMS9c/Tlds72QesEZnzLKXMqRQlo/4FrghlO5EYsOTgQm8a//zbHb/m/jV+JU5oFZD8UepzEbS7HoLdbtLVhkV8zCSLWDBXdxkMXL59ttP37+YopcXal0NNM1JwUHUyU6iwWdtCAsFrK79cSkN2CwWBhV6cCCJx+22/6Oxx7GojdgMJvxPHEYvakavcWMsJjRWSwYO3hgMJlwrK6i74y/MXbiqNptM4/lsHdcHxwqyzGYqvi5S1ckApNOh1kIkGYG5B3HpIMKvY7RXx+jWw/f2u2/WP0jqS+PpVInKDU4kOwZTbXOQLVeT7VOT7WswNVykFKjnhK9Cwc+SbM79oUrtvJc3EMgdRiqPehiGYhAh0CPDj2l5kLOGPYhpB4Xcw/y3/vYbvu/LtnK0t3vICxGXOhCsGtf9BjQCyMGYSS3pIDjxZnoLY6EeAWz472b7Lb/19IcPvnqFAbpQoBPJ2LCPdDrBHo9GAyQnQ2ZmdrXQ4bAw/aXnnXr4JdfwNERAgOhRw8wGrWPgwMUF0N1NXTsCN27g5/fed2SiqIoiqL8TrRaIH4e/IEsm+nj1nltGogv3fMo2WbtMFyOuuCGGw444IgjDjiQRx5llGHEyKDTfwDsA/HjW7ZQWJ2LO+5EEYU//nS0/nPEEQCBAOCXod0blD/7n9E4VgvrVDBVRqhygGrr/26FoJNg1kPcxNQG2/f7/iZ0ZkGFM8T3hwJPKOugfUo7glM55HeCM17wSu4Zu20LCwq56d//0SakxKmykg6VlThXVeFUVYVDVRWv+/mht1hwrK7m28JCulEXiJ8+tJ/vb12IS0UFXoWF/OmXX3AvKcC9tBT30lI6VFRg0unwLcjHsSoHPrE/ds+NH1L9eRJSQKkRDnntoMwIZUYodQCjCaJyocIIR911gH0gfnTfhzxwahW5HeCwJ/zaCcqNQM3l7Fy3bm65N9qzX53Fh2ZzYth/AfgVWAPaRTc5gckZHKuhdxFIPetTr+ZhttptP/PzZznh8j+o6gi7YuBkrPZ1lQtUeIBjEQgzFPszKDSIXdvc7LaPiYHERNDpoHNn7ePkBM7O2ic7WwvmnZ3hgQfgoYfsr9/HH8OZM+DrC717Q9eu4O6uPTgoiqIoinL5uyL+ZAsh7kdLX6FHjx4tum+TrK79usT6rynZlZkN5q2t/pJiihpdX48eAAsWDBgYffImHmeG3Tqfmj9CYqYb3RjAALyqvXCobmRngKE2YK8TG18Xdw7Z2eShA5D5pKPddEl1Fe/PgFIXKHITbB/mxBlvJ/I7acF7YRew6K3rAnoH+9vltFHH97GxtdMfjBvXZNl6k4kqKdGJunM47dqBa15/HZ/CQoJPnGDizz/TNT8f/5w8nKuq7LbvedbSYJ837k/knt3286p1kO+sfSTQrUgL7ON8i+Af9ut2LcqnWzEcd4fTHaHaABiqtI/d99SE2flUg/ILvDeB515tIuCnJs8dILlwMGD/DUrvOwU56hfMFR6cPDqak8evhkJvKPWBUl+QAqo7gMmZnTsbBuJz52qBeH0dOmgBeXk5SKlN//3vcO+99utt2gReXhAVpa2jKIqiKErbas9A/ARgW0XczTqvASnlO8A7AAMGDJAteRDVDtVQcX7rdvL3aLi9rhoaxogAmDHXrUc1nr6uDdZZafkUE6ba6Y50xMv6zxtvjnEMRxzpQhduDbnv/A60CVGjQuymO+o86HmsLpKrH8ibBSCgyqjVrvv94m633C8sGJ0JLOdxF0kh7IJwgOrIMLbHxNRO/2vq1NqvPYqL8Swu5rSnJ26lpYQfy+D7evuMdnFpUI7RAr6l2qeGWxUMPN3wtnkxLoU/JGpf5zvBr35w0gWOu8FRTzCYwbUK9naBLG99w7I6lp37xK2cdQ3vnUqfneBqfbjz29twI4sOdBYw6zlY/jDwit3i0k67QOcCBb20gN2qrEz71CgshJONvGe6+WaosN77Xl4QEKDVqtd8srMhKAiuugquvlpLwVEURVEUpeW0ZyC+FnhICLEKGAQUtnV+OEBuySnKysooKCjAZDJhMpmoqKigvLyciooKkpKSOHnyJIWFhdx6660Nth86agjp6emUlZXh6+tLRUUFhYWFFBUVUVlZabfuDX8Z2WB7szBrVbdWpdZ/mdjXvieSyIyQGXbzLBYLM11n4qH3oJexFzOvnUkncyfMRWbMxWaqz1ZTllKmPShI6BPby277gHI38pu5NnqpbedcqX06dfe0W97XEsm316ZjNkCpu+D4CAeyAwUZAZDew8KhTiYKpPaU4tBIvoR57A2Qk9No2QWurhS4ag8upc7OlLq7N1hnzZ33MPRv8/EoKaH/4cNM//Zbgo8dIzIjA5cK+6crX7/ABtv/wS2Qmme/ThUw5mjT16I0qqrBvOWdh5B21IFkPwOmgB44OnekpKqEkqoSCisKSTuTRmFlISaLieuG+jTY3tW7hILKBrPr6KxPeHozgcENX5NU3TYWHAoAMGaPQHdiCFUng5H5QZAfDPoKKPGD6o50b5gVhe3teeaM9klIaPxQPvkE7rjDft5TT2lB+rXXqhp1RVEURbkYrRaICyFWAtcA3kKI48AzgBFASvk2sBEYB6QDZcA9rXUszdHr9bi6uuLq2rC2GmDEiBHNbv/tt982uayyspL8/HyysrLIyMhg1KhRDdbp1asXBQUFlJSUYLFYqK5uIi8FGDxqsN30mTNnSC3W8sZ/4RdWfraSgIAAoqOj6TOiD7179yY1NZVrrrmG6N7RGDzsv90O/g743OZD9ZlqZLXEsYcjVTlVtR/TmbqaemEU6BztO9npkmLmKGAwgfsZiftXlUTZLBdOAmHQYfRzxHFAR6j3HDLEy4vh5eWcNZnQA046HSerqsiuqsIk7WuwPRqp/U6IjaUqP5/Tnp5sGjCATQMG1C4L0unwqq6muKqK3mfPMlUIbq6/gwtIpu7YrWeDebe+vQ1SUrSJPuUwcaKW59EnCiIitEi3QwcQAikb1sgvHPUse3P2klOSg6ezJ2XVZeSW5ZJbmktOSQ6FlYW1617bL7TB9sKxuPYhrrrrj9D1R/vl6JBYcJDuiJBV2HZiVF2t5aNXVoKliTc6tgYOtJ8uKIAXX6yb7tMH+vaF6Oi6j68v6Bu+SFAURVEUxao1e02Zeo7lEniwtcq/HDg6OuLn54efnx9XXXVVo+ukp6fXfi2lJD8/n+zsbLKzszl27Bjff/89WVlZ5ObmNsiP37mzYVL4sWPHOHbsGOvXr6+d99xzz6HT6Thx4gRdunSpne8c6EzUf6Ia7KOGqcREyd4SylLKkFUNA8nytPKmTx6QFRKJpDKtHNPphjXKY446MjixCz63+mBwr7sVLVKSV11NalkZe0tKSCsvJ8jZucH2GRVN5xQdtlg4rNeDszPJzs4c6tixQSCeumED7jodXYqLtdyNnBzt/8xMOHoUfv4Zjh/X8jwiIxsWkp1d9/X+/dqnRocOWivL8nKIjES8/DJcc43d5v836P+aPH6AkqoSsgqzSM5LZkj3IXbLqsxVCCHs3qbUJ605U1WikK6+RrtlRiOEvBpDVOcoxva8iSGdbibvlAPZ2dppHT4M//sf5OVp6Ss96z2H/Pyz/XT906/h6ak1Sl23Dhp5llIURVGU3zXRWE3d5WzAgAEyLi6uvQ/jspCYmMiCBQs4cuQIeXl55ObmNlmjbjAYqKqyBm9WW7ZsYfbs2YwYMYIpU6Y0WmPfHCkllScqKfqliOq8amSVpCypjNLkUsqSyqjOrTuWDr07cFWi/cPI/nH7yf9aS44xdjHiPcEb9xHudLq+Ew4+DucsP6O8nB8LCkgoKaHMYiGvupqUsjIOlZXZZOdr7vL15aOICLt5Qbt2caSiAle9nj/5+TGza1dCnJ3trhGgVR+bzVoVsq2uXRtPvm7M88/D00/bz/vhBwgLu+h+DaWU5JXlkZqXytGCo6Tnp5N+Np30/HSSc5MpriquXbf4iWJcHOoi4b05e+m3rF/t9A3BNzAqcBQjAkYQ6xeLQWfAIi3odY1Xaa9frzX+zM/XLk1zdDqoqrKvHT9+XPsMGgT1L7eiKPaEEPFSygHnXlNRlCuNCsR/Q6qqqjh06BD79+8nMTGRbdu2sW/fPsrKyggLCyOlJo3C6s477+TTTz8FwGg0MmHCBCZOnMj48ePx9va+5OMpOVBC/sZ8in4pwmOkB91md7Nb/rP/z1RlN6wpR4DrAFdc+rrgea0nPpN9EPrzj9YqzGaSy8rYcOYMPxUWklxWxstBQdzWubPdesZt2xqkwHQ2Ghnl4cFN3t50dXSkv4sLrs2lsJSVQXIyJCXBwYPaZ+9eLcq0deCAlrZSo7paqzE3m7VWkj/8oHVG3kKklGQVZbH7xG4STyXy3Kjn7JY/9d1TvLjjxUa37WDsQHTnaPaf2s+owFHc0+8ebo1s2D6ixunT2iVITKz7JCTU5aD36AHHjtlv8+CDsHSplh00eLDWq8vQoarrRUVpzO81EI+Pj+9sMBjeBXrTugMQKkprsQAHTCbTfbGxsacbW0EF4r8DZ8+epbi4uEFqS3BwMIcPH26wvk6nY9iwYXTv3h1HR0fuvPNOhg0bhtFobLDupYjrH0dpYinSdI57UAcBTwfQ87mGedoX62RlJf47dzaX2QFoXUOGdejA/6KiCO3Y8fwLOHFCy9/4+mvYtw/27NGqhmt8/jlMmVI3bTTCyJEwbpz2CQmBU6dabRSgbce2Mf/7+SScTKC0urTZdd0d3Tn7+NmGbwqaYbHArl2wciUEB8Mc++736d1be2ax5ekJ48drqfbXXgseDTuaUZTfpd9rIL5v3761Xbp0ifDx8SnS6XRXVrCiKIDFYhG5ubnuOTk5STExMRMbW0cF4r9jixcv5rPPPiMxMZGysua74rvvvvtYvnx5qxxHaXIplccrKdpVRP7mfIp2FjXoEjLi8wh8b/e1myctEqG7+LyGSouFnYWFrD1zhkNlZfxUVESBydTouqlXXUVoS3YNMmcOLF7c9PIePSArS6smfvBB+6C9BUkpSc9P58djP/Jj5o9sy9jGsUL76usBfgPYc/8eu3kf/PoBqWdSmd5nOlGdm25n0JSoKO0lQlN0OnBz09Lq//53+5cJivJ78zsOxI9ER0efVUG4ciWzWCwiMTHRMyYmpldjy1UgriClJCUlhbVr17J27Vp27tzZoJePf//738yaNctuXnFxcZO9zVyK6rPVnF51msyXMqk8XgkCRpSPQOdQV6NcnV/Nz34/0zG6Iz3+1gOfW3wuqMa2MRYp2V9SwrozZ1iRk0O6tTGop8FA/rBhduv+WlzMHcnJPNa9O1M6d8bpQrsHMZlg505Ys0arNU9ObnrdXr201pNt5FjBMX7I+IFPEz/lh4wfWHzDYh4Y+IDdOv6L/Mku1hqrLrxmIfNHzr/gckpKtPSUI0e0xpy2bV9t3XmnNoqoovxe/Y4D8YyYmJi89j4ORblU+/bt846JiQlsbJkKxJUGTp06xZo1a3j//feJj4/HYrFQUFCAm1vdEO1lZWV4e3sTExPD3LlzueWWW9C3Ql915gozxbuL8Rhhn6eQNieNE4vrxn9yCnbCb4YfvtN9cerhVH83FyWzooKPTp7EWa/nr/XSeq7du5dvC7Q+vEOdnVkfHU3IpdSYHz+uBeQbN8KWLVBqky4yeTJ8+aX9+t98A/7+rV5VXF5djk7ocDTUjeaTX5aP18teduvdGHojDw58kOuCrkMnLjyVU0otr3ztWi1rJzW1bllWFnSzb15AerqW8qIovwcqEFeUK5sKxJWLVlZWxt69exkyxL77vCeffJKXXnoJ0LppXLJkCVOnTqXjheRRX4KdgTupPNbIaDgCfG7xIeDpAFxiWqe/PLPFgtP27Q0aeo7x8GCmvz8Tvbww6i6hXVF5OXz1lVZd/NNP8OuvWifdNaQEHx9tBJ4JE+D117Va8zay/9R+Rnwwwq6f8xrBnYL5S+xf2JS+iTui7+D2qNvp6HDh98TevfDqq9qooGvX2i9buxZuukl7Dpk9Gx59VPW8ovy2qUBcUa5sKhBXWlx4eDipttWWgLu7O/PmzWPu3LmtkrJiy1xuJvPlTHKW51BdUI2lpOGoNE69nAheHIz3+EvvAcZWpcXCs0eP8vbJk43mlPs5OBDs5MQtPj7M9PfH4VKC8hMntIjT1rffaq0ZQYtAFy+GBx5o0y5HzBYzm9I38ebuN9l8eHOT63V3686ROUcw6Fru2Pr10wL1GgMGwAsvaJdEBeTKb5EKxNtPamqqw4033hiSlpZW27x83rx5XV1cXMwLFy48VTMvPT3deMcdd/TMy8szCiG4++67c+fPn38aoKysTAwaNCi8qqpKmM1mMWHChLOvvfZaNoC/v390x44dzTqdDoPBIA8cONBonuLhw4eN33//vcuf//zns619zraaOr7bbrst8LvvvnP38vIy2V6b+p5//vnOK1as8JFSctddd+UuWLDgNMBzzz3X+eOPP/YRQhAeHl72+eefZ3To0OGyC0gb+15fjOYCcdUdkHJR3n33XW666Sa7dJTCwkKeeeYZgoKCGDduHLNmzSK7qcTfS6R31tNzQU+uzrqaoaeGEvFpBJ7XetqtU3GkggM3HuDowmbGrr8IjjodLwUFcWboUDZGRzPRy8vuB+lkVRXbi4p4+PBh/HfuJK+qkS4az1f9IBy01JUaUsL//Z824NDHH2u551VV2v+tSK/TMz50PJvu3MShhw4xd/Bc3B3dG6xXVFnU4mXX77o9Lg6uvx5GjdJeICiKorQ1o9HIq6++evzw4cMH9+zZk/zee+91jo+PdwJwcnKSO3bsSE1NTU06ePBg0nfffef23Xff1b4q3LZt26GUlJSkpoJwgI0bN7olJCS0YI8B56+x47v33nvz1q5dm9bcdnv27HFasWKFT0JCQnJycvJPHVUfAAAgAElEQVTBTZs2eRw4cMDx6NGjxnfeecd37969SWlpaQfNZrN49913O7X+mVyeVCCuXJRhw4axZs0acnJyeOWVVwi2SdjNzc3l66+/5q233iIwMJA9e/Y0s6dLp++gx3eaLzHfxBD7aywu/WxSUnTgP6uRYLYF6IRgrJcX/4uO5ujgwcwPCKCLg/1ARAXV1ehaupr2b3+DZ5+1H6oyLQ3uugsiIuC++7SBglas0AL1VhbiFcKi6xdxYt4Jlt24jAjvuoGTXhrzUoPa8NS8VMyWc4wC1IycHC1zZ+BAcKxLXWfbNhg2DIKCYNmyi969oijKBQsICKgeNmxYGYCnp6clKCioPDMz0wG0LoHd3d0tAFVVVcJkMokL6Vxg8+bNLvPnz+++fv16z/Dw8MikpKRzj3jXysaOHVvi4+PTbI1PYmKic79+/UpcXV0tRqORoUOHFq9atcoDwGw2i9LSUl11dTXl5eW6bt26NRiNsKioSHfNNdcEh4WFRYaEhEQtX77cE2Dp0qWdoqOjI8LDwyOnTZsWYLJWPC1ZssQrNDQ0MiwsLHLSpEm1/R0/++yzviEhIVEhISFRCxcu7Azam45evXpFTZkyJSA4ODhq6NChISUlJQLg8ccf7xIYGNg7NjY2LC0tzbG5Y2kJKhBXLom3tzePPPIIKSkpfPDBBw36Kq+ursbBoe1+Z7j2dSU2PpaQpSEYvAx4TfDCwdu+/MqcSop+bdma2h5OTizs2ZNjgwfzWlAQLtZ0lFldu9KpXv/rZ6qrG/RKc0E8PeGZZ7RWjM89Z9/hdnq6VjN+5AjcfbeWaN1GOjp05P7Y+zk46yA/zviRmbEzuT/2frt1SqpKGPTuIGLejmF18uqLvg6TJsHu3VpnMvWzco4c0eZ16QJ5KrtUUZQ2lpqa6pCUlNRh5MiRJTXzTCYT4eHhkb6+vjEjR44sGj16dG2L/DFjxoRERUVFvPLKK43mUV5//fUl0dHRpatXr05PSUlJioyMvOjXrLGxsWHh4eGR9T9r1qxpMp/0XMfXlL59+5bv3r3bNScnR19cXKzbsmWLe1ZWlkPPnj2rH3zwwZyePXv26dy5c4yrq6t58uTJDf4or1692q1Lly7VqampSWlpaQcnT55clJCQ4PTFF190iouLS0lJSUnS6XTy7bff9oqLi3N65ZVX/LZt23YoNTU1admyZZkA27dv7/DZZ595xcfHJ8fFxSWvWLHC56effnIGyMzMdJo9e/bp9PT0g+7u7uYVK1Z4bt++vcNXX33VKTExMWnLli1p+/bt69jUsVzYlW+aCsSVFqHX65kxYwaHDh3i9ddfr+1hZejQocTExNitazKZLi0QPQchBP4z/RmaO5SoLxv2KpI4NpGE/gkk3ZWEpbphbvmlcNDpeLh7d04OGcKLPXvyUlCQ3XIpJQPj4+kXF0fqOfpuPycPD1iwADIyYOHCxkfAsenppq0IIRgeMJylNy5Fr7PvSWfOpjkUVhZyMPcgf1n/FypNjTS4vQD+/vDWW5CSonVzaKuyEjr9bl92Kspvz7x5dBWC2PP5TJ1KQP3tp04lwHadefPoeq4ym6q5bmp+YWGhbvLkyUH/+Mc/sjp16lT7B8ZgMJCSkpKUmZm5PyEhoeOePXucAHbs2JGSlJSU/M0336QtX76889dff91oLwNHjhxx6tu3bwVAUlKSw+233x5www031LbSX7JkidfTTz/tO2XKlIDx48f3Wr16daO//OPj41NTUlKS6n8mTZpU3Nj653t8jenfv3/FnDlzcsaMGRM6atSokKioqDK9Xk9ubq5+w4YNHunp6Yk5OTn7y8rKdEuXLm3w27p///7l27dvd5s5c6b/pk2bXLy8vMybNm1yPXDgQIeYmJiI8PDwyB07drgdOXLEcfPmzW4TJkw46+fnZwLw9fU1A/zwww8u48aNK3Bzc7O4u7tbxo8ff3br1q2uAP7+/pVDhgwpB+jXr19ZRkaG49atW13GjRtX4OrqaunUqZPluuuuK2jqWM73OpyLCsSVFuXo6MicOXM4ceIEzz33HB988EGDde6//34mTZpETk5Oqx6LEAKd3v4Wz34vm5K9WiXF6Y9PsztsN0W7Wz6P2cVg4ImAADrU69Lx7exsjlZUsK+0lOg9ezhWXn7phbm7w/z5WkD+/PN1AXm3blqtuC2LpU3SVRpjkRY2p9c17Mwry+P6T68nPT/9kvcdFKS9CPjmGwiw/vl9+WX7wUwVRVEulK+vr6mwsNDuF3l+fr7e29vb9NJLL/nU1ChnZGQYKysrxfjx44Nuu+22/Lvvvrugsf15e3ubhw8fXrxu3Tp3gJ49e1YD+Pv7m8aPH1+wc+fOBt1MnTx50uDq6mquGd06MjKy6j//+Y/dyGtxcXEdFi5ceGrVqlXHPvzww2OrVq1qNHXiQmvEz+f4mjN37ty8gwcPJsfFxaV6enqaQ0NDK9atW+fWo0ePyq5du5ocHR3lpEmTCn7++ecGAX6fPn0qExISkqKjo8vnz5/v/9e//tVPSiluu+22MzUPEBkZGQcWLVp0UY3RHBwcav8Y6vV6aTKZmswXauxYLqbMxqg/U0qrcHFxYcGCBYSEhNjN37JlCx988AFr164lLCyM9PRLD8IuhKySCEPdz1rF0QoSBieQ9nAapuLWbeAI8JZN49VqKfljUhJpl1ozXsPdHZ5+WgvIZ86EL76wT6IGeOUVrcvDoy3bgPV8mC1mHrrqIVwc6n7f/njsR/ot68dHez9CSkmFqeKSyrj2Wu30t22DP/3JfpmUcPvt7XLqiqJcodzd3S2dO3euXrt2rSvAqVOn9D/88IP76NGjS5544oncmoCwR48e1VOmTAkIDQ2tePbZZ+162MjOzjbk5eXpAUpKSsTWrVvdIiIiKoqKinRnz57VgZaDvHXrVrc+ffo0qJ1JS0tz8PX1bTIdpbKyUhgMBqmz1jw8+eSTfrNnz85tbN0LqRE/3+NrzokTJww157BhwwaP++67Lz8wMLAqISHBpbi4WGexWPj+++9dIyIiGvzyz8jIMLq6ulpmzZqVP2/evJy9e/d2uOGGG4rWr1/vWbPfU6dO6Q8dOuRw/fXXF61bt84zJydHXzMfYNSoUSUbN270KC4u1hUVFek2btzoOWrUqEZr/wFGjx5dsnHjRo+SkhJx9uxZ3ZYtWzyaOpYLuQ7NUYG40qYef/zx2q+Li4tZtWoVplbu4cOW/0x/Bp8YjOsgV4SjNSCXcOKNE+yJ2sOZDWdatfyVkZH0telr/ZfiYvrGxbEsO7vl0nXc3bU+yAcNsp9/7Bg8+SRs2KANBPTLLy1T3nky6o38bdjfODL7CLOvml3biLOkqoQZ/5vBpFWTCHojiFd/fvWSGnMCjBjRsCvDhx6C//4XQkLgxRcvafeKorSDRYvIlpL48/msXMmx+tuvXMkx23UWLeK8alI/+uijoy+88IJfeHh45MiRI8Mef/zx7KioKLu8ui1btrisWbPGa8eOHa41tcyff/65O0BWVpZx+PDhYaGhoZH9+vWLHDVqVNHUqVMLjx8/bhg8eHB4WFhYZP/+/SOuu+66gltvvbXBK9qYmJiK/Px8Y0hISNSWLVsa1Ehv3rzZZfjw4SUWi4WZM2f6jx8/vrCm4eilaO74JkyY0HPYsGHhR48edfT19e3z2muv1eaPjxw5MjgjI8MIMHHixKCgoKCoG2+8Mfj111/P9Pb2No8ePbp0woQJZ/v06RMRFhYWZbFYxLx58xo8OMTHxzv37ds3Ijw8PPKFF17oumDBgpOxsbEVTz/99IkxY8aEhoaGRo4ePTo0KyvLOGDAgIpHHnnk5PDhw8PDwsIiZ82a1R1g2LBhZdOmTTvTv3//iNjY2Ijp06fnDh06tMmHiWHDhpXdfPPN+b179476wx/+ENKnT5/Spo7lUq9vDdWPuNJmpJS89dZbzJ07lyqbLv0GDRrEihUrCA0NbdPjKT9azqEHDnH2G/tuWV36uhCzNQajh7GJLS+NWUpezsxkQUYG1TY/fzd4euLv6MhTAQH0dHZu+YLvuQc+/FD72tkZduyA/v1bvpzzFJ8dz7TV0zh05lCDZdOip/Hp5E9brKyjR7X0Fdtfd489prV1dWqZgVgVpdWofsQVWzk5Ofp58+b5b9++3e3OO+/MKyoq0r/44osn33zzTe+VK1d6xcTElPbt27f8sccea7RWXGl7akAf5bKSlpbG9OnT+cWmRtbZ2ZmXX36Z8vJy7rvvPjwaa3jYCqSUnP7sNOkPp1OdV9d7kt5NT2xcLB1CWq/b1l+Li7kzOZmkeqkpTjodrwcHc7+fX5MNgi6YlDBmDGzdWjfPwQHee69hK8c2VFpVytzNc1mesNxu/tzBc1l0/aIWK0dKbQTORYvsg/GoKK2Xx3Z8HlGUc1KBuNKcu+66q8eKFSsy2/s4lKapAX2Uy0pISAg7duzgxRdfpKbxSXl5OQ899BCPPvoogwcP5mgbJfIKIfC9w5eByQNx6GbTzaEAB7/W7Xaxn6sr8bGxzO3WzW5+hcXCspYeCEkI2LwZ/v53qOlOsaoKpk/X8sotFi11pY11dOjIOxPe4cvbv8TDUXv40gs9f+7/5xYtRwgtPX7/fhg8uG7+wYNaBs8777RocYqiKG1GBeFXNhWIK+3CYDDwxBNPsHv3bnr37m23LDU1lQcffLBNj8fB24HBRwbjeb0nwijov6s/BpfWHzLeSa9nUXAw38bE0Nmmv/E3Q0Jarja8htEITz0F+/ZpI3HWqBkfPiwM/vrXVh+VszGTIyaTOCuRUYGjWDJuCRE+EXbLz5af5UzZpefv9+4NP/8M//43dLC+7DCZ4C9/gZgYrctDRVEURWkrKhBX2lXfvn2Ji4vj0UcftZsfHR3d5seiM+qI2RTD1dlX0zHcvj2MlBKLqWX7HLc1xtOT1KuuYoqPD3/r3p2h7g2Hi28xERFaNHrDDXXzvv9ei0JffRXmzGm9spvRza0b3971LX+J/Yvd/EpTJRNWTmDI+0M4cvbIJZcjBMyapT2P2Kak7N8PPXtCrsqqVBRFUdqICsSVdufo6Mi//vUvVqxYgV6vZ+zYsbz00kvtdjz1R+IESJmRwi9Bv1CVe9EDmp2Th9HIyqgoXujVq8Gyt0+cYF9JSSNbXSR3d1i3DmbPtp8vBIwb13LlXCCd0DV4E3Dbf2/jp6yfOHTmEEPeG0JBRaPd816w4GCtm8PAwLp5p061S4aOoiiK8julAnHlsjF9+nS2b9/O6tWr0dUbiSUhIcGup5W2dPzN45xacYrKzEp2Be6iaE/LDwBkS1cvEH0nO5uZaWkMSUjgm/z8livIYIA33tDyNGqut6cn9O3bcmVcoqzCLH7K+ql2Otw7HHfHlntb4OIChw5BbKw2/cknMOB31yROURRFaS8qEFcuK1dffTVO9fqTS0hIYNiwYVx33XXkt2Qgep5OfVI3NoOlzMLe0Xs5+/3ZZrZoOdkVFTyYlgZAmcXCvPT0lutvvMasWbBpE/j5aUNT+vvbL7e0XkrOubg5utG7c10bgm3HtnH/uvsvuZ9xW0Yj7Nmj9eY4dWqL7VZRFEVRzkkF4spl7cyZM4wcOZLy8nK2bdvGlClT2vwY+v/cH6+JXrXTlhILiRMTKdxV2OplF5rNeOjrRlc+WFbG0pbuUQW0xppHjtRVDdc4fVrrZuSbb1q+zPPg7uTOpjs2MTFsYu28d399lz9+8UcqTZWYLWYs8tIfFISAoUMbzv/kE619q6IoiqK0BhWIK5e19evXU2KTG20wGNo8RUXoBdH/iybmuxgc/LX8cUuphcSxiZTsa8G87UZEdOzInthYgmzeEjyUlsZTR460fM14/ZFtTp6Eq6/Wqotvuklr0NkOnI3OfHn7l9wVc1ftvC+Tv2T8Z+N5YP0DzFgzo0WC8fq2b4e779ZG4bz77hbfvaIoiqKoQFy5vN1+++1MmjSpdvrrr7/m3nvvbfkg9Dx4jvYk5tsYjD5aN4OmAhN7x+yleF9xq5Yb6OzMrv79GeTqWjvvxcxMHk5Pp7C6upktL9GOHdqQlKD1qJKT03plnYNBZ+CDmz7g4UEP18777uh3vPvru3y8/2Me2/JYi5d56611WTkrVsDnn7d4EYqiKMrvnArElcuas7MzX3zxBbNmzaqd9+mnnzJ//vx2OZ6O4R3p800f9O5auojpjIlfB/9KWXrZOba8NN4ODnzXty/jOnWqnbf4xAl67NrF+ydPtk6hH35oPwylo2PrlHOedELHousX8fdRf2+wbPeJ3VSaWrYT8G+/BWfnuun774fExBYtQlEURfmdU4G4ctnT6/UsWbKE+++/v3beCy+8wBtvvME//vEPLG3cmNC1ryuRKyPB2rmJpcJCfGw8lsrWPY6Oej3/692b23x8aucVmc38OTWVjWcufbCbBlaurOtoW0qYNk2LTtuREIKnRjzF0nFL7eYP6T4ER0PLPihER8Pu3VBzuYuKtJ4djx9v0WIURbnM6fX62PDw8MiQkJCosWPH9iouLj6v2Ck9Pd04aNCg0KCgoKjg4OCo559/vnPNsrKyMhEdHR0RFhYWGRwcHDV37tyuNcuef/75ziEhIVHBwcFRCxcu7Nz43uHw4cPG5cuXe17a2V04f3//6NDQ0Mjw8PDI3r17R0Dz52qrqfWaux6Xm3nz5nVdsGCBb0vtTwXiyhVBCMG///1vxtn0cf3www/zxBNPMG/evDZPVfEa60XnqXW/Z7rc2wWdY+v/OBl0OlaEh3OVTZqKBTjeGkNCurnB119DaKg2XVUFkyZp0anJBIcPt3yZ52nmwJm8P/F9AGbEzGDhqIWtUk7v3rBlC9Rc7uPHtWC8sPXb6SqKcplwdHS0pKSkJKWlpR00Go3y1Vdf9Tn3VmA0Gnn11VePHz58+OCePXuS33vvvc7x8fFOAE5OTnLHjh2pqampSQcPHkz67rvv3L777ruOe/bscVqxYoVPQkJCcnJy8sFNmzZ5HDhwoNFaho0bN7olJCR0aMlzPV/btm07lJKSknTgwIFkaP5cbTW1XlPXo+3PrO2pQFy5YhgMBj7//HP62w6HCLzxxhv88ssvbX48EZ9E4DXJi8DnAgl5LaTNynXS69kQHU2gtXHlQFdXbvc5r78LF65zZy0S7dZNmy4thbFjYeJEGDRIG46yndzT7x62zdjG+ze9j4PefhAmk8XUYuXExMDq1Vq366Clp0RFtWvKvKIo7WTYsGEl6enpjqmpqQ4hISFRNfMXLFjgO2/ePLta3ICAgOphw4aVAXh6elqCgoLKMzMzHQB0Oh3u7u4WgKqqKmEymYQQgsTEROd+/fqVuLq6WoxGI0OHDi1etWqVR/3j2Lx5s8v8+fO7r1+/3jM8PDwyKSmp4Uh0bai5cz2f9Zq6HvUVFRXprrnmmuCwsLDIkJCQqJo3AkuXLu0UHR0dER4eHjlt2rQAk0n7G7BkyRKv0NDQyLCwsMhJkyb1rNnPs88+6xsSEhIVEhJS+9YhNTXVoVevXlFTpkwJCA4Ojho6dGhISUmJAHj88ce7BAYG9o6NjQ1LS0tzbO5YLpQKxJUriouLCxs2bKBHjx6183x8fIit3+1eGxBCEP1VNIELAtu8bG8HB77p04cHu3ZlR79+eBiNrVdYjx5a94Ve1i4c8/O1mvIzZ2D8eMjLa72yz2FEwIgGI3GuP7Se6LeiOVF0osXK+cMf4P3366ZPnIA+faC8vMWKUBTlMlddXc3mzZvdoqOjL/gnPzU11SEpKanDyJEja7vaMplMhIeHR/r6+saMHDmyaPTo0aV9+/Yt3717t2tOTo6+uLhYt2XLFvesrKwGAe31119fEh0dXbp69er0lJSUpMjIyIvuTiw2NjYsPDw8sv5nzZo1rk1tM2bMmJCoqKiIV155xft8zrUx9ddr7HrU32b16tVuXbp0qU5NTU1KS0s7OHny5KKEhASnL774olNcXFxKSkpKkk6nk2+//bZXXFyc0yuvvOK3bdu2Q6mpqUnLli3LBNi+fXuHzz77zCs+Pj45Li4uecWKFT4//fSTM0BmZqbT7NmzT6enpx90d3c3r1ixwnP79u0dvvrqq06JiYlJW7ZsSdu3b1/Hpo7lwq68RgXiyhWnS5cufP3117i7u+Ph4cGGDRswtmYgeoEqT1WSfHdyq6fLhHTowJLQUBzqjUJaYjJRYmq5GmEAIiK04LtjvTeFgwfbt2hsZ+8lvMfElRNJyUth3GfjKKpsuVFQp0/X0uRr5ObCnDkttntFUc5h3jy6CkGsEMTOm0eDHOI//5luNcufeYYGObxTpxJQs/yVV2gQQDalsrJSFx4eHhkdHR3ZrVu3qjlz5lxQ7UNhYaFu8uTJQf/4xz+yOnXqVNuYyGAwkJKSkpSZmbk/ISGh4549e5z69+9fMWfOnJwxY8aEjho1KiQqKqpMbzOWhK0jR4449e3btwIgKSnJ4fbbbw+44YYbetUsX7JkidfTTz/tO2XKlIDx48f3Wr16tVtj+4mPj09NSUlJqv+ZNGlSo12C7dixIyUpKSn5m2++SVu+fHnnr7/+2uVc53o+16Sx61F/u/79+5dv377dbebMmf6bNm1y8fLyMm/atMn1wIEDHWJiYiLCw8Mjd+zY4XbkyBHHzZs3u02YMOGsn5+fCcDX19cM8MMPP7iMGzeuwM3NzeLu7m4ZP3782a1bt7oC+Pv7Vw4ZMqQcoF+/fmUZGRmOW7dudRk3blyBq6urpVOnTpbrrruuoKljaep8m6MCceWKFBkZycaNG4mPj2fgwIHtfTi1yo+WsztkN6dWnOLwY22fQ326qoqB8fHcdvAg1S3diHXgQFizBhxsKme6dGkYnLeTSlMlnx34DIn2AFRYUUheWcvW1n/yifbsAdrlePPNFt29oiiXoZoc8ZSUlKSPPvooy8nJSRoMBmnbUUBFRYUO4KWXXvKpqVHOyMgwVlZWivHjxwfddttt+XfffXdBY/v39vY2Dx8+vHjdunXuAHPnzs07ePBgclxcXKqnp6c5NDS0ov42J0+eNLi6upprKqEiIyOr/vOf/xyzXScuLq7DwoULT61aterYhx9+eGzVqlWNpk5caI14z549qwH8/f1N48ePL9i5c2dHgPM51/NZr/71sNWnT5/KhISEpOjo6PL58+f7//Wvf/WTUorbbrvtTM33KCMj48CiRYsuauQ7BweH2ho0vV4vTSZTw/yYZo7lYspUgbhyxRoyZAi9evWymyelZPny5eS1U7rEwVsPYi7WHoqPv3Kcgh+b/F3U4opNJiJ27yalvJxNZ8/ywKFDLV/IH/4An32mjQv/zDPw2mstX8ZFSstPY9fxXbXTfq5+dHPr1qJlCAE//ggLF8KuXe3eo6OiKO2kW7dupvz8fENOTo6+vLxcbN682R3giSeeyK0JCHv06FE9ZcqUgNDQ0Ipnn332lO322dnZhry8PD1ASUmJ2Lp1q1tEREQFwIkTJwwAaWlpDhs2bPC477778uuXn5aW5uDr69tkOkplZaUwGAxSZ31j+uSTT/rNnj07t7F1L6RGvKioSHf27Fldzddbt25169OnT7nFYqGpc7XV1HrNXQ9bGRkZRldXV8usWbPy582bl7N3794ON9xwQ9H69es9a67bqVOn9IcOHXK4/vrri9atW+eZk5Ojr5kPMGrUqJKNGzd6FBcX64qKinQbN270HDVqVJMDgowePbpk48aNHiUlJeLs2bO6LVu2eDR1LE3tozmGi9lIUS5Hp0+f5o9//CM//PAD69evZ82aNQ3yh1tbxMcR7Ineo3VlAqTcm8KAXwdgcG39H7Wv8vLIt0lJOVVVhUVKdC19DW65BTIyoGsjvUtZLKBrn+f73p1788nNnzD5P5MB2HV8Fw+sf4D3Jr7XoveB0Qjt1I29ovyuLVpE9qJFNFnTuXw5x5cvp8kORleu5NjKlRxravmFcHR0lI888sjJgQMHRvj6+lYHBwc3CBq3bNnismbNGq+QkJDy8PDwSIDnnnvuxB//+MfCrKws44wZM3qazWaklOKmm27Knzp1aiHAxIkTgwoKCgwGg0G+/vrrmd7e3g1SHmJiYiry8/ONISEhUUuXLs249tpr7fKpN2/e7DJ8+PASi8XCgw8+6D9+/PjCmkaSl+L48eOGm2++ORjAbDaLW2655cytt95atHnz5ibPFWDkyJHBH3300bHU1FTHxtYLDAysaup62IqPj3d+4oknuul0OgwGg1y6dOmx2NjYiqeffvrEmDFjQi0WC0ajUS5evDhzzJgxpY888sjJ4cOHh+t0Otm7d++yL7/8MmPYsGFl06ZNO9O/f/8IgOnTp+cOHTq0PDU1tdEGr8OGDSu7+eab83v37h3l5eVV3adPn9KmjuVirqlojxEKL8WAAQNkXFxcex+Gchl6+eWXeeyxuhEWP/30U6bZJvW2keNLjnPk0SNYKrRovPO0zkR8EtHqDwXVFgs37t/PNwVaLbyjEMQPGEBUW6SOSKnlaXz1ldawsx1z9v+545/87bu/1U3/4Z88NrTlR960JSU8+SQ8+ijYjLmkKC1CCBEvpRzQ3sfR1vbt25cRExPTfq3BryA5OTn6efPm+W/fvt3tzjvvzCsqKtK/+OKLJ998803vlStXesXExJT27du3/LHHHmu0VlxpXfv27fOOiYkJbGyZCsSV34yxY8eyadMmANzd3Tl8+DBeNT19tLFTn54i+c7k2umw98Lwu/ei0scuSJHJxLBffyWxVKsc6e/iwq7+/TG2Zi21lHDHHdoAQADz5sGrr7Zeeec8HMm9a+/lw70fAiAQfHzzx/x47EfeHPdmg64OL9XhwzB6NGRmQt++8OuvLbp7RVGBuHLB7rrrrh4rVqzIbO/jUDTNBeIqR1z5zVi2bBmu1pFXCgsLmd+O+QO+d/jS5d4utdNpD6VRcrDZnpxahJvBwMrISByttSQiHcoAACAASURBVO8JJSW8mNnKv4tPntQG+amxfTtUNHhL22aEECy7cRkjAkYAIJFM/2o67yS8w/Pbnm/x8l54QQvCAfbuhUWLWrwIRVGUC6KC8CuHCsSV34wePXqwZMmS2um33nqLzZs3t9vxhCwOoUOE1nbDUm5h78i9mMsvqnejCxLVsSN/71k7bgHPZ2RwT0oKvxY32Rbl0rz5Zt0omzodvPUWODXodapNOegdWHnLSjyctHEwanpSefnnl8kpadmReJYvB9vxlN5+G8ouORNTURRF+T1QgbjymzJ9+nRuvvnm2ul77rmH/Px8SksbjAvQ6vQd9YS9HwbW1HDTGRMHJh1ok7Lndu/OMHet5ycz8GFODnckJ1NuboUHgWee0YafBK2x5l13XRaRaFfXriy+YbHdvMVjF9PFpUsTW1wcvV5Li6959khLg8cfb9EiFEVRlN8oFYgrvylCCJYtW0bnzp0BOHnyJCNGjCA8PJzc3LZvo+I2yA2XmNqxDiiOL26TWnG9EHwYHo6TTQPR5LIyPmiNcdmdnLT88JqBfZKS4JFHWr6ci3Bnnzu5MfRGALq4dCHIM6hVyunbF2xexrBkiRacK4qiKEpzVCCu/Ob4+PiwfPny2umDBw9y/Phx7rvvvlYf7bI+IQR9vu2DrqMO95HuXH38avTOjY+S1tKCnJ1ZFBxcO20Qgptaq/FqRAS88Ubd9Ntvw+rVkJgIP//cOmWeh5p88VkDZpH8YDJjeo1ptbLuvRcmTqybvucebfRNRVEURWmKCsSV36SJEydy77332s3Lzc2lpKT1G0zW5+DlwJBTQ+j3Qz/0Tm0ThNd4oGtXrvXwINzZmYTYWPxbM3f7vvvg1lvrpqdNg379tFSVdmy82dW1K/8e/+/afPEaZdVl5Jc3GCfjoglhny+enQ2RkVDV5JAbiqIoyu+dCsSV36zXXnuNwMDA2ulbb721tleVtmbo2D5jZwkhWBkVxb6BA4l2cTn3BpdWGLzzDvTooU1XVoLZrDXk/Oc/W7fsCxSXHUf/Zf2ZsWZGi74l6dxZuwQ18vJg6tQW272iKIryG6MCceU3y83NjQ8//JDOnTvz5ZdfMm/evPY+pFpSSjJfzqTyVGWrl+VlNOLQSD/iWa1RS+3pCZ9+aj+6Zng43H57y5d1kY4VHOPq964m9Uwq6w6t492Ed1t0/5MmwcCBddMbN2rPJIqiKIpSnwrEld+0kSNHcvToUSZPnvz/7N15XFTl/gfwzzMLoOyLLIKAwMAwLIOiWQIZ8HODzCUxNE3r5i21a4mmWWoupf28al41fnW9lVCJlaKJkUhe9IJpsRRXGRhZRBaBRJZh2Ic5vz+GYVFWmzND9bxfr3l5zpkz5/uc6d7hmWe+z/fRdVO61F6qxQ92P6BoYxFyI3MHf4GG1SsUWHDjBkTp6ShhozMeGAi80b2yJTgcVWd8BGhVtGLn5Z1QKBUAgFG8UTDgaT5dR11FxdUVyM0F9PU1HoKiKIr6A6AdceoPb/To0Q8cS09PR13nUvDaduf/7qC9qh0AUHepDrWptVqLzTAMHsvKwunqasg7OrC5qIidQG++CTg7A6++CqSlqdJWRgA9rh4q5BVd+9aG1nha9LTG45iZATdvqh49sqMoiqIoqhfaEaf+VMrKyrB06VI88sgjeOedd3TSBo+jHiD63R3TwtcKwSi1U80ltb4euT1qfN9sbka7Uqn5QIaGqjKGBw+q0lVGCEII/jnnnzDRNwEA3K6/jS3/3sJKrHHjemfoUBT1+yOVSvUEAoFXz2NRUVFjt23bZtPzWEFBAX/KlCnurq6uXm5ubl67du2yVj/X1NREfHx8PD08PERubm5e69atG6t+zt7e3sfd3V0kFApF3t7env21o7CwkH/06FGtfpgOdE8RERHOFhYW4vvfm/v1dV52dra+UCgUqR9GRkYTdu7caT3QdXSlr//Wmkb/TFB/GgzD4P3338cXX3wBADh06BDy8/O13g6eCQ9u77sBnfM35VlyVH1epZXYj5uZYalN92dKm1IJDluj1eq64j0lJvYuc6gDDiYOeH/m+137B68dxJWSK1qJXVyslTAURWkZn8/H/v37ywoLC3PS09NzP/74Y+vMzEwDADAwMGDS0tKkUqlUkpOTI7l48aLJxYsXDdWvvXz58s28vDzJjRs3+s1VTExMNMnKynrw510WDXRPL7zwQvXZs2cH/QPa13lisbg1Ly9P0nnPEgMDA2VkZKRufqIeAWhHnPrTkMvliImJ6dp3d3eHnp6eTtpiv8oejhscu/aLNhVBIVNoJfbfXVxg2DlU+9/GRnxRpYUvATIZMH8+EB4OvP46kJfHfswBPO/3PGa6zgQAMGCwLmkdGlob8HPFz6zEKywEJk0Cxo8HkpJYCUFRlA45OTm1BwYGNgGAubm50tXVtbmkpEQPADgcDkxNTZUA0NbWRhQKBSHDGABJSkoy2rp167hz586ZC4VCkUQi0cofroHuafbs2fIxY8YM+kdrsPPOnj1r4ujo2Oru7v5AoVeZTMZ54okn3Dw8PEQCgcBL/YtAdHS0hY+Pj6dQKBQtWbLESaFQXf7IkSOW7u7uIg8PD9G8efPGq6+zfft2G4FA4CUQCLzUI+9SqVTPxcXFKzIy0snNzc0rICBAIJfLCQBs2rTJ1tnZ2dvf398jPz9ff6C2aAKrHXFCyCxCiJQQUkAIeaOP5x0JISmEkJ8JIf8lhISx2R7qz83Y2Bhvv/121355ebnOyhkCgONbjtAbq/o8batsw+13bmslrq2+PtaPG9e1v+XWLbR0sLzap0wGXOkcdW5vB956i914g1Av9KPPVc2iTL+TDseDjngy7kk0tTcN8urhCwgAMjNV288/D2h5XSmKorRIKpXqSSSS0dOmTetauEKhUEAoFIpsbGzE06ZNk4WEhDSqnwsNDRV4eXl57tu3z6qv682cOVPu4+PTGB8fX5CXlycRiUQPvTqBv7+/R8+0EPXjzJkzA/4x7OueNCEuLs5i4cKF9/p6Lj4+3sTW1rZdKpVK8vPzcxYsWCDLysoyOHnypEVGRkZeXl6ehMPhMB9++KFlRkaGwb59++wuX758UyqVSj766KMSAEhNTR19/Phxy8zMzNyMjIzc2NjYMVeuXBkFACUlJQZr1679taCgIMfU1LQjNjbWPDU1dfTp06ctrl+/LklOTs7Pzs427K8tmnoPWOuIE0K4AD4AMBuACMBiQojovtO2APiKYZgJACIBRLPVHooCgJdeeglunatN1tXV4d1339VZW3hGPLj+vXvJ9dIDpZDf0M6CQxvGjYM1n6+K29qKQ2Vl7FRQAVS1+yZP7l5m8tFHVStv6piTmRNeeeSVrv26ljrcabiDA1cPaDxWz+kIFRVAerrGQ1DUH15UUtRYsoP4D+Wx+ORip/tfv/jkYqee50QlRY3tK05P/Y1c93e8vr6es2DBAtf33nuv1MLComsCDo/HQ15enqSkpOS/WVlZhunp6QYAkJaWlieRSHIvXLiQf/ToUevvvvuuzwUfioqKDPz8/FoAQCKR6C1atMhp1qxZLurnjxw5YrllyxabyMhIp/DwcJf4+HiTvq6TmZkpVaeF9HzMmzevob/3oL97+q1aWlrI999/b7ps2bI+KxZMnDixOTU11WTVqlX258+fN7K0tOw4f/688Y0bN0aLxWJPoVAoSktLMykqKtJPSkoymTNnTq2dnZ0CAGxsbDoA4NKlS0ZhYWF1JiYmSlNTU2V4eHhtSkqKMQDY29u3Tp06tRkAJkyY0FRcXKyfkpJiFBYWVmdsbKy0sLBQzpgxo66/tmjqfWBzRPwRAAUMwxQxDNMG4ASAufedwwBQ/4/FFMAdFttDUdDT08N7773XtX/kyBHcunVLZ+2xXmwNQ7/OVMEOICciR6MLzPTHmMfD2z3KebxVXAxxRgZq2ts1H0xfH1i7tnv/5k2Aq90VRvuzOXBz18RNADAzMIOLucsAr3g4L74ICATd+zt2aDwERVEssLGxUdTX1/f6wKqpqeFaWVkp9uzZM0Y9olxcXMxvbW0l4eHhrhERETXLly/vM+fZysqqIygoqCEhIcEUAMaPH98OAPb29orw8PC6q1evGt7/moqKCp6xsXEHv3PwRCQStX311Ve9fkLNyMgYvXPnzqoTJ07cPnbs2O0TJ070mTox3BHxodzTwzp58qSpSCRqGjduXJ+pK76+vq1ZWVkSHx+f5q1bt9pv2LDBjmEYEhERcU/9BaK4uPjGgQMHHqrvqKen1/XHlsvlMgqFot98ob7a8jAx+8JmR9weQGmP/bLOYz1tB7CUEFIGIBHA31hsD0UBABYsWIDHHnsMANDW1obNmzfj1KlTkMk09kvTkBFCYPZ499LrzXnNqPpCOxM3V9rZwa1zyXsFw6BOocA7t1lKj1m3TpUgDQA1NSOmJ2o52hKvT329a99E3wTPeD3DSqyTJ7urOCYmAt9/z0oYiqI0yNTUVGltbd1+9uxZYwCoqqriXrp0yTQkJES+efPmu+oOoaOjY3tkZKSTu7t7y/bt23t9iN+5c4dXXV3NBQC5XE5SUlJMPD09W2QyGae2tpYDqHKQU1JSTHx9fZvvb0N+fr6ejY1Nv+kora2thMfjMZzOuT9vvvmm3dq1a+/2de5wRsSVSiX6uydNOHHihMWiRYtq+nu+uLiYb2xsrFy9enVNVFRU5S+//DJ61qxZsnPnzpmXl5fzANV/j5s3b+rNnDlTlpCQYF5ZWclVHweA4OBgeWJiollDQwNHJpNxEhMTzYODg/sd/Q8JCZEnJiaayeVyUltby0lOTjbrry2aeh90s+52t8UAjjEMs58Q8hiAzwgh3gzD9PrpgxDyVwB/BQBHR8c+LkNRQ0cIwb59+xAQEAAA+PLLL/Hll19i06ZNvUbLtcV1rysqj1WiQ9YBQx9DmE411UpcPoeDPS4uiJBIuo7VtreDYZh+f3Z9aAYGwL59wNOdNbs/+AB46SVAdH+2mva99uhr+CD9Azzu9Dh2Be8Cl8POaL2vL7BiBfDpp6r9119X5Y3TEocUNTQHZh64c2Dmw41+AkDcwrjbcQvjhj3aEBMTc2v16tWOGzduHAcAmzZtuuPl5dVrvdzk5GSjM2fOWAoEgmahUCgCgB07dpQ/88wz9aWlpfwVK1aM7+joAMMwZO7cuTWLFy+ul0gkevPnz3cDgI6ODvL000/fW7hw4QMjQmKxuKWmpoYvEAi8oqOji6dPn97Y8/mkpCSjoKAguVKpxJo1a+zDw8Pr1ZMsf4uB7mnOnDnjr127ZlxbW8uzsbHxfeONN+6sW7euGgCmTZvmFhMTc9vZ2bm9v/NkMhknLS3NJCYmpt//HpmZmaM2b97swOFwwOPxmOjo6Nv+/v4tW7ZsKQ8NDXVXKpXg8/nMoUOHSkJDQxvXr19fERQUJORwOIy3t3fTqVOnigMDA5uWLFlyb+LEiZ4AsGzZsrsBAQHNUqm0zwmvgYGBTfPnz6/x9vb2srS0bPf19W3sry2/9f1VI2z9DN7Zsd7OMMzMzv3NAMAwzJ4e5+QAmMUwTGnnfhGARxmG+bW/606aNInJyMhgpc3Un8vTTz+N+Pj4rn09PT3k5ubCxUXzqQmDqf62GspmJawXareUKsMweDQzEz/J5bDh8/GVlxceNzMb/IUPFwwICQEuXVLt/8//AEuWADduAPv3sxNziOpa6mBmwNJ991BerkpRae4c8/r734ENG1gPS/3OEUIyGYaZpOt2aFt2dnaxWCyu1nU7RprKykpuVFSUfWpqqsnSpUurZTIZd/fu3RWHDx+2iouLsxSLxY1+fn7NGzdu7HNUnNK+7OxsK7FY7NzXc2x2xHkAbgIIBVAOIB3AEoZhcnqc8x2ALxmGOUYI8QRwEYA9M0CjaEec0pT8/Hx4enqio7NiyNy5c3Hs2DGYsdURHaGu1Ncjrb4ea+3tMYrt3O3sbGDiROD+RYSuXwe8vdmNPUxlsjLca7oHsa1Yo9fdtg3Ytat7/+bN3vnjFHU/2hGnBvLcc885xsbGlui6HVT/BuqIs/ajKMMwCgCvAEgCkAtVdZQcQshOQshTnaetB7CSEJINIA7AioE64RSlSQKBAKtWrQIAGBgYYPbs2X+6TjgABJiaYpOjI/udcAAQi4GVKx88fkDzlUoeVkNrA7b8ewsEhwV47sxz6FBqtrTjhg0Ar0dS4DPspKRTFPUnQTvhv2+sZicyDJPIMIw7wzCuDMO823lsG8MwZzu3JQzDBDAMI2YYxo9hmAtstoei7rdt2zasWbMGRUVFeOmll3TdnC6tla3IicxByx2WSgoOol2pxM0mzdfTBqAaDjbtkQf/5JPA++/3f76WVTRUYO+VvWhRtOC/Vf9FbHasRq9vYgL8rce09LIyQKGdtZwoiqKoEYZOE6L+1MaMGYMjR47Azk5jlYh+M8kyCa6OvYq7X95FwasFWo3NMAwSqqvh9uOPmJ6djWY2FvoZM0aVn9GTqXYmqA6mpL4EAZ8GoF2pKuPoPcYbAkvN543s3Qs4OwNbtqjyxnm6njZPURRF6QTtiFPUfRQKBc6ePauVet59xq9VqCrsA6iOr0Z7LQu1vfuRLpNhYU4OSlpbUdLaiiPl5ewEevllYM4c4NtvgbNn2YnxEMaZjIPQSti172frh0DHQI3H4fGAoiLVjwOdpYEpiqKoPyHaEaeoHv75z3/C2dkZc+fOxcWLF3XSBsGRHiOwSqDsUJnWYp+9dw9tnV9ACIBGNkbEAWD0aFUHPCysu7j2CEAIwZ7QrsJO+OL6F7hedZ2lWKxclqIoivodoR1xiup09+5dHDlyBOWdo8B79+7VSTtGOY+Cw3qHrv07R+6go4mlDvF9Njo6wrIzT4IBYKbNnIn6euDdd4ES3c47CnQMxJPuTwIAGDB4699vaSUuwwB1Gl23jqIoihrpaEecojpduXIF16+rRj8JIXjkkUegvL/Mnpa47HGBvpM+AKC9uh0V/6rQSlwTHg9vOzt37b9fVgaFNt6DmBjAyUmVNK2jL0A9vRvyLghUQ9YJNxNwpeQKbtXegkKp+VmVbW3Am28CZmbAhAkavzxFURQ1gtGOOEV1mjNnDtzc3ACoJi3a2tqCo6NlDzl8Dhxf715FtvTvpVC2aedLwUo7O4zpTFwuaW1FfDXLZXwVCiA3VzUiDgD/+hdw56EXz9MIXxtfPOv7bNf+/C/nw+2wG05JTmk81tdfA3v2ADIZUFwMXLum8RAURVHUCEU74hTVicvl4rXXXuvaP3jwYNdiP7pg+4It+NaqDnFrWSvufKSdzqkBl4vVY8d27R8oLWV3VHzjRuB//1e1bWgIfPSRqrKKju18Yid4HFVqzt2mu1AySuy7uk/jk3iXLAGMjbv3//EPjV6eoiiKGsFoR5yielixYgXMzc0BAIWFhUhISNBZW7ijuLB7qbus4q1tt8B0aKeSyyp7e+h1zib8saEBY69eRVZDAzvBXnyxe7uxEXjkkRFRSmS8+XhEiCJ6HTM3MEdDm2bfB0J61xX/z39U6SoURVHUHx/tiFNUD4aGhnj55Ze79vfv34+GhgY0sNUJHYTxhO6h0o66DlTGVGolro2eHp61senav9vejv2lpewEE4lUpQzV/v53duI8hFenvNq1zePw8Nn8z2Cib6LxONu2Aba2qu07d4Avv9R4CIqiHhKXy/UXCoUigUDgNXv2bJeGhoYh9Z0KCgr4U6ZMcXd1dfVyc3Pz2rVrl7X6uaamJuLj4+Pp4eEhcnNz81q3bl3Xz5C7du2yFggEXm5ubl47d+607vvqQGFhIf/o0aPmv+3uhqe/exroXvuiUCjg6ekpCg4OdlMfs7e393F3dxcJhUKRt7e3J9v38rCioqLGbtu2zWbwM4eGdsQp6j6vvPIK+J0jsmlpabC3t8fBgwd10hareVbg26raQngEbdXaGypd5+DQaz+lro6dBX4A4I03urc//1y13OQIMMVhCqbYT4GjqSN2h+zGKP4oVuLo6wOvvNK9v3+/qooKRVG6p6+vr8zLy5Pk5+fn8Pl8Zv/+/UPKnePz+di/f39ZYWFhTnp6eu7HH39snZmZaQAABgYGTFpamlQqlUpycnIkFy9eNLl48aJhenq6QWxs7JisrKzc3NzcnPPnz5vduHFDv6/rJyYmmmRlZY3W5L0+7D0NdK99eeedd2zc3Nya7z9++fLlm3l5eZIbN27ksnsnIwftiFPUfcaOHYvIyMiu/YaGBhw6dAjNzQ98ZrCOEALBIQHGrh6LAFkAnDY6aS22j5ER/se8e7Bl/bhxGMXlshNs6lQgsHPhnPZ21ZL3t28D586xE28YTi46icK1hXg94HVWRsPVXn4ZGNXZz8/OBv79b9ZCURT1kAIDA+UFBQX6UqlUTyAQeKmPb9u2zSYqKmpsz3OdnJzaAwMDmwDA3Nxc6erq2lxSUqIHABwOB6ampkoAaGtrIwqFghBCcP369VETJkyQGxsbK/l8PgICAhpOnDhhdn87kpKSjLZu3Tru3Llz5kKhUCSRSPTYvfOB72mge71fYWEhPykpyXTlypXDrgQgk8k4TzzxhJuHh4dIIBB4qX8RiI6OtvDx8fEUCoWiJUuWOCkUqgpXR44csXR3dxd5eHiI5s2bN159ne3bt9sIBAIvgUDQ9auDVCrVc3Fx8YqMjHRyc3PzCggIEMjlcgIAmzZtsnV2dvb29/f3yM/P1x+oLcNFF1amqD5ERUXhs88+69o3MjJCUVERvLy8BngVO6wjrGEdMeCvfKzZMG4cxvD5WOfggMkm7HVCAQCbNgFpaartQ4dUD0NDVYfc1JTd2ANwMHHo83iHsgNcjua+mFhaAs8/D0RHq/YjI4GqKkBHhXsoirpPe3s7kpKSTGbMmCEb7mulUqmeRCIZPW3aNLn6mEKhgLe3t6ikpER/+fLlv4aEhDRmZWV17Ny5076yspJraGjIJCcnm4rF4sb7rzdz5ky5j49P44EDB0onT57c8lvuy9/f36OxsfGBD7P33nuvdN68ef3mZfZ1TwMdV1uzZs24vXv3ltXX1z8QMzQ0VEAIwfPPP393w4YND3TU4+PjTWxtbdsvXbpUAAD37t3jZmVlGZw8edIiIyMjT19fn1m6dKnjhx9+aPnoo4827tu3z+7q1at5dnZ2iqqqKi4ApKamjj5+/LhlZmZmLsMw8Pf39wwNDW2wsrLqKCkpMfj888+Lpk6dejssLMwlNjbW3MfHp+X06dMW169fl7S3t8PPz080YcKEpr7aMth73Rf6EU9RffDz80NISEjX/vLly3XSCde1mRYWOC4Ssd8JB1SrbKrfY4VC9aivB44cYT/2ECkZJc7dPIcnjj2BXf/ZpfHrr13bvV1d3d0ppygKiEqKGkt2EH+yg/hHJfUefQaAlQkrHdTPv53y9gM5vItPLnZSP7/vh31WQ43b2trKEQqFIh8fH5GDg0Pbq6++OqyR3Pr6es6CBQtc33vvvVILC4uuElQ8Hg95eXmSkpKS/2ZlZRmmp6cbTJw4seXVV1+tDA0NdQ8ODhZ4eXk1cfv5JbKoqMjAz8+vBQAkEoneokWLnGbNmuWifv7IkSOWW7ZssYmMjHQKDw93iY+P7/ODPDMzU5qXlye5/zFQJ7y/e+rvuFpcXJyplZWVIigoqOn+59LS0vIkEknuhQsX8o8ePWr93XffGd1/zsSJE5tTU1NNVq1aZX/+/HkjS0vLjvPnzxvfuHFjtFgs9hQKhaK0tDSToqIi/aSkJJM5c+bU2tnZKQDAxsamAwAuXbpkFBYWVmdiYqI0NTVVhoeH16akpBgDgL29fevUqVObAWDChAlNxcXF+ikpKUZhYWF1xsbGSgsLC+WMGTPq+mtLf+/XQGhHnKL6ERUVhalTp+LUqVPYunWrrpvTizy7z4GG3zcORzUq3lNAAODtrZv29OGs9CzmxM3B5duX8UH6B2hu12y6kocHIBB074+geasU9aelzhHPy8uTxMTElBoYGDA8Ho/pueBbS0sLBwD27NkzRigUioRCoai4uJjf2tpKwsPDXSMiImqWL1/e59q5VlZWHUFBQQ0JCQmmALBu3brqnJyc3IyMDKm5uXmHu7v7AyPeFRUVPGNj4w71fCaRSNT21Vdf3e55TkZGxuidO3dWnThx4vaxY8dunzhxos/UCX9/fw91m3s+zpw5Y9zX+f3d01DuNS0tzSg5OdnM3t7eZ8WKFS7Xrl0znjt37ngAGD9+fDsA2NvbK8LDw+uuXr1qeP/rfX19W7OysiQ+Pj7NW7dutd+wYYMdwzAkIiLinvq/UXFx8Y0DBw48VL1fPT29rtk5XC6XUSgUpL9z+2rLw8SkHXGK6kdYWBiuXLmCBQsWoL8RCW2r+KQCP9j9gAy/DDT8rP1KLmUtLXi9sBBf//orOwEiIwHH7oWMsGQJMHcuO7GGKfNOJt6/+n7Xfm1zLa6UXtF4nPfeU/3r7w/0yI6iKGoEcXBwUNTU1PAqKyu5zc3NJCkpyRQANm/efFfdIXR0dGyPjIx0cnd3b9m+fXtVz9ffuXOHV11dzQUAuVxOUlJSTDw9PVsAoLy8nAcA+fn5et9++63Ziy++WHN//Pz8fD0bG5t+Z++3trYSHo/HqBele/PNN+3Wrl17t69zhzMirlQq0dc99Xf8fh988EF5VVXVf8vLy68fO3as6NFHH2345ptvbslkMk5tbS0HUOVep6SkmPj6+j4w0lFcXMw3NjZWrl69uiYqKqryl19+GT1r1izZuXPnzNXvW1VVFffmzZt6M2fOlCUkJJhXVlZy1ccBIDg4WJ6YmGjW0NDAkclknMTERPPg4OB+/6CGhITIExMTzeRyOamtreUkJyeb9deW/q4xEJojTlH9IKTvL8IMw/T7HJuUbUrcXH0TTKvqC3vB2gJMSNXemuhfVlVhSW4ulAB8DA2xcMwYE2lVsQAAIABJREFUzb8PfD4QFQVs3gysXAmEh2v2+r8Bn8vHf0r+AwAgILjywhVMcZii8Tjz5wMlJcC4cRq/NEX9rh2YeeDOgZn9j3QenXO07Oico/2WXIpbGHc7bmHc7f6eHw59fX1m/fr1FZMnT/a0sbFpd3Nze2DUOjk52ejMmTOWAoGgWSgUigBgx44d5c8880x9aWkpf8WKFeM7OjrAMAyZO3duzeLFi+sB4KmnnnKtq6vj8Xg85uDBgyVWVlYPpDyIxeKWmpoavkAg8IqOji6ePn16rzzypKQko6CgILlSqcSaNWvsw8PD69WTKX+L/u7JzMyso797BYBp06a5xcTE3HZ2dm7v67plZWW8+fPnuwFAR0cHefrpp+8tXLjwgVz8zMzMUZs3b3bgcDjg8XhMdHT0bX9//5YtW7aUh4aGuiuVSvD5fObQoUMloaGhjevXr68ICgoScjgcxtvbu+nUqVPFgYGBTUuWLLk3ceJETwBYtmzZ3YCAgGapVNrn5NLAwMCm+fPn13h7e3tZWlq2+/r6NvbXlod5T4mmV4lj26RJk5iMjAxdN4P6E8rLy8O+fftw7949nD59WjdtWJmHyn911hLnAAF3A8C3YH/xm+aODjhcvYqazpnoAPBvsRjB5iyUsG1qUj2shpzCqTXBMcG4VHwJALA5cDN2h+7WbYOoPwVCSCbDMJN03Q5ty87OLhaLxcOurPFnVFlZyY2KirJPTU01Wbp0abVMJuPu3r274vDhw1ZxcXGWYrG40c/Pr3njxo19jopT7MrOzrYSi8XOfT1HO+IUNQTl5eVwdHSEOicwOzsbvr6+Wm9HW3UbfvL4CYoaVYfY7ZAbHP7Wd1UPTXsuNxefVal+cXzc1BQpfn7gaPOXgcZGVRUVHTqdexoLvloAALAcZYnSdaWs1RanKDXaEaeG67nnnnOMjY0t0XU7KJWBOuI0R5yiBqFQKDBz5kz0nJgTGxurk7boWenBZXfXpHhUHK2Atr5M91zg5weZDOWtrewH7egAzpwBZs9WzWRs7/NXTa15yuMpOJs5AwDuNd/DF9e/YD1mQQHw1FNAzQNZohRFUX2jnfDfD9oRp6hB8Hg8TJnSnQv8+OOPY+/evTprj/Via3BGq/6v23i9EQ3p2pm0OcHYGNM663krGAZHysvZD6pUAi+9BJw/D5SXAwkJ7MccAJfDxSuTu5fAfP/a+/jk50/w1sW3WIk3fbqqikpCgip1nqIoivpjoR1xihqCdevWdW2npaWhuLhYZ23hmfBgvah7gZ+Kf1VoLfa6HjMI/1lRAXmPnHGNq6kBnn1WVVAbAAgBfv6ZvXhD9JeJf4EhX5UiI7krwV/O/gX/e+V/USbrd47YQ+P1mE4fF6cqrU5RFEX9cdCOOEUNgbe3N2bMmAFAVabpiI4XmbFb2V2utDKmEgq5dnpoT1pawq1zHfY6hQJ7S0pwrb6enWCmpsC1a6pRcUC1sM8uzS+iM1xmBmZYLl7e61gH04HPsjVfa7Dn/8za2gCJROMhKIqiKB2iHXGKGqKeo+KfffYZ2tr6LeHKOiN/IxB91URJpo1B+QdaSBMBwCUEr9rbd+3vKinB3woKWArGBVas6N4/d46dOA/hb1P+1mt//WPrsUy8TONxXF2BJ5/s3o+L03gIiqIoSodoR5yihmj69Omw7+yEVldX4+DBgzorY8jV52LU+O5qHeWHtdMRB4AVtrYw4nR/dGQ0NOCGnKWVPp9/vns7KQko03z6x8MQWgkx03Vm176jqSMcTNipXrNyZff2Z5+p5q9SFEVRfwy0I05RQ8TlcrFsWfeo56ZNm7BmzRoodJS4O+51Vb72KPdRGP/OeK3FNeLx8Ix1d466s4EBlAOc/5uMHw+EhKi2lUogJoatSMO2/rH1WOG3Aj+/9DPWTlnLWpzZs4ExY1Tb5eXAxYushaIoiqK0jHbEKWoYli/vnRtcUVGBCxcu6KQtNstsMPXuVEyRToHdCrvBX6BBz9naAgAseTw8Z2MDXyMj9oL95S/d2x9/DHz+ObBpE3vxhmi663R8OvdT+Nn6sRqHz1fNWVX78ENWw1EURVFaRDviFDUMQqGwVynDxx57DE5OTjppC4fPgZ5Vnyvysi7Q1BTf+figYupU7BjP8mj8/PmAmZlq+9YtYNkyYO9eoLCQ3bgPobGtEbdqb2n8uj1T5U+fBn76SeMhKIqiKB2gHXGKGib1qDiPx8MTTzwBLy8vHbdI+ziEYJalJfgcLXyEjBrVe0hY7ehR9mMP0a3aW3jhmxdgu98WL3/7ssavLxarisiovf22xkNQFEVROkA74hQ1TJGRkTh8+DAqKyuxe/duXTenS1tNG+78645O28DaKp8vvNB7/623gLXs5WUPV11LHY79cgzyNjmSC5NZqSkeEdG9PQLKqVPUn4JUKtUTCAS9RluioqLGbtu2zabnsYKCAv6UKVPcXV1dvdzc3Lx27drVNZGmqamJ+Pj4eHp4eIjc3Ny81q1bN1b9nL29vY+7u7tIKBSKvL29PftrR2FhIf/o0aPmmry3oRisfdnZ2fpCoVCkfhgZGU3YuXOndc9zFAoFPD09RcHBwW7aa/nw9PXfVFt4g59CUVRP5ubmeOWVVwY/UUva69uRHZIN+c9ygAHMgs0w2nW01uLXtbfjq7t38WllJZZYW+NvDixUD5k4EfDzA375RbXv5ASMHTvwa7TkQuEFhB8PBwPVlxAPKw+U1pdqvIrK9u3Av/8NvPyy6kFR1MjB5/Oxf//+ssDAwKba2lrOhAkTRGFhYTJ/f/8WAwMDJi0tTWpqaqpsbW0lkydP9rh48WJ9aGhoIwBcvnz5pp2d3YCz/hMTE00kEokBgFqt3FAPA7VPLBa35uXlSQBVh9vW1lYcGRlZ1/Ocd955x8bNza1ZLpdztdHe3xs6Ik5RGsAwDBobG3USm3AJ5NmqTjgA3N55W2ux25RKbCwqwks3b+KaTIZPKyvZC/bSS8BTTwFnzvROmtaxRx0eBY/TPabx5dNf4rFxj2k8jr29Ki3+9dcBY2ONX56iqN/AycmpPTAwsAkAzM3Nla6urs0lJSV6AMDhcGBqaqoEgLa2NqJQKAghZMjXTkpKMtq6deu4c+fOmQuFQpFEItHN5KBBnD171sTR0bHV3d29a5GNwsJCflJSkunKlSur+3qNTCbjPPHEE24eHh4igUDg1XPUPzo62sLHx8dTKBSKlixZ4qSuUHbkyBFLd3d3kYeHh2jevHnjAWD79u02AoHASyAQeKlH5KVSqZ6Li4tXZGSkk5ubm1dAQIBALpd3vfGbNm2ydXZ29vb39/fIz8/XH6w9bKEdcYr6DaqqqrBnzx54eHhg48aNOmkDz4gH85Duz4rqs9VQKlgrKNhLU0cHYioquvavNzbidksLO8Fefhn45htg7lxVKZERwkTfBHM95nbtf3H9Cx22hqIoXZNKpXoSiWT0tGnTuhZYUCgUEAqFIhsbG/G0adNkISEhXSM3oaGhAi8vL899+/ZZ9XW9mTNnyn18fBrj4+ML8vLyJCKR6KFXk/P39/fomUqifpw5c6bfr/eDtU8tLi7OYuHChfd6HluzZs24vXv3lnH6mU8UHx9vYmtr2y6VSiX5+fk5CxYskAFAVlaWwcmTJy0yMjLy8vLyJBwOh/nwww8tMzIyDPbt22d3+fLlm1KpVPLRRx+VpKamjj5+/LhlZmZmbkZGRm5sbOyYK1eujAKAkpISg7Vr1/5aUFCQY2pq2hEbG2sOAKmpqaNPnz5tcf36dUlycnJ+dna24UDtYRPtiFPUQ2IYBqdPn8abb76J/Px8HD9+HC1sdUIH4fKeC7jGql/9Ouo6UHO+Ritxzfh8zFMXuQbwkp0dnAwMtBIbACCXA+np2ovXj2W+3fXlv7j+BTqUdNUditK4qKixIMR/SI/Fix8sZ7V4sVOvc6KiBs1v62/kur/j9fX1nAULFri+9957pRYWFl0jIjweD3l5eZKSkpL/ZmVlGaanpxsAQFpaWp5EIsm9cOFC/tGjR62/++67PmvBFhUVGfj5+bUAgEQi0Vu0aJHTrFmzXNTPHzlyxHLLli02kZGRTuHh4S7x8fEmfV0nMzNTmpeXJ7n/MW/evIa+zh9q+1paWsj3339vumzZsq7Umbi4OFMrKytFUFBQU59vFoCJEyc2p6ammqxatcr+/PnzRpaWlh0AcP78eeMbN26MFovFnkKhUJSWlmZSVFSkn5SUZDJnzpxadaqMjY1Nx6VLl4zCwsLqTExMlKampsrw8PDalJQUYwCwt7dvnTp1ajMATJgwoam4uFgfAFJSUozCwsLqjI2NlRYWFsoZM2bUDdQeNtGOOEU9pNzcXKxataprX6lU4vr16zppi/FEY4xd1f03peJfFQOcrVnLO2uKA0B8dTUUSi2MxstkwOrVqjzx8HCgvZ39mAOY4ToDY0arvpCUN5Tj8u3LrMZrbAS2bQOmT2c1DEX96dnY2Cjq6+t75TbX1NRwraysFHv27BmjHlEuLi7mt7a2kvDwcNeIiIia5cuX1/V1PSsrq46goKCGhIQEUwAYP358OwDY29srwsPD665evWp4/2sqKip4xsbGHfzOXwJFIlHbV1991SsHMSMjY/TOnTurTpw4cfvYsWO3T5w40WdKxXBHxIfSPgA4efKkqUgkaho3blxXLnlaWppRcnKymb29vc+KFStcrl27Zjx37txe9W59fX1bs7KyJD4+Ps1bt26137Bhgx0AMAxDIiIi7qm/KBQXF984cODAsKsR6OnpdVUQ4HK5jEKhGDAnqL/2sIl2xCnqIYlEIvj5dS/m8u6772Ly5Mk6a4/dX7o/L+6du4fWilatxJ1hbg6bzj8QFW1tuFjX598fzeLzgS+/BBoagLt3db7cJJ/LR6R3ZNf+3it7seLMCsTnxms8VmkpYGIC7NoFfP89kJGh8RAURXUyNTVVWltbt589e9YYAKqqqriXLl0yDQkJkW/evPmuuqPo6OjYHhkZ6eTu7t6yffv2qp7XuHPnDq+6upoLAHK5nKSkpJh4enq2yGQyTm1tLQdQ5SanpKSY+Pr6Nt/fhvz8fD0bG5t+01FaW1sJj8dj1Okfb775pt3atWvv9nXucEbEh9o+ADhx4oTFokWLev0U+8EHH5RXVVX9t7y8/PqxY8eKHn300YZvvvmm10ILxcXFfGNjY+Xq1atroqKiKn/55ZfRADBr1izZuXPnzMvLy3mA6n2/efOm3syZM2UJCQnmlZWVXPXx4OBgeWJiollDQwNHJpNxEhMTzYODg/sc4VcLCQmRJyYmmsnlclJbW8tJTk42G6g9bKJVUyjqN1i+fDl+6azkceLECZ1WUxntPhqm00xRf7ke6AAqYyrh9Ab7iw3xOBw8a2ODA2Wqkn2xlZWYaWHBXsALF4ClS4Gazs98FxfVELGOLfNdhsM/HQYAJBUmAQAq5ZVY4LlAo3EcHAAjI9WPAoCqpvi332o0BEWNTAcO3MFDjIp2iYu7jbi4Yc9mj4mJubV69WrHjRs3jgOATZs23fHy8uo10pGcnGx05swZS4FA0CwUCkUAsGPHjvJnnnmmvrS0lL9ixYrxHR0dYBiGzJ07t2bx4sX1EolEb/78+W4A0NHRQZ5++ul7CxcufCAnWSwWt9TU1PAFAoFXdHR08fTp03t94CUlJRkFBQXJlUol1qxZYx8eHl6vnjj6W5SVlfH6a9+0adPcYmJibjs7O7fLZDJOWlqaSUxMzLDf28zMzFGbN2924HA44PF4THR09G0A8Pf3b9myZUt5aGiou1KpBJ/PZw4dOlQSGhrauH79+oqgoCAhh8NhvL29m06dOlW8ZMmSexMnTvQEgGXLlt0NCAholkql/U5qDQwMbJo/f36Nt7e3l6WlZbuvr2/jQO1hE2Gt7i9LJk2axGTQISBqhPj1119hb28P9Wzu/Px8uLnprlRq5eeVyFuWBwDgWfAQUB3Qby6jJmXL5fDr/P+lASF418UFS21sYK3HwuT+khLA2RlQf3bduqXa1zGGYSD8QIib9252HSMgKI8qh52xZn/dfOEF4NNPVduPPAL8+KNGL0+NMISQTIZhJum6HdqWnZ1dLBaL+6y28WdWWVnJjYqKsk9NTTVZunRptUwm4+7evbvi8OHDVnFxcZZisbjRz8+veePGjX2OilPal52dbSUWi537em7Q1BRCSFQfj78QQvwGey1F/dFZW1tj9uzZXfuxsbE6bA0wynVU17aiRoH6H+q1EldsZASxoSp1sIVhsL6wEMerqgZ51UNydOydHK3j91yNENJr0qaTqRN+WvkTbI1sB3jVw3nnHUBdhOCnn1RlDSmK+nOwtbXtOH78eElpaemNPXv2VDY0NHBNTU2VW7Zs+TUnJyf3+PHjJbQT/vsxlBzxSQBeBmDf+XgJwCwARwkhuqnXRlEjiHrJewD45JNPsGPHDly7dk0nbTGZYgKOYff/rcve1/wKj/15zrZ3h/PTykrtrLT5ySeANiaIDsGzPs92bbd2tMJrjBcrv0iMHQv0+P43Ur6LUBSlA7GxsSW6bgP18IbSEXcAMJFhmPUMw6wH4A/AGsDjAFaw2DaK+l148sknYW6umqBeXl6O7du3Izo6WidtIRwCq6esoGerh7GrxkLwD4HWYi+xtu71gbLAygqsdY/nzQM633Pcvq0aFh4BxpuPx9bHt+Js5FmUvFaCUfxRg7/oIfVc0yg2dsR8F6EoiqKGYSgdcWsAPScltAOwYRim+b7jFPWnpK+vj8WLF/c6durUKTQ1/ea5Mg9FdFyEqRVT4R7tDn17fa3FtdXXxywLC+gBiBgzBpE2NuCylZ+urw/Mn9+9f+AAsGoVcP48O/GGYWfwTszxmAM+l91Fh+bM6f4uUlwMxMWxGo6iKIpiwVA64l8A+JEQ8jYh5G0AVwAcJ4QYApCw2jqK+p3omZ7C5XKxf/9+rUySHGkOCQSoDAjAV15e8BjNctWnhQu7t7/+Gvjww+4ZjCOIklHiYtFFNLf3WfXroenrqzrjauvWafTyFEVRlBYM2hFnGGYXVHnhdZ2PlxmG2ckwTCPDMM8O/GqK+nOYPHkyhEIhAGDSpEkICQnBqFHspSWMVK6jRsFcW8vPh4YCZma9j507NyJKGap98NMHGP+P8fifz/4H30i/0fj1n+3xCXz3LpCVpfEQFEVRFIuGuqBPFoCvAZwG8CshxJG9JlHU7w8hBB9++CFyc3Nx7do1uLu767pJAABluxK/fvUr5BK57trA1oRNPT1g7tzu/QkTVKkpI+QLUKuiFaklqSipV82jOpV7SuMxpk9X1RRXO3dO4yEoiqIoFg26oA8h5G8A3gZQBaADAAHAAPBlt2kU9fsybdo0XTehF+lLUlR+UglGwWDMwjHw+tpLa7EVSiXiq6vx9d27SJfJUDBlCngcFhbyXbgQiIlRbcvlQFCQ5mM8BIZh4BXthcJaVV1BE30T2BpqvowhIcAbbwDV1cCaNYAOS9hTFEVRD2EoK2u+CsCDYZh7bDeGov5ompqaMJrtXOl+tFW1gVGoRqPvnb8HhmG0lrf+i1yOF/Ly0NhZyuM/9fUIUc8s1KTp04EnnwTCw3tP3tQxQgimu0xHYaaqIx4hisDhsMOsxHrrLVYuS1EURWnBUIaoSgFoZ1UQivoDaG9vxwcffICQkBA4OTmhvb1dJ+1wWOfQta2UK9GQ0aC12Cfv3u3qhAPApbo6dgLp6wMJCcDLLwM2NuzEeEjLxN2L+5yUnESLokWHraEoiqJGoqF0xIsAXCKEbO65uibbDaOo36vCwkK89dZbSElJQXV1NVJSUnTSDrMgMxg/Zty1f/dr7S20tmDMmK5tUy4XWx21OK2EYYCbNwc/j2WPOTwGF3MXAEB9az2+vfmtjltEURRFjTRD6YiXAEgGoAfAuMeDoqg+PPvss6ivV/2IRAjBzz//rJN2EA6B81vOXft3v77L3kqX95lkbAx7PT0AQH1HB9JkMvaDdnQAmzYBLi6AtzdQW8t+zAEQQnqttBmfF89qPIUC+OwzIDAQKKHr7FGUxnC5XH+hUCgSCARes2fPdmloaBjShJeCggL+lClT3F1dXb3c3Ny8du3aZa1+rqmpifj4+Hh6eHiI3NzcvNatWzdW/dyuXbusBQKBl5ubm9fOnTut+746UFhYyD969CgLOX8Dq66u5s6aNctl/PjxXi4uLl7ff/+9YV/nRUREOFtYWIgFAoHXUI6PNFFRUWO3bdvG+k+tQylfuKOvB9sNo6jfq/k9cpXDwsKwadMmnbXFfLo5uKZcAEBLcQsaMrWTnsIhBPOsrLr246urtRCUo0pTKS4G2tuBM2fYjzmIpz2f7to+m3cWW/69BbtTd7MSy94eeO454MoVYP9+VkJQ1J+Svr6+Mi8vT5Kfn5/D5/OZ/fv3jxn8VQCfz8f+/fvLCgsLc9LT03M//vhj68zMTAMAMDAwYNLS0qRSqVSSk5MjuXjxosnFixcN09PTDWJjY8dkZWXl5ubm5pw/f97sxo0bfa7MlpiYaJKVlaX1SUh//etfx82YMUN269atHIlEIvHz8+sz7+6FF16oPnv2bP5Qj/9Z9dsRJ4Qc7Pw3gRBy9v6H9ppIUb8vCxYs6NpOSUlBc7NmF3IZDo4eB1ZzuzvEd7/SXnrK/B7pKWeqq9kdjb9xQzUSnpur2jczA+p1P7XF18YXzmbOAAB5uxzvpr6Lf/z4D3QoOzQeSyTq3j6l+UqJFEUBCAwMlBcUFOhLpVK9niO627Zts4mKihrb81wnJ6f2wMDAJgAwNzdXurq6NpeUlOgBAIfDgampqRIA2traiEKhIIQQXL9+fdSECRPkxsbGSj6fj4CAgIYTJ07ct2ACkJSUZLR169Zx586dMxcKhSKJRKLH7p2r3Lt3j/vjjz8av/baa9WA6guFlZVVnx9os2fPlo8ZM0Yx1ONqMpmM88QTT7h5eHiIBAKBV89R/+joaAsfHx9PoVAoWrJkiZNCobrMkSNHLN3d3UUeHh6iefPmjQeA7du32wgEAi+BQND1y4JUKtVzcXHxioyMdHJzc/MKCAgQyOXyrioGmzZtsnV2dvb29/f3yM/P1x+sPZow0Ij4Z53/7gOwv4/HoAghswghUkJIASHkjX7OWUQIkRBCcgghx4fRdooakTw9PeHh4QFAVTXlwoULOm3PmIjuDnHFxxVaS0953NQUFjxVYaay1lYcKS9HEVtfSlxcgF9/7d5PSQFee42dWMNACME8j3m9jv3a+CuulF7ReKxXXunebmpSZepQFKU57e3tSEpKMvHx8Rn2B5lUKtWTSCSjp02b1rWog0KhgFAoFNnY2IinTZsmCwkJafTz82v+6aefjCsrK7kNDQ2c5ORk09LS0gc62TNnzpT7+Pg0xsfHF+Tl5UlEIlHbw96Xv7+/h1AoFN3/OHPmzANpyFKpVM/CwkIRERHh7OnpKXrmmWecZDKZRmvTxsfHm9ja2rZLpVJJfn5+zoIFC2QAkJWVZXDy5EmLjIyMvLy8PAmHw2E+/PBDy4yMDIN9+/bZXb58+aZUKpV89NFHJampqaOPHz9umZmZmZuRkZEbGxs75sqVK6MAoKSkxGDt2rW/FhQU5JiamnbExsaaA0Bqauro06dPW1y/fl2SnJycn52dbThQezSl3zePYZjMzn8v9/UY7MKEEC6ADwDMBiACsJgQIrrvHAGAzQACGIbxAqD7v5wU9RsRQnqlp5w+fVqHrQH0x3b/qqmoUUD2kxbytQHwORzMsbTs2l9bUIBPKirYCTZ6NBAW1r1/duT8aDdP2N0RH8UbhS8Xfgl/O3/Nx5kHqH+EqK0Frl3TeAiK0q2oqLEgxB+E+OO+0WcAwMqVDl3Pv/32g7m9ixc7dT2/b5/VA8/3o7W1lSMUCkU+Pj4iBweHtldffXVYuXb19fWcBQsWuL733nulFhYWXeWkeDwe8vLyJCUlJf/NysoyTE9PN5g4cWLLq6++WhkaGuoeHBws8PLyauJyuX1et6ioyECdFiKRSPQWLVrkNGvWLBf180eOHLHcsmWLTWRkpFN4eLhLfHy8SV/XyczMlObl5Unuf8ybN++BXEaFQkFyc3NHr1mz5m5ubq5k9OjRyq1bt2p0kYSJEyc2p6ammqxatcr+/PnzRpaWlh0AcP78eeMbN26MFovFnkKhUJSWlmZSVFSkn5SUZDJnzpxaOzs7BQDY2Nh0XLp0ySgsLKzOxMREaWpqqgwPD69NSUkxBgB7e/vWqVOnNgPAhAkTmoqLi/UBICUlxSgsLKzO2NhYaWFhoZwxY0bdQO3RlEG/xRBCAgghyYSQm4SQIkLILUJI0RCu/QiAAoZhihiGaQNwAsDc+85ZCeADhmFqAYBhmF9BUX8APdNTvvnmGxw7dgw5OTk6aYuR2AicUd3/Vy97v0xrsXumpwDAKTZzxSMiurdPnmQvzjAFOAbAcpTqC0lrRyu8rb1hqNfn3KbfhMvtXUo9nt25oRT1p6HOEc/Ly5PExMSUGhgYMDwej1H2KNHa0tLCAYA9e/aMUY8oFxcX81tbW0l4eLhrREREzfLly/us42plZdURFBTUkJCQYAoA69atq87JycnNyMiQmpubd7i7uz+Qg11RUcEzNjbu4PP5AACRSNT21Vdf3e55TkZGxuidO3dWnThx4vaxY8dunzhxos+UiuGMiDs7O7fZ2Ni0hYSENALAM888U5udna3RPHVfX9/WrKwsiY+PT/PWrVvtN2zYYAcADMOQiIiIe+r/FsXFxTcOHDhwZ7jX19PT6/pZmMvlMgqFYsAFNvprj6YM5eeEjwEcABAIYDKASZ3/DsYeqhrkamWdx3pyB+BOCLlCCLlGCJnV14UIIX8lhGQQQjLu3tVejitFPaxJkybBwUFVx7uurg7PP/88Pv74Y520hXAJzEPNwTXiwvJJSzi+rr1SgjPMzTFc5b9TAAAgAElEQVSqxyJCjxgbo63HHy+NCgsDDAxU29evA1IpO3GGicfh4e1pb+PTuZ+iakMVRGNEg7/oIfX4/of4eFUlR4qiNM/BwUFRU1PDq6ys5DY3N5OkpCRTANi8efNddUfR0dGxPTIy0snd3b1l+/btVT1ff+fOHV51dTUXAORyOUlJSTHx9PRsAYDy8nIeAOTn5+t9++23Zi+++GLN/fHz8/P1bGxs+k1HaW1tJTwej+F0rmj85ptv2q1du7bPDtRwRsQdHR0Vtra2bdnZ2foAcOHCBRMPDw+NLpJQXFzMNzY2Vq5evbomKiqq8pdffhkNALNmzZKdO3fOXP3+VFVVcW/evKk3c+ZMWUJCgnllZSVXfTw4OFiemJho1tDQwJHJZJzExETz4ODgAasVhISEyBMTE83kcjmpra3lJCcnmw3UHk0Zysqa9QzDfKfJoPfFFwB4AoADgP8QQnwYhun1rZFhmH8C+CcATJo0if5poUY8dXrK4cPdqymeOnUK+/fv19rqlj15nfYCh8fCEvODGMXlIszSEqeqq/GIkRFeHjsWemwsdQ8ARkbA7NmAOhXo//5PNWlTJAIWLWIn5hD9bcrftBInOBgwNVXNUy0uBn74AQgI0EpoimLfgQN3MNAI6NGjZTh6tP+f/OLibiMu7na/zw+Dvr4+s379+orJkyd72tjYtLu5uT3QGU1OTjY6c+aMpUAgaBYKhSIA2LFjR/kzzzxTX1payl+xYsX4jo4OMAxD5s6dW7N48eJ6AHjqqadc6+rqeDwejzl48GBJX5MhxWJxS01NDV8gEHhFR0cXT58+vbHn80lJSUZBQUFypVKJNWvW2IeHh9erJ47+VocPHy559tlnXdra2oijo2NrXFxcMQBMmzbNLSYm5razs3M7AMyZM2f8tWvXjGtra3k2Nja+b7zxxp1169ZV93dcff3MzMxRmzdvduBwOODxeEx0dPRtAPD392/ZsmVLeWhoqLtSqQSfz2cOHTpUEhoa2rh+/fqKoKAgIYfDYby9vZtOnTpVvGTJknsTJ070BIBly5bdDQgIaJZKpf1Oag0MDGyaP39+jbe3t5elpWW7r69v40Dt0RQy2MQtQsh7ALgA4gG0qo8zDJM1yOseA7CdYZiZnfubO1+3p8c5HwL4kWGYTzv3LwJ4g2GY9P6uO2nSJCYjI2OQ26Io3bt06RKCg4MBqMpYbd++HevXr4e+fp+VqP6wbjY1wZDLhb027vv4ceDZZ3sfe/xx4PKg01q0rrS+FA4mDhr/YjZ/fnflRpEI0FFGFKVBhJBMhmEm6bod2padnV0sFou1UPv096+yspIbFRVln5qaarJ06dJqmUzG3b17d8Xhw4et4uLiLMVicaOfn1/zxo0baVqBDmRnZ1uJxWLnvp4bSke8r2UBGYZhQgZ5HQ/ATQChAMoBpANYwjBMTo9zZgFYzDDMckKIFYCfAfgxDHOvv+vSjjj1e6FQKGBnZ4fq6mrY2dnhhx9+gLOzs66b9ccmkwHW1kBra/cxQoCyMmDsg3O7dOEf1/6Bz/77GTIrMnF91XV4W3tr9PoHDwLr1qm2ORygsbE7Y4f6faIdcWq4nnvuOcfY2Fi6tNcIMVBHfCgL+gT38RiwE975OgWAVwAkAcgF8BXDMDmEkJ2EkKc6T0sCcI8QIgGQAuD1gTrhFPV7wuPxEB0djR9++AFlZWUjphPOMAxkP8nQXKy7+uasMTEBZs7s3vf1BWJjVcdHACWjRMLNBGRWZAIA4nM1P6Ny5UrVdw8AUCqBxESNh6AoaoSjnfDfj35zxAkhSxmG+ZwQEtXX8wzDHBjs4gzDJAJIvO/Yth7bDICozgdF/eFE9KzkMQIUbSlC+aFydDR0wPpZa4g+Z2/i4P06GAZX6utx6u5d3Glrw9deLK1uvHBhd/lCPT1g6VJ24gxTq6IVbofdUCZTpbDyOXzca9L8uIOhoSpVXl8fWLtWlZlDURRFjUwDTdZU19d6oHwNRVEPj2EYnUzYBICGzAZ0NKjm/dxLuKfVtqTW1SEkOxvqZLjy1lZ28sbnzAH8/IC5c1Wd8hFCn6cPgYWgqyP+9+l/x6uPvspKrG+/ZeWyFEVRlIb12xFnGOajzn93aK85FPXH1NbWhoSEBJw6dQqFhYX48ccfddIOh7UOqD1fCwDokHVA/rMcxhO18137rVu30HNGyjfV1Vhtf39FUw0wMwN+/lnz19WAecJ5SClWTbtJKkxirSNOURRF/T4MZUEfA0LIGkJINCHkE/VDG42jqD+KyspKLFmyBHFxcfjpp58gkUh00g7z6eYw9O1eTKb6rPbmQS3osbjPFGNjrLTT6JoIg2vWfU78XI/uNc0u3roIWat2VjmlKIqiRqahFPT9DIAtgJkALkNV73vAougURXVrbW2FSCRCW1v32gtJSUk6aQuHx4HTW05d+zXfPrBOBGvmW3WvKP2LXI4Wthb26ampCdi9G3jsMUAgUM1e1CEnMydMsJ0AAGjraMN3+Wwt0dDt2jXgL3/R+a1TFEVRfRhKR9yNYZitABoZhokBEA5gCrvNoqg/Dn19fYSEdBcaWrduHV577TWdtcd8hrlqZQAADRkNaK1sHfgFGuIyahR8DVWj8a0Mg/M1WvgSoK8P7Nun6o2Wl4+IlJV5wnld23E34vB/6f+HBGmCxuMoFICFheo7yCef0OopFEVRI9FQOuLtnf/WEUK8AZgCsGavSRT1x7Ogx9rj165d09lkTQDgm/FhFmTWtV/znW5GxeOrWU6L+eknYMoUoFaVEw8OZ8R1xL+RfoPViatx8MeDGo/D46m+h6gdOqTxEBRFUdRvNJSO+D8JIeYAtgI4C0ACYC+rraKoP5g5c+aAy1UNQ1+9ehV37vS/SrM2WIRbdG1XxlRqLe78Hnni56qrkSGToUGhYCfYmDFApqpeN/h84PZt4MUX2Yk1DD7WPhhvNr7XscvFl1HdpPkvJnO7U9Jxj67QQFEUNeIMZUGffzEMU8swzGWGYVwYhrFmGOZDbTSOov4oLC0tMW3atK79b775RoetAbhG3K7t+rR6KNu0k0Dsa2gIl85lHuVKJSZnZeEsWz3E8eMBT0/Vdns7kJ3NTpxhIoT0GhUfazwWB2cdhB5XT+OxNm7s3r5+Hair03gIiqIo6jcYStUUM0LIWkLIAULIIfVDG42jqD+SnukpJ0+eRFpaGhobG3XSFvPp5t07HUDt97VaiUsI6ZWeAgDfsjlUGx7evT2CkqR7dsQZhsHqyathoq/51T9dXIBJnQujt7cD585pPARF/T979x7X5Hn3D/xz5UREIJzkLAdJICQcBHS2AkVBAWFWi7Wlrp32Wbv9qnt0YqfTqfOwVftMXdd2PK22W2V71HVoXVUKUgsO7UEOlSKRACKCB1DkEMI5yf37IwSCctQcUK/365VX7yR38r3uSOGb6/7e1/exJpfLeSKRaFD3sdTUVLetW7c66z9WVVXFnTVrlp+vr69UKBRKd+7c2V/C29HRQYKCggL8/f0lQqFQunbtWjfdc+7u7kF+fn4SsVgsCQwMDBhuHFeuXOEeOHDAbrjnjWGkYxrrPjt37nQSiURSoVAo3bFjx4Qtax7q39RUxlKakgnAG0ApgCK9G0VR47B48UDy9dVXXyEqKgpnzpwxy1gsfS3BseOAcAmsQq3AcRipt5dh6ZenEAAWrLH8GnpAiYkD26dOAQwz/L4mFDE1AvG+8dgVuwtfLf8KLGK8z0Dv+x9OGP6aUIqiAHC5XOzdu/f6lStXygoKCi5//PHHTkVFRXwA4PP5zLlz5+RyuVxWVlYmO3PmjM2ZM2f615E9e/ZsRXl5uezSpUuXh3v/zMxMm+LiYktTHIvOSMc0ln0KCgr46enpU4qLiy9fvny5LCsry/bSpUtG6OL2aBvLb38+wzCpDMP8jWGYg7qb0UdGUY8Zd3d3zJo1eMGhTDPO0s6UzcQz3c9gRvEMCGYJTBb3aRsbOHG0if9UHg+/8/Ia5RUPITISsOmbab52DcjPBz75xOxrirNZbGS9nIXfRP4GYkexUWMtXDiwffq0djUViqIMy8vLqzcyMrIDAOzs7DS+vr6dtbW1PABgsVgQCAQaAOjp6SEqlYqM54L97Oxsqy1btkw9efKknVgslshkMsPXsQ1hpGMayz6lpaWTQkNDldbW1houl4uIiIi2I0eO2Oq/XqFQsObMmSP09/eXiEQiqf6sf1pamn1QUFCAWCyWLFu2zEvV98vr/fffd/Dz85P4+/tLFi9e7AMA27ZtcxaJRFKRSNQ/8y6Xy3nTpk2TpqSkeAmFQmlERIRIqVT2f/AbNmxw8fb2DgwPD/evrKy0GG08xjKWabC/E0JeB3ASQP86ZwzDmG6pBYp6TCQlJfV31bS0tMQUvdlhU7NwMc/EBIsQHBCLMdXCAtOtrIy7ggyXC8TFARkZ2vtz5mhnxZ2dgQULjBf3ATEMY/DPQyoFXFyA+nptjfiOHdobRVHGIZfLeTKZzDI6Olqpe0ylUiEwMFBSW1trsXz58tsxMTH9dYmxsbEiQgheffXVO2+++eZ9V23Hx8crg4KC2vft21c3c+bMrocZW3h4uH97ezv73sd3795dt3jx4mF7xAx1TKPtM3369M4dO3a419fXsydPnszk5OQIQkJCBtVjHjt2zMbFxaU3Ly+vCgDu3r3LBoDi4mJ+RkaGfWFhYbmFhQXz8ssve37wwQcOTz31VPuePXtcv/nmm3JXV1dVQ0MDOz8/3/LQoUMORUVFlxmGQXh4eEBsbGybo6Ojura2lv+Pf/yjevbs2dcSExOnpaen261cubIpPz/f8rPPPrMvLS2V9fb2Yvr06ZLQ0NCO4cZjTGNJxHsA/BHAb4H+DtUMgGnGGhRFPa4WLFiArVu3AgBsbW2x4wnNiJ69p07cqBITBxJxXWnKiRMTJhHv6O3AwYsHkVmViRuKGyj+RbFB358QwNNTm4gD2o/iCf2xo6hxG+6L8XCPt7a2spKTk313795dZ29v338VPIfDQXl5uayxsZGdlJTkW1BQwJ85c2bXuXPnyn18fHpv3LjBiYmJ8ZNKpV0LFiy4L9mtrq7mT58+vQsAZDIZb9u2ba4KhYKdlZVVDWhnievr6zlVVVX8trY29s9+9rPG5OTk+1r3FhUVycf7GQx3TKPtExYW1rVmzZr62NhYv0mTJmmkUmmHbvUwnbCwsM7f/va3U9944w33RYsWtSYkJCgBICsry/rSpUuWISEhAQDQ1dXFcnJyUrW2trIXLlzY7OrqqgIAZ2dn9f79+60SExNbbGxsNACQlJTUnJuba7106dIWd3f37tmzZ3cCQGhoaEdNTY0FAOTm5lolJia2WFtbawAgLi6uZaTxGNNYEvF10Db1MV0vbIp6TIWFheFXv/oVoqOjERsba9b1xO+lbleDPdnoX/5N796E++mngbAw84xlCCzCwrrT69Cp0pbLXGm6Al97X4PGWLZMu6w6AFRUAGo1wH4M/6mpx1tqVZXbn65fdx3LvilOTo2HJZJr+o+9JJN5Hbl9u38WYK2Hx619QuGIa8k6OzurWltbB/3f0tTUxPbx8enetWvXlIMHD04BgKysrEpXV1dVUlKS79KlS5uWL18+5BpFjo6O6qioqLYTJ04IZs6c2eXj49MLAO7u7qqkpKSWb775ZvK9ifitW7c41tbWai6XCwCQSCQ9n3766bWEhIT+CdHCwkLLv/71r3UsFgt37txhr1q1ymOoRHy8M+Ld3d1ktGMaaZ+1a9c2rl27thEAfvnLX7p7eHj06D8fHBzcXVxcLDt69Khgy5Yt7l9++aViz549txiGIUuXLr37l7/85Yb+/n/4wx/GdcEnj8frvzCIzWYznZ2dI5ZkDzee8cQcr7HUiFcB6DDmICjqScFisfCnP/0JixcvhrW1tbmHA3WPGvLX5fja/WvkC/KhajNtATHDMChrb8ee2lpkG6vTposLEB4+cP9Xv5oQ64kDwA8NP2DWR7P6k3AA+M+1/xg8zquvApaWwFNPAe+9p+1tRFHU6AQCgcbJyan3888/twaAhoYGdl5eniAmJka5cePGO+Xl5bLy8nKZp6dnb0pKipefn1/Xtm3bGvTf4+bNm5zGxkY2ACiVSpKbm2sTEBDQpVAoWM3NzSxAW5ucm5trExwcfN8FLJWVlTxnZ+eeex/X6e7uJhwOh2H1/Y+9adMm19WrV98Zat+ioiK5bsz6t6GScI1Gg+GOaaz73Lhxg6M7hlOnTtm+9tprg37R19TUcK2trTUrV65sSk1Nrb948aIlACQkJChOnjxpp3t9Q0MDu6KighcfH684ceKEXX19PVv3+Ny5c5WZmZm2bW1tLIVCwcrMzLSbO3fusGU2ABATE6PMzMy0VSqVpLm5mZWTk2M70niMaSwz4u0ALhJCcjG4Rny10UZFUZRJqJvVuPXRwJf9xs8a4fJTF5PF33ntGn5XUwMAWDplCuLt7Ud+wYNKStLWZiQmatf0myDcrN1Q2lAKACAguPD6Bcxwm2HwODY2gFKpLVOhKGp8Dh48eHXlypWe69evnwoAGzZsuCmVSrv198nJybE6fvy4g0gk6hSLxRIA2L59+40XX3yxta6ujrtixQoftVoNhmHIokWLml566aVWmUzGe+6554QAoFaryZIlS+4+//zz981ih4SEdDU1NXFFIpE0LS2tZv78+YPqrLOzs62ioqKUGo0Gq1atck9KSmrVXUD5MEY6pujoaOHBgwevyeVyi+H2AYBnn33Wt6WlhcPhcJh33nmn1tHRUa0fo6ioaNLGjRs9WCwWOBwOk5aWdg0AwsPDuzZv3nwjNjbWT6PRgMvlMu+++25tbGxs+7p1625FRUWJWSwWExgY2HH06NGaZcuW3Q0LCwsAgFdeeeVOREREp1wuH/ai1sjIyI7nnnuuKTAwUOrg4NAbHBzcPtJ4jIkwoyznRQhZPtTj5lo5ZcaMGUxhYaE5QlOUQfX29uLrr79GZmYmYmNjERcXZ5ZxfO32NXpuaSdbBHMECM0NNUncK52dEPZduAoAAjYbjRER4BhjurarS9vvfQJmorM+moULN7R1I/98/p94QfqCmUdETTSEkCKGYQz/DW2CKykpqQkJCaFlsfeor69np6amuufn59u8/PLLjQqFgv3WW2/deu+99xwPHz7sEBIS0j59+vTO9evXDzkrTpleSUmJY0hIiPdQz406I84wzEFCyCQAngzDjLvIn6Koof3+97/vv1izoaHBbIm400+ccH3PdQBAx+UOMBoGhGX8hHUanw8vCwtc69ZOLP3c1RVqjO003bjx+aPvYyYJvgn9iXhWVRZNxCmKGpGLi4v60KFDtbr7P/3pTz0FAoFm8+bNtzdv3nzbnGOjxm8snTUXArgIIKvv/nRCyOfGHhhFPc6OHDmCt99+u//+F198AY3GNG3m7+W72xdcR+1FQL0NvWgrHrG0zmAIIUh0cBh036jNfXRu3wb+9jdgyRLgyBHjxxvFAtHAxaRZVVkY7SylIdy5o215T1HUoy89Pb129L2oiWosf/W2AfgRgBYAYBjmIujShRT1UEQiEbr7ZoL5fD4OHDhgkgRsKIRNYJ8wUJvddMp0LQIS9GrCvzDWxZr3OngQ+K//Ao4dA/71L9PEHMFMt5mwn6T9HG4pb+HCjQs4U33GKD8PH30ETJkCODkBzz9v8LenKIqixmksiXgvwzCt9zxmnqk7inpMhIaGwslJuwpTV1cXXF1dce/6qqbk8OOBmem7p+6aLG6MrS14fXXbpe3tuN71UL0qRvfxx4B+N9PTp4Hu7uH3NwE2i40434GypMi/RWLe3+ehsqnS4LE6O4HGvorbqiqgt9fgISiKoqhxGEsiXkYIWQaATQgREULeA/C1kcdFUY81FouFhISE/vtffPGFGUcD2MXbAX3fA9oK2tDTMOxKWQZlxeEgSiDov5/V1ASNMc8MpKcDeXna7RdeAAoKAJ5JukWPKMF34GdBpdEuIflFpeF/JpbrXXqv0QDff2/wEBRFUdQ4jCUR/28AUmiXLjwEQAHgV8YcFEU9CRboNZoxdyLOEXDAcx1ISBsODblkrFEs0KsT/011NVJkMuMFS0oa2NZoALF4QqykEi+MH3Tf38Efk3mTDR7HxgaYobf2xg8/GDwERVEUNQ6jJuIMw3QwDPNbhmFm9t1+C2BcnY0oirpfXFwcdA0YvvvuOzQ2NvbXjZsaIQQsi4FfBw3/MGEirlcnflelwhdNTegx1oWriYkD26dPT5jaDBcrF4S6DCwbuXvebrwWZpymQykpA9tm/v5HURT1xBsxESeEPE0IeZ4Q4tR3P5gQcgjAeZOMjqIeY/b29njqqacAaDtMhoSEYPnyIZftN4kpyVP6twnPdLPEAZaWmKpXHtKuVuOiUjnCKx6CVAp4emq3FQrg/MT5VZYgTIDQXohfzvwlfGx9jBZH/7tITg7QY5oqJIqiKGoIwybihJA/AvgrgCUAThFCfg/gNIDvAIhMMzyKerzpl6fcvHkT2dnZUKlM22Zex321O4R/FiKqPQrh34SP/gIDuXcZw1+6u+NHNjbGCja4POXUKe3FmteM3jxtVNvnbEflf1fivcT3EOISYrQ4YjHg5aXdbmsDvqZX/FAURZnNSDPiSQBCGYZ5CUActHXhTzEM82eGYYy8tAFFPRn0E3FAu4KKXG6evll8Dz48VnuAbWn61VtecHLCL93dcSooCLuN3YJePxH/8EPA0RFYscK4MceAy+aaJA4hg2fFd+40SViKoihqCCMl4l26hJthmGYAlQzD1JhkVBT1hNBfxhAATp8+DalUasYRmUeMnR3eE4mQ6OAAS2Mv4zh37kCnzbY2QKnUlqgYqxzmAbT3tOOE/ATeOPkGKu5WGPz9w8IGtvPyaHkKRVGUuYyUiE8jhHyuuwHwuec+RVEPicViYcmSJUhMTMR7770Hf39/cw/p8WdpqU3G9bm7A1evmmc8Q1jx7xV49siz+KDoA5ysOGnw99e/YFOjAT77zOAhKOqxwWazw8VisUQkEkkXLFgwra2tbUwtgKuqqrizZs3y8/X1lQqFQunOnTv7Z106OjpIUFBQgL+/v0QoFErXrl3rpntu586dTiKRSCoUCqU7duwYdnGMK1eucA8cOGD3cEc3PiMdk77hjq+kpMRCLBZLdDcrK6vQkY7RnFJTU922bt3qbOw4nBGeW3TP/b3GHAhFPanS0tLMPYRBehp7cOvjW7h9+DacXnSC10Yvk4/hbm8vLrW3I9rW1jgBkpIGlgyJjgZycyfEMoYaRoN3v3sXsjsDSzh+UfUFUp9ONWgcKytg6lSgrg7w8dEua0hR1NAsLCw05eXlMgB49tlnffbu3Ttl27Ztoy4txeVysXfv3uuRkZEdzc3NrNDQUEliYqIiPDy8i8/nM+fOnZMLBAJNd3c3mTlzpv+ZM2dabWxs1Onp6VOKi4sv8/l8TXR0tF9ycnJrYGDgfUtqZWZm2shkMj6AZiMc9riPSX+/4Y4vNja2XfdZqlQquLi4hKSkpLSYavwT0bDf6hiGOTvSzZSDpCjKdMqeK8PV31xFe0k76g/WmzR2m0qFp4uL4XT+PBJ/+AFdarVxAumKpPl8bc/3CYJFWPio+KP+RHxJwBJsfWarUWJ99RXQ2gpUVwP3XKpAUdQwIiMjlVVVVRZyuZwnEon66wi3bt3qnJqa6qa/r5eXV29kZGQHANjZ2Wl8fX07a2treYD2bKhAINAAQE9PD1GpVIQQgtLS0kmhoaFKa2trDZfLRURERNuRI0fum5HIzs622rJly9STJ0/aicViiUwmM0lnspGOSd9wx6fv888/t/H09Oz28/MbVBynUChYc+bMEfr7+0tEIpFUf9Y/LS3NPigoKEAsFkuWLVvmpVvc4P3333fw8/OT+Pv7SxYvXuwDANu2bXMWiURSkUjUf2ZBLpfzpk2bJk1JSfESCoXSiIgIkVKp7B/Yhg0bXLy9vQPDw8P9KysrLUYbjyGM6fQKRVGmU1lZiRMnTpgtvn3iwLrenZWdUHcZKRkewuqqKnynUEADoEOjQX5rq3EC+fgAZ84ATU3Av/41IWbDdRKEA1023azdEOUVZZQ4QiGdCaeo8ejt7UV2drZNUFBQ53hfK5fLeTKZzDI6Orr/YhSVSgWxWCxxdnYOiY6OVsTExLRPnz6988KFC9b19fXstrY2Vk5OjqCuru6+RDc+Pl4ZFBTUfuzYsary8nKZRCJ54Cs9wsPD/fXLRXS348ePW4/3mPQNdXz6zx8+fNj++eefv3vv644dO2bj4uLSK5fLZZWVlWXJyckKACguLuZnZGTYFxYWlpeXl8tYLBbzwQcfOBQWFvL37Nnjevbs2Qq5XC778MMPa/Pz8y0PHTrkUFRUdLmwsPByenr6lPPnz08CgNraWv7q1atvV1VVlQkEAnV6erodAOTn51t+9tln9qWlpbKcnJzKkpKSySONx1BGKk2hKMqEmpqa8NRTT6GyshJWVlZobGyEhYWFycfh/BNnXN18FdAA0ACt51phP89+1NcZAo8Q6Brcu/N4MGKzeyAmxpjv/sAShAnY+422EvCLKtpxh6LMrbu7myUWiyUAMGvWrLY1a9Y0Xrt2bczLHLW2trKSk5N9d+/eXWdvb9/frYzD4aC8vFzW2NjITkpK8i0oKODPnDmza82aNfWxsbF+kyZN0kil0g72MBewV1dX86dPn94FADKZjLdt2zZXhULBzsrKqga0s8T19fWcqqoqfltbG/tnP/tZ41BJZFFR0biX6hrumPQNd3wA0NXVRb788kvBvn37rt/7urCwsM7f/va3U9944w33RYsWtSYkJCgBICsry/rSpUuWISEhAX3vwXJyclK1trayFy5c2Ozq6qoCAGdnZ/X+/futEhMTW2xsbDQAkJSU1Jybm2u9dOnSFnd39+7Zs/9JZ/0AACAASURBVGd3AkBoaGhHTU2NBQDk5uZaJSYmtlhbW2sAIC4urmWk8RgKnRGnqAmgra0NGzduxNW+CwaVSiXOnTtnlrHwPflwe2PgDGvzaZOVHw7qsjmFx0OcvWm+AKCzU9tp85NPTBNvBFGeUbDkWgIAqpqqUNVUZZK4jFG/9VDUw0utqnIjeXnhJC8vPLWqyu3e51+Xyz10z//u6tX7LrJ7SSbz0j2/p7bWcaxxdTXi5eXlsoMHD9bx+XyGw+EwGr0OwF1dXSwA2LVr1xTdjHJNTQ23u7ubJCUl+S5durRp+fLlQ9ZCOzo6qqOiotpOnDghAIC1a9c2lpWVXS4sLJTb2dmp/fz87lsy+tatWxxra2s1l6v9PiCRSHo+/fTTQQ0RCgsLLXfs2NFw5MiRa5988sm1I0eODFlSMd4Z8bEc00jHBwAZGRkCiUTSMXXq1PsaZwQHB3cXFxfLgoKCOrds2eL+5ptvugIAwzBk6dKld3X/FjU1NZf27dt3c7T49+LxeP2/7dhsNqNSqUY8JTrceAxl1EScEOJHCDlACDlNCPlKdzPkICjqSTd58mT8+9//7m/mExkZCR7PJCV/Q7JPGEiAm043mSxujJ0dOH1lIheVStzqvu/6JMOrrQXs7YH4eOBXvwLM1FBJx4JjgRifgdn67KpsMAyDHrXh1xjs6QHWr9c2+Zk8WdvbiKKo0Xl4eKiampo49fX17M7OTpKdnS0AgI0bN97RJYqenp69KSkpXn5+fl33Xtx58+ZNTmNjIxsAlEolyc3NtQkICOgCgBs3bnAAoLKyknfq1Cnb11577b5fwpWVlTxnZ+dhfyl0d3cTDofDsFjaNG/Tpk2uq1evvjPUvkVFRXLdmPVvixcvbrt3X41Gg+GOaazHBwBHjhyxf+GFF4b841JTU8O1trbWrFy5sik1NbX+4sWLlgCQkJCgOHnypJ3u82loaGBXVFTw4uPjFSdOnLCrr69n6x6fO3euMjMz07atrY2lUChYmZmZdnPnzr3vePTFxMQoMzMzbZVKJWlubmbl5OTYjjQeQxlLacq/AHwA4AAA0xWLUtQThMViISEhAQcPHgQAzJs3D1FRxqkNHgvbObYgXAKml0F7STt6GnrAczb+FwMbDgeRAgHyWrSTLFlNTXjV1aCTD4MpFMD33wO6U7+trcCFC8Ds2caLOQYJvgn9yxa+ff5t7Dq3C2tmrcGvI35t0DgqFfDHPw7cP3oUWLbMoCEo6rFkYWHBrFu37tbMmTMDnJ2de4VC4X2z1jk5OVbHjx93EIlEnbrSlu3bt9948cUXW+vq6rgrVqzwUavVYBiGLFq0qOmll15qBYBnn33Wt6WlhcPhcJh33nmn1tHR8b7cKyQkpKupqYkrEomkaWlpNfPnzx9Uf52dnW0VFRWl1Gg0WLVqlXtSUlKr7iLLhzHSMUVHRwsPHjx4zdvbu3ek41MoFKxz587ZHDx4cMiWxkVFRZM2btzowWKxwOFwmLS0tGsAEB4e3rV58+YbsbGxfhqNBlwul3n33XdrY2Nj29etW3crKipKzGKxmMDAwI6jR4/WLFu27G5YWFgAALzyyit3IiIiOuVy+bB/yCIjIzuee+65psDAQKmDg0NvcHBw+0jjMRTCjHI+khBSxDCM6fpdj2LGjBlMYWGhuYdBUQb3z3/+Eyl9CzzPmjUL3377rVnH8/2c79F6VnuxZMA/AuD8E6MvpwoA+J/aWmyorgYALJ0yBZ8as8HRn/4EpPYtDWhtDbz6KvDGG9opYjOqbq6G77u+gx6b6z0XXy03/MlILy/tSQFAu5jMqVMGD0E9pL6/wzPMPQ5TKykpqQkJCWk09zgeBfX19ezU1FT3/Px8m5dffrlRoVCw33rrrVvvvfee4+HDhx1CQkLap0+f3rl+/fohZ8Up4yopKXEMCQnxHuq5sdSInyCErCSEuBJC7HU3ww6Roqi4uDjoTiNeuHABjY3m/ftjFWrVv33zw3GX4T0w/TrxU3fvYvnly+jWDHkt0MOLixvYZrOBffvMnoQDwDS7aRDZiwY99kPDD0YpT0lOHtg2dlNTiqKMw8XFRX3o0KHaurq6S7t27apva2tjCwQCzebNm2+XlZVdPnToUC1NwiemsSTiywH8GsDXAIr6bnRKmqIMzM7ODk8//TQAgGEYZGdnm3U8TM/A2bK2gjaMdvbMUAInT4Z7X318h0aD9IYGfG2sZQwlEsCt75qvlhZgAp1t01/GMCUwBfVv1oPHNnx50BtvDGzn5gK9vQYPQVGUiaWnp9eaewzU2IyaiDMM4zPEbZopBkdRT5oFep1V3nnnHaSkpJgsAb6X8ysDpSiaLg06qh66vHBMCCFY4OAw6LHTzUZauYUQYP58vUCnjRPnAegScSueFVytXMFhGWe1WZFIW54CAEolYOaKKIqiqCfKWFZN4RJCVhNCMvpuvySEjHn9TIqixi5Or1SisLAQ//znP1FaWmqWsdjMtIFNpA3c/9sdM8pmYLJossli65enuPF4+ImTk/GC6Zen5OQYL844zfWei7zlebi7/i72xe8zWhxCJuxHQFEU9dgbS2nK/wIIB5DWdwvve4yiKAMLCwuDnd3gpV5Pm2mWlrAJwvLDIHpXBCuJ1egvMKBYOzs4cDh4ztERW729IZ1sxC8B8+YNbJ8/D/z859pmP2ZeWHsSdxKivaONUo5yL/2TAkePAsYqyacoiqIGG8u5zpkMw4To3f+KEFJirAFR1JOMzWYjNjYWGRkZAIClS5f2r6TyJBFwOLgdEQGWKVrPOzkBoaHaZQw1GuDAAe3jFRWAv7/x44+RhtHgh4YfwCIsBDsHG/S99ZuMymRAfj4QHW3QEBRFUdQQxjIjriaE9K+jRQiZBrqeOEUZja48JTg4GAkJCfDw8DDziMzDJEm4jn5tho6ZL5bVd7LiJFz2uCD0w1C8lf+Wwd/fwUHb00hH912EoiiKMq6xzIj/GkAuIaQaAAHgBeBVo46Kop5gL7zwAhYuXAgXFxdzD6WfpluDptNNULep4bzMNOuJ30vNMGBBezGnwcXFAW+/rd22swP+9S8gIsLwcR7A3Y67kN2R4U6HduWxL6u/hIbRgEXGMo8ydrNnAye1PYRw65ZB35qiKIoaxqiJOMMwZwghIgC6c7RyhmFoI2SKMhKBQACBQGDuYfSr+3MdrqReATQA15Fr8kT8/xoacPzOHZxpacE3YWHwtzRod2GtiAhg0iSgsxNobgb8/AA+3/BxHsCGLzfg4+8/BgBYci0x33c+WrtaYTfJbpRXjjPOBiA8XNtZUyQafX+Koijq4Q2biBNCYhiG+YoQknzPU0JCCBiGOWbksVEU1aezsxOTJk0yS2wLdwug7+K93sZedN/qhoWrhUli/6elBZuqq1Hbrf3uf7qpyTiJuIUFsHWrtl58/nxg6lTDx3hAcb5x/Yl4sFMwDi85bJQ4kZHaG0VRFGU6I82IRwP4CsDCIZ5jANBEnKKM7I9//CNOnTqFb775BrW1tXB2Nn1ZiH2CvbYorW8Rkbun7sLtNTeTxC5tb+9PwgHgQlub8YL95jfGe++HEOsTCwICBgwKbhagtasVAv7EOWNCURRFPbhhiwwZhvld3+YOhmFe1b8B2Gma4VHUk6ugoABpaWk4e/Ysenp68OWXX5plHBwrDlxeHahXb8lrMVnsOL2lHC1ZLHzs52ey2GAY4OpV08UbhoOlA8JcwwAAakaN3JpcM4+Iop4ccrmcJxKJpPqPpaamum3dunXQrEhVVRV31qxZfr6+vlKhUCjduXNnf/ODjo4OEhQUFODv7y8RCoXStWvX9s9kuLu7B/n5+UnEYrEkMDAwYLhxXLlyhXvgwAHD1qONQUZGho23t3egp6dn4KZNm4a8cGn79u1OQqFQKhKJpAsXLvTp6OggwMifyUQz1L+pqYzlap+jQzyWYeiBUBQ12Jo1a1BTU9N/v6yszGxjcV/p3r/dnNMMRmOaNbaFkybBy0JbBtOh0Rh3RlyHYbR93729gWnTgNu3jR9zFPOnDSz0nXPFuB13OjqAjz/WVuhcv27UUBT12OByudi7d+/1K1eulBUUFFz++OOPnYqKivgAwOfzmXPnzsnlcrmsrKxMdubMGZszZ870N0c4e/ZsRXl5uezSpUuXh3v/zMxMm+LiYiPU5Q1PpVJh7dq1npmZmRUVFRVlR48etdcdk87Vq1e5+/fvd7548aKssrKyTK1Wk48++sgeGPkzoQYMm4gTQsSEkCUABISQZL3bCgBj+iAJIQmEEDkhpIoQMux5X0LIEkIIQwiZMe4joKjHlH6XzZSUFLz1luGXrRsrq1ArcBy0lWy9t3uh/EFpkriEEMzXW1cvx1it7vUxDPDdd0BtbV9Q87eanO87kIj/W/5vbM/bjrSCNKPEcnMDXnsN+PJLuowhRY2Vl5dXb2RkZAcA2NnZaXx9fTtra2t5AMBisSAQCDQA0NPTQ1QqFRnP6k/Z2dlWW7ZsmXry5Ek7sVgskclkxu/yBSAvL2+yl5dXt0Qi6eHz+UxycnJTRkaG7b37qdVq0t7ezurt7UVnZyfLw8OjFxj5M9FRKBSsOXPmCP39/SUikUiqP+uflpZmHxQUFCAWiyXLli3zUqlUAID333/fwc/PT+Lv7y9ZvHixDwBs27bNWSQSSUUikXTHjh1OgPZsxrRp06QpKSleQqFQGhERIVIqlf0f/IYNG1y8vb0Dw8PD/SsrKy1GG4+xjDQj7g/gxwBsoa0T193CALw+2hsTQtgA/gJgAQAJgJcIIZIh9rMGsAbAd+MdPEU9zubrtTs8f/48GDN2eiQsAvv5Awlx82kTJMR95uuVpxg9Ef/6a8DVVdvcBwBsbIDGRuPGHIOIqRGYxNFerHuj7Qa2nd2G/y00ToNjX9+B7X//2yghKOqxJpfLeTKZzDI6Orp/xkKlUkEsFkucnZ1DoqOjFTExMe2652JjY0VSqTRgz549jkO9X3x8vDIoKKj92LFjVeXl5TKJRNLzoGMLDw/3F4vFkntvx48ft75337q6Op67u3t/LA8Pj54bN24MSqR9fHx6V61aVe/j4xPs5OQUYm1trU5OTlaM5TMBgGPHjtm4uLj0yuVyWWVlZZnutcXFxfyMjAz7wsLC8vLychmLxWI++OADh8LCQv6ePXtcz549WyGXy2UffvhhbX5+vuWhQ4ccioqKLhcWFl5OT0+fcv78+UkAUFtby1+9evXtqqqqMoFAoE5PT7cDgPz8fMvPPvvMvrS0VJaTk1NZUlIyeaTxGNNINeL/7qsH//E9NeKrGYb5egzv/SMAVQzDVDMM0wPgCIBFQ+y3E8DbALoe5AAo6nH1ox/9CDY2NgCAuro6VFRUmHU8dnEDCXHDoQaTxY21s4NuCuM7hQKnGhuh6JsZMTihcKAUhc0GqquBNWuME2scLDgWeMbrmUGPXbp9CTfbbho8VrLeOllq2rqNesINN3M93OOtra2s5ORk3927d9fZ29trdI9zOByUl5fLamtrfyguLp5cUFDAB4Bz586Vy2Syy6dPn648cOCA0xdffGE11PtWV1fzp0+f3gUAMpmM98ILL3glJCRM0z3//vvvO2zevNk5JSXFKykpadqxY8dshnqfoqIieXl5ueze2+LFix+o7u/OnTvsU6dO2VZVVZXW19f/0NHRwUpLS7PX32e4zwQAwsLCOvPz823eeOMN96ysLCsHBwc1AGRlZVlfunTJMiQkJEAsFkvOnTtnU11dbZGdnW2zcOHCZldXVxUAODs7q/Py8qwSExNbbGxsNAKBQJOUlNScm5trDQDu7u7ds2fP7gSA0NDQjpqaGgsAyM3NtUpMTGyxtrbW2Nvba+Li4lpGGo8xjaVG/P8RQvpPRRBC7Aghfx3D69wB1Ondv973WD9CSBiAqQzDnBrLYCnqScLlcjF37tz++6dPnzbjaABGNTAj3/5DO9QdpsnSHLhchFtrJ2s0AH586ZLxZsZ17e4BbRZ6/rxx4jyAON+BUiVvW28cXnIYNhZD/q19KD//+cD25cuAwujzQRQ1NlWpVW55JC98LDfZSzKve18ve0nmpb9PVWrVqMs/OTs7q1pbW9n6jzU1NbEdHR1Vu3btmqKbUa6pqeF2d3eTpKQk36VLlzYtX758yKvaHR0d1VFRUW0nTpwQANoZZQBwd3dXJSUltXzzzTeT733NrVu3ONbW1moulwsAkEgkPZ9++uk1/X0KCwstd+zY0XDkyJFrn3zyybUjR44MWVIxnhnxqVOnDpoBv379+qAZcgA4ceKEjaenZ7ebm5vKwsKCWbx4ccvXX3/d/2VitM8kODi4u7i4WBYUFNS5ZcsW9zfffNMVABiGIUuXLr2r+6JQU1Nzad++feOeeeDxeP1/uNhsNqNSqUasCRpuPMY0lkQ8mGGY/g+PYZhmAKEPG5gQwgKwD8C6Mez7c0JIISGk8M6dOw8bmqIeGfp14qdOncLRo0fR1WWek0f2C/QmORig6XSTyWLrl6cA2vXEjRdsoCQIZv7yo0//gk1FtwIvSF+AFW/IybOHMmXK4O8ieXkGD0FRjwyBQKBxcnLq/fzzz60BoKGhgZ2XlyeIiYlRbty48Y4uUfT09OxNSUnx8vPz69q2bdugU4Y3b97kNDY2sgFAqVSS3Nxcm4CAgC6FQsFqbm5mAdra5NzcXJvg4ODOe8dQWVnJc3Z2HrYcpbu7m3A4HIbF0qZ0mzZtcl29evWQydJ4ZsSjo6Pba2pq+OXl5byuri5y7Ngx+yVLlgxKpr29vXuKi4ut2traWBqNBl999ZV1QEBAFwBoNBoM95no1NTUcK2trTUrV65sSk1Nrb948aIlACQkJChOnjxpd+PGDY7uc6+oqODFx8crTpw4YVdfX8/WPT537lxlZmambVtbG0uhULAyMzPt5s6dO+IMf0xMjDIzM9NWqVSS5uZmVk5Oju1I4zGmsbS4ZxFC7PoScBBC7Mf4uhsA9LtiePQ9pmMNIBBAXt8pHhcAnxNCnmUYplD/jRiG2Q9gPwDMmDHDfIWyFGVi+nXi2dnZyM7OxpkzZxATE2PysfA9+OA6ccH0MrB5ygaWfqa7gH++nR129V08ySEErjwjXqsUFwf8z/9otyfAhZo6gU6BWDVzFZ72eBrzps0zeIt7ffPnD5TJnz4NPPus0UJR1IR38ODBqytXrvRcv379VADYsGHDTalUOqjDeE5OjtXx48cdRCJRp1gslgDA9u3bb7z44outdXV13BUrVvio1WowDEMWLVrU9NJLL7XKZDLec889JwS0FzwuWbLk7vPPP3/fOaiQkJCupqYmrkgkkqalpdXMnz+/Xf/57Oxsq6ioKKVGo8GqVavck5KSWnUXST6MvlVPahMSEvzUajWWLVvWOGPGjC4AiI6OFh48ePBaTExM+8KFC5uDg4MDOBwOpFJpR2pq6p3RPhNdjKKiokkbN270YLFY4HA4TFpa2jUACA8P79q8efON2NhYP41GAy6Xy7z77ru1sbGx7evWrbsVFRUlZrFYTGBgYMfRo0drli1bdjcsLCwAAF555ZU7ERERnXK5fNg/FJGRkR3PPfdcU2BgoNTBwaE3ODi4faTxGBMZ7QIwQshPAWwC8C9o23o8D+APDMP8fZTXcQBUAIiFNgEvALCMYZgh12AjhOQBePPeJPxeM2bMYAoLR9yFoh4bDMNg2rRpg5Yx3LBhA3bv3m2W8WhUGrA4xksAh9Ot0cAuPx+dDIMwKyvkTZ8Oa85Y5gMeQFcXYG+vbXcPAKdOAWVlwKpVgDG6ek5AZ84A8+Zpt/38gPJyYByLPFAGRggpYhjmiVtVrKSkpCYkJMT8V0tPMPX19ezU1FT3/Px8m5dffrlRoVCw33rrrVvvvfee4+HDhx1CQkLap0+f3rl+/XpaQjBBlJSUOIaEhHgP9dyof8kYhkknhBQB0BWrJjMMIxvD61SEkF8CyAbABvBXhmHKCCE7ABQyDPP5mI+Aop5QhBDMnz8fB/rWkXNzc4OPj4/ZxmOOJBwALFgsfBESAqmlJRyNORsOAHw+EB0NZGVp7yclaf8bEqKdLZ9gVBoVOCzDfimJiAB4PKCnB6ioAA4fBpYtM2gIiqIekIuLi/rQoUO1uvs//elPPQUCgWbz5s23N2/ebP7GB9S4jOmvat8s9qcAPgegJIR4jvF1mQzD+DEM48swzB/6Hts6VBLOMMyc0WbDKepJpF+eIpFI8Itf/MKMozGfaFtb4yfhOvp14joTqEzlhuIGNn65EeH7w7Hw8EKDvz+fDzjr9Zj7+4jnPymKMqf09PTa0feiJqpRp1EIIc8C2AvADcBtAF4ALgOQjvQ6iqIMIzY2Fn/4wx8wf/58hIWFmXs4g/Q09oDnaKLk2JT0Z74JAZYuBSIjzTeee/Soe7D7vLY8ic/ho0vVBT7HsA3r5s0D/vY37faFCwZ9a4qiKKrPWGbEdwJ4CkAFwzA+0NZ8f2vUUVEU1c/e3h6bNm3CzJkzwWazR3+BkXVe68TFuRfxH6v/4Nup35qs3b1Oh1qN7KYmrKuqwkVjtbyXSrWNfQBtp81164BFQ7VBML1PLn6CsP0DX8h61b0oqS8xeJzXX9eu5vjCC8Cnnxr87SmKoiiMbfWTXoZh7hJCWIQQFsMwuYSQd4w+MoqiJqTeO71oyRtYwart+zbYhBt+PeshY2s0eLGsDCf7li+04XAw3fq+5W8fHiHAggXahbTnzx9cp2FmzpOd0dKl/fyn2kxF6RulEPAFBo/z9NNAg+n6NlEURT2RxjIj3kIIsQLwHwD/Rwj5M4D2UV5DUZQR1NfX4x//+Ad++tOfQi6Xm2UM1mHWIBYDS2g0pJsuW/v0zp3+JBwAcoy5nvhHH2lb3m/fDnjd1xvEbJ7xegY8trYcqE5Rh/Ze+uuYoijqUTWWRHwRgA4AawFkAbgCwPBXB1EUNaqf/exneOWVV/D3v/8dWbpVPUyMsAgcFjr031eWKk0WO9a2v8kvWADenDp1+J0f1gRdr28ybzIipkb03/+y+kszjoaiKIp6GCMm4oQQNoCTDMNoGIZRMQxzkGGYdxmGuWui8VEU1WfVqlXIzMzsv5+dnW22sYjeEfVvK84rTNbu3sXCAsGTtR2gNQC4LBMtp1hUBOzYAURFadcUNzP9Lps51cZfzYVhtB/BjRuj70tRFEWN3Yh/xRiGUQPQEEIMX4BIUdS4+Pn59W9LJBL8/ve/N9tYLNwtYCnVNrdhehi0/KdllFcYjn67e6OWpujbvRv43e+Ac+cmRNv7+b56ifiVHFxvvY5zteeMEuvll7XLGc6Yof0uQlEURRnOWKaTlABKCSEfE0Le1d2MPTCKogbTX0/85s2bCA4ONuNoAPs4+/7t5tPNJosbZz8Q93SzkeO2tACbNg1ev28CrCce6hIKh0na8qCG9gZMfWcqXsx4EaN1Sn4Q9fXaxj7AhDh0iqKox8pYEvFjALZAe7Fmkd6NoigTCggIgJubGwCgpaUFhYXm7X9lN39gZrrxpOm6UEcJBLDoq9++3NGB611d0BghAQWgnQp+5x2gtq9fxp//DHzyiXFijQObxUbstNhBj91suwnZnVGbHo+bfkdNU52AoCiKelIMm4jrumf21YXfdzPdECmKAgba3evkmHl6ctK0SUDf9YxdlV3ovtltmrhsNiIFA9Vy4UVFOHDrlnGC6drd9wefpF1cewLQrxMnIJg3bR46VZ0Gj5OSAnD6FrptbaV14hRFUYY00oz4cd0GIeSoCcZCUdQo4vQ6Pp4+fRpqtRo9uroBE7PwsBh0//ant00We75eecrt3l6cNuZUrX6XzQlQH66jn4jz2DyceOkEZrjNMHgcS0vgmWcG7k+gj4CiTILNZoeLxWKJSCSSLliwYFpbW9uYrhKvqqrizpo1y8/X11cqFAqlO3fu7P8W39HRQYKCggL8/f0lQqFQunbtWjfdczt37nQSiURSoVAo3bFjx7Df/K9cucI9cOCA3XDPG0tGRoaNt7d3oKenZ+CmTZtchttv+/btTkKhUCoSiaQLFy706ejoIACwdOlSb3t7+xCRSDShO7Snpqa6bd261ehNJEb6YdJfu2uasQdCUdTo5s2b1799/vx5ODo6IiMjwyxjYU9mg++jbatOuASqZpXJYsfZDf7b861CYZT6aG0wvUT8yy8BtWlWiBmNl60XAp0CMcd7DrZGb0WP2nhfyOLjB7ZpIk49aSwsLDTl5eWyysrKMi6Xy+zdu3fKWF7H5XKxd+/e61euXCkrKCi4/PHHHzsVFRXxAYDP5zPnzp2Ty+VyWVlZmezMmTM2Z86cmVxQUMBPT0+fUlxcfPny5ctlWVlZtpcuXbIY6v0zMzNtiouLLQ15rKNRqVRYu3atZ2ZmZkVFRUXZ0aNH7XXHpO/q1avc/fv3O1+8eFFWWVlZplaryUcffWQPAP/1X//V+Pnnn1eactwT2UiJODPMNkVRZuLk5ITQ0FAAAMMwaGlpwWkzZkZ++/0w/ex0PNP9DHy2+5gsboiVFRw5A42Bj0mlIMZa91siAfpq89HSAhQWAo2NQEeHceKNw8VfXETu8lxsitoEGwvjdTfVT8RzcibMdxGKMrnIyEhlVVWVhVwu5+nP6G7dutU5NTXVTX9fLy+v3sjIyA4AsLOz0/j6+nbW1tbyAIDFYkEgEGgAoKenh6hUKkIIQWlp6aTQ0FCltbW1hsvlIiIiou3IkSO2uEd2drbVli1bpp48edJOLBZLZDIZz7hHrpWXlzfZy8urWyKR9PD5fCY5ObkpIyPjvvEBgFqtJu3t7aze3l50dnayPDw8egFgwYIFyilTpgw7c6NQKFhz5swR+vv7S0QikVR/1j8tLc0+KCgoQCwWS5YtW+alUmnf5v3333fw8/OT+Pv7SxYvXuwDANu2bXMWiURSkUjUf2ZBLpfzpk2bJk1JSfESCoXSiIgIP4WtcQAAIABJREFUkVKp7P/jsWHDBhdvb+/A8PBw/8rKSovRxmMIIyXiIYQQBSGkDUBw37aCENJGCFEYchAURY1dvH5WBKC0tNRMIwHsY+1h+4yt8ZLgYbAIwbqpU/H2tGm4OGMGfmRjvCQUhAyeFU9O1taJnzhhvJhjxGaxTRInKGigNP7uXeDAAZOEpagJpbe3F9nZ2TZBQUHjvhhDLpfzZDKZZXR0dH8HNJVKBbFYLHF2dg6Jjo5WxMTEtE+fPr3zwoUL1vX19ey2tjZWTk6OoK6u7r4kOz4+XhkUFNR+7NixqvLycplEInngU2Lh4eH+YrFYcu/t+PHj1vfuW1dXx3N3d++P5eHh0XPjxo37xufj49O7atWqeh8fn2AnJ6cQa2trdXJy8phyx2PHjtm4uLj0yuVyWWVlZZnudcXFxfyMjAz7wsLC8vLychmLxWI++OADh8LCQv6ePXtcz549WyGXy2UffvhhbX5+vuWhQ4ccioqKLhcWFl5OT0+fcv78+UkAUFtby1+9evXtqqqqMoFAoE5PT7cDgPz8fMvPPvvMvrS0VJaTk1NZUlIyeaTxGMqwiTjDMGyGYWwYhrFmGIbTt627b8S/ehRFjUQ/EXd3d0dBQYEZR2M+v/HywnpPT4RYWRn/i4DeRbK4eVPb4WaCreVX3VyN/y34X/wq61cGf28WC/DwGLi/f7/BQ1DUqKpSq9zySF54HskLr0qtcrv3efnrcg/d81d/d/W+2l7ZSzIv3fO1e2odxxq3u7ubJRaLJUFBQRIPD4+eNWvWjGuZqNbWVlZycrLv7t276+zt7TW6xzkcDsrLy2W1tbU/FBcXTy4oKOCHhYV1rVmzpj42NtZv7ty5IqlU2sFmD/2Fu7q6mj99+vQuAJDJZLwXXnjBKyEhob+U+P3333fYvHmzc0pKildSUtK0Y8eODZm7FRUVycvLy2X33hYvXtw2nuPUd+fOHfapU6dsq6qqSuvr63/o6OhgpaWl2Y/+SiAsLKwzPz/f5o033nDPysqycnBwUANAVlaW9aVLlyxDQkICxGKx5Ny5czbV1dUW2dnZNgsXLmx2dXVVAYCzs7M6Ly/PKjExscXGxkYjEAg0SUlJzbm5udYA4O7u3j179uxOAAgNDe2oqamxAIDc3FyrxMTEFmtra429vb0mLi6uZaTxGIqJ2tJRFGUos2fPRmBgIH7+85/j3Xfpkv4moVebDwBgs7VLiEwQ7T3tEL8vxsrMlfjzd3/GrTbDryKzcOHAdlmZ9rsIRT0JdDXi5eXlsoMHD9bx+XyGw+EwGk1/To2uri4WAOzatWuKbka5pqaG293dTZKSknyXLl3atHz58iE7nzk6OqqjoqLaTpw4IQCAtWvXNpaVlV0uLCyU29nZqf38/Lrufc2tW7c41tbWai6XCwCQSCQ9n3766TX9fQoLCy137NjRcOTIkWuffPLJtSNHjgxZUjGeGfGpU6cOmgG/fv36oBlynRMnTth4enp2u7m5qSwsLJjFixe3fP3111ZDf8KDBQcHdxcXF8uCgoI6t2zZ4v7mm2+6AgDDMGTp0qV3df8WNTU1l/bt23dzLO+pj8fj9f/2YrPZjEqlGnEmZ7jxGApNxCnqEcPj8VBaWooPP/wQycnJYJmqzfsIWr9uRfnPynEh4ILJ2t3rYxgGsvZ2VBqrbtvJCeirzQcA/P3vwL/+ZZxY41TVVIXf5f0OXDa3/7HTVwx/3cAvfqH9L4+n7bLZ22vwEBT1yPDw8FA1NTVx6uvr2Z2dnSQ7O1sAABs3bryjSxQ9PT17U1JSvPz8/Lq2bdvWoP/6mzdvchobG9kAoFQqSW5urk1AQEAXANy4cYMDAJWVlbxTp07Zvvbaa/ctC1VZWclzdnYethylu7ubcDgcRvf3YdOmTa6rV6++M9S+45kRj46Obq+pqeGXl5fzurq6yLFjx+yXLFly3xcMb2/vnuLiYqu2tjaWRqPBV199Za07vtHU1NRwra2tNStXrmxKTU2tv3jxoiUAJCQkKE6ePGmn+3waGhrYFRUVvPj4eMWJEyfs6uvr2brH586dq8zMzLRta2tjKRQKVmZmpt3cuXNHnOGPiYlRZmZm2iqVStLc3MzKycmxHWk8hsIZfReKoqjh9Tb14vvI7/sv6W7+shmOz475rO9DO37nDlZWVuJWTw9ed3XFfn9/4wSKiwO+/x5wd59QVyve7biLvd/sBQBYsC3w9ry3MddnrsHjuLoCpaXaa1cnwHc/6gkk3Ce8KdwnHHYG1P+A/3X/A/7Xh3teclhyTXJYcm2458fDwsKCWbdu3a2ZM2cGODs79wqFwvuSzJycHKvjx487iESiTrFYLAGA7du333jxxRdb6+rquCtWrPBRq9VgGIYsWrSo6aWXXmoFgGeffda3paWFw+FwmHfeeafW0dHxvl84ISEhXU1NTVyRSCRNS0urmT9/frv+89nZ2VZRUVFKjUaDVatWuSclJbXqLhx9GH0rwdQmJCT4qdVqLFu2rHHGjBldABAdHS08ePDgNW9v796YmJj2hQsXNgcHBwdwOBxIpdKO1NTUOwCwcOFCn2+//da6ubmZ4+zsHPyb3/zm5tq1a/vLfYqKiiZt3LjRg8VigcPhMGlpadcAIDw8vGvz5s03YmNj/TQaDbhcLvPuu+/WxsbGtq9bt+5WVFSUmMViMYGBgR1Hjx6tWbZs2d2wsLAAAHjllVfuREREdMrl8mEvao2MjOx47rnnmgIDA6UODg69wcHB7SONx1CI0Zb8MpIZM2Yw5u4oSFETSU9PD7799lu4urpCJBKZZQznHM5B1aS9et0x2RGBRwNNEreqowOxJSWo7dY2E/KysMDVp54yTs34tWvalVLEYu0FnBOEWqOG0x4nNHVqJ81K/l8Jgp2DzTwqypAIIUUMwxh+kfgJrqSkpCYkJMR0bXsfYfX19ezU1FT3/Px8m5dffrlRoVCw33rrrVvvvfee4+HDhx1CQkLap0+f3rl+/fohZ8Up4yopKXEMCQnxHuo5Oq9BUY+wAwcOwMHBAdHR0ThgxqUsBFEDnS7bS9tH2NOwpvL5uKPX0EhsaYl2Y81We3kBAQETKgkHtCun6Df3yarKMuNoKIoyBxcXF/WhQ4dq6+rqLu3atau+ra2NLRAINJs3b75dVlZ2+dChQ7U0CZ+YaCJOUY+o3Nxc7N+/H0qldjWs7Oxss41F/IkYhKtNUDsrO9F9yzTt7i1YLMzVa+6zyNERVhwTVdzduAF88gkgk5km3ggShAn929lXTPdz8IidUKWoJ0Z6enqtucdAjQ1NxCnqEdXS0gJdmRaPx8PTTz8NtZlql7m2XAgiBmbFm3OaTRY7Xq/dfbYxW93r27JFu57fq68Chw+bJuYI4nwH1jnPv5YPZY8SKo1xOp1euKBdSn3KlMErqVAURVHjRxNxinpExcTEQLe+bE9PD3bu3Inh1ps1Bbu4gZlpcyXiX7W0oFdvSTGjqK4G6usH7k+A9cTdrN3668J7Nb2I/iQajv/jCGWPcpRXjt/f/gZ89pm2ueh//mPwt6coinqi0EScoh5RAoEATz/9dP/9HDMnhPZxAwlxU04TGI1p6hb8Jk2Cl4UFAKBNrcY3CiM2/mUY4JlngI8+0t4PDweWLJkQNRrxvgONnopvFaO1uxV5NXkGj6NbxhAA2tq0FToURVHUg6GJOEU9wvS7bJqzRhwAJgdPBsta+yult6EXyhLDz8YOhRAyaFb8d1ev4uNbhm9o0xdscLv7Z58Ffv3rCXEBp36duE7hTcOvMBUSAtjaDtyvrjZ4CIqiqCcGTcQp6hEWp5cUnj59GuZcjpSwCZiegfj16fUj7G1Y+ol4Xmsr0ow5TaufiJ82fOOcBxUxNQKW3IE+E7nLc7FtzjaDxyEEWLp04L6Zv/9RFEU90mgiTlGPsPDwcNj3JaH19fVYsWIF0tPTzTIWwiKwChnoYNx82nR14rF2doN+mRUrlbjdM2zTuYcMFjuw/e23E6bVvQXHAnO9tY18ptlNA4HxZun1TsRMpO8iFEVRjxyaiFPUI4zNZmP+/IE1pNPT082WiAOA2xtusImwgfDPQoR9F2ayuAIOB0/b2PTf/4WrKyYZq/3jlClAWN+xqdVAbq5x4jyAt2LfQuV/V+LK6iuI9o42WpzY2IHumoWF2gs3KYqiqPGjiThFPeL068QBID8/Hx0dD93J+IG4rnBF2LkweKz2AMfKROt594m3t4ffpEn4pbs7fuHmBmtjrieuX57ypz8BixYNXMBpRsHOwRDaC40ex9YWmDVLu80wwMGDRg9JURT1WKKJOEU94vRnxFksFg4fPgyOqZraTCAbPT0hnzUL74lECLW2Nm4w/UT8P/8BPv8cyMgwbswHoOxR4lTFKaOsKR4SMrD9xz8a/O0piqKeCDQRp6hHnIeHB6RSKSZNmoT4+HiEh4eDx+OZe1gmxzFWKcpQZs8GLC0HP5aXB5jpTMRQfnLsJ7B/2x4/PvxjXLhxweDv/+MfD2w3NEyYUnmKMii5XM4TiURS/cdSU1Pdtm7d6qz/WFVVFXfWrFl+vr6+UqFQKN25c6eT7rmOjg4SFBQU4O/vLxEKhdK1a9e66Z5zd3cP8vPzk4jFYklgYGDAcOO4cuUK98CBA3bDPW8sGRkZNt7e3oGenp6BmzZtcrn3+ZGOW0elUiEgIEAyd+5c45+ue0BD/ZuaCk3EKeoxcPz4cTQ3NyMzMxNeXl7mHg4AoOtWF2r/VIueO0a6aHIM1MZaRcbCApgzZ+D+0qVAaen9ybkZMAyD8sZyXGm6gl5NLwDg9BXDX1EZHw/o948qKDB4CIp6ZHC5XOzdu/f6lStXygoKCi5//PHHTkVFRXwA4PP5zLlz5+RyuVxWVlYmO3PmjM2ZM2cm61579uzZivLyctmlS5cuD/f+mZmZNsXFxSb9BaNSqbB27VrPzMzMioqKirKjR4/a645JZ6Tj1vn973/vLBQKO0059kcJTcQp6jEgFAph0dfUxtwYhsEF6QV86/YtqlOr0fD3BpPGr+/uxrarV/F0cTF+XFpqvED65SkMA4hExos1Du297Qj+32B8d+M7AECAYwCcJt83SfXQOBxg82bgH/8AWlqAefMMHoKiHhleXl69kZGRHQBgZ2en8fX17aytreUB2pJBgUCgAYCenh6iUqkIGUfvgezsbKstW7ZMPXnypJ1YLJbIZDKTnPLMy8ub7OXl1S2RSHr4fD6TnJzclJGRYau/z0jHDWhn8rOzswWvv/76kJd0KxQK1pw5c4T+/v4SkUgk1Z/1T0tLsw8KCgoQi8WSZcuWealU2hK7999/38HPz0/i7+8vWbx4sQ8AbNu2zVkkEklFIpF0x44dToD2bMa0adOkKSkpXkKhUBoRESFSKpX9H/yGDRtcvL29A8PDw/0rKystRhuPsTx5haQU9YTo7u42S3JOCIGme6DNfMP/NWBq6lSTxGYYBn+5eRO/v3YNAGBBCDrVakzSn7o1lKQk4No1bUL+zDOGf/8HZMWzQqRnJHJrtKu5rI9YjxXTVxgl1rZtRnlbinqkyeVynkwms4yOju7vaqZSqRAYGCipra21WL58+e2YmJh23XOxsbEiQgheffXVO2+++eZ9CWt8fLwyKCjo/7d353FRVf0fwD9nWGVfRRgFF0B2EDDNJVMrSTJcstQ0KzVTKx+xR3PJ1HqyfpWVmU9qi1qPmimaC4pWmGsmkKYgiyKyibLvA8zM+f0xMAtboHNnEL7v12te3XPn3vs9cxqH75w595zK9evXZw0cOFByP3ULCQnpX1lZ2eQD8YMPPsgaP358ufq+rKwsY7FYrPxJs2fPnrUXLlywaHxug+Ze94IFC3r93//9X3ZpaWmzH8JRUVFWPXr0qDt58uR1ACgsLDQAgISEBNO9e/faxcXFJZuYmPDp06e7fvXVV/aDBw+u/Pjjj53Pnz+f7OzsLL1z547B6dOnzXbu3GkfHx9/jXOOkJAQ79GjR5c7ODjIMjMzTX/44Yf0IUOG3Bo7dmzfHTt22M6fP7/o9OnTZvv377e7cuVKUl1dHYKCgnwGDBhQ1VJ9hEQ94oR0ImlpaXj99dfh6emJF198UW/1cJzkqNyuvFqpkZgLiTGG/fn5ynIt50ioEGiFT3d3YP16ICysQwxJUae+3H3MDVpxh3QOkZGRLoyxkLY8pk6d2mSM3tSpU93Uj4mMjHRpLo66lnquW9pfWloqmjhxYr8PPvggy87OTvnBZ2hoiOTk5KTMzMy/ExISzC9evGgKAGfOnElOSkq6dvz48bStW7d2P3r0aLOJbnp6umlQUJAEAJKSkoyfffZZt7CwsL4Nz2/cuNF+5cqVTlOmTHELDw/vGxUVZdXcdeLj41OSk5OTGj8aJ+Ht1dzr3rVrl7WDg4N0+PDhLd48ExwcXH369GmrefPmiY8dO2Zhb28vA4Bjx45ZXr161SwwMNDby8vL58yZM1bp6ekmMTExVuPGjSt2dnaWAoCTk5Ps5MmTFmPHji2xsrKSW1tby8PDw4tjY2MtAUAsFtcMGTKkGgAGDBhQlZGRYQIAsbGxFmPHji2xtLSU29nZyZ944omS1uojJErECekkKisrcfjwYWzcuBFpaWk4ceIE5HLdJMCNid8Qw8jFCADAazlKTpXoLLb6KpuzevTAUGtrncVGdTWQkaG7eC1QX+7++I3jkMkF/1tCSKfk5OQkbdybW1RUZODg4CBdt26do5eXl4+Xl5dPRkaGUU1NDQsPD+83efLkopkzZzb7oefg4CAbPnx4+aFDh6wBoE+fPnUAIBaLpeHh4SXnz583b3zO7du3DS0tLWVGRorPVB8fn9o9e/bcUj8mLi7ObO3atXd27959a9u2bbd2797d7JCKkJCQ/g11Vn8cOHCgyVRTvXr1qs3JyVEOM8nOztboIW/Q0us+c+aMxYkTJ2zEYrH/iy++2PePP/6wjIiI6KN+bkBAQE1CQkKSv79/9dtvvy1+8803nQGAc84mT55c2PBFISMj4+r69etzm3tNrTE2NlbeKGRgYMClUmmrY4Jaqo+QKBEnpJO4efMmIiMjleXa2lrcuHFDL3UxFZui+2TVuOTCw4U6i62eiJ/S1VQeqamKaUTs7YEXXtBNzFYEOAWgh4VigoOi6iLE344XNF5GBrB0KTBnjqBhCNE5a2treffu3esOHjxoCQB37twxOHnypPWoUaMqli1blt+QKLq6utZNmTLFzdPTU7J69WqNG2Nyc3MNCwoKDACgoqKCxcbGWnl7e0vKyspExcXFIkAxNjk2NtYqICCgyU2NaWlpxk5OTi3e9V5TU8MMDQ25qH7mqOXLlzu/8cYb+c0d254e8REjRlRmZGSYJicnG0skEhYVFWU3adIkjS8YcrkcLb3uL7/8MufOnTt/5+TkXNm2bVv64MGDy3/++eeb6sdkZGQYWVpayufPn18UGRmZd+nSJTMACAsLKzt8+LBtTk6OYUO7p6amGo8ZM6bs0KFDtnl5eQYN+0eOHFkRHR1tU15eLiorKxNFR0fbjhw5stUe/lGjRlVER0fbVFRUsOLiYtGJEydsWquPkGiMOCGdhK+vL8RiMXJycgAAR44cgYcebyC0f8oeOZ8r6lJ4qBDun7m3+HOuNg23toapSASJXI7U6mpkVFejd7duwgY1MgKOHFFsnzsHFBcDtjqfaUyJMYYx/cZg+2XFSjvrz6+HlYkVlgxdovUFfw4cACZMUGyLRMCmTYrmIETb1q9fn3svvaINdu3adWvXrl23/vlITdu3b785f/581yVLlvQCgKVLl+b6+vrWqB9z4sQJiwMHDth7eHhUe3l5+QDAmjVrcp577rnSrKwsoxdffLGPTCYD55xFREQUTZ06tTQpKcl4woQJ7gAgk8nYpEmTCp955pmyxvEDAwMlRUVFRh4eHr6bNm3KePzxxyvVn4+JibEYPnx4hVwux4IFC8Th4eGlDTdQ3o/6GVEyw8LCPGUyGaZNm1YQGhoqAYARI0a4b9++/VZKSopJS6+7LTHi4+O7LVu2rKdIJIKhoSHftGnTLQAICQmRrFy5Mmf06NGecrkcRkZGfMOGDZmjR4+uXLx48e3hw4d7iUQi7ufnV7Vv376MadOmFQYHB3sDwIwZM/KHDh1anZKS0uJNrcOGDauaMGFCkZ+fn6+9vX1dQEBAZWv1ERLjQk3vJZDQ0FAeFxen72oQ0iG9/PLL+O677wAAq1evxjvvvKO3ushr5ThrfxayCsWwiIFJA2Hu3eRXV0GEXb6MmOJiAMBXnp6Y6/KPQ0Hv3Zo1wLp1QE3932UvL2DXLiAoSLiYbbDryi5Mi5qmse/zsM/xxqA3tBqnogJQXz8pKkqVmBPtYIzFc85D9V0PXbt8+XJGYGBgs7NtdGV5eXkGkZGR4tOnT1tNnz69oKyszOD999+//cUXXzjs2rXLPjAwsDIoKKh6yZIlzfaKE927fPmyQ2BgYO/mnqOhKYR0Ik+oTakXE6Pfm/RExiLYPKGa6er2tts6i60+POXnggLEFBUJF8zZWZWEP/wwcO2a3pNwAHi83+Ng0PwF4nDqYa3HsbAAxGJV+ebNlo8lhNy/Hj16yHbu3JmZlZV1dd26dXnl5eUG1tbW8pUrV95NTEy8tnPnzkxKwh8clIgT0ok8/vjjyuEfFy5cQJGQCWgbSItUS6vn/6S7vwvqifjRoiKMv3oVlTKBblgMD1dtX7zYYZaYdDBzwEDxQGV5ovdErBu9TpBYr7+u2j51SpAQhJAW7NixI1PfdSD3jhJxQjoRe3t7DBo0CIDiJprNmzdj586dequP+jSGNTdrUFdcp5O43mZm6Kk2h7pELscv9UNVtE4sBoKDFdtSKaDnXyLUqU9j6GjmiBCXEEHiqA9FOX4cqLrv0amEENI1UCJOSCcTERGh3F6+fDlmzpyJUj310naf0h3MiMG0jynEi8QQddPNRw5jDE+q9Yr3MjFBN5GAsceNU20fOiRcnHaa6D0RS4cuRezMWGx4coNgcTw9FUPjAcUMjr/8IlgoQgjpVCgRJ6STGT9+vEZZKpXqbby4sYMxHql+BIPTB8NjvQcMTAVfpEwpwsEBAGApEmFq9+54Qi0x1zr1RPzIEeDnn4H33xcuXhsF9QjCB499gEd7PwpjA2FXxVb7/of9+wUNRQghnQYl4oR0Ml5eXvD09FSWhw4dCmdnwdckaBEzEH7KwuaMtrFBTEAACoYNw4f9+gkbLDgYaJiZpbgYGD8eWLECuHOn9fP0QCaXoaymyQxp9039+9/27UBentZDEEJIp0OJOCGdkHqv+JNPPonhw4frsTb6YWpggCfs7GAs5JCUBowpFvRp7OhR4WO30d93/sbLP78M50+cseLXFVq//kMPqeYP5xzYINxIGEII6TQoESekE5oxYwY2b96M3NxcrFih/aTrXskkMlSmVf7zgQ8i9eEpxsbAv/8NhAhzc+S9uFl8E99d+g75Vfk4mHoQ2l5DQiRS3bMKdKjvIIQQ0mHRypqEdEJ+fn7w8/PTdzWUSs+XImVWCqpSqmBoa4hhBcN0Gv9ubS0OFxbiYEEB/q9fP3iaCbBq8ahRgKkpIJEAtbXAK68A7tpdxfJeLT2xFJ+c/0RZrpXVIrc8F2IrcStntd+8eUBRETBliuLlE0IIaR0l4oQQwdXdrUPVNcWcdtJCKarSq2DWV4BkuBkVUinGXbmCP8vLAQBDra3xb1dX7QcyM1PM41dToxim4uj4z+foiLOlM2RcMY/64J6DcfblsxAx7f8gOnOm4kEIIaRtaGgKIZ1ccnIyPvzwQwwdOhTJycl6qYNdmB2gNmHKnR90dxPj93fuKJNwADhYWChcsJ07gX37gJdeAqythYvTThO8VBN9x+fGC3KzJiGEkPYTNBFnjIUxxlIYY9cZY28183wkYyyJMfY3Y+xXxpibkPUhpKvhnGP+/Pl46623cO7cORzS0xzXIhMRHCIclOWyc7pLBJ92UMUVAfhU6BlUGtPyWOx74WbjhhBnxXj1OnkdjqQe0XONCHlwGBgYhHh5efl4eHj4Pvnkk33Ly8vblDtdv37daNCgQZ79+vXzdXd393333Xe7NzxXVVXF/P39vfv37+/j7u7uu2jRIpeG5959993uHh4evu7u7r5r167t3vzVgRs3bhht3brV9v5eXfvt3bvXqnfv3n6urq5+y5cv79HcMa29drFY7O/p6enj5eXl4+fn5627mrdPZGSky6pVq5yEjiNYIs4YMwDwJYAnAfgAmMoY82l02F8AQjnnAQD2Avg/oepDSFc0d+5cxMbGKsv6SsQBwH29arx0SWwJpBVSncQVm5jgIUtLAIAcQLKuln08ehSYOxdwdQVu3dJNzFZM9J6o3I5KjhI8XnU1sHEjcPGi4KEIEZSJiYk8OTk5KS0tLdHIyIh/8sknbRp3ZmRkhE8++ST7xo0biRcvXrz2zTffdI+PjzcFAFNTU37mzJmUlJSUpMTExKRff/3V6tdffzW/ePGi6Y4dOxwTEhKuXbt2LfHYsWM2V69eNWnu+tHR0VYJCQm6GeNXTyqVYtGiRa7R0dGpqampifv27bNreE3qWnvtAPD777+nJicnJ129evWaLuvfEQnZI/4QgOuc83TOeS2A3QAi1A/gnMdyzhv+Kv4BoKeA9SGky3nkkUeU23379sW+ffv0VhdTN1OY+5sDAHgtR/EvAi0534zxar3iBwoKdBP088+BLVuA7GwgOlo3MVuhnohHp0Yj9mYsvk74WpBYU6cC5ubA668Db78tSAhC9GLYsGEV169fN0lJSTH28PDwbdi/atUqp8jISBf1Y93c3OqGDRtWBQC2trbyfv36VWdmZhoDgEgkgrW1tRwAamtrmVQqZYwxXLlypduAAQMqLC0t5UZGRhg6dGj57t27bRrXIyYmxuLtt9/udfjwYVsvLy+fpKQkYVfsqne1bc7TAAAgAElEQVTy5ElzNze3Gh8fn1pTU1M+ceLEor179zapX2uv/Z+UlZWJHn30Uff+/fv7eHh4+Kr3+m/atMnO39/f28vLy2fatGluUqmiQ2fjxo32np6ePv379/cZP358HwBYvXq1k4eHh6+Hh4fyl4WUlBTjvn37+k6ZMsXN3d3dd+jQoR4VFRXKxS6WLl3ao3fv3n4hISH909LSTP6pPtogZCIuBpClVs6u39eSWQBowitCtGjs2LEwMFAMzk5PT0ddXZ1e62P/lL1yu/CwgGO1G1FPxI8VFaFaJhMuWHk5MGsWcO6cat9vvwkXr428HLzg5aBYh14ik2DUjlGYf2Q+SiWlWo9lbq4akXPmjNYvT4he1NXVISYmxsrf37+6veempKQYJyUlmY0YMaKiYZ9UKoWXl5ePk5NT4IgRI8pGjRpVGRQUVP3nn39a5uXlGZSXl4tOnDhhnZWV1SSBHTNmTIW/v39lVFTU9eTk5CQfH5/ae31dISEh/b28vHwaPw4cOGDZ+NisrCxjsVisjNWzZ8/anJycVhPs5l776NGjPXx9fb0//vhjh8bHR0VFWfXo0aMuJSUlKS0tLXHixIllAJCQkGC6d+9eu7i4uOTk5OQkkUjEv/rqK/u4uDjTjz/+2Pn3339PTUlJSdq8eXPm6dOnzXbu3GkfHx9/LS4u7tqOHTscz5492w0AMjMzTd944427169fT7S2tpbt2LHDFgBOnz5ttn//frsrV64knThxIu3y5cvmrdVHWzrEzZqMsekAQgF81MLzrzDG4hhjcfn5+bqtHCEPMDs7O4wYMUJZ1ufQFEAzES/YXwAu1834aS8zM3h26wYAqJTLcbSwEPm19/x3q3UWFsCxY4qEHAC++ALYtUuYWO000WuiRrlOXoej17Xf/xEZqdqWSBRTGhJyvyIjI10YYyGMsZDGvc8AMGfOnJ4Nz7/zzjtNxvZOnTrVreH55hLAltTU1Ii8vLx8/P39fXr27Fm7cOHCdv2sVlpaKpo4cWK/Dz74IMvOzk7esN/Q0BDJyclJmZmZfyckJJhfvHjRNDg4WLJw4cK80aNHe44cOdLD19e3qqEzpbH09HTToKAgCQAkJSUZP/vss25hYWF9G57fuHGj/cqVK52mTJniFh4e3jcqKsqquevEx8enJCcnJzV+jB8/vry54+/3tZ85cyY5KSnp2vHjx9O2bt3a/ejRoxbq5wQHB1efPn3aat68eeJjx45Z2NvbywDg2LFjllevXjULDAz09vLy8jlz5oxVenq6SUxMjNW4ceOKnZ2dpQDg5OQkO3nypMXYsWNLrKys5NbW1vLw8PDi2NhYSwAQi8U1Q4YMqQaAAQMGVGVkZJgAQGxsrMXYsWNLLC0t5XZ2dvInnniipLX6aIuQiXgOgF5q5Z71+zQwxh4DsALA05zzmuYuxDnfwjkP5ZyHOnagKcEIeRBERKhGhB04cECPNQG69eumnDRVWiRF2Z+6uWmTMabRK/7ctWtYcfOmUME0V9nMzAQMO8ZMserDUxgYXgp6Ce522p/r3McH6N9fsS2TASdPaj0EITrTMEY8OTk5afv27Vmmpqbc0NCQy+XKnBoSiUQEAOvWrXNs6FHOyMgwqqmpYeHh4f0mT55cNHPmzJLmru/g4CAbPnx4+aFDh6wBYNGiRQWJiYnX4uLiUmxtbWWenp6Sxufcvn3b0NLSUmZUv5ytj49P7Z49ezRuRomLizNbu3btnd27d9/atm3brd27dzc7pKI9PeK9evXS6AHPzs7W6CFX19Jr79OnTx0AiMViaXh4eMn58+fN1c8LCAioSUhISPL3969+++23xW+++aYzAHDO2eTJkwsb/l9kZGRcXb9+fW5zsVtjbGys7AEyMDDgUqmUtXZ8S/XRFiET8YsAPBhjfRhjxgCmADiofgBjbACAzVAk4XcFrAshXZZ6Iv7bb7/h5s2byMlp8p1YJ4y6G0FkrPrYyd3c7s/QezZBLRGXco5DhYWQCzWjifoqm4cPCxPjHgQ7B8PVWjGHOgfHFL8pCHUJFSTWM8+otn/+WZAQhOhNz549pUVFRYZ5eXkG1dXVLCYmxhoAli1blt+QKLq6utZNmTLFzdPTU7J69WqNOVtzc3MNCwoKDACgoqKCxcbGWnl7e0sAICcnxxAA0tLSjI8cOWIze/bsJr8ppaWlGTs5ObX4s15NTQ0zNDTkIpHi83b58uXOb7zxRrNDCtrTIz5ixIjKjIwM0+TkZGOJRMKioqLsJk2a1OQLhlwuR3OvvaysTFRcXCxq2I6NjbUKCAjQGOqTkZFhZGlpKZ8/f35RZGRk3qVLl8wAICwsrOzw4cO2De1z584dg9TUVOMxY8aUHTp0yDYvL8+gYf/IkSMroqOjbcrLy0VlZWWi6Oho25EjR7bawz9q1KiK6Ohom4qKClZcXCw6ceKETWv10RbBumk451LG2GsAYqCYQfhbznkiY2wtgDjO+UEohqJYAPiJMQYAmZzzp4WqEyFdkZubG4KCgnDp0iXU1taiX79+mD9/PjZu3KjzujDGYD3EGsW/FMPQ1hDdenfTWeyHrKzgZGSEO/Xj5I0Yw+3aWohNmp2Q4P6or7J57Rpw4wag62kTm8EYwwsBLyCtKA0TvSdiSK8hgsWKiAD+8x/F9uHDgFTaYX4YIA+o9evX57bWA7p169bsrVu3Zrf0/K5du27t2rVLK1MYmZiY8MWLF98eOHCgt5OTU527u3uTXusTJ05YHDhwwN7Dw6Pay8vLBwDWrFmT89xzz5VmZWUZvfjii31kMhk45ywiIqJo6tSppQDw9NNP9yspKTE0NDTkn332WaaDg0OToRCBgYGSoqIiIw8PD99NmzZlPP7445Xqz8fExFgMHz68Qi6XY8GCBeLw8PDShpsn70f9bCiZYWFhnjKZDNOmTSsIDQ2VAMCIESPct2/ffqt37951Lb12f3//6gkTJrgDgEwmY5MmTSp85plnNH4ajY+P77Zs2bKeIpEIhoaGfNOmTbcAICQkRLJy5cqc0aNHe8rlchgZGfENGzZkjh49unLx4sW3hw8f7iUSibifn1/Vvn37MqZNm1YYHBzsDQAzZszIHzp0aHVKSkqL49mHDRtWNWHChCI/Pz9fe3v7uoCAgMrW6qMtjHeAOW7bIzQ0lMfFxem7GoQ8UNasWYPVq1cry66ursjIyED9F2CdqrpeBZGxCKauTWa8EtyrKSnYfPs2RAA2eHhggVi7S7xrGDdO1Rv+ySfAoEGK1TcHDBAuZgcilwO9egG59WlTbCzw6KN6rdIDizEWzzkX5qeLDuzy5csZgYGBOprm6MGWl5dnEBkZKT59+rTV9OnTC8rKygzef//921988YXDrl277AMDAyuDgoKqlyxZQjfa6cHly5cdAgMDezf3HCXihHQBly9fRlBQkLI8ZMgQHDp0CHZ2dnqsle7Fl5fjamUlnrK3h3392ErBbNmimEccUPWOT54M7NkjbNwOZO5cRTMAgL8/8Pff+q3Pg4oScdJeL7zwguuOHTsy9V0PotBaIt4hZk0hhAgrICAAbm6qhWvfe++9LpeEA0CIpSVm9ughfBIOaN6wKan/1frQIaCs4ywvH58bj+W/LoffJj/8dfsvrV9/0CDV9tWrQGVly8cSQrSHkvAHByXihHQBjDEsXLgQa9aswaVLl/BoBxojIK+TQ1Yp4Lze+uLiAoSEqMrm5sCMGR0qG/343MdYd2YdEvMT8XOK9u+ofP55oP5eMXAOfPON1kMQQsgDjRJxQrqIRYsWYdWqVQgMDNTL2PDGyuLKcOmJSzhtfhrpy9N1Hl8ik+FoYSE+ycr654Pv1dNq956PGKEYp+Gs1Zmv7tnCowtxKFU1r/yx68e0HsPEBAgIAOztgenTNSeTIYQQIuCsKYQQ0prrC6+j7JximMadH+7A/TN3nX1BKKmrQ8/z51Epl8MAwItCDVd5/nngnXeAwYOBCRO0f/37UCQpQmWdond+svdkfDf+O0Hi/PGHIiEnhBDSFPWIE9IFlZeX45tvvsHs2bP1Vodekar1vqRFUpTH3fcibm32amoqKusX45ABiC4sFCZQv35ARgZw/jygx7Zujvoqm4kFiTA3Nm/l6HtHSTghhLSMEnFCupiamhq4ublh9uzZ+Oabb3D58mW91MP+aXsYOal6oe/8704rR2vXSFvVAnNuJiZ4xMZGuGBqN8kqdYDZqsa4j0E3Q8U87kn5SUgpSNFzjQhpQi6Xy/U/jo6Q+1D/Hpa39Dwl4oR0IZxzPP744yguLlbu27Ztm17qIjISwfsHb2X57q67kEtb/KzSqqft7ZXb2TU1sDAw0ElcJCcDq1Yp1n+/pdU1IdrNzMgMYe5hyvL+5P2Cx5TLge+/VyzuQ0gbXM3Pz7emZJw8qORyOcvPz7cGcLWlY2iMOCFdCGMM1tbWyvKYMWOwbNkyvdXHdqQtjF2MUZtbi7q7dSg+Xgz7sfb/fOJ9cjYxwWArK/xRVgYZgMOFhZjZo4fgcbFoEXCs/qbI3buBpUuFj9mKid4TlQl41LUojPMch+yybIxxH6P1WNOnAz/9BNTWAlVVqinWCWmJVCqdnZeX93VeXp4fqOOQPJjkAK5KpdIWxybSgj6EdDE//vgjpkyZAkCxwmZ6ejoMdNUj3IwbS24g6yPFzCWOzznCd7evTuJ+mJmJt9IVs7U8ZmuLE4GBwgWrrgY+/RT44gsgL0+xb8gQ4OxZ4WK2QYmkBI4fOUIqV3VRu1q7Iv2NdBiItPue8PAArl9XbLu7A2lpWr18p9ZVF/QhpCugb5iEdDHjx4+Hg4MDACAzMxPHjx/Xa32cZjgptwuiCiAt1c24handuys/AH8pLkZiRQXu1tYKE8zYGNi0SZWEv/UW8MsvwsRqBxtTG4zuM1pjX2ZpJn5J137d3nxTtZ2bq+gZJ4SQro4ScUK6GBMTE8ycOVNZ3tKwBrmemPuaw9BWMUqO13Hkbs3VSVxXU1M8qba66MCEBCxq6LLVNgMDxdiMBqmpQLduwsRqp4neqtlTGBgm+0yGo7mj1uPMmgU0NHdVFXDkiNZDEELIA4cScUK6oDlz5ii3Dx06hJSUFFy5ckUvdWEiBiNH1ewpuZt0k4gDwFwXF+V2tVyOffn5KK6rEyaY2pcfHDoECDVlYjtF9I+AAVMMQ+HgeGfEOwh2DtZ6HENDYN48VXnrVq2HIISQBw4l4oR0Qf3798cjjzwCAJDJZPDz88PUqVOhr3tGxK+JAQAiUxGshlrprB5P2tmhp9pE15aGhrheXS1MMG9v4KGHFNt1dYqbNTsAJwsnRHhFYKDLQGyL2Ia+tn0FizVrlmr72DEgM1OwUIQQ8kCgRJyQLuqVV15RbkulUiQmJiI+Pl4vdXF+2Rn+0f4YXjUcPt/76GyFTUORCLPVlpyf1aMHBlpZCRdQvVd82zbgxg0gJka4eG30/YTv8eecPzEzaCa6GQk3ZKZPH+CxxxTbnAPffitYKEIIeSDQrCmEdFESiQQuLi7KOcX79u2Lr7/+GiNHjtRzzXQrWyLBptxczHF2Rh+hx20XFQHOzpp3Kjo5AdnZirEbHYxEKoGpoalWr7lnD/Dcc4ptAwPFjZvdu2s1RKdDs6YQ0nlRjzghXZSpqSleeOEFZTk8PLzLJeEA0NPUFO/37St8Eg4o7lZ8+mnNfXfuACdPCh+7jUolpdh0cROCNwdj3pF5/3xCO0VEqL5zyGSK9Y0IIaSrokSckC7slVdewfTp03Hq1Cl8/vnn+q6OEuccNbdr9F0NYagPTwGAp54CLCz0U5dmJBckY0H0AvyV9xf2JO5BqaRUq9c3MQEefVRVjorS6uUJIeSBQok4IV2Yj48Pvv/+ewwfPlxn47JbI62QInlWMs7YnsEfff/Q2ZL3DTjniC8vx/zUVETl5wsTZMwYzbEYCxYAgwcLE6udTmacxAv7Vb+SyLkccbnaHwr4/vuAkREwdiwQHa31yxNCyAOj4w1KJIR0WTW3apD3bZ6ynL8vH07PObVyhnaty8zEips3AQDJVVWY6Kj9+bRhZAQ8/zywbx/wwguAj4/2Y9wjRzNHpBalAlDMKX5xzkX4dffTepyBA4HyckXvOCGEdGXUI04IAaCYxjAmJgZTpkzBJ598opc6mPuaw7iHsbKc81mOzmKX1NVhTX0SDgCxJSVIF2oqw3ffBW7eVPzX1VWYGPfAt7svRriNAKCYU3xP4h7BYlESTgghlIgTQur98MMPCAsLw48//oivvvpKb3OKu7ymWmSn/K9ySMt0s+S9jZERnnJwUJYnOTigj6l2ZwxRMjcHRI0+fmUyoH4GG31aMHCBcntL/BbUymgtekIIEQol4oQQ3L59GwsWqBKw69evIyEhQS916b2iN8wDzAEAvIYjf59AY7Wbob7S5q8lJZDIdTBGXSoFvv8e8PMDXn1V+Hj/YLzXeLhYKtrhTuUdRF0T/m7Kc+cAtWntCSGky6BEnBACZ2dn+Pr6KsuLFy9GSEiI3urjNEM1Ljx3U67Oeucfs7VF3/pe8BKpFD8JdcOmuqtXFWPFk5OBn34Crl0TPmYrjAyMMDdkrrL82R+f4dPzn+Jo2lGtx6qsVEyjPnSoYsn7c+e0HoIQQjo0SsQJIQA0V9o8fPiw3oamAIDTdCcwE8UsLuVx5Sg8WKiTuCLGMEdtpc3NubnCBvztNyAyUlW2tAQSE4WN2QZzgufAUKS4l/9CzgVEHo/ER+c+0nocc3Ogrk5VXrFC6yEIIaRDo0ScEAIAeO6552BpaQkASElJwenTp/VWF5MeJhDPFyvLqfNSwWW6+WLwkrMzDOuncjxXVoYf8vJQUCvQOOmSEiA2VrFtYgJcugQ884wwsdrB2dIZk7wnaeyLzYjF9aLrWo81Y4ZqOyMDeMAWeyaEkPtCiTghBABgYWGBadOmKctbtmzRY20ApxecgPqpzWtv1yJ3i8C90w1xjY0xQe2mzRnJydiWl9fKGfdh3DjA01OxXVMDfPmlMHHugfpNmyImwudhn6OHRQ+tx1mzBmhY1DQjA/jzT62HIISQDosScUKIkvrwlJ9++gkff/wxtm/frpe6WPhbwMjRSFnOWJuhs9jqN20CwJe5uagR4sZNIyPF6jYNvvgCuHVL+3HuwTDXYfDv7q8s97HpAwtj7a8AamMDTJmiKm/dqvUQhBDSYVEiTghRCg4OVt6kWVtbi3//+9948803UVqq3WXO24IZMLh/5g4wwHq4NUL+1N3NoyNtbJQ3bQJAkLm5cGPmJ04EBg1SbNfWAqtWKbalupm2sSWMMbw17C2sGL4CGQszMK7/OMFizZmj2v7f/xQ944QQ0hVQIk4I0fBKo3nkCgoK8MUXX+ilLt2ndMfDuQ9jwKkBMO0l0JzezRAxhlfre8X7mJpiipMTTA0MhAnGGPDhh6ryjh3AwoVA795AVpYwMdtomv80vDfqPfSy7iVonMGDgdBQxbZEAkyerHkTJyGEdFZMnzMj3IvQ0FAeFxen72oQ0mlJJBL4+voiPT0dABAaGopTp06hW8NA3i6isK4OVyoqMMLGBqz+5k1BPfUUcOSI5r7XXlMMV+lA/rr9F06kn8CSoUu0et2zZ4Fhw1TlefOATZu0GuKBxRiL55yH6rsehBDtox5xQogGU1NTbNiwAQDg6OiIf/3rXx0uCddFB4K9kREetbXVTRIOAOvWKXrH1R0/3mG6hqVyKV49/CpCtoRg6S9LcT7rvFavP3QoEBysKm/eDGRnazUEIYR0OJSIE0KaCA8Px9atW5GWlobnn39e39VRKr9cjouBF5H2Wppe4pdJpdiYnS3MFwF/f2DmTFW5d2/g778VN3R2ACWSEhxJOwIOxWtffHyx1mPs36/6LuLq2mG+gxBCiGAoESeENGv27NmwtrbWdzWUMj/ORHxQPCr/rsTtLbdRV6zbLG17Xh56nT+P169fx667d4UJsmaNYj5xQDFouqZGmDjtVCurReiWUGSXKbqo3e3c8W3Et1qP4+oKrFwJbNwIpKcDffpoPQQhhHQolIgTQtqkpKQES5YsweHDh/US336svXKbSznSXtddr3haVRWW3biBMpkMAPDvGzdQWb+tVa6uiiz0jz8Uy91bWWk/xj0wNjDGG4PeUJZvldyCnAswnSOAtWuBBQuajtIhhJDOiBJxQsg/+v333+Hm5oaPPvoIixcvRp0exgyY+5jDZqSNspy/Px+1dwVa8bIRK0NDjcR7kKUlzEQCfXzOnq2azrADWThoIQaJFfWqk9fh5Z9fhkwuwJcRQgjpQigRJ4S0qra2Fhs2bEBZWRkAIDU1FXv37tVLXXz3+sLM1wwAwKs4Mtdl6iSuk7ExPujXT1k+UlSE69XVOomNrCzF7CnqC//ogYHIAN88/Q2MRIox6xdyLuDzC58LHrewEIiIAEpKBA9FCCE6R4k4IaRVxsbGkKutKunm5obJkyfrpS5Gdkbo+5++ynLOf3MgyZLoJPYrLi4YaGkJAKjlHPPT0oSfveXiRaBfP+DLL4H//Af46y9h4/0D3+6+ePuRt5XlFb+uwFdxX2HOwTmCtMWaNYCTE3DwIPDss1q/PCGE6B0l4oSQf/Tpp5/CtH6lyVu3bmHz5s16q4v90/awfEiREPMajltrdbMkvAFj+MrTU/mh+UtxMX4U6qZNQLGy5h9/AA1fgiQS4NIl4eK10VvD3kKAUwAAQCKTYN6Refj6r6/xc8rPWo915QrQMCLoxAkgPl7rIQghRK8oESeE/KPevXtjxYoVyvKKFStwV8gktBWMMfT5j2o6jdtf30bmR7oZohJsaYnXxGJl+Y3r1/GvtDTIhOgZZ0wxmXZDJjp2LPDSS9qP005GBkb49ulvYcA0Vxp979R7Wu8V37FDNYkMAGzdqtXLE0KI3lEiTghpkzfffBPu7u4AgNLSUrz11lvIycmBVCrVeV1sR9uiW3/VIkPpS9Jxe9ttncR+t08fOBsbAwDy6+rweU4Ovr0tQGwDA8UiPw0OH+4wS02GuITgzSFvKstGIkVyru3Fj8zMNBcW3bIFSEjQaghCCNErSsQJIW1iamqKL9Syou+++w7BwcGYPn26zpNxxhj6fdQPUMv7au/obgaVz+q/kDT4MidHmGBPPQWEhanKCxYA32p//u578c6Id+Bp7wkAGOM+Bo7mjoLEmT1b1QScK+5b1cN3P0IIEQQl4oSQNgsLC8OECROU5bt37+LHH3/ErFmzdF4Xh3EO8PrOC8yIwWOLB9yWuuks9mRHRzxmo5pK0VGo1S8ZA378UXM6w9mzge++A158EThwQJi4bdDNqBu+i/gOOyfuxMEpB+Fs6SxIHMaAzz9XLTB6/jzwxBPAjRuChCOEEJ1igt/1r2WhoaE8Li5O39UgpMu6desWvL29Ua02fd/GjRuxYMECvdRHWiGFoYWhzuPeqK6G359/YqqTEz53d4eloYB1KCkBRo9uOi7D3Bw4cwYIChIu9j1Yd3odBooH4rG+j2ntmqtXK2ZRaWBiAvz+e4eccl3rGGPxnPNQfdeDEKJ91CNOCGkXNzc37N+/H2Zmivm8e/XqhalTp+qtPs0l4dU3qyHJFnZaw37duiF7yBB86+XVJAnX+qqbNjbA8eOAv7/m/spKxQqcHcj7p9/H8t+WY+z/xmJP4h6tXfedd4AlS1Tlmhpg+HCgtFRrIQghROcoESeEtNuYMWNw6tQpBAUF4dSpU7Czs9N3lZTKEsrwp/efiAuIQ12xsCuA2jczJOVKeTnczp/Hjrw8LQezV8zh5+Wl2mdgAOhhWFBLSiWlWPv7WgCK1Te3XdqmtZlUGAM+/BCYO1e1b+pUwNpaK5cnhBC9oEScEHJPQkJCkJCQgN69e2vsr6qqwqpVq1BTU6PzOtXk1uCvQX+B13BIi6W46H8RMonulmHPkkgw+K+/UCiVYmZyMv6r7Zs4nZyAX39VLPIDAJ98AvTt2/o5OrTp4ibUyFT/3ytrK5Ffla/VGF99BaxdCzz5JLBtm1YvTQghOkeJOCHknjWerq6qqgoPPfQQ3n33XUREREAi0c2qlw2MnY1h9bCVslybU4vESYmQZOqmHt/n5aFKbRXSAwUFqFEra4WLC/Dbb4pJthcu1HwuMVEx2baephWZGzoXYz3GKsunMk8heHMwzmed12qct98GoqMVveTq9PDdjxBC7gsl4oQQrVm9ejUSExMBADExMfjf//6n0/iMMQTFBsEiyEK5ryi6CBf6XUDyS8moTK4UNP58sRiPWKm+CBwvLsZjly+joFbLUyu6ugIzZjTdP20a8MorQEAAcO6cdmO2gV03OxyaeghrHl0DVj+3ZE55DkZsG4Ev//wSZzPPolQizKDu0lKgRw/Fukfabm5CCBEKJeKEEK0xUV8GEcCSJUswd+5cnDx5EnK5XOsrLzaHGTCE/hWKXkt6KfdxKUfetjxc9L6IC14XUBRTJEhsGyMj/BIUhNk9eij3nSktRXB8PFbfvIn5KSmIKSwUZiXOgweBv/9WbF+7pkjE9dAzLmIirBqxCtHPR8PW1BaAYrz4a0dfwyPbHkGPT3rgrV/e0mrM2lrA11cxuczRo4Cjo2L4Ck1xSAjp6Gj6QkKIVn322WdYtGhRk/1isRjOzs6ws7PD8uXL8cgjj2h9JcbGio4X4db7t1D6e9Ne2F5Le6HfB/0Eics5x/rsbPz7xg009wlrY2iIjEGDYK3N+cfXrlVMLaLO1RV4/XXF3ONmZkD9iqC6klGSgUl7JiHhtua0iw+5PIQLcy5oLU5uLuDtDZSVNX3u4YeB6dOBiAhALNZaSJ2i6QsJ6bwE7RFnjIUxxlIYY9cZY026QBhjJoyxH+ufv8AY6y1kfQghwvvXv/6FAwcOwM1Nc4GdnJwcxMXF4fjx43j00Ufx3//+V+N5uVwOuZbHU9s9YYcBJwdgwNkBGsNVAEC8QDMrKzlbgpurb6Iwpt83vQYAAA1ISURBVBDSivvrSWaMYXGvXojy9YVNM/OL18jlsGq0P6myEqlVVai+16kPn35aMVxF/bqZmcC//w307KnoMra0BAIDgaioe4vRTr1teuPsy2fxctDLGvsn+0xucuzcQ3Ox9ve1OH3rNOS8fe8DFxfg5k0gNBQQNfqrdv68YkHSnj0VPeWvv65YoZMQQjoCwXrEGWMGAFIBPA4gG8BFAFM550lqx8wHEMA5f5UxNgXABM75c61dl3rECXkwyOVynDt3Drt27cJPP/2E/HzN2TOys7MhVuui3LZtG1566SWYmppCLBZj/PjxcHBwgJGREQwNDZGfn4/U1FQYGxvD398fS5cu1bje0aNHcfz4cQCAi4sL+vTpA0B1Q2lmZiaSDyaj7I8yBLgFYFnyMo3z1w9ZjwvnFb203dEdzg7OMHY2hrGTMUQmItzMvIn8knwwEcPo8NF44csXNM7/eMbHuHb1GhhjcPd0R3eX7gAD6rgc6RIJ4uKvorCkGADQe/ITOPCe5rSDgx99A9V5dwAA3fr1ga2DLcxFIpgZGMBMJMKNhKuolVRDBGDm0ll4ccYojfMnDluAitIyQCZDfzsrmN3OAWprweo/46/UAtL67ZXh/hi+bb3G+WN7jYNMKgUYEODZF4YmxoqsViSCHAyXrqYoj/0m5nP09OqtLOel52LmqHkAAJFIhKBAH41rV1fX4EpSMqTyOnDG8f3FLXDroTr/959/xYr5HyjONxDBTGwIQ5HqIZcABdnFYIzBxMQYx28c0rj+f9/bhD2bDwEMMDE2gZ2zM8rLgKpqAHIA8grUVBUAAIyNLfHrrT0aN3rOn7QGV87+oTjf1Ax2Tk7K5xkDKopLUFaq+H9n4+CAg39/rxF/1pOLkXZZ8afN3NwCy79ahuGjg6Et1CNOSCfGORfkAeBhADFq5WUAljU6JgbAw/XbhgAKUP/loKVHSEgIJ4Q8WOrq6vixY8f4U089xY2MjHj//v2bHLN48WIOoE0PJyenJueHh4e3+Xw/P78m53t182rz+YNsBzU538nAqc3nh7uPb3K+GczbfP7EYQuanG8Awzaf/9aEZU3Ob+u5AHj01kMa557bf6pd5+ekZWqc/3L4rDafy8Ca1D3C99k2n28K0ybnD+n+WJvPt2V2Tc73swjROGb1gk+bHHM/AMRxgf5W04Me9NDvQ8h1ocUAstTK2QAaL0asPIZzLmWMlQKwhyIhV2KMvQLgFQBwdXUVqr6EEIEYGhpizJgxGDNmDKqrq3H37t0mx2RmZrb5egYGBtqsHgBAZCoCqtt2LBPd39h2E3Z/owIbZiS5Z7a2muWsrOaPayt+f7+sWpla3l/8Zkfi6+psQgi5d0Im4lrDOd8CYAugGJqi5+oQQu5Dt27dmowfB4Cvv/4akZGRuHLlCkpLSyGTyVBUVASpVAqpVIrMzEykpaVBKpUiOLjpz/6BgYG4fPkyAKBHjx5wc3MDV0sQs7KykFO/wE5z5z888WGUHC0BALj2ckV3q+6QVcggr5YDMuBm9k0UVhYCHAgIDGhyvk93H8juKMZ3u1q6ws6ifrXR+ircKLiBcmm54lhvnybne1p6ILsyGwDgZtUX3UwtIOccMnDIOZBddB01MsU3BQ9v9ybnuxj1QoVUcbei2MYDxoaaM9hkFiZDxhVj3139PDRPNjCAo8gJ0vrn3aw8IGoYbM0Vv5xmlKUqD3cQO2qcbmVvA1tmD0Axa4qblWb9pLI6ZFXcBAAYMkOYdDPVeD7Axx+2UYrzjZgxxJa91Z7lqJFKcLtK8WWhm4FZk9feo5cDbJMU53cTmaG7hYvG89W1VbgryQUA2Bk7NjnfsbsjbPMV55sbWsK+m5PG85U15SisVQwbcjFr+t51sO4B20rF+dZGtnDp7dzkGEIIaY6QY8QfBrCacz6mvrwMADjn69SOiak/5jxjzBBAHgBH3kqlaIw4IYSQroTGiBPSeQk5a8pFAB6MsT6MMWMAUwAcbHTMQQAz67efAfBba0k4IYQQQgghnYVgQ1Pqx3y/BsUNmQYAvuWcJzLG1kJx48lBAN8A+J4xdh1AERTJOiGEEEIIIZ2eoGPEOefRAKIb7Vulti0B0HRCWUIIIYQQQjo5WuKeEEIIIYQQPaBEnBBCCCGEED2gRJwQQgghhBA9oEScEEIIIYQQPaBEnBBCCCGEED2gRJwQQgghhBA9oEScEEIIIYQQPaBEnBBCCCGEED2gRJwQQgghhBA9YJxzfdehXRhjpQDSGu22BlD6D/vUy+rbDgAKtFzN5upzP8e39nxbXnvjfa21jbbbQ9tt0doxbd3fnnJHbw9tvzcal7vav5XO9N5o7Rht/Ftp/FxHb48H+d+KG4CXOeeHtHhNQkhHwDl/oB4AttzLPvVyo+04XdTxfo5v7fl7aY9/aButtoe226K1Y9q6vz3ljt4e2n5vtPZe6Qr/VjrTe6O1Y7Txb6WZ5zp0e3S1fyv0oAc9HozHgzg0pbkegbbsO9TKc9rW3uv/0/GtPX8v7dFa22ibttuitWPaur+9ZW3q6O+NxuWu9m+lM703WjtGG/9Wutp7o7l9Hbk9CCEPgAduaIq2McbiOOeh+q5HR0HtoYnaQ4XaQhO1hyZqDxVqC0JIWz2IPeLatkXfFehgqD00UXuoUFtoovbQRO2hQm1BCGmTLt8jTgghhBBCiD5QjzghhBBCCCF6QIk4IYQQQgghekCJOCGEEEIIIXpAiXgrGGPejLGvGGN7GWPz9F0ffWOMjWeMbWWM/cgYe0Lf9dEnxlhfxtg3jLG9+q6LvjDGzBlj2+vfE8/ruz76Ru8JFfqs0ER/SwghLem0iThj7FvG2F3G2NVG+8MYYymMseuMsbdauwbn/Brn/FUAzwIYKmR9haal9jjAOZ8D4FUAzwlZXyFpqS3SOeezhK2p7rWzbSYC2Fv/nnha55XVgfa0R2d9TzRoZ1t0is+K1rSzPTrN3xJCiHZ12kQcwDYAYeo7GGMGAL4E8CQAHwBTGWM+jDF/xtjhRo/u9ec8DeAIgGjdVl/rtkEL7VFvZf15D6pt0F5bdDbb0Ma2AdATQFb9YTId1lGXtqHt7dHZbUP72+JB/6xozTa0oz060d8SQogWGeq7AkLhnJ9ijPVutPshANc55+kAwBjbDSCCc74OwFMtXOcggIOMsSMAdgpXY2Fpoz0YYwzABwCOcs4ThK2xcLT13uiM2tM2ALKhSMYvoZN+qW9neyTptna61Z62YIxdQyf4rGhNe98bneVvCSFEuzrlH89WiKHqwQMUiYS4pYMZY48yxjYwxjajc/ZitKs9ALwO4DEAzzDGXhWyYnrQ3veGPWPsKwADGGPLhK6cnrXUNlEAJjHG/ouutfx2s+3Rxd4TDVp6b3Tmz4rWtPTe6Ox/Swgh96jT9ohrA+f8JICTeq5Gh8E53wBgg77r0RFwzguhGP/aZXHOKwG8pO96dBT0nlChzwpN9LeEENKSrtYjngOgl1q5Z/2+roraQ4XaomXUNpqoPVSoLTRRexBC2qWrJeIXAXgwxvowxowBTAFwUM910idqDxVqi5ZR22ii9lChttBE7UEIaZdOm4gzxnYBOA+gP2MsmzE2i3MuBfAagBgA1wDs4Zwn6rOeukLtoUJt0TJqG03UHirUFpqoPQgh2sA45/quAyGEEEIIIV1Op+0RJ4QQQgghpCOjRJwQQgghhBA9oEScEEIIIYQQPaBEnBBCCCGEED2gRJwQQgghhBA9oEScEEIIIYQQPaBEnBBCCCGEED2gRJyQTooxZs8Yu1T/yGOM5aiVzwkUcwBj7JtWnndkjB0TIjYhhBDyoDHUdwUIIcLgnBcCCAIAxthqABWc848FDrscwHut1CmfMXabMTaUc35W4LoQQgghHRr1iBPSBTHGKur/+yhj7HfG2M+MsXTG2AeMsecZY38yxq4wxvrVH+fIGNvHGLtY/xjazDUtAQRwzi/Xl0eo9cD/Vf88ABwA8LyOXiohhBDSYVEiTggJBPAqAG8AMwB4cs4fAvA1gNfrj/kcwKec84EAJtU/11gogKtq5TcBLOCcBwEYDqC6fn9cfZkQQgjp0mhoCiHkIuf8NgAwxm4AOF6//wqAkfXbjwHwYYw1nGPFGLPgnFeoXccZQL5a+SyA9Yyx/wGI4pxn1++/C8BF+y+DEEIIebBQIk4IqVHblquV5VB9RogADOacS1q5TjUA04YC5/wDxtgRAGMBnGWMjeGcJ9cfU93CNQghhJAug4amEELa4jhUw1TAGAtq5phrANzVjunHOb/COf8QwEUAXvVPeUJzCAshhBDSJVEiTghpizcAhDLG/maMJUExplxDfW+3tdpNmf9ijF1ljP0NoA7A0fr9IwEc0UWlCSGEkI6Mcc71XQdCSCfBGFsEoJxz3tzNnA3HnAIQwTkv1l3NCCGEkI6HesQJIdr0X2iOOdfAGHMEsJ6ScEIIIYR6xAkhhBBCCNEL6hEnhBBCCCFEDygRJ4QQQgghRA8oESeEEEIIIUQPKBEnhBBCCCFEDygRJ4QQQgghRA/+H2OmgFbMn4ZAAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Get the decay rate data\n", + "dr_tally = decay_rate.xs_tally\n", + "dr_u235 = dr_tally.get_values(nuclides=['U235']).flatten()\n", + "dr_pu239 = dr_tally.get_values(nuclides=['Pu239']).flatten()\n", + "\n", + "# Compute the exponential decay of the precursors\n", + "time = np.logspace(-3,3)\n", + "dr_u235_points = np.exp(-np.outer(dr_u235, time))\n", + "dr_pu239_points = np.exp(-np.outer(dr_pu239, time))\n", + "\n", + "# Create a plot of the fraction of the precursors remaining as a f(time)\n", + "colors = ['b', 'g', 'r', 'c', 'm', 'k']\n", + "legend = []\n", + "fig = plt.figure(figsize=(8,6))\n", + "for g,c in enumerate(colors):\n", + " plt.semilogx(time, dr_u235_points [g,:], color=c, linestyle='--', linewidth=3)\n", + " plt.semilogx(time, dr_pu239_points[g,:], color=c, linestyle=':' , linewidth=3)\n", + " legend.append('U-235 $t_{1/2}$ = ' + '{0:1.2f} seconds'.format(np.log(2) / dr_u235[g]))\n", + " legend.append('Pu-239 $t_{1/2}$ = ' + '{0:1.2f} seconds'.format(np.log(2) / dr_pu239[g]))\n", + "\n", + "plt.title('Delayed Neutron Precursor Decay Rates')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Fraction Remaining')\n", + "plt.legend(legend, loc=1, bbox_to_anchor=(1.55, 0.95))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's compute the initial concentration of the delayed neutron precursors:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
celldelayedgroupnuclidescoremeanstd. dev.
011U235(((delayed-nu-fission / nu-fission) * (delayed...8.779139e-084.658590e-10
111Pu239(((delayed-nu-fission / nu-fission) * (delayed...7.149814e-093.559010e-11
212U235(((delayed-nu-fission / nu-fission) * (delayed...9.527880e-075.055905e-09
312Pu239(((delayed-nu-fission / nu-fission) * (delayed...1.303159e-076.486820e-10
413U235(((delayed-nu-fission / nu-fission) * (delayed...2.353903e-071.249083e-09
513Pu239(((delayed-nu-fission / nu-fission) * (delayed...2.032895e-081.011928e-10
614U235(((delayed-nu-fission / nu-fission) * (delayed...4.720191e-072.504737e-09
714Pu239(((delayed-nu-fission / nu-fission) * (delayed...2.626309e-081.307315e-10
815U235(((delayed-nu-fission / nu-fission) * (delayed...2.827915e-081.500614e-10
915Pu239(((delayed-nu-fission / nu-fission) * (delayed...2.430587e-091.209889e-11
1016U235(((delayed-nu-fission / nu-fission) * (delayed...1.477530e-097.840413e-12
1116Pu239(((delayed-nu-fission / nu-fission) * (delayed...6.994312e-113.481605e-13
\n", + "
" + ], + "text/plain": [ + " cell delayedgroup nuclide \\\n", + "0 1 1 U235 \n", + "1 1 1 Pu239 \n", + "2 1 2 U235 \n", + "3 1 2 Pu239 \n", + "4 1 3 U235 \n", + "5 1 3 Pu239 \n", + "6 1 4 U235 \n", + "7 1 4 Pu239 \n", + "8 1 5 U235 \n", + "9 1 5 Pu239 \n", + "10 1 6 U235 \n", + "11 1 6 Pu239 \n", + "\n", + " score mean std. dev. \n", + "0 (((delayed-nu-fission / nu-fission) * (delayed... 8.78e-08 4.66e-10 \n", + "1 (((delayed-nu-fission / nu-fission) * (delayed... 7.15e-09 3.56e-11 \n", + "2 (((delayed-nu-fission / nu-fission) * (delayed... 9.53e-07 5.06e-09 \n", + "3 (((delayed-nu-fission / nu-fission) * (delayed... 1.30e-07 6.49e-10 \n", + "4 (((delayed-nu-fission / nu-fission) * (delayed... 2.35e-07 1.25e-09 \n", + "5 (((delayed-nu-fission / nu-fission) * (delayed... 2.03e-08 1.01e-10 \n", + "6 (((delayed-nu-fission / nu-fission) * (delayed... 4.72e-07 2.50e-09 \n", + "7 (((delayed-nu-fission / nu-fission) * (delayed... 2.63e-08 1.31e-10 \n", + "8 (((delayed-nu-fission / nu-fission) * (delayed... 2.83e-08 1.50e-10 \n", + "9 (((delayed-nu-fission / nu-fission) * (delayed... 2.43e-09 1.21e-11 \n", + "10 (((delayed-nu-fission / nu-fission) * (delayed... 1.48e-09 7.84e-12 \n", + "11 (((delayed-nu-fission / nu-fission) * (delayed... 6.99e-11 3.48e-13 " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use tally arithmetic to compute the precursor concentrations\n", + "precursor_conc = beta.get_condensed_xs(one_group).xs_tally.summation(filter_type=openmc.EnergyFilter, remove_filter=True) * \\\n", + " delayed_nu_fission.get_condensed_xs(one_group).xs_tally.summation(filter_type=openmc.EnergyFilter, remove_filter=True) / \\\n", + " decay_rate.xs_tally.summation(filter_type=openmc.EnergyFilter, remove_filter=True)\n", + "\n", + "# Get the Pandas DataFrames for inspection\n", + "precursor_conc.get_pandas_dataframe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot the delayed neutron fractions for each nuclide." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Beta (U-235) : 0.006504 +/- 0.000007\n", + "Beta (Pu-239): 0.002245 +/- 0.000002\n" + ] + }, + { + "data": { + "text/plain": [ + "(0, 7)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "energy_filter = [f for f in beta.xs_tally.filters if type(f) is openmc.EnergyFilter]\n", + "beta_integrated = beta.get_condensed_xs(one_group).xs_tally.summation(filter_type=openmc.EnergyFilter, remove_filter=True)\n", + "beta_u235 = beta_integrated.get_values(nuclides=['U235'])\n", + "beta_pu239 = beta_integrated.get_values(nuclides=['Pu239'])\n", + "\n", + "# Reshape the betas\n", + "beta_u235.shape = (beta_u235.shape[0])\n", + "beta_pu239.shape = (beta_pu239.shape[0])\n", + "\n", + "df = beta_integrated.summation(filter_type=openmc.DelayedGroupFilter, remove_filter=True).get_pandas_dataframe()\n", + "print('Beta (U-235) : {:.6f} +/- {:.6f}'.format(df[df['nuclide'] == 'U235']['mean'][0], df[df['nuclide'] == 'U235']['std. dev.'][0]))\n", + "print('Beta (Pu-239): {:.6f} +/- {:.6f}'.format(df[df['nuclide'] == 'Pu239']['mean'][1], df[df['nuclide'] == 'Pu239']['std. dev.'][1]))\n", + "\n", + "beta_u235 = np.append(beta_u235[0], beta_u235)\n", + "beta_pu239 = np.append(beta_pu239[0], beta_pu239)\n", + "\n", + "# Create a step plot for the MGXS\n", + "plt.plot(np.arange(0.5, 7.5, 1), beta_u235, drawstyle='steps', color='b', linewidth=3)\n", + "plt.plot(np.arange(0.5, 7.5, 1), beta_pu239, drawstyle='steps', color='g', linewidth=3)\n", + "\n", + "plt.title('Delayed Neutron Fraction (beta)')\n", + "plt.xlabel('Delayed Group')\n", + "plt.ylabel('Beta(fraction total neutrons)')\n", + "plt.legend(['U-235', 'Pu-239'])\n", + "plt.xlim([0,7])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also plot the energy spectrum for fission emission of prompt and delayed neutrons." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1000.0, 20000000.0)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "chi_d_u235 = np.squeeze(chi_delayed.get_xs(nuclides=['U235'], order_groups='decreasing'))\n", + "chi_d_pu239 = np.squeeze(chi_delayed.get_xs(nuclides=['Pu239'], order_groups='decreasing'))\n", + "chi_p_u235 = np.squeeze(chi_prompt.get_xs(nuclides=['U235'], order_groups='decreasing'))\n", + "chi_p_pu239 = np.squeeze(chi_prompt.get_xs(nuclides=['Pu239'], order_groups='decreasing'))\n", + "\n", + "chi_d_u235 = np.append(chi_d_u235 , chi_d_u235[0])\n", + "chi_d_pu239 = np.append(chi_d_pu239, chi_d_pu239[0])\n", + "chi_p_u235 = np.append(chi_p_u235 , chi_p_u235[0])\n", + "chi_p_pu239 = np.append(chi_p_pu239, chi_p_pu239[0])\n", + "\n", + "# Create a step plot for the MGXS\n", + "plt.semilogx(energy_groups.group_edges, chi_d_u235 , drawstyle='steps', color='b', linestyle='--', linewidth=3)\n", + "plt.semilogx(energy_groups.group_edges, chi_d_pu239, drawstyle='steps', color='g', linestyle='--', linewidth=3)\n", + "plt.semilogx(energy_groups.group_edges, chi_p_u235 , drawstyle='steps', color='b', linestyle=':', linewidth=3)\n", + "plt.semilogx(energy_groups.group_edges, chi_p_pu239, drawstyle='steps', color='g', linestyle=':', linewidth=3)\n", + "\n", + "plt.title('Energy Spectrum for Fission Neutrons')\n", + "plt.xlabel('Energy (eV)')\n", + "plt.ylabel('Fraction on emitted neutrons')\n", + "plt.legend(['U-235 delayed', 'Pu-239 delayed', 'U-235 prompt', 'Pu-239 prompt'],loc=2)\n", + "plt.xlim(1.0e3, 20.0e6)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mdgxs-part-ii.ipynb b/mdgxs-part-ii.ipynb new file mode 100644 index 0000000..1c996c8 --- /dev/null +++ b/mdgxs-part-ii.ipynb @@ -0,0 +1,1179 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multigroup (Delayed) Cross Section Generation Part II: Advanced Features\n", + "This IPython Notebook illustrates the use of the **`openmc.mgxs.Library`** class. The `Library` class is designed to automate the calculation of multi-group cross sections for use cases with one or more domains, cross section types, and/or nuclides. In particular, this Notebook illustrates the following features:\n", + "\n", + "* Calculation of multi-energy-group and multi-delayed-group cross sections for a **fuel assembly**\n", + "* Automated creation, manipulation and storage of `MGXS` with **`openmc.mgxs.Library`**\n", + "* Steady-state pin-by-pin **delayed neutron fractions (beta)** for each delayed group.\n", + "* Generation of surface currents on the interfaces and surfaces of a Mesh." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import math\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import openmc\n", + "import openmc.mgxs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we need to define materials that will be used in the problem: fuel, water, and cladding." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 1.6 enriched fuel\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel.set_density('g/cm3', 10.31341)\n", + "fuel.add_nuclide('U235', 3.7503e-4)\n", + "fuel.add_nuclide('U238', 2.2625e-2)\n", + "fuel.add_nuclide('O16', 4.6007e-2)\n", + "\n", + "# borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_nuclide('H1', 4.9457e-2)\n", + "water.add_nuclide('O16', 2.4732e-2)\n", + "water.add_nuclide('B10', 8.0042e-6)\n", + "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide('Zr90', 7.2758e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we can now create a `Materials` object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a materials collection and export to XML\n", + "materials = openmc.Materials((fuel, water, zircaloy))\n", + "materials.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. This problem will be a square array of fuel pins and control rod guide tubes for which we can use OpenMC's lattice/universe feature. The basic universe will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces for fuel and clad, as well as the outer bounding surfaces of the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create cylinders for the fuel and clad\n", + "fuel_outer_radius = openmc.ZCylinder(r=0.39218)\n", + "clad_outer_radius = openmc.ZCylinder(r=0.45720)\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "min_x = openmc.XPlane(x0=-10.71, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=+10.71, boundary_type='reflective')\n", + "min_y = openmc.YPlane(y0=-10.71, boundary_type='reflective')\n", + "max_y = openmc.YPlane(y0=+10.71, boundary_type='reflective')\n", + "min_z = openmc.ZPlane(z0=-10., boundary_type='reflective')\n", + "max_z = openmc.ZPlane(z0=+10., boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now construct a fuel pin cell from cells that are defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "fuel_pin_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "fuel_pin_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "fuel_pin_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Likewise, we can construct a control rod guide tube with the same surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a control rod guide tube\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "\n", + "# Create guide tube Cell\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell.fill = water\n", + "guide_tube_cell.region = -fuel_outer_radius\n", + "guide_tube_universe.add_cell(guide_tube_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "guide_tube_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "guide_tube_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the pin cell universe, we can construct a 17x17 rectangular lattice with a 1.26 cm pitch." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Create fuel assembly Lattice\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly.pitch = (1.26, 1.26)\n", + "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create a NumPy array of fuel pin and guide tube universes for the lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Create array indices for guide tube locations in lattice\n", + "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", + " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", + "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", + " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", + "\n", + "# Create universes array with the fuel pin and guide tube universes\n", + "universes = np.tile(fuel_pin_universe, (17,17))\n", + "universes[template_x, template_y] = guide_tube_universe\n", + "\n", + "# Store the array of universes in the lattice\n", + "assembly.universes = universes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the pin cell universe and then assign it to the root universe." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell', fill=assembly)\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", + "root_universe.add_cell(root_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry that is assigned a root universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Create Geometry and export to XML\n", + "geometry = openmc.Geometry(root_universe)\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 2500 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 50\n", + "inactive = 10\n", + "particles = 2500\n", + "\n", + "# Instantiate a Settings object\n", + "settings = openmc.Settings()\n", + "settings.batches = batches\n", + "settings.inactive = inactive\n", + "settings.particles = particles\n", + "settings.output = {'tallies': False}\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-10.71, -10.71, -10, 10.71, 10.71, 10.]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings.source = openmc.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us also create a plot to verify that our fuel assembly geometry was created successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot our geometry\n", + "plot = openmc.Plot.from_geometry(geometry)\n", + "plot.pixels = (250, 250)\n", + "plot.color_by = 'material'\n", + "openmc.plot_inline(plot)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see from the plot, we have a nice array of fuel and guide tube pin cells with fuel, cladding, and water!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create an MGXS Library" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we are ready to generate multi-group cross sections! First, let's define a 20-energy-group and 1-energy-group." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a 20-group EnergyGroups object\n", + "energy_groups = openmc.mgxs.EnergyGroups()\n", + "energy_groups.group_edges = np.logspace(-3, 7.3, 21)\n", + "\n", + "# Instantiate a 1-group EnergyGroups object\n", + "one_group = openmc.mgxs.EnergyGroups()\n", + "one_group.group_edges = np.array([energy_groups.group_edges[0], energy_groups.group_edges[-1]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will instantiate an `openmc.mgxs.Library` for the energy and delayed groups with our the fuel assembly geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=1.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=5.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=6.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=17.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=23.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Instantiate a tally mesh \n", + "mesh = openmc.RegularMesh(mesh_id=1)\n", + "mesh.dimension = [17, 17, 1]\n", + "mesh.lower_left = [-10.71, -10.71, -10000.]\n", + "mesh.width = [1.26, 1.26, 20000.]\n", + "\n", + "# Initialize an 20-energy-group and 6-delayed-group MGXS Library\n", + "mgxs_lib = openmc.mgxs.Library(geometry)\n", + "mgxs_lib.energy_groups = energy_groups\n", + "mgxs_lib.num_delayed_groups = 6\n", + "\n", + "# Specify multi-group cross section types to compute\n", + "mgxs_lib.mgxs_types = ['total', 'transport', 'nu-scatter matrix', 'kappa-fission', 'inverse-velocity', 'chi-prompt',\n", + " 'prompt-nu-fission', 'chi-delayed', 'delayed-nu-fission', 'beta']\n", + "\n", + "# Specify a \"mesh\" domain type for the cross section tally filters\n", + "mgxs_lib.domain_type = 'mesh'\n", + "\n", + "# Specify the mesh domain over which to compute multi-group cross sections\n", + "mgxs_lib.domains = [mesh]\n", + "\n", + "# Construct all tallies needed for the multi-group cross section library\n", + "mgxs_lib.build_library()\n", + "\n", + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "mgxs_lib.add_to_tallies_file(tallies_file, merge=True)\n", + "\n", + "# Instantiate a current tally\n", + "mesh_filter = openmc.MeshSurfaceFilter(mesh)\n", + "current_tally = openmc.Tally(name='current tally')\n", + "current_tally.scores = ['current']\n", + "current_tally.filters = [mesh_filter]\n", + "\n", + "# Add current tally to the tallies file\n", + "tallies_file.append(current_tally)\n", + "\n", + "# Export to \"tallies.xml\"\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can run OpenMC to generate the cross sections." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2019 MIT and OpenMC contributors\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.11.0-dev\n", + " Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n", + " Date/Time | 2019-07-18 22:07:58\n", + " OpenMP Threads | 4\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U235 from /opt/data/hdf5/nndc_hdf5_v15/U235.h5\n", + " Reading U238 from /opt/data/hdf5/nndc_hdf5_v15/U238.h5\n", + " Reading O16 from /opt/data/hdf5/nndc_hdf5_v15/O16.h5\n", + " Reading H1 from /opt/data/hdf5/nndc_hdf5_v15/H1.h5\n", + " Reading B10 from /opt/data/hdf5/nndc_hdf5_v15/B10.h5\n", + " Reading Zr90 from /opt/data/hdf5/nndc_hdf5_v15/Zr90.h5\n", + " Maximum neutron transport energy: 20000000.000000 eV for U235\n", + " Reading tallies XML file...\n", + " Writing summary.h5 file...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.03852\n", + " 2/1 0.99743\n", + " 3/1 1.02987\n", + " 4/1 1.04397\n", + " 5/1 1.06262\n", + " 6/1 1.06657\n", + " 7/1 0.98574\n", + " 8/1 1.04364\n", + " 9/1 1.01253\n", + " 10/1 1.02094\n", + " 11/1 0.99586\n", + " 12/1 1.00508 1.00047 +/- 0.00461\n", + " 13/1 1.05292 1.01795 +/- 0.01769\n", + " 14/1 1.04732 1.02530 +/- 0.01450\n", + " 15/1 1.04886 1.03001 +/- 0.01218\n", + " 16/1 1.00948 1.02659 +/- 0.01052\n", + " 17/1 1.02644 1.02657 +/- 0.00889\n", + " 18/1 1.03080 1.02710 +/- 0.00772\n", + " 19/1 1.00018 1.02411 +/- 0.00743\n", + " 20/1 1.05668 1.02736 +/- 0.00740\n", + " 21/1 1.01160 1.02593 +/- 0.00685\n", + " 22/1 1.04334 1.02738 +/- 0.00642\n", + " 23/1 1.03105 1.02766 +/- 0.00591\n", + " 24/1 1.01174 1.02653 +/- 0.00559\n", + " 25/1 0.99844 1.02465 +/- 0.00553\n", + " 26/1 1.02241 1.02451 +/- 0.00517\n", + " 27/1 1.02904 1.02478 +/- 0.00487\n", + " 28/1 1.02132 1.02459 +/- 0.00459\n", + " 29/1 1.01384 1.02402 +/- 0.00438\n", + " 30/1 1.03891 1.02477 +/- 0.00422\n", + " 31/1 1.04092 1.02553 +/- 0.00409\n", + " 32/1 1.00058 1.02440 +/- 0.00406\n", + " 33/1 0.99940 1.02331 +/- 0.00403\n", + " 34/1 0.98362 1.02166 +/- 0.00420\n", + " 35/1 1.05358 1.02294 +/- 0.00422\n", + " 36/1 0.99923 1.02202 +/- 0.00416\n", + " 37/1 1.08491 1.02435 +/- 0.00463\n", + " 38/1 1.01838 1.02414 +/- 0.00447\n", + " 39/1 0.98567 1.02281 +/- 0.00451\n", + " 40/1 1.05047 1.02374 +/- 0.00445\n", + " 41/1 1.01993 1.02361 +/- 0.00431\n", + " 42/1 1.01223 1.02326 +/- 0.00419\n", + " 43/1 1.06259 1.02445 +/- 0.00423\n", + " 44/1 1.01993 1.02432 +/- 0.00411\n", + " 45/1 0.99233 1.02340 +/- 0.00409\n", + " 46/1 0.98532 1.02234 +/- 0.00411\n", + " 47/1 1.02513 1.02242 +/- 0.00400\n", + " 48/1 1.01637 1.02226 +/- 0.00390\n", + " 49/1 1.03215 1.02251 +/- 0.00381\n", + " 50/1 1.01826 1.02241 +/- 0.00371\n", + " Creating state point statepoint.50.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 4.2397e-01 seconds\n", + " Reading cross sections = 4.0321e-01 seconds\n", + " Total time in simulation = 2.0407e+01 seconds\n", + " Time in transport only = 2.0154e+01 seconds\n", + " Time in inactive batches = 1.0937e+00 seconds\n", + " Time in active batches = 1.9314e+01 seconds\n", + " Time synchronizing fission bank = 7.8056e-03 seconds\n", + " Sampling source sites = 6.7223e-03 seconds\n", + " SEND/RECV source sites = 9.5783e-04 seconds\n", + " Time accumulating tallies = 9.2006e-02 seconds\n", + " Total time for finalization = 1.0890e-02 seconds\n", + " Total time elapsed = 2.0869e+01 seconds\n", + " Calculation Rate (inactive) = 22858.4 particles/second\n", + " Calculation Rate (active) = 5177.70 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.02207 +/- 0.00343\n", + " k-effective (Track-length) = 1.02241 +/- 0.00371\n", + " k-effective (Absorption) = 1.02408 +/- 0.00356\n", + " Combined k-effective = 1.02306 +/- 0.00307\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tally Data Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the last statepoint file\n", + "sp = openmc.StatePoint('statepoint.50.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by the `Library`. We simply have to load the tallies from the statepoint into the `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize MGXS Library with OpenMC statepoint data\n", + "mgxs_lib.load_from_statepoint(sp)\n", + "\n", + "# Extrack the current tally separately\n", + "current_tally = sp.get_tally(name='current tally')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using Tally Arithmetic to Compute the Delayed Neutron Precursor Concentrations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we illustrate how one can leverage OpenMC's [tally arithmetic](tally-arithmetic.ipynb) data processing feature with `MGXS` objects. The `openmc.mgxs` module uses tally arithmetic to compute multi-group cross sections with automated uncertainty propagation. Each `MGXS` object includes an `xs_tally` attribute which is a \"derived\" `Tally` based on the tallies needed to compute the cross section type of interest. These derived tallies can be used in subsequent tally arithmetic operations. For example, we can use tally artithmetic to compute the delayed neutron precursor concentrations using the `Beta` and `DelayedNuFissionXS` objects. The delayed neutron precursor concentrations are modeled using the following equations:\n", + "\n", + "$$\\frac{\\partial}{\\partial t} C_{k,d} (t) = \\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r} \\beta_{k,d} (t) \\nu_d \\sigma_{f,x}(\\mathbf{r},E',t)\\Phi(\\mathbf{r},E',t) - \\lambda_{d} C_{k,d} (t) $$\n", + "\n", + "$$C_{k,d} (t=0) = \\frac{1}{\\lambda_{d}} \\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r} \\beta_{k,d} (t=0) \\nu_d \\sigma_{f,x}(\\mathbf{r},E',t=0)\\Phi(\\mathbf{r},E',t=0) $$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mesh 1delayedgroupnuclidescoremeanstd. dev.
xyz
01111total(((delayed-nu-fission / nu-fission) * (delayed...0.0000992.275247e-05
11112total(((delayed-nu-fission / nu-fission) * (delayed...0.0012602.852271e-04
21113total(((delayed-nu-fission / nu-fission) * (delayed...0.0008001.795615e-04
31114total(((delayed-nu-fission / nu-fission) * (delayed...0.0006301.397151e-04
41115total(((delayed-nu-fission / nu-fission) * (delayed...0.0000234.861639e-06
51116total(((delayed-nu-fission / nu-fission) * (delayed...0.0000023.879558e-07
62111total(((delayed-nu-fission / nu-fission) * (delayed...0.0000912.062544e-05
72112total(((delayed-nu-fission / nu-fission) * (delayed...0.0011622.584797e-04
82113total(((delayed-nu-fission / nu-fission) * (delayed...0.0007371.626991e-04
92114total(((delayed-nu-fission / nu-fission) * (delayed...0.0005811.265708e-04
\n", + "
" + ], + "text/plain": [ + " mesh 1 delayedgroup nuclide \\\n", + " x y z \n", + "0 1 1 1 1 total \n", + "1 1 1 1 2 total \n", + "2 1 1 1 3 total \n", + "3 1 1 1 4 total \n", + "4 1 1 1 5 total \n", + "5 1 1 1 6 total \n", + "6 2 1 1 1 total \n", + "7 2 1 1 2 total \n", + "8 2 1 1 3 total \n", + "9 2 1 1 4 total \n", + "\n", + " score mean std. dev. \n", + " \n", + "0 (((delayed-nu-fission / nu-fission) * (delayed... 0.000099 2.275247e-05 \n", + "1 (((delayed-nu-fission / nu-fission) * (delayed... 0.001260 2.852271e-04 \n", + "2 (((delayed-nu-fission / nu-fission) * (delayed... 0.000800 1.795615e-04 \n", + "3 (((delayed-nu-fission / nu-fission) * (delayed... 0.000630 1.397151e-04 \n", + "4 (((delayed-nu-fission / nu-fission) * (delayed... 0.000023 4.861639e-06 \n", + "5 (((delayed-nu-fission / nu-fission) * (delayed... 0.000002 3.879558e-07 \n", + "6 (((delayed-nu-fission / nu-fission) * (delayed... 0.000091 2.062544e-05 \n", + "7 (((delayed-nu-fission / nu-fission) * (delayed... 0.001162 2.584797e-04 \n", + "8 (((delayed-nu-fission / nu-fission) * (delayed... 0.000737 1.626991e-04 \n", + "9 (((delayed-nu-fission / nu-fission) * (delayed... 0.000581 1.265708e-04 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set the time constants for the delayed precursors (in seconds^-1)\n", + "precursor_halflife = np.array([55.6, 24.5, 16.3, 2.37, 0.424, 0.195])\n", + "precursor_lambda = math.log(2.0) / precursor_halflife\n", + "\n", + "beta = mgxs_lib.get_mgxs(mesh, 'beta')\n", + "\n", + "# Create a tally object with only the delayed group filter for the time constants\n", + "beta_filters = [f for f in beta.xs_tally.filters if type(f) is not openmc.DelayedGroupFilter]\n", + "lambda_tally = beta.xs_tally.summation(nuclides=beta.xs_tally.nuclides)\n", + "for f in beta_filters:\n", + " lambda_tally = lambda_tally.summation(filter_type=type(f), remove_filter=True) * 0. + 1.\n", + "\n", + "# Set the mean of the lambda tally and reshape to account for nuclides and scores\n", + "lambda_tally._mean = precursor_lambda\n", + "lambda_tally._mean.shape = lambda_tally.std_dev.shape\n", + "\n", + "# Set a total nuclide and lambda score\n", + "lambda_tally.nuclides = [openmc.Nuclide(name='total')]\n", + "lambda_tally.scores = ['lambda']\n", + "\n", + "delayed_nu_fission = mgxs_lib.get_mgxs(mesh, 'delayed-nu-fission')\n", + "\n", + "# Use tally arithmetic to compute the precursor concentrations\n", + "precursor_conc = beta.xs_tally.summation(filter_type=openmc.EnergyFilter, remove_filter=True) * \\\n", + " delayed_nu_fission.xs_tally.summation(filter_type=openmc.EnergyFilter, remove_filter=True) / lambda_tally\n", + " \n", + "# The difference is a derived tally which can generate Pandas DataFrames for inspection\n", + "precursor_conc.get_pandas_dataframe().head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another useful feature of the Python API is the ability to extract the surface currents for the interfaces and surfaces of a mesh. We can inspect the currents for the mesh by getting the pandas dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mesh 1nuclidescoremeanstd. dev.
xyzsurf
0111x-min outtotalcurrent0.000000.000000
1111x-min intotalcurrent0.000000.000000
2111x-max outtotalcurrent0.032450.000677
3111x-max intotalcurrent0.031800.000659
4111y-min outtotalcurrent0.000000.000000
5111y-min intotalcurrent0.000000.000000
6111y-max outtotalcurrent0.030720.000677
7111y-max intotalcurrent0.031040.000652
8111z-min outtotalcurrent0.000000.000000
9111z-min intotalcurrent0.000000.000000
\n", + "
" + ], + "text/plain": [ + " mesh 1 nuclide score mean std. dev.\n", + " x y z surf \n", + "0 1 1 1 x-min out total current 0.00000 0.000000\n", + "1 1 1 1 x-min in total current 0.00000 0.000000\n", + "2 1 1 1 x-max out total current 0.03245 0.000677\n", + "3 1 1 1 x-max in total current 0.03180 0.000659\n", + "4 1 1 1 y-min out total current 0.00000 0.000000\n", + "5 1 1 1 y-min in total current 0.00000 0.000000\n", + "6 1 1 1 y-max out total current 0.03072 0.000677\n", + "7 1 1 1 y-max in total current 0.03104 0.000652\n", + "8 1 1 1 z-min out total current 0.00000 0.000000\n", + "9 1 1 1 z-min in total current 0.00000 0.000000" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "current_tally.get_pandas_dataframe().head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cross Section Visualizations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to inspecting the data in the tallies by getting the pandas dataframe, we can also plot the tally data on the domain mesh. Below is the delayed neutron fraction tallied in each mesh cell for each delayed group." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Beta - delayed group 6')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Extract the energy-condensed delayed neutron fraction tally\n", + "beta_by_group = beta.get_condensed_xs(one_group).xs_tally.summation(filter_type='energy', remove_filter=True)\n", + "beta_by_group.mean.shape = (17, 17, 6)\n", + "beta_by_group.mean[beta_by_group.mean == 0] = np.nan\n", + "\n", + "# Plot the betas\n", + "plt.figure(figsize=(18,9))\n", + "fig = plt.subplot(231)\n", + "plt.imshow(beta_by_group.mean[:,:,0], interpolation='none', cmap='jet')\n", + "plt.colorbar()\n", + "plt.title('Beta - delayed group 1')\n", + "\n", + "fig = plt.subplot(232)\n", + "plt.imshow(beta_by_group.mean[:,:,1], interpolation='none', cmap='jet')\n", + "plt.colorbar()\n", + "plt.title('Beta - delayed group 2')\n", + "\n", + "fig = plt.subplot(233)\n", + "plt.imshow(beta_by_group.mean[:,:,2], interpolation='none', cmap='jet')\n", + "plt.colorbar()\n", + "plt.title('Beta - delayed group 3')\n", + "\n", + "fig = plt.subplot(234)\n", + "plt.imshow(beta_by_group.mean[:,:,3], interpolation='none', cmap='jet')\n", + "plt.colorbar()\n", + "plt.title('Beta - delayed group 4')\n", + "\n", + "fig = plt.subplot(235)\n", + "plt.imshow(beta_by_group.mean[:,:,4], interpolation='none', cmap='jet')\n", + "plt.colorbar()\n", + "plt.title('Beta - delayed group 5')\n", + "\n", + "fig = plt.subplot(236)\n", + "plt.imshow(beta_by_group.mean[:,:,5], interpolation='none', cmap='jet')\n", + "plt.colorbar()\n", + "plt.title('Beta - delayed group 6')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mgxs-part-i.ipynb b/mgxs-part-i.ipynb new file mode 100644 index 0000000..3d5711a --- /dev/null +++ b/mgxs-part-i.ipynb @@ -0,0 +1,1139 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multigroup Cross Section Generation Part I: Introduction\n", + "This IPython Notebook introduces the use of the `openmc.mgxs` module to calculate multi-group cross sections for an infinite homogeneous medium. In particular, this Notebook introduces the the following features:\n", + "\n", + "* **General equations** for scalar-flux averaged multi-group cross sections\n", + "* Creation of multi-group cross sections for an **infinite homogeneous medium**\n", + "* Use of **tally arithmetic** to manipulate multi-group cross sections" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction to Multi-Group Cross Sections (MGXS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many Monte Carlo particle transport codes, including OpenMC, use continuous-energy nuclear cross section data. However, most deterministic neutron transport codes use *multi-group cross sections* defined over discretized energy bins or *energy groups*. An example of U-235's continuous-energy fission cross section along with a 16-group cross section computed for a light water reactor spectrum is displayed below." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtMAAAI8CAYAAAAz5idmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\njwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": { + "image/png": { + "width": 350 + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(filename='images/mgxs.png', width=350)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A variety of tools employing different methodologies have been developed over the years to compute multi-group cross sections for certain applications, including NJOY (LANL), MC$^2$-3 (ANL), and Serpent (VTT). The `openmc.mgxs` Python module is designed to leverage OpenMC's tally system to calculate multi-group cross sections with arbitrary energy discretizations for fine-mesh heterogeneous deterministic neutron transport applications.\n", + "\n", + "Before proceeding to illustrate how one may use the `openmc.mgxs` module, it is worthwhile to define the general equations used to calculate multi-group cross sections. This is only intended as a brief overview of the methodology used by `openmc.mgxs` - we refer the interested reader to the large body of literature on the subject for a more comprehensive understanding of this complex topic." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Introductory Notation\n", + "The continuous real-valued microscopic cross section may be denoted $\\sigma_{n,x}(\\mathbf{r}, E)$ for position vector $\\mathbf{r}$, energy $E$, nuclide $n$ and interaction type $x$. Similarly, the scalar neutron flux may be denoted by $\\Phi(\\mathbf{r},E)$ for position $\\mathbf{r}$ and energy $E$. **Note**: Although nuclear cross sections are dependent on the temperature $T$ of the interacting medium, the temperature variable is neglected here for brevity." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Spatial and Energy Discretization\n", + "The energy domain for critical systems such as thermal reactors spans more than 10 orders of magnitude of neutron energies from 10$^{-5}$ - 10$^7$ eV. The multi-group approximation discretization divides this energy range into one or more energy groups. In particular, for $G$ total groups, we denote an energy group index $g$ such that $g \\in \\{1, 2, ..., G\\}$. The energy group indices are defined such that the smaller group the higher the energy, and vice versa. The integration over neutron energies across a discrete energy group is commonly referred to as **energy condensation**.\n", + "\n", + "Multi-group cross sections are computed for discretized spatial zones in the geometry of interest. The spatial zones may be defined on a structured and regular fuel assembly or pin cell mesh, an arbitrary unstructured mesh or the constructive solid geometry used by OpenMC. For a geometry with $K$ distinct spatial zones, we designate each spatial zone an index $k$ such that $k \\in \\{1, 2, ..., K\\}$. The volume of each spatial zone is denoted by $V_{k}$. The integration over discrete spatial zones is commonly referred to as **spatial homogenization**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### General Scalar-Flux Weighted MGXS\n", + "The multi-group cross sections computed by `openmc.mgxs` are defined as a *scalar flux-weighted average* of the microscopic cross sections across each discrete energy group. This formulation is employed in order to preserve the reaction rates within each energy group and spatial zone. In particular, spatial homogenization and energy condensation are used to compute the general multi-group cross section $\\sigma_{n,x,k,g}$ as follows:\n", + "\n", + "$$\\sigma_{n,x,k,g} = \\frac{\\int_{E_{g}}^{E_{g-1}}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\sigma_{n,x}(\\mathbf{r},E')\\Phi(\\mathbf{r},E')}{\\int_{E_{g}}^{E_{g-1}}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\Phi(\\mathbf{r},E')}$$\n", + "\n", + "This scalar flux-weighted average microscopic cross section is computed by `openmc.mgxs` for most multi-group cross sections, including total, absorption, and fission reaction types. These double integrals are stochastically computed with OpenMC's tally system - in particular, [filters](../usersguide/tallies.rst#filters) on the energy range and spatial zone (material, cell or universe) define the bounds of integration for both numerator and denominator." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multi-Group Scattering Matrices\n", + "The general multi-group cross section $\\sigma_{n,x,k,g}$ is a vector of $G$ values for each energy group $g$. The equation presented above only discretizes the energy of the incoming neutron and neglects the outgoing energy of the neutron (if any). Hence, this formulation must be extended to account for the outgoing energy of neutrons in the discretized scattering matrix cross section used by deterministic neutron transport codes. \n", + "\n", + "We denote the incoming and outgoing neutron energy groups as $g$ and $g'$ for the microscopic scattering matrix cross section $\\sigma_{n,s}(\\mathbf{r},E)$. As before, spatial homogenization and energy condensation are used to find the multi-group scattering matrix cross section $\\sigma_{n,s,k,g \\to g'}$ as follows:\n", + "\n", + "$$\\sigma_{n,s,k,g\\rightarrow g'} = \\frac{\\int_{E_{g'}}^{E_{g'-1}}\\mathrm{d}E''\\int_{E_{g}}^{E_{g-1}}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\sigma_{n,s}(\\mathbf{r},E'\\rightarrow E'')\\Phi(\\mathbf{r},E')}{\\int_{E_{g}}^{E_{g-1}}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\Phi(\\mathbf{r},E')}$$\n", + "\n", + "This scalar flux-weighted multi-group microscopic scattering matrix is computed using OpenMC tallies with both energy in and energy out filters." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multi-Group Fission Spectrum\n", + "The energy spectrum of neutrons emitted from fission is denoted by $\\chi_{n}(\\mathbf{r},E' \\rightarrow E'')$ for incoming and outgoing energies $E'$ and $E''$, respectively. Unlike the multi-group cross sections $\\sigma_{n,x,k,g}$ considered up to this point, the fission spectrum is a probability distribution and must sum to unity. The outgoing energy is typically much less dependent on the incoming energy for fission than for scattering interactions. As a result, it is common practice to integrate over the incoming neutron energy when computing the multi-group fission spectrum. The fission spectrum may be simplified as $\\chi_{n}(\\mathbf{r},E)$ with outgoing energy $E$.\n", + "\n", + "Unlike the multi-group cross sections defined up to this point, the multi-group fission spectrum is weighted by the fission production rate rather than the scalar flux. This formulation is intended to preserve the total fission production rate in the multi-group deterministic calculation. In order to mathematically define the multi-group fission spectrum, we denote the microscopic fission cross section as $\\sigma_{n,f}(\\mathbf{r},E)$ and the average number of neutrons emitted from fission interactions with nuclide $n$ as $\\nu_{n}(\\mathbf{r},E)$. The multi-group fission spectrum $\\chi_{n,k,g}$ is then the probability of fission neutrons emitted into energy group $g$. \n", + "\n", + "Similar to before, spatial homogenization and energy condensation are used to find the multi-group fission spectrum $\\chi_{n,k,g}$ as follows:\n", + "\n", + "$$\\chi_{n,k,g'} = \\frac{\\int_{E_{g'}}^{E_{g'-1}}\\mathrm{d}E''\\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\chi_{n}(\\mathbf{r},E'\\rightarrow E'')\\nu_{n}(\\mathbf{r},E')\\sigma_{n,f}(\\mathbf{r},E')\\Phi(\\mathbf{r},E')}{\\int_{0}^{\\infty}\\mathrm{d}E'\\int_{\\mathbf{r} \\in V_{k}}\\mathrm{d}\\mathbf{r}\\nu_{n}(\\mathbf{r},E')\\sigma_{n,f}(\\mathbf{r},E')\\Phi(\\mathbf{r},E')}$$\n", + "\n", + "The fission production-weighted multi-group fission spectrum is computed using OpenMC tallies with both energy in and energy out filters.\n", + "\n", + "This concludes our brief overview on the methodology to compute multi-group cross sections. The following sections detail more concretely how users may employ the `openmc.mgxs` module to power simulation workflows requiring multi-group cross sections for downstream deterministic calculations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import openmc\n", + "import openmc.mgxs as mgxs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We being by creating a material for the homogeneous medium." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Material and register the Nuclides\n", + "inf_medium = openmc.Material(name='moderator')\n", + "inf_medium.set_density('g/cc', 5.)\n", + "inf_medium.add_nuclide('H1', 0.028999667)\n", + "inf_medium.add_nuclide('O16', 0.01450188)\n", + "inf_medium.add_nuclide('U235', 0.000114142)\n", + "inf_medium.add_nuclide('U238', 0.006886019)\n", + "inf_medium.add_nuclide('Zr90', 0.002116053)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our material, we can now create a `Materials` object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate a Materials collection and export to XML\n", + "materials_file = openmc.Materials([inf_medium])\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. This problem will be a simple square cell with reflective boundary conditions to simulate an infinite homogeneous medium. The first step is to create the outer bounding surfaces of the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Instantiate boundary Planes\n", + "min_x = openmc.XPlane(boundary_type='reflective', x0=-0.63)\n", + "max_x = openmc.XPlane(boundary_type='reflective', x0=0.63)\n", + "min_y = openmc.YPlane(boundary_type='reflective', y0=-0.63)\n", + "max_y = openmc.YPlane(boundary_type='reflective', y0=0.63)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now create a cell that is defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Cell\n", + "cell = openmc.Cell(cell_id=1, name='cell')\n", + "\n", + "# Register bounding Surfaces with the Cell\n", + "cell.region = +min_x & -max_x & +min_y & -max_y\n", + "\n", + "# Fill the Cell with the Material\n", + "cell.fill = inf_medium" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create a root universe and add our square cell to it." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create root universe\n", + "root_universe = openmc.Universe(name='root universe', cells=[cell])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry that is assigned a root universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "openmc_geometry = openmc.Geometry(root_universe)\n", + "\n", + "# Export to \"geometry.xml\"\n", + "openmc_geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we must define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 2500 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 50\n", + "inactive = 10\n", + "particles = 2500\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': True}\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-0.63, -0.63, -0.63, 0.63, 0.63, 0.63]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in `EnergyGroups` class." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a 2-group EnergyGroups object\n", + "groups = mgxs.EnergyGroups()\n", + "groups.group_edges = np.array([0., 0.625, 20.0e6])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now use the `EnergyGroups` object, along with our previously created materials and geometry, to instantiate some `MGXS` objects from the `openmc.mgxs` module. In particular, the following are subclasses of the generic and abstract `MGXS` class:\n", + "\n", + "* `TotalXS`\n", + "* `TransportXS`\n", + "* `AbsorptionXS`\n", + "* `CaptureXS`\n", + "* `FissionXS`\n", + "* `KappaFissionXS`\n", + "* `ScatterXS`\n", + "* `ScatterMatrixXS`\n", + "* `Chi`\n", + "* `ChiPrompt`\n", + "* `InverseVelocity`\n", + "* `PromptNuFissionXS`\n", + "\n", + "Of course, we are aware that the fission cross section (`FissionXS`) can sometimes be paired with the fission neutron multiplication to become $\\nu\\sigma_f$. This can be accomodated in to the `FissionXS` class by setting the `nu` parameter to `True` as shown below.\n", + "\n", + "Additionally, scattering reactions (like (n,2n)) can also be defined to take in to account the neutron multiplication to become $\\nu\\sigma_s$. This can be accomodated in the the transport (`TransportXS`), scattering (`ScatterXS`), and scattering-matrix (`ScatterMatrixXS`) cross sections types by setting the `nu` parameter to `True` as shown below.\n", + "\n", + "These classes provide us with an interface to generate the tally inputs as well as perform post-processing of OpenMC's tally data to compute the respective multi-group cross sections. In this case, let's create the multi-group total, absorption and scattering cross sections with our 2-group structure." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a few different sections\n", + "total = mgxs.TotalXS(domain=cell, groups=groups)\n", + "absorption = mgxs.AbsorptionXS(domain=cell, groups=groups)\n", + "scattering = mgxs.ScatterXS(domain=cell, groups=groups)\n", + "\n", + "# Note that if we wanted to incorporate neutron multiplication in the\n", + "# scattering cross section we would write the previous line as:\n", + "# scattering = mgxs.ScatterXS(domain=cell, groups=groups, nu=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each multi-group cross section object stores its tallies in a Python dictionary called `tallies`. We can inspect the tallies in the dictionary for our `Absorption` object as follows. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('flux', Tally\n", + " \tID =\t1\n", + " \tName =\t\n", + " \tFilters =\tCellFilter, EnergyFilter\n", + " \tNuclides =\ttotal \n", + " \tScores =\t['flux']\n", + " \tEstimator =\ttracklength), ('absorption', Tally\n", + " \tID =\t2\n", + " \tName =\t\n", + " \tFilters =\tCellFilter, EnergyFilter\n", + " \tNuclides =\ttotal \n", + " \tScores =\t['absorption']\n", + " \tEstimator =\ttracklength)])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "absorption.tallies" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `Absorption` object includes tracklength tallies for the 'absorption' and 'flux' scores in the 2-group structure in cell 1. Now that each `MGXS` object contains the tallies that it needs, we must add these tallies to a `Tallies` object to generate the \"tallies.xml\" input file for OpenMC." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romano/openmc/openmc/mixin.py:61: IDWarning: Another CellFilter instance already exists with id=3.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:61: IDWarning: Another EnergyFilter instance already exists with id=4.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Instantiate an empty Tallies object\n", + "tallies_file = openmc.Tallies()\n", + "\n", + "# Add total tallies to the tallies file\n", + "tallies_file += total.tallies.values()\n", + "\n", + "# Add absorption tallies to the tallies file\n", + "tallies_file += absorption.tallies.values()\n", + "\n", + "# Add scattering tallies to the tallies file\n", + "tallies_file += scattering.tallies.values()\n", + "\n", + "# Export to \"tallies.xml\"\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we a have a complete set of inputs, so we can go ahead and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2017 Massachusetts Institute of Technology\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.9.0\n", + " Git SHA1 | 9b7cebf7bc34d60e0f1750c3d6cb103df11e8dc4\n", + " Date/Time | 2017-12-04 20:56:46\n", + " OpenMP Threads | 4\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Building neighboring cells lists for each surface...\n", + " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n", + " Reading O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n", + " Reading U235 from /home/romano/openmc/scripts/nndc_hdf5/U235.h5\n", + " Reading U238 from /home/romano/openmc/scripts/nndc_hdf5/U238.h5\n", + " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n", + " Maximum neutron transport energy: 2.00000E+07 eV for H1\n", + " Reading tallies XML file...\n", + " Writing summary.h5 file...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k \n", + " ========= ======== ==================== \n", + " 1/1 1.11184 \n", + " 2/1 1.15820 \n", + " 3/1 1.18468 \n", + " 4/1 1.17492 \n", + " 5/1 1.19645 \n", + " 6/1 1.18436 \n", + " 7/1 1.14070 \n", + " 8/1 1.15150 \n", + " 9/1 1.19202 \n", + " 10/1 1.17677 \n", + " 11/1 1.20272 \n", + " 12/1 1.21366 1.20819 +/- 0.00547\n", + " 13/1 1.15906 1.19181 +/- 0.01668\n", + " 14/1 1.14687 1.18058 +/- 0.01629\n", + " 15/1 1.14570 1.17360 +/- 0.01442\n", + " 16/1 1.13480 1.16713 +/- 0.01343\n", + " 17/1 1.17680 1.16852 +/- 0.01144\n", + " 18/1 1.16866 1.16853 +/- 0.00990\n", + " 19/1 1.19253 1.17120 +/- 0.00913\n", + " 20/1 1.18124 1.17220 +/- 0.00823\n", + " 21/1 1.19206 1.17401 +/- 0.00766\n", + " 22/1 1.17681 1.17424 +/- 0.00700\n", + " 23/1 1.17634 1.17440 +/- 0.00644\n", + " 24/1 1.13659 1.17170 +/- 0.00654\n", + " 25/1 1.17144 1.17169 +/- 0.00609\n", + " 26/1 1.20649 1.17386 +/- 0.00610\n", + " 27/1 1.11238 1.17024 +/- 0.00678\n", + " 28/1 1.18911 1.17129 +/- 0.00647\n", + " 29/1 1.14681 1.17000 +/- 0.00626\n", + " 30/1 1.12152 1.16758 +/- 0.00641\n", + " 31/1 1.12729 1.16566 +/- 0.00639\n", + " 32/1 1.15399 1.16513 +/- 0.00612\n", + " 33/1 1.13547 1.16384 +/- 0.00599\n", + " 34/1 1.17723 1.16440 +/- 0.00576\n", + " 35/1 1.09296 1.16154 +/- 0.00622\n", + " 36/1 1.19621 1.16287 +/- 0.00612\n", + " 37/1 1.12560 1.16149 +/- 0.00605\n", + " 38/1 1.17872 1.16211 +/- 0.00586\n", + " 39/1 1.17721 1.16263 +/- 0.00568\n", + " 40/1 1.13724 1.16178 +/- 0.00555\n", + " 41/1 1.18526 1.16254 +/- 0.00542\n", + " 42/1 1.13779 1.16177 +/- 0.00531\n", + " 43/1 1.15066 1.16143 +/- 0.00516\n", + " 44/1 1.12174 1.16026 +/- 0.00514\n", + " 45/1 1.17478 1.16068 +/- 0.00501\n", + " 46/1 1.14146 1.16014 +/- 0.00489\n", + " 47/1 1.20464 1.16135 +/- 0.00491\n", + " 48/1 1.15119 1.16108 +/- 0.00479\n", + " 49/1 1.17938 1.16155 +/- 0.00468\n", + " 50/1 1.15798 1.16146 +/- 0.00457\n", + " Creating state point statepoint.50.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 4.0504E-01 seconds\n", + " Reading cross sections = 3.6457E-01 seconds\n", + " Total time in simulation = 6.3478E+00 seconds\n", + " Time in transport only = 6.0079E+00 seconds\n", + " Time in inactive batches = 8.1713E-01 seconds\n", + " Time in active batches = 5.5307E+00 seconds\n", + " Time synchronizing fission bank = 5.4640E-03 seconds\n", + " Sampling source sites = 4.0981E-03 seconds\n", + " SEND/RECV source sites = 1.2606E-03 seconds\n", + " Time accumulating tallies = 1.2030E-04 seconds\n", + " Total time for finalization = 9.6554E-04 seconds\n", + " Total time elapsed = 6.7713E+00 seconds\n", + " Calculation Rate (inactive) = 30594.8 neutrons/second\n", + " Calculation Rate (active) = 18080.8 neutrons/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.15984 +/- 0.00411\n", + " k-effective (Track-length) = 1.16146 +/- 0.00457\n", + " k-effective (Absorption) = 1.16177 +/- 0.00380\n", + " Combined k-effective = 1.16105 +/- 0.00364\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tally Data Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the last statepoint file\n", + "sp = openmc.StatePoint('statepoint.50.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to the statepoint file, our simulation also created a summary file which encapsulates information about the materials and geometry. By default, a `Summary` object is automatically linked when a `StatePoint` is loaded. This is necessary for the `openmc.mgxs` module to properly process the tally data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by our multi-group cross sections. We simply have to load the tallies from the `StatePoint` into each object as follows and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the tallies from the statepoint into each MGXS object\n", + "total.load_from_statepoint(sp)\n", + "absorption.load_from_statepoint(sp)\n", + "scattering.load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Voila! Our multi-group cross sections are now ready to rock 'n roll!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting and Storing MGXS Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first inspect our total cross section by printing it to the screen." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-Group XS\n", + "\tReaction Type =\ttotal\n", + "\tDomain Type =\tcell\n", + "\tDomain ID =\t1\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t6.81e-01 +/- 2.69e-01%\n", + " Group 2 [0.0 - 0.625 eV]:\t1.40e+00 +/- 5.93e-01%\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "total.print_xs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the `openmc.mgxs` module uses [tally arithmetic](../examples/tally-arithmetic.rst) under-the-hood, the cross section is stored as a \"derived\" `Tally` object. This means that it can be queried and manipulated using all of the same methods supported for the `Tally` class in the OpenMC Python API. For example, we can construct a [Pandas](https://pandas.pydata.org/) `DataFrame` of the multi-group cross section data." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellgroup innuclidemeanstd. dev.
111total0.6677870.001802
012total1.2920130.007642
\n", + "
" + ], + "text/plain": [ + " cell group in nuclide mean std. dev.\n", + "1 1 1 total 0.667787 0.001802\n", + "0 1 2 total 1.292013 0.007642" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = scattering.get_pandas_dataframe()\n", + "df.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each multi-group cross section object can be easily exported to a variety of file formats, including CSV, Excel, and LaTeX for storage or data processing." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "absorption.export_xs_data(filename='absorption-xs', format='excel')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following code snippet shows how to export all three `MGXS` to the same HDF5 binary data store." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "total.build_hdf5_store(filename='mgxs', append=True)\n", + "absorption.build_hdf5_store(filename='mgxs', append=True)\n", + "scattering.build_hdf5_store(filename='mgxs', append=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparing MGXS with Tally Arithmetic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we illustrate how one can leverage OpenMC's [tally arithmetic](../examples/tally-arithmetic.rst) data processing feature with `MGXS` objects. The `openmc.mgxs` module uses tally arithmetic to compute multi-group cross sections with automated uncertainty propagation. Each `MGXS` object includes an `xs_tally` attribute which is a \"derived\" `Tally` based on the tallies needed to compute the cross section type of interest. These derived tallies can be used in subsequent tally arithmetic operations. For example, we can use tally artithmetic to confirm that the `TotalXS` is equal to the sum of the `AbsorptionXS` and `ScatterXS` objects." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellenergy low [eV]energy high [eV]nuclidescoremeanstd. dev.
010.0006.250000e-01total(((total / flux) - (absorption / flux)) - (sca...-1.110223e-150.011292
110.6252.000000e+07total(((total / flux) - (absorption / flux)) - (sca...7.771561e-160.002570
\n", + "
" + ], + "text/plain": [ + " cell energy low [eV] energy high [eV] nuclide \\\n", + "0 1 0.00e+00 6.25e-01 total \n", + "1 1 6.25e-01 2.00e+07 total \n", + "\n", + " score mean std. dev. \n", + "0 (((total / flux) - (absorption / flux)) - (sca... -1.11e-15 1.13e-02 \n", + "1 (((total / flux) - (absorption / flux)) - (sca... 7.77e-16 2.57e-03 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use tally arithmetic to compute the difference between the total, absorption and scattering\n", + "difference = total.xs_tally - absorption.xs_tally - scattering.xs_tally\n", + "\n", + "# The difference is a derived tally which can generate Pandas DataFrames for inspection\n", + "difference.get_pandas_dataframe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, we can use tally arithmetic to compute the ratio of `AbsorptionXS` and `ScatterXS` to the `TotalXS`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellenergy low [eV]energy high [eV]nuclidescoremeanstd. dev.
010.0006.250000e-01total((absorption / flux) / (total / flux))0.0761150.000649
110.6252.000000e+07total((absorption / flux) / (total / flux))0.0192630.000095
\n", + "
" + ], + "text/plain": [ + " cell energy low [eV] energy high [eV] nuclide \\\n", + "0 1 0.00e+00 6.25e-01 total \n", + "1 1 6.25e-01 2.00e+07 total \n", + "\n", + " score mean std. dev. \n", + "0 ((absorption / flux) / (total / flux)) 7.61e-02 6.49e-04 \n", + "1 ((absorption / flux) / (total / flux)) 1.93e-02 9.46e-05 " + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use tally arithmetic to compute the absorption-to-total MGXS ratio\n", + "absorption_to_total = absorption.xs_tally / total.xs_tally\n", + "\n", + "# The absorption-to-total ratio is a derived tally which can generate Pandas DataFrames for inspection\n", + "absorption_to_total.get_pandas_dataframe()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellenergy low [eV]energy high [eV]nuclidescoremeanstd. dev.
010.0006.250000e-01total((scatter / flux) / (total / flux))0.9238850.007736
110.6252.000000e+07total((scatter / flux) / (total / flux))0.9807370.003737
\n", + "
" + ], + "text/plain": [ + " cell energy low [eV] energy high [eV] nuclide \\\n", + "0 1 0.00e+00 6.25e-01 total \n", + "1 1 6.25e-01 2.00e+07 total \n", + "\n", + " score mean std. dev. \n", + "0 ((scatter / flux) / (total / flux)) 9.24e-01 7.74e-03 \n", + "1 ((scatter / flux) / (total / flux)) 9.81e-01 3.74e-03 " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use tally arithmetic to compute the scattering-to-total MGXS ratio\n", + "scattering_to_total = scattering.xs_tally / total.xs_tally\n", + "\n", + "# The scattering-to-total ratio is a derived tally which can generate Pandas DataFrames for inspection\n", + "scattering_to_total.get_pandas_dataframe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we sum the derived scatter-to-total and absorption-to-total ratios to confirm that they sum to unity." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellenergy low [eV]energy high [eV]nuclidescoremeanstd. dev.
010.0006.250000e-01total(((absorption / flux) / (total / flux)) + ((sc...1.00.007763
110.6252.000000e+07total(((absorption / flux) / (total / flux)) + ((sc...1.00.003739
\n", + "
" + ], + "text/plain": [ + " cell energy low [eV] energy high [eV] nuclide \\\n", + "0 1 0.00e+00 6.25e-01 total \n", + "1 1 6.25e-01 2.00e+07 total \n", + "\n", + " score mean std. dev. \n", + "0 (((absorption / flux) / (total / flux)) + ((sc... 1.00e+00 7.76e-03 \n", + "1 (((absorption / flux) / (total / flux)) + ((sc... 1.00e+00 3.74e-03 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use tally arithmetic to ensure that the absorption- and scattering-to-total MGXS ratios sum to unity\n", + "sum_ratio = absorption_to_total + scattering_to_total\n", + "\n", + "# The sum ratio is a derived tally which can generate Pandas DataFrames for inspection\n", + "sum_ratio.get_pandas_dataframe()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mgxs-part-ii.ipynb b/mgxs-part-ii.ipynb new file mode 100644 index 0000000..495f012 --- /dev/null +++ b/mgxs-part-ii.ipynb @@ -0,0 +1,2745 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multigroup Cross Section Generation Part II: Advanced Features\n", + "This IPython Notebook illustrates the use of the `openmc.mgxs` module to calculate multi-group cross sections for a heterogeneous fuel pin cell geometry. In particular, this Notebook illustrates the following features:\n", + "\n", + "* Creation of multi-group cross sections on a **heterogeneous geometry**\n", + "* Calculation of cross sections on a **nuclide-by-nuclide basis**\n", + "* The use of **[tally precision triggers](../io_formats/settings.rst#trigger-element)** with multi-group cross sections\n", + "* Built-in features for **energy condensation** in downstream data processing\n", + "* The use of the **`openmc.data`** module to plot continuous-energy vs. multi-group cross sections\n", + "* **Validation** of multi-group cross sections with **[OpenMOC](https://mit-crpg.github.io/OpenMOC/)**\n", + "\n", + "**Note:** This Notebook was created using [OpenMOC](https://mit-crpg.github.io/OpenMOC/) to verify the multi-group cross-sections generated by OpenMC. You must install [OpenMOC](https://mit-crpg.github.io/OpenMOC/) on your system in order to run this Notebook in its entirety. In addition, this Notebook illustrates the use of [Pandas](https://pandas.pydata.org/) `DataFrames` to containerize multi-group cross section data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use('seaborn-dark')\n", + "\n", + "import openmoc\n", + "\n", + "import openmc\n", + "import openmc.mgxs as mgxs\n", + "import openmc.data\n", + "from openmc.openmoc_compatible import get_openmoc_geometry\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we need to define materials that will be used in the problem. We'll create three distinct materials for water, clad and fuel." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 1.6% enriched fuel\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel.set_density('g/cm3', 10.31341)\n", + "fuel.add_nuclide('U235', 3.7503e-4)\n", + "fuel.add_nuclide('U238', 2.2625e-2)\n", + "fuel.add_nuclide('O16', 4.6007e-2)\n", + "\n", + "# borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_nuclide('H1', 4.9457e-2)\n", + "water.add_nuclide('O16', 2.4732e-2)\n", + "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide('Zr90', 7.2758e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our materials, we can now create a `Materials` object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Materials collection\n", + "materials_file = openmc.Materials([fuel, water, zircaloy])\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. Our problem will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces -- in this case two cylinders and six reflective planes." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create cylinders for the fuel and clad\n", + "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.39218)\n", + "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.45720)\n", + "\n", + "# Create box to surround the geometry\n", + "box = openmc.model.rectangular_prism(1.26, 1.26, boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now create cells that are defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "pin_cell_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "pin_cell_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "pin_cell_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius & box\n", + "pin_cell_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry with the pin cell universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "openmc_geometry = openmc.Geometry(pin_cell_universe)\n", + "\n", + "# Export to \"geometry.xml\"\n", + "openmc_geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we must define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 10,000 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 50\n", + "inactive = 10\n", + "particles = 10000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': True}\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-0.63, -0.63, -0.63, 0.63, 0.63, 0.63]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "# Activate tally precision triggers\n", + "settings_file.trigger_active = True\n", + "settings_file.trigger_max_batches = settings_file.batches * 4\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we are finally ready to make use of the `openmc.mgxs` module to generate multi-group cross sections! First, let's define \"coarse\" 2-group and \"fine\" 8-group structures using the built-in `EnergyGroups` class." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a \"coarse\" 2-group EnergyGroups object\n", + "coarse_groups = mgxs.EnergyGroups([0., 0.625, 20.0e6])\n", + "\n", + "# Instantiate a \"fine\" 8-group EnergyGroups object\n", + "fine_groups = mgxs.EnergyGroups([0., 0.058, 0.14, 0.28,\n", + " 0.625, 4.0, 5.53e3, 821.0e3, 20.0e6])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will instantiate a variety of `MGXS` objects needed to run an OpenMOC simulation to verify the accuracy of our cross sections. In particular, we define transport, fission, nu-fission, nu-scatter and chi cross sections for each of the three cells in the fuel pin with the 8-group structure as our energy groups." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Extract all Cells filled by Materials\n", + "openmc_cells = openmc_geometry.get_all_material_cells().values()\n", + "\n", + "# Create dictionary to store multi-group cross sections for all cells\n", + "xs_library = {}\n", + "\n", + "# Instantiate 8-group cross sections for each cell\n", + "for cell in openmc_cells:\n", + " xs_library[cell.id] = {}\n", + " xs_library[cell.id]['transport'] = mgxs.TransportXS(groups=fine_groups)\n", + " xs_library[cell.id]['fission'] = mgxs.FissionXS(groups=fine_groups)\n", + " xs_library[cell.id]['nu-fission'] = mgxs.FissionXS(groups=fine_groups, nu=True)\n", + " xs_library[cell.id]['nu-scatter'] = mgxs.ScatterMatrixXS(groups=fine_groups, nu=True)\n", + " xs_library[cell.id]['chi'] = mgxs.Chi(groups=fine_groups)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we showcase the use of OpenMC's [tally precision trigger](../io_formats/settings.rst#trigger-element) feature in conjunction with the `openmc.mgxs` module. In particular, we will assign a tally trigger of 1E-2 on the standard deviation for each of the tallies used to compute multi-group cross sections." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a tally trigger for +/- 0.01 on each tally used to compute the multi-group cross sections\n", + "tally_trigger = openmc.Trigger('std_dev', 1e-2)\n", + "\n", + "# Add the tally trigger to each of the multi-group cross section tallies\n", + "for cell in openmc_cells:\n", + " for mgxs_type in xs_library[cell.id]:\n", + " xs_library[cell.id][mgxs_type].tally_trigger = tally_trigger" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we must loop over all cells to set the cross section domains to the various cells - fuel, clad and moderator - included in the geometry. In addition, we will set each cross section to tally cross sections on a per-nuclide basis through the use of the `MGXS` class' boolean `by_nuclide` instance attribute. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=53.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=21.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=3.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=4.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=41.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=15.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Instantiate an empty Tallies object\n", + "tallies_file = openmc.Tallies()\n", + "\n", + "# Iterate over all cells and cross section types\n", + "for cell in openmc_cells:\n", + " for rxn_type in xs_library[cell.id]:\n", + "\n", + " # Set the cross sections domain to the cell\n", + " xs_library[cell.id][rxn_type].domain = cell\n", + " \n", + " # Tally cross sections by nuclide\n", + " xs_library[cell.id][rxn_type].by_nuclide = True\n", + " \n", + " # Add OpenMC tallies to the tallies file for XML generation\n", + " for tally in xs_library[cell.id][rxn_type].tallies.values():\n", + " tallies_file.append(tally, merge=True)\n", + "\n", + "# Export to \"tallies.xml\"\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we a have a complete set of inputs, so we can go ahead and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2019 MIT and OpenMC contributors\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.11.0-dev\n", + " Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n", + " Date/Time | 2019-07-19 07:08:16\n", + " OpenMP Threads | 4\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U235 from /opt/data/hdf5/nndc_hdf5_v15/U235.h5\n", + " Reading U238 from /opt/data/hdf5/nndc_hdf5_v15/U238.h5\n", + " Reading O16 from /opt/data/hdf5/nndc_hdf5_v15/O16.h5\n", + " Reading H1 from /opt/data/hdf5/nndc_hdf5_v15/H1.h5\n", + " Reading Zr90 from /opt/data/hdf5/nndc_hdf5_v15/Zr90.h5\n", + " Maximum neutron transport energy: 20000000.000000 eV for U235\n", + " Reading tallies XML file...\n", + " Writing summary.h5 file...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.20332\n", + " 2/1 1.22209\n", + " 3/1 1.24322\n", + " 4/1 1.21622\n", + " 5/1 1.25850\n", + " 6/1 1.22581\n", + " 7/1 1.21118\n", + " 8/1 1.23377\n", + " 9/1 1.24254\n", + " 10/1 1.21241\n", + " 11/1 1.21042\n", + " 12/1 1.23539 1.22290 +/- 0.01249\n", + " 13/1 1.22436 1.22339 +/- 0.00723\n", + " 14/1 1.22888 1.22476 +/- 0.00529\n", + " 15/1 1.22553 1.22491 +/- 0.00410\n", + " 16/1 1.24194 1.22775 +/- 0.00439\n", + " 17/1 1.24755 1.23058 +/- 0.00466\n", + " 18/1 1.21117 1.22815 +/- 0.00471\n", + " 19/1 1.22530 1.22784 +/- 0.00417\n", + " 20/1 1.20762 1.22582 +/- 0.00424\n", + " 21/1 1.20377 1.22381 +/- 0.00433\n", + " 22/1 1.24305 1.22541 +/- 0.00426\n", + " 23/1 1.22434 1.22533 +/- 0.00392\n", + " 24/1 1.22937 1.22562 +/- 0.00364\n", + " 25/1 1.22458 1.22555 +/- 0.00339\n", + " 26/1 1.18978 1.22332 +/- 0.00388\n", + " 27/1 1.20582 1.22229 +/- 0.00379\n", + " 28/1 1.22719 1.22256 +/- 0.00358\n", + " 29/1 1.21307 1.22206 +/- 0.00343\n", + " 30/1 1.20915 1.22141 +/- 0.00331\n", + " 31/1 1.22799 1.22173 +/- 0.00317\n", + " 32/1 1.21251 1.22131 +/- 0.00305\n", + " 33/1 1.20540 1.22062 +/- 0.00299\n", + " 34/1 1.20052 1.21978 +/- 0.00299\n", + " 35/1 1.24552 1.22081 +/- 0.00304\n", + " 36/1 1.21685 1.22066 +/- 0.00293\n", + " 37/1 1.22395 1.22078 +/- 0.00282\n", + " 38/1 1.22379 1.22089 +/- 0.00272\n", + " 39/1 1.20951 1.22049 +/- 0.00265\n", + " 40/1 1.25199 1.22154 +/- 0.00277\n", + " 41/1 1.23243 1.22190 +/- 0.00270\n", + " 42/1 1.20973 1.22152 +/- 0.00264\n", + " 43/1 1.24682 1.22228 +/- 0.00268\n", + " 44/1 1.20694 1.22183 +/- 0.00263\n", + " 45/1 1.22196 1.22183 +/- 0.00256\n", + " 46/1 1.20687 1.22142 +/- 0.00252\n", + " 47/1 1.22023 1.22139 +/- 0.00245\n", + " 48/1 1.22204 1.22140 +/- 0.00239\n", + " 49/1 1.22077 1.22139 +/- 0.00232\n", + " 50/1 1.23166 1.22164 +/- 0.00228\n", + " Triggers unsatisfied, max unc./thresh. is 1.17623 for flux in tally 53\n", + " The estimated number of batches is 66\n", + " Creating state point statepoint.050.h5...\n", + " 51/1 1.20071 1.22113 +/- 0.00228\n", + " Triggers unsatisfied, max unc./thresh. is 1.26577 for flux in tally 53\n", + " The estimated number of batches is 76\n", + " 52/1 1.21423 1.22097 +/- 0.00223\n", + " Triggers unsatisfied, max unc./thresh. is 1.24 for flux in tally 53\n", + " The estimated number of batches is 75\n", + " 53/1 1.25595 1.22178 +/- 0.00233\n", + " Triggers unsatisfied, max unc./thresh. is 1.2112 for flux in tally 53\n", + " The estimated number of batches is 74\n", + " 54/1 1.21806 1.22170 +/- 0.00227\n", + " Triggers unsatisfied, max unc./thresh. is 1.18484 for flux in tally 53\n", + " The estimated number of batches is 72\n", + " 55/1 1.22911 1.22186 +/- 0.00223\n", + " Triggers unsatisfied, max unc./thresh. is 1.1596 for flux in tally 53\n", + " The estimated number of batches is 71\n", + " 56/1 1.23054 1.22205 +/- 0.00219\n", + " Triggers unsatisfied, max unc./thresh. is 1.13453 for flux in tally 53\n", + " The estimated number of batches is 70\n", + " 57/1 1.19384 1.22145 +/- 0.00222\n", + " Triggers unsatisfied, max unc./thresh. is 1.11914 for flux in tally 53\n", + " The estimated number of batches is 69\n", + " 58/1 1.20625 1.22114 +/- 0.00220\n", + " Triggers unsatisfied, max unc./thresh. is 1.11471 for flux in tally 53\n", + " The estimated number of batches is 70\n", + " 59/1 1.21977 1.22111 +/- 0.00216\n", + " Triggers unsatisfied, max unc./thresh. is 1.10334 for flux in tally 53\n", + " The estimated number of batches is 70\n", + " 60/1 1.20813 1.22085 +/- 0.00213\n", + " Triggers unsatisfied, max unc./thresh. is 1.09813 for flux in tally 53\n", + " The estimated number of batches is 71\n", + " 61/1 1.22077 1.22085 +/- 0.00209\n", + " Triggers unsatisfied, max unc./thresh. is 1.10221 for flux in tally 53\n", + " The estimated number of batches is 72\n", + " 62/1 1.21956 1.22082 +/- 0.00205\n", + " Triggers unsatisfied, max unc./thresh. is 1.11395 for flux in tally 53\n", + " The estimated number of batches is 75\n", + " 63/1 1.22360 1.22087 +/- 0.00201\n", + " Triggers unsatisfied, max unc./thresh. is 1.09283 for flux in tally 53\n", + " The estimated number of batches is 74\n", + " 64/1 1.23955 1.22122 +/- 0.00200\n", + " Triggers unsatisfied, max unc./thresh. is 1.07416 for flux in tally 53\n", + " The estimated number of batches is 73\n", + " 65/1 1.21143 1.22104 +/- 0.00197\n", + " Triggers unsatisfied, max unc./thresh. is 1.06461 for flux in tally 53\n", + " The estimated number of batches is 73\n", + " 66/1 1.21791 1.22099 +/- 0.00194\n", + " Triggers unsatisfied, max unc./thresh. is 1.13207 for flux in tally 53\n", + " The estimated number of batches is 82\n", + " 67/1 1.24897 1.22148 +/- 0.00196\n", + " Triggers unsatisfied, max unc./thresh. is 1.11277 for flux in tally 53\n", + " The estimated number of batches is 81\n", + " 68/1 1.22221 1.22149 +/- 0.00193\n", + " Triggers unsatisfied, max unc./thresh. is 1.09514 for flux in tally 53\n", + " The estimated number of batches is 80\n", + " 69/1 1.25627 1.22208 +/- 0.00199\n", + " Triggers unsatisfied, max unc./thresh. is 1.07653 for flux in tally 53\n", + " The estimated number of batches is 79\n", + " 70/1 1.21493 1.22196 +/- 0.00196\n", + " Triggers unsatisfied, max unc./thresh. is 1.12831 for flux in tally 53\n", + " The estimated number of batches is 87\n", + " 71/1 1.23406 1.22216 +/- 0.00193\n", + " Triggers unsatisfied, max unc./thresh. is 1.11005 for flux in tally 53\n", + " The estimated number of batches is 86\n", + " 72/1 1.23842 1.22242 +/- 0.00192\n", + " Triggers unsatisfied, max unc./thresh. is 1.09352 for flux in tally 53\n", + " The estimated number of batches is 85\n", + " 73/1 1.24542 1.22279 +/- 0.00193\n", + " Triggers unsatisfied, max unc./thresh. is 1.08766 for flux in tally 53\n", + " The estimated number of batches is 85\n", + " 74/1 1.21314 1.22263 +/- 0.00190\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Triggers unsatisfied, max unc./thresh. is 1.07419 for flux in tally 53\n", + " The estimated number of batches is 84\n", + " 75/1 1.26484 1.22328 +/- 0.00198\n", + " Triggers unsatisfied, max unc./thresh. is 1.06788 for flux in tally 53\n", + " The estimated number of batches is 85\n", + " 76/1 1.22243 1.22327 +/- 0.00195\n", + " Triggers unsatisfied, max unc./thresh. is 1.05164 for flux in tally 53\n", + " The estimated number of batches is 83\n", + " 77/1 1.21865 1.22320 +/- 0.00192\n", + " Triggers unsatisfied, max unc./thresh. is 1.04022 for flux in tally 53\n", + " The estimated number of batches is 83\n", + " 78/1 1.23500 1.22338 +/- 0.00190\n", + " Triggers unsatisfied, max unc./thresh. is 1.0275 for flux in tally 53\n", + " The estimated number of batches is 82\n", + " 79/1 1.22125 1.22334 +/- 0.00187\n", + " Triggers unsatisfied, max unc./thresh. is 1.0283 for flux in tally 53\n", + " The estimated number of batches is 83\n", + " 80/1 1.23793 1.22355 +/- 0.00186\n", + " Triggers unsatisfied, max unc./thresh. is 1.01363 for flux in tally 53\n", + " The estimated number of batches is 82\n", + " 81/1 1.24238 1.22382 +/- 0.00185\n", + " Triggers unsatisfied, max unc./thresh. is 1.01172 for flux in tally 53\n", + " The estimated number of batches is 83\n", + " 82/1 1.23493 1.22397 +/- 0.00183\n", + " Triggers satisfied for batch 82\n", + " Creating state point statepoint.082.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 9.5644e-01 seconds\n", + " Reading cross sections = 9.0579e-01 seconds\n", + " Total time in simulation = 9.9887e+01 seconds\n", + " Time in transport only = 9.9333e+01 seconds\n", + " Time in inactive batches = 5.4841e+00 seconds\n", + " Time in active batches = 9.4403e+01 seconds\n", + " Time synchronizing fission bank = 7.3998e-02 seconds\n", + " Sampling source sites = 5.9021e-02 seconds\n", + " SEND/RECV source sites = 1.4787e-02 seconds\n", + " Time accumulating tallies = 1.2234e-03 seconds\n", + " Total time for finalization = 2.8416e-02 seconds\n", + " Total time elapsed = 1.0094e+02 seconds\n", + " Calculation Rate (inactive) = 18234.5 particles/second\n", + " Calculation Rate (active) = 7626.89 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.22348 +/- 0.00169\n", + " k-effective (Track-length) = 1.22397 +/- 0.00183\n", + " k-effective (Absorption) = 1.22467 +/- 0.00117\n", + " Combined k-effective = 1.22448 +/- 0.00108\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tally Data Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the last statepoint file\n", + "sp = openmc.StatePoint('statepoint.082.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by our multi-group cross sections. We simply have to load the tallies from the `StatePoint` into each object as follows and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Iterate over all cells and cross section types\n", + "for cell in openmc_cells:\n", + " for rxn_type in xs_library[cell.id]:\n", + " xs_library[cell.id][rxn_type].load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's it! Our multi-group cross sections are now ready for the big spotlight. This time we have cross sections in three distinct spatial zones - fuel, clad and moderator - on a per-nuclide basis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting and Storing MGXS Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first inspect one of our cross sections by printing it to the screen as a microscopic cross section in units of barns." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-Group XS\n", + "\tReaction Type =\tnu-fission\n", + "\tDomain Type =\tcell\n", + "\tDomain ID =\t1\n", + "\tNuclide =\tU235\n", + "\tCross Sections [barns]:\n", + " Group 1 [821000.0 - 20000000.0eV]:\t3.30e+00 +/- 2.14e-01%\n", + " Group 2 [5530.0 - 821000.0 eV]:\t3.96e+00 +/- 1.33e-01%\n", + " Group 3 [4.0 - 5530.0 eV]:\t5.50e+01 +/- 2.29e-01%\n", + " Group 4 [0.625 - 4.0 eV]:\t8.85e+01 +/- 3.10e-01%\n", + " Group 5 [0.28 - 0.625 eV]:\t2.90e+02 +/- 3.94e-01%\n", + " Group 6 [0.14 - 0.28 eV]:\t4.49e+02 +/- 4.12e-01%\n", + " Group 7 [0.058 - 0.14 eV]:\t6.87e+02 +/- 3.01e-01%\n", + " Group 8 [0.0 - 0.058 eV]:\t1.44e+03 +/- 2.79e-01%\n", + "\n", + "\tNuclide =\tU238\n", + "\tCross Sections [barns]:\n", + " Group 1 [821000.0 - 20000000.0eV]:\t1.06e+00 +/- 2.53e-01%\n", + " Group 2 [5530.0 - 821000.0 eV]:\t1.21e-03 +/- 2.60e-01%\n", + " Group 3 [4.0 - 5530.0 eV]:\t5.73e-04 +/- 2.93e+00%\n", + " Group 4 [0.625 - 4.0 eV]:\t6.54e-06 +/- 2.72e-01%\n", + " Group 5 [0.28 - 0.625 eV]:\t1.07e-05 +/- 3.83e-01%\n", + " Group 6 [0.14 - 0.28 eV]:\t1.55e-05 +/- 4.13e-01%\n", + " Group 7 [0.058 - 0.14 eV]:\t2.30e-05 +/- 3.01e-01%\n", + " Group 8 [0.0 - 0.058 eV]:\t4.24e-05 +/- 2.79e-01%\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "nufission = xs_library[fuel_cell.id]['nu-fission']\n", + "nufission.print_xs(xs_type='micro', nuclides=['U235', 'U238'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our multi-group cross sections are capable of summing across all nuclides to provide us with macroscopic cross sections as well." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-Group XS\n", + "\tReaction Type =\tnu-fission\n", + "\tDomain Type =\tcell\n", + "\tDomain ID =\t1\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [821000.0 - 20000000.0eV]:\t2.52e-02 +/- 2.41e-01%\n", + " Group 2 [5530.0 - 821000.0 eV]:\t1.51e-03 +/- 1.31e-01%\n", + " Group 3 [4.0 - 5530.0 eV]:\t2.07e-02 +/- 2.29e-01%\n", + " Group 4 [0.625 - 4.0 eV]:\t3.32e-02 +/- 3.10e-01%\n", + " Group 5 [0.28 - 0.625 eV]:\t1.09e-01 +/- 3.94e-01%\n", + " Group 6 [0.14 - 0.28 eV]:\t1.69e-01 +/- 4.12e-01%\n", + " Group 7 [0.058 - 0.14 eV]:\t2.58e-01 +/- 3.01e-01%\n", + " Group 8 [0.0 - 0.058 eV]:\t5.40e-01 +/- 2.79e-01%\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "nufission = xs_library[fuel_cell.id]['nu-fission']\n", + "nufission.print_xs(xs_type='macro', nuclides='sum')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Although a printed report is nice, it is not scalable or flexible. Let's extract the microscopic cross section data for the moderator as a [Pandas](https://pandas.pydata.org/) `DataFrame` ." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellgroup ingroup outnuclidemeanstd. dev.
126311H10.2339910.003752
127311O161.5692880.006360
124312H11.5872790.003098
125312O160.2855990.001422
122313H10.0104820.000220
123313O160.0000000.000000
120314H10.0000090.000006
121314O160.0000000.000000
118315H10.0000050.000005
119315O160.0000000.000000
\n", + "
" + ], + "text/plain": [ + " cell group in group out nuclide mean std. dev.\n", + "126 3 1 1 H1 0.233991 0.003752\n", + "127 3 1 1 O16 1.569288 0.006360\n", + "124 3 1 2 H1 1.587279 0.003098\n", + "125 3 1 2 O16 0.285599 0.001422\n", + "122 3 1 3 H1 0.010482 0.000220\n", + "123 3 1 3 O16 0.000000 0.000000\n", + "120 3 1 4 H1 0.000009 0.000006\n", + "121 3 1 4 O16 0.000000 0.000000\n", + "118 3 1 5 H1 0.000005 0.000005\n", + "119 3 1 5 O16 0.000000 0.000000" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nuscatter = xs_library[moderator_cell.id]['nu-scatter']\n", + "df = nuscatter.get_pandas_dataframe(xs_type='micro')\n", + "df.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we illustate how one can easily take multi-group cross sections and condense them down to a coarser energy group structure. The `MGXS` class includes a `get_condensed_xs(...)` method which takes an `EnergyGroups` parameter with a coarse(r) group structure and returns a new `MGXS` condensed to the coarse groups. We illustrate this process below using the 2-group structure created earlier." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the 8-group transport cross section for the fuel\n", + "fine_xs = xs_library[fuel_cell.id]['transport']\n", + "\n", + "# Condense to the 2-group structure\n", + "condensed_xs = fine_xs.get_condensed_xs(coarse_groups)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Group condensation is as simple as that! We now have a new coarse 2-group `TransportXS` in addition to our original 8-group `TransportXS`. Let's inspect the 2-group `TransportXS` by printing it to the screen and extracting a Pandas `DataFrame` as we have already learned how to do." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-Group XS\n", + "\tReaction Type =\ttransport\n", + "\tDomain Type =\tcell\n", + "\tDomain ID =\t1\n", + "\tNuclide =\tU235\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t7.79e-03 +/- 2.12e-01%\n", + " Group 2 [0.0 - 0.625 eV]:\t1.82e-01 +/- 1.92e-01%\n", + "\n", + "\tNuclide =\tU238\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t2.17e-01 +/- 1.12e-01%\n", + " Group 2 [0.0 - 0.625 eV]:\t2.53e-01 +/- 1.89e-01%\n", + "\n", + "\tNuclide =\tO16\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t1.45e-01 +/- 1.12e-01%\n", + " Group 2 [0.0 - 0.625 eV]:\t1.74e-01 +/- 2.03e-01%\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "condensed_xs.print_xs()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellgroup innuclidemeanstd. dev.
311U23520.7630620.044093
411U2389.5790860.010757
511O163.1572740.003531
012U235485.3490360.930937
112U23811.1991670.021167
212O163.7883830.007676
\n", + "
" + ], + "text/plain": [ + " cell group in nuclide mean std. dev.\n", + "3 1 1 U235 20.763062 0.044093\n", + "4 1 1 U238 9.579086 0.010757\n", + "5 1 1 O16 3.157274 0.003531\n", + "0 1 2 U235 485.349036 0.930937\n", + "1 1 2 U238 11.199167 0.021167\n", + "2 1 2 O16 3.788383 0.007676" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = condensed_xs.get_pandas_dataframe(xs_type='micro')\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verification with OpenMOC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's verify our cross sections using OpenMOC. First, we construct an equivalent OpenMOC geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an OpenMOC Geometry from the OpenMC Geometry\n", + "openmoc_geometry = get_openmoc_geometry(sp.summary.geometry)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we we can inject the multi-group cross sections into the equivalent fuel pin cell OpenMOC geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Get all OpenMOC cells in the gometry\n", + "openmoc_cells = openmoc_geometry.getRootUniverse().getAllCells()\n", + "\n", + "# Inject multi-group cross sections into OpenMOC Materials\n", + "for cell_id, cell in openmoc_cells.items():\n", + " \n", + " # Ignore the root cell\n", + " if cell.getName() == 'root cell':\n", + " continue\n", + " \n", + " # Get a reference to the Material filling this Cell\n", + " openmoc_material = cell.getFillMaterial()\n", + " \n", + " # Set the number of energy groups for the Material\n", + " openmoc_material.setNumEnergyGroups(fine_groups.num_groups)\n", + " \n", + " # Extract the appropriate cross section objects for this cell\n", + " transport = xs_library[cell_id]['transport']\n", + " nufission = xs_library[cell_id]['nu-fission']\n", + " nuscatter = xs_library[cell_id]['nu-scatter']\n", + " chi = xs_library[cell_id]['chi']\n", + " \n", + " # Inject NumPy arrays of cross section data into the Material\n", + " # NOTE: Sum across nuclides to get macro cross sections needed by OpenMOC\n", + " openmoc_material.setSigmaT(transport.get_xs(nuclides='sum').flatten())\n", + " openmoc_material.setNuSigmaF(nufission.get_xs(nuclides='sum').flatten())\n", + " openmoc_material.setSigmaS(nuscatter.get_xs(nuclides='sum').flatten())\n", + " openmoc_material.setChi(chi.get_xs(nuclides='sum').flatten())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are now ready to run OpenMOC to verify our cross-sections from OpenMC." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Initializing a default angular quadrature...\n", + "[ NORMAL ] Initializing 2D tracks...\n", + "[ NORMAL ] Initializing 2D tracks reflections...\n", + "[ NORMAL ] Initializing 2D tracks array...\n", + "[ NORMAL ] Ray tracing for 2D track segmentation...\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 0.09 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 10.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 19.94 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 29.87 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 39.80 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 49.72 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 59.65 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 69.58 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 79.50 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 89.43 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 100.00 %\n", + "[ NORMAL ] Initializing FSR lookup vectors\n", + "[ NORMAL ] Total number of FSRs 3\n", + "[ RESULT ] Total Track Generation & Segmentation Time...........2.5566E-02 sec\n", + "[ NORMAL ] Initializing MOC eigenvalue solver...\n", + "[ NORMAL ] Initializing solver arrays...\n", + "[ NORMAL ] Centering segments around FSR centroid...\n", + "[ NORMAL ] Max boundary angular flux storage per domain = 0.42 MB\n", + "[ NORMAL ] Max scalar flux storage per domain = 0.00 MB\n", + "[ NORMAL ] Max source storage per domain = 0.00 MB\n", + "[ NORMAL ] Number of azimuthal angles = 128\n", + "[ NORMAL ] Azimuthal ray spacing = 0.100000\n", + "[ NORMAL ] Number of polar angles = 6\n", + "[ NORMAL ] Source type = Flat\n", + "[ NORMAL ] MOC transport undamped\n", + "[ NORMAL ] CMFD acceleration: OFF\n", + "[ NORMAL ] Using 1 threads\n", + "[ NORMAL ] Computing the eigenvalue...\n", + "[ NORMAL ] Iteration 0: k_eff = 0.423133 res = 5.671E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... -57686 D.R. = 0.00\n", + "[ NORMAL ] Iteration 1: k_eff = 0.475953 res = 2.442E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 5282 D.R. = 4.31\n", + "[ NORMAL ] Iteration 2: k_eff = 0.491468 res = 4.764E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1551 D.R. = 1.95\n", + "[ NORMAL ] Iteration 3: k_eff = 0.487446 res = 2.253E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -402 D.R. = 0.47\n", + "[ NORMAL ] Iteration 4: k_eff = 0.483930 res = 6.957E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... -351 D.R. = 0.31\n", + "[ NORMAL ] Iteration 5: k_eff = 0.477280 res = 3.902E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -665 D.R. = 5.61\n", + "[ NORMAL ] Iteration 6: k_eff = 0.468938 res = 3.161E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -834 D.R. = 0.81\n", + "[ NORMAL ] Iteration 7: k_eff = 0.460319 res = 2.480E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -861 D.R. = 0.78\n", + "[ NORMAL ] Iteration 8: k_eff = 0.450591 res = 9.377E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... -972 D.R. = 0.38\n", + "[ NORMAL ] Iteration 9: k_eff = 0.441377 res = 3.085E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -921 D.R. = 3.29\n", + "[ NORMAL ] Iteration 10: k_eff = 0.431990 res = 1.028E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -938 D.R. = 0.33\n", + "[ NORMAL ] Iteration 11: k_eff = 0.422932 res = 1.180E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -905 D.R. = 1.15\n", + "[ NORMAL ] Iteration 12: k_eff = 0.414487 res = 1.633E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -844 D.R. = 1.38\n", + "[ NORMAL ] Iteration 13: k_eff = 0.406708 res = 1.754E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -777 D.R. = 1.07\n", + "[ NORMAL ] Iteration 14: k_eff = 0.399378 res = 5.021E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -732 D.R. = 2.86\n", + "[ NORMAL ] Iteration 15: k_eff = 0.393067 res = 9.074E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... -631 D.R. = 0.18\n", + "[ NORMAL ] Iteration 16: k_eff = 0.387427 res = 4.840E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... -564 D.R. = 0.53\n", + "[ NORMAL ] Iteration 17: k_eff = 0.382668 res = 2.299E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -475 D.R. = 4.75\n", + "[ NORMAL ] Iteration 18: k_eff = 0.378741 res = 1.573E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -392 D.R. = 0.68\n", + "[ NORMAL ] Iteration 19: k_eff = 0.375642 res = 7.017E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -309 D.R. = 4.46\n", + "[ NORMAL ] Iteration 20: k_eff = 0.373489 res = 4.053E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -215 D.R. = 0.58\n", + "[ NORMAL ] Iteration 21: k_eff = 0.372357 res = 4.235E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -113 D.R. = 1.04\n", + "[ NORMAL ] Iteration 22: k_eff = 0.371974 res = 6.352E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -38 D.R. = 1.50\n", + "[ NORMAL ] Iteration 23: k_eff = 0.372581 res = 3.267E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 60 D.R. = 0.51\n", + "[ NORMAL ] Iteration 24: k_eff = 0.374056 res = 1.573E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 147 D.R. = 0.48\n", + "[ NORMAL ] Iteration 25: k_eff = 0.376384 res = 3.630E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 232 D.R. = 2.31\n", + "[ NORMAL ] Iteration 26: k_eff = 0.379563 res = 2.420E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 317 D.R. = 0.07\n", + "[ NORMAL ] Iteration 27: k_eff = 0.383583 res = 3.146E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 401 D.R. = 13.00\n", + "[ NORMAL ] Iteration 28: k_eff = 0.388380 res = 1.089E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 479 D.R. = 0.35\n", + "[ NORMAL ] Iteration 29: k_eff = 0.393938 res = 6.049E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 555 D.R. = 5.56\n", + "[ NORMAL ] Iteration 30: k_eff = 0.400234 res = 3.267E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 629 D.R. = 0.54\n", + "[ NORMAL ] Iteration 31: k_eff = 0.407235 res = 2.420E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 700 D.R. = 0.74\n", + "[ NORMAL ] Iteration 32: k_eff = 0.414884 res = 1.815E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 764 D.R. = 0.75\n", + "[ NORMAL ] Iteration 33: k_eff = 0.423172 res = 7.259E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 828 D.R. = 0.40\n", + "[ NORMAL ] Iteration 34: k_eff = 0.432051 res = 6.049E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 887 D.R. = 8.33\n", + "[ NORMAL ] Iteration 35: k_eff = 0.441471 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 942 D.R. = 0.96\n", + "[ NORMAL ] Iteration 36: k_eff = 0.451430 res = 2.662E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 995 D.R. = 0.46\n", + "[ NORMAL ] Iteration 37: k_eff = 0.461853 res = 8.227E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1042 D.R. = 3.09\n", + "[ NORMAL ] Iteration 38: k_eff = 0.472730 res = 5.928E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1087 D.R. = 0.72\n", + "[ NORMAL ] Iteration 39: k_eff = 0.484006 res = 2.299E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1127 D.R. = 0.39\n", + "[ NORMAL ] Iteration 40: k_eff = 0.495653 res = 2.299E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1164 D.R. = 1.00\n", + "[ NORMAL ] Iteration 41: k_eff = 0.507634 res = 7.017E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1198 D.R. = 3.05\n", + "[ NORMAL ] Iteration 42: k_eff = 0.519914 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1227 D.R. = 0.28\n", + "[ NORMAL ] Iteration 43: k_eff = 0.532458 res = 1.089E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1254 D.R. = 0.56\n", + "[ NORMAL ] Iteration 44: k_eff = 0.545234 res = 6.291E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1277 D.R. = 5.78\n", + "[ NORMAL ] Iteration 45: k_eff = 0.558210 res = 3.509E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1297 D.R. = 0.56\n", + "[ NORMAL ] Iteration 46: k_eff = 0.571353 res = 3.025E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1314 D.R. = 0.86\n", + "[ NORMAL ] Iteration 47: k_eff = 0.584635 res = 7.259E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 1328 D.R. = 0.24\n", + "[ NORMAL ] Iteration 48: k_eff = 0.598027 res = 4.961E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1339 D.R. = 6.83\n", + "[ NORMAL ] Iteration 49: k_eff = 0.611500 res = 9.014E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1347 D.R. = 1.82\n", + "[ NORMAL ] Iteration 50: k_eff = 0.625029 res = 5.203E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1352 D.R. = 0.58\n", + "[ NORMAL ] Iteration 51: k_eff = 0.638590 res = 1.512E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1356 D.R. = 0.29\n", + "[ NORMAL ] Iteration 52: k_eff = 0.652158 res = 2.359E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1356 D.R. = 1.56\n", + "[ NORMAL ] Iteration 53: k_eff = 0.665710 res = 4.598E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1355 D.R. = 1.95\n", + "[ NORMAL ] Iteration 54: k_eff = 0.679228 res = 2.783E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1351 D.R. = 0.61\n", + "[ NORMAL ] Iteration 55: k_eff = 0.692689 res = 2.117E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1346 D.R. = 0.76\n", + "[ NORMAL ] Iteration 56: k_eff = 0.706075 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1338 D.R. = 0.91\n", + "[ NORMAL ] Iteration 57: k_eff = 0.719370 res = 5.505E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1329 D.R. = 2.84\n", + "[ NORMAL ] Iteration 58: k_eff = 0.732556 res = 2.238E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1318 D.R. = 0.41\n", + "[ NORMAL ] Iteration 59: k_eff = 0.745619 res = 7.864E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 1306 D.R. = 0.35\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Iteration 60: k_eff = 0.758546 res = 4.477E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1292 D.R. = 5.69\n", + "[ NORMAL ] Iteration 61: k_eff = 0.771323 res = 4.658E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1277 D.R. = 1.04\n", + "[ NORMAL ] Iteration 62: k_eff = 0.783939 res = 9.679E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 1261 D.R. = 0.21\n", + "[ NORMAL ] Iteration 63: k_eff = 0.796383 res = 4.235E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 1244 D.R. = 0.44\n", + "[ NORMAL ] Iteration 64: k_eff = 0.808646 res = 9.074E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 1226 D.R. = 2.14\n", + "[ NORMAL ] Iteration 65: k_eff = 0.820719 res = 6.412E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1207 D.R. = 7.07\n", + "[ NORMAL ] Iteration 66: k_eff = 0.832594 res = 2.420E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 1187 D.R. = 0.04\n", + "[ NORMAL ] Iteration 67: k_eff = 0.844264 res = 2.299E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1167 D.R. = 9.50\n", + "[ NORMAL ] Iteration 68: k_eff = 0.855724 res = 5.928E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1146 D.R. = 2.58\n", + "[ NORMAL ] Iteration 69: k_eff = 0.866968 res = 6.049E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1124 D.R. = 1.02\n", + "[ NORMAL ] Iteration 70: k_eff = 0.877992 res = 2.722E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1102 D.R. = 0.45\n", + "[ NORMAL ] Iteration 71: k_eff = 0.888792 res = 1.633E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1079 D.R. = 0.60\n", + "[ NORMAL ] Iteration 72: k_eff = 0.899364 res = 2.117E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1057 D.R. = 1.30\n", + "[ NORMAL ] Iteration 73: k_eff = 0.909708 res = 3.327E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1034 D.R. = 1.57\n", + "[ NORMAL ] Iteration 74: k_eff = 0.919819 res = 4.477E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1011 D.R. = 1.35\n", + "[ NORMAL ] Iteration 75: k_eff = 0.929699 res = 3.569E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 987 D.R. = 0.80\n", + "[ NORMAL ] Iteration 76: k_eff = 0.939346 res = 4.840E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 964 D.R. = 0.14\n", + "[ NORMAL ] Iteration 77: k_eff = 0.948758 res = 4.840E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 941 D.R. = 1.00\n", + "[ NORMAL ] Iteration 78: k_eff = 0.957938 res = 6.049E-10 delta-k (pcm) =\n", + "[ NORMAL ] ... 917 D.R. = 0.12\n", + "[ NORMAL ] Iteration 79: k_eff = 0.966885 res = 2.057E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 894 D.R. = 34.00\n", + "[ NORMAL ] Iteration 80: k_eff = 0.975601 res = 4.235E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 871 D.R. = 2.06\n", + "[ NORMAL ] Iteration 81: k_eff = 0.984087 res = 5.868E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 848 D.R. = 1.39\n", + "[ NORMAL ] Iteration 82: k_eff = 0.992344 res = 7.259E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 825 D.R. = 0.12\n", + "[ NORMAL ] Iteration 83: k_eff = 1.000375 res = 1.512E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 803 D.R. = 2.08\n", + "[ NORMAL ] Iteration 84: k_eff = 1.008182 res = 7.864E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 780 D.R. = 0.52\n", + "[ NORMAL ] Iteration 85: k_eff = 1.015768 res = 7.259E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 758 D.R. = 0.92\n", + "[ NORMAL ] Iteration 86: k_eff = 1.023136 res = 3.025E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 736 D.R. = 0.42\n", + "[ NORMAL ] Iteration 87: k_eff = 1.030288 res = 1.210E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 715 D.R. = 4.00\n", + "[ NORMAL ] Iteration 88: k_eff = 1.037228 res = 3.690E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 693 D.R. = 3.05\n", + "[ NORMAL ] Iteration 89: k_eff = 1.043960 res = 5.203E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 673 D.R. = 1.41\n", + "[ NORMAL ] Iteration 90: k_eff = 1.050486 res = 6.231E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 652 D.R. = 1.20\n", + "[ NORMAL ] Iteration 91: k_eff = 1.056812 res = 6.775E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 632 D.R. = 1.09\n", + "[ NORMAL ] Iteration 92: k_eff = 1.062939 res = 2.964E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 612 D.R. = 0.44\n", + "[ NORMAL ] Iteration 93: k_eff = 1.068872 res = 5.505E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 593 D.R. = 1.86\n", + "[ NORMAL ] Iteration 94: k_eff = 1.074616 res = 4.235E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 574 D.R. = 0.08\n", + "[ NORMAL ] Iteration 95: k_eff = 1.080173 res = 2.541E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 555 D.R. = 6.00\n", + "[ NORMAL ] Iteration 96: k_eff = 1.085550 res = 1.996E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 537 D.R. = 0.79\n", + "[ NORMAL ] Iteration 97: k_eff = 1.090748 res = 3.388E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 519 D.R. = 1.70\n", + "[ NORMAL ] Iteration 98: k_eff = 1.095774 res = 3.085E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 502 D.R. = 0.91\n", + "[ NORMAL ] Iteration 99: k_eff = 1.100629 res = 3.267E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 485 D.R. = 1.06\n", + "[ NORMAL ] Iteration 100: k_eff = 1.105320 res = 3.025E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 469 D.R. = 0.09\n", + "[ NORMAL ] Iteration 101: k_eff = 1.109851 res = 6.654E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 453 D.R. = 2.20\n", + "[ NORMAL ] Iteration 102: k_eff = 1.114224 res = 3.569E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 437 D.R. = 5.36\n", + "[ NORMAL ] Iteration 103: k_eff = 1.118444 res = 5.203E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 421 D.R. = 1.46\n", + "[ NORMAL ] Iteration 104: k_eff = 1.122516 res = 1.452E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 407 D.R. = 0.28\n", + "[ NORMAL ] Iteration 105: k_eff = 1.126445 res = 5.445E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 392 D.R. = 0.38\n", + "[ NORMAL ] Iteration 106: k_eff = 1.130232 res = 2.783E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 378 D.R. = 5.11\n", + "[ NORMAL ] Iteration 107: k_eff = 1.133884 res = 1.996E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 365 D.R. = 0.72\n", + "[ NORMAL ] Iteration 108: k_eff = 1.137403 res = 4.235E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 351 D.R. = 2.12\n", + "[ NORMAL ] Iteration 109: k_eff = 1.140793 res = 3.751E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 339 D.R. = 0.89\n", + "[ NORMAL ] Iteration 110: k_eff = 1.144059 res = 4.174E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 326 D.R. = 1.11\n", + "[ NORMAL ] Iteration 111: k_eff = 1.147203 res = 4.416E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 314 D.R. = 1.06\n", + "[ NORMAL ] Iteration 112: k_eff = 1.150231 res = 3.025E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 302 D.R. = 0.68\n", + "[ NORMAL ] Iteration 113: k_eff = 1.153146 res = 5.384E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 291 D.R. = 1.78\n", + "[ NORMAL ] Iteration 114: k_eff = 1.155950 res = 3.569E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 280 D.R. = 0.66\n", + "[ NORMAL ] Iteration 115: k_eff = 1.158649 res = 5.142E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 269 D.R. = 1.44\n", + "[ NORMAL ] Iteration 116: k_eff = 1.161244 res = 2.843E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 259 D.R. = 0.55\n", + "[ NORMAL ] Iteration 117: k_eff = 1.163739 res = 3.267E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 249 D.R. = 1.15\n", + "[ NORMAL ] Iteration 118: k_eff = 1.166139 res = 5.505E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 239 D.R. = 1.69\n", + "[ NORMAL ] Iteration 119: k_eff = 1.168445 res = 4.719E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 230 D.R. = 0.86\n", + "[ NORMAL ] Iteration 120: k_eff = 1.170662 res = 6.170E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 221 D.R. = 1.31\n", + "[ NORMAL ] Iteration 121: k_eff = 1.172791 res = 5.384E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 212 D.R. = 0.87\n", + "[ NORMAL ] Iteration 122: k_eff = 1.174837 res = 1.331E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 204 D.R. = 0.25\n", + "[ NORMAL ] Iteration 123: k_eff = 1.176801 res = 1.391E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 196 D.R. = 1.05\n", + "[ NORMAL ] Iteration 124: k_eff = 1.178688 res = 1.089E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 188 D.R. = 0.78\n", + "[ NORMAL ] Iteration 125: k_eff = 1.180500 res = 3.448E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 181 D.R. = 3.17\n", + "[ NORMAL ] Iteration 126: k_eff = 1.182238 res = 1.041E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 173 D.R. = 3.02\n", + "[ NORMAL ] Iteration 127: k_eff = 1.183907 res = 3.690E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 166 D.R. = 0.35\n", + "[ NORMAL ] Iteration 128: k_eff = 1.185508 res = 2.722E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 160 D.R. = 0.74\n", + "[ NORMAL ] Iteration 129: k_eff = 1.187044 res = 9.074E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 153 D.R. = 0.33\n", + "[ NORMAL ] Iteration 130: k_eff = 1.188518 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 147 D.R. = 3.20\n", + "[ NORMAL ] Iteration 131: k_eff = 1.189930 res = 2.783E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 141 D.R. = 0.96\n", + "[ NORMAL ] Iteration 132: k_eff = 1.191285 res = 2.541E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 135 D.R. = 0.91\n", + "[ NORMAL ] Iteration 133: k_eff = 1.192584 res = 4.537E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 129 D.R. = 1.79\n", + "[ NORMAL ] Iteration 134: k_eff = 1.193829 res = 5.505E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 124 D.R. = 1.21\n", + "[ NORMAL ] Iteration 135: k_eff = 1.195022 res = 6.412E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 119 D.R. = 1.16\n", + "[ NORMAL ] Iteration 136: k_eff = 1.196166 res = 6.049E-10 delta-k (pcm)\n", + "[ NORMAL ] ... = 114 D.R. = 0.01\n", + "[ NORMAL ] Iteration 137: k_eff = 1.197262 res = 4.416E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 109 D.R. = 73.00\n", + "[ NORMAL ] Iteration 138: k_eff = 1.198311 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 104 D.R. = 0.88\n", + "[ NORMAL ] Iteration 139: k_eff = 1.199316 res = 2.420E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 100 D.R. = 0.06\n", + "[ NORMAL ] Iteration 140: k_eff = 1.200279 res = 4.053E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 96 D.R. = 16.75\n", + "[ NORMAL ] Iteration 141: k_eff = 1.201201 res = 1.028E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 92 D.R. = 0.25\n", + "[ NORMAL ] Iteration 142: k_eff = 1.202083 res = 3.509E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 88 D.R. = 3.41\n", + "[ NORMAL ] Iteration 143: k_eff = 1.202927 res = 1.815E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 84 D.R. = 0.52\n", + "[ NORMAL ] Iteration 144: k_eff = 1.203736 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 80 D.R. = 1.07\n", + "[ NORMAL ] Iteration 145: k_eff = 1.204510 res = 6.836E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 77 D.R. = 3.53\n", + "[ NORMAL ] Iteration 146: k_eff = 1.205251 res = 5.324E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 74 D.R. = 0.78\n", + "[ NORMAL ] Iteration 147: k_eff = 1.205959 res = 2.299E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 70 D.R. = 0.43\n", + "[ NORMAL ] Iteration 148: k_eff = 1.206637 res = 1.815E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 67 D.R. = 0.79\n", + "[ NORMAL ] Iteration 149: k_eff = 1.207285 res = 8.469E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 64 D.R. = 0.47\n", + "[ NORMAL ] Iteration 150: k_eff = 1.207905 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 61 D.R. = 2.29\n", + "[ NORMAL ] Iteration 151: k_eff = 1.208498 res = 9.074E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 59 D.R. = 0.47\n", + "[ NORMAL ] Iteration 152: k_eff = 1.209065 res = 2.178E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 56 D.R. = 2.40\n", + "[ NORMAL ] Iteration 153: k_eff = 1.209607 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 54 D.R. = 3.11\n", + "[ NORMAL ] Iteration 154: k_eff = 1.210125 res = 9.074E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 51 D.R. = 1.34\n", + "[ NORMAL ] Iteration 155: k_eff = 1.210621 res = 5.445E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 49 D.R. = 0.06\n", + "[ NORMAL ] Iteration 156: k_eff = 1.211094 res = 6.049E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 47 D.R. = 1.11\n", + "[ NORMAL ] Iteration 157: k_eff = 1.211546 res = 6.049E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 45 D.R. = 1.00\n", + "[ NORMAL ] Iteration 158: k_eff = 1.211978 res = 4.658E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 43 D.R. = 7.70\n", + "[ NORMAL ] Iteration 159: k_eff = 1.212391 res = 1.815E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 41 D.R. = 0.04\n", + "[ NORMAL ] Iteration 160: k_eff = 1.212786 res = 1.210E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 39 D.R. = 6.67\n", + "[ NORMAL ] Iteration 161: k_eff = 1.213162 res = 6.049E-10 delta-k (pcm)\n", + "[ NORMAL ] ... = 37 D.R. = 0.05\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Iteration 162: k_eff = 1.213522 res = 1.996E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 35 D.R. = 33.00\n", + "[ NORMAL ] Iteration 163: k_eff = 1.213866 res = 4.658E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 34 D.R. = 2.33\n", + "[ NORMAL ] Iteration 164: k_eff = 1.214194 res = 1.996E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 32 D.R. = 0.43\n", + "[ NORMAL ] Iteration 165: k_eff = 1.214507 res = 1.210E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 31 D.R. = 0.06\n", + "[ NORMAL ] Iteration 166: k_eff = 1.214806 res = 1.875E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 29 D.R. = 15.50\n", + "[ NORMAL ] Iteration 167: k_eff = 1.215092 res = 4.961E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 28 D.R. = 2.65\n", + "[ NORMAL ] Iteration 168: k_eff = 1.215365 res = 6.049E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 27 D.R. = 1.22\n", + "[ NORMAL ] Iteration 169: k_eff = 1.215625 res = 2.964E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 26 D.R. = 0.49\n", + "[ NORMAL ] Iteration 170: k_eff = 1.215874 res = 5.505E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 24 D.R. = 1.86\n", + "[ NORMAL ] Iteration 171: k_eff = 1.216110 res = 2.117E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 23 D.R. = 0.38\n", + "[ NORMAL ] Iteration 172: k_eff = 1.216337 res = 4.174E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 22 D.R. = 1.97\n", + "[ NORMAL ] Iteration 173: k_eff = 1.216552 res = 3.509E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 21 D.R. = 0.84\n", + "[ NORMAL ] Iteration 174: k_eff = 1.216759 res = 2.722E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 20 D.R. = 0.78\n", + "[ NORMAL ] Iteration 175: k_eff = 1.216954 res = 2.601E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 19 D.R. = 0.96\n", + "[ NORMAL ] Iteration 176: k_eff = 1.217142 res = 4.295E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 18 D.R. = 1.65\n", + "[ NORMAL ] Iteration 177: k_eff = 1.217320 res = 4.598E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 17 D.R. = 1.07\n", + "[ NORMAL ] Iteration 178: k_eff = 1.217491 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 17 D.R. = 1.26\n", + "[ NORMAL ] Iteration 179: k_eff = 1.217654 res = 2.480E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 16 D.R. = 0.43\n", + "[ NORMAL ] Iteration 180: k_eff = 1.217809 res = 6.049E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 15 D.R. = 0.24\n", + "[ NORMAL ] Iteration 181: k_eff = 1.217956 res = 6.412E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 14 D.R. = 10.60\n", + "[ NORMAL ] Iteration 182: k_eff = 1.218098 res = 7.138E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 14 D.R. = 1.11\n", + "[ NORMAL ] Iteration 183: k_eff = 1.218232 res = 1.633E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 13 D.R. = 0.23\n", + "[ NORMAL ] Iteration 184: k_eff = 1.218360 res = 2.541E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 12 D.R. = 1.56\n", + "[ NORMAL ] Iteration 185: k_eff = 1.218482 res = 1.028E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 12 D.R. = 0.40\n", + "[ NORMAL ] Iteration 186: k_eff = 1.218599 res = 7.864E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 11 D.R. = 0.76\n", + "[ NORMAL ] Iteration 187: k_eff = 1.218709 res = 4.053E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 11 D.R. = 5.15\n", + "[ NORMAL ] Iteration 188: k_eff = 1.218815 res = 2.299E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 10 D.R. = 0.57\n", + "[ NORMAL ] Iteration 189: k_eff = 1.218916 res = 5.445E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 10 D.R. = 2.37\n", + "[ NORMAL ] Iteration 190: k_eff = 1.219011 res = 3.327E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 9 D.R. = 0.61\n", + "[ NORMAL ] Iteration 191: k_eff = 1.219103 res = 4.840E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 9 D.R. = 0.15\n", + "[ NORMAL ] Iteration 192: k_eff = 1.219190 res = 1.210E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = 2.50\n", + "[ NORMAL ] Iteration 193: k_eff = 1.219273 res = 1.573E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = 1.30\n", + "[ NORMAL ] Iteration 194: k_eff = 1.219352 res = 1.331E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 0.85\n", + "[ NORMAL ] Iteration 195: k_eff = 1.219428 res = 2.783E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 2.09\n", + "[ NORMAL ] Iteration 196: k_eff = 1.219499 res = 2.722E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 0.98\n", + "[ NORMAL ] Iteration 197: k_eff = 1.219567 res = 2.057E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 0.76\n", + "[ NORMAL ] Iteration 198: k_eff = 1.219633 res = 1.331E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 0.65\n", + "[ NORMAL ] Iteration 199: k_eff = 1.219695 res = 3.932E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 2.95\n", + "[ NORMAL ] Iteration 200: k_eff = 1.219753 res = 1.996E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 0.51\n", + "[ NORMAL ] Iteration 201: k_eff = 1.219810 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 2.42\n", + "[ NORMAL ] Iteration 202: k_eff = 1.219863 res = 1.270E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 0.26\n", + "[ NORMAL ] Iteration 203: k_eff = 1.219914 res = 2.662E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 2.10\n", + "[ NORMAL ] Iteration 204: k_eff = 1.219962 res = 5.445E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.20\n", + "[ NORMAL ] Iteration 205: k_eff = 1.220009 res = 3.327E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 6.11\n", + "[ NORMAL ] Iteration 206: k_eff = 1.220052 res = 4.658E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 1.40\n", + "[ NORMAL ] Iteration 207: k_eff = 1.220094 res = 3.025E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.65\n", + "[ NORMAL ] Iteration 208: k_eff = 1.220134 res = 2.117E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.70\n", + "[ NORMAL ] Iteration 209: k_eff = 1.220172 res = 1.875E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.89\n", + "[ NORMAL ] Iteration 210: k_eff = 1.220208 res = 1.028E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.55\n", + "[ NORMAL ] Iteration 211: k_eff = 1.220243 res = 5.263E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 5.12\n", + "[ NORMAL ] Iteration 212: k_eff = 1.220275 res = 2.480E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.47\n", + "[ NORMAL ] Iteration 213: k_eff = 1.220306 res = 4.598E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 1.85\n", + "[ NORMAL ] Iteration 214: k_eff = 1.220336 res = 3.630E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.08\n", + "[ NORMAL ] Iteration 215: k_eff = 1.220364 res = 1.391E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 3.83\n", + "[ NORMAL ] Iteration 216: k_eff = 1.220391 res = 6.049E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 4.35\n", + "[ NORMAL ] Iteration 217: k_eff = 1.220416 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.32\n", + "[ NORMAL ] Iteration 218: k_eff = 1.220441 res = 6.049E-10 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.03\n", + "[ NORMAL ] Iteration 219: k_eff = 1.220464 res = 1.270E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 21.00\n", + "[ NORMAL ] Iteration 220: k_eff = 1.220486 res = 1.452E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 1.14\n", + "[ NORMAL ] Iteration 221: k_eff = 1.220507 res = 2.299E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 1.58\n", + "[ NORMAL ] Iteration 222: k_eff = 1.220527 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.42\n", + "[ NORMAL ] Iteration 223: k_eff = 1.220545 res = 7.078E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 7.31\n", + "[ NORMAL ] Iteration 224: k_eff = 1.220563 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.14\n", + "[ NORMAL ] Iteration 225: k_eff = 1.220580 res = 3.146E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 3.25\n", + "[ NORMAL ] Iteration 226: k_eff = 1.220596 res = 1.633E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.52\n", + "[ NORMAL ] Iteration 227: k_eff = 1.220612 res = 3.569E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 2.19\n", + "[ NORMAL ] Iteration 228: k_eff = 1.220627 res = 2.722E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.76\n", + "[ NORMAL ] Iteration 229: k_eff = 1.220641 res = 1.875E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.69\n", + "[ NORMAL ] Iteration 230: k_eff = 1.220655 res = 3.448E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.84\n", + "[ NORMAL ] Iteration 231: k_eff = 1.220667 res = 8.046E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 2.33\n", + "[ NORMAL ] Iteration 232: k_eff = 1.220679 res = 3.751E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.47\n", + "[ NORMAL ] Iteration 233: k_eff = 1.220690 res = 5.686E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.52\n", + "[ NORMAL ] Iteration 234: k_eff = 1.220701 res = 1.270E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.22\n", + "[ NORMAL ] Iteration 235: k_eff = 1.220711 res = 6.715E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 0 D.R. = 5.29\n" + ] + } + ], + "source": [ + "# Generate tracks for OpenMOC\n", + "track_generator = openmoc.TrackGenerator(openmoc_geometry, num_azim=128, azim_spacing=0.1)\n", + "track_generator.generateTracks()\n", + "\n", + "# Run OpenMOC\n", + "solver = openmoc.CPUSolver(track_generator)\n", + "solver.computeEigenvalue()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We report the eigenvalues computed by OpenMC and OpenMOC here together to summarize our results." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "openmc keff = 1.224484\n", + "openmoc keff = 1.220711\n", + "bias [pcm]: -377.3\n" + ] + } + ], + "source": [ + "# Print report of keff and bias with OpenMC\n", + "openmoc_keff = solver.getKeff()\n", + "openmc_keff = sp.k_combined.n\n", + "bias = (openmoc_keff - openmc_keff) * 1e5\n", + "\n", + "print('openmc keff = {0:1.6f}'.format(openmc_keff))\n", + "print('openmoc keff = {0:1.6f}'.format(openmoc_keff))\n", + "print('bias [pcm]: {0:1.1f}'.format(bias))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a sanity check, let's run a simulation with the coarse 2-group cross sections to ensure that they also produce a reasonable result." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "openmoc_geometry = get_openmoc_geometry(sp.summary.geometry)\n", + "openmoc_cells = openmoc_geometry.getRootUniverse().getAllCells()\n", + "\n", + "# Inject multi-group cross sections into OpenMOC Materials\n", + "for cell_id, cell in openmoc_cells.items():\n", + " \n", + " # Ignore the root cell\n", + " if cell.getName() == 'root cell':\n", + " continue\n", + " \n", + " openmoc_material = cell.getFillMaterial()\n", + " openmoc_material.setNumEnergyGroups(coarse_groups.num_groups)\n", + " \n", + " # Extract the appropriate cross section objects for this cell\n", + " transport = xs_library[cell_id]['transport']\n", + " nufission = xs_library[cell_id]['nu-fission']\n", + " nuscatter = xs_library[cell_id]['nu-scatter']\n", + " chi = xs_library[cell_id]['chi']\n", + " \n", + " # Perform group condensation\n", + " transport = transport.get_condensed_xs(coarse_groups)\n", + " nufission = nufission.get_condensed_xs(coarse_groups)\n", + " nuscatter = nuscatter.get_condensed_xs(coarse_groups)\n", + " chi = chi.get_condensed_xs(coarse_groups)\n", + " \n", + " # Inject NumPy arrays of cross section data into the Material\n", + " openmoc_material.setSigmaT(transport.get_xs(nuclides='sum').flatten())\n", + " openmoc_material.setNuSigmaF(nufission.get_xs(nuclides='sum').flatten())\n", + " openmoc_material.setSigmaS(nuscatter.get_xs(nuclides='sum').flatten())\n", + " openmoc_material.setChi(chi.get_xs(nuclides='sum').flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Initializing a default angular quadrature...\n", + "[ NORMAL ] Initializing 2D tracks...\n", + "[ NORMAL ] Initializing 2D tracks reflections...\n", + "[ NORMAL ] Initializing 2D tracks array...\n", + "[ NORMAL ] Ray tracing for 2D track segmentation...\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 0.09 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 10.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 19.94 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 29.87 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 39.80 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 49.72 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 59.65 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 69.58 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 79.50 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 89.43 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 100.00 %\n", + "[ NORMAL ] Initializing FSR lookup vectors\n", + "[ NORMAL ] Total number of FSRs 3\n", + "[ RESULT ] Total Track Generation & Segmentation Time...........3.9517E-02 sec\n", + "[ NORMAL ] Initializing MOC eigenvalue solver...\n", + "[ NORMAL ] Initializing solver arrays...\n", + "[ NORMAL ] Centering segments around FSR centroid...\n", + "[ NORMAL ] Max boundary angular flux storage per domain = 0.10 MB\n", + "[ NORMAL ] Max scalar flux storage per domain = 0.00 MB\n", + "[ NORMAL ] Max source storage per domain = 0.00 MB\n", + "[ NORMAL ] Number of azimuthal angles = 128\n", + "[ NORMAL ] Azimuthal ray spacing = 0.100000\n", + "[ NORMAL ] Number of polar angles = 6\n", + "[ NORMAL ] Source type = Flat\n", + "[ NORMAL ] MOC transport undamped\n", + "[ NORMAL ] CMFD acceleration: OFF\n", + "[ NORMAL ] Using 1 threads\n", + "[ NORMAL ] Computing the eigenvalue...\n", + "[ NORMAL ] Iteration 0: k_eff = 0.366880 res = 4.840E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -63312 D.R. = 0.00\n", + "[ NORMAL ] Iteration 1: k_eff = 0.391184 res = 9.679E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 2430 D.R. = 0.20\n", + "[ NORMAL ] Iteration 2: k_eff = 0.392990 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 180 D.R. = 6.00\n", + "[ NORMAL ] Iteration 3: k_eff = 0.381099 res = 9.195E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -1189 D.R. = 1.58\n", + "[ NORMAL ] Iteration 4: k_eff = 0.375018 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... -608 D.R. = 0.00\n", + "[ NORMAL ] Iteration 5: k_eff = 0.369593 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -542 D.R. = inf\n", + "[ NORMAL ] Iteration 6: k_eff = 0.365543 res = 1.065E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... -405 D.R. = 5.50\n", + "[ NORMAL ] Iteration 7: k_eff = 0.363054 res = 1.065E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... -248 D.R. = 1.00\n", + "[ NORMAL ] Iteration 8: k_eff = 0.361473 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -158 D.R. = 0.18\n", + "[ NORMAL ] Iteration 9: k_eff = 0.361280 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... -19 D.R. = 3.00\n", + "[ NORMAL ] Iteration 10: k_eff = 0.362003 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 72 D.R. = 0.33\n", + "[ NORMAL ] Iteration 11: k_eff = 0.363718 res = 4.840E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 171 D.R. = 2.50\n", + "[ NORMAL ] Iteration 12: k_eff = 0.366338 res = 1.258E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 262 D.R. = 2.60\n", + "[ NORMAL ] Iteration 13: k_eff = 0.369804 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 346 D.R. = 0.77\n", + "[ NORMAL ] Iteration 14: k_eff = 0.373989 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 418 D.R. = 0.40\n", + "[ NORMAL ] Iteration 15: k_eff = 0.378923 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 493 D.R. = 0.00\n", + "[ NORMAL ] Iteration 16: k_eff = 0.384479 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 555 D.R. = inf\n", + "[ NORMAL ] Iteration 17: k_eff = 0.390637 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 615 D.R. = 1.00\n", + "[ NORMAL ] Iteration 18: k_eff = 0.397338 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 670 D.R. = 0.00\n", + "[ NORMAL ] Iteration 19: k_eff = 0.404533 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 719 D.R. = inf\n", + "[ NORMAL ] Iteration 20: k_eff = 0.412184 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 765 D.R. = 1.67\n", + "[ NORMAL ] Iteration 21: k_eff = 0.420253 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 806 D.R. = 0.80\n", + "[ NORMAL ] Iteration 22: k_eff = 0.428686 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 843 D.R. = 0.75\n", + "[ NORMAL ] Iteration 23: k_eff = 0.437462 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 877 D.R. = 1.67\n", + "[ NORMAL ] Iteration 24: k_eff = 0.446538 res = 1.161E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 907 D.R. = 1.20\n", + "[ NORMAL ] Iteration 25: k_eff = 0.455883 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 934 D.R. = 0.17\n", + "[ NORMAL ] Iteration 26: k_eff = 0.465469 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 958 D.R. = 1.00\n", + "[ NORMAL ] Iteration 27: k_eff = 0.475265 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 979 D.R. = 2.00\n", + "[ NORMAL ] Iteration 28: k_eff = 0.485246 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 998 D.R. = 1.00\n", + "[ NORMAL ] Iteration 29: k_eff = 0.495385 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1013 D.R. = 0.50\n", + "[ NORMAL ] Iteration 30: k_eff = 0.505661 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1027 D.R. = 4.00\n", + "[ NORMAL ] Iteration 31: k_eff = 0.516051 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1038 D.R. = 1.25\n", + "[ NORMAL ] Iteration 32: k_eff = 0.526534 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1048 D.R. = 1.00\n", + "[ NORMAL ] Iteration 33: k_eff = 0.537092 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1055 D.R. = 1.00\n", + "[ NORMAL ] Iteration 34: k_eff = 0.547706 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1061 D.R. = 0.60\n", + "[ NORMAL ] Iteration 35: k_eff = 0.558361 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1065 D.R. = 0.33\n", + "[ NORMAL ] Iteration 36: k_eff = 0.569040 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1067 D.R. = 3.00\n", + "[ NORMAL ] Iteration 37: k_eff = 0.579730 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1068 D.R. = 1.67\n", + "[ NORMAL ] Iteration 38: k_eff = 0.590416 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 1068 D.R. = 0.00\n", + "[ NORMAL ] Iteration 39: k_eff = 0.601087 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1067 D.R. = inf\n", + "[ NORMAL ] Iteration 40: k_eff = 0.611731 res = 1.549E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 1064 D.R. = 1.60\n", + "[ NORMAL ] Iteration 41: k_eff = 0.622338 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1060 D.R. = 0.50\n", + "[ NORMAL ] Iteration 42: k_eff = 0.632897 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1055 D.R. = 1.00\n", + "[ NORMAL ] Iteration 43: k_eff = 0.643400 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1050 D.R. = 0.75\n", + "[ NORMAL ] Iteration 44: k_eff = 0.653837 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 1043 D.R. = 0.00\n", + "[ NORMAL ] Iteration 45: k_eff = 0.664203 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1036 D.R. = inf\n", + "[ NORMAL ] Iteration 46: k_eff = 0.674488 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1028 D.R. = 1.25\n", + "[ NORMAL ] Iteration 47: k_eff = 0.684688 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1020 D.R. = 1.00\n", + "[ NORMAL ] Iteration 48: k_eff = 0.694796 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1010 D.R. = 0.40\n", + "[ NORMAL ] Iteration 49: k_eff = 0.704807 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 1001 D.R. = 1.00\n", + "[ NORMAL ] Iteration 50: k_eff = 0.714715 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 990 D.R. = 0.50\n", + "[ NORMAL ] Iteration 51: k_eff = 0.724517 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 980 D.R. = 1.00\n", + "[ NORMAL ] Iteration 52: k_eff = 0.734209 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 969 D.R. = 1.00\n", + "[ NORMAL ] Iteration 53: k_eff = 0.743787 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 957 D.R. = 0.00\n", + "[ NORMAL ] Iteration 54: k_eff = 0.753247 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 946 D.R. = inf\n", + "[ NORMAL ] Iteration 55: k_eff = 0.762588 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 934 D.R. = 1.50\n", + "[ NORMAL ] Iteration 56: k_eff = 0.771806 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 921 D.R. = 0.33\n", + "[ NORMAL ] Iteration 57: k_eff = 0.780901 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 909 D.R. = 2.00\n", + "[ NORMAL ] Iteration 58: k_eff = 0.789868 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 896 D.R. = 0.50\n", + "[ NORMAL ] Iteration 59: k_eff = 0.798708 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 884 D.R. = 1.00\n", + "[ NORMAL ] Iteration 60: k_eff = 0.807419 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 871 D.R. = 4.00\n", + "[ NORMAL ] Iteration 61: k_eff = 0.816000 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 858 D.R. = 0.50\n", + "[ NORMAL ] Iteration 62: k_eff = 0.824450 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 844 D.R. = 1.00\n", + "[ NORMAL ] Iteration 63: k_eff = 0.832768 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 831 D.R. = 2.00\n", + "[ NORMAL ] Iteration 64: k_eff = 0.840954 res = 1.742E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 818 D.R. = 2.25\n", + "[ NORMAL ] Iteration 65: k_eff = 0.849008 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 805 D.R. = 0.44\n", + "[ NORMAL ] Iteration 66: k_eff = 0.856930 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 792 D.R. = 0.50\n", + "[ NORMAL ] Iteration 67: k_eff = 0.864720 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 778 D.R. = 1.00\n", + "[ NORMAL ] Iteration 68: k_eff = 0.872378 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 765 D.R. = 1.00\n", + "[ NORMAL ] Iteration 69: k_eff = 0.879905 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 752 D.R. = 0.50\n", + "[ NORMAL ] Iteration 70: k_eff = 0.887301 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 739 D.R. = 2.00\n", + "[ NORMAL ] Iteration 71: k_eff = 0.894566 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 726 D.R. = 1.50\n", + "[ NORMAL ] Iteration 72: k_eff = 0.901702 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 713 D.R. = 0.33\n", + "[ NORMAL ] Iteration 73: k_eff = 0.908710 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 700 D.R. = 2.00\n", + "[ NORMAL ] Iteration 74: k_eff = 0.915590 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 687 D.R. = 1.50\n", + "[ NORMAL ] Iteration 75: k_eff = 0.922342 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 675 D.R. = 0.00\n", + "[ NORMAL ] Iteration 76: k_eff = 0.928971 res = 1.161E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 662 D.R. = inf\n", + "[ NORMAL ] Iteration 77: k_eff = 0.935474 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 650 D.R. = 0.17\n", + "[ NORMAL ] Iteration 78: k_eff = 0.941853 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 637 D.R. = 1.00\n", + "[ NORMAL ] Iteration 79: k_eff = 0.948112 res = 9.679E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 625 D.R. = 5.00\n", + "[ NORMAL ] Iteration 80: k_eff = 0.954249 res = 1.065E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 613 D.R. = 1.10\n", + "[ NORMAL ] Iteration 81: k_eff = 0.960267 res = 9.679E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 601 D.R. = 0.09\n", + "[ NORMAL ] Iteration 82: k_eff = 0.966168 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 590 D.R. = 8.00\n", + "[ NORMAL ] Iteration 83: k_eff = 0.971953 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 578 D.R. = 0.75\n", + "[ NORMAL ] Iteration 84: k_eff = 0.977623 res = 1.936E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 566 D.R. = 0.33\n", + "[ NORMAL ] Iteration 85: k_eff = 0.983179 res = 2.904E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 555 D.R. = 1.50\n", + "[ NORMAL ] Iteration 86: k_eff = 0.988624 res = 0.000E+00 delta-k (pcm) =\n", + "[ NORMAL ] ... 544 D.R. = 0.00\n", + "[ NORMAL ] Iteration 87: k_eff = 0.993958 res = 6.775E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 533 D.R. = inf\n", + "[ NORMAL ] Iteration 88: k_eff = 0.999184 res = 9.679E-09 delta-k (pcm) =\n", + "[ NORMAL ] ... 522 D.R. = 0.14\n", + "[ NORMAL ] Iteration 89: k_eff = 1.004304 res = 4.840E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 511 D.R. = 5.00\n", + "[ NORMAL ] Iteration 90: k_eff = 1.009318 res = 3.872E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 501 D.R. = 0.80\n", + "[ NORMAL ] Iteration 91: k_eff = 1.014228 res = 4.840E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 491 D.R. = 1.25\n", + "[ NORMAL ] Iteration 92: k_eff = 1.019037 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 480 D.R. = 1.20\n", + "[ NORMAL ] Iteration 93: k_eff = 1.023744 res = 2.904E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 470 D.R. = 0.50\n", + "[ NORMAL ] Iteration 94: k_eff = 1.028353 res = 6.775E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 460 D.R. = 2.33\n", + "[ NORMAL ] Iteration 95: k_eff = 1.032865 res = 7.743E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 451 D.R. = 1.14\n", + "[ NORMAL ] Iteration 96: k_eff = 1.037281 res = 1.355E-07 delta-k (pcm) =\n", + "[ NORMAL ] ... 441 D.R. = 1.75\n", + "[ NORMAL ] Iteration 97: k_eff = 1.041604 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 432 D.R. = 0.43\n", + "[ NORMAL ] Iteration 98: k_eff = 1.045834 res = 4.840E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 422 D.R. = 0.83\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Iteration 99: k_eff = 1.049974 res = 5.807E-08 delta-k (pcm) =\n", + "[ NORMAL ] ... 413 D.R. = 1.20\n", + "[ NORMAL ] Iteration 100: k_eff = 1.054024 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 405 D.R. = 1.00\n", + "[ NORMAL ] Iteration 101: k_eff = 1.057987 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 396 D.R. = 0.83\n", + "[ NORMAL ] Iteration 102: k_eff = 1.061864 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 387 D.R. = 0.20\n", + "[ NORMAL ] Iteration 103: k_eff = 1.065657 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 379 D.R. = 3.00\n", + "[ NORMAL ] Iteration 104: k_eff = 1.069367 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 370 D.R. = 1.33\n", + "[ NORMAL ] Iteration 105: k_eff = 1.072996 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 362 D.R. = 1.00\n", + "[ NORMAL ] Iteration 106: k_eff = 1.076545 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 354 D.R. = 0.50\n", + "[ NORMAL ] Iteration 107: k_eff = 1.080016 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 347 D.R. = 3.50\n", + "[ NORMAL ] Iteration 108: k_eff = 1.083411 res = 1.161E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 339 D.R. = 1.71\n", + "[ NORMAL ] Iteration 109: k_eff = 1.086731 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 331 D.R. = 0.50\n", + "[ NORMAL ] Iteration 110: k_eff = 1.089976 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 324 D.R. = 0.33\n", + "[ NORMAL ] Iteration 111: k_eff = 1.093150 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 317 D.R. = 4.00\n", + "[ NORMAL ] Iteration 112: k_eff = 1.096253 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 310 D.R. = 1.00\n", + "[ NORMAL ] Iteration 113: k_eff = 1.099286 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 303 D.R. = 0.50\n", + "[ NORMAL ] Iteration 114: k_eff = 1.102251 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 296 D.R. = 1.25\n", + "[ NORMAL ] Iteration 115: k_eff = 1.105150 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 289 D.R. = 0.20\n", + "[ NORMAL ] Iteration 116: k_eff = 1.107983 res = 1.452E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 283 D.R. = 15.00\n", + "[ NORMAL ] Iteration 117: k_eff = 1.110753 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 276 D.R. = 0.33\n", + "[ NORMAL ] Iteration 118: k_eff = 1.113459 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 270 D.R. = 1.80\n", + "[ NORMAL ] Iteration 119: k_eff = 1.116105 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 264 D.R. = 1.22\n", + "[ NORMAL ] Iteration 120: k_eff = 1.118690 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 258 D.R. = 0.36\n", + "[ NORMAL ] Iteration 121: k_eff = 1.121216 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 252 D.R. = 0.25\n", + "[ NORMAL ] Iteration 122: k_eff = 1.123685 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 246 D.R. = 1.00\n", + "[ NORMAL ] Iteration 123: k_eff = 1.126097 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 241 D.R. = 4.00\n", + "[ NORMAL ] Iteration 124: k_eff = 1.128454 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 235 D.R. = 0.00\n", + "[ NORMAL ] Iteration 125: k_eff = 1.130758 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 230 D.R. = inf\n", + "[ NORMAL ] Iteration 126: k_eff = 1.133008 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 224 D.R. = 5.50\n", + "[ NORMAL ] Iteration 127: k_eff = 1.135207 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 219 D.R. = 0.45\n", + "[ NORMAL ] Iteration 128: k_eff = 1.137354 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 214 D.R. = 0.40\n", + "[ NORMAL ] Iteration 129: k_eff = 1.139453 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 209 D.R. = 0.00\n", + "[ NORMAL ] Iteration 130: k_eff = 1.141503 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 204 D.R. = inf\n", + "[ NORMAL ] Iteration 131: k_eff = 1.143505 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 200 D.R. = 1.50\n", + "[ NORMAL ] Iteration 132: k_eff = 1.145461 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 195 D.R. = 2.00\n", + "[ NORMAL ] Iteration 133: k_eff = 1.147372 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 191 D.R. = 1.50\n", + "[ NORMAL ] Iteration 134: k_eff = 1.149238 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 186 D.R. = 1.22\n", + "[ NORMAL ] Iteration 135: k_eff = 1.151061 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 182 D.R. = 0.18\n", + "[ NORMAL ] Iteration 136: k_eff = 1.152842 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 178 D.R. = 1.00\n", + "[ NORMAL ] Iteration 137: k_eff = 1.154581 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 173 D.R. = 2.00\n", + "[ NORMAL ] Iteration 138: k_eff = 1.156279 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 169 D.R. = 2.50\n", + "[ NORMAL ] Iteration 139: k_eff = 1.157938 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 165 D.R. = 0.80\n", + "[ NORMAL ] Iteration 140: k_eff = 1.159557 res = 1.161E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 161 D.R. = 1.50\n", + "[ NORMAL ] Iteration 141: k_eff = 1.161139 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 158 D.R. = 0.33\n", + "[ NORMAL ] Iteration 142: k_eff = 1.162684 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 154 D.R. = 1.00\n", + "[ NORMAL ] Iteration 143: k_eff = 1.164193 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 150 D.R. = 2.75\n", + "[ NORMAL ] Iteration 144: k_eff = 1.165666 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 147 D.R. = 0.09\n", + "[ NORMAL ] Iteration 145: k_eff = 1.167105 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 143 D.R. = 2.00\n", + "[ NORMAL ] Iteration 146: k_eff = 1.168509 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 140 D.R. = 4.00\n", + "[ NORMAL ] Iteration 147: k_eff = 1.169881 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 137 D.R. = 1.25\n", + "[ NORMAL ] Iteration 148: k_eff = 1.171220 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 133 D.R. = 0.10\n", + "[ NORMAL ] Iteration 149: k_eff = 1.172528 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 130 D.R. = 6.00\n", + "[ NORMAL ] Iteration 150: k_eff = 1.173804 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 127 D.R. = 1.67\n", + "[ NORMAL ] Iteration 151: k_eff = 1.175051 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 124 D.R. = 0.80\n", + "[ NORMAL ] Iteration 152: k_eff = 1.176268 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 121 D.R. = 1.00\n", + "[ NORMAL ] Iteration 153: k_eff = 1.177456 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 118 D.R. = 1.00\n", + "[ NORMAL ] Iteration 154: k_eff = 1.178616 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 115 D.R. = 0.63\n", + "[ NORMAL ] Iteration 155: k_eff = 1.179749 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 113 D.R. = 1.20\n", + "[ NORMAL ] Iteration 156: k_eff = 1.180855 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 110 D.R. = 0.83\n", + "[ NORMAL ] Iteration 157: k_eff = 1.181935 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 107 D.R. = 0.20\n", + "[ NORMAL ] Iteration 158: k_eff = 1.182988 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 105 D.R. = 3.00\n", + "[ NORMAL ] Iteration 159: k_eff = 1.184017 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 102 D.R. = 0.67\n", + "[ NORMAL ] Iteration 160: k_eff = 1.185021 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 100 D.R. = 1.50\n", + "[ NORMAL ] Iteration 161: k_eff = 1.186002 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 98 D.R. = 0.67\n", + "[ NORMAL ] Iteration 162: k_eff = 1.186959 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 95 D.R. = 2.50\n", + "[ NORMAL ] Iteration 163: k_eff = 1.187893 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 93 D.R. = 1.40\n", + "[ NORMAL ] Iteration 164: k_eff = 1.188805 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 91 D.R. = 1.29\n", + "[ NORMAL ] Iteration 165: k_eff = 1.189695 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 89 D.R. = 0.22\n", + "[ NORMAL ] Iteration 166: k_eff = 1.190564 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 86 D.R. = 2.00\n", + "[ NORMAL ] Iteration 167: k_eff = 1.191413 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 84 D.R. = 2.00\n", + "[ NORMAL ] Iteration 168: k_eff = 1.192241 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 82 D.R. = 0.00\n", + "[ NORMAL ] Iteration 169: k_eff = 1.193049 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 80 D.R. = inf\n", + "[ NORMAL ] Iteration 170: k_eff = 1.193838 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 78 D.R. = 4.50\n", + "[ NORMAL ] Iteration 171: k_eff = 1.194607 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 76 D.R. = 0.56\n", + "[ NORMAL ] Iteration 172: k_eff = 1.195359 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 75 D.R. = 1.20\n", + "[ NORMAL ] Iteration 173: k_eff = 1.196092 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 73 D.R. = 0.67\n", + "[ NORMAL ] Iteration 174: k_eff = 1.196808 res = 1.355E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 71 D.R. = 3.50\n", + "[ NORMAL ] Iteration 175: k_eff = 1.197507 res = 1.161E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 69 D.R. = 0.86\n", + "[ NORMAL ] Iteration 176: k_eff = 1.198190 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 68 D.R. = 0.33\n", + "[ NORMAL ] Iteration 177: k_eff = 1.198855 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 66 D.R. = 0.75\n", + "[ NORMAL ] Iteration 178: k_eff = 1.199505 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 64 D.R. = 0.67\n", + "[ NORMAL ] Iteration 179: k_eff = 1.200139 res = 1.258E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 63 D.R. = 6.50\n", + "[ NORMAL ] Iteration 180: k_eff = 1.200757 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 61 D.R. = 0.62\n", + "[ NORMAL ] Iteration 181: k_eff = 1.201361 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 60 D.R. = 0.25\n", + "[ NORMAL ] Iteration 182: k_eff = 1.201951 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 58 D.R. = 1.50\n", + "[ NORMAL ] Iteration 183: k_eff = 1.202526 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 57 D.R. = 0.33\n", + "[ NORMAL ] Iteration 184: k_eff = 1.203088 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 56 D.R. = 5.00\n", + "[ NORMAL ] Iteration 185: k_eff = 1.203636 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 54 D.R. = 0.00\n", + "[ NORMAL ] Iteration 186: k_eff = 1.204171 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 53 D.R. = inf\n", + "[ NORMAL ] Iteration 187: k_eff = 1.204692 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 52 D.R. = 2.33\n", + "[ NORMAL ] Iteration 188: k_eff = 1.205202 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 50 D.R. = 0.57\n", + "[ NORMAL ] Iteration 189: k_eff = 1.205698 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 49 D.R. = 0.50\n", + "[ NORMAL ] Iteration 190: k_eff = 1.206183 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 48 D.R. = 0.50\n", + "[ NORMAL ] Iteration 191: k_eff = 1.206656 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 47 D.R. = 6.00\n", + "[ NORMAL ] Iteration 192: k_eff = 1.207118 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 46 D.R. = 0.00\n", + "[ NORMAL ] Iteration 193: k_eff = 1.207570 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 45 D.R. = inf\n", + "[ NORMAL ] Iteration 194: k_eff = 1.208010 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 44 D.R. = 0.33\n", + "[ NORMAL ] Iteration 195: k_eff = 1.208439 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 42 D.R. = 1.33\n", + "[ NORMAL ] Iteration 196: k_eff = 1.208858 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 41 D.R. = 0.50\n", + "[ NORMAL ] Iteration 197: k_eff = 1.209267 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 40 D.R. = 1.50\n", + "[ NORMAL ] Iteration 198: k_eff = 1.209665 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 39 D.R. = 1.33\n", + "[ NORMAL ] Iteration 199: k_eff = 1.210055 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 38 D.R. = 1.50\n", + "[ NORMAL ] Iteration 200: k_eff = 1.210435 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 37 D.R. = 0.17\n", + "[ NORMAL ] Iteration 201: k_eff = 1.210805 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 37 D.R. = 9.00\n", + "[ NORMAL ] Iteration 202: k_eff = 1.211167 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 36 D.R. = 0.11\n", + "[ NORMAL ] Iteration 203: k_eff = 1.211520 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 35 D.R. = 5.00\n", + "[ NORMAL ] Iteration 204: k_eff = 1.211864 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 34 D.R. = 0.60\n", + "[ NORMAL ] Iteration 205: k_eff = 1.212200 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 33 D.R. = 0.67\n", + "[ NORMAL ] Iteration 206: k_eff = 1.212528 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 32 D.R. = 2.50\n", + "[ NORMAL ] Iteration 207: k_eff = 1.212848 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 32 D.R. = 1.60\n", + "[ NORMAL ] Iteration 208: k_eff = 1.213160 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 31 D.R. = 0.25\n", + "[ NORMAL ] Iteration 209: k_eff = 1.213466 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 30 D.R. = 5.50\n", + "[ NORMAL ] Iteration 210: k_eff = 1.213763 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 29 D.R. = 0.55\n", + "[ NORMAL ] Iteration 211: k_eff = 1.214053 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 29 D.R. = 1.67\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Iteration 212: k_eff = 1.214337 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 28 D.R. = 0.30\n", + "[ NORMAL ] Iteration 213: k_eff = 1.214614 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 27 D.R. = 2.33\n", + "[ NORMAL ] Iteration 214: k_eff = 1.214883 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 26 D.R. = 1.29\n", + "[ NORMAL ] Iteration 215: k_eff = 1.215145 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 26 D.R. = 0.56\n", + "[ NORMAL ] Iteration 216: k_eff = 1.215402 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 25 D.R. = 0.40\n", + "[ NORMAL ] Iteration 217: k_eff = 1.215653 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 25 D.R. = 3.00\n", + "[ NORMAL ] Iteration 218: k_eff = 1.215897 res = 1.258E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 24 D.R. = 2.17\n", + "[ NORMAL ] Iteration 219: k_eff = 1.216136 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 23 D.R. = 0.77\n", + "[ NORMAL ] Iteration 220: k_eff = 1.216368 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 23 D.R. = 0.80\n", + "[ NORMAL ] Iteration 221: k_eff = 1.216595 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 22 D.R. = 0.25\n", + "[ NORMAL ] Iteration 222: k_eff = 1.216817 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 22 D.R. = 3.00\n", + "[ NORMAL ] Iteration 223: k_eff = 1.217033 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 21 D.R. = 0.33\n", + "[ NORMAL ] Iteration 224: k_eff = 1.217244 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 21 D.R. = 4.00\n", + "[ NORMAL ] Iteration 225: k_eff = 1.217450 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 20 D.R. = 0.75\n", + "[ NORMAL ] Iteration 226: k_eff = 1.217651 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 20 D.R. = 0.17\n", + "[ NORMAL ] Iteration 227: k_eff = 1.217847 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 19 D.R. = 4.00\n", + "[ NORMAL ] Iteration 228: k_eff = 1.218039 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 19 D.R. = 2.50\n", + "[ NORMAL ] Iteration 229: k_eff = 1.218225 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 18 D.R. = 0.20\n", + "[ NORMAL ] Iteration 230: k_eff = 1.218407 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 18 D.R. = 2.50\n", + "[ NORMAL ] Iteration 231: k_eff = 1.218585 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 17 D.R. = 1.00\n", + "[ NORMAL ] Iteration 232: k_eff = 1.218758 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 17 D.R. = 1.40\n", + "[ NORMAL ] Iteration 233: k_eff = 1.218927 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 16 D.R. = 0.71\n", + "[ NORMAL ] Iteration 234: k_eff = 1.219092 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 16 D.R. = 1.00\n", + "[ NORMAL ] Iteration 235: k_eff = 1.219253 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 16 D.R. = 1.40\n", + "[ NORMAL ] Iteration 236: k_eff = 1.219410 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 15 D.R. = 0.57\n", + "[ NORMAL ] Iteration 237: k_eff = 1.219563 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 15 D.R. = 0.50\n", + "[ NORMAL ] Iteration 238: k_eff = 1.219712 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 14 D.R. = 0.00\n", + "[ NORMAL ] Iteration 239: k_eff = 1.219858 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 14 D.R. = -nan\n", + "[ NORMAL ] Iteration 240: k_eff = 1.220000 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 14 D.R. = inf\n", + "[ NORMAL ] Iteration 241: k_eff = 1.220139 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 13 D.R. = 1.13\n", + "[ NORMAL ] Iteration 242: k_eff = 1.220274 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 13 D.R. = 1.11\n", + "[ NORMAL ] Iteration 243: k_eff = 1.220407 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 13 D.R. = 1.10\n", + "[ NORMAL ] Iteration 244: k_eff = 1.220536 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 12 D.R. = 0.64\n", + "[ NORMAL ] Iteration 245: k_eff = 1.220662 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 12 D.R. = 0.43\n", + "[ NORMAL ] Iteration 246: k_eff = 1.220784 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 12 D.R. = 0.67\n", + "[ NORMAL ] Iteration 247: k_eff = 1.220904 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 11 D.R. = 1.00\n", + "[ NORMAL ] Iteration 248: k_eff = 1.221021 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 11 D.R. = 3.50\n", + "[ NORMAL ] Iteration 249: k_eff = 1.221135 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 11 D.R. = 1.43\n", + "[ NORMAL ] Iteration 250: k_eff = 1.221246 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 11 D.R. = 0.80\n", + "[ NORMAL ] Iteration 251: k_eff = 1.221355 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 10 D.R. = 0.87\n", + "[ NORMAL ] Iteration 252: k_eff = 1.221461 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 10 D.R. = 0.43\n", + "[ NORMAL ] Iteration 253: k_eff = 1.221564 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 10 D.R. = 1.67\n", + "[ NORMAL ] Iteration 254: k_eff = 1.221665 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 10 D.R. = 0.40\n", + "[ NORMAL ] Iteration 255: k_eff = 1.221763 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 9 D.R. = 0.00\n", + "[ NORMAL ] Iteration 256: k_eff = 1.221859 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 9 D.R. = inf\n", + "[ NORMAL ] Iteration 257: k_eff = 1.221953 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 9 D.R. = 1.00\n", + "[ NORMAL ] Iteration 258: k_eff = 1.222044 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 9 D.R. = 0.40\n", + "[ NORMAL ] Iteration 259: k_eff = 1.222133 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = 1.50\n", + "[ NORMAL ] Iteration 260: k_eff = 1.222220 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = 0.00\n", + "[ NORMAL ] Iteration 261: k_eff = 1.222305 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = inf\n", + "[ NORMAL ] Iteration 262: k_eff = 1.222387 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = 1.17\n", + "[ NORMAL ] Iteration 263: k_eff = 1.222468 res = 1.839E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 8 D.R. = 2.71\n", + "[ NORMAL ] Iteration 264: k_eff = 1.222547 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 0.16\n", + "[ NORMAL ] Iteration 265: k_eff = 1.222624 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 1.00\n", + "[ NORMAL ] Iteration 266: k_eff = 1.222699 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 0.33\n", + "[ NORMAL ] Iteration 267: k_eff = 1.222772 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 6.00\n", + "[ NORMAL ] Iteration 268: k_eff = 1.222844 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 7 D.R. = 1.17\n", + "[ NORMAL ] Iteration 269: k_eff = 1.222913 res = 1.452E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 2.14\n", + "[ NORMAL ] Iteration 270: k_eff = 1.222981 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 0.40\n", + "[ NORMAL ] Iteration 271: k_eff = 1.223048 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 0.17\n", + "[ NORMAL ] Iteration 272: k_eff = 1.223113 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 3.00\n", + "[ NORMAL ] Iteration 273: k_eff = 1.223176 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 1.33\n", + "[ NORMAL ] Iteration 274: k_eff = 1.223238 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 1.00\n", + "[ NORMAL ] Iteration 275: k_eff = 1.223298 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 1.00\n", + "[ NORMAL ] Iteration 276: k_eff = 1.223357 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 1.00\n", + "[ NORMAL ] Iteration 277: k_eff = 1.223414 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 0.50\n", + "[ NORMAL ] Iteration 278: k_eff = 1.223470 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 1.50\n", + "[ NORMAL ] Iteration 279: k_eff = 1.223524 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 1.67\n", + "[ NORMAL ] Iteration 280: k_eff = 1.223577 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 0.20\n", + "[ NORMAL ] Iteration 281: k_eff = 1.223629 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 5.00\n", + "[ NORMAL ] Iteration 282: k_eff = 1.223680 res = 1.258E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 2.60\n", + "[ NORMAL ] Iteration 283: k_eff = 1.223729 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.77\n", + "[ NORMAL ] Iteration 284: k_eff = 1.223777 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.70\n", + "[ NORMAL ] Iteration 285: k_eff = 1.223824 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 1.00\n", + "[ NORMAL ] Iteration 286: k_eff = 1.223870 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 1.00\n", + "[ NORMAL ] Iteration 287: k_eff = 1.223915 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.29\n", + "[ NORMAL ] Iteration 288: k_eff = 1.223959 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.00\n", + "[ NORMAL ] Iteration 289: k_eff = 1.224001 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = inf\n", + "[ NORMAL ] Iteration 290: k_eff = 1.224043 res = 1.355E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 2.80\n", + "[ NORMAL ] Iteration 291: k_eff = 1.224083 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.57\n", + "[ NORMAL ] Iteration 292: k_eff = 1.224123 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.37\n", + "[ NORMAL ] Iteration 293: k_eff = 1.224161 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 1.33\n", + "[ NORMAL ] Iteration 294: k_eff = 1.224199 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 2.00\n", + "[ NORMAL ] Iteration 295: k_eff = 1.224235 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.50\n", + "[ NORMAL ] Iteration 296: k_eff = 1.224271 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 1.75\n", + "[ NORMAL ] Iteration 297: k_eff = 1.224306 res = 1.161E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 1.71\n", + "[ NORMAL ] Iteration 298: k_eff = 1.224340 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.08\n", + "[ NORMAL ] Iteration 299: k_eff = 1.224373 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 2.00\n", + "[ NORMAL ] Iteration 300: k_eff = 1.224406 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 5.50\n", + "[ NORMAL ] Iteration 301: k_eff = 1.224438 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.82\n", + "[ NORMAL ] Iteration 302: k_eff = 1.224468 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.78\n", + "[ NORMAL ] Iteration 303: k_eff = 1.224498 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.71\n", + "[ NORMAL ] Iteration 304: k_eff = 1.224528 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.40\n", + "[ NORMAL ] Iteration 305: k_eff = 1.224557 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 3.00\n", + "[ NORMAL ] Iteration 306: k_eff = 1.224585 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.83\n", + "[ NORMAL ] Iteration 307: k_eff = 1.224612 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.20\n", + "[ NORMAL ] Iteration 308: k_eff = 1.224639 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 3.00\n", + "[ NORMAL ] Iteration 309: k_eff = 1.224665 res = 9.679E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 3.33\n", + "[ NORMAL ] Iteration 310: k_eff = 1.224691 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.80\n", + "[ NORMAL ] Iteration 311: k_eff = 1.224716 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.50\n", + "[ NORMAL ] Iteration 312: k_eff = 1.224740 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.75\n", + "[ NORMAL ] Iteration 313: k_eff = 1.224764 res = 1.161E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 4.00\n", + "[ NORMAL ] Iteration 314: k_eff = 1.224786 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.17\n", + "[ NORMAL ] Iteration 315: k_eff = 1.224809 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 1.50\n", + "[ NORMAL ] Iteration 316: k_eff = 1.224831 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 3.67\n", + "[ NORMAL ] Iteration 317: k_eff = 1.224852 res = 1.161E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 1.09\n", + "[ NORMAL ] Iteration 318: k_eff = 1.224873 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.00\n", + "[ NORMAL ] Iteration 319: k_eff = 1.224893 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = inf\n", + "[ NORMAL ] Iteration 320: k_eff = 1.224913 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.63\n", + "[ NORMAL ] Iteration 321: k_eff = 1.224932 res = 6.775E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.40\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Iteration 322: k_eff = 1.224951 res = 8.711E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.29\n", + "[ NORMAL ] Iteration 323: k_eff = 1.224969 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.11\n", + "[ NORMAL ] Iteration 324: k_eff = 1.224987 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 8.00\n", + "[ NORMAL ] Iteration 325: k_eff = 1.225005 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.25\n", + "[ NORMAL ] Iteration 326: k_eff = 1.225022 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.50\n", + "[ NORMAL ] Iteration 327: k_eff = 1.225039 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 2.00\n", + "[ NORMAL ] Iteration 328: k_eff = 1.225055 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 3.00\n", + "[ NORMAL ] Iteration 329: k_eff = 1.225071 res = 1.065E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.83\n", + "[ NORMAL ] Iteration 330: k_eff = 1.225086 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.27\n", + "[ NORMAL ] Iteration 331: k_eff = 1.225102 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.00\n", + "[ NORMAL ] Iteration 332: k_eff = 1.225116 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.00\n", + "[ NORMAL ] Iteration 333: k_eff = 1.225131 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 2.00\n", + "[ NORMAL ] Iteration 334: k_eff = 1.225145 res = 4.840E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.83\n", + "[ NORMAL ] Iteration 335: k_eff = 1.225159 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.20\n", + "[ NORMAL ] Iteration 336: k_eff = 1.225172 res = 5.807E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 6.00\n", + "[ NORMAL ] Iteration 337: k_eff = 1.225185 res = 1.355E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 2.33\n", + "[ NORMAL ] Iteration 338: k_eff = 1.225198 res = 1.258E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.93\n", + "[ NORMAL ] Iteration 339: k_eff = 1.225210 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.00\n", + "[ NORMAL ] Iteration 340: k_eff = 1.225222 res = 9.679E-09 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = inf\n", + "[ NORMAL ] Iteration 341: k_eff = 1.225233 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 4.00\n", + "[ NORMAL ] Iteration 342: k_eff = 1.225245 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.50\n", + "[ NORMAL ] Iteration 343: k_eff = 1.225256 res = 0.000E+00 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.00\n", + "[ NORMAL ] Iteration 344: k_eff = 1.225267 res = 7.743E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = inf\n", + "[ NORMAL ] Iteration 345: k_eff = 1.225278 res = 2.904E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.38\n", + "[ NORMAL ] Iteration 346: k_eff = 1.225288 res = 3.872E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 1.33\n", + "[ NORMAL ] Iteration 347: k_eff = 1.225298 res = 1.936E-08 delta-k (pcm)\n", + "[ NORMAL ] ... = 0 D.R. = 0.50\n" + ] + } + ], + "source": [ + "# Generate tracks for OpenMOC\n", + "track_generator = openmoc.TrackGenerator(openmoc_geometry, num_azim=128, azim_spacing=0.1)\n", + "track_generator.generateTracks()\n", + "\n", + "# Run OpenMOC\n", + "solver = openmoc.CPUSolver(track_generator)\n", + "solver.computeEigenvalue()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "openmc keff = 1.224484\n", + "openmoc keff = 1.225298\n", + "bias [pcm]: 81.4\n" + ] + } + ], + "source": [ + "# Print report of keff and bias with OpenMC\n", + "openmoc_keff = solver.getKeff()\n", + "openmc_keff = sp.k_combined.n\n", + "bias = (openmoc_keff - openmc_keff) * 1e5\n", + "\n", + "print('openmc keff = {0:1.6f}'.format(openmc_keff))\n", + "print('openmoc keff = {0:1.6f}'.format(openmoc_keff))\n", + "print('bias [pcm]: {0:1.1f}'.format(bias))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is a non-trivial bias in both the 2-group and 8-group cases. In the case of a pin cell, one can show that these biases do not converge to <100 pcm with more particle histories. For heterogeneous geometries, additional measures must be taken to address the following three sources of bias:\n", + "\n", + "* Appropriate transport-corrected cross sections\n", + "* Spatial discretization of OpenMOC's mesh\n", + "* Constant-in-angle multi-group cross sections" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Visualizing MGXS Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is often insightful to generate visual depictions of multi-group cross sections. There are many different types of plots which may be useful for multi-group cross section visualization, only a few of which will be shown here for enrichment and inspiration.\n", + "\n", + "One particularly useful visualization is a comparison of the continuous-energy and multi-group cross sections for a particular nuclide and reaction type. We illustrate one option for generating such plots with the use of the `openmc.plotter` module to plot continuous-energy cross sections from the openly available cross section library distributed by NNDC.\n", + "\n", + "The MGXS data can also be plotted using the openmc.plot_xs command, however we will do this manually here to show how the openmc.Mgxs.get_xs method can be used to obtain data." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1e-05, 20000000.0)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure of the U-235 continuous-energy fission cross section \n", + "fig = openmc.plot_xs('U235', ['fission'])\n", + "\n", + "# Get the axis to use for plotting the MGXS\n", + "ax = fig.gca()\n", + "\n", + "# Extract energy group bounds and MGXS values to plot\n", + "fission = xs_library[fuel_cell.id]['fission']\n", + "energy_groups = fission.energy_groups\n", + "x = energy_groups.group_edges\n", + "y = fission.get_xs(nuclides=['U235'], order_groups='decreasing', xs_type='micro')\n", + "y = np.squeeze(y)\n", + "\n", + "# Fix low energy bound\n", + "x[0] = 1.e-5\n", + "\n", + "# Extend the mgxs values array for matplotlib's step plot\n", + "y = np.insert(y, 0, y[0])\n", + "\n", + "# Create a step plot for the MGXS\n", + "ax.plot(x, y, drawstyle='steps', color='r', linewidth=3)\n", + "\n", + "ax.set_title('U-235 Fission Cross Section')\n", + "ax.legend(['Continuous', 'Multi-Group'])\n", + "ax.set_xlim((x.min(), x.max()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another useful type of illustration is scattering matrix sparsity structures. First, we extract Pandas `DataFrames` for the H-1 and O-16 scattering matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Construct a Pandas DataFrame for the microscopic nu-scattering matrix\n", + "nuscatter = xs_library[moderator_cell.id]['nu-scatter']\n", + "df = nuscatter.get_pandas_dataframe(xs_type='micro')\n", + "\n", + "# Slice DataFrame in two for each nuclide's mean values\n", + "h1 = df[df['nuclide'] == 'H1']['mean']\n", + "o16 = df[df['nuclide'] == 'O16']['mean']\n", + "\n", + "# Cast DataFrames as NumPy arrays\n", + "h1 = h1.values\n", + "o16 = o16.values\n", + "\n", + "# Reshape arrays to 2D matrix for plotting\n", + "h1.shape = (fine_groups.num_groups, fine_groups.num_groups)\n", + "o16.shape = (fine_groups.num_groups, fine_groups.num_groups)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Matplotlib's `imshow` routine can be used to plot the matrices to illustrate their sparsity structures." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create plot of the H-1 scattering matrix\n", + "fig = plt.subplot(121)\n", + "fig.imshow(h1, interpolation='nearest', cmap='jet')\n", + "plt.title('H-1 Scattering Matrix')\n", + "plt.xlabel('Group Out')\n", + "plt.ylabel('Group In')\n", + "\n", + "# Create plot of the O-16 scattering matrix\n", + "fig2 = plt.subplot(122)\n", + "fig2.imshow(o16, interpolation='nearest', cmap='jet')\n", + "plt.title('O-16 Scattering Matrix')\n", + "plt.xlabel('Group Out')\n", + "plt.ylabel('Group In')\n", + "\n", + "# Show the plot on screen\n", + "plt.show()" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mgxs-part-iii.ipynb b/mgxs-part-iii.ipynb new file mode 100644 index 0000000..d75255d --- /dev/null +++ b/mgxs-part-iii.ipynb @@ -0,0 +1,1668 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multigroup Cross Section Generation Part III: Libraries\n", + "This IPython Notebook illustrates the use of the **`openmc.mgxs.Library`** class. The `Library` class is designed to automate the calculation of multi-group cross sections for use cases with one or more domains, cross section types, and/or nuclides. In particular, this Notebook illustrates the following features:\n", + "\n", + "* Calculation of multi-group cross sections for a **fuel assembly**\n", + "* Automated creation, manipulation and storage of `MGXS` with **`openmc.mgxs.Library`**\n", + "* **Validation** of multi-group cross sections with **[OpenMOC](https://mit-crpg.github.io/OpenMOC/)**\n", + "* Steady-state pin-by-pin **fission rates comparison** between OpenMC and [OpenMOC](https://mit-crpg.github.io/OpenMOC/)\n", + "\n", + "**Note:** This Notebook was created using [OpenMOC](https://mit-crpg.github.io/OpenMOC/) to verify the multi-group cross-sections generated by OpenMC. You must install [OpenMOC](https://mit-crpg.github.io/OpenMOC/) on your system to run this Notebook in its entirety. In addition, this Notebook illustrates the use of [Pandas](https://pandas.pydata.org/) `DataFrames` to containerize multi-group cross section data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Input Files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import pickle\n", + "\n", + "from IPython.display import Image\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import openmc\n", + "import openmc.mgxs\n", + "from openmc.openmoc_compatible import get_openmoc_geometry\n", + "import openmoc\n", + "import openmoc.process\n", + "from openmoc.materialize import load_openmc_mgxs_lib\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we need to define materials that will be used in the problem. We'll create three materials for the fuel, water, and cladding of the fuel pins." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 1.6 enriched fuel\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel.set_density('g/cm3', 10.31341)\n", + "fuel.add_nuclide('U235', 3.7503e-4)\n", + "fuel.add_nuclide('U238', 2.2625e-2)\n", + "fuel.add_nuclide('O16', 4.6007e-2)\n", + "\n", + "# borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_nuclide('H1', 4.9457e-2)\n", + "water.add_nuclide('O16', 2.4732e-2)\n", + "water.add_nuclide('B10', 8.0042e-6)\n", + "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide('Zr90', 7.2758e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we can now create a `Materials` object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Materials object\n", + "materials_file = openmc.Materials([fuel, water, zircaloy])\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. This problem will be a square array of fuel pins and control rod guide tubes for which we can use OpenMC's lattice/universe feature. The basic universe will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces for fuel and clad, as well as the outer bounding surfaces of the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create cylinders for the fuel and clad\n", + "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.39218)\n", + "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.45720)\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "min_x = openmc.XPlane(x0=-10.71, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=+10.71, boundary_type='reflective')\n", + "min_y = openmc.YPlane(y0=-10.71, boundary_type='reflective')\n", + "max_y = openmc.YPlane(y0=+10.71, boundary_type='reflective')\n", + "min_z = openmc.ZPlane(z0=-10., boundary_type='reflective')\n", + "max_z = openmc.ZPlane(z0=+10., boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now construct a fuel pin cell from cells that are defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "fuel_pin_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "fuel_pin_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "fuel_pin_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "fuel_pin_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Likewise, we can construct a control rod guide tube with the same surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a control rod guide tube\n", + "guide_tube_universe = openmc.Universe(name='Guide Tube')\n", + "\n", + "# Create guide tube Cell\n", + "guide_tube_cell = openmc.Cell(name='Guide Tube Water')\n", + "guide_tube_cell.fill = water\n", + "guide_tube_cell.region = -fuel_outer_radius\n", + "guide_tube_universe.add_cell(guide_tube_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='Guide Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "guide_tube_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='Guide Tube Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "guide_tube_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the pin cell universe, we can construct a 17x17 rectangular lattice with a 1.26 cm pitch." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Create fuel assembly Lattice\n", + "assembly = openmc.RectLattice(name='1.6% Fuel Assembly')\n", + "assembly.pitch = (1.26, 1.26)\n", + "assembly.lower_left = [-1.26 * 17. / 2.0] * 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create a NumPy array of fuel pin and guide tube universes for the lattice." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Create array indices for guide tube locations in lattice\n", + "template_x = np.array([5, 8, 11, 3, 13, 2, 5, 8, 11, 14, 2, 5, 8,\n", + " 11, 14, 2, 5, 8, 11, 14, 3, 13, 5, 8, 11])\n", + "template_y = np.array([2, 2, 2, 3, 3, 5, 5, 5, 5, 5, 8, 8, 8, 8,\n", + " 8, 11, 11, 11, 11, 11, 13, 13, 14, 14, 14])\n", + "\n", + "# Initialize an empty 17x17 array of the lattice universes\n", + "universes = np.empty((17, 17), dtype=openmc.Universe)\n", + "\n", + "# Fill the array with the fuel pin and guide tube universes\n", + "universes[:,:] = fuel_pin_universe\n", + "universes[template_x, template_y] = guide_tube_universe\n", + "\n", + "# Store the array of universes in the lattice\n", + "assembly.universes = universes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the assembly and then assign it to the root universe." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell')\n", + "root_cell.fill = assembly\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", + "root_universe.add_cell(root_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry that is assigned a root universe and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "geometry = openmc.Geometry(root_universe)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters. In this case, we will use 10 inactive batches and 40 active batches each with 2500 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "batches = 50\n", + "inactive = 10\n", + "particles = 10000\n", + "\n", + "# Instantiate a Settings object\n", + "settings_file = openmc.Settings()\n", + "settings_file.batches = batches\n", + "settings_file.inactive = inactive\n", + "settings_file.particles = particles\n", + "settings_file.output = {'tallies': False}\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-10.71, -10.71, -10, 10.71, 10.71, 10.]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings_file.source = openmc.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings_file.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us also create a plot to verify that our fuel assembly geometry was created successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate a Plot\n", + "plot = openmc.Plot.from_geometry(geometry)\n", + "plot.pixels = (250, 250)\n", + "plot.color_by = 'material'\n", + "plot.to_ipython_image()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see from the plot, we have a nice array of fuel and guide tube pin cells with fuel, cladding, and water!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create an MGXS Library" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we are ready to generate multi-group cross sections! First, let's define a 2-group structure using the built-in `EnergyGroups` class." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a 2-group EnergyGroups object\n", + "groups = openmc.mgxs.EnergyGroups()\n", + "groups.group_edges = np.array([0., 0.625, 20.0e6])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we will instantiate an `openmc.mgxs.Library` for the energy groups with the fuel assembly geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize a 2-group MGXS Library for OpenMOC\n", + "mgxs_lib = openmc.mgxs.Library(geometry)\n", + "mgxs_lib.energy_groups = groups" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we must specify to the `Library` which types of cross sections to compute. In particular, the following are the multi-group cross section `MGXS` subclasses that are mapped to string codes accepted by the `Library` class:\n", + "\n", + "* `TotalXS` (`\"total\"`)\n", + "* `TransportXS` (`\"transport\"` or `\"nu-transport` with `nu` set to `True`)\n", + "* `AbsorptionXS` (`\"absorption\"`)\n", + "* `CaptureXS` (`\"capture\"`)\n", + "* `FissionXS` (`\"fission\"` or `\"nu-fission\"` with `nu` set to `True`)\n", + "* `KappaFissionXS` (`\"kappa-fission\"`)\n", + "* `ScatterXS` (`\"scatter\"` or `\"nu-scatter\"` with `nu` set to `True`)\n", + "* `ScatterMatrixXS` (`\"scatter matrix\"` or `\"nu-scatter matrix\"` with `nu` set to `True`)\n", + "* `Chi` (`\"chi\"`)\n", + "* `ChiPrompt` (`\"chi prompt\"`)\n", + "* `InverseVelocity` (`\"inverse-velocity\"`)\n", + "* `PromptNuFissionXS` (`\"prompt-nu-fission\"`)\n", + "* `DelayedNuFissionXS` (`\"delayed-nu-fission\"`)\n", + "* `ChiDelayed` (`\"chi-delayed\"`)\n", + "* `Beta` (`\"beta\"`)\n", + "\n", + "In this case, let's create the multi-group cross sections needed to run an OpenMOC simulation to verify the accuracy of our cross sections. In particular, we will define `\"nu-transport\"`, `\"nu-fission\"`, `'\"fission\"`, `\"nu-scatter matrix\"` and `\"chi\"` cross sections for our `Library`.\n", + "\n", + "**Note**: A variety of different approximate transport-corrected total multi-group cross sections (and corresponding scattering matrices) can be found in the literature. At the present time, the `openmc.mgxs` module only supports the `\"P0\"` transport correction. This correction can be turned on and off through the boolean `Library.correction` property which may take values of `\"P0\"` (default) or `None`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Specify multi-group cross section types to compute\n", + "mgxs_lib.mgxs_types = ['nu-transport', 'nu-fission', 'fission', 'nu-scatter matrix', 'chi']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we must specify the type of domain over which we would like the `Library` to compute multi-group cross sections. The domain type corresponds to the type of tally filter to be used in the tallies created to compute multi-group cross sections. At the present time, the `Library` supports `\"material\"`, `\"cell\"`, `\"universe\"`, and `\"mesh\"` domain types. We will use a `\"cell\"` domain type here to compute cross sections in each of the cells in the fuel assembly geometry.\n", + "\n", + "**Note:** By default, the `Library` class will instantiate `MGXS` objects for each and every domain (material, cell or universe) in the geometry of interest. However, one may specify a subset of these domains to the `Library.domains` property. In our case, we wish to compute multi-group cross sections in each and every cell since they will be needed in our downstream OpenMOC calculation on the identical combinatorial geometry mesh." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Specify a \"cell\" domain type for the cross section tally filters\n", + "mgxs_lib.domain_type = 'cell'\n", + "\n", + "# Specify the cell domains over which to compute multi-group cross sections\n", + "mgxs_lib.domains = geometry.get_all_material_cells().values()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can easily instruct the `Library` to compute multi-group cross sections on a nuclide-by-nuclide basis with the boolean `Library.by_nuclide` property. By default, `by_nuclide` is set to `False`, but we will set it to `True` here." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute cross sections on a nuclide-by-nuclide basis\n", + "mgxs_lib.by_nuclide = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we use the `Library` to construct the tallies needed to compute all of the requested multi-group cross sections in each domain and nuclide." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Construct all tallies needed for the multi-group cross section library\n", + "mgxs_lib.build_library()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tallies can now be export to a \"tallies.xml\" input file for OpenMC. \n", + "\n", + "**NOTE**: At this point the `Library` has constructed nearly 100 distinct `Tally` objects. The overhead to tally in OpenMC scales as $O(N)$ for $N$ tallies, which can become a bottleneck for large tally datasets. To compensate for this, the Python API's `Tally`, `Filter` and `Tallies` classes allow for the smart *merging* of tallies when possible. The `Library` class supports this runtime optimization with the use of the optional `merge` paramter (`False` by default) for the `Library.add_to_tallies_file(...)` method, as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a \"tallies.xml\" file for the MGXS Library\n", + "tallies_file = openmc.Tallies()\n", + "mgxs_lib.add_to_tallies_file(tallies_file, merge=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition, we instantiate a fission rate mesh tally to compare with OpenMOC." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a tally Mesh\n", + "mesh = openmc.RegularMesh(mesh_id=1)\n", + "mesh.dimension = [17, 17]\n", + "mesh.lower_left = [-10.71, -10.71]\n", + "mesh.upper_right = [+10.71, +10.71]\n", + "\n", + "# Instantiate tally Filter\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "# Instantiate the Tally\n", + "tally = openmc.Tally(name='mesh tally')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['fission', 'nu-fission']\n", + "\n", + "# Add tally to collection\n", + "tallies_file.append(tally)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=126.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=21.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=3.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=4.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=96.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=15.\n", + " warn(msg, IDWarning)\n", + "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=114.\n", + " warn(msg, IDWarning)\n" + ] + } + ], + "source": [ + "# Export all tallies to a \"tallies.xml\" file\n", + "tallies_file.export_to_xml()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2019 MIT and OpenMC contributors\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.11.0-dev\n", + " Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n", + " Date/Time | 2019-07-19 07:12:55\n", + " OpenMP Threads | 4\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U235 from /opt/data/hdf5/nndc_hdf5_v15/U235.h5\n", + " Reading U238 from /opt/data/hdf5/nndc_hdf5_v15/U238.h5\n", + " Reading O16 from /opt/data/hdf5/nndc_hdf5_v15/O16.h5\n", + " Reading H1 from /opt/data/hdf5/nndc_hdf5_v15/H1.h5\n", + " Reading B10 from /opt/data/hdf5/nndc_hdf5_v15/B10.h5\n", + " Reading Zr90 from /opt/data/hdf5/nndc_hdf5_v15/Zr90.h5\n", + " Maximum neutron transport energy: 20000000.000000 eV for U235\n", + " Reading tallies XML file...\n", + " Writing summary.h5 file...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.03784\n", + " 2/1 1.02297\n", + " 3/1 1.02244\n", + " 4/1 1.02344\n", + " 5/1 1.02057\n", + " 6/1 1.04077\n", + " 7/1 1.00775\n", + " 8/1 1.03892\n", + " 9/1 1.01606\n", + " 10/1 1.02209\n", + " 11/1 1.03259\n", + " 12/1 1.03331 1.03295 +/- 0.00036\n", + " 13/1 1.02027 1.02872 +/- 0.00423\n", + " 14/1 1.03901 1.03130 +/- 0.00395\n", + " 15/1 1.02000 1.02904 +/- 0.00380\n", + " 16/1 1.04469 1.03164 +/- 0.00405\n", + " 17/1 1.01862 1.02978 +/- 0.00390\n", + " 18/1 1.03265 1.03014 +/- 0.00340\n", + " 19/1 1.00489 1.02734 +/- 0.00410\n", + " 20/1 1.04533 1.02914 +/- 0.00409\n", + " 21/1 1.01534 1.02788 +/- 0.00390\n", + " 22/1 1.02204 1.02739 +/- 0.00360\n", + " 23/1 1.02181 1.02696 +/- 0.00334\n", + " 24/1 0.99207 1.02447 +/- 0.00397\n", + " 25/1 1.03041 1.02487 +/- 0.00372\n", + " 26/1 1.03652 1.02560 +/- 0.00355\n", + " 27/1 1.03793 1.02632 +/- 0.00341\n", + " 28/1 1.02099 1.02603 +/- 0.00323\n", + " 29/1 1.01953 1.02568 +/- 0.00308\n", + " 30/1 1.01690 1.02525 +/- 0.00295\n", + " 31/1 1.01938 1.02497 +/- 0.00282\n", + " 32/1 1.01800 1.02465 +/- 0.00271\n", + " 33/1 1.01598 1.02427 +/- 0.00262\n", + " 34/1 1.01735 1.02398 +/- 0.00252\n", + " 35/1 1.01080 1.02346 +/- 0.00247\n", + " 36/1 1.01267 1.02304 +/- 0.00241\n", + " 37/1 1.01907 1.02289 +/- 0.00233\n", + " 38/1 1.02333 1.02291 +/- 0.00224\n", + " 39/1 1.01516 1.02264 +/- 0.00218\n", + " 40/1 1.02797 1.02282 +/- 0.00211\n", + " 41/1 1.03949 1.02336 +/- 0.00211\n", + " 42/1 1.01456 1.02308 +/- 0.00207\n", + " 43/1 1.02376 1.02310 +/- 0.00200\n", + " 44/1 1.01917 1.02299 +/- 0.00195\n", + " 45/1 1.01631 1.02280 +/- 0.00190\n", + " 46/1 1.02381 1.02282 +/- 0.00185\n", + " 47/1 1.04002 1.02329 +/- 0.00185\n", + " 48/1 1.01059 1.02296 +/- 0.00184\n", + " 49/1 1.02647 1.02305 +/- 0.00179\n", + " 50/1 1.02451 1.02308 +/- 0.00175\n", + " Creating state point statepoint.50.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 5.7635e-01 seconds\n", + " Reading cross sections = 5.4002e-01 seconds\n", + " Total time in simulation = 7.0174e+01 seconds\n", + " Time in transport only = 6.9687e+01 seconds\n", + " Time in inactive batches = 7.1832e+00 seconds\n", + " Time in active batches = 6.2991e+01 seconds\n", + " Time synchronizing fission bank = 3.9991e-02 seconds\n", + " Sampling source sites = 3.4633e-02 seconds\n", + " SEND/RECV source sites = 5.2616e-03 seconds\n", + " Time accumulating tallies = 4.9801e-04 seconds\n", + " Total time for finalization = 1.3501e-05 seconds\n", + " Total time elapsed = 7.0791e+01 seconds\n", + " Calculation Rate (inactive) = 13921.3 particles/second\n", + " Calculation Rate (active) = 6350.11 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.02434 +/- 0.00173\n", + " k-effective (Track-length) = 1.02308 +/- 0.00175\n", + " k-effective (Absorption) = 1.02494 +/- 0.00175\n", + " Combined k-effective = 1.02408 +/- 0.00144\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "# Run OpenMC\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tally Data Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our simulation ran successfully and created statepoint and summary output files. We begin our analysis by instantiating a `StatePoint` object. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the last statepoint file\n", + "sp = openmc.StatePoint('statepoint.50.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint is now ready to be analyzed by the `Library`. We simply have to load the tallies from the statepoint into the `Library` and our `MGXS` objects will compute the cross sections for us under-the-hood." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize MGXS Library with OpenMC statepoint data\n", + "mgxs_lib.load_from_statepoint(sp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Voila! Our multi-group cross sections are now ready to rock 'n roll!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting and Storing MGXS Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `Library` supports a rich API to automate a variety of tasks, including multi-group cross section data retrieval and storage. We will highlight a few of these features here. First, the `Library.get_mgxs(...)` method allows one to extract an `MGXS` object from the `Library` for a particular domain and cross section type. The following cell illustrates how one may extract the `NuFissionXS` object for the fuel cell.\n", + "\n", + "**Note:** The `MGXS.get_mgxs(...)` method will accept either the domain *or* the integer domain ID of interest." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Retrieve the NuFissionXS object for the fuel cell from the library\n", + "fuel_mgxs = mgxs_lib.get_mgxs(fuel_cell, 'nu-fission')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `NuFissionXS` object supports all of the methods described previously in the `openmc.mgxs` tutorials, such as [Pandas](https://pandas.pydata.org/) `DataFrames`:\n", + "Note that since so few histories were simulated, we should expect a few division-by-error errors as some tallies have not yet scored any results." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellgroup innuclidemeanstd. dev.
311U2358.089079e-031.461462e-05
411U2387.358661e-032.302063e-05
511O160.000000e+000.000000e+00
012U2353.617174e-019.467633e-04
112U2386.744743e-071.750450e-09
212O160.000000e+000.000000e+00
\n", + "
" + ], + "text/plain": [ + " cell group in nuclide mean std. dev.\n", + "3 1 1 U235 8.089079e-03 1.461462e-05\n", + "4 1 1 U238 7.358661e-03 2.302063e-05\n", + "5 1 1 O16 0.000000e+00 0.000000e+00\n", + "0 1 2 U235 3.617174e-01 9.467633e-04\n", + "1 1 2 U238 6.744743e-07 1.750450e-09\n", + "2 1 2 O16 0.000000e+00 0.000000e+00" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = fuel_mgxs.get_pandas_dataframe()\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, we can use the `MGXS.print_xs(...)` method to view a string representation of the multi-group cross section data." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multi-Group XS\n", + "\tReaction Type =\tnu-fission\n", + "\tDomain Type =\tcell\n", + "\tDomain ID =\t1\n", + "\tNuclide =\tU235\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t8.09e-03 +/- 1.81e-01%\n", + " Group 2 [0.0 - 0.625 eV]:\t3.62e-01 +/- 2.62e-01%\n", + "\n", + "\tNuclide =\tU238\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t7.36e-03 +/- 3.13e-01%\n", + " Group 2 [0.0 - 0.625 eV]:\t6.74e-07 +/- 2.60e-01%\n", + "\n", + "\tNuclide =\tO16\n", + "\tCross Sections [cm^-1]:\n", + " Group 1 [0.625 - 20000000.0eV]:\t0.00e+00 +/- 0.00e+00%\n", + " Group 2 [0.0 - 0.625 eV]:\t0.00e+00 +/- 0.00e+00%\n", + "\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/romano/openmc/openmc/tallies.py:1269: RuntimeWarning: invalid value encountered in true_divide\n", + " data = self.std_dev[indices] / self.mean[indices]\n" + ] + } + ], + "source": [ + "fuel_mgxs.print_xs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can export the entire `Library` to HDF5 with the `Library.build_hdf5_store(...)` method as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Store the cross section data in an \"mgxs/mgxs.h5\" HDF5 binary file\n", + "mgxs_lib.build_hdf5_store(filename='mgxs.h5', directory='mgxs')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The HDF5 store will contain the numerical multi-group cross section data indexed by domain, nuclide and cross section type. Some data workflows may be optimized by storing and retrieving binary representations of the `MGXS` objects in the `Library`. This feature is supported through the `Library.dump_to_file(...)` and `Library.load_from_file(...)` routines which use Python's [`pickle`](https://docs.python.org/3/library/pickle.html) module. This is illustrated as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Store a Library and its MGXS objects in a pickled binary file \"mgxs/mgxs.pkl\"\n", + "mgxs_lib.dump_to_file(filename='mgxs', directory='mgxs')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a new MGXS Library from the pickled binary file \"mgxs/mgxs.pkl\"\n", + "mgxs_lib = openmc.mgxs.Library.load_from_file(filename='mgxs', directory='mgxs')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `Library` class may be used to leverage the energy condensation features supported by the `MGXS` class. In particular, one can use the `Library.get_condensed_library(...)` with a coarse group structure which is a subset of the original \"fine\" group structure as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a 1-group structure\n", + "coarse_groups = openmc.mgxs.EnergyGroups(group_edges=[0., 20.0e6])\n", + "\n", + "# Create a new MGXS Library on the coarse 1-group structure\n", + "coarse_mgxs_lib = mgxs_lib.get_condensed_library(coarse_groups)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cellgroup innuclidemeanstd. dev.
011U2350.0745560.000144
111U2380.0059760.000019
211O160.0000000.000000
\n", + "
" + ], + "text/plain": [ + " cell group in nuclide mean std. dev.\n", + "0 1 1 U235 0.074556 0.000144\n", + "1 1 1 U238 0.005976 0.000019\n", + "2 1 1 O16 0.000000 0.000000" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Retrieve the NuFissionXS object for the fuel cell from the 1-group library\n", + "coarse_fuel_mgxs = coarse_mgxs_lib.get_mgxs(fuel_cell, 'nu-fission')\n", + "\n", + "# Show the Pandas DataFrame for the 1-group MGXS\n", + "coarse_fuel_mgxs.get_pandas_dataframe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verification with OpenMOC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of course it is always a good idea to verify that one's cross sections are accurate. We can easily do so here with the deterministic transport code [OpenMOC](https://mit-crpg.github.io/OpenMOC/). We first construct an equivalent OpenMOC geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an OpenMOC Geometry from the OpenMC Geometry\n", + "openmoc_geometry = get_openmoc_geometry(mgxs_lib.geometry)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can inject the multi-group cross sections into the equivalent fuel assembly OpenMOC geometry. The `openmoc.materialize` module supports the loading of `Library` objects from OpenMC as illustrated below." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the library into the OpenMOC geometry\n", + "materials = load_openmc_mgxs_lib(mgxs_lib, openmoc_geometry)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are now ready to run OpenMOC to verify our cross-sections from OpenMC." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Initializing a default angular quadrature...\n", + "[ NORMAL ] Initializing 2D tracks...\n", + "[ NORMAL ] Initializing 2D tracks reflections...\n", + "[ NORMAL ] Initializing 2D tracks array...\n", + "[ NORMAL ] Ray tracing for 2D track segmentation...\n", + "[ WARNING ] The Geometry was set with non-infinite z-boundaries and supplied\n", + "[ WARNING ] ... to a 2D TrackGenerator. The min-z boundary was set to -10.00 \n", + "[ WARNING ] ... and the max-z boundary was set to 10.00. Z-boundaries are \n", + "[ WARNING ] ... assumed to be infinite in 2D TrackGenerators.\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 0.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 10.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 20.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 30.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 40.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 50.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 60.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 70.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 80.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 90.02 %\n", + "[ NORMAL ] Progress Segmenting 2D tracks: 100.00 %\n", + "[ NORMAL ] Initializing FSR lookup vectors\n", + "[ NORMAL ] Total number of FSRs 867\n", + "[ RESULT ] Total Track Generation & Segmentation Time...........4.2139E-01 sec\n", + "[ NORMAL ] Initializing MOC eigenvalue solver...\n", + "[ NORMAL ] Initializing solver arrays...\n", + "[ NORMAL ] Centering segments around FSR centroid...\n", + "[ NORMAL ] Max boundary angular flux storage per domain = 0.42 MB\n", + "[ NORMAL ] Max scalar flux storage per domain = 0.01 MB\n", + "[ NORMAL ] Max source storage per domain = 0.01 MB\n", + "[ NORMAL ] Number of azimuthal angles = 32\n", + "[ NORMAL ] Azimuthal ray spacing = 0.100000\n", + "[ NORMAL ] Number of polar angles = 6\n", + "[ NORMAL ] Source type = Flat\n", + "[ NORMAL ] MOC transport undamped\n", + "[ NORMAL ] CMFD acceleration: OFF\n", + "[ NORMAL ] Using 1 threads\n", + "[ NORMAL ] Computing the eigenvalue...\n", + "[ NORMAL ] Iteration 0: k_eff = 0.823216 res = 9.828E-02 delta-k (pcm) =\n", + "[ NORMAL ] ... -17678 D.R. = 0.10\n", + "[ NORMAL ] Iteration 1: k_eff = 0.779788 res = 4.642E-02 delta-k (pcm) =\n", + "[ NORMAL ] ... -4342 D.R. = 0.47\n", + "[ NORMAL ] Iteration 2: k_eff = 0.738779 res = 9.633E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -4100 D.R. = 0.21\n", + "[ NORMAL ] Iteration 3: k_eff = 0.710046 res = 8.556E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -2873 D.R. = 0.89\n", + "[ NORMAL ] Iteration 4: k_eff = 0.688781 res = 5.190E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -2126 D.R. = 0.61\n", + "[ NORMAL ] Iteration 5: k_eff = 0.674128 res = 3.585E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -1465 D.R. = 0.69\n", + "[ NORMAL ] Iteration 6: k_eff = 0.664928 res = 2.516E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -919 D.R. = 0.70\n", + "[ NORMAL ] Iteration 7: k_eff = 0.660304 res = 1.866E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -462 D.R. = 0.74\n", + "[ NORMAL ] Iteration 8: k_eff = 0.659481 res = 1.471E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... -82 D.R. = 0.79\n", + "[ NORMAL ] Iteration 9: k_eff = 0.661799 res = 1.248E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... 231 D.R. = 0.85\n", + "[ NORMAL ] Iteration 10: k_eff = 0.666690 res = 1.123E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... 489 D.R. = 0.90\n", + "[ NORMAL ] Iteration 11: k_eff = 0.673664 res = 1.049E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... 697 D.R. = 0.93\n", + "[ NORMAL ] Iteration 12: k_eff = 0.682301 res = 1.001E-03 delta-k (pcm) =\n", + "[ NORMAL ] ... 863 D.R. = 0.95\n", + "[ NORMAL ] Iteration 13: k_eff = 0.692239 res = 9.638E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 993 D.R. = 0.96\n", + "[ NORMAL ] Iteration 14: k_eff = 0.703171 res = 9.329E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1093 D.R. = 0.97\n", + "[ NORMAL ] Iteration 15: k_eff = 0.714835 res = 9.055E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1166 D.R. = 0.97\n", + "[ NORMAL ] Iteration 16: k_eff = 0.727008 res = 8.803E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1217 D.R. = 0.97\n", + "[ NORMAL ] Iteration 17: k_eff = 0.739503 res = 8.566E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1249 D.R. = 0.97\n", + "[ NORMAL ] Iteration 18: k_eff = 0.752162 res = 8.335E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1265 D.R. = 0.97\n", + "[ NORMAL ] Iteration 19: k_eff = 0.764855 res = 8.108E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1269 D.R. = 0.97\n", + "[ NORMAL ] Iteration 20: k_eff = 0.777472 res = 7.879E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1261 D.R. = 0.97\n", + "[ NORMAL ] Iteration 21: k_eff = 0.789924 res = 7.647E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1245 D.R. = 0.97\n", + "[ NORMAL ] Iteration 22: k_eff = 0.802140 res = 7.410E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1221 D.R. = 0.97\n", + "[ NORMAL ] Iteration 23: k_eff = 0.814061 res = 7.168E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1192 D.R. = 0.97\n", + "[ NORMAL ] Iteration 24: k_eff = 0.825643 res = 6.922E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1158 D.R. = 0.97\n", + "[ NORMAL ] Iteration 25: k_eff = 0.836850 res = 6.672E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1120 D.R. = 0.96\n", + "[ NORMAL ] Iteration 26: k_eff = 0.847658 res = 6.419E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1080 D.R. = 0.96\n", + "[ NORMAL ] Iteration 27: k_eff = 0.858047 res = 6.165E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 1038 D.R. = 0.96\n", + "[ NORMAL ] Iteration 28: k_eff = 0.868008 res = 5.911E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 996 D.R. = 0.96\n", + "[ NORMAL ] Iteration 29: k_eff = 0.877535 res = 5.658E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 952 D.R. = 0.96\n", + "[ NORMAL ] Iteration 30: k_eff = 0.886625 res = 5.409E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 909 D.R. = 0.96\n", + "[ NORMAL ] Iteration 31: k_eff = 0.895281 res = 5.163E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 865 D.R. = 0.95\n", + "[ NORMAL ] Iteration 32: k_eff = 0.903509 res = 4.921E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 822 D.R. = 0.95\n", + "[ NORMAL ] Iteration 33: k_eff = 0.911317 res = 4.685E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 780 D.R. = 0.95\n", + "[ NORMAL ] Iteration 34: k_eff = 0.918715 res = 4.456E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 739 D.R. = 0.95\n", + "[ NORMAL ] Iteration 35: k_eff = 0.925715 res = 4.232E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 699 D.R. = 0.95\n", + "[ NORMAL ] Iteration 36: k_eff = 0.932329 res = 4.016E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 661 D.R. = 0.95\n", + "[ NORMAL ] Iteration 37: k_eff = 0.938571 res = 3.807E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 624 D.R. = 0.95\n", + "[ NORMAL ] Iteration 38: k_eff = 0.944455 res = 3.606E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 588 D.R. = 0.95\n", + "[ NORMAL ] Iteration 39: k_eff = 0.949996 res = 3.413E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 554 D.R. = 0.95\n", + "[ NORMAL ] Iteration 40: k_eff = 0.955210 res = 3.227E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 521 D.R. = 0.95\n", + "[ NORMAL ] Iteration 41: k_eff = 0.960110 res = 3.049E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 490 D.R. = 0.94\n", + "[ NORMAL ] Iteration 42: k_eff = 0.964713 res = 2.880E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 460 D.R. = 0.94\n", + "[ NORMAL ] Iteration 43: k_eff = 0.969032 res = 2.717E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 431 D.R. = 0.94\n", + "[ NORMAL ] Iteration 44: k_eff = 0.973082 res = 2.562E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 405 D.R. = 0.94\n", + "[ NORMAL ] Iteration 45: k_eff = 0.976877 res = 2.414E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 379 D.R. = 0.94\n", + "[ NORMAL ] Iteration 46: k_eff = 0.980431 res = 2.274E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 355 D.R. = 0.94\n", + "[ NORMAL ] Iteration 47: k_eff = 0.983757 res = 2.140E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 332 D.R. = 0.94\n", + "[ NORMAL ] Iteration 48: k_eff = 0.986869 res = 2.014E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 311 D.R. = 0.94\n", + "[ NORMAL ] Iteration 49: k_eff = 0.989777 res = 1.894E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 290 D.R. = 0.94\n", + "[ NORMAL ] Iteration 50: k_eff = 0.992495 res = 1.780E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 271 D.R. = 0.94\n", + "[ NORMAL ] Iteration 51: k_eff = 0.995033 res = 1.672E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 253 D.R. = 0.94\n", + "[ NORMAL ] Iteration 52: k_eff = 0.997402 res = 1.569E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 236 D.R. = 0.94\n", + "[ NORMAL ] Iteration 53: k_eff = 0.999613 res = 1.473E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 221 D.R. = 0.94\n", + "[ NORMAL ] Iteration 54: k_eff = 1.001675 res = 1.382E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 206 D.R. = 0.94\n", + "[ NORMAL ] Iteration 55: k_eff = 1.003597 res = 1.296E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 192 D.R. = 0.94\n", + "[ NORMAL ] Iteration 56: k_eff = 1.005388 res = 1.215E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 179 D.R. = 0.94\n", + "[ NORMAL ] Iteration 57: k_eff = 1.007057 res = 1.138E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 166 D.R. = 0.94\n", + "[ NORMAL ] Iteration 58: k_eff = 1.008612 res = 1.066E-04 delta-k (pcm) =\n", + "[ NORMAL ] ... 155 D.R. = 0.94\n", + "[ NORMAL ] Iteration 59: k_eff = 1.010059 res = 9.980E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 144 D.R. = 0.94\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ NORMAL ] Iteration 60: k_eff = 1.011406 res = 9.342E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 134 D.R. = 0.94\n", + "[ NORMAL ] Iteration 61: k_eff = 1.012659 res = 8.740E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 125 D.R. = 0.94\n", + "[ NORMAL ] Iteration 62: k_eff = 1.013825 res = 8.175E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 116 D.R. = 0.94\n", + "[ NORMAL ] Iteration 63: k_eff = 1.014909 res = 7.642E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 108 D.R. = 0.93\n", + "[ NORMAL ] Iteration 64: k_eff = 1.015917 res = 7.142E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 100 D.R. = 0.93\n", + "[ NORMAL ] Iteration 65: k_eff = 1.016853 res = 6.675E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 93 D.R. = 0.93\n", + "[ NORMAL ] Iteration 66: k_eff = 1.017724 res = 6.235E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 87 D.R. = 0.93\n", + "[ NORMAL ] Iteration 67: k_eff = 1.018533 res = 5.822E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 80 D.R. = 0.93\n", + "[ NORMAL ] Iteration 68: k_eff = 1.019284 res = 5.436E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 75 D.R. = 0.93\n", + "[ NORMAL ] Iteration 69: k_eff = 1.019982 res = 5.074E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 69 D.R. = 0.93\n", + "[ NORMAL ] Iteration 70: k_eff = 1.020630 res = 4.734E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 64 D.R. = 0.93\n", + "[ NORMAL ] Iteration 71: k_eff = 1.021232 res = 4.417E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 60 D.R. = 0.93\n", + "[ NORMAL ] Iteration 72: k_eff = 1.021790 res = 4.119E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 55 D.R. = 0.93\n", + "[ NORMAL ] Iteration 73: k_eff = 1.022308 res = 3.841E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 51 D.R. = 0.93\n", + "[ NORMAL ] Iteration 74: k_eff = 1.022789 res = 3.579E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 48 D.R. = 0.93\n", + "[ NORMAL ] Iteration 75: k_eff = 1.023235 res = 3.336E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 44 D.R. = 0.93\n", + "[ NORMAL ] Iteration 76: k_eff = 1.023648 res = 3.107E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 41 D.R. = 0.93\n", + "[ NORMAL ] Iteration 77: k_eff = 1.024032 res = 2.897E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 38 D.R. = 0.93\n", + "[ NORMAL ] Iteration 78: k_eff = 1.024388 res = 2.696E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 35 D.R. = 0.93\n", + "[ NORMAL ] Iteration 79: k_eff = 1.024718 res = 2.510E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 32 D.R. = 0.93\n", + "[ NORMAL ] Iteration 80: k_eff = 1.025024 res = 2.338E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 30 D.R. = 0.93\n", + "[ NORMAL ] Iteration 81: k_eff = 1.025307 res = 2.175E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 28 D.R. = 0.93\n", + "[ NORMAL ] Iteration 82: k_eff = 1.025570 res = 2.025E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 26 D.R. = 0.93\n", + "[ NORMAL ] Iteration 83: k_eff = 1.025814 res = 1.886E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 24 D.R. = 0.93\n", + "[ NORMAL ] Iteration 84: k_eff = 1.026039 res = 1.752E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 22 D.R. = 0.93\n", + "[ NORMAL ] Iteration 85: k_eff = 1.026249 res = 1.628E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 20 D.R. = 0.93\n", + "[ NORMAL ] Iteration 86: k_eff = 1.026442 res = 1.517E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 19 D.R. = 0.93\n", + "[ NORMAL ] Iteration 87: k_eff = 1.026622 res = 1.408E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 17 D.R. = 0.93\n", + "[ NORMAL ] Iteration 88: k_eff = 1.026788 res = 1.308E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 16 D.R. = 0.93\n", + "[ NORMAL ] Iteration 89: k_eff = 1.026942 res = 1.218E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 15 D.R. = 0.93\n", + "[ NORMAL ] Iteration 90: k_eff = 1.027085 res = 1.132E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 14 D.R. = 0.93\n", + "[ NORMAL ] Iteration 91: k_eff = 1.027217 res = 1.049E-05 delta-k (pcm) =\n", + "[ NORMAL ] ... 13 D.R. = 0.93\n", + "[ NORMAL ] Iteration 92: k_eff = 1.027339 res = 9.760E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 12 D.R. = 0.93\n", + "[ NORMAL ] Iteration 93: k_eff = 1.027453 res = 9.076E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 11 D.R. = 0.93\n", + "[ NORMAL ] Iteration 94: k_eff = 1.027557 res = 8.434E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 10 D.R. = 0.93\n", + "[ NORMAL ] Iteration 95: k_eff = 1.027655 res = 7.827E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 9 D.R. = 0.93\n", + "[ NORMAL ] Iteration 96: k_eff = 1.027744 res = 7.266E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 8 D.R. = 0.93\n", + "[ NORMAL ] Iteration 97: k_eff = 1.027828 res = 6.737E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 8 D.R. = 0.93\n", + "[ NORMAL ] Iteration 98: k_eff = 1.027905 res = 6.255E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 7 D.R. = 0.93\n", + "[ NORMAL ] Iteration 99: k_eff = 1.027976 res = 5.803E-06 delta-k (pcm) =\n", + "[ NORMAL ] ... 7 D.R. = 0.93\n", + "[ NORMAL ] Iteration 100: k_eff = 1.028042 res = 5.383E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 0.93\n", + "[ NORMAL ] Iteration 101: k_eff = 1.028103 res = 5.017E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 6 D.R. = 0.93\n", + "[ NORMAL ] Iteration 102: k_eff = 1.028160 res = 4.618E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 0.92\n", + "[ NORMAL ] Iteration 103: k_eff = 1.028212 res = 4.306E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 5 D.R. = 0.93\n", + "[ NORMAL ] Iteration 104: k_eff = 1.028260 res = 3.999E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.93\n", + "[ NORMAL ] Iteration 105: k_eff = 1.028305 res = 3.706E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.93\n", + "[ NORMAL ] Iteration 106: k_eff = 1.028347 res = 3.429E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 4 D.R. = 0.93\n", + "[ NORMAL ] Iteration 107: k_eff = 1.028385 res = 3.213E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.94\n", + "[ NORMAL ] Iteration 108: k_eff = 1.028420 res = 2.943E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.92\n", + "[ NORMAL ] Iteration 109: k_eff = 1.028453 res = 2.740E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.93\n", + "[ NORMAL ] Iteration 110: k_eff = 1.028484 res = 2.531E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 3 D.R. = 0.92\n", + "[ NORMAL ] Iteration 111: k_eff = 1.028512 res = 2.369E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.94\n", + "[ NORMAL ] Iteration 112: k_eff = 1.028538 res = 2.186E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.92\n", + "[ NORMAL ] Iteration 113: k_eff = 1.028562 res = 2.026E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.93\n", + "[ NORMAL ] Iteration 114: k_eff = 1.028584 res = 1.858E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.92\n", + "[ NORMAL ] Iteration 115: k_eff = 1.028604 res = 1.760E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 2 D.R. = 0.95\n", + "[ NORMAL ] Iteration 116: k_eff = 1.028623 res = 1.612E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.92\n", + "[ NORMAL ] Iteration 117: k_eff = 1.028641 res = 1.496E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.93\n", + "[ NORMAL ] Iteration 118: k_eff = 1.028657 res = 1.382E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.92\n", + "[ NORMAL ] Iteration 119: k_eff = 1.028672 res = 1.293E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.94\n", + "[ NORMAL ] Iteration 120: k_eff = 1.028686 res = 1.191E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.92\n", + "[ NORMAL ] Iteration 121: k_eff = 1.028699 res = 1.112E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.93\n", + "[ NORMAL ] Iteration 122: k_eff = 1.028711 res = 1.005E-06 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.90\n", + "[ NORMAL ] Iteration 123: k_eff = 1.028722 res = 9.443E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.94\n", + "[ NORMAL ] Iteration 124: k_eff = 1.028732 res = 8.583E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 1 D.R. = 0.91\n", + "[ NORMAL ] Iteration 125: k_eff = 1.028742 res = 8.028E-07 delta-k (pcm)\n", + "[ NORMAL ] ... = 0 D.R. = 0.94\n" + ] + } + ], + "source": [ + "# Generate tracks for OpenMOC\n", + "track_generator = openmoc.TrackGenerator(openmoc_geometry, num_azim=32, azim_spacing=0.1)\n", + "track_generator.generateTracks()\n", + "\n", + "# Run OpenMOC\n", + "solver = openmoc.CPUSolver(track_generator)\n", + "solver.computeEigenvalue()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We report the eigenvalues computed by OpenMC and OpenMOC here together to summarize our results." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "openmc keff = 1.024078\n", + "openmoc keff = 1.028742\n", + "bias [pcm]: 466.4\n" + ] + } + ], + "source": [ + "# Print report of keff and bias with OpenMC\n", + "openmoc_keff = solver.getKeff()\n", + "openmc_keff = sp.k_combined.nominal_value\n", + "bias = (openmoc_keff - openmc_keff) * 1e5\n", + "\n", + "print('openmc keff = {0:1.6f}'.format(openmc_keff))\n", + "print('openmoc keff = {0:1.6f}'.format(openmoc_keff))\n", + "print('bias [pcm]: {0:1.1f}'.format(bias))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is a non-trivial bias between the eigenvalues computed by OpenMC and OpenMOC. One can show that these biases do not converge to <100 pcm with more particle histories. For heterogeneous geometries, additional measures must be taken to address the following three sources of bias:\n", + "\n", + "* Appropriate transport-corrected cross sections\n", + "* Spatial discretization of OpenMOC's mesh\n", + "* Constant-in-angle multi-group cross sections" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flux and Pin Power Visualizations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will conclude this tutorial by illustrating how to visualize the fission rates computed by OpenMOC and OpenMC. First, we extract volume-integrated fission rates from OpenMC's mesh fission rate tally for each pin cell in the fuel assembly." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the OpenMC fission rate mesh tally data\n", + "mesh_tally = sp.get_tally(name='mesh tally')\n", + "openmc_fission_rates = mesh_tally.get_values(scores=['nu-fission'])\n", + "\n", + "# Reshape array to 2D for plotting\n", + "openmc_fission_rates.shape = (17,17)\n", + "\n", + "# Normalize to the average pin power\n", + "openmc_fission_rates /= np.mean(openmc_fission_rates[openmc_fission_rates > 0.])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we extract OpenMOC's volume-averaged fission rates into a 2D 17x17 NumPy array." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# Create OpenMOC Mesh on which to tally fission rates\n", + "openmoc_mesh = openmoc.process.Mesh()\n", + "openmoc_mesh.dimension = np.array(mesh.dimension)\n", + "openmoc_mesh.lower_left = np.array(mesh.lower_left)\n", + "openmoc_mesh.upper_right = np.array(mesh.upper_right)\n", + "openmoc_mesh.width = openmoc_mesh.upper_right - openmoc_mesh.lower_left\n", + "openmoc_mesh.width /= openmoc_mesh.dimension\n", + "\n", + "# Tally OpenMOC fission rates on the Mesh\n", + "openmoc_fission_rates = openmoc_mesh.tally_fission_rates(solver)\n", + "openmoc_fission_rates = np.squeeze(openmoc_fission_rates)\n", + "openmoc_fission_rates = np.fliplr(openmoc_fission_rates)\n", + "\n", + "# Normalize to the average pin fission rate\n", + "openmoc_fission_rates /= np.mean(openmoc_fission_rates[openmoc_fission_rates > 0.])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can easily use Matplotlib to visualize the fission rates from OpenMC and OpenMOC side-by-side." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'OpenMOC Fission Rates')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Ignore zero fission rates in guide tubes with Matplotlib color scheme\n", + "openmc_fission_rates[openmc_fission_rates == 0] = np.nan\n", + "openmoc_fission_rates[openmoc_fission_rates == 0] = np.nan\n", + "\n", + "# Plot OpenMC's fission rates in the left subplot\n", + "fig = plt.subplot(121)\n", + "plt.imshow(openmc_fission_rates, interpolation='none', cmap='jet')\n", + "plt.title('OpenMC Fission Rates')\n", + "\n", + "# Plot OpenMOC's fission rates in the right subplot\n", + "fig2 = plt.subplot(122)\n", + "plt.imshow(openmoc_fission_rates, interpolation='none', cmap='jet')\n", + "plt.title('OpenMOC Fission Rates')" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/post-processing.ipynb b/post-processing.ipynb new file mode 100644 index 0000000..8d9e109 --- /dev/null +++ b/post-processing.ipynb @@ -0,0 +1,980 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Post Processing\n", + "This notebook demonstrates some basic post-processing tasks that can be performed with the Python API, such as plotting a 2D mesh tally and plotting neutron source sites from an eigenvalue calculation. The problem we will use is a simple reflected pin-cell." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from IPython.display import Image\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import openmc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Input Files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we need to define materials that will be used in the problem. We'll create three materials for the fuel, water, and cladding of the fuel pin." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 1.6 enriched fuel\n", + "fuel = openmc.Material(name='1.6% Fuel')\n", + "fuel.set_density('g/cm3', 10.31341)\n", + "fuel.add_nuclide('U235', 3.7503e-4)\n", + "fuel.add_nuclide('U238', 2.2625e-2)\n", + "fuel.add_nuclide('O16', 4.6007e-2)\n", + "\n", + "# borated water\n", + "water = openmc.Material(name='Borated Water')\n", + "water.set_density('g/cm3', 0.740582)\n", + "water.add_nuclide('H1', 4.9457e-2)\n", + "water.add_nuclide('O16', 2.4732e-2)\n", + "water.add_nuclide('B10', 8.0042e-6)\n", + "\n", + "# zircaloy\n", + "zircaloy = openmc.Material(name='Zircaloy')\n", + "zircaloy.set_density('g/cm3', 6.55)\n", + "zircaloy.add_nuclide('Zr90', 7.2758e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With our three materials, we can now create a materials file object that can be exported to an actual XML file." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate a Materials collection\n", + "materials = openmc.Materials([fuel, water, zircaloy])\n", + "\n", + "# Export to \"materials.xml\"\n", + "materials.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's move on to the geometry. Our problem will have three regions for the fuel, the clad, and the surrounding coolant. The first step is to create the bounding surfaces -- in this case two cylinders and six reflective planes." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Create cylinders for the fuel and clad\n", + "fuel_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.39218)\n", + "clad_outer_radius = openmc.ZCylinder(x0=0.0, y0=0.0, r=0.45720)\n", + "\n", + "# Create boundary planes to surround the geometry\n", + "min_x = openmc.XPlane(x0=-0.63, boundary_type='reflective')\n", + "max_x = openmc.XPlane(x0=+0.63, boundary_type='reflective')\n", + "min_y = openmc.YPlane(y0=-0.63, boundary_type='reflective')\n", + "max_y = openmc.YPlane(y0=+0.63, boundary_type='reflective')\n", + "min_z = openmc.ZPlane(z0=-0.63, boundary_type='reflective')\n", + "max_z = openmc.ZPlane(z0=+0.63, boundary_type='reflective')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the surfaces defined, we can now create cells that are defined by intersections of half-spaces created by the surfaces." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a Universe to encapsulate a fuel pin\n", + "pin_cell_universe = openmc.Universe(name='1.6% Fuel Pin')\n", + "\n", + "# Create fuel Cell\n", + "fuel_cell = openmc.Cell(name='1.6% Fuel')\n", + "fuel_cell.fill = fuel\n", + "fuel_cell.region = -fuel_outer_radius\n", + "pin_cell_universe.add_cell(fuel_cell)\n", + "\n", + "# Create a clad Cell\n", + "clad_cell = openmc.Cell(name='1.6% Clad')\n", + "clad_cell.fill = zircaloy\n", + "clad_cell.region = +fuel_outer_radius & -clad_outer_radius\n", + "pin_cell_universe.add_cell(clad_cell)\n", + "\n", + "# Create a moderator Cell\n", + "moderator_cell = openmc.Cell(name='1.6% Moderator')\n", + "moderator_cell.fill = water\n", + "moderator_cell.region = +clad_outer_radius\n", + "pin_cell_universe.add_cell(moderator_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OpenMC requires that there is a \"root\" universe. Let us create a root cell that is filled by the pin cell universe and then assign it to the root universe." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Create root Cell\n", + "root_cell = openmc.Cell(name='root cell')\n", + "root_cell.fill = pin_cell_universe\n", + "\n", + "# Add boundary planes\n", + "root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z\n", + "\n", + "# Create root Universe\n", + "root_universe = openmc.Universe(universe_id=0, name='root universe')\n", + "root_universe.add_cell(root_cell)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now must create a geometry that is assigned a root universe, put the geometry into a geometry file, and export it to XML." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Create Geometry and set root Universe\n", + "geometry = openmc.Geometry(root_universe)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Export to \"geometry.xml\"\n", + "geometry.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the geometry and materials finished, we now just need to define simulation parameters. In this case, we will use 10 inactive batches and 90 active batches each with 5000 particles." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# OpenMC simulation parameters\n", + "settings = openmc.Settings()\n", + "settings.batches = 100\n", + "settings.inactive = 10\n", + "settings.particles = 5000\n", + "\n", + "# Create an initial uniform spatial source distribution over fissionable zones\n", + "bounds = [-0.63, -0.63, -0.63, 0.63, 0.63, 0.63]\n", + "uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True)\n", + "settings.source = openmc.Source(space=uniform_dist)\n", + "\n", + "# Export to \"settings.xml\"\n", + "settings.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us also create a plot file that we can use to verify that our pin cell geometry was created successfully." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEXpgJFyEhJNv8T///9xF1FxAAAAAWJLR0QDEQxM8gAAAAd0SU1FB+MHEwEWFzIBvcoAAAKlSURBVGje7ZrBscIwDETxwSWkn5TAgXCgBPqhBA6kyj/fDhCIJa2zZAwz0pmHpZWdSazd7Tw8PDw8PDw8vinCMBzW03HIsRLvhnv0HL7qD+IwjzXKzaNaxeEt9kz21RWEBV5XQbfka3pQWL4qgdLyNQkUcbwFT/FP4zjWt+D+++OY4laZQJgtnqNOwe5l9XkGmIIL/PEHUAGTeuc5P15wBbu34ucSIAXkX77h4xUtIBSXnxIAOhCLy98TANNfLj8lYBYQCuLPWmAWEBe9f90DUPdKy08JWB0U1HsoaAgQxPSnAgwBopz+VABQvoDnAnqTP0r8zealzfPcQqqAQSs/C6AKGLX0pwKs8uX0cwGaAHr6uYC9wSt46qDCB4RXBDTkMwWMhnxZQF3+s8pf1AZY5VsCWuVnAUQ+YPxB43X5koAiH035soCa/AaeBOw34m359AaQPCK/1oAAyJ8aIPBI+7QGRkD+3IBt+A6QPzeg34SH2pcauN+Kt9uXGljkse0jb6BP8AD+vwGKPLZ95A0UofbnDbAFj20/eQN+gD8h/LgRD25/8QCA2088AD/Oo8dPOoDo8ZMOoPPNeej4pwdAgUcfX9IDzHnnf5lnz88XnH/nSf4M8cIL7I+/P3yCP0G88P7W+v2z9ft36+8P9vuJ/X5r/f3Jfj83//5vff/R+v6Hvb9i78/Y+7vW94/N71/Z+2P2/pq9P2fv7+n5ATu/YOcn7PyGnR+x8yt6ftYN3PzOENCcH7LzS3Z+Ss9vO62DV5uPmgAXSz5+fs7O72n/QBQLwPwLrH+C9W/Q/hHWv8L6Z2j/ThZgvX+I9S/R/inWv8X6x2j/Guufo/17rH+Q9S/S/knWv0n7R2n/Kuufpf27tH+Y9i/vWP+0h4eHh4eHh8cW8QcxLJDBvLKoigAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wNy0xOVQwNjoyMjoyMy0wNTowMKrH6zcAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDctMTlUMDY6MjI6MjMtMDU6MDDbmlOLAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot = openmc.Plot.from_geometry(geometry)\n", + "plot.pixels = (250, 250)\n", + "plot.to_ipython_image()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see from the plot, we have a nice pin cell with fuel, cladding, and water! Before we run our simulation, we need to tell the code what we want to tally. The following code shows how to create a 2D mesh tally." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate an empty Tallies object\n", + "tallies = openmc.Tallies()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Create mesh which will be used for tally\n", + "mesh = openmc.RegularMesh()\n", + "mesh.dimension = [100, 100]\n", + "mesh.lower_left = [-0.63, -0.63]\n", + "mesh.upper_right = [0.63, 0.63]\n", + "\n", + "# Create mesh filter for tally\n", + "mesh_filter = openmc.MeshFilter(mesh)\n", + "\n", + "# Create mesh tally to score flux and fission rate\n", + "tally = openmc.Tally(name='flux')\n", + "tally.filters = [mesh_filter]\n", + "tally.scores = ['flux', 'fission']\n", + "tallies.append(tally)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Export to \"tallies.xml\"\n", + "tallies.export_to_xml()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we a have a complete set of inputs, so we can go ahead and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " %%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%%%%%%%%%\n", + " ################## %%%%%%%%%%%%%%%%%%%%%%%\n", + " ################### %%%%%%%%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%%%%%%\n", + " ##################### %%%%%%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%%\n", + " ####################### %%%%%%%%%%%%%%%%%\n", + " ###################### %%%%%%%%%%%%%%%%%\n", + " #################### %%%%%%%%%%%%%%%%%\n", + " ################# %%%%%%%%%%%%%%%%%\n", + " ############### %%%%%%%%%%%%%%%%\n", + " ############ %%%%%%%%%%%%%%%\n", + " ######## %%%%%%%%%%%%%%\n", + " %%%%%%%%%%%\n", + "\n", + " | The OpenMC Monte Carlo Code\n", + " Copyright | 2011-2019 MIT and OpenMC contributors\n", + " License | http://openmc.readthedocs.io/en/latest/license.html\n", + " Version | 0.11.0-dev\n", + " Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n", + " Date/Time | 2019-07-19 06:22:24\n", + " OpenMP Threads | 4\n", + "\n", + " Reading settings XML file...\n", + " Reading cross sections XML file...\n", + " Reading materials XML file...\n", + " Reading geometry XML file...\n", + " Reading U235 from /opt/data/hdf5/nndc_hdf5_v15/U235.h5\n", + " Reading U238 from /opt/data/hdf5/nndc_hdf5_v15/U238.h5\n", + " Reading O16 from /opt/data/hdf5/nndc_hdf5_v15/O16.h5\n", + " Reading H1 from /opt/data/hdf5/nndc_hdf5_v15/H1.h5\n", + " Reading B10 from /opt/data/hdf5/nndc_hdf5_v15/B10.h5\n", + " Reading Zr90 from /opt/data/hdf5/nndc_hdf5_v15/Zr90.h5\n", + " Maximum neutron transport energy: 20000000.000000 eV for U235\n", + " Reading tallies XML file...\n", + " Writing summary.h5 file...\n", + " Initializing source particles...\n", + "\n", + " ====================> K EIGENVALUE SIMULATION <====================\n", + "\n", + " Bat./Gen. k Average k\n", + " ========= ======== ====================\n", + " 1/1 1.04359\n", + " 2/1 1.04323\n", + " 3/1 1.04711\n", + " 4/1 1.03892\n", + " 5/1 1.02459\n", + " 6/1 1.03936\n", + " 7/1 1.03529\n", + " 8/1 1.01590\n", + " 9/1 1.03060\n", + " 10/1 1.02892\n", + " 11/1 1.03987\n", + " 12/1 1.04395 1.04191 +/- 0.00204\n", + " 13/1 1.04971 1.04451 +/- 0.00285\n", + " 14/1 1.03880 1.04308 +/- 0.00247\n", + " 15/1 1.03091 1.04065 +/- 0.00310\n", + " 16/1 1.03618 1.03990 +/- 0.00264\n", + " 17/1 1.04109 1.04007 +/- 0.00223\n", + " 18/1 1.02978 1.03879 +/- 0.00232\n", + " 19/1 1.06363 1.04155 +/- 0.00344\n", + " 20/1 1.06549 1.04394 +/- 0.00390\n", + " 21/1 1.03469 1.04310 +/- 0.00362\n", + " 22/1 1.01925 1.04111 +/- 0.00386\n", + " 23/1 1.03268 1.04046 +/- 0.00361\n", + " 24/1 1.03906 1.04036 +/- 0.00334\n", + " 25/1 1.02632 1.03943 +/- 0.00325\n", + " 26/1 1.03906 1.03940 +/- 0.00304\n", + " 27/1 1.05058 1.04006 +/- 0.00293\n", + " 28/1 1.03248 1.03964 +/- 0.00279\n", + " 29/1 1.04076 1.03970 +/- 0.00264\n", + " 30/1 1.00994 1.03821 +/- 0.00292\n", + " 31/1 1.04785 1.03867 +/- 0.00281\n", + " 32/1 1.03080 1.03831 +/- 0.00270\n", + " 33/1 1.01862 1.03746 +/- 0.00272\n", + " 34/1 1.05370 1.03813 +/- 0.00269\n", + " 35/1 1.02226 1.03750 +/- 0.00266\n", + " 36/1 1.02862 1.03716 +/- 0.00258\n", + " 37/1 1.04790 1.03755 +/- 0.00251\n", + " 38/1 1.03762 1.03756 +/- 0.00242\n", + " 39/1 1.02255 1.03704 +/- 0.00239\n", + " 40/1 1.06094 1.03784 +/- 0.00245\n", + " 41/1 1.03842 1.03786 +/- 0.00237\n", + " 42/1 1.00628 1.03687 +/- 0.00249\n", + " 43/1 1.04916 1.03724 +/- 0.00245\n", + " 44/1 1.06237 1.03798 +/- 0.00248\n", + " 45/1 1.08153 1.03922 +/- 0.00271\n", + " 46/1 1.05649 1.03970 +/- 0.00268\n", + " 47/1 1.06265 1.04032 +/- 0.00268\n", + " 48/1 1.05728 1.04077 +/- 0.00265\n", + " 49/1 1.07343 1.04161 +/- 0.00271\n", + " 50/1 1.04640 1.04173 +/- 0.00265\n", + " 51/1 1.05143 1.04196 +/- 0.00259\n", + " 52/1 1.03639 1.04183 +/- 0.00253\n", + " 53/1 1.04846 1.04199 +/- 0.00248\n", + " 54/1 1.02435 1.04158 +/- 0.00245\n", + " 55/1 1.04806 1.04173 +/- 0.00240\n", + " 56/1 1.04798 1.04186 +/- 0.00235\n", + " 57/1 1.06621 1.04238 +/- 0.00236\n", + " 58/1 1.05734 1.04269 +/- 0.00233\n", + " 59/1 1.04581 1.04276 +/- 0.00228\n", + " 60/1 1.02682 1.04244 +/- 0.00226\n", + " 61/1 1.05971 1.04278 +/- 0.00224\n", + " 62/1 1.02357 1.04241 +/- 0.00223\n", + " 63/1 1.02645 1.04211 +/- 0.00221\n", + " 64/1 1.00711 1.04146 +/- 0.00226\n", + " 65/1 1.06171 1.04183 +/- 0.00225\n", + " 66/1 1.03444 1.04170 +/- 0.00221\n", + " 67/1 1.05875 1.04199 +/- 0.00219\n", + " 68/1 1.04640 1.04207 +/- 0.00216\n", + " 69/1 1.04376 1.04210 +/- 0.00212\n", + " 70/1 1.07078 1.04258 +/- 0.00214\n", + " 71/1 1.03916 1.04252 +/- 0.00210\n", + " 72/1 1.01843 1.04213 +/- 0.00211\n", + " 73/1 1.03666 1.04205 +/- 0.00207\n", + " 74/1 1.04625 1.04211 +/- 0.00204\n", + " 75/1 1.05277 1.04228 +/- 0.00202\n", + " 76/1 1.04944 1.04238 +/- 0.00199\n", + " 77/1 1.01898 1.04203 +/- 0.00199\n", + " 78/1 1.03283 1.04190 +/- 0.00197\n", + " 79/1 1.02304 1.04163 +/- 0.00196\n", + " 80/1 1.01539 1.04125 +/- 0.00196\n", + " 81/1 1.03988 1.04123 +/- 0.00194\n", + " 82/1 1.02138 1.04096 +/- 0.00193\n", + " 83/1 1.02473 1.04073 +/- 0.00192\n", + " 84/1 1.03810 1.04070 +/- 0.00189\n", + " 85/1 1.07438 1.04115 +/- 0.00192\n", + " 86/1 1.03048 1.04101 +/- 0.00190\n", + " 87/1 1.06778 1.04135 +/- 0.00191\n", + " 88/1 1.07341 1.04177 +/- 0.00192\n", + " 89/1 1.06729 1.04209 +/- 0.00193\n", + " 90/1 1.05069 1.04220 +/- 0.00191\n", + " 91/1 1.07675 1.04262 +/- 0.00193\n", + " 92/1 1.06470 1.04289 +/- 0.00193\n", + " 93/1 1.02609 1.04269 +/- 0.00191\n", + " 94/1 1.04761 1.04275 +/- 0.00189\n", + " 95/1 1.08802 1.04328 +/- 0.00194\n", + " 96/1 1.04162 1.04326 +/- 0.00192\n", + " 97/1 1.04573 1.04329 +/- 0.00190\n", + " 98/1 1.03232 1.04317 +/- 0.00188\n", + " 99/1 1.03473 1.04307 +/- 0.00186\n", + " 100/1 1.04505 1.04309 +/- 0.00184\n", + " Creating state point statepoint.100.h5...\n", + "\n", + " =======================> TIMING STATISTICS <=======================\n", + "\n", + " Total time for initialization = 6.4445e-01 seconds\n", + " Reading cross sections = 6.1129e-01 seconds\n", + " Total time in simulation = 2.0000e+02 seconds\n", + " Time in transport only = 1.9970e+02 seconds\n", + " Time in inactive batches = 2.9966e+00 seconds\n", + " Time in active batches = 1.9701e+02 seconds\n", + " Time synchronizing fission bank = 4.0040e-02 seconds\n", + " Sampling source sites = 3.1522e-02 seconds\n", + " SEND/RECV source sites = 8.3459e-03 seconds\n", + " Time accumulating tallies = 9.3582e-03 seconds\n", + " Total time for finalization = 4.6582e-02 seconds\n", + " Total time elapsed = 2.0072e+02 seconds\n", + " Calculation Rate (inactive) = 16685.4 particles/second\n", + " Calculation Rate (active) = 2284.19 particles/second\n", + "\n", + " ============================> RESULTS <============================\n", + "\n", + " k-effective (Collision) = 1.04342 +/- 0.00159\n", + " k-effective (Track-length) = 1.04309 +/- 0.00184\n", + " k-effective (Absorption) = 1.04107 +/- 0.00140\n", + " Combined k-effective = 1.04195 +/- 0.00117\n", + " Leakage Fraction = 0.00000 +/- 0.00000\n", + "\n" + ] + } + ], + "source": [ + "# Run OpenMC!\n", + "openmc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tally Data Processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our simulation ran successfully and created a statepoint file with all the tally data in it. We begin our analysis here loading the statepoint file and 'reading' the results. By default, data from the statepoint file is only read into memory when it is requested. This helps keep the memory use to a minimum even when a statepoint file may be huge." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Load the statepoint file\n", + "sp = openmc.StatePoint('statepoint.100.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we need to get the tally, which can be done with the ``StatePoint.get_tally(...)`` method." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tally\n", + "\tID =\t1\n", + "\tName =\tflux\n", + "\tFilters =\tMeshFilter\n", + "\tNuclides =\ttotal \n", + "\tScores =\t['flux', 'fission']\n", + "\tEstimator =\ttracklength\n", + "\n" + ] + } + ], + "source": [ + "tally = sp.get_tally(scores=['flux'])\n", + "print(tally)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statepoint file actually stores the sum and sum-of-squares for each tally bin from which the mean and variance can be calculated as described [here](../methods/tallies.rst#variance). The sum and sum-of-squares can be accessed using the ``sum`` and ``sum_sq`` properties:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.40767451, 0. ]],\n", + "\n", + " [[0.40933814, 0. ]],\n", + "\n", + " [[0.4119165 , 0. ]],\n", + "\n", + " ...,\n", + "\n", + " [[0.40854327, 0. ]],\n", + "\n", + " [[0.40970805, 0. ]],\n", + "\n", + " [[0.40948065, 0. ]]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tally.sum" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, the mean and standard deviation of the mean are usually what you are more interested in. The Tally class also has properties ``mean`` and ``std_dev`` which automatically calculate these statistics on-the-fly." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10000, 1, 2)\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[[0.00452972, 0. ]],\n", + " \n", + " [[0.0045482 , 0. ]],\n", + " \n", + " [[0.00457685, 0. ]],\n", + " \n", + " ...,\n", + " \n", + " [[0.00453937, 0. ]],\n", + " \n", + " [[0.00455231, 0. ]],\n", + " \n", + " [[0.00454978, 0. ]]]),\n", + " array([[[2.03553236e-05, 0.00000000e+00]],\n", + " \n", + " [[1.83847389e-05, 0.00000000e+00]],\n", + " \n", + " [[1.68647098e-05, 0.00000000e+00]],\n", + " \n", + " ...,\n", + " \n", + " [[1.71606078e-05, 0.00000000e+00]],\n", + " \n", + " [[1.87645811e-05, 0.00000000e+00]],\n", + " \n", + " [[1.94447454e-05, 0.00000000e+00]]]))" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(tally.mean.shape)\n", + "(tally.mean, tally.std_dev)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tally data has three dimensions: one for filter combinations, one for nuclides, and one for scores. We see that there are 10000 filter combinations (corresponding to the 100 x 100 mesh bins), a single nuclide (since none was specified), and two scores. If we only want to look at a single score, we can use the ``get_slice(...)`` method as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tally\n", + "\tID =\t2\n", + "\tName =\tflux\n", + "\tFilters =\tMeshFilter\n", + "\tNuclides =\ttotal \n", + "\tScores =\t['flux']\n", + "\tEstimator =\ttracklength\n", + "\n" + ] + } + ], + "source": [ + "flux = tally.get_slice(scores=['flux'])\n", + "fission = tally.get_slice(scores=['fission'])\n", + "print(flux)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the bins into a form that we can plot, we can simply change the shape of the array since it is a numpy array." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "flux.std_dev.shape = (100, 100)\n", + "flux.mean.shape = (100, 100)\n", + "fission.std_dev.shape = (100, 100)\n", + "fission.mean.shape = (100, 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAC7CAYAAAB1qmWGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvXm8JEd15/uNzMraq27dfe/bt/dF6kWtbkktARIIBBgDgwFjjz1jv3kP8/w89oDHHn/85n3GfMZ+Y/vZeJ3xDDPj8Y6xZTCDRxiQQPvWaqnVrd7X23ff6t7al6zMeH+cqKxqwCCE3KBWnX9u3qzIiMjIzBMnfvE75yitNR3pSEc60pHXvljf7Q50pCMd6UhHXh3pKPSOdKQjHblBpKPQO9KRjnTkBpGOQu9IRzrSkRtEOgq9Ix3pSEduEOko9I50pCMduUHkO1LoSqm3K6XOKqUuKKV+4dXqVEc68t2WzrvdkdeiqFfKQ1dK2cA54K3ADHAE+CGt9alXr3sd6cj1l8673ZHXqnwnFvoh4ILW+pLWug78JfCeV6dbHenId1U673ZHXpPynSj0UWC67f8Zc64jHXmtS+fd7shrUkL/2A0opT4MfBjAtpwD8WgfXtymkfKlA3mLUKkRlG8kpEu+DX5EzkWXG9R6TFcV2FVz6INWcqwt0LYc2zWBkbStwCBKXhS0Y/6xdOtCCMrYFYVvt05bplt+iGDq06p13ik1K/fxw3bQPwyMpS0VXOfb0t9mX5r3oG3wHVNf1CVqS+WFUiwoH1mRc2461HaPrVvwYpBMVQAoN8J4FTvoiuWam/FB6VZfLE+OG0k5aVVVULdum+ZDZVMR0s9mn/DlPgDsuhmj5rXmehXy0Z5cbJdU636bb53V6p9VB+VLX5SGRsyUV602lQ9erDnmqu05+LgJCzeXpVEptT3Yfzy55r3GPhAnfT2a7cjrVAqsrWit+79Vue9Eoc8C423/j5lz14jW+pPAJwESfeN663s+SuZSldWdog16T1ex83UAqsNxZt8kXbLqEF+UbzM561HuFy3hphTpK6KNlg5Y9L0oH3hx1AqUZHVA/vq2pu+E/D5/l8aqSR3RFUXmgtSxvtWmcUsBgK7PJ1k5IOVTFy3qXVKP8iCck+NaN4w+UgZg9eaYtD0Odl36qhow+ogo1+yuKFbdXNfTUpilCQ9tmXYuhIi+eVnKn+5l5HHRXrPvd/GrRjGH5VzvVyOBEnWTilqvDtpMmJHPbwIvJffWdSpEaUTKhMotPVcdc1FmLCLL0kZiXgd9XTnoE12U804edHMubRAo98K+Gk7MaONzCRJ7swBUjvYG9YTKEF+SvsdWRfuu7grTfU6uW9njBAq9+2yD2GxJnsmuFEuHpd+JKZtGrNV+ZaNc0P18iPiy1J3daVPP+Mx+4rd5leRbvtvt73Va9ejb1FterbY70pGvkwf1/VMvp9x3otCPAFuVUpPIy/4h4Ie/2QXaAj8Mc4djpKblY5x6e5SB58IA1JMWflg+5NFHPZyiKAGr0iBUFnM9nKtz9e1JOd/Q1FOiYbrPN1i5SW4ntiB11LsUlR7MOYtIVs4nFxqEytJ+34s+lTmpr/tUntW9KQDy2z1GvirXFjbYdJ+rAbB6U4S5N8SBlsXbfVqzvs0ozrri8nukr2JRSjs62SC0KPcZXbCpjMq9VQ8WKSzKzLH1s1Vm7pG6w5EK1aIx3cuiXMMlzdxdcl3qZBjbKOnwLWus9Um/Jz6nWb1Zrstv9klsyAPgP5uhOiB9mfhbWDwkdda3yuRTHXEgIhNBaDlMZVK0cn3VYeILclwadsjuNpZz2aaxJu34Aw3cy90ApNcgZhTt4u1QGTJ9XJd71xbYVfk9sqbpumjqHgkzf1is3EbKJ3lJ+teIQXWjjP0d2y5x4nM7AVg7VKMyJeMcXYHqoH41Sbjf9rvdkY58L8grVuha64ZS6qeALwI28Ida65OvWs860pHvknTe7Y68VuU7wtC11g8AD7zc8l5ckz3oEr8UJjUtVle1Jxb8Hl9qEP+SqdtWLO2X38I5je2KBRybzjP+5SagrQPsujQcJn1FLL9qr/zed9yl2iO/23Wx2AEKY6EACvBtWLrbNe3HmXhAjte3hqkZyMUpai6/38AfDQ/VkHpCBflbHFfokLH+pzXhnLQfzmuK4+Y638ZNSZn0JR/ngMA8PNzN5JNyHFpcZ8MXxUpeXk5S3S/Hm/9arNilAzGsvDyy9JTH7NvlHmpX05ASy33xUARbhpbYgsXwX4oVvbwfRh8Wazx0YY7e+CYA5reYwdfgmBUEPvQ+JddlLtQoDct531E00tJm+myI0gY5jl9xqA7KcX6bR6hkxv8FWD4k9zByYAmA3N+OkN0llvX6XpfsrVI2cUEx8YBAWdldMfJbZKy8iIaajOFTZzYTbcIvpRBu0jzvIZ/4VCiAel4N+Xbf7Y505HtB/tE3RdtFNRTOioNdhVpGFEaorImsiTIqjoVxSvKR5iZtImvyUbtJRf+DK6YSRXFMgOSuk+tYUbmFSM5mbbvUWT4oiiGyFiW6JgpldZcTbK6Vh3SglNcP14helPrWtkJ0TQp1XXZZ3S2KrLDZa2HOWUs2ChGFDZBYbFDub0EE5TcWAaieSlLvlvrsqiIxI21G1xvkG1I+ZMHaLoF8uiIh1rdKXwobITYt9xY6chyA+Pg+GjHpx9p26Btek7JH+7AWW1h4zijpRspn9p6EXLugmf6YmcTObKH/RTlOvGA0pIb+d84AsPzAGM2d4uV9USr9cuxHNNrg+bVeC8uV+4kta2q9Uk3/tlXG9q4DcPyxrVgpmSAP9gkE+NlNQ0RW5R5SZ5wAestvgMXbBG5yE+CbdrrOW1T7pHzv7QusnxuSsc9awQQZWQzRc8Zj2uyhdKQjr1fpuP53pCMd6cgNItfZQofIiiKa1RSHxaLUlmLmHrGE+477zN6rg8L6inRv7Is5rrxPGDuWBz2nxaLXjo2qy3FpKERxwsABCTHVYqsOhTGpQ/lQnBRrfegJheeIdbnpDyFUEArL1Pd3kb9V1u0bPm3jFA1EctYmt0cszdhpRXGDdLHJHHFjljBAgNU7GthXxSpOzWgytwuDZflUP+s3SfuRNZvGednE9LugSR0pbIzRiBqoIe7jReR89gP7pe69ms33i/V/6X0J3KJY8+mrOqA+Zu+pYjvSjs5HaOw1m56NJKEj0mbppipz3eYCX8rG5m1mnhaqdaqgg/GxajD0jJTxIhbKFxugMKbwDK109XCd+Hl5hmtH+6ntkTEfuXWelYdGAHioa5vUkfCxlqQOp6BZPGjacXXAphnYs0jjLwYBWLrTBQNnzZ8ZgGF5xmMP+dg1OV7f7OAUGiivk32rI69vua4KXdtQ79LUesAziit9QTH5t8LEmL2nC8KiUKNT4eC6RibC0BHDhhhyqPTKZLC8t4uuS/JRKx/sIcFCcjlZuncpyDfhh+EqYcOKyO6CzFlpvzAewQ/J+fQljX1a2q30KWoGcx9+okR5VOosbgR3UPpSM8yb4QdXWLpLJpzkBYfoitTdfbbC+atCs0nOWxR3iNZf22ETn5O6B54rceU9BmrocwnPi6JtxD36HpPjaq+BapYVlSFR4oPP+GQLAtVU+4VeCODXbNSS9MupKbrHBJYpN5IB5dGJNAhflX9q3Qb7n9EsHzKY+JImVBIlXs+EKIyHTFmo9RjYJuFiFeU5dB0LE1+U8wt3aXJrMqGFbJ9qn6FnfkpYMNYhAt5/vUsREbYjsSVNcYPc58qRQRD9DwqsnHlNrRb3vjRgUxmU8+F1qHWH0KHrQkHvSEe+Z6UDuXSkIx3pyA0i19VCR4PlKoYfqzNzj+EwR8AqCi1jw59fInfnBAClgZYn5tW3RYgZJ6P89gaZl8xG6BosvtFABlMOI38qlmkTZlm6VZE5I3WshsMM3T4PwNTFAZa6ZC7TEQ9n3WxQFhTpK01HJUXYEFFKY1F6jIOS8iG3yfDMjaW5cnt/4HnZc6pBwTBbLv5AlJGH5HxxmIChonTLm7WRcnDyxoHqisPafrHiVcWmbDjc9S4pmzkHuUmpI7qqg1VO7NAqtSf65B5WHTyzgnAuRyg+Il5Wpd11nIScDztey1vT3EO1T9H9koxJqOKS2yQrleS8h12RQv1THnljrdczVnBtqKypp41jlQfaDMxkZpVCWfoVLsgApS6HCOfk9+x9FSIRgbIyvx8hsSh1r28NUR5quu9q/GiLWVMzfgXZN1XRxeZY2My/y8V9tgO5dOT1LddXoSMf/Ppmh9iCUWLzPpf+qcAVdnUg8Mh0UxAzjkCb7i+gbVE2lYFk4CLulCCyYJbdeSgNyHFhUuq45Q1nePHLOwDoPgmLecFzwyGN3izwTOLxBOsGH4+sOBTHjaK3xUNV+uVT3CETUGGLh6q3cFyA5X2hQLnVMqHAszExqyiaCCB2VQfURsu1qBpWSHHCwYsYGMOxSJ+RdmJLPqs3N+9TxmptlyZ5Ra5bPuRjdYuCzi6miRo8O7yuqFmijL0dJdwZ46iUrNOYl+NSl8v4KcMsGjIORhlIzhivztMLRBYFb1/f1YVn3PDrKSvA6t09RTJ/L9DK+nZoxA3jZ9rCWxU45/iV7dQnZT+jsCAdLI5rugwbZcfIIhcfloeV36Cp9kk7pTGf73vDUQC+8JVbA2/S8qgOxnnDUJaFp4dNnTD5J4rVVTrSkde1dCCXjnSkIx25QeT6boo6UB32qIxrhh6RuWTxNgJr3YsSxAqJLWpym0zslWyM5X1idY4+Umd5vxzbVU1syfDJD9TIHDVQSEPMuBce3o4fawV86j0hFnd5wELPiXXZd7xMqCImdeVdOSpXxDKNLltkd4j16sUsbCGL0DWWI5+X8ss/JqZjpRAhcUba9sPQfV7aSZ9Y5fyPy+ojvqjoOif15bf4ZE5Lv3vuneHqimwYbujLsjUtrJgn5zfiHOk194O5XwgZ+COyYpM4JpZwdr/PmHEaqvSFWTLOOqGXEnSfF6v713/gj/jRv/s/pS/nIjQMjNF0tkpN+fhmU7G8a4jISsX026URk/HO7lT4JsCZno3jJpsBt3TALS/tqTLwRSm/+OYGIwPCSc8OCH/c66vhHBMzv/SrY3AbQT+asW78mM8DDx+Qe/eh3ivj6azbWDVpc/7IMF2XTHkbVm6O0Dje2RTtyOtbrqtCt2oSbKn3rXNMV+QD73teBd6EqrtO+u9FMdYyFg2jjMsDIdxkk86oAhZJYqFBcdTEb7kUoZaRIiEDUdh1KGwVbZic9XGTTa9NiOZEoZWHI+S2ynWNuSTdZ+XaRgwKtxhsIO+w5S/kOLvUjX6T8XKdFZYJiUbgnVnr0dSTotz8ZCTA2Z2CDpSxk1dBNMELVwdIZkR5Tj+8gXd96AQAP7/vId7h/gQAlQVpx8laAWvHyUP1nUJtcU6mWd4jk0x+m0di2lABD6/h3yWwzE+f/BBjX5H2Z+71SF1tRT8EWLzPxQrLcxi+P0J5UOKqFEcVI4+VzZjEsesGTz+Sx8pJMK0L//sIdcN+2fBpm6nvNx5cvmLpRaEfBi9aw2J1r7S9+a+rxAxuvnbIJfWSTARWxSK6YiC2QR9lAp+NPVhneZ+ZOB0lXqRAZUDJpNdZb3bkdS6dT6AjHelIR24Qua4WulPwGH0wR/EtFtFlmUvWt2syJ42zymSUitkYK49oNh4QV/TCgQg1w+de3+TQdVmgjuJYKHC+8UPQSJgY68bhp7yxgbMmt3jlAz6p02KOxpZ0EI43NeuRviD9a8RtXEFi6D3lghJII7+twepNsqEYXdfET8r5ypC0Nzi6RuGCWKKJGUjOiFV8+b1p3H7pa/Jxxdyd0hd3yCU+J7CDKoWwX5ClhY7Bn1wWDOIPvTuY6BEO+dVnJahMbFkHzJ+lg5rYk3I+FCYI9evkrCCmSfQzGRZMnBpqFubWiKzYwSZmM/5NOBcJmC9uzMcysFV5ssGVrmZMHRh43tSnNYtvkU3m5FQrfs7MPWAlZbnil0JEl028m+1yXeKCQ2lSVk0Lt6cYfEaoROFCotWnJzSzb5Eykd4K6qRxwor4wf034ioIwRCf09huW+z3jnTkdSrXF0MPWVSH4lQ+m8bd2KIB1jMGQ094FCYNDtpdp1CT5XUqUqN2okmXg9xmUYZOUQeMksw5n6XbTdjcPsNamYpQ7xMYITodpjghx7WMRdcFKVtLWdhGETSAxLxhnIQU5WEpE+6pUh4S2MOutRIuRI3H4/jBdY5MyoRT7Q1RGWzSGjURo7j3fPw5Vq6Kt4y7HsM2Sjc8UKZcNJBKTrGyLMprdHiNK6tSpzb32H22QnaX/JO+QKB0lQ+Z8wIJLdwWI79dlKF93CbeJXBO918kyU3IhJa82qIZNpNZ2FWNY7D67hPrLN4puL6qWkFiED+iqGXkOTTi6QB/9yKtJB1WQ9F02Eyfcaj2mLDCWbkuMa9xCnLsRWHpoNxveVgz8njDPB+b6IJh31QSsEXuYS4WDVgu0RUoTJj2Y5rhJxvBeHSkI69X6UAuHelIRzpyg8j1jeXia5xiA6seChyFqn06iAnSc8wKls2l0Sj1rPwwtQF6TRREtMXIAwLFeN0p6v1isS7cFiYiBBGqxqKsjdVJNzfa7s7ineoO+tKMSOg74BsHnS1/WaLWK23Wk3aQVUidTVDbIhawv7tB3fCso4YDf+LB7Wy8UxLaTJ0eomJixkRmHNghsVce/ouD1AaNBdnvkt0jx/EjKeppE1WyS6PyYuouhLv4ib2PAvBfpt4qdb8jFsBJmQs+xWEzH1tQGpF+lya8IAuRthSRB2Vzc+kgJKfMCialAo59M41bpccKVh7VkVQwTvE5m8idEunyHeOn+dzem+WHJzKMflWcBi58KE101SSyyCu6H5VxWbkZotmmc5RcZtd8Bk/IZu7FH0zjxQ3ks2azeEDuvbajglqMBH3wS3Le9iGca0FsjuzJMvJ4jcjlZaxKB3PpyOtbrqtCb0Qtsjuj+CHF4DPyNa7tjFMVZ0JWb/VQUVE0o58Lsb5FFJPlQm6TfMhDT9dYuke8deIrHvkNxms0SwCRjE+KZle/18/MvaIwDvYtcawuEEY942P1GwW9HGVku8Tqnj88RHpK2s9PWkFat/SUR/WKieG9LUKXicMSeHtGFVcXpG5nsMLAX8oks3gQ3Kwc1yc9hrdKv7oiVc6+IBG+lC9x4kFC7Da9RiMTVf7g6JukA2bCCU8UqV0ReGbxNtj8acGfp9+WYnm/XBcfLTC6SxTtxefHgwxQmTOKwkZT3Yo8C4DougnkFYLQBxalvmwaz/Qj2lshOy0Y/2eeeQPVQSk/+XyNWp/B1tdbTJjieAsWKY95AVzTDD9c2GBR7ZZJJr6giKwZuuMIuHvknYi8lAhgsPiCJrtb3oP0ZaibuWbsC8uUtnSbcWtQ2j2EbzIodaQjr1fpQC4d6UhHOnKDyHXeFIVatyK+oFk8JJyLoacKZG8SqzO6YuM7JpLifgkTAOCmfUJFw5YYDbO6z1i0R6wgtkcjpnEzcsH0FTH5rXstUpdkzjqxuIP6sHFQyVnokliXyoa1R4UTX97aoLDdcMXTVbzFmOmXFfDGe0/4LL9drHtt8mT+9Ju/yBcWbgJg6TMbmL3HdByfeL9YndGwy9ys6exoFjUkdThnYsTnjPW6zQVb2t/fv8jz1TG5T5OAw5pOs+PtlwE4fWyC5X8rO6uRL0L/MZPIY62LKymxgFWYYPUxG+2l94g87uxej/KwgS6EvEPqvGI4KpuPKxcH8YwzjzuVILloePUhiM/K84meusLcD2wGZIWxYnjwfkhR6TGOTUVNxEAxIeOYlbnoMv0WsymaamCb7EbxOYU2YX/tGgEMt3S7R/dxk1O1jcu/dLiP1IyY8VbFZW1bksaRjmNRR17fct2Dc9l1iC83qPaZMLHJMHnRC2TOgpsw0MG8DhyFnLxFRBh8RPIevceMAhxXjH9ZMOrL700Q7hUlaZ02YWWH3SAGjB8BbbwjrRWb2JwohuiapjRo4IXFELUeUSqNpVgQQwVFEHo2t9VC503C45iU/fz8HqoNE1hqfx18k7j6+RD5mijXmtKExwWW8LUidEEUYGEjuEOG8lK3UEapPf/odnr3iTJebEIbQ2VOnjbJ6KM+a4tS99C7FmlmXystZLAM9PCv7vsCv/XgO5q3EHh2Dj6lWLzDhPg9JspybV+D1Ypo9/qIS/q43GOtV+OZSMaVyTqhrNR96cOb6T8uAHxuu8IPGXisoWnEpZ3EtApohokFUb7ZneEgZG7XUYt5M/nFF8D5c5nkc5PQ95JJqbenytpBEyjsTDhI9O0mFYUx43E6lMEp6mAPoCMdeb1KB3LpSEc60pEbRK6rhe6HobjBxw85AbNj6dYI8Tn5vTAOMePW34i1YnuE8wR889m7VcA3DhUVFz4oVmX6oiI3bHJwGpfw6JwDxmqzapLMGGQjsiQ+MfQdrxLOyfnp+2xGtsnG5dojQ1QMRBMuQD1lkk3XwCmYcLtvkjgls0+OBha8rSC6WVgc67uSwZRplyzqa1JoybVJrplwwDfVweQ3jU2HUCZtj3VwncVloYb0nDAbh9kUEcO8aWyuBlb+QiiDFZIbHRleY2FdQuZ+4tl7wURyTA4WKRoGT3k2GkBR6atiOa/tU4T+q0BV6j0uyXcsSDuPDhG9Q1guuhohdE6sZTepWd1lXh/bo3xYoKXQqQRhGRZCVR2suJrxd7rPeRRHTGLvQYsuE7K3NAwpE+3RasDSLVJ3X1eRg1uuAvDwsUNBRMbB52qsbzYrJQ09p8qEKh0TvSOvb+lY6B3pSEc6coPIt7TQlVLjwJ8Agwgh7ZNa699RSvUAnwY2AleAD2qt175ZXbF4jd23XOFMdZKI4SdHsppqv9k4q0K1x+Cvc5quy2IhF0fsINXcQpdFdMVskO5o8cwjOZ/0cyatmok17oc0hf2CLidORUhdNREGE4qYMPSYekcsyGXpJxrYvy9WqncQIlljldddahmDEXstT1H3MRMNMQGNjFi6H7vzS/zRJXHfLyvQJnt993MWy28wFqil2f3+0wA8OzVBd1qw9bVE0zkf4kqzY1ys5HPbheJojZbp6RJL2PUsfvGH/gaAn3/2B4LrFk8OYI/IDuSGvnWumJAEh0cv8+Wn9krdc4q62Z8omxjym/66zvoWGUu1GmYtISsfb2+RD01KbPL/fOyNgTdp34s+2Z3G8/SiTcE2ae88GHpa6JTL+5PBpnXEWO3rm+wgkFl+l0vqrKyOvBh0nRa6ZfpiCN8RW2N5eYjPb5IVR4q2pCI3RWiYDd3krMYuu0Gc/Jcrr+a73ZF/WKxoFGtQoo7qeDQ4r8qGOry4jF+tflf6dqPJy4FcGsDPaq2fV0qlgKNKqS8DPwY8pLX+VaXULwC/APybb1qRb7FaiRPZkaNWNc4iTyVIzMqHmNuigngssRVFdEWUcXy2weX3CAF54KiPtg1DwwkHDivhnCJzQZRqbdW4jacU60lpZ/xzS0y9TxQDt+bo/pRsnPaeUMRW5DptqyDbTs8pn9Wbmu0oXAMRRVcV5T1GYQ7K7t78k6MoVxTQJ555K3ZEJqLElI0+LJu2y3fEg2iG9vk4L0YE83nX9pd4MSu8+mo8RHFJlPq+TbM8ecnsFo/Iy37P5nNcKcgkkq3E+WpuJwBbR5awTL/9EcXVrPCzp+Z7wUA0jvIDBk2tB2L7pO+5kJRNTUPJJONIX7KIPSvj0/ORKaImfm/oSpTiJrmHwg6fxCUZ50Zc4CIQn4HsLrm2MqjY8IAo6exNsoFr16D3RRkTp5QMfBDiC5r1XfIw13ZYgebufcmnuZCsdYnzlTwrTdhw2HObFUt3JKn+v9/2gvNVe7dft2LZNO7eB8D84Qhqvzzv92w6wfd1HQNgf7iBi2GYYWMrE7JBtybgl1w59+nsbTxwaTcA6sUUw0/J7B/66rEgoXlH/mH5ll+A1npea/28OS4Ap4FR4D3AH5tifwy89x+rkx3pyD+GdN7tjtxoorR++ctUpdRG4FHgJuCq1jpjzitgrfn/PySRyTE9/PGfQmuIGs/LgecbFEYNt3lN4/9z2YBbPzIQxLvuukCQX7OdmlbbXcGaliVc4qqiPGKsN7Pu8MaqRE/JxqHlCgUPwBut0v/FiGnTI3FK6IEz7x6lsNXEZu+qM9wv1kblM4NUBox36IF1SlcNz9sMnR/1g83XoclVFqYFZ0ifcihMtiJAemNiaQ/355idEkvbTjZwzkkfvZ1F3LKBkGYcbr1XYJmMIyuCr17dgn9crNi9bzvDxTUxb3OFGG7OBATzFMmLMp61Xo23UdpUM1F+8L7HAbj/c2+gbuiZKiOrIL9h0fWC1OFFobhFVi2/cfen+bd//iNSJqSpD4m1PvYFK9jcLG7QZKSr1DOKwmbjTbpjHv2rstTOT8h9haqaRlTGcvX2BpjN3MSZCN6tAtVEHk2RuSTtr29ycI13aGJWY7smfEFSsb7L5FSdtyjtqLHwS79P7fLMKyKjfyfvdlr16NvUW15Js68pUY48w/UP3kLuvQL9/Y8Df8RN4VbIBUfZwXFVmyBxtB6Jq30cJXakZ1yKfa2xjNUeV+G2sh41U8dZN8KPH/0xALr+NkHmr54HQLt1Xg/yoL7/qNb61m9V7mWzXJRSSeBvgH+ltc4r1XpIWmutlPqGM4NS6sPAhwHsvi6ssIf2VRDlrzRgk1iSj3p9s015Vb5ea2uZxNMCkq7eXmfgUYFO8pOKoaflIS7pWMCKyU9qUjdLUsn6o6LoSrEIyelmREJNaczc9HSUnqNm4tjTS/Fek2s0r0mfbeLmUWYPyXG8TzFwVF7anrct84JJOJEcFgWkgPinRdHmB6MkjTNRI5YJMvk04hrflfoWs2nwzAQ1HWXzPeIsdPLyCLdtlzQ8z8fGefK57QBsu0li1/zc7i/zwKDEUjmxMMzmPrnfQjmCnZYx8YoOha3NZCCQfFEmi3s+eIS/eOKwPK8hlwkTHqEZskCVQlRMrBm9uQR5Ue4/94UfhgETm2agTPx5eT6rOwl46KURO9gHacRh+BFpvv7QMGWTdar7nCyd8xMRfPPNhrIhNv+HDXn+AAAgAElEQVS1jOHSrWFyswI3+YMaaEXUbGLujThEFqSPhQ0WyoR17HnzPPtSa3wxagp+m/JK3u329zpK/BW1+1qQ0Lh8NGc+OsZ/fPf/AOCu6KPB71Xt4WoDoaBxtXzLERUiqkS9lP1rY+w0yzTFo5UrtoZ7Tbmm8t8ZrvP0HZ+UH+6Axz8uUOFPf/7H2PEJ+T4a0zPf2c3eAPKyQEellIO88H+utf6MOb2olBo2vw8DS9/oWq31J7XWt2qtb7VTiW9UpCMd+a7JK323299rh8jX/tyRjnxX5OWwXBTw34HTWutPtP30P4F/Dvyq+fu5b9law8JfiRBdsqmMiXVX71YMPyY/d59vAGJRhsot7jlAfqNYAW5Ss7JHTDzfAWMcECop1q7KrD1k2Cy+09pca8QUg88YL8MEZA8I5LF8ALpPSR0rb3BJnpK6nRKkTsqxd2cO/03CROmPFkkOyaZe46i050U0hfvEQt6cyXNlUere/faLnHpiEwDJGUVju9RhKc34iNBseiIlnp2eAGDLhiWePSr58LomcqwnxEpdLZswCaEcF9ek7nS8Ssk1uVVtH8d4mL5v9xH+5Ik75YbCfgCdHM+OQkLGPBxzWSubwTUc/PhoEW9Q5vfqepTojIl82OcRmzErleeSrBySOjIvhVjeJ69P6oqmPCzV+SHN6s1Sz/CTDQa/IrqwtFOgl/6HrqJrMlZdBzaSvUks/khOk74g19lVTbggzzC+WGf+sGFGaIiYaIulTS6DY0I8sS2flWoC1//2NkVf1Xf7BhJ7UMgDp//dRr74fb8FwJjdCnzmoqm1WdlNkMUHfGNqW3gYdAwXjWNgl/bj1vXXQjIBFAN42mymKiuw7G0Ud0Xl2Z/4wO8y8z55x+/7wkfZ9UtTADQWFl/x/b+W5Vti6Eqpu4DHgBMESDG/CDwD/BWwAZhCqF3Zb1ZXbHhcT/74x/Ai4G4TXNjPhgmZeB7DT3hYdWmiMOYE0QFDFcXgc6IEpn+sgWVLma4vJFg1YWiT0xauSfHZTOhc3FlnfExgibnjQ4w+Ytgn57NkDwoss7JPQguA5NdshhhwipqyCQlQ21HBrxvaYsRj+6i8LBcWREnFYnXyq6J0Y13X0q9qFfkQ9k7McHpRYsaEQh7hkCjG/kQpKHv24gibJqXuhVyKt28UYPozL9wCgKraQbiBD97yHOuuKOVn5yfIXxaIN7M5y9qUTDRWVfHOu4Vy+JWr2+hJyIQSd+rMfEkmkfIu6W9XVznoh1Ka9atSn7NmYRnHp3q3T3ymmetTY43JNcrSNFGJ+kKcyLCp62SK8S8ammWXTD7xY1fJH94IQLXLopFoTtRQ2tDMhq3Z8PkWw2h5v7SpGoo+k+h7fasdhCQA+P4feJI//eGHWDiZfdkY+qv1bt8QGLpSzH/0DgB+/6f+EwB3RDxco1BdPHyjK1xaOsNBBQq4XdoVsKs17fwU++tKEzBfHFSApwOUDbPFVtc+1oiBYnytiaiWXfpsTSb/f/kHHwFg5DefEs+z17i8ahi61vpx4B/6SF7jb3FHXs/Sebc7cqPJt8Vy+U4lPjCut33go7hJRWXQJDZYt1q5JC8RWMXVEY/ovMzliVlN7j5j6VUcbOOsM9ibo/pZcZxZu8knPGggDcO9Dj2VbjkBJSFlEjxU+lubslYdkibtnFP0Ahd/L6wojpncpFvrkqwCiQLoDcpqwV4QE7Ex4BK7bI53F9FTYq3bk0V8E6irUXUIRWVp6OYj9D8hc+m7f/arfHZqDwC3Dk4HY/Xg2R2oBbE2/AHZ7NNVm/iU9MM6uM77Nr0IwJ88cSfJy1JfZcjHLjetW+jbK5CHY/nMvygrhIE9i+QM5KKPyGauHybYnF2rxlg6LuOqR6vEjsWCe0/OyBiu7mkFw7LqCrtuntuGOqEV6WPvcU1uswx0zymzOpqtYh87L/Xt38b5f2pgo4pFyARDq/V5RBeN6/9xLwgB0YiqoM2VPSpI9hHav05xJcHCv/9daldeGcvlO5HXsoVub5kEIPzfy3x6y98BLX54TTcCa9lGUTXWelVrwm1c8qb1HVaKurk2qlSwoVn2vWu451+bhiSqVNCmo1QAwVS1H5RtB9NsuKY+p62P7f0F+OD598H/YdhbFy5/2+PzvSKvOsvlVRElzjuNBKS2iutgKlqjLyaY9IvRzQw9bRRG2GbgBRNnZJtD7GnBU1SvDp5uPl7DNc4wdtnCeVbw2LTB0BcP6iAjj9vXwHfkdjPnfBYPGyW+btNzRgp5UYtwwSzptziB7Ra7GA6YFt6AJnlCXhDboCsF28GR8C34Z5M0klL3jsElqp60OfXIBPVuUXTJOSvAnF1t43qisbbHF/FMo1+q7SY2KQyQdFwaWivEObT3DABn1gb4q3MCxfS+YAeMj+RMa7+h2u+z/owo5pvvPct0t4GZcknqhuboGIep3/rA/+CnHvxnAFgViy0HZHJpaItLm4bMIGsacbmf6LKFm5JrR26dJ1+V+mpriSCpRiOqGHlMBs7yZExKo1FSrgm7G7UZ+7L0tTBm0XtSyi7dEiFcaO53KOImUqM7HCa3Rcqndq2yvi4TZzUbZ+PGJbIR87A78rKk9P7b+Piv/TcAbouUKPvmm1At9dnEyr9WoTbFo4VVFXxNyjLGRNu1dpuiB4Kcs4a9eo1SlslCzrcrfh8CTN5RUDVewQlL4TbrVhD5GpX2uW2f56kvSY9/8ed/gsT9z/zDA3IDSCeWS0c60pGO3CByXSGXdHJU37bnI8zenQwYLPH9q7iPCnOjEYfqsGFirNj4hg3mh1oMiEYCysMmsuBjmqVbzZL+ZIvLurbDnDvts/AGY7mO5gl/Xjb61nZrkleNc0OkFescBY1oazx84wh02+QVyg3jGGN5rFbFMuw3K4sjJzeR6DcbhEpTNDx11VDER6WMZfmkDU96rRRjIC3nV4oJ9DPSr9hdK6wsidNS30CeyYxs6IYMzpByqnz5jLj72wsRxh4SG6Y86BD7kXkAphe7CV2VGxp6yqOelvtce2+JTFJ2i2tuCN/Qgwoz0p4OabZvk5x7c/k07974EgB/c34froGQvESL2RDK2cEKJnWFYAMbBd6AQFL9D4VZFTQpSEUXWbbwzBgPPdPqX3S1QW5SVjDrh2sk09LXwmJSomYCmfM+tbRhuYxDeq+MT+mZPuoZn9lP/Da16ekO5PItZOYXxR/hmZ/8ROAIVNUNnK/ZrmyHXGraD6xsV4tlLNdpmvwXF4Jjj5ZF7SNWNYgF2XyLmtZkVLWsbA+otakkJ7DiW+fa64srFdQXV3awQdvOnIkow9jSLof+88cAGP/lJ7/x4HyPyvcm5KJBeZrMeY+5N8sp71QPIUNPH3vjNBcuyPLe31whdE4cNsLrKoj5oW3oPW48DXdZAewRWWuQ3SkPzjcepvNv8eh91jg3LHQzeE6URD0TC7wP+443WNsuZYrb6thxmVD81QgDfy8zylN3bcXJSEOZVIVSVZR7xTXxaIo29azxHvUhVlVBX0uOwdNTLuWSyTxk+WxMCWni6mIP/naD59QdYmlpZz0f502bngLgoZUdABx5fB9pAxHnD1aZeYuBfjYWSVryWut8mOQeUXQLuhc3LecnuvOBE5Hv2qR7ZE8iZbxKy4Oas2cMfmXBp67cacbeYuQOmSzmTgzi98kkMvz3sL7F5HPN+VQLJktRBQomxO3ybT6Jq1J/02lJ+ZARCB3laVb3SNn0BYe1W4xnoa2pH5dJbuKZBoUxE2r5kIRBlrHVFMoGNqrAvrddYC3xyhyLXk9y8Tdv5/SHfg+AstZ4xhPT1xpfNVkp8tdDUzUwjMu1y/lSWyC0Kk3cWgeK1qeluD1UwDRxFNdMANLetSyYZh2uvlaRmxBO2G19cZQVMGEKuvF1cWKiysJqq/25j/w2AHu6f5rNP/v0Nx6k17B0IJeOdKQjHblB5Ppa6BZ40RCrN9l0nZRTxY06WIJffn4Mx3CbY88mgpyihUMVks8JRuOmIC++OkRXwHmbuPDPxXvxTDKHoV3C7Kh/epDEolgg5UGHpVuljnqXpjYm9sH0iIWVEst9/H4H56fEcp4NdbF0m6wQEgMlSotiaWc9m5CJIRsyVvG+Qxc48ag4BCkPBt8o0MWVSwP0PC9DnN9k45uoifduO8vjs8Iu6O0ukoqIZXlr71Uemd8CwJoX54vLEnVuQ1zI8ac3Fek9IPFlko0Qy9Oy4bmxL0vWpI/TIZ/8KQNhDbXYN4uLo/gb3OA5FHIyFmNvF+tbf2mYooG7IpfaQpx6MH1R+PYkfZw5qa+e0tQOCWykjySxTUgN9/YCrErddk+NYkIs9NgFsaYtF9YlogGVfiewuFcP19m0QZ5bSPmcNxEoa2mbwc9cACCzZwOXPig2SKS7yp0bhLXwTGiCo+c3Uq61EdM7co1c+K3bATj1wd+jaFzxXXTA5/bQWE2noCbnW7c45xYCjTR/qH0DpNYCqm0wixWc14F1bcHXsVzaN1bbpa4tbOPf4LRx3S1aG7M17Qcbqq7WASwUDjZZfSSopoQjaFrwZz/0n9hm/SQAWz5641jq15nlotAhhWpAYZOBCEKwYbcolVS4RqEuH/70WAyn0LbbflgYH9bxFL7pdXlY07gkTjSxvEIZx6L5C6KAoiOKcNF4Pw55VIzCj3RVST0tmItdh8Jh0Ubv+5Uv8YfnxbmiL11idl0UW0+izOg2UaS25ZMJywQwVzKUP62CIFipZIV3Dgv+/GelQ3iRbnOfPuODopi3xJYIj8tL9qHuZ/hXZ34QgL966hAHbpZYLtkX+7nkiGIejMq9v3vLCY5lJbZGybcC6mXY9og75jNxNL03S5yW2gMDAfvFakDXZRO//F/MkqvKvc2vyj1seudVzp2TmDbJaU3FxGap7y9izZlYJaoVkGzxLh/LOFt5+yt4FTnOfDXF9h+8CMDZhzbj9ZrgZAfl3gvLScIL8gCdgiZk/KrGHvYpDUv71R6LsJlDwOfKh2WyHHqmFuD2E71rPHpJJr9wxOX7bj7B/bEKHfl6mf63hzn3wd8HoKgbAc7soFrOQlrj8w0YLYFyv1aDe20YdbQt1E20DfKotl3ShE6qbdfFmyGfgarZ04kq3caCafNGVa062icES+uALQPtirx5j02lDh4uUTMVuHic+qBAT7cs/Qxj/+G1han/Q9KBXDrSkY505AaR62qh19OK6XsjuEmfSNYkLej3uHJRoIPYTIhG0oRE3Z4j9KBsjNUzEWph2Urpv2OZ5QWxKpM9ZULPS5lQVdzEQULfAoTPxQIeevcJi9wWw5TJJajtkjKqbJN8TizQLwzeROWM1FexgLRgPrGQy+a0QDun1wfZlhZoIO+KlfvCyUkwzk5d/VX+64m7AHALYXreKtepU71Mn5QN35GJR/gnqeMA/KfVN5AvSz0ff/NnWGnI5urpbYOUcnL+Qkp2hNfL46yvyjJk+8Z5bn/bEQA+f/pm/KpYHuEFh9UVMW8jCajtFatVWT69JtvRxmSWB6/KRmv/gBDoL8z1s3OHRKs7n59Aj8l1FqDNJvNbDx7nS89LtMdwd5Wk4cfHnAYLJyX+h1PSHD8mcFLMhcwZZZ6nYCvDmwqcd+R5b33zZVb+740AVHsdKr3yfPJbPeyKcff35dkCTN8bpntIILGLi31ETshzS85ovrTzFvJ5E+axIwAUPyCZs577yG+T9+VDsNpYIY5S13DFm9ZdkyFS0n4Abbi0Nhpd3YJA2i1nR7U2S20FLk13fn0NpOIZa7zWBuc066tqFVj8bsvlBE9/PTsG5Fz7RmgTcmmWcYEuy1jl2g+co5r/Azz+k7/Buy58FIDkX7+2eerXVaGHytD/gs/irRZVg2GrmgUmw09lBJxu+fBLcykidwvUEDqbpDEh5cO2h7Msyr263EXILLfye2pEk6KkrUui9EIlTa3LxB4ZUEzsF4U1v56mYuAUMm4Qbjb2x+NMnhcMf+lggvB9AhP0Rkus1ARDn3t6BOsOKd8McKXiDeKnpb6V8yP4/fKiHLztPOdXRbk2uhtBMKlH89v5zLI4BQ1Eitw0JJDTLz3zbn7ptv8JQDTskh4STVb8C4EiijtAGerg+4Zf4G8XJFOMXg/T+6KZrGKKwkFRxo1KjGhMxiTqNFg6LX15sKsbZTfxUvl7cNMUZ1dEKeuQxg61XvyxLTKBPb80HpzzPYs9/dLv09nBIHtQcUyeM0h2IcuECa48KZNZ9uYCIeNhe3RpOwNmrFZvtojPm/C9UZ/kOQPnRKCwWZRRbDbE2qxM5k53lUbCUN2iEFtSqK8FZ1/HYm+Z5D/82n8BwMdvYeFt0ImvW4GyStoP4IqmogsrFUAX0KITeqhAKUfbVHVNt0ExWmPTjP2igmMHHcBmVeMCLBh7k5Wir4FfSibgmo8KMP6o8gMmDLQmERd1zUQj7bWk3WHKRgX3aSnFr//aHwDwK8fej3f+0tcP6GtEOpBLRzrSkY7cIHJdLfRGDJb3WoQqCs8sqXXM5+6d5wB45NxWYs+KJVzc4FOfkWPd5fP2HRJ58AvP30x63nCxdzQY+6rMsleGbaoYlkPGJF4Yd6j1GkvTInCmqdcclCPXHd5yiWP/cxcAyvMpjZvwvRXN8rRsaK6d7MM3jjH+qMvK38nGZPFWsYSd6Qilja1IgeElGdbnjm7lnttkg9QfVOxKzgHwpxcOsW9wNhiXI+cEoghFG5ypiDX+k1se5ZcfeTcAEePKH85BzZgev/HZ9zBxm6w4rJ4a+Tcby+R0InAsYmeBkmGzjE/Mc+ebxPJ4Yn5T4LR0NS/3+MLMGPXVaPMWaMwLnLFh9zy39EgYgPPFAbIVw2WvRnm4InSVSKqGY1guQ89UCF+STdnTvzyAY2Cj6riYz1EgVDAbV9uqLB2UTXDf0XgGhrNiDdb3GWtsJkzc5CutjHikzxrW0J4wvVekzdKooueUh92x0AOJ/mGRvWbz3tUtNku5LS+noxTrfsvCLjehE/O/Tctadto45p4msKir2go2L702S9xts+KhVV42QMUyb36PEeUFZUta4dO00D3Cpu7mNc02/baVQXNV4GmFa2xUp/m70tfcc3vcmfYwvttNVrDQfyvj3f2NN4JfC3JdFbpVh9QUJBYa+CZgw8JtIR577CYAhm9exJoy2cEtO/AmdZOah/9WIIqeZU3OQCR2V53Vm0TxxKeheTuxRfm9PNRynCls9ZhZFuVlX4kSW5P2j8bH6ZqWh790X530c6KAek/WUCY+68qtHvEZqTt9JERk3dC+ks2gVZrYrAkmdaJB1SQrK45bPPyk3Jsf83l2YAMAh0av8uSUKPGuZAUrJ9du3jjP3SmZuP5s+Q7GTVahuYLAFbElRXncMHUmS9Qacl1/d4GlFZOEuW3N5V1OMrxXwvGeOTXOuYxg1yN96xw5JdzP23YLI6UvXuJkWSaT2HAR61G5icJLIzwUFwrhxh+4GIQaro3WUSWTJHotgTLPaubuGN47BJrRfj3ITtQ/IrF7lpfSsEm0/2B/ntxlg73nFSGjUfySQ3zKOC2t6YBZ40VtknMmvPItPtl9xmnq8x65SSdgP72eZf5j4gV6ZPPvUPabStcPcPF2B57S12QOakrZKE8Hv6WUVcvzs11spQOsXNoysfOVFyhaHxUc2+hA2fqq9XtTHOUHHt8lv0VbtNCBcq9rK6ivqu0WnNN2rd1Gc2xi7PWvUdBN9ksUK/BU/dPNn+UNH/tZAIZ/87XHfOlALh3pSEc6coPIdbVplC9QxsqeENFVE5FvoE7mqCy7l/Qgk4uy9Jl9cwRlEiuEs1bLceWd63gLJu/oUpSeM2ItZ3c4VA+Ko0vVwAX0V7FeMmFiYx6+CUd74O6zvPCwwAX+xSRZ8d9h5HMOecn7QKXfwTEW48DTNok52axd2RPBM2vP6lbZtBz9nBMkul7aHyJmkqVYdfDjbUvaZYGQHl7ciUoKRJPoqfO/3fd5AI4WNvKpFXEAefzsVvZMCqSyNCH3lRtw2LtRoJo/mPwbPlOUuC6/e+KeYKOp1usRXTJhhw+usqtbOrM2GKdSMOOcSxIxXPCdty0A8OX5HUyMCgyTDNc4ucPEY/AU3Sekvvn/tglLFhmkXwpT6zFhVgc8urYL+yT8qZ7AnX/070JkBc3C/6wwdeztkGiGL7g8gDbr+8iaptprWEpRj8PvFc+zRx/cE1jesSUo9xuormGh0vLsl/dHKY97eP+L17XYgwN88qeEW+22sTnaGSzXsk24xrpuSlQ1w+TawUZkO3ziYrUgja8R6xrL2Bzr1vUuVlDGNY4UjvLFug762GqrCctY6Gtgl2+QU+Maa91rY9i0c9LbVyjNYxcdWPG+1vzuT/5nAH79z+7FW/yGmTW/Z6VjoXekIx3pyA0i19VC90NQ6bNoxDS1jOEnX4hQEyYakVVFYYNY0aGiCkICOEUo7Da88dk0fRNC/8uXouQmhaJY3OjhnBerMmyocow1qGWMK/C8E8zqLzy8ncTNYlGuzXZhmxR4s/f5KMN5zlzUxK8Kb3t9V4qrP25wv0aV0NNi6fZ9Vf5Wu6B4u6wsosdjWO8Q7vlovMzMutxceTkRuFnGpx0qo9LH2XAXv/mCbH76w1XuM5u/f/TG/84npu8DoGY2FicmlrmjRzY2/2P2Dh5dFE9J7SusGSnjDdewTA7QtZUUX8ltA+DA5FVeuCTHjZUw2sRB//MH3iTj6kFjohqU/bHbn5B+PH0n+//5CQCe/7M9QYq+4oQmuir30EhYhP5KvForvYpG3AvGM2H2MOLLcq40FiK/SyzrzIsODbMQ0BaMPCo01Xk/xUN52XuI1BRuxthSSzaRnDyH2OUwnom7nrng0YjZqNd5OPTTv7SR7Y6sJKtaB7iw3cY9d/W1Xp5NsdHUdTMMgLFulR9Y0R4qsMpTqhFY9uW2jQtLtaiK7fZ7VPnX/N9sp0mZbbfOq9puYext2LuFvqbfXtvGadNybz/2gr9+gL1bimsSc6QMP72m/RY9U8H+iHz3pz++kW0feW1Z6NcXctFg1zVdFyC+LB91PWVTmDAhVJc1blIGPD6nSE/JhzzzVh2wUhI9ZcbTolVOHd1KbqeUGdy0wvrTsulX75Ky3X+fDJgP2d3Q6GoyXjT1FYFtQjmbkImOGN+SC+KzLPxQBDcr2iaUqWJdFejGT/j4hvy+st+8KH01fDOJ7Pr+s8GLeuTSBFtGZGPzYs3BX5UJoLGviHLlZdoxvMSJrOAY20eXGInI5uH52hD7M8IuOZuRjcNcJcrnZ8WxZyBeYKUg/Wu4NlHDHFF+JOCBZ54LBwrzWGiMhmH/OKshDt0piTKeeVxgm213XOH0C4I3+RsVrvkgVMPiK6cFnrInNJh4NLFjsSDph11R9Lwoz+Tcz8UgK/ep6ha7vv+sjMV22QROn4CqCeqY2+XhGP768ONlGinZQXVT4OTk/NhXyky/VSC0ws46GCaTXYWEIQrlN9h0n/WZvTad6+tGQuPCunrwnZ+guehud7hp3wyMKAJF77RtdBZ0KIBa2jcUm2ECLDQJq03x+i2lH2x+ahUo55JuhWi2lA7qBgIF25ws2icFR/kB5OJqi4hqB0kI2mn1r41Zoy0yxpOweV/tG6i0wS9RpSgY9ktYKVJtMW2a8uA7PsFPj0lYjsZMi5X2vSwdyKUjHelIR24Qub6QiwOlEUjMwfS9YgGmrlh8/w89DsD9X7gzoKglr2oaMZlvRh7WzN8llpl/OsqJboEx4nvXGDaZ7HOVKNVxgWWaOS2zb6yhSyYQVN7GSoi5nk5XqL4gfOrqeB17VsqXClEiMSkTi7okRqW+0unuYDlvly3CebOUNZb9gY1TvLQoOeXClse5NaFefnjf45woiDlqD/ucWRE63/6xGc5nZZPwUPcVxg6KVf4rQ1/hXSd/RO7fqXNuSuiKuze1Ek9sSIklfOSJHUS2iNu+rth4Ji9rI+lTHjVeoyM1EikxW/XZLiwDYb3/7U9wKi/9baTESjl5YZTYilx3anGI4zPGjE65pE2yiXLEo1E0OU0bkpAEoBHXnP3Xxg3/WJTyLVLeDnkBz735YN0kxC9LHeEcFDbK+ezueBCmwa5BdEXG9uo7YgwekR8K+4o0zslzi2Q1/U/I6mfm+wZY2atoPMzrUs58TCz0DaEYRV+WTQ4qoOXBtVBDM2p8e8REu23Tsd2attsCbxX8pgu9RTywhK1rLPH2+tqvvWZD82ukHapp9xr1UNTMdRHlBWVs1eprTdvXwC/tljkIbFMz/bYtl0jgpaqvsWbdYPO31ZdBO8TZj8o3u/lnXxsW+svOWKSUsoHngFmt9buUUpPAXwK9wFHgR7XW9W9WR2RiXA//ws/Qc8yiYpIgZC76zL/LuKefj1IxDig7fztHcWsmuHbujQZ3c1Xg5HPLbeeDbD7bk4v80VMSQ2Vik+BeS/kke4bFmWe6kGFu3vDQV8IB/lse9dAJeYFTPSXqL0oZf3uRVEKUYXY2Q/yqSZQx1gjWNX1joojH02vMFKSvy/Nd3LFTuN1XC928dVigjdPFIY5cMpCGa+PEW0P1nm2CUecbUc7lBF6ZX0sTi8hY/Ltdkrz3vYkin8wJV7zmO/zHk28M6qgvikLNnLJYOyjXjY5kSUfkHg72TLFQE67680vj1L4iE0qTqRJfUFTfJBj24fHLfPWs4O1qNUzPNtlvuHvkPCfWpf2zl4ZJn5BJtjTuB5EfsVoTnZvx6HvGfEx1aac4ZhFZM6ETbvLpfUEuLGxUwWRe6/XITMjYNh7ppbihBW31ZITxszyboec5eSZrN/v0PWdx+vO/RWnl28tY9Gq819/NjEXKCfORU6cAuCu62IrTwrVOQ+2JJ9qTRlT1y1+ku20qsIlzl3UogFnctroc5V/DhPHbeONNiRsrqabtAFppx81dbV0D/wSYO/41TJjmBFTX1jUTQHcJB48AACAASURBVFOaEE9ctSfVIFDuYdUG4WhNVDXZNxZPVgWa/cTO/Wj3m74G/6jycjMWfTuQy88Ap9v+/zXgt7TWW4A14F98e13sSEe+J6TzXnfkhpGXBbkopcaA7wN+BfiYUkoBbwZ+2BT5Y+CXgD/4pvU0wFmzqPQrKsMygw4/7aKL0g21LwcmkcTpf52m7zGZbetdCmtEdp4Hugv0xeT4yPmNjI+I9ThV6CYzLBDE1fOyOXrLnosBtLG7b4GFZYFqElvX2X1Y+NfPXN7IWL9YgwtrKXTMLOvOJqnUhUET3lPEn5PjyHKIxJyUWfHFKl+JpejuFcvxXxx6nJcKYsX2xMr0mIDf1YbDv7zlqwD8zhNvxc0KK2Xb9jnuPyITb2gthDUp5Tf0rTG9KvX/r+xeAE5VVvj0JfGYLV7qwqqbjdCJMsNbBX6Y1/3gyvm58/3Mm+PTqdHgOUS6qkG0yfCiwB+Rdy6xs0t46I9c2sItm64CcNTdSP6YMFges/zWhpRWFLbIM8xMrDOQlPu/+OwG3B6xvJRrURoz1pbZnE1OQ/aAyRubqRH6oNxv5s/7SU0LGLC6K0rOk5VS97omZmLhv3PyFLcnZfXzb3LvI/V+uefci8Ms3+7R+Mq356r9ar3X301Z/+At3BOTKJPybJqu96044S7Xenm2p4Zr977029gtIBzuJpvF0+oaaKW9bNMSt5WmpA3ECRR0e2gskXaLu/l7VHmBZd3evkubWz8KWzcZNK3NVw91jdXfDvs0+9Sso6xb4QustjGx23jotlJBgg9X+7wtLjb9//OhA2T+9Kmvu5/vNXm5GPpvAz8PmEyc9ALrWusmUWwGGP1GF17TWFkzeMRj5eYQ0UV5CNkdFskrJpxmLk3Y1Nhz2qJolEF8XlNYFgU4m4tQGZVu26sO064o7NRAkeK6wA5On2C4R09sYmhSlFTDt/FLJgfoE1Ge2i8KOj7lML2h9eIlDC5dWo7jpEXpufkIapNBHi2NVZe+HNwjyuVw90V2RCTy4FOlLbyzV0Ljfil7E385fQCAueleViqi1RJ9ZSolgSvOnRshZML9sh7CeV76dXmPzRs2S6aeh54WZsuvvuNTfHy3OCH9f9G3UXpAMPbiBsUHxp8H4HeuvpVQVsbHH60SmpK+6uF6gGPX5xP0nJKxzZo8nuvFGP/XjocAWK2+mzPLMinSsFDbRFkvXu0JqJ/Dj1jkNpkIi6Ue1pMGHov7xKZkPJWG8XunAFj6a2Hy2DVN6qzZs9jfIP+YtBPqA8sVdkxsxSch8y2z92j0ijzXL9o7uD8r4xmZcXB7zB7CcBXVsF7JFv+r8l5/NyX/T4pBrBJbqWsYLe24eVORrftWi63SVtZuw7FboWxbA+qjrlGW7RTCdigm3AazNKEQXytKRnn7aBxzvsmksmm1HVEe5eakoPy2uC9WULOtGtfAO+3hAaw2nL3VjyYLpgU3tWdUah832/RR7ktT9AWyLP2TPJk/5XtevuUnoJR6F7CktT76ShpQSn1YKfWcUuq5Rq30SqroSEdedXk132uXTnLqjnxvyMux0O8E3q2UeicSLC8N/A6QUUqFjDUzBnzDbWCt9SeBTwKkMmPacjWJWc3KHWIEVUYVqQvG4q4oaoMyeyen6/CjYoHlnhwkOSUzdWncZzglS/Bsb4rQkli64WczREbEatA3icU7NLnKD26Q7/XvF3ezfZt0ce2JDVhlqe/n/tn9fGr2EACD8TzPTsvGZXg5hFeQMukZC+42KdRyMaqmj6eWhoL7vL8oUMjSC4P87gf+EICZYmtTd+j/Z++94+S4rjvf763qHGd6cgAwGOTMnEWJpCiLkmk5SnqOki3bclxb613Z3rfvo30bvPv2WV57g3cd5JwkWcGmZIkSRVIMIEgiEyASB4PJOXUOVXf/OLeqa0DIorQ0BIF9Ph9+2Oiprrp1u/rcc3/nd35ncIn5FyQa3frfRzj/SyKO9aMPPclfvCyQS+cRTcWQQojXeOppo0nQKdu+D3/5PfQPS9HS3PEeGvvlPrf3LPDonNTYR9sq6HmJ8mMn4qi7zbjnUuT6pI1eqV+TL8oxw1tEGuDiZCcf+JOfB6TpSKJfovJYR5lq2bBS5ptsmsU9ymelRJcU9awp4OqqUK8YlUxLM/l5mc+oSYoWBxTZCxJrlbtjhOUy5IdcCkPyetMjDabvlmg9VNRQMm0El9tIGlG1tgsOU5tkfqMjMdywRtW+oXzo6/ZcZ1Tu6svymaKYP775j8ha8hso6boflUeV5fOsbSAf5G6b0a6P5gKl9erVhT1ynlezVoLFPHVt+9E3Giom0r68kMlnq6w7nxxbo5kILbnNnXNYOX5EX9EhEpb8JtzLJAmudO4lJ2zO4a6L4L3XNa39Rh62Uuta9Hn2sRv/mH9tiSwH7qu58deKfV2HrrX+NeDXAJRSbwF+RWv9Q0qpTwDfjzACfgz47Nc7lxtSlLpDLNzRAFOIkxgL+XosaxtCVAZMYc8dcUpn5Ufdf8phZdhsvZIOF+YEZlGWxjJoxeo2aGTEw9zcJ/DHai3O8bzQjqbWMuQXTSXpTnBNf9F/8/R3sWmj6Ua02OtXZaoNVWxTzFTb5EBdpkpXbDAVils75HMnv7SDG98mebW2O8v8zrgwHpZLcWJ/K05nbYui1ivje/nXh/xen4dXNvJ/7ZJF509X7yI+IQ+f83KG+G5xwN5WtxIPk6/InOgNZW4cFF9zcmKATFrom9Fn0n6/1lpvHaYETdize5zxFRlLZSEOPTLnQynJQYxPD1A33aIS/QXKl+Rz4bzCMk48uqxw98giW62EqdfFJewZHvNpjs5EAt1nio9OxTG/O4qmMraR0qzskM8NPFn3NWicWNi//uxtUZ+CGpkO4xg14NR4U5FRaej6ssxFfhMk5pV/rddir+dz/a2wxn3S3GRH+GmqfqGQ5Xcgql6mpOg7OLW+k5BnV9qqF3XIh1CCcIsUDTUrSF1fk8VZp6oYMyyWig41Kz4DhUieec7cG1OwcjSIofvHBBaRtKqvY9D44w047iCDJhLA3j1VyQSO/xyitY+hO2gSSo45EGnOeeixb2pTd1Xs/6Sw6MNIIukCgj3+4eszpJa17Ftqree6Zd+29g0VFmmtnwCeMK9HgNu+oc8rcCLQ8UKI2IqslMpxWNsow4jkNUOfMpnscIOuo7KyTt8dxTZl3eGFEGpcoseYK0UtAE5Mo5ISERy9JFF55FycV7aa9vGuorNHostGp0VtwcASmaqvkx4/GscaNNFBrIG6JOX+9U1lkgmDk+YqVBbl/fE1Yc1YNTg5ZwqLQg2W5oTvvWFwkYnbXP/66XNyn8kHZ+lLyliOH97CybgkDKNzNpUus51rq9MoSgTa2ymResOxCNvy92SiSsVsJZXlsnpWCm52f+8IZ56VMvuGbRPukgTx6Zc2snOPSAlUayGqpgXfommtV++sQ8MUYxzOorfLhNd1xOeHx5Y0Nw6KlkzDtXlyZKv/emuvME4uRdopmaYaxa01cs/LGGtZUx4e1sTmjY7PeB5luNIT9+e44XZJAp94ehuDnzMMp5TsvkD0Zow0DV1/sUa9Xa6TO1Fm9s4mvPWN2v/pc/2tsCkDScVUiApekY97RVXFINwStGBrOOBVKogR3Ctyv5OqQcWAFJdDMk2d8pAPv9SwSaomh9uDTry/W5eNw7PLz93Uo7H96H/VjfrnidBUbfSSojbaH6tNs5jIQvvQUrB1HbCOy+8E9HC8Od/42KuGes3YVZfPDRc15W6LNdOwObqgKBkn2v+kxmoYLHa1wuIecTbhglSZAtQ7GljT8o/Br5SYvU0YEIWMy9t3SYHFFw4Jza+edbFCcu53bD9F1WhGPP7YDV5PZ5xkjbdvl899bvWA3x0nsrnM5rtFvvbSajtrebmO1sqX9V0ek4Wgc0pTf0wcytL+Om09gvHf1DnO+CWBh6yCTeVWSQrXD/YQvUcewnBeYS0YrDGhifYJdOKeSVEzzr2cMU7xfIZynyws0ZEY4zfIOLb2LPDBm58A4GhpiJfSJg+wZBG9IAtX26Jm6HaBVy7MdrJvhzj3oZSwgCrDIc6eE9ikvKEBpsK2besyhZI8yAsdYabLsojF7Do/uU8EvF5Y2cSpQ8PmHly/YXb70RAFGQqNuBF2GrF82GTqwRwdJ+V+YgsWx58Vz50ZhdXNgZzJMwZ/77HJijQM1Z4k4/d7bJoomVe4oqTq9WpqvwQEToCpUtF6XZGM97qkm5h3UjV8p1YJ6JzYASpiUJzLc5BBaqCN9p2ypVwsj/oY2PCLmJcZB0382/uMnLPpfjxmiaVcbLMABRkzFR3yPxe0GjZhHP+YqKr6Y7zcwspdR8MMWiyAVdiBhaSkBcdLqwjsy7/qnNeatbRcWtaylrXsOrGr21M0rZm918EqSmd5ALdXEdsgK9/M7RlCJhrsOWzhmMqIxIyLZZCI4uZmV/nlnXEyYybSLVg8PidMk6hZphpxTfS4RNaP1PfRYYp/6u0OoTWJGDoeSfD5O0yyI1clY3jrlVqYuZJAO+lojbVTUlwTqsFO05vzlSV5b2VnloFbJEG5erqPfFHgjGemh8l0yzULiRjupEAEtgWTCxLRu5srYFQYda6GMn1UrTCEVmSMIdN2rtFVR3nRyypEwrLtvLjQwUfyDwPwE1uf5Yb9Mr6FcoqZJYF/4tkiIbM17W3PM52X908dHpLr1RXxNQOLHMhTXTLt9VwLZ8aItuRqDKckEfz4+DZeNFIGrIWhVyKjnq5VFo+LfMHaVu3vZuiSv9eW4sQX5Ltf64CxhySOS78CHS+Z5FVYUc0YjvtmzdIOmYdIHta2yOmKgxHCJmCyHKh/5zL6K9cu++D1tncOSwOQOg4JZVgulK94rCQom3MT8wPQpqxtTVvNZGSg8YQXybpa+RF1MCoPmqstH/5w0f7xYeX4iVPvOBmHPL8OTXVPi/WRfrO9nOPfQxCKSdKEcsLK8XcZnpZLnabWjINqQjFKr2uw4Vldayo+UwafQeRozTvMnL/0qju/duyqOvRQQdH9TIi1IYX3fLkRqIwZKdsGVDYbcaEnXdyQ/NhTkzVqbabDzu+sMfWAca4VzfwNBu9bUb6cqyeepd++jPV5gUVu33GOkbx8rm3bNOPPiKDR7L0OqfNynR0HJvyxjix3+PjhzHN9uGnzYBUsTj8r8IJXEUmuwWrZUDEsjbMiD4HKFuFJub7Vp3F6jFZ1IkTqmDjJyKqm1GMYILUojQ7Z4qmVEFZV3l88a+63ofjAQ18G4PeWHyDxVYFznDaNvV8WoqRV5dhxGd+23ZP+w1yoRDm5LBWs0VAD2xSXLObkepGzUaqdJq8xkqJtl9Adi+UIfltJpfnsC7Jo3rnvPAcXxLuGO8vU12RRKv9DDxHj/0t9mt03jwJwbkZyGY2EptQj31ltoEpoVuZKh2DyLd53aeHtxsMrFt1vFj2esTM9JI3We3hNs3yDPERdz9lkfzPGpdlviLb4bW3vbT8EQBibVVP8ElbKl8YNWlitZ7R4mHpMaVy/0KZZCRrUZrG+Bo4VLArynHvCqvvQjKVcf2FYR2fkynDIld6L4PoFSTHV8M8ddMByfRMcXqEpddVV61guQVqjR0+MrYObmpa2Qv6SV9EOD7cdA+Al9l9xTq4Fa0EuLWtZy1p2ndjVhVySmrk7HZSryB2TtWTt/hKRMwIzuGGNvSgr8uhPV4hKBT1T98RIjctqWr4950f3+Y0WjaSsoF1HXRpmL1ltM4UoR3Mg5BNykSIjSKR7caYT2yxl0ZkQRZOUXa4mGLkkcIGq2Oy+UTJwiXtqaLP6XzgxiG0i5+6nZfrm31plY1b0YJZTKTDi/4vLKdydJqnSUyBuOOlzb67T/4TgBaGFPNWNwlAZfzCKKgfU6GZMUksCa7QFnx6XhO+OG8Y42yWFSuFIg8UlSX7+1pkH/GX6wolB3nr3cQBeXu71YZ7GUgxlNF5CPUYad8jyx60SDYovy87CGaiQmDaRViHmz/2N2TEaO808O2HOIPNWvKPOjn4pVjr18gYuLsq9ffjAowB8vOsWlIme1s73k5wyW+R717DOy05N25CcNFGXDRNm3N1bF1mbk+uUt2lUVa5fbVeET46gyt86NbyraVYsxt5Is6w/CH7YgXL/iqdVopqRWylYiKNZx/rwSvi9ZKZAIeu7GPnXCSYxaUbI9cuSp97/r1Twc6XOScFj1jevsAOc9Cb8EmywYV0BRokqx4/WXa18CCkozRvTrg+zWDSTyXXt+lF8QoV5U0x25P8pFsOtXJvdVK4uy6WuiE/JJReNQFPiRLI5mLLCLRr4YYNL1zFxhqubQz7LpdSnfAzdiYJr2BOVnE2p13xZRvdbW4KXA3z6K7fTeVQ+l8pZOAIRU78lz20Dgn8fnxrgfbc8C8Cff+HNHJ4U+mM8WqP+tCwGem+F4UFxWOf6xaF25Ap+d6HakM3LLwucE5oOY5dNHuCrWeZuk3Ht2TrJhe8cAqDzRIJyh5EGrioiS/I6ewGSM6btniOwRLkbVl4Qh7aQ0KS2ySJSGM36VZuD/3qekR8TZ9xIab50WipIY6kqvUb7ZGoqTnRRrlNWMhE333SBoy+alnZJqGdk3gY+G6Fq4KZqO4RMNeZnJg74+jFztQynJ6VqNn4kwXRaHPPA5gW/A9TzeaFSRkMNzj8ukJCddrGNKHf9QtrvHBVdwpdXVi70fEbgrLmb4yhTfJR+xSK6Zpgz42Xq+4bRR2Sernezerp8dovHwvDMe7+OOHLPPCEqRzdx5KAgl4UmGcC0wWixmHOU3BBhU7lVcsMBpkqYmJL3RajL02+58uY/SGcMFiEFKYn2ZePwXgcXA6+K1FLuuuKnoPRu89imNowHIbkEoRh86Cms8LsaRS2LMB4W38xVWD1duJfGr3h/32prQS4ta1nLWnad2FWN0HUIqh0uyaFV1KSwLPqeq5DfIAm1WkoRX5LVNu+kGH23RKgbP+1QaZftUXxONyGXvTXsJVmp1+4vkcsKz3tuTrjSumyDZbZvaYe5O2X9atu4SCYq554+1supsESX27rn2RWXaP3Gu89xc1YkZP9heg/22yRhmo2UuScnKoujCwInrObjfOVfSXON5Q/kUQa6qG+s0vC2e3cVYFEi1+VKnIbZIWhLETMNH5ZudEhcMhIDSlPok3sr9ZqIYUURLpjzhRRrvRK5utk6yvDGR39oA7U2mcPQQImGkemNPZdmcqfAMm57g1LaRGZxiYYOn9kMbSbacxQ9Q8JZn3xbO6nzpmnAsjQEASjXwvzhubvkdSnK9+yShNGnZm/nRzdLafTu2CQ//9QPyT2X5Ia35Bb8BiXJCYvV7TLWzqP4NQgzd2sfkiv1K2bulGElphXheyT5a13IUTP9Z5e3xYjkNe7JN0Z8ohMxH1qJYVPSXoFOM6kXbGIBgWhdNyGNmKWbkftlMrQgEa0X3UYDDJKEVfcTkG4gjRjG9Yt4vHPKedbz0D32i8dykWbUr4ZqAL/4hwCDRvjk2j9X3VwzSf1VTJgw7mUMn2YxkQe/WDTlENKquctxtfZ3KDYKx8gp6ESMa9WuemGRXVKUijHivULnG3sww4bHxLnO3RhlYaOh5a1A36PmYVoogxann5goMPGgEWVK1qiVTFFOMUxvv+DS2Q2Cb52f7CY8Jp+zdhSIPC0ONfpsO+P3GkZH3KUzJQvB6ec386+0QAPpnUu8eFwgCLtgcf994rAePbKP997/PACuY7ZjxTCT95kqy7U4oYJ5P2Hx5t2Cw4/mc9hdUvE5NdZBwohMVbOw9CbD7Ik06N4ix1ya7iB1TB4cT8DKiYDzNiMZeySL9tg0mToP3CpkqmCmf6LYxsRxqUItbtD88H1PAfCnz9wNtjy08VPiaCtdLpFNgqdXJ1KspeXabz1wmue7jfSt5RL/tCxibbtLjEwJy6b/0xE++Q6RtVUhzafGhQaaHSqTaRd8rGToqCfPbMXIY9B5okqnyZNYVYdyr6FvxlzWtsgc2hX8nEWpz8WdlkAgk1K4BmEpd7u0vaxwv3aXs+vOLDxsu+G/VwmITMVUszuPo6GimwVEtSAtMVBo42uM61e/J9dqwhlNzfRma7jqZcVDNcNQsQPMm7BycPR6t1MPOGsL5dMWY8rxi4ycgLyvq9fDL97CEIRc/HMHBLusgL57OFDV6tJcRCqBvEJFu75AV1iFWTNsIh+fuQbtjRHStKxlLWvZG8CuboQec4juWiVkuawuJ817mpEfMCt7pEbfF2VICzc0d1uFjXHyG2XtKfZm6TwpscdSLU31gET3b9t7iv0pgUWOrEnBy7lGL5Zhc1QW48QfMNv1SB3bFNxETyZY2miI00ozeIMoNY5OdLJpmyQ/1z7dxwsfk6iT2+p8+Ks/IOfJy1gT8xbl7RJld3euMW8ZrZkLcZ7PSnRbWothm5J4O9lgs4Fw5j82hDUvoeb+28Z4d88LALzQMcyjmZ1yna8axsndq2zKCT98zMn628G29iJfPrkLgHceOMnhBUnKDqRW/TlEw58eMfKfcQcqMuflHjkgNmdRSso8dG1bZH5KdkFfdbbQmJT33bhL6EGJ4hfGuomlzM7q5hgeDvbeew7y2RFpyPEbT7+TaFaiGvu8nKORcnGMWuX0XVE2fkF2VWvDSZYNayYxYlPPyDHZEZeCaXqttCKy4iVLta+uWNpXpVCK+RH79W6q1GRYuIFmx0nVjM8q2l3XzMFr8uBoCHvqnboJswRlcIMWbMzsepG2csmbyQ4HmjdDs1y/hkWEJvwRbGrhRdRB+YBm9B1sqvFqZUa5ZrPxRdqqNeGfwI4iuNsIdmXyS/5V8HzNpHFdN/uvXj4bUWU6q5WuTYYLtCL0lrWsZS27buzqVoraLt3pAtVGiOKUqaDcWqC3TaK0lUf6WRVGG3YFygLX4sSalaXVnKKWFWyu/6t51nYIBvzCzEYenZTIMNkjmHhv3zIzDTnJWw+c5ssvSRSrOwuEw445n6Y0Z/qFlhTjx4T0bYU1M2Pyun5XGWtKMOXkuQiRuyTS32hogw3dLC9+eaQf2yQaEzcv+PdejURw8jLurg3LnHlhSO7t3jpeKeax8UHOL0pFZTpWpWgkBLThyb9z0zm/2rOyv0T2GYl6nfMdhG4XrPpLj95ExOioH1vaQNebZZexs32OJ8+J+JVuWAH9Z/lfI9VsELGwkMZOSvibSVZYyEo01t6V5+0bRPf9r0/eQm3S1A90OESMYNpfPXcH77vraQD+8pE3o83cevTRSG+J+JNGa72oOffDco7uFyTpClC6q4B2JdZYCMeIyy0QWdVUDJ0xnActpyZ6Ni73c+1Cm6+rubPz1E0iNGGFWXJkd+gqaWwBXiQux1cvmxevtVzacn2uekXb67Dmy60eFPIK8MojgShakpsml6StpjyAtvxoPKYa/mufHhlk0ivHT5pWdGidPEBz/PY6PD0arEL1281Z/r0EBciCSpK2ryQJMauZIC0FFBZ9OiUOMROhu/PN3/W1ZlfVodcqYS6e7SPZnye2W5xhNOTQGZesX7GgWdsaUFjrkYntecaisMEkShY00VU55vwPJsmcMw/QmQ5ipttPUYmTsHtdbCOp+5Xz29mzRRgsZ17c5EMxqSlFzagZuhFoO2P4vX0W5Q3i1KzFKFGTxHRtWFkxcJF5IJYW0ngidyrsEjlt4IVigprpVhm7YZXhQYFzTp7eSMzw7cNDVeKGcRMNN1g8JjzzQlwTKpiim14Zx6MjO3ENg8ZditIwFP5GHBprXoLUxT0nLJ+tt44RMXK7B8eGaGuThW51pJ3YnOGhG6ioVrdQpqFHONbwYZaBgWnyhyX5WW0L8dVZw1UvhtCeZKXGn59aDj4zakqjtxb984S6ZJtam0vQuNsoStZsMA3C525VxE0f0fDxFKVtMiepWYuNfyasorEf3ULFyBPYFYu8KdrKdBconW3ja1CfrztzKxVeMs/v3rAmHFBYdL9G6b8/NQrSymuCgd/guY61zjF75jnAIBxTCsAmwDrnGmS2+GMK/NsJdEHyPle7DCgInjuoyOh40riBcv/LzblMviAc4LgH9WqCvHY7OH8ECqu0Jqa8Yiubo6aQ7VotKoIW5NKylrWsZdeNXdUIHaXRUYfiWIae5+Stmfscal+SCLCwz/WXmOiC7feezG+0fOre2lZR4wPInVQs7zba26eVr86Y7JZIdG0uhZ0y4lPnEpyqit636qwTHjXty7a4ZM4bfvordapZ0x8xrygbah+dVWolgT/iu1com1Z2DUeOzXXmWbkg0E52yzL1ihy7trNOzEARN/ROslaX9xPdRSKnJIru61zk5Qsyrl1bJ5lNe1xXB8cxfN0xib4bO5uRSyhvUeo3vR8DPPT2lyz2vE9U4Z5+fjfRfpmLvX3THD43JNffkMddkut7EbJVU8SHJHJuNCwG9gjOcWduhOI9cv18Ncr0adlB2D1VXEObDC9ZVDpkru48cJ6a4Q8OJlYY2ivb009N3AjA+HKU7BMCk63s1mgzxzrhUJViXJLjFt2Py7yFKg6LDwiVNDavqRvueX57w4eN1qbTpBaaPU7fCPa3K7cCsK3zWV+QK6yUz88GAtWXkFDN9+qB4NYNRMvN5hSm3WMgyRhTjp8ItZS7jkt+pb6jwUSpfdkxHn56pbJ+O9B4IqjeuC6iRr9KSEyuo1+lc17Rli9pkLxsHE16YpOPn1BNLr8NFA33PGOF+NuVm81frl1s7+o6dFdh5UPEZy1WTBea1AXLL/+2qgpD7aaWdSl3muKS7VVSL4sDVg1ITRrGywA4WfkVL+21ic8ZvnJBjrVXQ1hp2bpXept9TLv7VphflkVkeN8kF9JSwp8dUUzfZ5TjxizChsVRX4phD4tjzE9k/AYO9YY8+GsLSYb2CpwyfryP275HcObnzg+jd0t+4NxyF+moaebwPyS8mQAAIABJREFUxQylB+X9XZkZ3nn3SQA++oV30rFdCnocV7HsCBPHSZky/Nwak9OCK9mbyty9WWRyxwvt1MziMpVs56mXpa3PB+9/jD85ezsAZ+Z7UKYx9vffcoxP2wKLRL8i51vdVycalsWvuJDFzcj9jldyjEzLXOnlCJaZw2isxptvk/v88pdu5M0PCKH82PwA79ggC8pMNcPvPPEdMt684ZVvLFPNGdZMzCFzxuClnRYhA0MVN7iUjYxD7pRieYeBxybw+4v2Pmmhf0QWi4VTXRT3VHHj1+4P7fW2z4+KpMOvdj5LwvIcsKaivQbPTYclvPMm08P2GS/KL7oJQipBZxlscOFBIUGIJKxcasa5X66Y6H22qENfV8tlHUQT6FHqWXDBSaiGz3mva8sfT4eqXrH034OVgteLKe2zgIILXEVD2vLOoUl7c4vmC5ckB9fPaa5Va0EuLWtZy1p2ndhVjdCtuvCdE9OapX2yLHYdd1kdlmE02hrETQu4cBF/C509GvWTi5E9q+STErl2HlHUDETSc0hTNtv+zOdla7jy/Xkapk9meMUmuiQrb+GVbkKG5zy+2EZXr6nOfLjd303V9zeZFh1Hbbp/UKLB+VSK+hclYl29SVb+XVumSIUl+r4U0Rw8aVqp9eZxDkoEvNibpLhRovIb3/cyZ5cEulipJ/iDibsBuPOOM5yaFxmCtbU4VtGU3BshraloO0nD666/nKEwKDuRZLhGPCT3NrBtlJe+sAOAfxjcw9s2nwGk2UYxKuP9s6fu8UXAatskCopOhyiNy32prRXe3i9RyGfH9vOWrecB+MqJXTgGIlEKHn3ScPOj2teaH0iv8vFzopleq4TQMbO7MJz+SyPdlHbLPcRGYuTOyK5g8i0hn1fu5Bo4JgFVGAzR86LhLSct4rNmd9avKLwi18ydgaV4yFeLfCOYc0TqBKxbFXXdhB08pcBaQIUxbbl+FBpTri8DEEztCaTiCV412S5e6X+wCjOmHEqBZGmzCUWT5RJVzjqo4/IWdvLZV8M2QaEuB+Xz2h2au4k6zeRmXTcrQWuBqDzI1PF46BbrmT/BaNZ7bSt8CMtWal07usbRb75v7dWyq+rQ3RBUO10q3ZAaM7S0/RYh2d3T/5hC2zL5pW6L2KK8Xtlu0X1EftTzVhtxo5Ka3wTtsrun3KHID8nr5azBvUIO6og4//SYS0P8H4v31KBqnCVQOGiogrcsUzltZAUupggZ3L7aBmePSoFQdusyqzfIALJH5YQzHWkarmDSbUMrFE4Lnl5ZaCMz5ykVKqoVWWieO7gTuyQPyqE9Xk4d1uoxSuYYt2FJF2ygEW8+VMVF0xjDheOXpIDo1uFLPJgTB/z06jZ/IZx+oY/oHfKPhbkMkawsOl3ZAvMvCszU9bznOJul9PdtP8fHjopOSzJTYU9KGkwcGtlPuVfGNNyxyCWjpFgqRZlekXm+VAvR1S4L1/5NUzx6RKikU4eNjnFPHcssCpUNNZaWTX4g7bD5VmEhTXx5I6UNZnuf1Vg1OT6/yyKyIq+Hf+g8x56ThbPUp4Ry+eomOtet9T1r4LsPhnADiouuD200nbsVeN8JOLKYamLH4uyaThLAtrTvGMXRrqcEwmWwCU1nHZQBqGA3nXGA/pi25HdUcsPrWTNXoCoGF4uYctZDKoHG0JfL/do0pQ4iyr3sfjFjbb6OqGZj6GigUKvgVul/usq1bi3IpWUta1nLrhN7TRG6UqoN+ANgLwJK/DhwFvgbYAgYBd6ttV7+x85j1SE+bRFd1bSfkxLyWibM9F2mBLhuU+42gvIzUDOKgJX+OuPDssKnToRIzDZDsbVNZk1S4JpkZc8z8p622ogvSvRS7ghR6TLLcMPymyOEww6uyb3s757muCcGdKTNj9DdO1YJnZYIdGW0jd5tprDANJ6Ye7mLtm2SzIyHG0T2zwOwtJqkZhgx0WW46c3Cp35qbSebPyPjeqUtRXJQItoz091s6pIp3Jhc5okLEoE6FRnrpoEFRi9IZK1t/F6k830pfuPo22UOx+J0mGKipRe7uTAtuw9laSIRiXzu7bnAJy05z9x9Mo5dm6d4eVSi6NV6jPCEnLuQCzE7JPde3NQgfUEembPFzQzdIZrQ8fYl5styn1OjnczWZbdyIVzHMgVKLJtS7Zci5HfIe3bBJr9dJl9HXC6ckB2HldWETc/X9N5FLrXLrqntBP53ePjUMKTls7X+Onopsq6c+7Xa6/VsX20LPymNSw5Vw+wOS6QbTISGleUzXoLcaks1C42igfkqBZgmXqGOo1VAVVFdVkDUbEEXTKwGC4iCUbIf9aObEXWgX6iX2FzHjgkydgKCXJdLFFiB970EaPAaNb/IqKk66ejmDoZ1XHVNTHlSAk21xfONMKEnjnGt22uFXH4b+ILW+vuVUhEgAfw68JjW+j8qpX4V+FXgw//YSZQr1YH6uxYZPyJ4bWpM026SxmvD+CyKUp8mtEuUBd+2YYQjc9JsohxqSle2v7TG4j4DdZyFsGFSzN5vMJmKhfeNhNtL1MvyWKuyTccWccC1L3VS2CfHHzy0k/RFOcdtP3iCJ86LQ01YmlqfEfFP1pmZEQcTvyBOzx2usTRp8DWlUXEj8zkepThgVB0biqeOizbL9u1TjL5d7kdHGzSOm05CXQ6XzL29Mt6NHTErjWn8sPS5ARJvErzfupilZv48MtpNZEbuLVxQ7GyfA+DUTRaFsoyxr22Nubyp2tQ2G24TeGPmMXGio5kc8bTJA6zm2HKXjKTcCPO5i3vk3Ms21TaDV3Y2KNQFLjl3qZe37hHGy/xymropclr43CD7vlsWsdNhWUCqbpINQ7Iglj7ZS/T7ZKwzZ7qJrJgfdRWq+4VCWX6+E2WKiRoJqJncx427L3L+Efl+qjmb0HDBL4z6Bu11ebavtumGLM4fPPLDvHjHxwBpduHNQEW7vhZJpekXpb9oAGrwnF1COb4SYZC26JmldLMIKVgFirBYgHUytVdq9OyZ59x9NchAk2gC2jAVHVrXSCOpaq+6jhPohRrsThSU/fXHESiwspQ4b/jaSJ2DJmpc5I8ffR8D7qmvceS1Y18XclFKZYF7gT8E0FrXtNYrwLuAPzGH/Qnw3f9Ug2xZy/4prPVst+x6s9cSoW8G5oE/UkodAA4D/wzo0VpPm2NmgJ6vdyJtS3Iw/pkO2iqyLs7e4xKdMyyXRDNar2UVVkhW1y8d2k9sxvBOcxpMsqKWzpILLJprJtL2CnHQUBmUOCAer+FMS0FLaniVlTXDhR5yyfXITmB1JUfVyAc8fmgv3QZa+RdbH+VXnno3AMlElb5egVRS2ySiXa3G6YhJZne6lKHSkPvJDFR55YhE4o22ZvOK6nCIhuFMt/eusZqQsei1MM6MvI4NFijPy2srapQHH5rBNonIsX0R3KKJypN19Ba5z8a5JItVgT8W5jN0dsm95atRX6pgX2KcBzOin/4vbv9+mctj7dRTJhqKaRYdSeyqXNWHdtycQ/aUYT00wizOyleuOlweOyvMmgd3vsx8RXYCx4tbOHlEioIyr8h3lt+kmZiVSY71KuoVOXfmvMXKAbmHxGiYyElz7w4+P1250P+0PBPH4sPYOZPoS7vYoyl07RtOCb1uz/a3yjKfSVG/o9lKzZsB0fgWS1rNRF9FN2EH6Z/ZbPjgKTJ6Ccqi22xRFzRLaVzDALMDETA0k5ERXJ8tE9RPD7JSPJZLWDlETBs7h/XyAV7kHgnorltof1xhXNxA6b53Dx4zIKi2WL9sp9JMDiu/7ZxNM2IPo/wWf6lPpV81D9eivRaHHgJuAn5Ba31IKfXbyBbUN621VurK4gpKqZ8CfgoglG3HiWmWbnBJvyJfVLi9hGu0Udy4S6VT3g8+J+kRm+4XZAteHIxR7jA4d0RR6jXH3LxA6JTQ2DzH5KRcotNyi2s6hdUtDviO/lGOL0h15pLlsmw6Cd1x51kOjQwBkDwZZ9aIw/zK9Lt5aL84wJ/qfJKPmyq9gwvirObzKc6Py28+NBUhvU/Eu5bdOAkj4AWQ2CgPx6VLXahOWXw6kiW25mThuLjSQcoUH12a6vA/55riqfHRTtr7xEHfvHmM8bxANQOpVfrjAsVMDLT5Al+RS1HmGwJJfe+NR4jbcv3fPPMgm9sFcmpPSC5jrCMDWfn79sFZEiEZ37mFbsLPyUKYfdcMl7TQLQm7tHVJkkFXIty+cRSAG1Nj7OsUbP1flr6f6VkZY6lf7sGdSRCJmR9vNEp1VMbXmdf0fFW++7nbHUIGPms71xTtSk43mLjfUEmHlsibphnqQor47hWs6Hrn8hrsm362g891jMQ3et3Xzdr+5ggHPyJzfGdsxddykQYOxgINo+so/5iatkiaAMHSep3crmdXqgIN4/oMlYq2SRtnHGS2OCgf244px4dl1p3nMujEs0gABw9SIq0Agyao5bJee2b9NVDrKYnBJd/7lAUkAotCOMBuOVQRH9D2N0eu4frQpr2WkGYCmNBaHzL//iTyI5hVSvUBmP/PXenDWuvf01rforW+xU4mr3RIy1r2rbJv+tkOPtdholdtwC1r2T9mXzdC11rPKKXGlVI7tNZngQeA0+a/HwP+o/n/Z1/LBZWr0FGXNaPBYo8ncYy0atuJEKU+WQf7nmswvlEiD9WvCRUMZ7U74fPT5+7QWKY9WTxcZzFp+lNulujzjp5RDi8I5KGAzrjAIpcKOQbTEjkPZZe4OSsJwP/55QeJm+Kf2L1FGiahWKuG6IlIZPzro9/DbMEkF025fXEmyZ0HpPhm+q+2MJqTcQ9tmWVxWY7NGaVDAHslhBs3PPxssllavxLh/rvFt4yOdbFjhyQuR+YkWlcKlk0LtsNrCaJnJHJeindzfo/cz6b2ZUpFA5F0N/ij+yRh9v9ceJcf1RQKMU6MD8k1Y031wsEvyP1M7N1EZb9E7kzFqGw2UMxqmnC7lKMkn06hHNN4Y6vmXFoi96de2sHWYZFNnJ5pb/Z0NTIJ2aEV+JJpY/euScZOCbMme76EXZZIb2V7ls7bhKkz2ddO6pTcTz0VwjWsGaW0rzx505vPcn6pk6+xSfya9no/298K0/UaP//Z9wNw+D2/hWUizbQK+QVHFe1iZI4uK71fP1/Bgp5/zOxAO7iYctYV9ATP7zNblONH8SUd8qEWK6AT4yU2LaWbLJbLvk43wLKxfAZPszeoHfhswkT/Na38RGnFbe5IoMn8CUJVdmAHA/Bzfydzu7X+3D86J9eKvVaWyy8Af2FYACPA+5E5+LhS6ieAS8C7v95JlCM61uGzYV9Y6pa7znJ8SuCPcm+KTZ8XaKWwMU7Xi+ZzrmbhJtma17IQzpus9rxF9g4JniZm29FGKrdhBGEeOb2P6IiwYir9dWZXBBZpdNUYGhSYY6mYYLkiW+Z9N15kMi/XWc3HST4jO4r6Js0fl6Wa0040cA0T54Ed0i/06aMHeOEpYbBEblKoqtzbxHw7G3tkcbk01YGuGXpmX8XXY19dThKaFsy/68ZZbk5eBOATxdu5MGMoh2PiuNN7Flkx5xjuW2AiKguHPp+i+IqM++J0OyHDRGlsqvCB534MgBs2jlNqyHW29c9R6ZbHeeyswcEHyqxtlOv0PVtmWsnr4pa6rwETCTcom3OEipplkRMhVLBYOCVj7TmuGcuIox/sW/LxctcUEK0uRugxjcAnF7PokIx14UACxxRQ1dodlp4SLE1tq2IKGLEcfLrp0ulOkgbOev78ZhJnoujCN1Un97o8299K2/FfpPvVxPfB5lAQ9pBnLKYsX+MlDJQCsESwmbTHfsE4tKAgVpAFE7QghdAKiGNdrrcSDQhyeTK4HrRiX4aJBzXNvSCkou2AJK57RWy/rq1ANakR6gs4cAu32VuVJiXR0dqnMMriJ69nHYudvyVz++2i+/aafgFa62PALVf40wOv73Ba1rKra61nu2XXk13d0v8IFDY5pC7Z2GVZBZ+/MIRt+MMd5zTjb5OoODmpqWWaq7CX99jwb59l6cfvBKD9rMuKSdLFgPa7Zau/NycEhUen9qH2ClTSFm5g9clJliba2J6VyH481M5AQhKKZ1e6+f09fwbADx/9cX/LF1lRRLeb3pcjbWBK1+/OCszy4k0b2NwuidCTEwP8meEF/8hXf5KJo1J9dMfdZzh4XHjTbb1FaoYJU5+P45oem4trSf7Vp38QAN1RZ7BTItBLhtftfqGTrnfKuLORMhs3SLZwtivNxqS8PrvazcWzAmMkU1WqFQlvD58cxsrItjd2Ku7PqzaNJNyZGEWhpLN8q0334zKm8t4GysAca9NplGGSdPzIGI1PbgKgkYL0zXL/iS9lqD8m3+HsxiRxU0vgXJSdUnQJil4i+ytJKibBXWuT3RuAqivKm00tQc3CQ1LqSbA7JWls2S6lM0bPJKQp7ynjxt9Atf8Ba4xLFPnw536Jl971XwHpx5lQ8t2XdN1v4lALwAkWwoABKLrNaN2DHyJq/XwmzBex6to+5JFQDvlAwjOYoPSiaxvtR+th5fq/K4+rXnFD60r/g+fypQcCcIqt9DrIJeJz1ZvFUc3eodqHVsKq2QAkodY3tvBYQG1WiIrpBvXwI7/EtvFDfDuZ0lfocPJPZbH+DXrTT30IHdLUNwsWa03HfE1st6PuY67JkzGSU2ZrVnQpdhu8ekD5P3DlQGOPKefUCm2+xNC5hP/3arucI7qxQDkvWGyqrew7unoxDLWmgJfXSWl/9zSvrDaZJjPjhsYXc2h/Rs7zpp+Shs6fP7eH2AvixL7jhw9SdOTvS7UEL17a6I/PMddRtibzgmkvZ8Gm7xUZ3OHUAks1GftTx3eSG5CxrKwaFlAhzG8/8OcA/N+n3kVhQvD05ECewrwcYxVtLNNKrtHe4EdvfxaAP3/8TSjT5SbzCqzcJY5RG00bK94gZGAgziWp9coPzE408CY8dCFORobKwq0uKmMWg3yYISO+NTaTI3RJ7q3rmEvd5ApWRNEXe1ee+JfS/r070WYhWed+WaxqDZvyIckrVHoc4lMyxmqni5Mx+ZajYepy+1TbNY2uOjP/5r9SvThx1RW6Miqnb1ff+oDe7unmI899DoADESi5shDX0b7DCsIvQU5QJEDd8xxgRbMOZvHglyAUE1aQd5vQSpB9EtRvuZJ574eV62PewYpVYF3RUFDsyzMngKHLfayXyo0pHcDHA9cO3KetFGE8DF/xYlXyXr951wM4s1fkelx1+7L+5GGt9ZV2kuuspeXSspa1rGXXiV3ljkWgQ5regw3yExLFLd3SQBmtkvB4hNSEOdTVJGcMRHBulsr9plTe1jhmae08ppkZMkVENcvXGUmPyyo9f5Mis0Wi3PKxHFbGcG7bSzAqkXB61wr/bo+QGD70/HsoG27zcwd34rSZKHUlRNhEvfUezS0/IZoOY0WT8NMKda9AHp88fpPfX/SP7/1D5rskjPy1T/4QbDKCpUpTult2FvXVKCdPSxRf3BZhZESSlNFc2e+CdOBmKZ9/aaqPv5y7A4D3Dh/h95fvkc+NZcidkosu310lckbmtpFV/OkzkswlWycyJXMVfdccjEgE3HHMyJ1+36Lff3TSThKZkbms9UDbcZnwcjcUJH9Noq9AaVIimYFt8ySNnkj0TJxaTua5+xdHOP7iFnnfyPXqlzI0jHpDcaNLeqvMm7OSYFubFGwdfGoP7eMm0tO2n7yy6orwpIzFiUkhGkBiWlEiDPU3jnzulcyZneMD/+2fAfDsL3+UqGlq7Oh6Uyo3ILVr04zSLZrRnVeSb6tAVB6I1p0Ac6ToNmPCtKd/jHDcKwG9F3+MqHW6Lp7VAwwWAoqJHoTjotY1qqhfQSo3otxXJXYt1kfmfv/Vy6Anb67CyuaX/8dPA9A3+yzfbtaK0FvWspa17Dqxq4qhJzs26L1v/yWiqw6lLq/1mKL7sMQPczfFiC0Zyl1MaGoA4YKm3GVW7Qh+xBZd0r76XmbUZW3IRIHm77ElTcMQcOsZ/I7xqUsWHtvKuX2NSkkiV10K8RN3fRWA1Uacp2eHAZg91+Xj0kqDHhSOtqf7nQjXeVuPiFP9ryNvYvOAUCInnx0geaMkC/OnOmiYfqHxCZu6EZlqJF3aTxls8HtnGB83nPOSjWqXqNfDpGudDoSM2FfV5oFbpHr1y0f3gKmSDM1G/ByDG8Kn9lWqYWpFQzmMNXCWZSfSfsLQAG9q+A0iejYt0Z+SRPHRs0MkO4RKWj2fIbJq6F3dLpFl+Wz6tnnmpyRBGV4MUTc4N7b2v4zIgkx4ra9O+pSMI7aosd8rGOXy8z1sumcMgFdmO1ETkrjtOKFZuNGcrqKILMv5sqMOi3tMoi0PjSSM/v5HqUyNv2Ex9KDFn+zhb7Y+AjQTfgB1nAA/Xa8T8PIbX2iPy96sNnVpYuXB5hF2ADPPu2EfN7cCiVArwFu/XCkRhOIYPI8TUHgMVof6tMXLkrVeub+jXy20FVXrI/SY8oTBtK937mrtR+jvG32I1XsWXzXGb7W9Vgz9qkIuThRWhy3aLkDHUdlqF7ZmqeZkG13p1lRukwKczs80y6lXhy1KGwX+SJ8LYXKOVNuVv+1e3KeImBJxU+HO0i3NhF5sPIJOyMNWzSnazskxayczfp1fZUON7rCwMh6Z2MvqIWHQdF3UlM3CUenShM7K2DL3iuOuuTbjFYFHvnPPSR55Sfp1knOpjQksk5lSdL8gC9f5H4v6Cc9IyGEWgT8an++DXXKfOqzZOSiJxjNrAjfFOso0RgTmaHTXeGZcpAc6B1dwjDPWL3awcpMsBL39y5Sq4jzrs3EiawZe2VukYDo5WQ8L9JNp2D5rZO58J3nTDcmKNdjZZcZxKMve75IOSA3X4uyCYRiFGqTPyHcYW9S4hgu9tN/lhhski3r0tIxVlW0qneZHenuRmkk2bzja4GJE7tNNumy6UZpqLMwNgGu21CvKh9MmH3IIz3vSyYq2sy72td9/4KpZ7ScSHH1U5mdXpEbMOKyS6/odeYJ6L7bCZ7n4zZsvO6fnSIP6KEUd8hOXCdVoNp1W65tjeJ+10Ot45jIOta6IKBbQl3Gu0N8URNrAu4d13HJjQU0bzyJK+cVUYRRhc/d15fBiTX4nhfdngWvPob9Wa0EuLWtZy1p2ndjVTYpa0EhrErM1nJQpq09Z5I5IaG3VMyysSgQaqjRY22hgmS4XqyRrT7WjWe7ffbTuwytrm0JeLoXCkInK2ypUp000PaJJTsn5tILYskTrK9ts9FaBFGIhly8vSmfvXblZjqxIBDp3l8P2bRIxnp/opm6iW08PHOChdmk4cLoywK/e/g8A/Oe/e5cfNZZ6NRd+xgiPuQ61pyQqX9pSZ3i38OYvZrqgIsd0blhh8rNDACTMFkJPplEGqul6IsL8mwyctJgmvGagDQs6n5ZoeWFXN5EtsuPQKYcDN10A4EP9j/KBYz8qx4xJVH7zvhGOhaTatPdZmLlHvge7bHG4LNG13e1y6Jx5HXW4aaOIcL1wbjNd90tCcyUfp75qRLMqNi9/xWjK7xMIp7Qcp/NpGetMqrlrWNmi/ETVlk/UuPhBidyzaxrlRWkFTXxe4sbBz4WYFY00suddlncpnCdomTHnwkX++a/+HACf/+hv+bBLWFl+4rDkNomLMaWIWgaO0F4iUvjpIBF82ousA63rYsoJUARdSgFIJRloJRcUywrSFcFUjwa02JsiYM1oft05aPLnHa39Rh5hWAcR+fdloJWS6/jSCFaAg17XLr/2YUmEps5/e/HOL7er6tDDeU3/kw1mbo+x4XNSEu9EEkzfJz/etW0OKZFVYWFviMp2gSg6cgXcvxNsObaimXlY3p8hTkh8MZYDazsMKyUvD1XyCyk6TZn50k7l49apMZi9RW5daY0zYXjrVVjOyesXTm6BAwJd5J4Lcy4k1TCJ9jKJqDiVueNGSqCtwelBoX88ubCdqmMy5gVFY7dASI35GLpkZHXPhIia3phOOMxIpMtcJ0L+Pjm+/HQnxe1yP7FZs7BtqtFxUJx1fkihiobFEHdxTK1QpQ+ic3L/Wmn29cpisdiW9NUZ//XF76a4IPfZtUkW04c6X+LUJilIys+m2fgFo73xs0usnJDFJzmuyPfJT+Z9e5/jxJrcczRV5b5+00h6cjsLBqvf/Hd1VofNojcpbB/dq1g0DcLj0xalTaZ3aI8me1LubeaOOL0dUiS21B2n0i3X7HlOMfkWOV/ulPbhtlBVk5hWWJdjBG9wS31c9Efu2vLPOfHz/03e1FJ0BOv513W03xC5FMDcg80wvNxVXV+mwug5+gDmHUav47B7UIDDeugGmueF9RxzN3B9S2sf42924V1/bjvQDzQW6KfavJegzG4Iy/z13t/9JTZ84tuP0XIla0EuLWtZy1p2ndjVLf0PKaptNk4Ulm6UZKFyoSIBIJkLNvlbhUESjjbo/ZRUP+YHO4m6noiTYvgP5PiLD7tUBkyv0VfChFa9Nlbyv+6Di1QGTTmhsokuyh9Wbq/6NNTEuSi1nJwjOlxgynSvj3eVcIzIV6k3QnRSIsNyMUQpatgy2wVGyMYr9IcN370RZq3SrAJVpvJ1+94Jzp2W2vrCRpdyr6lqLYAykbu2oLEgoXZ9qEH6vLyf3ypRS65rjeV7ZU5y7UUaRv991x2jnDkoUEi9vUEtZyCpHfNsiEsEfujcZt6ySzLBx+f6sY2Q2fyswCz/izfReEVgFhWD5W0mDqqHfG16u6oJm4Twp756H2tbzXZ8Q4m//9u75P77G+zbI2yVU+/vIxoTJpCnhFgbydAmeVVKfdD1nElMfc8yK3ulgjR1Iczis7IjcvYW2N4tSarRlY3kTmt/rnpNUFXqlD61l/VaaJmxwd94lu3dPwvAuXf/D8ra1AwEdL+jNBOGCcur/HQDioTNqL2oQz4n/HJ5AO+3V9HWOnVEz2yHCEZFAAAgAElEQVT0q5guEdx1SUwvKo8pRd5t8sk9C1Z51mgmdsOoZs1C4Hzuuh2HYctpze6PCyS19d9fH9E5XGWH3si6zH9nleTzcVKT8lCNvy1Cw2hwJCcVA93iGKOhBkUtzis+r+k4LI5Jue2MvEsw2g1fdqgn5Qta3i7QB8BbDojHeHFuH8VNxuFfBPvNAvO8uWeSyX8uBS8XH9YkJkwBxIUsa3sNVXApTNhQ9Ko7y9y9VYp7wsrl8bNSx76vW+CMQyND/Nu1d8g91kM4a/K4dY5pSvvl+ucnu7ntRoElnn9xO3ZJzt3/TIWL3yWLxfIBh/Q5+UrsGmQvCoZQMI2wl5dSJE/KYmHPRGncI+e+MN9JvUuOzZyM+LmEuY4MjxT2yj8qNic+Jq+Xb3KazZvNb235ZCe2kU+JrMAv/dwn5dyVHv722JsAWLrJIWyoimtb8AuvQmeTlIcMs2ZgmVPjAt24pRC1aRmv52x1RFN7WBbC6kgWx9BKa5MZOjfKd2893cGStDGFsSRnV8w5sprlneYHGdN+JyO7IpDb16gwbxmw9ZcFftmuf5bT7xG9F0trwsr0D8X14Yo6zQ5ItUCBjoebh3F9FUNHNx1wXQcojQqfuWJfBr/EfGnb5hcWbDYR85UPA2X7inUl/JWvQbcOlvCDOHNP6kAgJrnffZ/4RbZ+6NtDEvcbsdZPoGUta1nLrhO7qoVF0eEB3f/vfo6Nfx6ikvMYH7Dw3ZLZzGVKDGdle33w5S3YqxKt5k4oqm0GoqhoPxFaHFDE55pb8PyQvB9ZaSZbvN1dcVOD3GCT+z1zSeCKaK5MfVJ2Ajqs+dhDvw/AT/3NT+OaUv29g1NMFQSKuav3In//8j45z3mBR6rdDvFJE+mEIHKT7Cbya3Ew0XpyzKbUK5GCDmli/ZL8rF1Mo/vkOt0da8wvyXUGu5Yp/5lEulZD7jH6/hkuXTAt4KKuXwiU612lUpPraK1wzqT9eajcJJPVKISx17w5VzRyEqFHM0LDcR2LulF1JKTpH5DdTK0RIn9YMLEgz9uNQOQGuc/Mn2ZwQzKWqbc1wLCAQqs2jazRwU6bfqHJip9Ec7+S85O57i1rVMcE8rHqyte8r/Q5aHP8Q7ee4ItP3SDn2bxG6aLMVXTJwg3D2P/8KJXJVmHR17OJXxd47IWf/S/+ey6uD7m46wqRvIIgvS4Z6eWfw0DeYyGh/UYadZq89nDgG5Ho2jvG469rSboCaUutU4T03g8qQ16pjRwIhOQG2DyelYx6oqM1b/3dfwkIDPXtZNdkYVF42aL/byNM3G/Re1C+ioX9NqknxaHO7Y6zUBPnEaorel6UY0qdCk+hc3mvS9RUHW74UhFtvmQ3alPpECgmtihfana0ytIOeW/jd0xw4ZDIvT784CGeMQ/h8uEukqb6sHhTmV/+zQ8CYHdDJC4wwk8OPMnvTtzn38dAlywMi+bvqhyhnJZzpI7F/D6d+dU4iXEZayMGiWkDF0ShURKnu+XWcUZelIKaBUujjMZNtLfB5ENyHqduHs6pDiLLxik3QiSmzRb57TZlo6uicjWilSaQ2FgRJ52+EKKwySwoYcev4GyMJc35FLZZ/MJFxVJG3q9VQtimSbXVUNR2yQJhj8TRT0kepNDbhIewNZbpB2pXIWmaShcH5eTlDRp31sBGvdpffKOPZ6jslh+e6i9RXpJj4tMhnyn0xWdu8DHStj9L4xr4pZ7WpEdpsVxeow3+B3FmD57/BX7r/xP2y23RGAVXAgsPL3fWqTSud7SO75SbBT12wHFbrFdzDDreJlvFqwJtOunKZdfw3g8uCiWtyRqcv6rddQ4+ZZmCOPOgVHWDkbosRb/yL3+WwU9+eznyb9RakEvLWtayll0ndnVL/2NSyOOGXJZ2ygrbfsal7aRs7zOXsiztMmp6EZgyhTMeOwWAdIMNfy17/6l7kww8IaXryzubnPT2M/Ji8i1JalmzZVzMYRqVc2JlgIUViWid/johT8tlKULfD4wCcP75TcRDkvT7DxfeQXtMouV9iQnCXRJ7fHpBtv8P7zrJ3x28GYDIqubSuOwyVMWmnjaaLQkNpnCjsqGGMu3SRhdyRLdJ8U9xMUF8i7BCfm7jV/iN2kMALJwQmEXb2teU0XvylF2J8tPhBkWj+9L+eIyiBPzU4prwisxzpUv70gdYGmU06J2E2S63V3FMe7uqght6hAf+0tNbfW0YqwbxY8JyqXRo8nvle8iciLI6LN9bx7OaxLxcZ+pum9U9JnFqxtGeLdLZJ/ots3+9icrbTIJUKwb+0uzUbkqSGzP3kIH6Jbmmm3WwTYHZ0g6bkGnTGllRIgfxxhZb/IYt9YlDfOTYewBIfGyNvxr+IgAO8iyFsQibL7/kOn6y0qUZxScDkXvasv1iJZdmJB7s2RkJcMWDSo/BQiE/sldNNksw2s9adhNauexLrxt4xWte8b7Rh0w5PyS/zYuGXotdVQw90bNBb3vPh1jZ3SA+aYpsRl2/G5HSUEuaLzauiC/IH6bf4pI7avpa5rXPZljbbBFbMF9sAUqGCuidr9ytyQg5hZXdmv6vyrFzNwa64GyuoGZlmxZdtCgbGmTmrO1L3Pbn1sjFxHscvzSIZZgbrsG+la1xDP6cuhCiNGAq7RIOiVF5JK06NG4XZ31j/wQvmh6km28dpyPWbCB9ZlGc9/JMBky/zVS7LFAf3PEUv/unDwOw9aFXOH7eeG4LOrtlUVgYb+PAbqnOOjPbTW3OaOJosHLyQ3WqNvGM2V4bHN6yNNUJg2FXlY99RxZsYmZBXdtVJ7wk39vAEw3KnfKdpCZrrGyVOVzdgs+WcSOw4RZpdD3+ghQh1dsd7KLR8Iho2jYJfFWqRGiMi0PvOKaYv8MwEwoWTkpe545aTVZMGqzb5LM828aGj53h4MqnWK3PtzD0b8aUYvpD0gnsd3/Og2G07yCruuEzR+ra9SEUR2u/YMdG+YyShGVTDUj1BgXCPGcbdMbBhtXuFT4TVmodLu6dO6Fsv0DIxeW40WT5mf/+8wD0ffTgOqncb1drNbhoWcta1rI3mF3lwiKJmmNzIZyYrJrzN0PmgpFhnWqgDSwRqmhS4xJFDn/cpthvtFwyzRZ0WkE9ZaLHYU3ayAas3CxQQCJTIe8IE8KNuawMy+22n3UJmVT78p4a9rRQLRoxuGG/qAOeLG5lICdRb74a4aG+UwDMltJsGJYLHZuUqFOfT2HovBSGG/QPiwrjwos9fsSvGgrbsD8Ont5KzPDQz13oY99O0UQ5/fxmdt46CkDsL9pZ2Wruea9k+z43u4+iKZVfqiR8hkq9GmLlJWHtWIMVZooCxVSX4qiUHB8diWIbSVrrzmW/aKqal91GKlfCNQVTdtkme9oUNd1aZs2oYaqY4yspztzW5Dw44SjOdwrjJflYjlK/2VJHNCPjImuQNJz+cD5ERKaV1Z0O2bh8xytjbWjDa1/eHSbUIRBX5lgSuypjXf3OApYp1KqNpgidMJK9wMqD23G+GKNl36RpTd9vSsLw3//52wF4+SNDfOUdHwWgPxQNHNwIsEkC5f1K+cnSYHQOTdnaYCQefB0OSNl6hUKWwpcjcALSBBaWD/nUtcuSK8/NWz/3IXb/v/Lb7Ju5vpOfX8tek0NXSv0y8AGkVOAk8H6gD/hroAM4DPyI1qYE7WuYjmiqg3VQmv4+cQBTYx3okHyZ8wdCVI1uR3TWphEXB1TLKHoOyw98YU/ch1wia9D2inyZq5UQhUFD70uaXpeuRcSIVrkRy6fIzb6lwdAn5HUiWmdhm9GAKVicf0TEpHSPy+SCOAz7fIJD2SEAyrUwNcdoexs4o/2SFN0AJEdDTCnB0GM7CoSME49EG9imGCN6NEk9ZaryRsO8vCxVnk6bw9iKXLN4B+iInDN+QqCIzqGL2Fm5t6mTPey/TfCkbKTCE7UdckOFMKWUcbZRh9RJ+SHm99SwDA1UX8oSNbTJSErOVxrNYJkGzNkNKyymhMGSTFXRL8nElXY3CBfkfhKz2m/wrFyoPSd6PE6n9gtKElMWVbMFji7Lm2ubwTbiapmzNmMNoWaGKgpt8PF6dx1rRua23KnofEm+n8qzadb2yOIWbijabxNZ38JjPczco6k/wzdsr9ezfT2Z10dz+8/M8fMb3gvAmV8e5PfeJZTeO6Nl7ADm7VlB14kYBx+kEEKARhhw9JYPvdjr9GWaEreWX/hkYfnMlQYOzxq56n/2mfex47elzdn28ed5davpN5Z9XchFKTUA/CJwi9Z6L0IlfS/wn4Df0lpvBZaBn/inHGjLWvZ6W+vZbtn1Zq8VcgkBcaVUHUgA08D9wA+av/8J8BHgd/+xk9gFRe65MEu3NKj/lSgV5mKwfLfpeLgSpv9xeZmYLDJ7u+FIuzB7i4FF4tD7nESStbYQriGorm11SY/I+tR5izAnLh3rp2ogj6G/d6ilZbVfdiIsHJDrHMjNsSkrLJsjr2yisclE98UIasZwwsuwMy3R4EtTfbxUkqgyc9ZIBtQ0ysAC1Zz2NWVq6RDaayRxLknuDpEKWHbxeeBWA78LkJNSqCckMtabXbKDch8F07v06Rd2kRiURG0pFuXYRdNn1bGIml6b1S6HUtFAD3WLgpE+iKaqREynoMKBCpxKm2ua5NKMhbMkc1w8UEc1TDR0vM2fw+hIjLrpy1orWKQvyevVbRbZC6aP682QmDRsnk7Ne97+NAB/PyqyA85khnyPYb7MRfxo3olqYqZhRXwm4jcxCRehETdzWIPotOl1mnNZe0qeofJGkSRQ31x49ro829erNcYl+t36oQn+84eFybX83pspfa88m394w59wW9TsCN2mkqP809QvKOUnLsMK/3XzuGZRk30Za8U79kTN4ceOvh+A1KfStP3NEQC21J97w0flQfu6Dl1rPamU+v+BMaAMPIpsQ1e01t5cTgADX+9cyoVwUdP7uE1VkAXym/ArHu2Sxext8n5kOUml24hgjVr0HBKmR609wth3mIpGpYnPmYcj5JDfKo6n/KIMxck1sFOyRS/2xKV93f9u70xjI7uu/P67b6m9WGSxuTd771ar1S2ptVgt2ZJlWZYcTWLPIJolHiT+4GAwQIBMFmAyziAf8iXBAIGT+RDMYJBBPniM2LDiGcsaZWzLtixra6lbUqtbvbObZJNNNnfWvr26+XBOPUrIBFYmIimR7w8QLD6+enepW/ee+7/n/A8SeFQeljJff+0wib3ifZJ9J07xuM4wZQ+/2NENgW+/KwfM/+HEX/KHb/wqAKv3yMISuxkjMSITLe90EZf1gb4fWGZPyMxUHmkTVzfI0oEWptnx5nE4eL/wfjEn4B8/8RoAv//cV0J50SCtVE1/BecVccFib0BCqSXe7qI6ujas40qRVAfbHDom/Pz0ao5qv7ZtOUbylrweOCl9trpfoi0Bkj/MwoB6k+QsmXFZoMqjbXrOy/X0TIvSsLpEDrRw6jKUcpcsVdHVotUV8PKcaOZUNPl2csolpgue07LhZB0kCT+fyqFW6NXUyBlmJbARv2BJi9MMjZyhoXLIsWWXRm8QBp99WHyUY3s7wDZlvHV/8zW6vynX/p1zguZj4r4781Ac926Z6J/cfYHfzIub4F0xiBs1OGwT7wNJ4cSD5pIGhX17+QGev34EgPaZHMOvyHfM//kZRlrvrdVlHdq3FfBhKJce4MvAXmAYSANf/LAFGGN+xxhzyhhzqlUv//I3RIiwQfj/GdvvH9dNotx3ET4e+DA2zePAdWvtPIAx5nvAp4FuY4ynlsxOYPpve7O19s+APwNIDI/a1QMO+fMBJhBLb8cZyy216EbumWFyVg47bn9wkjOvyQFleVeblaJYnf3PX2O0IVTDzc/4Yfh7tc+BETk4bbpi6jlll9QlsQxaScvynXrwUnZodYkB5lQdatdV+yQNuTc15HyhTUODgryqZcXI9X+7+htYX6UFLnhatsWeE2+a/OU2flE9W5oB9R65t+uaw/SS1PvA525w9ao02jYMN/9yDwC1zxR5Li5ckPUtNc3xaTXpsu+3cB9R838iR70mbWuPtvC7hbay4+nQDz8+XObSNaGHaDj4u2SXY2aSNHLS/zeeEGup6yphEFZlfxOjPvA7+gp86lGJ8nnh+iHMWfFVXzzq4eumpPusR2ZWD4UnSlz7h9IXXsnl5ukh7U8pr3RnDfmUwJ+Ms++70p5Lv5Njxyn1cKp6VFVSuTYYhFIP9f01/IJ8DtndKxQWhZJrdaQR/t/ttr/z2H7/uO4y+e1rMLYD/BdOA7DrhbXL54BzSEopJ5HAGRBvJ5ta80QyFY2FuDVPu6a0K5adrFnihFcjfBh8mAl9EjhhjEkh29LPA6eAnwFPI94AXwW+/0uflGwT3F6iPpUOPSQK+yCWkq3cxOQO/DmZpE4Hu0Hd2AZecmnKd5eFL+wLpXezk7AsGePoGgM7sRZEA9BKQXxJJ/x+syagFYPEoibNHWoTn+9MJKCJzZl9qsGBP5VJ6vqXUiQPi1dOcKmbxKTUvRP4FCQcqgPy+uYXWyTHZEFpZT1ymoy6tAvsEaF2lipJ7jqsGe6f20/XhO7ubZYX71ZvlUSb7B4V+SrJYvbkros8+9cnpO3HVvCelwm/OmCoVzXrkmdDoSz3VJaDL8skfvU348TOpMM2d/jmrjFpe2K5Tf6C7HsnfsWn3Suv5yd7+MWP5cuYLVhKo2ueLZ3PpO1D3xmxUiuj6VAQLXtN+hQIKTbHswSr8hk3d9Up3CYUUnzBpe/nMm9OfXkEV7/f9T5DkNSoxLOJMGipUo3hLmli6v0Fyoupv0uk6Ec3tiP8X9Gu1WhP3NjsamwL/FLKxVp7EngGeAtx63IQy+TfAP/KGHMVce/683WsZ4QIHzmisR1hq2FDQ/8T+0fszv/4uxgD2RfEvFt8qBHKrZq6Q+KWWtHHitQ1N6WpeGSvyPXKkCUzsaYmqO6o9D40y+JrQmPURsS6zJ31w4M+pwXZKbG4b93v4KoiYeb+BWovyv6+mV2rq1+C2CMSILRaTOFdFSvZrRp6L3Qsavm1cNSjrYqEg6+1KA+K9b/0+RrtklQgecOj0aMWfaYNTkf935KYiIXtqfdKHXfddouEJ+0YO7VL+sS3tLNSdrK7RtzXJLwv5an1qe/uqiF/UZ6RWGiweFS2uKsP1eh/XhNzdxmKe7X4yprUsC8bCCpDlvw5eb16ABrqlULbcPzIdQDOvXoAowdZjZ0NUpfl2e2YBG4BzN9tiKuaYid2oHZ7lfhl6ct9n7/OlV/skWcMtojNSr8l5w1dk1JmecClJM0niIGzUwV7rqdwVdcmtiLPH/uLb1CdjeRzI2w9RKH/ESJEiLDNsLF66G7AcL5A8Zkh6j3KxRY90qNiGpZmMmupyi5l6JeMbdR6DeUR9VOtyyElwMphSM3KcxZfHyR/QcW89slDajt8rKoK9ly0lPtl/UpPGwoPCLm7dDkPw6oTHregiRh6f+Azs1v8v0d+AkuH1wy/0tAH3a56LgdUBuTaxJcNuHrgOheHnLxOLFnqQkUzuneeqVvqb17xSMhGgEY3pCfkObcGs9Rvyi7GGVFC+VacRE646upikqbWtf8LszTeEJ/s2CoUR+UZ88cTOPU1C7zxFTmAzP5JjiVd65tSDTJj/lru0Jq4agI0htZExpP5Kst14eo/9cgFLi2JkNjCfJbKLm3nLY+mKjg6e8sEFzqCX/KM2FgyPEzt8mv03DsPwOrJftI3NcGCa8M+Xr4rCF0Y3Rosj+i4cQjPAfpPVVg+nIxyikbY9tjQCb3R8JiY6CO+E1opmUSTsy6VtnhF7PtBk4mnZNLtPWNCv+Tuq63Qd7ntQ0OzF5nAUrpXJmZnOkG9S68vyhvru+rEpuR1edhh8LWqvo5TmVRvlluG1SMyM/hLLo7m5nSbHruf04Vjv09FNVTuPzrG269ITtFOcoZmxqWtPRlbcMOgGKcJRp2j3ToM/UKeN1sbJH9V7qkMGPyy+lOXoLRThflnUtguqUtQFNomc9Oh3Cuv3ZKLNyOvi8UU9cNyb320TdcZqUC9L8DRgKfR/mUmxlTJ8UkHN60eBstyb++5JvVu6ePivQ2amseTtiHVq1mPWi5Tbw8DMH8gAyflQHP0Uoupz0k5XdcsDf0cGsUYvmr2NA5IeYnzSbomZOZ95/nbQ6oqe8PSUiVFt2FJLsn4qE15NDTPd9/1BqtjQtf4JcPAKVkl6r0xWikT7TcjbHtEX4EIESJE2CLYUAvdNA3xGY/MJDSzspbkrrUoqmhUedAP/dOFZhErzWm5JBfFqpt+uomZUxPYQua0CnjlxE0RCPNRJveXqY3LvYEPrZRYoDNfbOIuqsvboqVxQ7vBgPe6nIwu3SY0CUD1s0V8jWZ989x+um6u0RggOuFGfaH9VYd2Z/cxXKQyIeal0/xgVvqCBFDSzLXwalK+V7ahEmH3VUMrIbuL+QfkeeXRNv6UtidGeChbGbQ4Rd3BpIW6AYgtuvRcUFXLuWH6p+T10hGw06pUlpRnNzMulT6p4NAPfObvUVfBHRXiP5Q2VHcYGhqRGkxnyCqNsnCHx64fqWhWqcXV35b27HzepSoikLTHxeLv+9NXCR69B4DMlIOv9FngE+5U5o8bMj/X6NglN4wALez2Q5mE1JylsFulDHYa/FKophAhwrbFxk7obfDKBq/WDhMVTD/dJHVWVQBdh+xhSRJdbuTJXZF75h9pgmqLxGIBvobqV8eztJQZqA206LmgHHkn2Gimh2C3ep+8HjD+a/r/Sx49lzRxbNzQ965MUsURl5T6lmNh/m4NS2+5JM7IauE7UHlAKIieH8mkmJzyiWmuhcKhgPi8TK52yNBW+dr5Ey6ZMbmeviGaNCAqkPVulQJNm1ArpTJgCPYJTZE+IzeXDjbxb8pCNHK6zuIdMrm7dUMQU7pizsHXRaH6aImVQBao5BwURzsStpJYBKCwR+q09OtFgqvCd2durtFJ9s0cS/dqgudxn73PSL/NPBQPqaUd77VYOCb1ii955M6qwqUbsPigvLf7LaXBnrqfRpeUuXI7dFbF2IoJ5Qhiq4apx7zwc1s8Jvev9gd0XZbry7dD39uqrrliiK1anEjUI8I2R0S5RIgQIcIWwYZa6NYRWqTS71DRw8y+5+MsHVMLNRfgXRTHcseubcFNyeWrn/0FAN96/rOUezRvYGDC7Xhidi1cvHOIlpm2xJfFAly408MkNJpxxFDtV03uaw4zj4tp1/32WnfMH3do5KWcgecT1FUTq56HYElM0/x74q7RfcmhuEesaPP4KqWKuI4kfpoDzalp4wFFzWqfuRgL/cb7TsOSRrs6TULFwVbakn1NdcgH1VNnoMByIBWZIx5qjKfmLCsH1Ze/DYWDYn171uCpg8zAq6tc/ppY4DYZ0HNF2to5lAyuZ0Kf8ZnPgt8nbQtupMifUuGta3US4+Ipkzg8FEbVLhzzaKU7uVPBqo9923fxVTxt5U6x1FcPOaQntY3JdhgPEFuxrIrSA82eFmiyjfJALPSQ8QsuhcPqTTPjESvIaxNYCnvWDqYjRNiu2PgJPd3GtB26XhauZO6BNtnrGn4+54UTtDVQU9dGp2757thxqXDJkLopN5k2uLXORGIoKb3SmVC8qoOroedeGfx7hSopNDOYpioF9kLXOaEDKoOW4t4OEWtJaKCLdSyFA51sPobUDXnvjceFzog/uEjxvFAy9ko3QV555jk/fEYj1ya9TxMi9/hkx6WUaq9D73vKFy83Q1ooM+ZRfFAqH1TkGcGlPL0qJVDYb2lp6L1z3ZBSumL5aDt0VbTX02uh8rvTpCc77n8uSyJoR9eYTuhxqIoTDG7JwZmTyd94luIe7cNajMVjos2Su9ZiZX+H+4eaSh/Elhy8ckepkdCVMHNZKJnsjTYFDWqyqYDYLVXh6wGjQW5u2cFV/ZbV29phhqpdd8xQ/M5w+OxOTtOecwW8WpqJWqT4EWF7I6JcIkSIEGGLYEMtdLcOXWOG5GKbpcNqiY67+AWxrBbvD0hNSJWcptAbAEE2oLwi9EP6fSH8U0/Y8ACyfajEbYMSpHLhnd0AlHa1cQaFczDG0pwVi9pbcem/WxJWLL8yGB6mNYaamLKU7xcNux8VnfJLF0dwc0IZJN5K0ntOzN56t9IWkz3Yp5TbuJnAVZ95OQSWy7EVh0JOTGrPh+W7Ne1dwQvzqK7ui+EWVZ1xog1G2lzbobuQfJPSqKpHDtfp/2EsLGfxYMc334TJKXrOQ+9pOWReOdoTHoTWegzHHhdT/8KzIgZW3hWElv3ASZg9YcN62wOys6nNpcId0fIhL6R8EsvttdR0822WDkv7m9l2SCGVjjT0Woyc7gpM4IdtG3izHQYT5a6vaZtX+lzKGky09NcjtHVMlPa18Cq6U3qym67xNtaJ3FwibG9s6ITutEShcPbThp73lGf1CPVW/BWX6qBMOtlxh67rnWzQHhl1uUvPNlm4U10OZ+DYE5cAmZjGjdAEqU6Oil0Bjx2Q/7/wyl24rU5+UcvCKYmsdMxaYgV/wSd5S+/xYeFbIiLSnTB0uqo8YkMvjVhBFpbl23yCkvz/0YfPUW7JA6dLOSrPir5M8MQyibeEW3eakJyVNux4t87sA8LJ5661QaRSqPUYEvPSkJqeDdA2oWte16kEtx7VIKh0k+6fyeS/dLclf9qEfTv/QP7/+ByWj1gufF8m8k6SiPwZh/z5qna3wUj38GufO82LfyQZJqq9hEFDbY9QVbE86BLThag07NLUZ+Yum7W6mzU6rNPf9bwlOSfPW9nvhloyNx92yagkS/WRIq0bshBmrxsyM9LmyrGA1UOaWDjdIjXrfcAtNEKE7YjoKxAhQoQIWwQbaqG3ErB0xKUda9HMSNGFQy3ic3roF2sz8Lrcu3JQvFQAdpxrhx4VNx/xyEyon/mA4e1JSRqR+ZSJ+ZoAAA5GSURBVPQSq5PiAeJWZZ2yiYCfvijpsfwaxJfE6iser5Mak0PZlXsb2CnV5+5rktPDu/KQobRLKYhTa+nWvLIJfbeDhFIrLdj/bbHWX50/yv2PXZC6ju8gk9G2v9VDOyb17r5iKeyVOs7dGw8P/brGyiwdlTe0UobCPWKNJielTkHcpdktO5jcmINbULqp4ob+3vnXfYq7lXK5FHDzMaU0Xnao5XX9zjUwE7IrGHxDE1NcXaZ9VSim6pN3Y4xQJN+9cA/x3xDTubyQwlGawzQNu36k+U1HkgSa23XHjyco3Sc7m5mHXEygjWuvKWQW9snL5JyheLdQVcMDK1S+L9uC/tOWhTvlnmAyzYHvCG81d1+G5YNi3mdOEybyKO6B1YOEfvERImxXbDjlkpq19L5nqGs2oP7XXEwg38zlw4bCHvniD77RZGWfTGSVYRtSIc2uFtU+qXZtuElMtT1KsSQ2p8FC7U7mYRMKONX7A+rqxRGfiIceIm6iRV1Fu/L9BZaOCkXRNWbITsmbC7s9VlTvJTHrhRNHrV/K88oOc8c1EvLtgPdmxIXk6a+9xvdqDwDQTgb0v6xJNQYcGkeFl879LEl1h7Rt/B9kwujT3nNtCrd9MCL10LEbXLkpjZh/yOP44XHpt3qKyXND4b3VEXWVdD0GX1L3vyEnXDicRT8U35p9QCboQXow+yTENIgbzLi6YQYQaAhu1wpkbkqbC3scWmnNmOQa6jnpw7Hf3Udcg6x2nGmH7pS+erNYZ42qqeUt7ox05lwsS3BIkwqfM2GEa9e1KkFCPYW6DNkb0p5qr0Npz5qoWs9bcLOT9CZChG2KiHKJECFChC2CDbXQ27HO9tiEeit9Z1rUcmKy5c/bMICnOOqRntOM9IfBreo9Z1zqKvkau+WRndCHGygqFdIYEPphdHSR+AGxVqdfHKWeF4uuPtgircEylVsJjC5rxfJavsPSqCWId3zIIaV6L4lFy9I9Uq/Bl+SNzSQsPigURfEIGPXD/sFzJ9BscGTOezgtlSF4tcQs4nGTnWzg64HqwnFDMChRNM1rcfxlaU//IzcBuDw5iDsrlIPXhDOpnQA4jg39vVNzbfyX1SqurOnJ1ntt6MWy/ztlCvtli1LrlXsrfS5uvXNwuaZcuOPtdkgxxYoWvyJ9OPRyjYlfEcu97UGsoDEDTSiq5QxOqDfTNSa//apdo0p2OaSn5Y+VeprmoB54Dvkk5+SeufvSNJW2yl8McOtyf2nYIdAUhV1nYyzfbgl+SoQI2xobOqF7ZcvgyYCFox6uRv8tH/Coa47dwTfaGHVVmPl8wPCP5HX/SYPbkMlp/h6HkZ/LF//GF1xWD6iGSd2QFE9E4kvqZRLvJnVWqIP6YDvM9uOUvJB+yEw4FA/Is5uFOG4nH+lAg/w94vJ3Y66H7E+VUnlplpWHhZqY/YzQCLFll84bR//KZfGI1Hv3s4tMPy7qVK0k5K41wr4YOCm8cGl3kopSPm4VzLRmFfrSCukXZOWaGFBXEbuWNjM9DcEx4RhGu1eYy2ny5tU+Rn8s3Ha9N076PemU9FSOxWNyT70vQXlYyuwksc6/Z6lr4ujkYpvB1zRhdJ9LrNDRorcs3iFtNi2f/re031KG5IJq1tzlY9Paz80Yvrpthh4xQ07oqth/OggFwfwiNHVhrx+u0jiiLpHvpqgOSzlLuCQWVV8nAd6CunCmYNf/qnJrtbOQRIiwPRFRLhEiRIiwRbChFnozbZg54WKsxbqa0/OGpZnVpA5dLnOfEyvWWfGpDKjmR2pNnTAxL1YgQDsesFMP/ebu8ULLr3OA6swkwsz0bsMQ19ydQcyGXhmFO5qYmgbFjPvhzqEyFLBUkUIzbybJnxerd+5zg7RrmhBDvUz8ogFNpLGy35B9WPiC6Up/uBNodMHSEbG+Cwc8Rl7U6xlDfFVuuu3XL3NmegSA8pVugmOqcnhFpQkONhi+ZwaAKXeIxOtiwV9N9oQ0xtDJBtd+VRo98osW84/K86yB3rPShunPZmmoZZ6a7ljlTXpOiU7L4oMDLB6V6/1vt2ikpX+yU3Uw0obiLifsw56zq1z5J8qV0WZ0VHY2c9NDYSxBx3+9tDuQHQ2Qnqww8xn9gHbUaDfkujMXJzmjZd5o00rK9dSsDS19E4BXlWf2nm+xcGeK1sXIPomwvbGxckYGcCDw17iDRs6EKclWbgNnWSfrRJuGaqY7ATQPSdBLbdUnM67RpHXD1BPyXuu08Ffk295JV7fn3iluviBujY3dDewtmRhjK4bcdc0GlPTDQJdWylI5INfjV5M48+rdMdli9oTQFZVhS+yWcus71Mul5NGtGisLx9s0TkmuuUzZSiYdRGyrNqT67t0Nqr1C4Sw9XMdqdGrrLw6RUFnhet5iPZXh1UnMm/cp9+ui1NWiuUv59oUk6WFxLRzvzZKckWfcutcPF5TkLcvY00pGW0tOMyZVNS1eedDHrcqkHCu1iS9pXw641PLahlQifO00oDwon098JY2ryZt37VimA2MJOfTVO6RfTbyN0Wdf/a00Nq801FKM3NXOWUqd60/r5N7waOwRamlpn6XnJem30ReKtDIyVmp5X0XBiBBhWyP6CkSIECHCFsHGarnUIHdJQstLYjhTHmmHllVyT5HWZDa8v5N42Mk08a8K/TH0ThDqjKT2r2Jf1WTLJ1bJvCLvXTmkMrA/GsVRKsJZ9NlxRjVjjsHcvWLd+UUJ/wcwbbMWom4IvStqPS5NrZbTJAxX71jQ1Z0tjGq3do0Zyjs1M9DxNl6v7CzcixmSaoHWexJhxiJb8eg7KdfjhTare+V1a38NuxzTcjr1g8VxaW9mpEitqluLTJPmu3JQGzM2TPDRyBqGXhKL+epXuklPSb27rzZpxzr5UOXhqbkWtz6lB8jdluGXxXIu7PbJX9RDycOuaMwgXiadcP/lQzH6v6P5SP9pheWi7Gya+YD0lHy43rLuQroD6rqzoauJpxmYjCU8fF24K46vOjH5iw0qmrEpdjYVSiMX9qVDudzEckB61uCs5bOOEGFbYmPlc11odhmS822824UiyCUazM/IVj/7TJbhcZkAr38phbNXXCSadQ97WHiZlWImDDrxT3Uxd5/qhjzfFboFdlwinSYhh+6VDQ2dlHvftfScFp579e6+MAp19uE26UsywVgD8RV5XnnI0EqqJvlFcFrq/tit3Pu0R3G/XMvcMKzskIUoNufRt1/qbc4kWTyqE/pQC9NQumLOpdrXSavWDqNT79x5k5m/kZBKtyHPnj9uSE0pFZJJYjVq0604NPdJv2XfSIaufcEOw+RTsgB0X7L0npU+XzyWCReU7DVp18RTDjt/IvWu5l0W7pTFYvTZOa5+VXiZ+MpadObwN06y+LVPSd9WLV5ZMxktZ8n9XGiR4j5Yuku12ft0YbuRJqWUUHXACaN3vRp0XxHaZtkkwwxMxV0+3sVYeE9HG75r3IZ6+at7fdyGjSiXCNse0VcgQoQIEbYIjLUblxTAGDMPlIGFDSt0DTu2WbmbWfZmlbvbWtu30YVu8riG7fc5b2bZH+uxvaETOoAx5pS19r4NLXQblruZZW9mmzcL0ee8Pcr+uI/tiHKJECFChC2CaEKPECFChC2CzZjQ/2wTytyO5W5m2ZvZ5s1C9Dlvj7I/1mN7wzn0CBEiRIiwPogolwgRIkTYItiwCd0Y80VjzCVjzFVjzB+sYzmjxpifGWPOG2PeM8b8nl7PG2N+bIy5or971rEOrjHmbWPMc/r3XmPMSW37d4wxsXUos9sY84wx5qIx5oIx5sGNarMx5l9qX58zxvwPY0xiI9r8ccF2GdubMa61nE0Z25/Ecb0hE7oxxgX+K/D3gCPAPzLGHFmn4lrAv7bWHgFOAP9My/oD4CfW2oPAT/Tv9cLvARfe9/cfAf/ZWnsAWAa+tg5l/jHwN9baw8BdWv66t9kYMwL8c+A+a+1RwAV+i41p86Zjm43tzRjXsAlj+xM7rq216/4DPAj88H1/fx34+gaV/X3gC8AlYEivDQGX1qm8ncgAewx4DtGVXAC8v60vPqIyc8B19EzkfdfXvc3ACHADyCNSEs8BT653mz8uP9tlbG/GuNbnbsrY/qSO642iXDqd08GUXltXGGP2AMeBk8CAtXZG/zULDKxTsf8F+H2gkz6nF1ix1mq66nVp+15gHvjvuiX+b8aYNBvQZmvtNPCfgElgBlgFTrP+bf64YLuM7c0Y17BJY/uTOq637KGoMSYD/E/gX1hrC+//n5Xl9SN37zHG/H1gzlp7+qN+9i+BB9wD/Im19jgShv6BLeg6trkH+DLyxRsG0sAXP+pyIqxho8f2Jo5r2KSx/Ukd1xs1oU8Do+/7e6deWxcYY3xkwH/LWvs9vXzLGDOk/x8C5tah6E8DXzLGjAPfRranfwx0G2M6ypbr0fYpYMpae1L/fgb5EmxEmx8Hrltr5621TeB7SD+sd5s/LtgOY3uzxjVs3tj+RI7rjZrQ3wQO6glxDDlceHY9CjLGGODPgQvW2m+871/PAl/V119F+MePFNbar1trd1pr9yBt/Km19reBnwFPr1fZ1tpZ4IYx5ja99HngPBvQZmRLesIYk9K+75S9rm3+GGHLj+3NGtda9maN7U/muN4osh54CrgMjAF/uI7lfAbZfr0LvKM/TyGc30+AK8ALQH6d2/so8Jy+3ge8AVwFvgvE16G8u4FT2u6/Ano2qs3AvwcuAueAbwLxjWjzx+VnO43tjR7XWs6mjO1P4riOIkUjRIgQYYtgyx6KRogQIcJ2QzShR4gQIcIWQTShR4gQIcIWQTShR4gQIcIWQTShR4gQIcIWQTShR4gQIcIWQTShR4gQIcIWQTShR4gQIcIWwf8G6pQtqHouA6wAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.subplot(121)\n", + "fig.imshow(flux.mean)\n", + "fig2 = plt.subplot(122)\n", + "fig2.imshow(fission.mean)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's say we want to look at the distribution of relative errors of our tally bins for flux. First we create a new variable called ``relative_error`` and set it to the ratio of the standard deviation and the mean, being careful not to divide by zero in case some bins were never scored to." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Determine relative error\n", + "relative_error = np.zeros_like(flux.std_dev)\n", + "nonzero = flux.mean > 0\n", + "relative_error[nonzero] = flux.std_dev[nonzero] / flux.mean[nonzero]\n", + "\n", + "# distribution of relative errors\n", + "ret = plt.hist(relative_error[nonzero], bins=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Source Sites" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Source sites can be accessed from the ``source`` property. As shown below, the source sites are represented as a numpy array with a structured datatype." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([((-0.28690552, -0.23731283, 0.51447853), ( 0.02705364, -0.14292142, 0.98936422), 1780128.70101981, 1., 0, 0),\n", + " ((-0.28690552, -0.23731283, 0.51447853), (-0.16786951, 0.86432444, -0.47409186), 1553436.10501094, 1., 0, 0),\n", + " (( 0.17162994, 0.134092 , 0.42932363), ( 0.25199134, -0.11168216, 0.96126347), 829530.02360943, 1., 0, 0),\n", + " ...,\n", + " ((-0.24444068, -0.01351615, -0.41772172), ( 0.10437178, -0.86754673, 0.486281 ), 807617.55637656, 1., 0, 0),\n", + " ((-0.2146841 , 0.14307096, 0.07419328), ( 0.89645066, -0.35557279, -0.26446968), 6036005.44157462, 1., 0, 0),\n", + " ((-0.2146841 , 0.14307096, 0.07419328), (-0.95287644, -0.25857878, 0.15863005), 4923751.04163063, 1., 0, 0)],\n", + " dtype=[('r', [('x', '" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create log-spaced energy bins from 1 keV to 10 MeV\n", + "energy_bins = np.logspace(3,7)\n", + "\n", + "# Calculate pdf for source energies\n", + "probability, bin_edges = np.histogram(sp.source['E'], energy_bins, density=True)\n", + "\n", + "# Make sure integrating the PDF gives us unity\n", + "print(sum(probability*np.diff(energy_bins)))\n", + "\n", + "# Plot source energy PDF\n", + "plt.semilogx(energy_bins[:-1], probability*np.diff(energy_bins), drawstyle='steps')\n", + "plt.xlabel('Energy (eV)')\n", + "plt.ylabel('Probability/eV')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's also look at the spatial distribution of the sites. To make the plot a little more interesting, we can also include the direction of the particle emitted from the source and color each source by the logarithm of its energy." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 0.5)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.quiver(sp.source['r']['x'], sp.source['r']['y'],\n", + " sp.source['u']['x'], sp.source['u']['y'],\n", + " np.log(sp.source['E']), cmap='jet', scale=20.0)\n", + "plt.colorbar()\n", + "plt.xlim((-0.5,0.5))\n", + "plt.ylim((-0.5,0.5))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}