From 1475e25bf344ac397358c872c1d2e5d19d98dccc Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Sun, 30 Jun 2019 13:26:43 -0500
Subject: [PATCH 001/127] Add Universe subclass openmc.model.Pin

Designed to facilitate building universe that represent
pins, or concentric cylinders of materials. Can be built
by passing surfaces and materials, or radii and materials.
Places last material spanning region out to infinity from
the last surface.

Supports subdividing rings into equal volume slices of
unique [cloned] materials, useful for depletion.

Unit tests added for failure modes as well as basic operation
---
 openmc/model/__init__.py     |   1 +
 openmc/model/pin.py          | 249 +++++++++++++++++++++++++++++++++++
 tests/unit_tests/test_pin.py |  86 ++++++++++++
 3 files changed, 336 insertions(+)
 create mode 100644 openmc/model/pin.py
 create mode 100644 tests/unit_tests/test_pin.py

diff --git a/openmc/model/__init__.py b/openmc/model/__init__.py
index 9fa999dd4..8ec96845e 100644
--- a/openmc/model/__init__.py
+++ b/openmc/model/__init__.py
@@ -1,3 +1,4 @@
 from .triso import *
 from .model import *
 from .funcs import *
+from .pin import *
diff --git a/openmc/model/pin.py b/openmc/model/pin.py
new file mode 100644
index 000000000..0ec0c4dbd
--- /dev/null
+++ b/openmc/model/pin.py
@@ -0,0 +1,249 @@
+"""
+Helper class for building a pin from concentric cylinders
+"""
+
+
+from math import sqrt
+from numbers import Real
+from operator import attrgetter
+
+import openmc
+import openmc.checkvalue as cv
+from . import subdivide
+
+__all__ = ["Pin"]
+
+
+class Pin(openmc.Universe):
+    """Special universe used to model pins
+
+    Parameters
+    ----------
+    surfaces: iterable of :class:`openmc.Cylinder`
+        Cylinders used to define boundaries
+        between materials. All cylinders must be
+        concentric and of the same orientation, e.g.
+        all :class:`openmc.ZCylinders`
+    materials: iterable of :class:`openmc.Material`
+        Materials to go between ``surfaces``. There must be one
+        more material than surfaces, corresponding to the material
+        that spans all space outside the final ring.
+    universe_id: None or int
+        Unique identifier for this universe
+    name: str
+        Name for this universe
+
+    See Also
+    --------
+
+    :meth:`openmc.Pin.from_radii` - Convinience function to build
+    from radii of cylinders
+    """
+
+    def __init__(self, surfaces, materials, universe_id=None, name=""):
+        cv.check_iterable_type("materials", materials, openmc.Material)
+        cv.check_length("surfaces", surfaces, len(materials) - 1)
+
+        # Ensure that all surfaces are same type of cylinder
+        self._check_surfaces(surfaces)
+        regions = subdivide(surfaces)
+
+        cells = [
+            openmc.Cell(fill=m, region=r) for m, r in zip(materials, regions)
+        ]
+
+        super().__init__(universe_id=universe_id, name=name, cells=cells)
+        self._list_cells = cells  # need ordered by radial position
+
+    def _check_surfaces(self, surfaces):
+        cv.check_type(
+            "surface 0",
+            surfaces[0],
+            (openmc.ZCylinder, openmc.YCylinder, openmc.XCylinder),
+        )
+        if isinstance(surfaces[0], openmc.ZCylinder):
+            center_getter = attrgetter("x0", "y0")
+        elif isinstance(surfaces[0], openmc.YClylinder):
+            center_getter = attrgetter("x0", "y0")
+        elif isinstance(surfaces[0], openmc.XClylinder):
+            center_getter = attrgetter("z0", "y0")
+        else:
+            raise TypeError(
+                "Not configured to interpret {} surfaces".format(
+                    surfaces[0].__class__.__name__
+                )
+            )
+        cv.check_iterable_type("surfaces", surfaces[1:], type(surfaces[0]))
+        # Check for concentric-ness and increasing radii
+        centers = set()
+        radii = []
+        rad = 0
+        for ix, surf in enumerate(surfaces):
+            cur_rad = surf.r
+            if cur_rad <= rad:
+                raise ValueError(
+                    "Surfaces do not appear to be increasing in radius. "
+                    "Surface {} at index {} has radius {:7.3E} compared to "
+                    "previous radius of {:7.5E}".format(
+                        surf.id, ix, cur_rad, rad
+                    )
+                )
+            rad = cur_rad
+            radii.append(cur_rad)
+            centers.add(center_getter(surf))
+
+        if len(centers) > 1:
+            raise ValueError(
+                "Surfaces do not appear to be concentric. The following "
+                "centers were found: {}".format(centers)
+            )
+        self._radii = radii
+        self._surfaces = surfaces
+        self._surf_type = type(surfaces[0])
+
+    @classmethod
+    def from_radii(
+        cls,
+        radii,
+        materials,
+        universe_id=None,
+        name="",
+        orientation="z",
+        center=(0.0, 0.0),
+    ):
+        """Construct using radii of concentric cylinders and materials
+
+        Parameters
+        ----------
+        radii: iterable of float
+            Radii of the intended cylinders. Must be all positive
+            values and increasing
+        materials: iterable of :class:`openmc.Material`
+            Materials used to fill cylinders created by ``radii``,
+            starting from inside to the outside of the pin.
+            There must be one extra material corresponding to all
+            area outside the last ring
+        universe_id: None or int
+            Unique identifier to give this pin
+        name: str
+            Name of the created universe
+        orientation: {"x", "y", "z"}
+            Axis along which to orient the pin. Default is ``"z"``
+        center: iterable of float
+            Center of the pin in the plane perpendicular
+        """
+        cv.check_iterable_type("materials", materials, openmc.Material)
+        cv.check_length("radii", radii, len(materials) - 1)
+        for ix, rad in enumerate(radii):
+            if rad < 0:
+                raise ValueError(
+                    "Radius {:7.3E} at index {} is non-positive".format(
+                        rad, ix
+                    )
+                )
+            if ix and rad <= radii[ix - 1]:
+                raise ValueError(
+                    "Radii must be increasing values. Radius {:7.3E} at index "
+                    "{} is not greater than previous value of {:7.3E}".format(
+                        rad, ix, radii[ix - 1]
+                    )
+                )
+
+        if orientation == "z":
+            surfCls = openmc.ZCylinder
+            basis = ["x0", "y0"]
+        elif orientation == "y":
+            surfCls = openmc.YCylinder
+            basis = ["x0", "z0"]
+        elif orientation == "z":
+            surfCls = openmc.XCylinder
+            basis = ["y0", "z0"]
+        else:
+            raise ValueError(
+                "Orientation of {} not understood".format(orientation)
+            )
+
+        centerKwargs = dict(zip(basis, center))
+
+        surfaces = [surfCls(r=rad, **centerKwargs) for rad in radii]
+
+        return cls(surfaces, materials, universe_id=universe_id, name=name)
+
+    def subdivide_ring(self, ring_index, n_divs):
+        """Divide one ring of the pin into equal-area rings
+
+        Each new ring will be added to the model, and filled with
+        a unique material copied from the original.
+
+        Parameters
+        ring_index: int
+            Index of the ring to be divided where 0 is the innermost
+            ring. Will not divide the outermost region as there is no
+            upper bound
+        n_divs: int
+            Number of equal area divisions to make in this ring
+        """
+        # Don't allow subdivision of outer, infinite region
+        cv.check_less_than("ring_index", ring_index, len(self._radii))
+        cv.check_type("n_divs", n_divs, Real)
+        cv.check_greater_than("n_divs", n_divs, 1)
+
+        if ring_index < 0:
+            ring_index = len(self._list_cells) + ring_index
+
+        # Get all the information we need to replicate this
+        # region with unique insides
+        orig_cell = self._list_cells[ring_index]
+
+        lower_rad = self._radii[ring_index - 1] if ring_index else 0.0
+        area_term = (self._radii[ring_index] ** 2 - lower_rad ** 2) / n_divs
+
+        new_radii = []
+        new_surfaces = []
+        new_cells = []
+
+        # Adding N - 1 new regions
+        # N - 2 surfaces are made
+        # Original cell is not removed, but not occupies last ring
+
+        for i in range(n_divs - 1):
+            r = sqrt(area_term + lower_rad ** 2)
+            lower_rad = r
+            new_radii.append(r)
+            surf = self._surf_type(r=r)
+            new_surfaces.append(surf)
+            if i == 0:
+                if ring_index:
+                    region = (
+                        -surf & +self._surfaces[ring_index - 1]
+                    )
+                else:
+                    region = -surf
+            else:
+                region = -surf & +new_surfaces[-2]
+            new_cells.append(
+                openmc.Cell(region=region, fill=orig_cell.fill.clone())
+            )
+
+        orig_cell.region = -self._surfaces[ring_index] & +surf
+
+        self.add_cells(new_cells)
+
+        self._list_cells = (
+            self._list_cells[:ring_index]
+            + new_cells
+            + self._list_cells[ring_index:]
+        )
+        self._radii = (
+            self._radii[:ring_index] + new_radii + self._radii[ring_index:]
+        )
+        self._surfaces = (
+            self._surfaces[:ring_index]
+            + new_surfaces
+            + self._surfaces[ring_index:]
+        )
+
+    @property
+    def radii(self):
+        """Return a tuple of the radii in this :class:`Pin`"""
+        return tuple(self._radii)
diff --git a/tests/unit_tests/test_pin.py b/tests/unit_tests/test_pin.py
new file mode 100644
index 000000000..132e5f026
--- /dev/null
+++ b/tests/unit_tests/test_pin.py
@@ -0,0 +1,86 @@
+"""
+Tests for constructing Pin universes
+"""
+
+import numpy
+import pytest
+
+import openmc
+from openmc.model import Pin
+
+
+@pytest.fixture
+def pin_mats():
+    fuel = openmc.Material(name="UO2")
+    clad = openmc.Material(name="zirc")
+    water = openmc.Material(name="water")
+    return fuel, clad, water
+
+
+@pytest.fixture
+def good_radii():
+    return (0.4, 0.42)
+
+
+def test_failure(pin_mats, good_radii):
+    """Check for various failure modes"""
+    # Bad material type
+    with pytest.raises(TypeError):
+        Pin.from_radii(good_radii, [mat.name for mat in pin_mats])
+
+    # Incorrect lengths
+    with pytest.raises(ValueError) as exec_info:
+        Pin.from_radii(good_radii[: len(pin_mats) - 2], pin_mats)
+    assert "length" in str(exec_info)
+
+    # Non-positive radii
+    rad = (-0.1,) + good_radii[1:]
+    with pytest.raises(ValueError) as exec_info:
+        Pin.from_radii(rad, pin_mats)
+    assert "index 0" in str(exec_info)
+
+    # Non-increasing radii
+    rad = tuple(reversed(good_radii))
+    with pytest.raises(ValueError) as exec_info:
+        Pin.from_radii(rad, pin_mats)
+    assert "index 1" in str(exec_info)
+
+    # Bad orientation
+    with pytest.raises(ValueError) as exec_info:
+        Pin.from_radii(good_radii, pin_mats, orientation="fail")
+    assert "Orientation" in str(exec_info)
+
+
+def test_from_radii(pin_mats, good_radii):
+    name = "test pin"
+    p = Pin.from_radii(good_radii, pin_mats, name=name)
+    assert len(p.cells) == len(pin_mats)
+    assert p.name == name
+    assert p.radii == good_radii
+
+def test_subdivide(pin_mats, good_radii):
+    surfs = [openmc.ZCylinder(r=r) for r in good_radii]
+    pin = Pin(surfs, pin_mats)
+    assert pin.radii == good_radii
+    assert len(pin.cells) == len(pin_mats)
+
+    # subdivide inner region
+    N = 5
+    pin.subdivide_ring(0, N)
+    assert len(pin.radii) == len(good_radii) + N - 1
+    assert len(pin.cells) == len(pin_mats) + N - 1
+    # check volumes of new rings
+    bounds = (0,) + pin.radii[:N]
+    sqrs = numpy.square(bounds)
+    assert sqrs[1:] - sqrs[:-1] == pytest.approx(good_radii[0] ** 2 / N)
+
+    # subdivide non-inner most region
+    new_pin = Pin.from_radii(good_radii, pin_mats)
+    new_pin.subdivide_ring(1, N)
+    assert len(new_pin.radii) == len(good_radii) + N - 1
+    assert len(new_pin.cells) == len(pin_mats) + N - 1
+    # check volumes of new rings
+    bounds = new_pin.radii[:N + 1]
+    sqrs = numpy.square(bounds)
+    assert sqrs[1:] - sqrs[:-1] == pytest.approx((good_radii[1] ** 2 - good_radii[0] ** 2) / N)
+

From c44154b5f1ae0e89d3c48aba4bb5b22e4c8c67bf Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 1 Jul 2019 08:33:55 -0500
Subject: [PATCH 002/127] Tally helper for helping operator with tallies, q
 values

openmc.deplete.tally_helers.ChainFissTallyHelper is responsible
for populating the fission_q vector, building the reaction rate
tallies, and updating the energy produced by fission per material.

This abstraction will be helpful as more methods for pulling
fission q values are introduced, namely as issue #1238, indirect
energy release, gets resolved
---
 openmc/deplete/operator.py      | 49 ++++++++++----------------------
 openmc/deplete/tally_helpers.py | 50 +++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 34 deletions(-)
 create mode 100644 openmc/deplete/tally_helpers.py

diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index ffbffbc73..3976fe7c9 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -24,6 +24,7 @@ from . import comm
 from .abc import TransportOperator, OperatorResult
 from .atom_number import AtomNumber
 from .reaction_rates import ReactionRates
+from .tally_helpers import ChainFissTallyHelper
 
 
 def _distribute(items):
@@ -152,6 +153,10 @@ class Operator(TransportOperator):
         self.reaction_rates = ReactionRates(
             self.local_mats, self._burnable_nucs, self.chain.reactions)
 
+        # Get class to assist working with tallies
+        self._tally_helper = ChainFissTallyHelper(len(self.local_mats))
+
+
     def __call__(self, vec, power, print_out=True):
         """Runs a simulation.
 
@@ -180,7 +185,7 @@ class Operator(TransportOperator):
 
         # Update material compositions and tally nuclides
         self._update_materials()
-        self._tally.nuclides = self._get_tally_nuclides()
+        self._tally_helper.reaction_tally.nuclides = self._get_tally_nuclides()
 
         # Run OpenMC
         openmc.capi.reset()
@@ -373,7 +378,9 @@ class Operator(TransportOperator):
         openmc.capi.init(intracomm=comm)
 
         # Generate tallies in memory
-        self._generate_tallies()
+        materials = [openmc.capi.materials[int(i)]
+                     for i in self.burnable_mats]
+        self._tally_helper.generate_tallies(materials, self.chain.reactions)
 
         # Return number density vector
         return list(self.number.get_mat_slice(np.s_[:]))
@@ -482,27 +489,6 @@ class Operator(TransportOperator):
         nuc_list = comm.bcast(nuc_list)
         return [nuc for nuc in nuc_list if nuc in self.chain]
 
-    def _generate_tallies(self):
-        """Generates depletion tallies.
-
-        Using information from the depletion chain as well as the nuclides
-        currently in the problem, this function automatically generates a
-        tally.xml for the simulation.
-
-        """
-        # Create tallies for depleting regions
-        materials = [openmc.capi.materials[int(i)]
-                     for i in self.burnable_mats]
-        mat_filter = openmc.capi.MaterialFilter(materials)
-
-        # Set up a tally that has a material filter covering each depletable
-        # material and scores corresponding to all reactions that cause
-        # transmutation. The nuclides for the tally are set later when eval() is
-        # called.
-        self._tally = openmc.capi.Tally()
-        self._tally.scores = self.chain.reactions
-        self._tally.filters = [mat_filter]
-
     def _unpack_tallies_and_normalize(self, power):
         """Unpack tallies from OpenMC and return an operator result
 
@@ -529,7 +515,7 @@ class Operator(TransportOperator):
 
         # Extract tally bins
         materials = self.burnable_mats
-        nuclides = self._tally.nuclides
+        nuclides = self._tally_helper.reaction_tally.nuclides
 
         # Form fast map
         nuc_ind = [rates.index_nuc[nuc] for nuc in nuclides]
@@ -544,19 +530,14 @@ class Operator(TransportOperator):
 
         # Create arrays to store fission Q values, reaction rates, and nuclide
         # numbers
-        fission_Q = np.zeros(rates.n_nuc)
         rates_expanded = np.zeros((rates.n_nuc, rates.n_react))
         number = np.zeros(rates.n_nuc)
 
         fission_ind = rates.index_rx["fission"]
 
-        for nuclide in self.chain.nuclides:
-            if nuclide.name in rates.index_nuc:
-                for rx in nuclide.reactions:
-                    if rx.type == 'fission':
-                        ind = rates.index_nuc[nuclide.name]
-                        fission_Q[ind] = rx.Q
-                        break
+        self._tally_helper.set_fission_q(self.chain.nuclides, rates.index_nuc)
+
+        tally_results = self._tally_helper.reaction_tally.results
 
         # Extract results
         for i, mat in enumerate(self.local_mats):
@@ -564,7 +545,7 @@ class Operator(TransportOperator):
             slab = materials.index(mat)
 
             # Get material results hyperslab
-            results = self._tally.results[slab, :, 1]
+            results = tally_results[slab, :, 1]
 
             # Zero out reaction rates and nuclide numbers
             rates_expanded[:] = 0.0
@@ -579,7 +560,7 @@ class Operator(TransportOperator):
                     j += 1
 
             # Accumulate energy from fission
-            energy += np.dot(rates_expanded[:, fission_ind], fission_Q)
+            energy += self._tally_helper.get_fiss_energy(rates_expanded[:, fission_ind], i)
 
             # Divide by total number and store
             for i_nuc_results in nuc_ind:
diff --git a/openmc/deplete/tally_helpers.py b/openmc/deplete/tally_helpers.py
new file mode 100644
index 000000000..47c78ba8e
--- /dev/null
+++ b/openmc/deplete/tally_helpers.py
@@ -0,0 +1,50 @@
+"""
+Class for normalizing fission energy deposition
+"""
+
+from numpy import dot, zeros
+
+from openmc.capi import Tally, MaterialFilter
+
+
+class ChainFissTallyHelper(object):
+    """Fission Q-values are pulled from chain"""
+
+    def __init__(self, n_materials):
+        self._fiss_q = None
+        self.n_materials = n_materials
+        self._rx_tally = None
+
+    def set_fission_q(self, chain_nucs, rate_index):
+        if (self._fiss_q is not None
+                and self._fiss_q.shape == (len(rate_index), )):
+            return
+
+        fq = zeros(len(rate_index))
+
+        for nuclide in chain_nucs:
+            if nuclide.name in rate_index:
+                for rx in nuclide.reactions:
+                    if rx.type == "fission":
+                        fq[rate_index[nuclide.name]] = rx.Q
+                        break
+
+        self._fiss_q = fq
+
+    @property
+    def reaction_tally(self):
+        if self._rx_tally is None:
+            raise AttributeError(
+                "Reaction tally for {} not set.".format(
+                    self.__class__.__name__
+                )
+            )
+        return self._rx_tally
+
+    def generate_tallies(self, materials, scores):
+        self._rx_tally = Tally()
+        self._rx_tally.scores = scores
+        self._rx_tally.filters = [MaterialFilter(materials)]
+
+    def get_fiss_energy(self, fiss_rates, _mat_index):
+        return dot(fiss_rates, self._fiss_q)

From 888086ac297d46e244b9b61d3e01c7de33bf6803 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 1 Jul 2019 09:22:01 -0500
Subject: [PATCH 003/127] Add base class for TallyHelpers

Interface is designed such that one could make a tally
helper work with unique materials, mainly for pulling
fission Q values on a per material basis
---
 openmc/deplete/operator.py      |  9 +--
 openmc/deplete/tally_helpers.py | 98 ++++++++++++++++++++++++++-------
 2 files changed, 84 insertions(+), 23 deletions(-)

diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index 3976fe7c9..9d3f6035e 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -154,7 +154,7 @@ class Operator(TransportOperator):
             self.local_mats, self._burnable_nucs, self.chain.reactions)
 
         # Get class to assist working with tallies
-        self._tally_helper = ChainFissTallyHelper(len(self.local_mats))
+        self._tally_helper = ChainFissTallyHelper()
 
 
     def __call__(self, vec, power, print_out=True):
@@ -185,7 +185,7 @@ class Operator(TransportOperator):
 
         # Update material compositions and tally nuclides
         self._update_materials()
-        self._tally_helper.reaction_tally.nuclides = self._get_tally_nuclides()
+        self._tally_helper.nuclides = self._get_tally_nuclides()
 
         # Run OpenMC
         openmc.capi.reset()
@@ -515,7 +515,7 @@ class Operator(TransportOperator):
 
         # Extract tally bins
         materials = self.burnable_mats
-        nuclides = self._tally_helper.reaction_tally.nuclides
+        nuclides = self._tally_helper.nuclides
 
         # Form fast map
         nuc_ind = [rates.index_nuc[nuc] for nuc in nuclides]
@@ -560,7 +560,8 @@ class Operator(TransportOperator):
                     j += 1
 
             # Accumulate energy from fission
-            energy += self._tally_helper.get_fiss_energy(rates_expanded[:, fission_ind], i)
+            energy += self._tally_helper.get_fission_energy(
+                rates_expanded[:, fission_ind], i)
 
             # Divide by total number and store
             for i_nuc_results in nuc_ind:
diff --git a/openmc/deplete/tally_helpers.py b/openmc/deplete/tally_helpers.py
index 47c78ba8e..d61bfb90b 100644
--- a/openmc/deplete/tally_helpers.py
+++ b/openmc/deplete/tally_helpers.py
@@ -1,35 +1,26 @@
 """
 Class for normalizing fission energy deposition
 """
+from abc import ABC, abstractmethod
 
 from numpy import dot, zeros
 
+from openmc.checkvalue import check_type
 from openmc.capi import Tally, MaterialFilter
 
 
-class ChainFissTallyHelper(object):
-    """Fission Q-values are pulled from chain"""
+class TallyHelperBase(ABC):
+    """Base class for working with tallies for depletion"""
 
-    def __init__(self, n_materials):
+    def __init__(self):
         self._fiss_q = None
-        self.n_materials = n_materials
         self._rx_tally = None
+        self._nuclides = []
 
+    @abstractmethod
     def set_fission_q(self, chain_nucs, rate_index):
-        if (self._fiss_q is not None
-                and self._fiss_q.shape == (len(rate_index), )):
-            return
-
-        fq = zeros(len(rate_index))
-
-        for nuclide in chain_nucs:
-            if nuclide.name in rate_index:
-                for rx in nuclide.reactions:
-                    if rx.type == "fission":
-                        fq[rate_index[nuclide.name]] = rx.Q
-                        break
-
-        self._fiss_q = fq
+        """Populate the energy released per fission Q value array"""
+        pass
 
     @property
     def reaction_tally(self):
@@ -46,5 +37,74 @@ class ChainFissTallyHelper(object):
         self._rx_tally.scores = scores
         self._rx_tally.filters = [MaterialFilter(materials)]
 
-    def get_fiss_energy(self, fiss_rates, _mat_index):
+    @property
+    def nuclides(self):
+        """List of nuclides with requested reaction rates"""
+        return self._nuclides
+
+    @nuclides.setter
+    def nuclides(self, nuclides):
+        check_type("nuclides", nuclides, list, str)
+        self._nuclides = nuclides
+        self._rx_tally.nuclides = nuclides
+
+    @abstractmethod
+    def get_fission_energy(self, fission_rates, mat_index):
+        """return a vector of the isotopic fission energy for this material
+
+        parameters
+        ----------
+        fission_rates: numpy.ndarray
+            fission reaction rate for each isotope in the specified
+            material. should be ordered corresponding to initial
+            ``rate_index`` used in :meth:`set_fission_q`
+        mat_index: int
+            index for the material requested.
+        """
+
+
+class ChainFissTallyHelper(TallyHelperBase):
+    """Fission Q-values are pulled from chain"""
+
+    def set_fission_q(self, chain_nucs, rate_index):
+        """Populate the fission Q value vector from a chain.
+
+        Paramters
+        ---------
+        chain_nucs: iterable of :class:`openmc.deplete.Nuclide`
+            Nuclides used in this depletion chain. Do not need
+            to be ordered
+        rate_index: dict of str to int
+            Dictionary mapping names of nuclides, e.g. ``"U235"``,
+            to a corresponding index in the desired fission Q
+            vector.
+        """
+        if (self._fiss_q is not None
+                and self._fiss_q.shape == (len(rate_index), )):
+            return
+
+        fq = zeros(len(rate_index))
+
+        for nuclide in chain_nucs:
+            if nuclide.name in rate_index:
+                for rx in nuclide.reactions:
+                    if rx.type == "fission":
+                        fq[rate_index[nuclide.name]] = rx.Q
+                        break
+
+        self._fiss_q = fq
+
+    def get_fission_energy(self, fiss_rates, _mat_index):
+        """Return a vector of the isotopic fission energy for this material
+
+        parameters
+        ----------
+        fission_rates: numpy.ndarray
+            fission reaction rate for each isotope in the specified
+            material. should be ordered corresponding to initial
+            ``rate_index`` used in :meth:`set_fission_q`
+        mat_index: int
+            index for the material requested. Unused, as all
+            isotopes in all materials have the same Q value.
+        """
         return dot(fiss_rates, self._fiss_q)

From e67abde6228feaa231b2b3bfc97d6ca1f2cf8276 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 1 Jul 2019 08:10:27 -0500
Subject: [PATCH 004/127] Use match argument in calls to pytest.raises when
 testing pin

---
 tests/unit_tests/test_pin.py | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/tests/unit_tests/test_pin.py b/tests/unit_tests/test_pin.py
index 132e5f026..0940c5e30 100644
--- a/tests/unit_tests/test_pin.py
+++ b/tests/unit_tests/test_pin.py
@@ -29,26 +29,22 @@ def test_failure(pin_mats, good_radii):
         Pin.from_radii(good_radii, [mat.name for mat in pin_mats])
 
     # Incorrect lengths
-    with pytest.raises(ValueError) as exec_info:
+    with pytest.raises(ValueError, match="length") as exec_info:
         Pin.from_radii(good_radii[: len(pin_mats) - 2], pin_mats)
-    assert "length" in str(exec_info)
 
     # Non-positive radii
     rad = (-0.1,) + good_radii[1:]
-    with pytest.raises(ValueError) as exec_info:
+    with pytest.raises(ValueError, match="index 0") as exec_info:
         Pin.from_radii(rad, pin_mats)
-    assert "index 0" in str(exec_info)
 
     # Non-increasing radii
     rad = tuple(reversed(good_radii))
-    with pytest.raises(ValueError) as exec_info:
+    with pytest.raises(ValueError, match="index 1") as exec_info:
         Pin.from_radii(rad, pin_mats)
-    assert "index 1" in str(exec_info)
 
     # Bad orientation
-    with pytest.raises(ValueError) as exec_info:
+    with pytest.raises(ValueError, match="Orientation") as exec_info:
         Pin.from_radii(good_radii, pin_mats, orientation="fail")
-    assert "Orientation" in str(exec_info)
 
 
 def test_from_radii(pin_mats, good_radii):
@@ -58,6 +54,7 @@ def test_from_radii(pin_mats, good_radii):
     assert p.name == name
     assert p.radii == good_radii
 
+
 def test_subdivide(pin_mats, good_radii):
     surfs = [openmc.ZCylinder(r=r) for r in good_radii]
     pin = Pin(surfs, pin_mats)
@@ -82,5 +79,5 @@ def test_subdivide(pin_mats, good_radii):
     # check volumes of new rings
     bounds = new_pin.radii[:N + 1]
     sqrs = numpy.square(bounds)
-    assert sqrs[1:] - sqrs[:-1] == pytest.approx((good_radii[1] ** 2 - good_radii[0] ** 2) / N)
-
+    assert sqrs[1:] - sqrs[:-1] == pytest.approx(
+        (good_radii[1] ** 2 - good_radii[0] ** 2) / N)

From e70c5d539f33f48049d8af1ef1e303e34cf41a10 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 5 Jul 2019 13:09:30 -0500
Subject: [PATCH 005/127] Refactor tally_helpers to Rates and Energy Helpers

The TallyHelperBase class has been split into two
abstract classes: ReactionRateHelper and FissionEnergyHelper.
The former is responsible for creating reaction rates
for all materials, given nuclides with non-zero densities from
the Operator.
The latter is responsible for producing recoverable fission
energy for each nuclide in each material tracked.

Two concrete classes are included to make the Operator functional.
These can be imported from openmc/deplete/helpers.py.
First, the DirectRxnRateHelper preserves the old mode for
directly tallying one-group reaction rates using the OpenMC C API.
The second, ChainFissHelper, generates the fission energy
vector from the chain data from before.
---
 openmc/deplete/abc.py           | 117 +++++++++++++++++++++++++++++++-
 openmc/deplete/helpers.py       | 117 ++++++++++++++++++++++++++++++++
 openmc/deplete/tally_helpers.py | 110 ------------------------------
 3 files changed, 232 insertions(+), 112 deletions(-)
 create mode 100644 openmc/deplete/helpers.py
 delete mode 100644 openmc/deplete/tally_helpers.py

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index 1be3e27ff..4a332af59 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -7,11 +7,14 @@ to run a full depletion simulation.
 from collections import namedtuple
 import os
 from pathlib import Path
-from abc import ABCMeta, abstractmethod
+from abc import ABC, abstractmethod
 from xml.etree import ElementTree as ET
 from warnings import warn
 
+from numpy import zeros, nonzero
+
 from openmc.data import DataLibrary
+from openmc.checkvalue import check_type
 from .chain import Chain
 
 OperatorResult = namedtuple('OperatorResult', ['k', 'rates'])
@@ -34,7 +37,7 @@ except AttributeError:
     pass
 
 
-class TransportOperator(metaclass=ABCMeta):
+class TransportOperator(ABC):
     """Abstract class defining a transport operator
 
     Each depletion integrator is written to work with a generic transport
@@ -160,3 +163,113 @@ class TransportOperator(metaclass=ABCMeta):
 
     def finalize(self):
         pass
+
+
+class ReactionRateHelper(ABC):
+    """Abstract class for generating reaction rates for operators
+
+    Responsible for generating reaction rate tallies for burnable
+    materials, given nuclides and scores from the operator.
+
+    Reaction rates are passed back to the operator for be used in
+    an :class:`openmc.deplete.OperatorResult` instance
+    """
+
+    def __init__(self):
+        self._nuclides = None
+        self._rate_tally = None
+        self._results_cache = None
+
+    @abstractmethod
+    def generate_tallies(self, materials, scores):
+        """Use the capi to build tallies needed for reaction rates"""
+        pass
+
+    @property
+    def nuclides(self):
+        """List of nuclides with requested reaction rates"""
+        return self._nuclides
+
+    @nuclides.setter
+    def nuclides(self, nuclides):
+        check_type("nuclides", nuclides, list, str)
+        self._nuclides = nuclides
+        self._rate_tally.nuclides = nuclides
+
+    def _reset_results_cache(self, nnucs, nreact):
+        """Cache for results for a given material"""
+        if self._results_cache is None or self._results_cache.shape != (nnucs, nreact):
+            self._results_cache = zeros((nnucs, nreact))
+        else:
+            self._results_cache.fill(0.0)
+        return self._results_cache
+
+    @abstractmethod
+    def get_material_rates(self, mat_id, nuc_index, react_index):
+        """Return 2D array of [nuclide, reaction] reaction rates
+
+        ``nuc_index`` and ``react_index`` are orderings of nuclides
+        and reactions such that the ordering is consistent between
+        reaction tallies and energy deposition tallies"""
+        pass
+
+    def divide_by_adens(self, number):
+        """Normalize reaction rates by number of nuclides
+
+        Acts on the current material examined by
+        :meth:`get_material_rates`
+
+        Parameters
+        ----------
+        number : iterable of float
+            Number density [#/b/cm] of each nuclide tracked in the calculation.
+            Ordered identically to :attr:`nuclides`
+
+        Returns
+        -------
+        results : :class:`numpy.ndarray`
+            2D array ``[n_nuclides, n_rxns]`` of reaction rates normalized by
+            the number of nuclides
+        """
+
+        mask = nonzero(number)
+        results = self._results_cache
+        for col in range(results.shape[1]):
+            results[mask, col] /= number[mask]
+        return results
+
+
+class FissionEnergyHelper(ABC):
+    """Abstract class for normalizing fission reactions to a given level
+    """
+
+    def __init__(self):
+        self._nuclides = None
+        self._fission_E = None
+
+    @abstractmethod
+    def prepare(self, chain_nucs, rate_index, materials):
+        """Perform work needed to obtain fission energy per material
+
+        ``chain_nucs`` is all nuclides tracked in the depletion chain,
+        while ``rate_index`` should be a mapping from nuclide name
+        to index in the reaction rate vector used in
+        :meth:`get_fission_energy`.
+        ``materials`` should be a list of all materials tracked
+        on the operator to which this object is attached"""
+        pass
+
+    @abstractmethod
+    def get_fission_energy(self, fission_rates, mat_index):
+        """Return fission energy in this material given fission rates"""
+        pass
+
+    @property
+    def nuclides(self):
+        """List of nuclides with requested reaction rates"""
+        return self._nuclides
+
+    @nuclides.setter
+    def nuclides(self, nuclides):
+        check_type("nuclides", nuclides, list, str)
+        self._nuclides = nuclides
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
new file mode 100644
index 000000000..4b79d5b3d
--- /dev/null
+++ b/openmc/deplete/helpers.py
@@ -0,0 +1,117 @@
+"""
+Class for normalizing fission energy deposition
+"""
+from itertools import product
+
+from numpy import dot, zeros
+
+from openmc.capi import Tally, MaterialFilter
+from .abc import ReactionRateHelper, FissionEnergyHelper
+
+# -------------------------------------
+# Helpers for generating reaction rates
+# -------------------------------------
+
+
+class DirectRxnRateHelper(ReactionRateHelper):
+    """Class that generates tallies for one-group rates"""
+
+    def generate_tallies(self, materials, scores):
+        """Produce one-group reaction rate tally
+
+        Uses the :mod:`openmc.capi` to generate a tally
+        of relevant reactions across all burnable materials.
+
+        Parameters
+        ----------
+        materials : iterable of :class:`openmc.Material`
+            Burnable materials in the problem. Used to
+            construct a :class:`openmc.MaterialFilter`
+        scores : iterable of str
+            Reaction identifiers, e.g. ``"(n, fission)"``,
+            ``"(n, gamma)"``, needed for the reaction rate tally.
+        """
+        self._rate_tally = Tally()
+        self._rate_tally.scores = scores
+        self._rate_tally.filters = [MaterialFilter(materials)]
+
+    def get_material_rates(self, mat_id, nuc_index, react_index):
+        """Return an array of reaction rates for a material
+
+        Parameters
+        ----------
+        mat_id : int
+            Unique id for the requested material
+        nuc_index : iterable of int
+            Index for each nuclide in :attr:`nuclides` in the
+            desired reaction rate matrix
+        react_index : iterable of int
+            Index for each reaction scored in the tally
+
+        Returns
+        -------
+        rates : :class:`numpy.ndarray`
+            2D matrix ``(len(nuc_index), len(react_index))`` with the
+            reaction rates in this material
+        """
+        results = self._reset_results_cache(len(nuc_index), len(react_index))
+        full_tally_res = self._rate_tally.results[mat_id, :, 1]
+        for i_tally, (i_nuc, i_react) in enumerate(
+                product(nuc_index, react_index)):
+            results[i_nuc, i_react] = full_tally_res[i_tally]
+
+        return results
+
+
+# ------------------------------------
+# Helpers for obtaining fission energy
+# ------------------------------------
+
+
+class ChainFissHelper(FissionEnergyHelper):
+    """Fission Q-values are pulled from chain"""
+
+    def prepare(self, chain_nucs, rate_index, _materials):
+        """Populate the fission Q value vector from a chain.
+
+        Paramters
+        ---------
+        chain_nucs : iterable of :class:`openmc.deplete.Nuclide`
+            Nuclides used in this depletion chain. Do not need
+            to be ordered
+        rate_index : dict of str to int
+            Dictionary mapping names of nuclides, e.g. ``"U235"``,
+            to a corresponding index in the desired fission Q
+            vector.
+        _materials : list of str
+            Unused. Materials to be tracked for this helper.
+        """
+        if (self._fission_E is not None
+                and self._fission_E.shape == (len(rate_index),)):
+            return
+
+        fiss_E = zeros(len(rate_index))
+
+        for nuclide in chain_nucs:
+            if nuclide.name in rate_index:
+                for rx in nuclide.reactions:
+                    if rx.type == "fission":
+                        fiss_E[rate_index[nuclide.name]] = rx.Q
+                        break
+
+        self._fission_E = fiss_E
+
+    def get_fission_energy(self, fiss_rates, _mat_index):
+        """Return a vector of the isotopic fission energy for this material
+
+        parameters
+        ----------
+        fission_rates : numpy.ndarray
+            fission reaction rate for each isotope in the specified
+            material. should be ordered corresponding to initial
+            ``rate_index`` used in :meth:`set_fission_q`
+        _mat_index : int
+            index for the material requested. Unused, as all
+            isotopes in all materials have the same Q value.
+        """
+        return dot(fiss_rates, self._fission_E)
diff --git a/openmc/deplete/tally_helpers.py b/openmc/deplete/tally_helpers.py
deleted file mode 100644
index d61bfb90b..000000000
--- a/openmc/deplete/tally_helpers.py
+++ /dev/null
@@ -1,110 +0,0 @@
-"""
-Class for normalizing fission energy deposition
-"""
-from abc import ABC, abstractmethod
-
-from numpy import dot, zeros
-
-from openmc.checkvalue import check_type
-from openmc.capi import Tally, MaterialFilter
-
-
-class TallyHelperBase(ABC):
-    """Base class for working with tallies for depletion"""
-
-    def __init__(self):
-        self._fiss_q = None
-        self._rx_tally = None
-        self._nuclides = []
-
-    @abstractmethod
-    def set_fission_q(self, chain_nucs, rate_index):
-        """Populate the energy released per fission Q value array"""
-        pass
-
-    @property
-    def reaction_tally(self):
-        if self._rx_tally is None:
-            raise AttributeError(
-                "Reaction tally for {} not set.".format(
-                    self.__class__.__name__
-                )
-            )
-        return self._rx_tally
-
-    def generate_tallies(self, materials, scores):
-        self._rx_tally = Tally()
-        self._rx_tally.scores = scores
-        self._rx_tally.filters = [MaterialFilter(materials)]
-
-    @property
-    def nuclides(self):
-        """List of nuclides with requested reaction rates"""
-        return self._nuclides
-
-    @nuclides.setter
-    def nuclides(self, nuclides):
-        check_type("nuclides", nuclides, list, str)
-        self._nuclides = nuclides
-        self._rx_tally.nuclides = nuclides
-
-    @abstractmethod
-    def get_fission_energy(self, fission_rates, mat_index):
-        """return a vector of the isotopic fission energy for this material
-
-        parameters
-        ----------
-        fission_rates: numpy.ndarray
-            fission reaction rate for each isotope in the specified
-            material. should be ordered corresponding to initial
-            ``rate_index`` used in :meth:`set_fission_q`
-        mat_index: int
-            index for the material requested.
-        """
-
-
-class ChainFissTallyHelper(TallyHelperBase):
-    """Fission Q-values are pulled from chain"""
-
-    def set_fission_q(self, chain_nucs, rate_index):
-        """Populate the fission Q value vector from a chain.
-
-        Paramters
-        ---------
-        chain_nucs: iterable of :class:`openmc.deplete.Nuclide`
-            Nuclides used in this depletion chain. Do not need
-            to be ordered
-        rate_index: dict of str to int
-            Dictionary mapping names of nuclides, e.g. ``"U235"``,
-            to a corresponding index in the desired fission Q
-            vector.
-        """
-        if (self._fiss_q is not None
-                and self._fiss_q.shape == (len(rate_index), )):
-            return
-
-        fq = zeros(len(rate_index))
-
-        for nuclide in chain_nucs:
-            if nuclide.name in rate_index:
-                for rx in nuclide.reactions:
-                    if rx.type == "fission":
-                        fq[rate_index[nuclide.name]] = rx.Q
-                        break
-
-        self._fiss_q = fq
-
-    def get_fission_energy(self, fiss_rates, _mat_index):
-        """Return a vector of the isotopic fission energy for this material
-
-        parameters
-        ----------
-        fission_rates: numpy.ndarray
-            fission reaction rate for each isotope in the specified
-            material. should be ordered corresponding to initial
-            ``rate_index`` used in :meth:`set_fission_q`
-        mat_index: int
-            index for the material requested. Unused, as all
-            isotopes in all materials have the same Q value.
-        """
-        return dot(fiss_rates, self._fiss_q)

From 4832708ad79cc7c9dc7e5a40e893dc6ae54ed071 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 5 Jul 2019 13:28:32 -0500
Subject: [PATCH 006/127] Apply new reaction rate, fission energy helpers to
 Operator

rate_helper responsible for passing reaction rates
onto the operator, while energy_helper is responsible
for computing the actual fission energy produced in each
material
---
 openmc/deplete/abc.py      |  3 ++-
 openmc/deplete/operator.py | 47 +++++++++++++++-----------------------
 2 files changed, 20 insertions(+), 30 deletions(-)

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index 4a332af59..13be50812 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -198,7 +198,8 @@ class ReactionRateHelper(ABC):
 
     def _reset_results_cache(self, nnucs, nreact):
         """Cache for results for a given material"""
-        if self._results_cache is None or self._results_cache.shape != (nnucs, nreact):
+        if (self._results_cache is None
+                or self._results_cache.shape != (nnucs, nreact)):
             self._results_cache = zeros((nnucs, nreact))
         else:
             self._results_cache.fill(0.0)
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index f31978908..fab2a9f48 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -24,7 +24,7 @@ from . import comm
 from .abc import TransportOperator, OperatorResult
 from .atom_number import AtomNumber
 from .reaction_rates import ReactionRates
-from .tally_helpers import ChainFissTallyHelper
+from .helpers import DirectRxnRateHelper, ChainFissHelper
 
 
 def _distribute(items):
@@ -154,7 +154,8 @@ class Operator(TransportOperator):
             self.local_mats, self._burnable_nucs, self.chain.reactions)
 
         # Get class to assist working with tallies
-        self._tally_helper = ChainFissTallyHelper()
+        self._rate_helper = DirectRxnRateHelper()
+        self._energy_helper = ChainFissHelper()
 
 
     def __call__(self, vec, power, print_out=True):
@@ -185,7 +186,8 @@ class Operator(TransportOperator):
 
         # Update material compositions and tally nuclides
         self._update_materials()
-        self._tally_helper.nuclides = self._get_tally_nuclides()
+        self._rate_helper.nuclides = self._get_tally_nuclides()
+        self._energy_helper.nuclides = self._rate_helper.nuclides
 
         # Run OpenMC
         openmc.capi.reset()
@@ -380,7 +382,9 @@ class Operator(TransportOperator):
         # Generate tallies in memory
         materials = [openmc.capi.materials[int(i)]
                      for i in self.burnable_mats]
-        self._tally_helper.generate_tallies(materials, self.chain.reactions)
+        self._rate_helper.generate_tallies(materials, self.chain.reactions)
+        self._energy_helper.prepare(
+            self.chain.nuclides, self.reaction_rates.index_nuc, materials)
 
         # Return number density vector
         return list(self.number.get_mat_slice(np.s_[:]))
@@ -516,7 +520,7 @@ class Operator(TransportOperator):
 
         # Extract tally bins
         materials = self.burnable_mats
-        nuclides = self._tally_helper.nuclides
+        nuclides = self._rate_helper.nuclides
 
         # Form fast map
         nuc_ind = [rates.index_nuc[nuc] for nuc in nuclides]
@@ -530,47 +534,32 @@ class Operator(TransportOperator):
         energy = 0.0
 
         # Create arrays to store fission Q values, reaction rates, and nuclide
-        # numbers
-        rates_expanded = np.zeros((rates.n_nuc, rates.n_react))
-        number = np.zeros(rates.n_nuc)
+        # numbers, zeroed out in material iteration
+        number = np.empty(rates.n_nuc)
 
         fission_ind = rates.index_rx["fission"]
 
-        self._tally_helper.set_fission_q(self.chain.nuclides, rates.index_nuc)
-
-        tally_results = self._tally_helper.reaction_tally.results
-
         # Extract results
         for i, mat in enumerate(self.local_mats):
             # Get tally index
             slab = materials.index(mat)
 
-            # Get material results hyperslab
-            results = tally_results[slab, :, 1]
-
             # Zero out reaction rates and nuclide numbers
-            rates_expanded[:] = 0.0
             number[:] = 0.0
 
-            # Expand into our memory layout
-            j = 0
+            # Get new number densities
             for nuc, i_nuc_results in zip(nuclides, nuc_ind):
                 number[i_nuc_results] = self.number[mat, nuc]
-                for react in react_ind:
-                    rates_expanded[i_nuc_results, react] = results[j]
-                    j += 1
+
+            tally_rates = self._rate_helper.get_material_rates(
+                i, nuc_ind, react_ind)
 
             # Accumulate energy from fission
-            energy += self._tally_helper.get_fission_energy(
-                rates_expanded[:, fission_ind], i)
+            energy += self._energy_helper.get_fission_energy(
+                tally_rates[:, fission_ind], i)
 
             # Divide by total number and store
-            for i_nuc_results in nuc_ind:
-                if number[i_nuc_results] != 0.0:
-                    for react in react_ind:
-                        rates_expanded[i_nuc_results, react] /= number[i_nuc_results]
-
-            rates[i, :, :] = rates_expanded
+            rates[i, :, :] = self._rate_helper.divide_by_adens(number)
 
         # Reduce energy produced from all processes
         energy = comm.allreduce(energy)

From 9cbbc6e6b9ab405c473c3c6b756dafab76485222 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 5 Jul 2019 13:37:12 -0500
Subject: [PATCH 007/127] Document abstract and concrete operator helpers

---
 docs/source/pythonapi/deplete.rst | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/docs/source/pythonapi/deplete.rst b/docs/source/pythonapi/deplete.rst
index 532e06655..091b25da7 100644
--- a/docs/source/pythonapi/deplete.rst
+++ b/docs/source/pythonapi/deplete.rst
@@ -75,10 +75,24 @@ data, such as number densities and reaction rates for each material.
    :template: myclass.rst
 
    AtomNumber
+   ChainFissHelper
+   DirectRxnRateHelper
    OperatorResult
    ReactionRates
    Results
    ResultsList
+
+
+The following classes are abstract classes that can be used to extend the
+:mod:`openmc.deplete` capabilities:
+
+.. autosummary::
+   :toctree:generated
+   :nosignatures:
+   :template: myclass.rst
+
+   ReactionRateHelper
+   FissionEnergyHelper
    TransportOperator
 
 Each of the integrator functions also relies on a number of "helper" functions

From ff13e98a09286f44bd0b90645130df6622ccc76e Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 5 Jul 2019 14:44:21 -0500
Subject: [PATCH 008/127] Read in material temperatures from xml subelement

Closes #1280 by reading the temperature from an xml
subelement as it is written, not an attribute.

Added loading of temperature and volume material attributes
from xml in unit test
---
 openmc/material.py                | 7 +++++--
 tests/unit_tests/test_material.py | 4 ++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/openmc/material.py b/openmc/material.py
index 55aef743c..7eb6de66c 100644
--- a/openmc/material.py
+++ b/openmc/material.py
@@ -931,8 +931,11 @@ class Material(IDManagerMixin):
         mat_id = int(elem.get('id'))
         mat = cls(mat_id)
         mat.name = elem.get('name')
-        if 'temperature' in elem.attrib:
-            mat.temperature = float(elem.get('temperature'))
+
+        temp_node = elem.find("temperature")
+        if temp_node is not None:
+            mat.temperature = float(temp_node.text)
+
         if 'volume' in elem.attrib:
             mat.volume = float(elem.get('volume'))
         mat.depletable = bool(elem.get('depletable'))
diff --git a/tests/unit_tests/test_material.py b/tests/unit_tests/test_material.py
index 30a3e2498..62fff7cdf 100644
--- a/tests/unit_tests/test_material.py
+++ b/tests/unit_tests/test_material.py
@@ -189,6 +189,8 @@ def test_from_xml(run_in_tmpdir):
     m1.add_nuclide('H1', 1.0)
     m1.add_nuclide('O16', 2.0)
     m1.add_s_alpha_beta('c_H_in_H2O')
+    m1.temperature = 300
+    m1.volume = 100
     m1.set_density('g/cm3', 0.9)
     m1.isotropic = ['H1']
     m2 = openmc.Material(2, 'zirc')
@@ -209,6 +211,8 @@ def test_from_xml(run_in_tmpdir):
     assert m1.name == 'water'
     assert m1.nuclides == [('H1', 1.0, 'ao'), ('O16', 2.0, 'ao')]
     assert m1.isotropic == ['H1']
+    assert m1.temperature == 300
+    assert m1.volume == 100
     m2 = mats[1]
     assert m2.nuclides == [('Zr90', 1.0, 'wo')]
     assert m2.density == 10.0

From 50ea1ed02af4a89b4a4b4ff3c4c5ccc922a16f36 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 5 Jul 2019 16:51:10 -0500
Subject: [PATCH 009/127] Function based pin construction

Function openmc.model.funcs.pin has replaced the class-based
openmc.model.pin.Pin

Subdivision functionality is maintained by passing a dictionary
of integer ring indexes -> number of divisions to the function

Tests have been updated accordingly and are parametrized
against surface type: X, Y, and Z cylinders
---
 openmc/model/__init__.py     |   1 -
 openmc/model/funcs.py        | 130 +++++++++++++++++-
 openmc/model/pin.py          | 249 -----------------------------------
 tests/unit_tests/test_pin.py |  75 ++++++-----
 4 files changed, 167 insertions(+), 288 deletions(-)
 delete mode 100644 openmc/model/pin.py

diff --git a/openmc/model/__init__.py b/openmc/model/__init__.py
index 8ec96845e..9fa999dd4 100644
--- a/openmc/model/__init__.py
+++ b/openmc/model/__init__.py
@@ -1,4 +1,3 @@
 from .triso import *
 from .model import *
 from .funcs import *
-from .pin import *
diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index 143033eca..4b44b450f 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -1,12 +1,16 @@
-from collections import OrderedDict
 from collections.abc import Iterable
 from math import sqrt
 from numbers import Real
 from functools import partial
 from warnings import warn
+from operator import attrgetter
 
-from openmc import XPlane, YPlane, Plane, ZCylinder, Quadric
-from openmc.checkvalue import check_type, check_value
+from openmc import (
+    XPlane, YPlane, Plane, ZCylinder, Quadric, Cylinder, XCylinder,
+    YCylinder, Material, Universe, Cell)
+from openmc.checkvalue import (
+    check_type, check_value, check_length, check_less_than,
+    check_iterable_type)
 import openmc.data
 
 
@@ -414,7 +418,7 @@ def cylinder_from_points(p1, p2, r, **kwargs):
     kwargs['j'] = cx*dy - cy*dx
     kwargs['k'] = -(dx*dx + dy*dy + dz*dz)*r*r
 
-    return openmc.Quadric(**kwargs)
+    return Quadric(**kwargs)
 
 
 def subdivide(surfaces):
@@ -442,3 +446,121 @@ def subdivide(surfaces):
         regions.append(+s0 & -s1)
     regions.append(+surfaces[-1])
     return regions
+
+
+def pin(surfaces, materials, subdivisions=None, universe_id=None, name=""):
+    """Convenience function for building a fuel pin
+
+    Parameters
+    ----------
+    surfaces : iterable of :class:`openmc.Cylinder`
+        Cylinders used to define boundaries
+        between materials. All cylinders must be
+        concentric and of the same orientation, e.g.
+        all :class:`openmc.ZCylinder`
+    materials : iterable of :class:`openmc.Material`
+        Materials to go between ``surfaces``. There must be one
+        more material than surfaces, corresponding to the material
+        that spans all space outside the final ring.
+    subdivisions : None or dict of int to int
+        Dictionary describing which rings to subdivide and how
+        many times. Keys are indexes of the annular rings
+        to be divided. Will construct equal area rings
+    universe_id : None or int
+        Identifier for this universe
+    name : str
+        Name for this universe
+
+    Returns
+    -------
+    :class:`openmc.Universe`
+        Universe of concentric cylinders filled with the desired
+        materials
+    """
+    check_type("materials",  materials, Iterable, Material)
+    check_length("surfaces", surfaces, len(materials) - 1, len(materials) - 1)
+    # Check that all surfaces are of similar orientation
+    check_type("surface", surfaces[0], Cylinder)
+    surf_type = type(surfaces[0])
+    check_iterable_type("surfaces", surfaces[1:], surf_type)
+
+    # Check for increasing radii and equal centers
+    if surf_type is ZCylinder:
+        center_getter = attrgetter("x0", "y0")
+    elif surf_type is YCylinder:
+        center_getter = attrgetter("x0", "z0")
+    elif surf_type is XCylinder:
+        center_getter = attrgetter("z0", "y0")
+    else:
+        raise TypeError(
+            "Not configured to interpret {} surfaces".format(
+                surf_type.__name__))
+
+    centers = set()
+    prev_rad = 0
+    for ix, surf in enumerate(surfaces):
+        cur_rad = surf.r
+        if cur_rad <= prev_rad:
+            raise ValueError(
+                "Surfaces do not appear to be increasing in radius. "
+                "Surface {} at index {} has radius {:7.3E} compared to "
+                "previous radius of {:7.5E}".format(
+                    surf.id, ix, cur_rad, prev_rad))
+        prev_rad = cur_rad
+        centers.add(center_getter(surf))
+
+    if len(centers) > 1:
+        raise ValueError(
+            "Surfaces do not appear to be concentric. The following "
+            "centers were found: {}".format(centers))
+
+    if subdivisions is not None:
+        check_length("subdivisions", subdivisions, 1, len(surfaces))
+        orig_indexes = list(subdivisions.keys())
+        check_iterable_type("ring indexes", orig_indexes, int)
+        check_iterable_type(
+            "number of divisions", list(subdivisions.values()), int)
+        for ix in orig_indexes:
+            if ix < 0:
+                subdivisions[len(surfaces) + ix] = subdivisions.pop(ix)
+        # Dissallow subdivision on outer most, infinite region
+        check_less_than(
+            "outer ring", max(subdivisions), len(surfaces), equality=True)
+
+        # ensure ability to concatenate
+        if not isinstance(materials, list):
+            materials = list(materials)
+        if not isinstance(surfaces, list):
+            surfaces = list(surfaces)
+
+        # generate equal area divisions
+        # Adding N - 1 new regions
+        # N - 2 surfaces are made
+        # Original cell is not removed, but not occupies last ring
+        for ring_index in reversed(sorted(subdivisions.keys())):
+            nr = subdivisions[ring_index]
+            new_surfs = []
+
+            if ring_index == 0:
+                lower_rad = 0.0
+            else:
+                lower_rad = surfaces[ring_index - 1].r
+            upper_rad = surfaces[ring_index].r
+
+            area_term = (upper_rad ** 2 - lower_rad ** 2) / nr
+
+            for new_index in range(nr - 1):
+                lower_rad = sqrt(area_term + lower_rad ** 2)
+                new_surfs.append(surf_type(r=lower_rad))
+
+            surfaces = (
+                    surfaces[:ring_index] + new_surfs + surfaces[ring_index:])
+            materials = (
+                    materials[:ring_index]
+                    + [materials[ring_index].clone() for _i in range(nr - 1)]
+                    + materials[ring_index:])
+
+    # Build the universe
+    regions = subdivide(surfaces)
+    cells = [Cell(fill=f, region=r) for r, f in zip(regions, materials)]
+    return Universe(universe_id=universe_id, name=name, cells=cells)
diff --git a/openmc/model/pin.py b/openmc/model/pin.py
deleted file mode 100644
index 0ec0c4dbd..000000000
--- a/openmc/model/pin.py
+++ /dev/null
@@ -1,249 +0,0 @@
-"""
-Helper class for building a pin from concentric cylinders
-"""
-
-
-from math import sqrt
-from numbers import Real
-from operator import attrgetter
-
-import openmc
-import openmc.checkvalue as cv
-from . import subdivide
-
-__all__ = ["Pin"]
-
-
-class Pin(openmc.Universe):
-    """Special universe used to model pins
-
-    Parameters
-    ----------
-    surfaces: iterable of :class:`openmc.Cylinder`
-        Cylinders used to define boundaries
-        between materials. All cylinders must be
-        concentric and of the same orientation, e.g.
-        all :class:`openmc.ZCylinders`
-    materials: iterable of :class:`openmc.Material`
-        Materials to go between ``surfaces``. There must be one
-        more material than surfaces, corresponding to the material
-        that spans all space outside the final ring.
-    universe_id: None or int
-        Unique identifier for this universe
-    name: str
-        Name for this universe
-
-    See Also
-    --------
-
-    :meth:`openmc.Pin.from_radii` - Convinience function to build
-    from radii of cylinders
-    """
-
-    def __init__(self, surfaces, materials, universe_id=None, name=""):
-        cv.check_iterable_type("materials", materials, openmc.Material)
-        cv.check_length("surfaces", surfaces, len(materials) - 1)
-
-        # Ensure that all surfaces are same type of cylinder
-        self._check_surfaces(surfaces)
-        regions = subdivide(surfaces)
-
-        cells = [
-            openmc.Cell(fill=m, region=r) for m, r in zip(materials, regions)
-        ]
-
-        super().__init__(universe_id=universe_id, name=name, cells=cells)
-        self._list_cells = cells  # need ordered by radial position
-
-    def _check_surfaces(self, surfaces):
-        cv.check_type(
-            "surface 0",
-            surfaces[0],
-            (openmc.ZCylinder, openmc.YCylinder, openmc.XCylinder),
-        )
-        if isinstance(surfaces[0], openmc.ZCylinder):
-            center_getter = attrgetter("x0", "y0")
-        elif isinstance(surfaces[0], openmc.YClylinder):
-            center_getter = attrgetter("x0", "y0")
-        elif isinstance(surfaces[0], openmc.XClylinder):
-            center_getter = attrgetter("z0", "y0")
-        else:
-            raise TypeError(
-                "Not configured to interpret {} surfaces".format(
-                    surfaces[0].__class__.__name__
-                )
-            )
-        cv.check_iterable_type("surfaces", surfaces[1:], type(surfaces[0]))
-        # Check for concentric-ness and increasing radii
-        centers = set()
-        radii = []
-        rad = 0
-        for ix, surf in enumerate(surfaces):
-            cur_rad = surf.r
-            if cur_rad <= rad:
-                raise ValueError(
-                    "Surfaces do not appear to be increasing in radius. "
-                    "Surface {} at index {} has radius {:7.3E} compared to "
-                    "previous radius of {:7.5E}".format(
-                        surf.id, ix, cur_rad, rad
-                    )
-                )
-            rad = cur_rad
-            radii.append(cur_rad)
-            centers.add(center_getter(surf))
-
-        if len(centers) > 1:
-            raise ValueError(
-                "Surfaces do not appear to be concentric. The following "
-                "centers were found: {}".format(centers)
-            )
-        self._radii = radii
-        self._surfaces = surfaces
-        self._surf_type = type(surfaces[0])
-
-    @classmethod
-    def from_radii(
-        cls,
-        radii,
-        materials,
-        universe_id=None,
-        name="",
-        orientation="z",
-        center=(0.0, 0.0),
-    ):
-        """Construct using radii of concentric cylinders and materials
-
-        Parameters
-        ----------
-        radii: iterable of float
-            Radii of the intended cylinders. Must be all positive
-            values and increasing
-        materials: iterable of :class:`openmc.Material`
-            Materials used to fill cylinders created by ``radii``,
-            starting from inside to the outside of the pin.
-            There must be one extra material corresponding to all
-            area outside the last ring
-        universe_id: None or int
-            Unique identifier to give this pin
-        name: str
-            Name of the created universe
-        orientation: {"x", "y", "z"}
-            Axis along which to orient the pin. Default is ``"z"``
-        center: iterable of float
-            Center of the pin in the plane perpendicular
-        """
-        cv.check_iterable_type("materials", materials, openmc.Material)
-        cv.check_length("radii", radii, len(materials) - 1)
-        for ix, rad in enumerate(radii):
-            if rad < 0:
-                raise ValueError(
-                    "Radius {:7.3E} at index {} is non-positive".format(
-                        rad, ix
-                    )
-                )
-            if ix and rad <= radii[ix - 1]:
-                raise ValueError(
-                    "Radii must be increasing values. Radius {:7.3E} at index "
-                    "{} is not greater than previous value of {:7.3E}".format(
-                        rad, ix, radii[ix - 1]
-                    )
-                )
-
-        if orientation == "z":
-            surfCls = openmc.ZCylinder
-            basis = ["x0", "y0"]
-        elif orientation == "y":
-            surfCls = openmc.YCylinder
-            basis = ["x0", "z0"]
-        elif orientation == "z":
-            surfCls = openmc.XCylinder
-            basis = ["y0", "z0"]
-        else:
-            raise ValueError(
-                "Orientation of {} not understood".format(orientation)
-            )
-
-        centerKwargs = dict(zip(basis, center))
-
-        surfaces = [surfCls(r=rad, **centerKwargs) for rad in radii]
-
-        return cls(surfaces, materials, universe_id=universe_id, name=name)
-
-    def subdivide_ring(self, ring_index, n_divs):
-        """Divide one ring of the pin into equal-area rings
-
-        Each new ring will be added to the model, and filled with
-        a unique material copied from the original.
-
-        Parameters
-        ring_index: int
-            Index of the ring to be divided where 0 is the innermost
-            ring. Will not divide the outermost region as there is no
-            upper bound
-        n_divs: int
-            Number of equal area divisions to make in this ring
-        """
-        # Don't allow subdivision of outer, infinite region
-        cv.check_less_than("ring_index", ring_index, len(self._radii))
-        cv.check_type("n_divs", n_divs, Real)
-        cv.check_greater_than("n_divs", n_divs, 1)
-
-        if ring_index < 0:
-            ring_index = len(self._list_cells) + ring_index
-
-        # Get all the information we need to replicate this
-        # region with unique insides
-        orig_cell = self._list_cells[ring_index]
-
-        lower_rad = self._radii[ring_index - 1] if ring_index else 0.0
-        area_term = (self._radii[ring_index] ** 2 - lower_rad ** 2) / n_divs
-
-        new_radii = []
-        new_surfaces = []
-        new_cells = []
-
-        # Adding N - 1 new regions
-        # N - 2 surfaces are made
-        # Original cell is not removed, but not occupies last ring
-
-        for i in range(n_divs - 1):
-            r = sqrt(area_term + lower_rad ** 2)
-            lower_rad = r
-            new_radii.append(r)
-            surf = self._surf_type(r=r)
-            new_surfaces.append(surf)
-            if i == 0:
-                if ring_index:
-                    region = (
-                        -surf & +self._surfaces[ring_index - 1]
-                    )
-                else:
-                    region = -surf
-            else:
-                region = -surf & +new_surfaces[-2]
-            new_cells.append(
-                openmc.Cell(region=region, fill=orig_cell.fill.clone())
-            )
-
-        orig_cell.region = -self._surfaces[ring_index] & +surf
-
-        self.add_cells(new_cells)
-
-        self._list_cells = (
-            self._list_cells[:ring_index]
-            + new_cells
-            + self._list_cells[ring_index:]
-        )
-        self._radii = (
-            self._radii[:ring_index] + new_radii + self._radii[ring_index:]
-        )
-        self._surfaces = (
-            self._surfaces[:ring_index]
-            + new_surfaces
-            + self._surfaces[ring_index:]
-        )
-
-    @property
-    def radii(self):
-        """Return a tuple of the radii in this :class:`Pin`"""
-        return tuple(self._radii)
diff --git a/tests/unit_tests/test_pin.py b/tests/unit_tests/test_pin.py
index 0940c5e30..d2f7fa801 100644
--- a/tests/unit_tests/test_pin.py
+++ b/tests/unit_tests/test_pin.py
@@ -6,7 +6,18 @@ import numpy
 import pytest
 
 import openmc
-from openmc.model import Pin
+from openmc.model import pin
+
+
+def get_pin_radii(pin_univ):
+    """Return a sorted list of all radii from pin"""
+    rads = set()
+
+    for cell in pin_univ.get_all_cells().values():
+        surfs = cell.region.get_surfaces().values()
+        rads.update(set(s.r for s in surfs))
+
+    return list(sorted(rads))
 
 
 @pytest.fixture
@@ -24,60 +35,56 @@ def good_radii():
 
 def test_failure(pin_mats, good_radii):
     """Check for various failure modes"""
+    good_surfaces = [openmc.ZCylinder(r=r) for r in good_radii]
     # Bad material type
     with pytest.raises(TypeError):
-        Pin.from_radii(good_radii, [mat.name for mat in pin_mats])
+        pin(good_surfaces, [mat.name for mat in pin_mats])
 
     # Incorrect lengths
-    with pytest.raises(ValueError, match="length") as exec_info:
-        Pin.from_radii(good_radii[: len(pin_mats) - 2], pin_mats)
+    with pytest.raises(ValueError, match="length"):
+        pin(good_surfaces[:len(pin_mats) - 2], pin_mats)
 
     # Non-positive radii
-    rad = (-0.1,) + good_radii[1:]
-    with pytest.raises(ValueError, match="index 0") as exec_info:
-        Pin.from_radii(rad, pin_mats)
+    rad = [openmc.ZCylinder(r=-0.1)] + good_surfaces[1:]
+    with pytest.raises(ValueError, match="index 0"):
+        pin(rad, pin_mats)
 
     # Non-increasing radii
-    rad = tuple(reversed(good_radii))
-    with pytest.raises(ValueError, match="index 1") as exec_info:
-        Pin.from_radii(rad, pin_mats)
+    surfs = tuple(reversed(good_surfaces))
+    with pytest.raises(ValueError, match="index 1"):
+        pin(surfs, pin_mats)
 
     # Bad orientation
-    with pytest.raises(ValueError, match="Orientation") as exec_info:
-        Pin.from_radii(good_radii, pin_mats, orientation="fail")
+    surfs = [openmc.XCylinder(r=good_surfaces[0].r)] + good_surfaces[1:]
+    with pytest.raises(TypeError, match="surfaces"):
+        pin(surfs, pin_mats)
 
 
-def test_from_radii(pin_mats, good_radii):
-    name = "test pin"
-    p = Pin.from_radii(good_radii, pin_mats, name=name)
-    assert len(p.cells) == len(pin_mats)
-    assert p.name == name
-    assert p.radii == good_radii
-
-
-def test_subdivide(pin_mats, good_radii):
-    surfs = [openmc.ZCylinder(r=r) for r in good_radii]
-    pin = Pin(surfs, pin_mats)
-    assert pin.radii == good_radii
-    assert len(pin.cells) == len(pin_mats)
+@pytest.mark.parametrize(
+    "surf_type", [openmc.ZCylinder, openmc.XCylinder, openmc.YCylinder])
+def test_subdivide(pin_mats, good_radii, surf_type):
+    """Test the subdivision with various orientations"""
+    surfs = [surf_type(r=r) for r in good_radii]
+    fresh = pin(surfs, pin_mats)
+    assert len(fresh.cells) == len(pin_mats)
 
     # subdivide inner region
     N = 5
-    pin.subdivide_ring(0, N)
-    assert len(pin.radii) == len(good_radii) + N - 1
-    assert len(pin.cells) == len(pin_mats) + N - 1
+    div0 = pin(surfs, pin_mats, {0: N})
+    assert len(div0.cells) == len(pin_mats) + N - 1
+
     # check volumes of new rings
-    bounds = (0,) + pin.radii[:N]
+    radii = get_pin_radii(div0)
+    bounds = [0] + radii[:N]
     sqrs = numpy.square(bounds)
     assert sqrs[1:] - sqrs[:-1] == pytest.approx(good_radii[0] ** 2 / N)
 
     # subdivide non-inner most region
-    new_pin = Pin.from_radii(good_radii, pin_mats)
-    new_pin.subdivide_ring(1, N)
-    assert len(new_pin.radii) == len(good_radii) + N - 1
+    new_pin = pin(surfs, pin_mats, {1: N})
     assert len(new_pin.cells) == len(pin_mats) + N - 1
+
     # check volumes of new rings
-    bounds = new_pin.radii[:N + 1]
-    sqrs = numpy.square(bounds)
+    radii = get_pin_radii(new_pin)
+    sqrs = numpy.square(radii[:N + 1])
     assert sqrs[1:] - sqrs[:-1] == pytest.approx(
         (good_radii[1] ** 2 - good_radii[0] ** 2) / N)

From 220f12c2a74a797b94817ed7050752afd4c68c2f Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 8 Jul 2019 10:56:40 -0500
Subject: [PATCH 010/127] Add set/get capture branching ratios method for Chain

Related to #1237.

openmc.deplete.Chain.set_capture_branches takes in
a dictionary of parent nuclide names to {daughter: ratio}, e.g.
{"Am241": {"Am242": 0.9, "Am242_m1": 0.1}}
that will be used to overwrite existing capture
reactions with new branching ratios.

openmc.deplete.Chain.get_capture_branches returns a
similar dictionary of capture reactions with multiple targets
and their branching ratios.
---
 openmc/deplete/chain.py | 137 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 136 insertions(+), 1 deletion(-)

diff --git a/openmc/deplete/chain.py b/openmc/deplete/chain.py
index 643235d9f..eec9d3f50 100644
--- a/openmc/deplete/chain.py
+++ b/openmc/deplete/chain.py
@@ -11,7 +11,8 @@ import re
 from collections import OrderedDict, defaultdict
 from collections.abc import Mapping
 
-from openmc.checkvalue import check_type
+from openmc.checkvalue import check_type, check_less_than
+from openmc.data import gnd_name, zam
 
 # Try to use lxml if it is available. It preserves the order of attributes and
 # provides a pretty-printer by default. If not available,
@@ -451,3 +452,137 @@ class Chain(object):
         matrix_dok = sp.dok_matrix((n, n))
         dict.update(matrix_dok, matrix)
         return matrix_dok.tocsr()
+
+    def get_capture_branches(self):
+        """Return a dictionary with capture branching ratios
+
+        Returns
+        -------
+        capt :
+            nested dict of parent nuclide keys with capture targets and
+            branching ratios::
+
+                {"Am241": {"Am242": 0.91, "Am242_m1": 0.09}}
+
+        See Also
+        --------
+        :meth:`set_capture_branches`
+
+        """
+
+        capt = {}
+        for nuclide in self.nuclides:
+            nuc_capt = {}
+            for rx in nuclide.reactions:
+                if rx.type == "(n,gamma)" and rx.branching_ratio != 1.0:
+                    nuc_capt[rx.target] = rx.branching_ratio
+            if len(nuc_capt) > 0:
+                capt[nuclide.name] = nuc_capt
+        return capt
+
+    def set_capture_branches(self, branch_ratios):
+        """Set the capture branching ratios
+
+        ``branch_ratios`` may be modified in place, only to
+        insert missing ground state reactions. These will be
+        inserted only if:
+
+            1) There is no branch directly to a ground state
+               target, and
+            2) The sum of all ratios on this branch does not
+               equal 1.
+
+        Parameters
+        ----------
+        branch_ratios : dict of {str: {str: float}}
+            Capture branching ratios to be inserted.
+            First layer keys are names of parent nuclides, e.g.
+            ``"Am241"``. The capture branching ratios for these
+            parents will be modified. Corresponding values are
+            dictionaries of ``{target: branching_ratio}``
+
+        See Also
+        --------
+        :meth:`get_capture_branches`
+        """
+
+        # Store some useful information through the validation stage
+
+        sums = {}
+        capt_ix_map = {}
+        grounds = {}
+
+        missing = set()
+        no_capture = set()
+
+        # Check for validity before manipulation
+
+        check_type("branch_ratios", branch_ratios, dict, str)
+
+        for parent, sub in branch_ratios.items():
+            if parent not in self:
+                # TODO How to handle missing branching ratios
+                missing.add(parent)
+                continue
+
+            # Make sure this nuclide has capture reactions
+
+            indexes = []
+            for ix, rx in enumerate(self[parent].reactions):
+                if rx.type == "(n,gamma)":
+                    indexes.append(ix)
+                    if "_m" not in rx.target:
+                        grounds[parent] = rx.target
+
+            if len(indexes) == 0:
+                no_capture.add(parent)
+                continue
+
+            capt_ix_map[parent] = indexes
+
+            check_type(parent, sub, dict, str)
+            check_type(parent + " ratios", list(sub.values()), list, float)
+            this_sum = sum(sub.values())
+            check_less_than(parent + " ratios", this_sum, 1.0, True)
+            sums[parent] = this_sum
+
+        if len(missing) > 0:
+            print("The following nuclides were not found in {}: {}".format(
+                self.__class__.__name__, ", ".join(sorted(missing))))
+
+        if len(no_capture) > 0:
+            print("The following nuclides did not have capture reactions: "
+                  "{}".format(", ".join(sorted(no_capture))))
+
+        # Insert new ReactionTuples with updated branch ratios
+
+        for parent_name, capt_index in capt_ix_map.items():
+
+            parent = self[parent_name]
+            new_ratios = branch_ratios[parent_name]
+            capt_index = capt_ix_map[parent_name]
+
+            # Assume Q value is independent of target state
+            capt_Q = parent.reactions[capt_index[0]].Q
+
+            # Remove existing capture reactions
+
+            for ix in reversed(capt_index):
+                parent.reactions.pop(ix)
+
+            all_meta = False
+
+            for tgt, br in new_ratios.items():
+                all_meta |= ("_m" in tgt)
+                parent.reactions.append(ReactionTuple(
+                    "(n,gamma)", tgt, capt_Q, br))
+
+            if all_meta and sums[parent_name] != 1.0:
+                ground_br = 1.0 - sums[parent_name]
+                ground_tgt = grounds.get(parent_name, None)
+                if ground_tgt is None:
+                    pz, pa, pm = zam(parent_name)
+                    ground_tgt = gnd_name(pz, pa + 1, 0)
+                new_ratios[ground_tgt] = ground_br
+                parent.reactions.append(ReactionTuple(
+                    "(n,gamma)", ground_tgt, capt_Q, ground_br))

From 5440edd637c7b1cf22c8eb04401e2f2b29c642d2 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 8 Jul 2019 13:00:10 -0500
Subject: [PATCH 011/127] Check that all capture parents and products exist
 before adding to Chain

Before modifying the existing Chain, ensure that all desired
products exist. Otherwise, the Chain will be unable to build
a depletion matrix in Chain.form_matrix

Added an optional argument, strict, that controls the error/print
control. If strict, then an KeyError will be raised at the first
parent or product that does not exist in the chain. Otherwise,
messages will be printed at the end.
---
 openmc/deplete/chain.py | 49 ++++++++++++++++++++++++++++++++++-------
 1 file changed, 41 insertions(+), 8 deletions(-)

diff --git a/openmc/deplete/chain.py b/openmc/deplete/chain.py
index eec9d3f50..0267977d2 100644
--- a/openmc/deplete/chain.py
+++ b/openmc/deplete/chain.py
@@ -480,7 +480,7 @@ class Chain(object):
                 capt[nuclide.name] = nuc_capt
         return capt
 
-    def set_capture_branches(self, branch_ratios):
+    def set_capture_branches(self, branch_ratios, strict=True):
         """Set the capture branching ratios
 
         ``branch_ratios`` may be modified in place, only to
@@ -500,6 +500,13 @@ class Chain(object):
             ``"Am241"``. The capture branching ratios for these
             parents will be modified. Corresponding values are
             dictionaries of ``{target: branching_ratio}``
+        strict : bool
+            If this evalutes to ``True``, then all parents and
+            products must exist in the :class:`Chain`. A
+            :class:`KeyError` will be raised at the first
+            nuclide that does not exist. Otherwise, print
+            a warning message for missing parents and/or
+            products.
 
         See Also
         --------
@@ -512,7 +519,8 @@ class Chain(object):
         capt_ix_map = {}
         grounds = {}
 
-        missing = set()
+        missing_parents = set()
+        missing_products = {}
         no_capture = set()
 
         # Check for validity before manipulation
@@ -521,8 +529,24 @@ class Chain(object):
 
         for parent, sub in branch_ratios.items():
             if parent not in self:
-                # TODO How to handle missing branching ratios
-                missing.add(parent)
+                if strict:
+                    raise KeyError(parent)
+                missing_parents.add(parent)
+                continue
+
+            # Make sure all products are present in the chain
+
+            prod_flag = False
+
+            for product in sub:
+                if product not in self.nuclide_dict:
+                    if strict:
+                        raise KeyError(product)
+                    missing_products[parent] = product
+                    prod_flag = True
+                    break
+
+            if prod_flag:
                 continue
 
             # Make sure this nuclide has capture reactions
@@ -535,25 +559,34 @@ class Chain(object):
                         grounds[parent] = rx.target
 
             if len(indexes) == 0:
+                if strict:
+                    raise AttributeError(
+                        "Nuclide {} does not have capture reactions in "
+                        "this {}".format(parent, self.__class__.__name__))
                 no_capture.add(parent)
                 continue
 
             capt_ix_map[parent] = indexes
 
-            check_type(parent, sub, dict, str)
-            check_type(parent + " ratios", list(sub.values()), list, float)
             this_sum = sum(sub.values())
             check_less_than(parent + " ratios", this_sum, 1.0, True)
             sums[parent] = this_sum
 
-        if len(missing) > 0:
+        if len(missing_parents) > 0:
             print("The following nuclides were not found in {}: {}".format(
-                self.__class__.__name__, ", ".join(sorted(missing))))
+                self.__class__.__name__, ", ".join(sorted(missing_parents))))
 
         if len(no_capture) > 0:
             print("The following nuclides did not have capture reactions: "
                   "{}".format(", ".join(sorted(no_capture))))
 
+        if len(missing_products) > 0:
+            tail = ("{} -> {}".format(k, v)
+                    for k, v in sorted(missing_products.items()))
+            print("The following products were not found in the {} and "
+                  "parents were unmodified: \n{}".format(
+                      self.__class__.__name__, ", ".join(tail)))
+
         # Insert new ReactionTuples with updated branch ratios
 
         for parent_name, capt_index in capt_ix_map.items():

From 5b7253bca0f00903c94f24dd4e58fa590e1a0208 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 8 Jul 2019 13:54:05 -0500
Subject: [PATCH 012/127] Add tests for getting, setting capture branching
 ratios

Work with the test chain with isotopes A, B, C to make
minor modifications to a depletion chain.

Work with the "reference chain" at tests/chain_simple.xml to
check inference of ground state, non-construction of
reactions that dont' exist.
---
 tests/unit_tests/test_deplete_chain.py | 67 ++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/tests/unit_tests/test_deplete_chain.py b/tests/unit_tests/test_deplete_chain.py
index dd6817a8e..2458af7c5 100644
--- a/tests/unit_tests/test_deplete_chain.py
+++ b/tests/unit_tests/test_deplete_chain.py
@@ -243,3 +243,70 @@ def test_set_fiss_q():
         for rx in chain_nuc.reactions:
             if rx.type == 'fission':
                 assert rx.Q == q
+
+
+def test_get_set_chain_br(simple_chain):
+    """Test minor modifications to capture branch ratios"""
+    expected = {"C": {"A": 0.7, "B": 0.3}}
+    assert simple_chain.get_capture_branches() == expected
+
+    # safely modify
+    new_chain = Chain.from_xml("chain_test.xml")
+    new_br = {"C": {"A": 0.5, "B": 0.5}, "A": {"C": 0.99, "B": 0.01}}
+    new_chain.set_capture_branches(new_br)
+    assert new_chain.get_capture_branches() == new_br
+
+    # write, re-read
+    new_chain.export_to_xml("chain_mod.xml")
+    assert Chain.from_xml("chain_mod.xml").get_capture_branches() == new_br
+
+    # Test non-strict [warn, not error] setting
+    bad_br = {"B": {"X": 0.6, "A": 0.4}, "X": {"A": 0.5, "C": 0.5}}
+    bad_br.update(new_br)
+    new_chain.set_capture_branches(bad_br, strict=False)
+    assert new_chain.get_capture_branches() == new_br
+
+    # Ensure capture reactions are removed
+    rem_br = {"A": {"C": 1.0}}
+    new_chain.set_capture_branches(rem_br)
+    # A is not in returned dict because there is no branch
+    assert "A" not in new_chain.get_capture_branches()
+
+
+def test_capture_branch_infer_ground():
+    """Ensure the ground state is infered if not given"""
+    # Make up a metastable capture transition:
+    infer_br = {"Xe135": {"Xe136_m1": 0.5}}
+    set_br = {"Xe135": {"Xe136": 0.5, "Xe136_m1": 0.5}}
+
+    chain_file = Path(__file__).parents[1] / "chain_simple.xml"
+    chain = Chain.from_xml(chain_file)
+
+    # Create nuclide to be added into the chain
+    xe136m = nuclide.Nuclide()
+    xe136m.name = "Xe136_m1"
+
+    chain.nuclides.append(xe136m)
+    chain.nuclide_dict[xe136m.name] = len(chain.nuclides) - 1
+
+    chain.set_capture_branches(infer_br)
+
+    assert chain.get_capture_branches() == set_br
+
+
+def test_capture_branch_no_rxn():
+    """Ensure capture reactions that don't exist aren't created"""
+    u4br = {"U234": {"U235": 0.5, "U235_m1": 0.5}}
+
+    chain_file = Path(__file__).parents[1] / "chain_simple.xml"
+    chain = Chain.from_xml(chain_file)
+
+    u5m = nuclide.Nuclide()
+    u5m.name = "U235_m1"
+
+    chain.nuclides.append(u5m)
+    chain.nuclide_dict[u5m.name] = len(chain.nuclides) - 1
+
+    phrase = "U234 does not have capture reactions"
+    with pytest.raises(AttributeError, match=phrase):
+        chain.set_capture_branches(u4br)

From a7b6737069859ba0f1ec8ac578a842453eea3fea Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 8 Jul 2019 14:01:57 -0500
Subject: [PATCH 013/127] Test failure modes for Chain.set_capture_branches

Remove one validation check, that the passed item is a
dict of strings. The check is covered when every key is
inspected to ensure all parents exist in the chain
---
 openmc/deplete/chain.py                |  2 --
 tests/unit_tests/test_deplete_chain.py | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/openmc/deplete/chain.py b/openmc/deplete/chain.py
index 0267977d2..0a52b78d7 100644
--- a/openmc/deplete/chain.py
+++ b/openmc/deplete/chain.py
@@ -525,8 +525,6 @@ class Chain(object):
 
         # Check for validity before manipulation
 
-        check_type("branch_ratios", branch_ratios, dict, str)
-
         for parent, sub in branch_ratios.items():
             if parent not in self:
                 if strict:
diff --git a/tests/unit_tests/test_deplete_chain.py b/tests/unit_tests/test_deplete_chain.py
index 2458af7c5..33b13b596 100644
--- a/tests/unit_tests/test_deplete_chain.py
+++ b/tests/unit_tests/test_deplete_chain.py
@@ -310,3 +310,22 @@ def test_capture_branch_no_rxn():
     phrase = "U234 does not have capture reactions"
     with pytest.raises(AttributeError, match=phrase):
         chain.set_capture_branches(u4br)
+
+
+def test_capture_branch_failures(simple_chain):
+    """Test failure modes for setting capture branch ratios"""
+
+    # Parent isotope not present
+    br = {"X": {"A": 0.6, "B": 0.7}}
+    with pytest.raises(KeyError, match="X"):
+        simple_chain.set_capture_branches(br)
+
+    # Product isotope not present
+    br = {"C": {"X": 0.4, "A": 0.2, "B": 0.4}}
+    with pytest.raises(KeyError, match="X"):
+        simple_chain.set_capture_branches(br)
+
+    # Sum of ratios > 1.0
+    br = {"C": {"A": 1.0, "B": 1.0}}
+    with pytest.raises(ValueError, match="C ratios"):
+        simple_chain.set_capture_branches(br)

From 40f89caa223f6f84bc3a9d84681909c4704bb614 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 8 Jul 2019 23:24:19 -0500
Subject: [PATCH 014/127] Fix cylinder_from_points function

---
 openmc/model/funcs.py            |  6 +++---
 tests/unit_tests/test_surface.py | 35 +++++++++++++++++++++++---------
 2 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index 143033eca..4e79617dd 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -395,9 +395,9 @@ def cylinder_from_points(p1, p2, r, **kwargs):
     dx = x2 - x1
     dy = y2 - y1
     dz = z2 - z1
-    cx = y1*z2 + y2*z1
-    cy = -(x1*z2 + x2*z1)
-    cz = x1*y2 + x2*y1
+    cx = y1*z2 - y2*z1
+    cy = x2*z1 - x1*z2
+    cz = x1*y2 - x2*y1
 
     # Given p=(x,y,z), p1=(x1, y1, z1), p2=(x2, y2, z2), the equation for the
     # cylinder can be derived as r = |(p - p1) ⨯ (p - p2)| / |p2 - p1|.
diff --git a/tests/unit_tests/test_surface.py b/tests/unit_tests/test_surface.py
index 6ed657a4c..09bfa738e 100644
--- a/tests/unit_tests/test_surface.py
+++ b/tests/unit_tests/test_surface.py
@@ -1,4 +1,5 @@
 import numpy as np
+from random import random
 import openmc
 import pytest
 
@@ -329,14 +330,28 @@ def test_quadric():
 
 
 def test_cylinder_from_points():
-    # Generate 45-degree rotated cylinder in x-y plane with radius 1
-    p1 = (0, 0, 0)
-    p2 = (1, 1, 0)
-    s = openmc.model.cylinder_from_points(p1, p2, 1)
+    for _ in range(10):
+        # Generate cylinder in random direction
+        p1 = np.array([random(), random(), random()])
+        p2 = np.array([random(), random(), random()])
+        r = random()
+        s = openmc.model.cylinder_from_points(p1, p2, r)
 
-    # Points p1 and p2 need to be inside cylinder
-    assert p1 in -s
-    assert p2 in -s
-    assert (-1, 1, 0) in +s
-    assert (1, -1, 0) in +s
-    assert (0, 0, 1.5) in +s
+        # Points p1 and p2 need to be inside cylinder
+        assert p1 in -s
+        assert p2 in -s
+
+        # Points further along the line should be inside cylinder as well
+        t = 100*random() - 200
+        p = p1 + t*(p2 - p1)
+        assert p in -s
+
+        # Check that a point outside cylinder is in positive half-space. We do
+        # this by constructing a plane that includes the cylinder's axis,
+        # finding the normal to the plane, and using it to find a point slightly
+        # more than one radius away from the axis.
+        plane = openmc.Plane.from_points(p1, p2, (0., 0., 0.))
+        n = np.array([plane.a, plane.b, plane.c])
+        n /= np.linalg.norm(n)
+        assert (p1 + 1.1*r*n) in +s
+        assert (p2 + 1.1*r*n) in +s

From 13c2c837b1795e1c392671cb6a4620450e2aee90 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 28 Jun 2019 14:43:17 -0500
Subject: [PATCH 015/127] Major cleanup of tally filter interfaces

---
 include/openmc/capi.h                         |  8 +--
 include/openmc/tallies/filter.h               | 34 +++++++++--
 include/openmc/tallies/filter_azimuthal.h     |  4 ++
 include/openmc/tallies/filter_cell.h          |  6 +-
 include/openmc/tallies/filter_delayedgroup.h  |  4 ++
 include/openmc/tallies/filter_distribcell.h   |  4 +-
 include/openmc/tallies/filter_energy.h        |  4 ++
 include/openmc/tallies/filter_legendre.h      |  2 +
 include/openmc/tallies/filter_material.h      |  6 +-
 include/openmc/tallies/filter_mu.h            |  4 ++
 include/openmc/tallies/filter_particle.h      |  2 +
 include/openmc/tallies/filter_polar.h         |  4 ++
 include/openmc/tallies/filter_sph_harm.h      |  6 ++
 include/openmc/tallies/filter_sptl_legendre.h |  6 ++
 include/openmc/tallies/filter_surface.h       |  6 +-
 include/openmc/tallies/filter_universe.h      |  6 +-
 openmc/capi/filter.py                         | 12 ++--
 src/tallies/filter.cpp                        | 58 +++++++++++++++++--
 src/tallies/filter_azimuthal.cpp              | 33 +++++++----
 src/tallies/filter_cell.cpp                   | 44 ++++++++------
 src/tallies/filter_delayedgroup.cpp           | 25 +++++---
 src/tallies/filter_distribcell.cpp            | 27 +++++----
 src/tallies/filter_energy.cpp                 | 31 +++++++---
 src/tallies/filter_legendre.cpp               | 11 +++-
 src/tallies/filter_material.cpp               | 53 +++++++++--------
 src/tallies/filter_mu.cpp                     | 34 +++++++----
 src/tallies/filter_particle.cpp               | 19 +++++-
 src/tallies/filter_polar.cpp                  | 34 +++++++----
 src/tallies/filter_sph_harm.cpp               | 54 ++++++++++-------
 src/tallies/filter_sptl_legendre.cpp          | 53 ++++++++++++-----
 src/tallies/filter_surface.cpp                | 41 ++++++++-----
 src/tallies/filter_universe.cpp               | 41 ++++++++-----
 src/tallies/tally.cpp                         | 31 +---------
 33 files changed, 477 insertions(+), 230 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index 9f05a56dc..afca455dd 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -17,8 +17,8 @@ extern "C" {
   int openmc_cell_set_fill(int32_t index, int type, int32_t n, const int32_t* indices);
   int openmc_cell_set_id(int32_t index, int32_t id);
   int openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance);
-  int openmc_energy_filter_get_bins(int32_t index, double** energies, int32_t* n);
-  int openmc_energy_filter_set_bins(int32_t index, int32_t n, const double* energies);
+  int openmc_energy_filter_get_bins(int32_t index, double** energies, size_t* n);
+  int openmc_energy_filter_set_bins(int32_t index, size_t n, const double* energies);
   int openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end);
   int openmc_extend_filters(int32_t n, int32_t* index_start, int32_t* index_end);
   int openmc_extend_materials(int32_t n, int32_t* index_start, int32_t* index_end);
@@ -57,8 +57,8 @@ extern "C" {
   int openmc_material_set_densities(int32_t index, int n, const char** name, const double* density);
   int openmc_material_set_id(int32_t index, int32_t id);
   int openmc_material_set_volume(int32_t index, double volume);
-  int openmc_material_filter_get_bins(int32_t index, int32_t** bins, int32_t* n);
-  int openmc_material_filter_set_bins(int32_t index, int32_t n, const int32_t* bins);
+  int openmc_material_filter_get_bins(int32_t index, int32_t** bins, size_t* n);
+  int openmc_material_filter_set_bins(int32_t index, size_t n, const int32_t* bins);
   int openmc_mesh_filter_get_mesh(int32_t index, int32_t* index_mesh);
   int openmc_mesh_filter_set_mesh(int32_t index, int32_t index_mesh);
   int openmc_mesh_get_id(int32_t index, int32_t* id);
diff --git a/include/openmc/tallies/filter.h b/include/openmc/tallies/filter.h
index c2fd4dfb3..2c0dc2aa2 100644
--- a/include/openmc/tallies/filter.h
+++ b/include/openmc/tallies/filter.h
@@ -7,6 +7,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/hdf5_interface.h"
 #include "openmc/particle.h"
 #include "pugixml.hpp"
@@ -43,6 +45,23 @@ namespace openmc {
 class Filter
 {
 public:
+  // Default constructor
+  Filter();
+
+  //! Create a new tally filter
+  //
+  //! \param[in] type  Type of the filter
+  //! \param[in] id  Unique ID for the filter. If none is passed, an ID is
+  //!    automatically assigned
+  //! \return Pointer to the new filter object
+  static Filter* create(const std::string& type, int32_t id = -1);
+
+  //! Create a new tally filter from an XML node
+  //
+  //! \param[in] node XML node
+  //! \return Pointer to the new filter object
+  static Filter* create(pugi::xml_node node);
+
   virtual ~Filter() = default;
 
   virtual std::string type() const = 0;
@@ -57,6 +76,13 @@ public:
   virtual void
   get_all_bins(const Particle* p, int estimator, FilterMatch& match) const = 0;
 
+  //! Assign a unique ID to the filter
+  //
+  //! \param[in]  Unique ID to assign
+  void set_id(int32_t id);
+
+  gsl::index index() const { return index_; }
+
   //! Writes data describing this filter to an HDF5 statepoint group.
   virtual void
   to_statepoint(hid_t filter_group) const
@@ -71,11 +97,11 @@ public:
   //! "Incoming Energy [0.625E-6, 20.0)".
   virtual std::string text_label(int bin) const = 0;
 
-  virtual void initialize() {}
-
-  int32_t id_;
+  int32_t id_ {-1};
 
   int n_bins_;
+private:
+  gsl::index index_;
 };
 
 //==============================================================================
@@ -99,8 +125,6 @@ namespace model {
 // Non-member functions
 //==============================================================================
 
-Filter* allocate_filter(const std::string& type);
-
 //! Make sure index corresponds to a valid filter
 int verify_filter(int32_t index);
 
diff --git a/include/openmc/tallies/filter_azimuthal.h b/include/openmc/tallies/filter_azimuthal.h
index b89640031..f753bb280 100644
--- a/include/openmc/tallies/filter_azimuthal.h
+++ b/include/openmc/tallies/filter_azimuthal.h
@@ -4,6 +4,8 @@
 #include <string>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -24,6 +26,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_bins(gsl::span<double> bins);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_cell.h b/include/openmc/tallies/filter_cell.h
index 9c654e82e..eb3ff5236 100644
--- a/include/openmc/tallies/filter_cell.h
+++ b/include/openmc/tallies/filter_cell.h
@@ -5,6 +5,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -22,11 +24,11 @@ public:
 
   void from_xml(pugi::xml_node node) override;
 
-  void initialize() override;
-
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_cells(gsl::span<int32_t> cells);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_delayedgroup.h b/include/openmc/tallies/filter_delayedgroup.h
index 2f65a5059..ae2ad0cb4 100644
--- a/include/openmc/tallies/filter_delayedgroup.h
+++ b/include/openmc/tallies/filter_delayedgroup.h
@@ -3,6 +3,8 @@
 
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -26,6 +28,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_groups(gsl::span<int> groups);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_distribcell.h b/include/openmc/tallies/filter_distribcell.h
index 73857e7cb..db4cd4b1a 100644
--- a/include/openmc/tallies/filter_distribcell.h
+++ b/include/openmc/tallies/filter_distribcell.h
@@ -20,11 +20,11 @@ public:
 
   void from_xml(pugi::xml_node node) override;
 
-  void initialize() override;
-
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_cell(int32_t cell);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_energy.h b/include/openmc/tallies/filter_energy.h
index 025a77c62..b2123d7e7 100644
--- a/include/openmc/tallies/filter_energy.h
+++ b/include/openmc/tallies/filter_energy.h
@@ -3,6 +3,8 @@
 
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -23,6 +25,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_bins(gsl::span<const double> bins);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_legendre.h b/include/openmc/tallies/filter_legendre.h
index 054ba14e7..25cf99e15 100644
--- a/include/openmc/tallies/filter_legendre.h
+++ b/include/openmc/tallies/filter_legendre.h
@@ -23,6 +23,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_order(int order);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_material.h b/include/openmc/tallies/filter_material.h
index d272451db..34dffa2b8 100644
--- a/include/openmc/tallies/filter_material.h
+++ b/include/openmc/tallies/filter_material.h
@@ -5,6 +5,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -22,11 +24,11 @@ public:
 
   void from_xml(pugi::xml_node node) override;
 
-  void initialize() override;
-
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_materials(gsl::span<const int32_t> materials);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_mu.h b/include/openmc/tallies/filter_mu.h
index 68b2f7b02..06044e760 100644
--- a/include/openmc/tallies/filter_mu.h
+++ b/include/openmc/tallies/filter_mu.h
@@ -3,6 +3,8 @@
 
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -24,6 +26,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_bins(gsl::span<double> bins);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_particle.h b/include/openmc/tallies/filter_particle.h
index 268c19c6d..05e3d0505 100644
--- a/include/openmc/tallies/filter_particle.h
+++ b/include/openmc/tallies/filter_particle.h
@@ -24,6 +24,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_particles(gsl::span<Particle::Type> particles);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_polar.h b/include/openmc/tallies/filter_polar.h
index 2bcdcd07f..93488e5b0 100644
--- a/include/openmc/tallies/filter_polar.h
+++ b/include/openmc/tallies/filter_polar.h
@@ -4,6 +4,8 @@
 #include <cmath>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -24,6 +26,8 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_bins(gsl::span<double> bins);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_sph_harm.h b/include/openmc/tallies/filter_sph_harm.h
index b53b62441..522e89e78 100644
--- a/include/openmc/tallies/filter_sph_harm.h
+++ b/include/openmc/tallies/filter_sph_harm.h
@@ -3,6 +3,8 @@
 
 #include <string>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -27,6 +29,10 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_order(int order);
+
+  void set_cosine(gsl::cstring_span cosine);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_sptl_legendre.h b/include/openmc/tallies/filter_sptl_legendre.h
index 995bc7360..c65bb0cfc 100644
--- a/include/openmc/tallies/filter_sptl_legendre.h
+++ b/include/openmc/tallies/filter_sptl_legendre.h
@@ -27,6 +27,12 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_order(int order);
+
+  void set_axis(LegendreAxis axis);
+
+  void set_minmax(double min, double max);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_surface.h b/include/openmc/tallies/filter_surface.h
index ea4dc5b99..61b320ad6 100644
--- a/include/openmc/tallies/filter_surface.h
+++ b/include/openmc/tallies/filter_surface.h
@@ -5,6 +5,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -22,11 +24,11 @@ public:
 
   void from_xml(pugi::xml_node node) override;
 
-  void initialize() override;
-
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_surfaces(gsl::span<int32_t> surfaces);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/include/openmc/tallies/filter_universe.h b/include/openmc/tallies/filter_universe.h
index 3ae0093cb..0b43bb85c 100644
--- a/include/openmc/tallies/filter_universe.h
+++ b/include/openmc/tallies/filter_universe.h
@@ -5,6 +5,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include <gsl/gsl>
+
 #include "openmc/tallies/filter.h"
 
 namespace openmc {
@@ -22,11 +24,11 @@ public:
 
   void from_xml(pugi::xml_node node) override;
 
-  void initialize() override;
-
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void set_universes(gsl::span<int32_t> universes);
+
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
diff --git a/openmc/capi/filter.py b/openmc/capi/filter.py
index c0716bcef..404cd3898 100644
--- a/openmc/capi/filter.py
+++ b/openmc/capi/filter.py
@@ -28,10 +28,10 @@ _dll.openmc_cell_filter_get_bins.argtypes = [
 _dll.openmc_cell_filter_get_bins.restype = c_int
 _dll.openmc_cell_filter_get_bins.errcheck = _error_handler
 _dll.openmc_energy_filter_get_bins.argtypes = [
-    c_int32, POINTER(POINTER(c_double)), POINTER(c_int32)]
+    c_int32, POINTER(POINTER(c_double)), POINTER(c_size_t)]
 _dll.openmc_energy_filter_get_bins.restype = c_int
 _dll.openmc_energy_filter_get_bins.errcheck = _error_handler
-_dll.openmc_energy_filter_set_bins.argtypes = [c_int32, c_int32, POINTER(c_double)]
+_dll.openmc_energy_filter_set_bins.argtypes = [c_int32, c_size_t, POINTER(c_double)]
 _dll.openmc_energy_filter_set_bins.restype = c_int
 _dll.openmc_energy_filter_set_bins.errcheck = _error_handler
 _dll.openmc_filter_get_id.argtypes = [c_int32, POINTER(c_int32)]
@@ -53,10 +53,10 @@ _dll.openmc_legendre_filter_set_order.argtypes = [c_int32, c_int]
 _dll.openmc_legendre_filter_set_order.restype = c_int
 _dll.openmc_legendre_filter_set_order.errcheck = _error_handler
 _dll.openmc_material_filter_get_bins.argtypes = [
-    c_int32, POINTER(POINTER(c_int32)), POINTER(c_int32)]
+    c_int32, POINTER(POINTER(c_int32)), POINTER(c_size_t)]
 _dll.openmc_material_filter_get_bins.restype = c_int
 _dll.openmc_material_filter_get_bins.errcheck = _error_handler
-_dll.openmc_material_filter_set_bins.argtypes = [c_int32, c_int32, POINTER(c_int32)]
+_dll.openmc_material_filter_set_bins.argtypes = [c_int32, c_size_t, POINTER(c_int32)]
 _dll.openmc_material_filter_set_bins.restype = c_int
 _dll.openmc_material_filter_set_bins.errcheck = _error_handler
 _dll.openmc_mesh_filter_get_mesh.argtypes = [c_int32, POINTER(c_int32)]
@@ -148,7 +148,7 @@ class EnergyFilter(Filter):
     @property
     def bins(self):
         energies = POINTER(c_double)()
-        n = c_int32()
+        n = c_size_t()
         _dll.openmc_energy_filter_get_bins(self._index, energies, n)
         return as_array(energies, (n.value,))
 
@@ -231,7 +231,7 @@ class MaterialFilter(Filter):
     @property
     def bins(self):
         materials = POINTER(c_int32)()
-        n = c_int32()
+        n = c_size_t()
         _dll.openmc_material_filter_get_bins(self._index, materials, n)
         return [Material(index=materials[i]) for i in range(n.value)]
 
diff --git a/src/tallies/filter.cpp b/src/tallies/filter.cpp
index e9aae53a7..36a36044a 100644
--- a/src/tallies/filter.cpp
+++ b/src/tallies/filter.cpp
@@ -7,6 +7,7 @@
 #include "openmc/capi.h"
 #include "openmc/constants.h"  // for MAX_LINE_LEN;
 #include "openmc/error.h"
+#include "openmc/xml_interface.h"
 #include "openmc/tallies/filter_azimuthal.h"
 #include "openmc/tallies/filter_cell.h"
 #include "openmc/tallies/filter_cellborn.h"
@@ -50,8 +51,41 @@ namespace model {
 // Non-member functions
 //==============================================================================
 
-Filter*
-allocate_filter(const std::string& type)
+extern "C" size_t tally_filters_size()
+{
+  return model::tally_filters.size();
+}
+
+//==============================================================================
+// Filter implementation
+//==============================================================================
+
+Filter::Filter() : index_{model::tally_filters.size()}
+{ }
+
+Filter* Filter::create(pugi::xml_node node)
+{
+  // Copy filter id
+  if (!check_for_node(node, "id")) {
+    fatal_error("Must specify id for filter in tally XML file.");
+  }
+  int filter_id = std::stoi(get_node_value(node, "id"));
+
+  // Convert filter type to lower case
+  std::string s;
+  if (check_for_node(node, "type")) {
+    s = get_node_value(node, "type", true);
+  }
+
+  // Allocate according to the filter type
+  auto f = Filter::create(s, filter_id);
+
+  // Read filter data from XML
+  f->from_xml(node);
+  return f;
+}
+
+Filter* Filter::create(const std::string& type, int32_t id)
 {
   if (type == "azimuthal") {
     model::tally_filters.push_back(std::make_unique<AzimuthalFilter>());
@@ -100,12 +134,26 @@ allocate_filter(const std::string& type)
   } else {
     throw std::runtime_error{"Unknown filter type: " + type};
   }
+
+  // Assign ID
+  model::tally_filters.back()->set_id(id);
+
   return model::tally_filters.back().get();
 }
 
-extern "C" size_t tally_filters_size()
+void Filter::set_id(int32_t id)
 {
-  return model::tally_filters.size();
+  Expects(id >= 0);
+  if (model::filter_map.find(id) != model::filter_map.end()) {
+    throw std::runtime_error{"Two filters have the same ID: " + std::to_string(id)};
+  }
+
+  // Clear entry in filter map if an ID was already assigned before
+  if (id_ != -1) model::filter_map.erase(id_);
+
+  // Update ID and entry in filter map
+  id_ = id;
+  model::filter_map[id] = index_;
 }
 
 //==============================================================================
@@ -181,7 +229,7 @@ extern "C" int
 openmc_new_filter(const char* type, int32_t* index)
 {
   *index = model::tally_filters.size();
-  allocate_filter(type);
+  Filter::create(type);
   return 0;
 }
 
diff --git a/src/tallies/filter_azimuthal.cpp b/src/tallies/filter_azimuthal.cpp
index 1a33a6bfe..eb02319c2 100644
--- a/src/tallies/filter_azimuthal.cpp
+++ b/src/tallies/filter_azimuthal.cpp
@@ -15,22 +15,35 @@ AzimuthalFilter::from_xml(pugi::xml_node node)
 {
   auto bins = get_node_array<double>(node, "bins");
 
-  if (bins.size() > 1) {
-    bins_ = bins;
-
-  } else {
+  if (bins.size() == 1) {
     // Allow a user to input a lone number which will mean that you subdivide
     // [-pi,pi) evenly with the input being the number of bins
 
     int n_angle = bins[0];
-
-    if (n_angle <= 1) fatal_error("Number of bins for azimuthal filter must "
-                                  "be greater than 1.");
+    if (n_angle <= 1) throw std::runtime_error{
+      "Number of bins for azimuthal filter must be greater than 1."};
 
     double d_angle = 2.0 * PI / n_angle;
-    bins_.resize(n_angle + 1);
-    for (int i = 0; i < n_angle; i++) bins_[i] = -PI + i * d_angle;
-    bins_[n_angle] = PI;
+    bins.resize(n_angle + 1);
+    for (int i = 0; i < n_angle; i++) bins[i] = -PI + i * d_angle;
+    bins[n_angle] = PI;
+  }
+
+  this->set_bins(bins);
+}
+
+void AzimuthalFilter::set_bins(gsl::span<double> bins)
+{
+  // Clear existing bins
+  bins_.clear();
+  bins_.reserve(bins.size());
+
+  // Copy bins, ensuring they are valid
+  for (gsl::index i = 0; i < bins.size(); ++i) {
+    if (i > 0 && bins[i] <= bins[i-1]) {
+      throw std::runtime_error{"Azimuthal bins must be monotonically increasing."};
+    }
+    bins_.push_back(bins[i]);
   }
 
   n_bins_ = bins_.size() - 1;
diff --git a/src/tallies/filter_cell.cpp b/src/tallies/filter_cell.cpp
index 8286a6976..685d8ff74 100644
--- a/src/tallies/filter_cell.cpp
+++ b/src/tallies/filter_cell.cpp
@@ -12,29 +12,39 @@ namespace openmc {
 void
 CellFilter::from_xml(pugi::xml_node node)
 {
-  cells_ = get_node_array<int32_t>(node, "bins");
-  n_bins_ = cells_.size();
+  // Get cell IDs and convert into indices into the global cells vector
+  auto cells = get_node_array<int32_t>(node, "bins");
+  for (auto& c : cells) {
+    auto search = model::cell_map.find(c);
+    if (search == model::cell_map.end()) {
+      std::stringstream err_msg;
+      err_msg << "Could not find cell " << c
+              << " specified on tally filter.";
+      throw std::runtime_error{err_msg.str()};
+    }
+    c = search->second;
+  }
+
+  this->set_cells(cells);
 }
 
 void
-CellFilter::initialize()
+CellFilter::set_cells(gsl::span<int32_t> cells)
 {
-  // Convert cell IDs to indices of the global array.
-  for (auto& c : cells_) {
-    auto search = model::cell_map.find(c);
-    if (search != model::cell_map.end()) {
-      c = search->second;
-    } else {
-      std::stringstream err_msg;
-      err_msg << "Could not find cell " << c << " specified on tally filter.";
-      fatal_error(err_msg);
-    }
+  // Clear existing cells
+  cells_.clear();
+  cells_.reserve(cells.size());
+  map_.clear();
+
+  // Update cells and mapping
+  for (auto& index : cells) {
+    Expects(index >= 0);
+    Expects(index < model::cells.size());
+    cells_.push_back(index);
+    map_[index] = cells_.size() - 1;
   }
 
-  // Populate the index->bin map.
-  for (int i = 0; i < cells_.size(); i++) {
-    map_[cells_[i]] = i;
-  }
+  n_bins_ = cells_.size();
 }
 
 void
diff --git a/src/tallies/filter_delayedgroup.cpp b/src/tallies/filter_delayedgroup.cpp
index 4f448358e..2b6978308 100644
--- a/src/tallies/filter_delayedgroup.cpp
+++ b/src/tallies/filter_delayedgroup.cpp
@@ -8,21 +8,32 @@ namespace openmc {
 void
 DelayedGroupFilter::from_xml(pugi::xml_node node)
 {
-  groups_ = get_node_array<int>(node, "bins");
-  n_bins_ = groups_.size();
+  auto groups = get_node_array<int>(node, "bins");
+  this->set_groups(groups);
+}
+
+void
+DelayedGroupFilter::set_groups(gsl::span<int> groups)
+{
+  // Clear existing groups
+  groups_.clear();
+  groups_.reserve(groups.size());
 
   // Make sure all the group index values are valid.
   // TODO: do these need to be decremented for zero-based indexing?
-  for (auto group : groups_) {
+  for (auto group : groups) {
     if (group < 1) {
-      fatal_error("Encountered delayedgroup bin with index "
-        + std::to_string(group) + " which is less than 1");
+      throw std::invalid_argument{"Encountered delayedgroup bin with index "
+        + std::to_string(group) + " which is less than 1"};
     } else if (group > MAX_DELAYED_GROUPS) {
-      fatal_error("Encountered delayedgroup bin with index "
+      throw std::invalid_argument{"Encountered delayedgroup bin with index "
         + std::to_string(group) + " which is greater than MAX_DELATED_GROUPS ("
-        + std::to_string(MAX_DELAYED_GROUPS) + ")");
+        + std::to_string(MAX_DELAYED_GROUPS) + ")"};
     }
+    groups_.push_back(group);
   }
+
+  n_bins_ = groups_.size();
 }
 
 void
diff --git a/src/tallies/filter_distribcell.cpp b/src/tallies/filter_distribcell.cpp
index 94f23621b..f9c7ab4d6 100644
--- a/src/tallies/filter_distribcell.cpp
+++ b/src/tallies/filter_distribcell.cpp
@@ -15,23 +15,26 @@ DistribcellFilter::from_xml(pugi::xml_node node)
   if (cells.size() != 1) {
     fatal_error("Only one cell can be specified per distribcell filter.");
   }
-  cell_ = cells[0];
-}
 
-void
-DistribcellFilter::initialize()
-{
-  // Convert the cell ID to an index of the global array.
-  auto search = model::cell_map.find(cell_);
-  if (search != model::cell_map.end()) {
-    cell_ = search->second;
-    n_bins_ = model::cells[cell_]->n_instances_;
-  } else {
+  // Find index in global cells vector corresponding to cell ID
+  auto search = model::cell_map.find(cells[0]);
+  if (search == model::cell_map.end()) {
     std::stringstream err_msg;
     err_msg << "Could not find cell " << cell_
             << " specified on tally filter.";
-    fatal_error(err_msg);
+    throw std::runtime_error{err_msg.str()};
   }
+
+  this->set_cell(search->second);
+}
+
+void
+DistribcellFilter::set_cell(int32_t cell)
+{
+  Expects(cell >= 0);
+  Expects(cell < model::cells.size());
+  cell_ = cell;
+  n_bins_ = model::cells[cell]->n_instances_;
 }
 
 void
diff --git a/src/tallies/filter_energy.cpp b/src/tallies/filter_energy.cpp
index e11ab3080..d4e26a1f0 100644
--- a/src/tallies/filter_energy.cpp
+++ b/src/tallies/filter_energy.cpp
@@ -16,7 +16,25 @@ namespace openmc {
 void
 EnergyFilter::from_xml(pugi::xml_node node)
 {
-  bins_ = get_node_array<double>(node, "bins");
+  auto bins = get_node_array<double>(node, "bins");
+  this->set_bins(bins);
+}
+
+void
+EnergyFilter::set_bins(gsl::span<const double> bins)
+{
+  // Clear existing bins
+  bins_.clear();
+  bins_.reserve(bins.size());
+
+  // Copy bins, ensuring they are valid
+  for (gsl::index i = 0; i < bins.size(); ++i) {
+    if (i > 0 && bins[i] <= bins[i-1]) {
+      throw std::runtime_error{"Energy bins must be monotonically increasing."};
+    }
+    bins_.push_back(bins[i]);
+  }
+
   n_bins_ = bins_.size() - 1;
 
   // In MG mode, check if the filter bins match the transport bins.
@@ -27,7 +45,7 @@ EnergyFilter::from_xml(pugi::xml_node node)
   if (!settings::run_CE) {
     if (n_bins_ == data::num_energy_groups) {
       matches_transport_groups_ = true;
-      for (auto i = 0; i < n_bins_ + 1; i++) {
+      for (gsl::index i = 0; i < n_bins_ + 1; ++i) {
         if (data::rev_energy_bins[i] != bins_[i]) {
           matches_transport_groups_ = false;
           break;
@@ -111,7 +129,7 @@ EnergyoutFilter::text_label(int bin) const
 //==============================================================================
 
 extern"C" int
-openmc_energy_filter_get_bins(int32_t index, double** energies, int32_t* n)
+openmc_energy_filter_get_bins(int32_t index, double** energies, size_t* n)
 {
   // Make sure this is a valid index to an allocated filter.
   if (int err = verify_filter(index)) return err;
@@ -133,7 +151,7 @@ openmc_energy_filter_get_bins(int32_t index, double** energies, int32_t* n)
 }
 
 extern "C" int
-openmc_energy_filter_set_bins(int32_t index, int32_t n, const double* energies)
+openmc_energy_filter_set_bins(int32_t index, size_t n, const double* energies)
 {
   // Make sure this is a valid index to an allocated filter.
   if (int err = verify_filter(index)) return err;
@@ -149,10 +167,7 @@ openmc_energy_filter_set_bins(int32_t index, int32_t n, const double* energies)
   }
 
   // Update the filter.
-  filt->bins_.clear();
-  filt->bins_.resize(n);
-  for (int i = 0; i < n; i++) filt->bins_[i] = energies[i];
-  filt->n_bins_ = n - 1;
+  filt->set_bins({energies, n});
   return 0;
 }
 
diff --git a/src/tallies/filter_legendre.cpp b/src/tallies/filter_legendre.cpp
index 6fa041c76..21939b7d4 100644
--- a/src/tallies/filter_legendre.cpp
+++ b/src/tallies/filter_legendre.cpp
@@ -10,7 +10,13 @@ namespace openmc {
 void
 LegendreFilter::from_xml(pugi::xml_node node)
 {
-  order_ = std::stoi(get_node_value(node, "order"));
+  this->set_order(std::stoi(get_node_value(node, "order")));
+}
+
+void
+LegendreFilter::set_order(int order)
+{
+  order_ = order;
   n_bins_ = order_ + 1;
 }
 
@@ -81,8 +87,7 @@ openmc_legendre_filter_set_order(int32_t index, int order)
   }
 
   // Update the filter.
-  filt->order_ = order;
-  filt->n_bins_ = order + 1;
+  filt->set_order(order);
   return 0;
 }
 
diff --git a/src/tallies/filter_material.cpp b/src/tallies/filter_material.cpp
index fd9e637bd..c9fd644ad 100644
--- a/src/tallies/filter_material.cpp
+++ b/src/tallies/filter_material.cpp
@@ -3,7 +3,6 @@
 #include <sstream>
 
 #include "openmc/capi.h"
-#include "openmc/error.h"
 #include "openmc/material.h"
 #include "openmc/xml_interface.h"
 
@@ -12,30 +11,39 @@ namespace openmc {
 void
 MaterialFilter::from_xml(pugi::xml_node node)
 {
-  materials_ = get_node_array<int32_t>(node, "bins");
-  n_bins_ = materials_.size();
-}
-
-void
-MaterialFilter::initialize()
-{
-  // Convert material IDs to indices of the global array.
-  for (auto& m : materials_) {
+  // Get material IDs and convert to indices in the global materials vector
+  auto mats = get_node_array<int32_t>(node, "bins");
+  for (auto& m : mats) {
     auto search = model::material_map.find(m);
-    if (search != model::material_map.end()) {
-      m = search->second;
-    } else {
+    if (search == model::material_map.end()) {
       std::stringstream err_msg;
       err_msg << "Could not find material " << m
               << " specified on tally filter.";
-      fatal_error(err_msg);
+      throw std::runtime_error{err_msg.str()};
     }
+    m = search->second;
   }
 
-  // Populate the index->bin map.
-  for (int i = 0; i < materials_.size(); i++) {
-    map_[materials_[i]] = i;
+  this->set_materials(mats);
+}
+
+void
+MaterialFilter::set_materials(gsl::span<const int32_t> materials)
+{
+  // Clear existing materials
+  materials_.clear();
+  materials_.reserve(materials.size());
+  map_.clear();
+
+  // Update materials and mapping
+  for (auto& index : materials) {
+    Expects(index >= 0);
+    Expects(index < model::materials.size());
+    materials_.push_back(index);
+    map_[index] = materials_.size() - 1;
   }
+
+  n_bins_ = materials_.size();
 }
 
 void
@@ -69,7 +77,7 @@ MaterialFilter::text_label(int bin) const
 //==============================================================================
 
 extern "C" int
-openmc_material_filter_get_bins(int32_t index, int32_t** bins, int32_t* n)
+openmc_material_filter_get_bins(int32_t index, int32_t** bins, size_t* n)
 {
   // Make sure this is a valid index to an allocated filter.
   if (int err = verify_filter(index)) return err;
@@ -91,7 +99,7 @@ openmc_material_filter_get_bins(int32_t index, int32_t** bins, int32_t* n)
 }
 
 extern "C" int
-openmc_material_filter_set_bins(int32_t index, int32_t n, const int32_t* bins)
+openmc_material_filter_set_bins(int32_t index, size_t n, const int32_t* bins)
 {
   // Make sure this is a valid index to an allocated filter.
   if (int err = verify_filter(index)) return err;
@@ -107,12 +115,7 @@ openmc_material_filter_set_bins(int32_t index, int32_t n, const int32_t* bins)
   }
 
   // Update the filter.
-  filt->materials_.clear();
-  filt->materials_.resize(n);
-  for (int i = 0; i < n; i++) filt->materials_[i] = bins[i];
-  filt->n_bins_ = filt->materials_.size();
-  filt->map_.clear();
-  for (int i = 0; i < n; i++) filt->map_[filt->materials_[i]] = i;
+  filt->set_materials({bins, n});
   return 0;
 }
 
diff --git a/src/tallies/filter_mu.cpp b/src/tallies/filter_mu.cpp
index aed8371b8..9aaebea8c 100644
--- a/src/tallies/filter_mu.cpp
+++ b/src/tallies/filter_mu.cpp
@@ -13,22 +13,36 @@ MuFilter::from_xml(pugi::xml_node node)
 {
   auto bins = get_node_array<double>(node, "bins");
 
-  if (bins.size() > 1) {
-    bins_ = bins;
-
-  } else {
+  if (bins.size() == 1) {
     // Allow a user to input a lone number which will mean that you subdivide
     // [-1,1) evenly with the input being the number of bins
 
     int n_angle = bins[0];
-
-    if (n_angle <= 1) fatal_error("Number of bins for mu filter must "
-                                  "be greater than 1.");
+    if (n_angle <= 1) throw std::runtime_error{
+        "Number of bins for mu filter must be greater than 1."};
 
     double d_angle = 2.0 / n_angle;
-    bins_.resize(n_angle + 1);
-    for (int i = 0; i < n_angle; i++) bins_[i] = -1 + i * d_angle;
-    bins_[n_angle] = 1;
+    bins.resize(n_angle + 1);
+    for (int i = 0; i < n_angle; i++) bins[i] = -1 + i * d_angle;
+    bins[n_angle] = 1;
+  }
+
+  this->set_bins(bins);
+}
+
+void
+MuFilter::set_bins(gsl::span<double> bins)
+{
+  // Clear existing bins
+  bins_.clear();
+  bins_.reserve(bins.size());
+
+  // Copy bins, ensuring they are valid
+  for (gsl::index i = 0; i < bins.size(); ++i) {
+    if (i > 0 && bins[i] <= bins[i-1]) {
+      throw std::runtime_error{"Mu bins must be monotonically increasing."};
+    }
+    bins_.push_back(bins[i]);
   }
 
   n_bins_ = bins_.size() - 1;
diff --git a/src/tallies/filter_particle.cpp b/src/tallies/filter_particle.cpp
index 23a305b8d..de142489f 100644
--- a/src/tallies/filter_particle.cpp
+++ b/src/tallies/filter_particle.cpp
@@ -8,8 +8,25 @@ void
 ParticleFilter::from_xml(pugi::xml_node node)
 {
   auto particles = get_node_array<int>(node, "bins");
+
+  // Convert to vector of Particle::Type
+  std::vector<Particle::Type> types;
   for (auto& p : particles) {
-    particles_.push_back(static_cast<Particle::Type>(p - 1));
+    types.push_back(static_cast<Particle::Type>(p - 1));
+  }
+  this->set_particles(types);
+}
+
+void
+ParticleFilter::set_particles(gsl::span<Particle::Type> particles)
+{
+  // Clear existing particles
+  particles_.clear();
+  particles_.reserve(particles.size());
+
+  // Set particles and number of bins
+  for (auto p : particles) {
+    particles_.push_back(p);
   }
   n_bins_ = particles_.size();
 }
diff --git a/src/tallies/filter_polar.cpp b/src/tallies/filter_polar.cpp
index 9730bbb58..edbbc8922 100644
--- a/src/tallies/filter_polar.cpp
+++ b/src/tallies/filter_polar.cpp
@@ -14,22 +14,36 @@ PolarFilter::from_xml(pugi::xml_node node)
 {
   auto bins = get_node_array<double>(node, "bins");
 
-  if (bins.size() > 1) {
-    bins_ = bins;
-
-  } else {
+  if (bins.size() == 1) {
     // Allow a user to input a lone number which will mean that you subdivide
     // [0,pi] evenly with the input being the number of bins
 
     int n_angle = bins[0];
-
-    if (n_angle <= 1) fatal_error("Number of bins for polar filter must "
-                                  "be greater than 1.");
+    if (n_angle <= 1) throw std::runtime_error{
+      "Number of bins for polar filter must be greater than 1."};
 
     double d_angle = PI / n_angle;
-    bins_.resize(n_angle + 1);
-    for (int i = 0; i < n_angle; i++) bins_[i] = i * d_angle;
-    bins_[n_angle] = PI;
+    bins.resize(n_angle + 1);
+    for (int i = 0; i < n_angle; i++) bins[i] = i * d_angle;
+    bins[n_angle] = PI;
+  }
+
+  this->set_bins(bins);
+}
+
+void
+PolarFilter::set_bins(gsl::span<double> bins)
+{
+  // Clear existing bins
+  bins_.clear();
+  bins_.reserve(bins.size());
+
+  // Copy bins, ensuring they are valid
+  for (gsl::index i = 0; i < bins.size(); ++i) {
+    if (i > 0 && bins[i] <= bins[i-1]) {
+      throw std::runtime_error{"Polar bins must be monotonically increasing."};
+    }
+    bins_.push_back(bins[i]);
   }
 
   n_bins_ = bins_.size() - 1;
diff --git a/src/tallies/filter_sph_harm.cpp b/src/tallies/filter_sph_harm.cpp
index 0b3a37118..a01c2e87f 100644
--- a/src/tallies/filter_sph_harm.cpp
+++ b/src/tallies/filter_sph_harm.cpp
@@ -12,21 +12,34 @@ namespace openmc {
 void
 SphericalHarmonicsFilter::from_xml(pugi::xml_node node)
 {
-  order_ = std::stoi(get_node_value(node, "order"));
-  n_bins_ = (order_ + 1) * (order_ + 1);
-
+  this->set_order(std::stoi(get_node_value(node, "order")));
   if (check_for_node(node, "cosine")) {
-    auto cos = get_node_value(node, "cosine", true);
-    if (cos == "scatter") {
-      cosine_ = SphericalHarmonicsCosine::scatter;
-    } else if (cos == "particle") {
-      cosine_ = SphericalHarmonicsCosine::particle;
-    } else {
-      std::stringstream err_msg;
-      err_msg << "Unrecognized cosine type, \"" << cos
-              << "\" in spherical harmonics filter";
-      fatal_error(err_msg);
-    }
+    this->set_cosine(get_node_value(node, "cosine", true));
+  }
+}
+
+void
+SphericalHarmonicsFilter::set_order(int order)
+{
+  if (order < 0) {
+    throw std::invalid_argument{"Spherical harmonics order must be non-negative."};
+  }
+  order_ = order;
+  n_bins_ = (order_ + 1) * (order_ + 1);
+}
+
+void
+SphericalHarmonicsFilter::set_cosine(gsl::cstring_span cosine)
+{
+  if (cosine == "scatter") {
+    cosine_ = SphericalHarmonicsCosine::scatter;
+  } else if (cosine == "particle") {
+    cosine_ = SphericalHarmonicsCosine::particle;
+  } else {
+    std::stringstream err_msg;
+    err_msg << "Unrecognized cosine type, \"" << cos
+            << "\" in spherical harmonics filter";
+    throw std::invalid_argument{err_msg.str()};
   }
 }
 
@@ -153,8 +166,7 @@ openmc_sphharm_filter_set_order(int32_t index, int order)
   if (err) return err;
 
   // Update the filter.
-  filt->order_ = order;
-  filt->n_bins_ = (order + 1) * (order + 1);
+  filt->set_order(order);
   return 0;
 }
 
@@ -168,12 +180,10 @@ openmc_sphharm_filter_set_cosine(int32_t index, const char cosine[])
   if (err) return err;
 
   // Update the filter.
-  if (strcmp(cosine, "scatter") == 0) {
-    filt->cosine_ = SphericalHarmonicsCosine::scatter;
-  } else if (strcmp(cosine, "particle") == 0) {
-    filt->cosine_ = SphericalHarmonicsCosine::particle;
-  } else {
-    set_errmsg("Invalid spherical harmonics cosine.");
+  try {
+    filt->set_cosine(cosine);
+  } catch (const std::invalid_argument& e) {
+    set_errmsg(e.what());
     return OPENMC_E_INVALID_ARGUMENT;
   }
   return 0;
diff --git a/src/tallies/filter_sptl_legendre.cpp b/src/tallies/filter_sptl_legendre.cpp
index 6562ff01c..e0aeff9c1 100644
--- a/src/tallies/filter_sptl_legendre.cpp
+++ b/src/tallies/filter_sptl_legendre.cpp
@@ -12,25 +12,51 @@ namespace openmc {
 void
 SpatialLegendreFilter::from_xml(pugi::xml_node node)
 {
-  order_ = std::stoi(get_node_value(node, "order"));
+  this->set_order(std::stoi(get_node_value(node, "order")));
 
   auto axis = get_node_value(node, "axis");
-  if (axis == "x") {
-    axis_ = LegendreAxis::x;
-  } else if (axis == "y") {
-    axis_ = LegendreAxis::y;
-  } else if (axis == "z") {
-    axis_ = LegendreAxis::z;
-  } else {
-    fatal_error("Unrecognized axis on SpatialLegendreFilter");
+  switch (axis[0]) {
+  case 'x':
+    this->set_axis(LegendreAxis::x);
+    break;
+  case 'y':
+    this->set_axis(LegendreAxis::y);
+    break;
+  case 'z':
+    this->set_axis(LegendreAxis::z);
+    break;
+  default:
+    throw std::runtime_error{"Axis for SpatialLegendreFilter must be 'x', 'y', or 'z'"};
   }
 
-  min_ = std::stod(get_node_value(node, "min"));
-  max_ = std::stod(get_node_value(node, "max"));
+  double min = std::stod(get_node_value(node, "min"));
+  double max = std::stod(get_node_value(node, "max"));
+  this->set_minmax(min, max);
+}
 
+void
+SpatialLegendreFilter::set_order(int order)
+{
+  order_ = order;
   n_bins_ = order_ + 1;
 }
 
+void
+SpatialLegendreFilter::set_axis(LegendreAxis axis)
+{
+  axis_ = axis;
+}
+
+void
+SpatialLegendreFilter::set_minmax(double min, double max)
+{
+  if (max < min) {
+    throw std::invalid_argument{"Maximum value must be greater than minimum value"};
+  }
+  min_ = min;
+  max_ = max;
+}
+
 void
 SpatialLegendreFilter::get_all_bins(const Particle* p, int estimator,
                                     FilterMatch& match) const
@@ -157,8 +183,7 @@ openmc_spatial_legendre_filter_set_order(int32_t index, int order)
   if (err) return err;
 
   // Update the filter.
-  filt->order_ = order;
-  filt->n_bins_ = order + 1;
+  filt->set_order(order);
   return 0;
 }
 
@@ -173,7 +198,7 @@ openmc_spatial_legendre_filter_set_params(int32_t index, const int* axis,
   if (err) return err;
 
   // Update the filter.
-  if (axis) filt->axis_ = static_cast<LegendreAxis>(*axis);
+  if (axis) filt->set_axis(static_cast<LegendreAxis>(*axis));
   if (min) filt->min_ = *min;
   if (max) filt->max_ = *max;
   return 0;
diff --git a/src/tallies/filter_surface.cpp b/src/tallies/filter_surface.cpp
index faa8aafbf..72b356f21 100644
--- a/src/tallies/filter_surface.cpp
+++ b/src/tallies/filter_surface.cpp
@@ -11,30 +11,41 @@ namespace openmc {
 void
 SurfaceFilter::from_xml(pugi::xml_node node)
 {
-  surfaces_ = get_node_array<int32_t>(node, "bins");
-  n_bins_ = surfaces_.size();
-}
+  auto surfaces = get_node_array<int32_t>(node, "bins");
 
-void
-SurfaceFilter::initialize()
-{
-  // Convert surface IDs to indices of the global array.
-  for (auto& s : surfaces_) {
+  // Convert surface IDs to indices of the global surfaces vector.
+  for (auto& s : surfaces) {
     auto search = model::surface_map.find(s);
-    if (search != model::surface_map.end()) {
-      s = search->second;
-    } else {
+    if (search == model::surface_map.end()) {
       std::stringstream err_msg;
       err_msg << "Could not find surface " << s
               << " specified on tally filter.";
-      fatal_error(err_msg);
+      throw std::runtime_error{err_msg.str()};
     }
+
+    s = search->second;
   }
 
-  // Populate the index->bin map.
-  for (int i = 0; i < surfaces_.size(); i++) {
-    map_[surfaces_[i]] = i;
+  this->set_surfaces(surfaces);
+}
+
+void
+SurfaceFilter::set_surfaces(gsl::span<int32_t> surfaces)
+{
+  // Clear existing surfaces
+  surfaces_.clear();
+  surfaces_.reserve(surfaces.size());
+  map_.clear();
+
+  // Update surfaces and mapping
+  for (auto& index : surfaces) {
+    Expects(index >= 0);
+    Expects(index < model::surfaces.size());
+    surfaces_.push_back(index);
+    map_[index] = surfaces_.size() - 1;
   }
+
+  n_bins_ = surfaces_.size();
 }
 
 void
diff --git a/src/tallies/filter_universe.cpp b/src/tallies/filter_universe.cpp
index 50c058c05..dffdee621 100644
--- a/src/tallies/filter_universe.cpp
+++ b/src/tallies/filter_universe.cpp
@@ -11,30 +11,39 @@ namespace openmc {
 void
 UniverseFilter::from_xml(pugi::xml_node node)
 {
-  universes_ = get_node_array<int32_t>(node, "bins");
-  n_bins_ = universes_.size();
-}
-
-void
-UniverseFilter::initialize()
-{
-  // Convert universe IDs to indices of the global array.
-  for (auto& u : universes_) {
+  // Get material IDs and convert to indices in the global materials vector
+  auto universes = get_node_array<int32_t>(node, "bins");
+  for (auto& u : universes) {
     auto search = model::universe_map.find(u);
-    if (search != model::universe_map.end()) {
-      u = search->second;
-    } else {
+    if (search == model::universe_map.end()) {
       std::stringstream err_msg;
       err_msg << "Could not find universe " << u
               << " specified on tally filter.";
-      fatal_error(err_msg);
+      throw std::runtime_error{err_msg.str()};
     }
+    u = search->second;
   }
 
-  // Populate the index->bin map.
-  for (int i = 0; i < universes_.size(); i++) {
-    map_[universes_[i]] = i;
+  this->set_universes(universes);
+}
+
+void
+UniverseFilter::set_universes(gsl::span<int32_t> universes)
+{
+  // Clear existing universes
+  universes_.clear();
+  universes_.reserve(universes.size());
+  map_.clear();
+
+  // Update universes and mapping
+  for (auto& index : universes) {
+    Expects(index >= 0);
+    Expects(index < model::universes.size());
+    universes_.push_back(index);
+    map_[index] = universes_.size() - 1;
   }
+
+  n_bins_ = universes_.size();
 }
 
 void
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index 2cb0945ab..a4cb04169 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -614,36 +614,7 @@ void read_tallies_xml()
 
   // Check for user filters and allocate
   for (auto node_filt : root.children("filter")) {
-    // Copy filter id
-    if (!check_for_node(node_filt, "id")) {
-      fatal_error("Must specify id for filter in tally XML file.");
-    }
-    int filter_id = std::stoi(get_node_value(node_filt, "id"));
-
-    // Check to make sure 'id' hasn't been used
-    if (model::filter_map.find(filter_id) != model::filter_map.end()) {
-      fatal_error("Two or more filters use the same unique ID: "
-        + std::to_string(filter_id));
-    }
-
-    // Convert filter type to lower case
-    std::string s;
-    if (check_for_node(node_filt, "type")) {
-      s = get_node_value(node_filt, "type", true);
-    }
-
-    // Allocate according to the filter type
-    Filter* f = allocate_filter(s);
-
-    // Read filter data from XML
-    f->from_xml(node_filt);
-
-    // Set filter id
-    f->id_ = filter_id;
-    model::filter_map[filter_id] = model::tally_filters.size() - 1;
-
-    // Initialize filter
-    f->initialize();
+    auto f = Filter::create(node_filt);
   }
 
   // ==========================================================================

From 9553f2908a9d5b4a929ff6fed93a4c252deb1d3d Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 1 Jul 2019 22:08:42 -0500
Subject: [PATCH 016/127] Improvements in Tally interfaces

---
 include/openmc/capi.h          |   4 +-
 include/openmc/tallies/tally.h |  16 +++-
 openmc/capi/filter.py          |   1 +
 openmc/capi/tally.py           |   6 +-
 src/tallies/filter.cpp         |  28 ++++---
 src/tallies/tally.cpp          | 136 +++++++++++++++++++++------------
 6 files changed, 124 insertions(+), 67 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index afca455dd..fba653818 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -95,7 +95,7 @@ extern "C" {
   int openmc_tally_get_active(int32_t index, bool* active);
   int openmc_tally_get_estimator(int32_t index, int* estimator);
   int openmc_tally_get_id(int32_t index, int32_t* id);
-  int openmc_tally_get_filters(int32_t index, const int32_t** indices, int* n);
+  int openmc_tally_get_filters(int32_t index, const int32_t** indices, size_t* n);
   int openmc_tally_get_n_realizations(int32_t index, int32_t* n);
   int openmc_tally_get_nuclides(int32_t index, int** nuclides, int* n);
   int openmc_tally_get_scores(int32_t index, int** scores, int* n);
@@ -104,7 +104,7 @@ extern "C" {
   int openmc_tally_results(int32_t index, double** ptr, size_t shape_[3]);
   int openmc_tally_set_active(int32_t index, bool active);
   int openmc_tally_set_estimator(int32_t index, const char* estimator);
-  int openmc_tally_set_filters(int32_t index, int n, const int32_t* indices);
+  int openmc_tally_set_filters(int32_t index, size_t n, const int32_t* indices);
   int openmc_tally_set_id(int32_t index, int32_t id);
   int openmc_tally_set_nuclides(int32_t index, int n, const char** nuclides);
   int openmc_tally_set_scores(int32_t index, int n, const char** scores);
diff --git a/include/openmc/tallies/tally.h b/include/openmc/tallies/tally.h
index 969c064e7..be7666d5c 100644
--- a/include/openmc/tallies/tally.h
+++ b/include/openmc/tallies/tally.h
@@ -2,8 +2,10 @@
 #define OPENMC_TALLIES_TALLY_H
 
 #include "openmc/constants.h"
+#include "openmc/tallies/filter.h"
 #include "openmc/tallies/trigger.h"
 
+#include <gsl/gsl>
 #include "pugixml.hpp"
 #include "xtensor/xfixed.hpp"
 #include "xtensor/xtensor.hpp"
@@ -21,16 +23,22 @@ namespace openmc {
 
 class Tally {
 public:
-  Tally();
+  explicit Tally(int32_t id);
+
+  static Tally* create(int32_t id = -1);
 
   void init_from_xml(pugi::xml_node node);
 
+  void set_id(int32_t id);
+
   void set_scores(pugi::xml_node node);
 
-  void set_scores(std::vector<std::string> scores);
+  void set_scores(const std::vector<std::string>& scores);
 
   void set_nuclides(pugi::xml_node node);
 
+  void set_nuclides(const std::vector<std::string>& nuclides);
+
   //----------------------------------------------------------------------------
   // Methods for getting and setting filter/stride data.
 
@@ -38,7 +46,7 @@ public:
 
   int32_t filters(int i) const {return filters_[i];}
 
-  void set_filters(const int32_t filter_indices[], int n);
+  void set_filters(gsl::span<Filter*> filters);
 
   int32_t strides(int i) const {return strides_[i];}
 
@@ -112,6 +120,8 @@ private:
   std::vector<int32_t> strides_;
 
   int32_t n_filter_bins_ {0};
+
+  gsl::index index_;
 };
 
 //==============================================================================
diff --git a/openmc/capi/filter.py b/openmc/capi/filter.py
index 404cd3898..bda3c3178 100644
--- a/openmc/capi/filter.py
+++ b/openmc/capi/filter.py
@@ -94,6 +94,7 @@ _dll.openmc_zernike_filter_set_order.restype = c_int
 _dll.openmc_zernike_filter_set_order.errcheck = _error_handler
 _dll.tally_filters_size.restype = c_size_t
 
+
 class Filter(_FortranObjectWithID):
     __instances = WeakValueDictionary()
 
diff --git a/openmc/capi/tally.py b/openmc/capi/tally.py
index 9529a31f2..88c14e449 100644
--- a/openmc/capi/tally.py
+++ b/openmc/capi/tally.py
@@ -36,7 +36,7 @@ _dll.openmc_tally_get_id.argtypes = [c_int32, POINTER(c_int32)]
 _dll.openmc_tally_get_id.restype = c_int
 _dll.openmc_tally_get_id.errcheck = _error_handler
 _dll.openmc_tally_get_filters.argtypes = [
-    c_int32, POINTER(POINTER(c_int32)), POINTER(c_int)]
+    c_int32, POINTER(POINTER(c_int32)), POINTER(c_size_t)]
 _dll.openmc_tally_get_filters.restype = c_int
 _dll.openmc_tally_get_filters.errcheck = _error_handler
 _dll.openmc_tally_get_n_realizations.argtypes = [c_int32, POINTER(c_int32)]
@@ -63,7 +63,7 @@ _dll.openmc_tally_results.errcheck = _error_handler
 _dll.openmc_tally_set_active.argtypes = [c_int32, c_bool]
 _dll.openmc_tally_set_active.restype = c_int
 _dll.openmc_tally_set_active.errcheck = _error_handler
-_dll.openmc_tally_set_filters.argtypes = [c_int32, c_int, POINTER(c_int32)]
+_dll.openmc_tally_set_filters.argtypes = [c_int32, c_size_t, POINTER(c_int32)]
 _dll.openmc_tally_set_filters.restype = c_int
 _dll.openmc_tally_set_filters.errcheck = _error_handler
 _dll.openmc_tally_set_estimator.argtypes = [c_int32, c_char_p]
@@ -249,7 +249,7 @@ class Tally(_FortranObjectWithID):
     @property
     def filters(self):
         filt_idx = POINTER(c_int32)()
-        n = c_int()
+        n = c_size_t()
         _dll.openmc_tally_get_filters(self._index, filt_idx, n)
         return [_get_filter(filt_idx[i]) for i in range(n.value)]
 
diff --git a/src/tallies/filter.cpp b/src/tallies/filter.cpp
index 36a36044a..0b792da1b 100644
--- a/src/tallies/filter.cpp
+++ b/src/tallies/filter.cpp
@@ -143,13 +143,27 @@ Filter* Filter::create(const std::string& type, int32_t id)
 
 void Filter::set_id(int32_t id)
 {
-  Expects(id >= 0);
+  Expects(id >= -1);
+
+  // Clear entry in filter map if an ID was already assigned before
+  if (id_ != -1) {
+    model::filter_map.erase(id_);
+    id_ = -1;
+  }
+
+  // Make sure no other filter has same ID
   if (model::filter_map.find(id) != model::filter_map.end()) {
     throw std::runtime_error{"Two filters have the same ID: " + std::to_string(id)};
   }
 
-  // Clear entry in filter map if an ID was already assigned before
-  if (id_ != -1) model::filter_map.erase(id_);
+  // If no ID specified, auto-assign next ID in sequence
+  if (id == -1) {
+    id = 0;
+    for (const auto& f : model::tally_filters) {
+      id = std::max(id, f->id_);
+    }
+    ++id;
+  }
 
   // Update ID and entry in filter map
   id_ = id;
@@ -183,13 +197,7 @@ openmc_filter_set_id(int32_t index, int32_t id)
 {
   if (int err = verify_filter(index)) return err;
 
-  if (model::filter_map.find(id) != model::filter_map.end()) {
-    set_errmsg("Two filters have the same ID: " + std::to_string(id));
-    return OPENMC_E_INVALID_ID;
-  }
-
-  model::tally_filters[index]->id_ = id;
-  model::filter_map[id] = index;
+  model::tally_filters[index]->set_id(id);
   return 0;
 }
 
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index a4cb04169..05004ad96 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -240,9 +240,18 @@ score_str_to_int(std::string score_str)
 // Tally object implementation
 //==============================================================================
 
-Tally::Tally()
+Tally::Tally(int32_t id)
+  : index_{model::tallies.size()}
 {
-  this->set_filters(nullptr, 0);
+  this->set_id(id);
+  this->set_filters({});
+}
+
+Tally*
+Tally::create(int32_t id)
+{
+  model::tallies.push_back(std::make_unique<Tally>(id));
+  return model::tallies.back().get();
 }
 
 void
@@ -252,25 +261,55 @@ Tally::init_from_xml(pugi::xml_node node)
 }
 
 void
-Tally::set_filters(const int32_t filter_indices[], int n)
+Tally::set_id(int32_t id)
+{
+  Expects(id >= -1);
+
+  // Clear entry in tally map if an ID was already assigned before
+  if (id_ != -1) {
+    model::tally_map.erase(id_);
+    id_ = -1;
+  }
+
+  // Make sure no other tally has the same ID
+  if (model::tally_map.find(id) != model::tally_map.end()) {
+    throw std::runtime_error{"Two tallies have the same ID: " + std::to_string(id)};
+  }
+
+  // If no ID specified, auto-assign next ID in sequence
+  if (id == -1) {
+    id = 0;
+    for (const auto& t : model::tallies) {
+      id = std::max(id, t->id_);
+    }
+    ++id;
+  }
+
+  // Update ID and entry in tally map
+  id_ = id;
+  model::tally_map[id] = index_;
+}
+
+void
+Tally::set_filters(gsl::span<Filter*> filters)
 {
   // Clear old data.
   filters_.clear();
   strides_.clear();
 
   // Copy in the given filter indices.
-  filters_.assign(filter_indices, filter_indices + n);
+  auto n = filters.size();
+  filters_.reserve(n);
 
   for (int i = 0; i < n; ++i) {
-    auto i_filt = filters_[i];
-    if (i_filt < 0 || i_filt >= model::tally_filters.size())
-      throw std::out_of_range("Index in tally filter array out of bounds.");
+    // Add index to vector of filters
+    auto& f {filters[i]};
+    filters_.push_back(model::filter_map.at(f->id_));
 
     // Keep track of indices for special filters.
-    const auto* filt = model::tally_filters[i_filt].get();
-    if (dynamic_cast<const EnergyoutFilter*>(filt)) {
+    if (dynamic_cast<const EnergyoutFilter*>(f)) {
       energyout_filter_ = i;
-    } else if (dynamic_cast<const DelayedGroupFilter*>(filt)) {
+    } else if (dynamic_cast<const DelayedGroupFilter*>(f)) {
       delayedgroup_filter_ = i;
     }
   }
@@ -298,7 +337,7 @@ Tally::set_scores(pugi::xml_node node)
 }
 
 void
-Tally::set_scores(std::vector<std::string> scores)
+Tally::set_scores(const std::vector<std::string>& scores)
 {
   // Reset state and prepare for the new scores.
   scores_.clear();
@@ -450,17 +489,25 @@ Tally::set_nuclides(pugi::xml_node node)
     // The user provided specifics nuclides.  Parse it as an array with either
     // "total" or a nuclide name like "U-235" in each position.
     auto words = get_node_array<std::string>(node, "nuclides");
-    for (auto word : words) {
-      if (word == "total") {
-        nuclides_.push_back(-1);
-      } else {
-        auto search = data::nuclide_map.find(word);
-        if (search == data::nuclide_map.end())
-          fatal_error("Could not find the nuclide " + word
-            + " specified in tally " + std::to_string(id_)
-            + " in any material");
-        nuclides_.push_back(search->second);
-      }
+    this->set_nuclides(words);
+  }
+}
+
+void
+Tally::set_nuclides(const std::vector<std::string>& nuclides)
+{
+  nuclides_.clear();
+
+  for (const auto& nuc : nuclides) {
+    if (nuc == "total") {
+      nuclides_.push_back(-1);
+    } else {
+      auto search = data::nuclide_map.find(nuc);
+      if (search == data::nuclide_map.end())
+        fatal_error("Could not find the nuclide " + nuc
+          + " specified in tally " + std::to_string(id_)
+          + " in any material");
+      nuclides_.push_back(search->second);
     }
   }
 }
@@ -628,22 +675,14 @@ void read_tallies_xml()
   }
 
   for (auto node_tal : root.children("tally")) {
-    model::tallies.push_back(std::make_unique<Tally>());
-
-    auto& t {model::tallies.back()};
-    t->init_from_xml(node_tal);
-
     // Copy and set tally id
     if (!check_for_node(node_tal, "id")) {
       fatal_error("Must specify id for tally in tally XML file.");
     }
-    t->id_ = std::stoi(get_node_value(node_tal, "id"));
-    model::tally_map[t->id_] = model::tallies.size() - 1;
+    int32_t id = std::stoi(get_node_value(node_tal, "id"));
 
-    // Copy tally name
-    if (check_for_node(node_tal, "name")) {
-      t->name_ = get_node_value(node_tal, "name");
-    }
+    auto t = Tally::create(id);
+    t->init_from_xml(node_tal);
 
     // =======================================================================
     // READ DATA FOR FILTERS
@@ -665,7 +704,7 @@ void read_tallies_xml()
 
     // Allocate and store filter user ids
     if (!filters.empty()) {
-      std::vector<int> filter_indices;
+      std::vector<Filter*> filter_ptrs;
       for (int filter_id : filters) {
         // Determine if filter ID is valid
         auto it = model::filter_map.find(filter_id);
@@ -675,11 +714,11 @@ void read_tallies_xml()
         }
 
         // Store the index of the filter
-        filter_indices.push_back(it->second);
+        filter_ptrs.push_back(model::tally_filters[it->second].get());
       }
 
       // Set the filters
-      t->set_filters(filter_indices.data(), filter_indices.size());
+      t->set_filters(filter_ptrs);
     }
 
     // Check for the presence of certain filter types
@@ -1028,7 +1067,7 @@ openmc_extend_tallies(int32_t n, int32_t* index_start, int32_t* index_end)
   if (index_start) *index_start = model::tallies.size();
   if (index_end) *index_end = model::tallies.size() + n - 1;
   for (int i = 0; i < n; ++i) {
-    model::tallies.push_back(std::make_unique<Tally>());
+    model::tallies.push_back(std::make_unique<Tally>(-1));
   }
   return 0;
 }
@@ -1112,14 +1151,7 @@ openmc_tally_set_id(int32_t index, int32_t id)
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  if (model::tally_map.find(id) != model::tally_map.end()) {
-    set_errmsg("Two or more tallies use the same unique ID: "
-      + std::to_string(id));
-    return OPENMC_E_INVALID_ID;
-  }
-
-  model::tallies[index]->id_ = id;
-  model::tally_map[id] = index;
+  model::tallies[index]->set_id(id);
   return 0;
 }
 
@@ -1259,7 +1291,7 @@ openmc_tally_set_nuclides(int32_t index, int n, const char** nuclides)
 }
 
 extern "C" int
-openmc_tally_get_filters(int32_t index, const int32_t** indices, int* n)
+openmc_tally_get_filters(int32_t index, const int32_t** indices, size_t* n)
 {
   if (index < 0 || index >= model::tallies.size()) {
     set_errmsg("Index in tallies array is out of bounds.");
@@ -1272,7 +1304,7 @@ openmc_tally_get_filters(int32_t index, const int32_t** indices, int* n)
 }
 
 extern "C" int
-openmc_tally_set_filters(int32_t index, int n, const int32_t* indices)
+openmc_tally_set_filters(int32_t index, size_t n, const int32_t* indices)
 {
   // Make sure the index fits in the array bounds.
   if (index < 0 || index >= model::tallies.size()) {
@@ -1282,9 +1314,15 @@ openmc_tally_set_filters(int32_t index, int n, const int32_t* indices)
 
   // Set the filters.
   try {
-    model::tallies[index]->set_filters(indices, n);
+    // Convert indices to filter pointers
+    std::vector<Filter*> filters;
+    for (gsl::index i = 0; i < n; ++i) {
+      int32_t i_filt = indices[i];
+      filters.push_back(model::tally_filters.at(i_filt).get());
+    }
+    model::tallies[index]->set_filters(filters);
   } catch (const std::out_of_range& ex) {
-    set_errmsg(ex.what());
+    set_errmsg("Index in tally filter array out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 

From b0704a674f7c72b1fa6040df3e4165ed5ddf47bd Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 3 Jul 2019 21:47:36 -0500
Subject: [PATCH 017/127] Add Tally::set_active method

---
 include/openmc/tallies/tally.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/openmc/tallies/tally.h b/include/openmc/tallies/tally.h
index be7666d5c..a67204b59 100644
--- a/include/openmc/tallies/tally.h
+++ b/include/openmc/tallies/tally.h
@@ -31,6 +31,8 @@ public:
 
   void set_id(int32_t id);
 
+  void set_active(bool active) { active_ = active; }
+
   void set_scores(pugi::xml_node node);
 
   void set_scores(const std::vector<std::string>& scores);

From 0e15cb58d3d05a2e8062a6b73aaa14a1960a1eec Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 3 Jul 2019 21:59:27 -0500
Subject: [PATCH 018/127] Add getter for MaterialFilter::materials_

---
 include/openmc/tallies/filter_material.h | 10 ++++++++--
 src/tallies/filter_material.cpp          |  4 ++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/include/openmc/tallies/filter_material.h b/include/openmc/tallies/filter_material.h
index 34dffa2b8..97d0b2f8d 100644
--- a/include/openmc/tallies/filter_material.h
+++ b/include/openmc/tallies/filter_material.h
@@ -27,12 +27,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_materials(gsl::span<const int32_t> materials);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  // Accessors
+  std::vector<int32_t>& materials() { return materials_; }
+
+  const std::vector<int32_t>& materials() const { return materials_; }
+
+  void set_materials(gsl::span<const int32_t> materials);
+
+private:
   //! The indices of the materials binned by this filter.
   std::vector<int32_t> materials_;
 
diff --git a/src/tallies/filter_material.cpp b/src/tallies/filter_material.cpp
index c9fd644ad..c44ee0d28 100644
--- a/src/tallies/filter_material.cpp
+++ b/src/tallies/filter_material.cpp
@@ -93,8 +93,8 @@ openmc_material_filter_get_bins(int32_t index, int32_t** bins, size_t* n)
   }
 
   // Output the bins.
-  *bins = filt->materials_.data();
-  *n = filt->materials_.size();
+  *bins = filt->materials().data();
+  *n = filt->materials().size();
   return 0;
 }
 

From 4815cfebacd42099e1a5bc00c69044a4622b1c95 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 3 Jul 2019 22:21:10 -0500
Subject: [PATCH 019/127] Move openmc_material_add_nuclide into
 Material::add_nuclide

---
 include/openmc/material.h |  6 ++++
 src/material.cpp          | 76 +++++++++++++++++++++------------------
 2 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/include/openmc/material.h b/include/openmc/material.h
index 3109f6d78..107f436c9 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -59,6 +59,12 @@ public:
   //! Finalize the material, assigning tables, normalize density, etc.
   void finalize();
 
+  //! Add nuclide to the material
+  //
+  //! \param[in] nuclide Name of the nuclide
+  //! \param[in] density Density of the nuclide in [atom/b-cm]
+  void add_nuclide(const std::string& nuclide, double density);
+
   //! Set total density of the material
   int set_density(double density, std::string units);
 
diff --git a/src/material.cpp b/src/material.cpp
index ccbbe57a8..9e6240560 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -945,6 +945,44 @@ void Material::to_hdf5(hid_t group) const
   close_group(material_group);
 }
 
+void Material::add_nuclide(const std::string& name, double density)
+{
+  // Check if nuclide is already in material
+  for (int i = 0; i < nuclide_.size(); ++i) {
+    int i_nuc = nuclide_[i];
+    if (data::nuclides[i_nuc]->name_ == name) {
+      double awr = data::nuclides[i_nuc]->awr_;
+      density_ += density - atom_density_(i);
+      density_gpcc_ += (density - atom_density_(i))
+        * awr * MASS_NEUTRON / N_AVOGADRO;
+      atom_density_(i) = density;
+      return;
+    }
+  }
+
+  // If nuclide wasn't found, extend nuclide/density arrays
+  int err = openmc_load_nuclide(name.c_str());
+  if (err < 0) {
+    throw std::runtime_error{openmc_err_msg};
+  }
+
+  // Append new nuclide/density
+  int i_nuc = data::nuclide_map[name];
+  nuclide_.push_back(i_nuc);
+
+  auto n = nuclide_.size();
+
+  // Create copy of atom_density_ array with one extra entry
+  xt::xtensor<double, 1> atom_density = xt::zeros<double>({n});
+  xt::view(atom_density, xt::range(0, n-1)) = atom_density_;
+  atom_density(n-1) = density;
+  atom_density_ = atom_density;
+
+  density_ += density;
+  density_gpcc_ += density * data::nuclides[i_nuc]->awr_
+    * MASS_NEUTRON / N_AVOGADRO;
+}
+
 //==============================================================================
 // Non-method functions
 //==============================================================================
@@ -1141,40 +1179,10 @@ openmc_material_add_nuclide(int32_t index, const char* name, double density)
 {
   int err = 0;
   if (index >= 0 && index < model::materials.size()) {
-    auto& m = model::materials[index];
-
-    // Check if nuclide is already in material
-    for (int i = 0; i < m->nuclide_.size(); ++i) {
-      int i_nuc = m->nuclide_[i];
-      if (data::nuclides[i_nuc]->name_ == name) {
-        double awr = data::nuclides[i_nuc]->awr_;
-        m->density_ += density - m->atom_density_(i);
-        m->density_gpcc_ += (density - m->atom_density_(i))
-          * awr * MASS_NEUTRON / N_AVOGADRO;
-        m->atom_density_(i) = density;
-        return 0;
-      }
-    }
-
-    // If nuclide wasn't found, extend nuclide/density arrays
-    err = openmc_load_nuclide(name);
-
-    if (err == 0) {
-      // Append new nuclide/density
-      int i_nuc = data::nuclide_map[name];
-      m->nuclide_.push_back(i_nuc);
-
-      auto n = m->nuclide_.size();
-
-      // Create copy of atom_density_ array with one extra entry
-      xt::xtensor<double, 1> atom_density = xt::zeros<double>({n});
-      xt::view(atom_density, xt::range(0, n-1)) = m->atom_density_;
-      atom_density(n-1) = density;
-      m->atom_density_ = atom_density;
-
-      m->density_ += density;
-      m->density_gpcc_ += density * data::nuclides[i_nuc]->awr_
-        * MASS_NEUTRON / N_AVOGADRO;
+    try {
+      model::materials[index]->add_nuclide(name, density);
+    } catch (const std::runtime_error& e) {
+      return OPENMC_E_DATA;
     }
   } else {
     set_errmsg("Index in materials array is out of bounds.");

From 5d3afc11107cef825a4e652b8d4870d75bb16cbf Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 3 Jul 2019 22:34:06 -0500
Subject: [PATCH 020/127] Add accessors for Material.density_ and density_gpcc_

---
 include/openmc/material.h | 8 ++++++++
 src/material.cpp          | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/include/openmc/material.h b/include/openmc/material.h
index 107f436c9..2454de071 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -65,6 +65,14 @@ public:
   //! \param[in] density Density of the nuclide in [atom/b-cm]
   void add_nuclide(const std::string& nuclide, double density);
 
+  //! Get density in [atom/b-cm]
+  //! \return Density in [atom/b-cm]
+  double density() const { return density_; }
+
+  //! Get density in [g/cm^3]
+  //! \return Density in [g/cm^3]
+  double density_gpcc() const { return density_gpcc_; }
+
   //! Set total density of the material
   int set_density(double density, std::string units);
 
diff --git a/src/material.cpp b/src/material.cpp
index 9e6240560..45d000d4a 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1216,7 +1216,7 @@ openmc_material_get_density(int32_t index, double* density)
 {
   if (index >= 0 && index < model::materials.size()) {
     auto& mat = model::materials[index];
-    *density = mat->density_gpcc_;
+    *density = mat->density_gpcc();
     return 0;
   } else {
     set_errmsg("Index in materials array is out of bounds.");

From 1c97438be0722ff397f3805553476c7c6c4bde44 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 3 Jul 2019 22:47:46 -0500
Subject: [PATCH 021/127] Remove return value on Material::set_density

---
 include/openmc/material.h |  6 +++++-
 src/material.cpp          | 22 +++++++++++++---------
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/include/openmc/material.h b/include/openmc/material.h
index 2454de071..5c8d9006e 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include <gsl/gsl>
 #include <hdf5.h>
 #include "pugixml.hpp"
 #include "xtensor/xtensor.hpp"
@@ -74,7 +75,10 @@ public:
   double density_gpcc() const { return density_gpcc_; }
 
   //! Set total density of the material
-  int set_density(double density, std::string units);
+  //
+  //! \param[in] density Density value
+  //! \param[in] units Units of density
+  void set_density(double density, gsl::cstring_span units);
 
   //! Write material data to HDF5
   void to_hdf5(hid_t group) const;
diff --git a/src/material.cpp b/src/material.cpp
index 45d000d4a..2c400b413 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -849,11 +849,10 @@ void Material::calculate_photon_xs(Particle& p) const
   }
 }
 
-int Material::set_density(double density, std::string units)
+void Material::set_density(double density, gsl::cstring_span units)
 {
   if (nuclide_.empty()) {
-    set_errmsg("No nuclides exist in material yet.");
-    return OPENMC_E_ALLOCATE;
+    throw std::runtime_error{"No nuclides exist in material yet."};
   }
 
   if (units == "atom/b-cm") {
@@ -884,10 +883,9 @@ int Material::set_density(double density, std::string units)
     density_ *= f;
     atom_density_ *= f;
   } else {
-    set_errmsg("Invalid units '" + units + "' specified.");
-    return OPENMC_E_INVALID_ARGUMENT;
+    throw std::invalid_argument{"Invalid units '" + std::string(units.data())
+      + "' specified."};
   }
-  return 0;
 }
 
 void Material::to_hdf5(hid_t group) const
@@ -1272,11 +1270,17 @@ extern "C" int
 openmc_material_set_density(int32_t index, double density, const char* units)
 {
   if (index >= 0 && index < model::materials.size()) {
-    return model::materials[index]->set_density(density, units);
+    try {
+      model::materials[index]->set_density(density, units);
+    } catch (const std::exception& e) {
+      set_errmsg(e.what());
+      return OPENMC_E_UNASSIGNED;
+    }
   } else {
     set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
+  return 0;
 }
 
 extern "C" int
@@ -1303,11 +1307,11 @@ openmc_material_set_densities(int32_t index, int n, const char** name, const dou
     }
 
     // Set total density to the sum of the vector
-    int err = mat->set_density(sum_density, "atom/b-cm");
+    mat->set_density(sum_density, "atom/b-cm");
 
     // Assign S(a,b) tables
     mat->init_thermal();
-    return err;
+    return 0;
   } else {
     set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;

From bbf529bef03ccab57db1808efb42fd70aaa07395 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 3 Jul 2019 23:08:08 -0500
Subject: [PATCH 022/127] Add Material::volume() accessor function

---
 include/openmc/material.h |  4 ++++
 src/material.cpp          | 22 ++++++++++++++--------
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/include/openmc/material.h b/include/openmc/material.h
index 5c8d9006e..ab9987827 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -80,6 +80,10 @@ public:
   //! \param[in] units Units of density
   void set_density(double density, gsl::cstring_span units);
 
+  //! Get volume of material
+  //! \return Volume in [cm^3]
+  double volume() const;
+
   //! Write material data to HDF5
   void to_hdf5(hid_t group) const;
 
diff --git a/src/material.cpp b/src/material.cpp
index 2c400b413..701cb8d50 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -888,6 +888,15 @@ void Material::set_density(double density, gsl::cstring_span units)
   }
 }
 
+double Material::volume() const
+{
+  if (volume_ < 0.0) {
+    throw std::runtime_error{"Volume for material with ID="
+      + std::to_string(id_) + " not set."};
+  }
+  return volume_;
+}
+
 void Material::to_hdf5(hid_t group) const
 {
   hid_t material_group = create_group(group, "material " + std::to_string(id_));
@@ -1250,16 +1259,13 @@ extern "C" int
 openmc_material_get_volume(int32_t index, double* volume)
 {
   if (index >= 0 && index < model::materials.size()) {
-    auto& m = model::materials[index];
-    if (m->volume_ >= 0.0) {
-      *volume = m->volume_;
-      return 0;
-    } else {
-      std::stringstream msg;
-      msg << "Volume for material with ID=" << m->id_ << " not set.";
-      set_errmsg(msg);
+    try {
+      *volume = model::materials[index]->volume();
+    } catch (const std::exception& e) {
+      set_errmsg(e.what());
       return OPENMC_E_UNASSIGNED;
     }
+    return 0;
   } else {
     set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;

From 0c3247055127ef01a3cc62b16596810ea09b88a0 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 5 Jul 2019 08:00:12 -0500
Subject: [PATCH 023/127] Finish improving Material interface

---
 include/openmc/capi.h           |   2 +-
 include/openmc/material.h       |  31 +++++++
 include/openmc/tallies/filter.h |   4 +-
 openmc/capi/error.py            |   4 +-
 src/material.cpp                | 138 ++++++++++++++++++++------------
 tests/unit_tests/test_capi.py   |   2 +-
 6 files changed, 125 insertions(+), 56 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index fba653818..1f1d65cf5 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -48,7 +48,7 @@ extern "C" {
   int openmc_legendre_filter_set_order(int32_t index, int order);
   int openmc_load_nuclide(const char* name);
   int openmc_material_add_nuclide(int32_t index, const char name[], double density);
-  int openmc_material_get_densities(int32_t index, int** nuclides, double** densities, int* n);
+  int openmc_material_get_densities(int32_t index, const int** nuclides, const double** densities, int* n);
   int openmc_material_get_id(int32_t index, int32_t* id);
   int openmc_material_get_fissionable(int32_t index, bool* fissionable);
   int openmc_material_get_density(int32_t index, double* density);
diff --git a/include/openmc/material.h b/include/openmc/material.h
index ab9987827..0cf9ef72a 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -80,6 +80,34 @@ public:
   //! \param[in] units Units of density
   void set_density(double density, gsl::cstring_span units);
 
+  //! Get nuclides in material
+  //! \return Indices into the global nuclides vector
+  gsl::span<const int> nuclides() const { return {nuclide_.data(), nuclide_.size()}; }
+
+  //! Get densities of each nuclide in material
+  //! \return Densities in [atom/b-cm]
+  gsl::span<const double> densities() const { return {atom_density_.data(), atom_density_.size()}; }
+
+  //! Set atom densities for the material
+  //
+  //! \param[in] name Name of each nuclide
+  //! \param[in] density Density of each nuclide in [atom/b-cm]
+  void set_densities(const std::vector<std::string>& name,
+    const std::vector<double>& density);
+
+  //! Get ID of material
+  //! \return ID of material
+  int32_t id() const { return id_; }
+
+  //! Assign a unique ID to the material
+  //! \param[in] Unique ID to assign. A value of -1 indicates that an ID
+  //!   should be automatically assigned.
+  void set_id(int32_t id);
+
+  //! Get whether material is fissionable
+  //! \return Whether material is fissionable
+  bool fissionable() const { return fissionable_; }
+
   //! Get volume of material
   //! \return Volume in [cm^3]
   double volume() const;
@@ -128,6 +156,9 @@ private:
 
   void calculate_neutron_xs(Particle& p) const;
   void calculate_photon_xs(Particle& p) const;
+
+  // Data members
+  gsl::index index_;
 };
 
 //==============================================================================
diff --git a/include/openmc/tallies/filter.h b/include/openmc/tallies/filter.h
index 2c0dc2aa2..9bf7df0b7 100644
--- a/include/openmc/tallies/filter.h
+++ b/include/openmc/tallies/filter.h
@@ -77,8 +77,8 @@ public:
   get_all_bins(const Particle* p, int estimator, FilterMatch& match) const = 0;
 
   //! Assign a unique ID to the filter
-  //
-  //! \param[in]  Unique ID to assign
+  //! \param[in]  Unique ID to assign. A value of -1 indicates that an ID should
+  //!   be automatically assigned
   void set_id(int32_t id);
 
   gsl::index index() const { return index_; }
diff --git a/openmc/capi/error.py b/openmc/capi/error.py
index b35de4e60..89e7b6e39 100644
--- a/openmc/capi/error.py
+++ b/openmc/capi/error.py
@@ -36,4 +36,6 @@ def _error_handler(err, func, args):
     elif err == errcode('OPENMC_E_WARNING'):
         warn(msg)
     elif err < 0:
-        raise exc.OpenMCError("Unknown error encountered (code {}).".format(err))
+        if not msg:
+            msg = "Unknown error encountered (code {}).".format(err)
+        raise exc.OpenMCError(msg)
diff --git a/src/material.cpp b/src/material.cpp
index 701cb8d50..40d0bc438 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -47,9 +47,10 @@ std::unordered_map<int32_t, int32_t> material_map;
 //==============================================================================
 
 Material::Material(pugi::xml_node node)
+  : index_{model::materials.size()}
 {
   if (check_for_node(node, "id")) {
-    id_ = std::stoi(get_node_value(node, "id"));
+    this->set_id(std::stoi(get_node_value(node, "id")));
   } else {
     fatal_error("Must specify id of material in materials XML file.");
   }
@@ -849,8 +850,39 @@ void Material::calculate_photon_xs(Particle& p) const
   }
 }
 
+void Material::set_id(int32_t id)
+{
+  Expects(id >= -1);
+
+  // Clear entry in material map if an ID was already assigned before
+  if (id_ != -1) {
+    model::material_map.erase(id_);
+    id_ = -1;
+  }
+
+  // Make sure no other material has same ID
+  if (model::material_map.find(id) != model::material_map.end()) {
+    throw std::runtime_error{"Two materials have the same ID: " + std::to_string(id)};
+  }
+
+  // If no ID specified, auto-assign next ID in sequence
+  if (id == -1) {
+    id = 0;
+    for (const auto& f : model::materials) {
+      id = std::max(id, f->id_);
+    }
+    ++id;
+  }
+
+  // Update ID and entry in material map
+  id_ = id;
+  model::material_map[id] = index_;
+}
+
 void Material::set_density(double density, gsl::cstring_span units)
 {
+  Expects(density >= 0.0);
+
   if (nuclide_.empty()) {
     throw std::runtime_error{"No nuclides exist in material yet."};
   }
@@ -888,6 +920,39 @@ void Material::set_density(double density, gsl::cstring_span units)
   }
 }
 
+void Material::set_densities(const std::vector<std::string>& name,
+  const std::vector<double>& density)
+{
+  auto n = name.size();
+  Expects(n > 0);
+  Expects(n == density.size());
+
+  if (n != nuclide_.size()) {
+    nuclide_.resize(n);
+    atom_density_ = xt::zeros<double>({n});
+  }
+
+  double sum_density = 0.0;
+  for (gsl::index i = 0; i < n; ++i) {
+    const auto& nuc {name[i]};
+    if (data::nuclide_map.find(nuc) == data::nuclide_map.end()) {
+      int err = openmc_load_nuclide(nuc.c_str());
+      if (err < 0) throw std::runtime_error{openmc_err_msg};
+    }
+
+    nuclide_[i] = data::nuclide_map.at(nuc);
+    Expects(density[i] > 0.0);
+    atom_density_(i) = density[i];
+    sum_density += density[i];
+  }
+
+  // Set total density to the sum of the vector
+  this->set_density(sum_density, "atom/b-cm");
+
+  // Assign S(a,b) tables
+  this->init_thermal();
+}
+
 double Material::volume() const
 {
   if (volume_ < 0.0) {
@@ -969,9 +1034,7 @@ void Material::add_nuclide(const std::string& name, double density)
 
   // If nuclide wasn't found, extend nuclide/density arrays
   int err = openmc_load_nuclide(name.c_str());
-  if (err < 0) {
-    throw std::runtime_error{openmc_err_msg};
-  }
+  if (err < 0) throw std::runtime_error{openmc_err_msg};
 
   // Append new nuclide/density
   int i_nuc = data::nuclide_map[name];
@@ -1143,19 +1206,6 @@ void read_materials_xml()
     model::materials.push_back(std::make_unique<Material>(material_node));
   }
   model::materials.shrink_to_fit();
-
-  // Populate the material map.
-  for (int i = 0; i < model::materials.size(); i++) {
-    int32_t mid = model::materials[i]->id_;
-    auto search = model::material_map.find(mid);
-    if (search == model::material_map.end()) {
-      model::material_map[mid] = i;
-    } else {
-      std::stringstream err_msg;
-      err_msg << "Two or more materials use the same unique ID: " << mid;
-      fatal_error(err_msg);
-    }
-  }
 }
 
 void free_memory_material()
@@ -1199,14 +1249,14 @@ openmc_material_add_nuclide(int32_t index, const char* name, double density)
 }
 
 extern "C" int
-openmc_material_get_densities(int32_t index, int** nuclides, double** densities, int* n)
+openmc_material_get_densities(int32_t index, const int** nuclides, const double** densities, int* n)
 {
   if (index >= 0 && index < model::materials.size()) {
     auto& mat = model::materials[index];
-    if (!mat->nuclide_.empty()) {
-      *nuclides = mat->nuclide_.data();
-      *densities = mat->atom_density_.data();
-      *n = mat->nuclide_.size();
+    if (!mat->nuclides().empty()) {
+      *nuclides = mat->nuclides().data();
+      *densities = mat->densities().data();
+      *n = mat->nuclides().size();
       return 0;
     } else {
       set_errmsg("Material atom density array has not been allocated.");
@@ -1235,7 +1285,7 @@ extern "C" int
 openmc_material_get_fissionable(int32_t index, bool* fissionable)
 {
   if (index >= 0 && index < model::materials.size()) {
-    *fissionable = model::materials[index]->fissionable_;
+    *fissionable = model::materials[index]->fissionable();
     return 0;
   } else {
     set_errmsg("Index in materials array is out of bounds.");
@@ -1247,7 +1297,7 @@ extern "C" int
 openmc_material_get_id(int32_t index, int32_t* id)
 {
   if (index >= 0 && index < model::materials.size()) {
-    *id = model::materials[index]->id_;
+    *id = model::materials[index]->id();
     return 0;
   } else {
     set_errmsg("Index in materials array is out of bounds.");
@@ -1293,48 +1343,34 @@ extern "C" int
 openmc_material_set_densities(int32_t index, int n, const char** name, const double* density)
 {
   if (index >= 0 && index < model::materials.size()) {
-    auto& mat {model::materials[index]};
-    if (n != mat->nuclide_.size()) {
-      mat->nuclide_.resize(n);
-      mat->atom_density_ = xt::zeros<double>({n});
+    try {
+      model::materials[index]->set_densities({name, name + n}, {density, density + n});
+    } catch (const std::exception& e) {
+      set_errmsg(e.what());
+      return OPENMC_E_UNASSIGNED;
     }
-
-    double sum_density = 0.0;
-    for (int i = 0; i < n; ++i) {
-      std::string nuc {name[i]};
-      if (data::nuclide_map.find(nuc) == data::nuclide_map.end()) {
-        int err = openmc_load_nuclide(nuc.c_str());
-        if (err < 0) return err;
-      }
-
-      mat->nuclide_[i] = data::nuclide_map[nuc];
-      mat->atom_density_(i) = density[i];
-      sum_density += density[i];
-    }
-
-    // Set total density to the sum of the vector
-    mat->set_density(sum_density, "atom/b-cm");
-
-    // Assign S(a,b) tables
-    mat->init_thermal();
-    return 0;
   } else {
     set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
+  return 0;
 }
 
 extern "C" int
 openmc_material_set_id(int32_t index, int32_t id)
 {
   if (index >= 0 && index < model::materials.size()) {
-    model::materials[index]->id_ = id;
-    model::material_map[id] = index;
-    return 0;
+    try {
+      model::materials.at(index)->set_id(id);
+    } catch (const std::exception& e) {
+      set_errmsg(e.what());
+      return OPENMC_E_UNASSIGNED;
+    }
   } else {
     set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
+  return 0;
 }
 
 extern "C" int
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index 53ad09e90..af86a054d 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -113,7 +113,7 @@ def test_material(capi_init):
     m.volume = 10.0
     assert m.volume == 10.0
 
-    with pytest.raises(exc.InvalidArgumentError):
+    with pytest.raises(exc.OpenMCError):
         m.set_density(1.0, 'goblins')
 
     rho = 2.25e-2

From 7db1511f00a1c0c1a50990be81a03aa6669eabac Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 5 Jul 2019 21:09:04 -0500
Subject: [PATCH 024/127] Add destructors that remove key-value pairs from maps

---
 include/openmc/material.h       | 3 ++-
 include/openmc/tallies/filter.h | 2 +-
 include/openmc/tallies/tally.h  | 2 ++
 src/material.cpp                | 5 +++++
 src/tallies/filter.cpp          | 5 +++++
 src/tallies/tally.cpp           | 5 +++++
 6 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/include/openmc/material.h b/include/openmc/material.h
index 0cf9ef72a..03d76f6cc 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -43,9 +43,10 @@ public:
     double fraction; //!< How often to use table
   };
 
-  // Constructors
+  // Constructors and destructors
   Material() {};
   explicit Material(pugi::xml_node material_node);
+  ~Material();
 
   // Methods
   void calculate_xs(Particle& p) const;
diff --git a/include/openmc/tallies/filter.h b/include/openmc/tallies/filter.h
index 9bf7df0b7..905107790 100644
--- a/include/openmc/tallies/filter.h
+++ b/include/openmc/tallies/filter.h
@@ -62,7 +62,7 @@ public:
   //! \return Pointer to the new filter object
   static Filter* create(pugi::xml_node node);
 
-  virtual ~Filter() = default;
+  virtual ~Filter();
 
   virtual std::string type() const = 0;
 
diff --git a/include/openmc/tallies/tally.h b/include/openmc/tallies/tally.h
index a67204b59..3dd54f24a 100644
--- a/include/openmc/tallies/tally.h
+++ b/include/openmc/tallies/tally.h
@@ -25,6 +25,8 @@ class Tally {
 public:
   explicit Tally(int32_t id);
 
+  ~Tally();
+
   static Tally* create(int32_t id = -1);
 
   void init_from_xml(pugi::xml_node node);
diff --git a/src/material.cpp b/src/material.cpp
index 40d0bc438..74dfa152d 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -332,6 +332,11 @@ Material::Material(pugi::xml_node node)
   }
 }
 
+Material::~Material()
+{
+  model::material_map.erase(id_);
+}
+
 void Material::finalize()
 {
   // Set fissionable if any nuclide is fissionable
diff --git a/src/tallies/filter.cpp b/src/tallies/filter.cpp
index 0b792da1b..913a4debc 100644
--- a/src/tallies/filter.cpp
+++ b/src/tallies/filter.cpp
@@ -63,6 +63,11 @@ extern "C" size_t tally_filters_size()
 Filter::Filter() : index_{model::tally_filters.size()}
 { }
 
+Filter::~Filter()
+{
+  model::filter_map.erase(id_);
+}
+
 Filter* Filter::create(pugi::xml_node node)
 {
   // Copy filter id
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index 05004ad96..e2a3ef737 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -247,6 +247,11 @@ Tally::Tally(int32_t id)
   this->set_filters({});
 }
 
+Tally::~Tally()
+{
+  model::tally_map.erase(id_);
+}
+
 Tally*
 Tally::create(int32_t id)
 {

From 6e9c731b0c0c196b08a24a6af6a79ce46b9bef6b Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 5 Jul 2019 21:27:20 -0500
Subject: [PATCH 025/127] Move tally creating logic into
 Tally::Tally(pugi::xml_node)

---
 include/openmc/tallies/tally.h |   4 +-
 src/tallies/tally.cpp          | 437 +++++++++++++++++----------------
 2 files changed, 223 insertions(+), 218 deletions(-)

diff --git a/include/openmc/tallies/tally.h b/include/openmc/tallies/tally.h
index 3dd54f24a..8fe277305 100644
--- a/include/openmc/tallies/tally.h
+++ b/include/openmc/tallies/tally.h
@@ -23,10 +23,10 @@ namespace openmc {
 
 class Tally {
 public:
+  // Constructors, destructors, factory functions
   explicit Tally(int32_t id);
-
+  explicit Tally(pugi::xml_node node);
   ~Tally();
-
   static Tally* create(int32_t id = -1);
 
   void init_from_xml(pugi::xml_node node);
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index e2a3ef737..1eda7da50 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -247,6 +247,226 @@ Tally::Tally(int32_t id)
   this->set_filters({});
 }
 
+Tally::Tally(pugi::xml_node node)
+  : index_{model::tallies.size()}
+{
+  // Copy and set tally id
+  if (!check_for_node(node, "id")) {
+    throw std::runtime_error{"Must specify id for tally in tally XML file."};
+  }
+  int32_t id = std::stoi(get_node_value(node, "id"));
+  this->set_id(id);
+
+  if (check_for_node(node, "name")) name_ = get_node_value(node, "name");
+
+  // =======================================================================
+  // READ DATA FOR FILTERS
+
+  // Check if user is using old XML format and throw an error if so
+  if (check_for_node(node, "filter")) {
+    throw std::runtime_error{"Tally filters must be specified independently of "
+      "tallies in a <filter> element. The <tally> element itself should "
+      "have a list of filters that apply, e.g., <filters>1 2</filters> "
+      "where 1 and 2 are the IDs of filters specified outside of "
+      "<tally>."};
+  }
+
+  // Determine number of filters
+  std::vector<int> filter_ids;
+  if (check_for_node(node, "filters")) {
+    filter_ids = get_node_array<int>(node, "filters");
+  }
+
+  // Allocate and store filter user ids
+  std::vector<Filter*> filters;
+  if (!filter_ids.empty()) {
+    for (int filter_id : filter_ids) {
+      // Determine if filter ID is valid
+      auto it = model::filter_map.find(filter_id);
+      if (it == model::filter_map.end()) {
+        throw std::runtime_error{"Could not find filter " + std::to_string(filter_id)
+          + " specified on tally " + std::to_string(id_)};
+      }
+
+      // Store the index of the filter
+      filters.push_back(model::tally_filters[it->second].get());
+    }
+  }
+
+  // Set the filters
+  this->set_filters(filters);
+
+  // Check for the presence of certain filter types
+  bool has_energyout = energyout_filter_ >= 0;
+  int particle_filter_index = C_NONE;
+  for (gsl::index j = 0; j < filters_.size(); ++j) {
+    int i_filter = filters_[j];
+    const auto& f = model::tally_filters[i_filter].get();
+
+    auto pf = dynamic_cast<ParticleFilter*>(f);
+    if (pf) particle_filter_index = i_filter;
+
+    // Change the tally estimator if a filter demands it
+    std::string filt_type = f->type();
+    if (filt_type == "energyout" || filt_type == "legendre") {
+      estimator_ = ESTIMATOR_ANALOG;
+    } else if (filt_type == "sphericalharmonics") {
+      auto sf = dynamic_cast<SphericalHarmonicsFilter*>(f);
+      if (sf->cosine_ == SphericalHarmonicsCosine::scatter) {
+        estimator_ = ESTIMATOR_ANALOG;
+      }
+    } else if (filt_type == "spatiallegendre" || filt_type == "zernike"
+      || filt_type == "zernikeradial") {
+      estimator_ = ESTIMATOR_COLLISION;
+    }
+  }
+
+  // =======================================================================
+  // READ DATA FOR NUCLIDES
+
+  this->set_nuclides(node);
+
+  // =======================================================================
+  // READ DATA FOR SCORES
+
+  this->set_scores(node);
+
+  if (!check_for_node(node, "scores")) {
+    fatal_error("No scores specified on tally " + std::to_string(id_)
+      + ".");
+  }
+
+  // Check if tally is compatible with particle type
+  if (settings::photon_transport) {
+    if (particle_filter_index == C_NONE) {
+      for (int score : scores_) {
+        switch (score) {
+        case SCORE_INVERSE_VELOCITY:
+          fatal_error("Particle filter must be used with photon "
+            "transport on and inverse velocity score");
+          break;
+        case SCORE_FLUX:
+        case SCORE_TOTAL:
+        case SCORE_SCATTER:
+        case SCORE_NU_SCATTER:
+        case SCORE_ABSORPTION:
+        case SCORE_FISSION:
+        case SCORE_NU_FISSION:
+        case SCORE_CURRENT:
+        case SCORE_EVENTS:
+        case SCORE_DELAYED_NU_FISSION:
+        case SCORE_PROMPT_NU_FISSION:
+        case SCORE_DECAY_RATE:
+          warning("Particle filter is not used with photon transport"
+            " on and " + reaction_name(score) + " score.");
+          break;
+        }
+      }
+    } else {
+      const auto& f = model::tally_filters[particle_filter_index].get();
+      auto pf = dynamic_cast<ParticleFilter*>(f);
+      for (auto p : pf->particles_) {
+        if (p == Particle::Type::electron ||
+            p == Particle::Type::positron) {
+          estimator_ = ESTIMATOR_ANALOG;
+        }
+      }
+    }
+  } else {
+    if (particle_filter_index >= 0) {
+      const auto& f = model::tally_filters[particle_filter_index].get();
+      auto pf = dynamic_cast<ParticleFilter*>(f);
+      for (auto p : pf->particles_) {
+        if (p != Particle::Type::neutron) {
+          warning("Particle filter other than NEUTRON used with photon "
+            "transport turned off. All tallies for particle type " +
+            std::to_string(static_cast<int>(p)) + " will have no scores");
+        }
+      }
+    }
+  }
+
+  // Check for a tally derivative.
+  if (check_for_node(node, "derivative")) {
+    int deriv_id = std::stoi(get_node_value(node, "derivative"));
+
+    // Find the derivative with the given id, and store it's index.
+    auto it = model::tally_deriv_map.find(deriv_id);
+    if (it == model::tally_deriv_map.end()) {
+      fatal_error("Could not find derivative " + std::to_string(deriv_id)
+        + " specified on tally " + std::to_string(id_));
+    }
+
+    deriv_ = it->second;
+
+    // Only analog or collision estimators are supported for differential
+    // tallies.
+    if (estimator_ == ESTIMATOR_TRACKLENGTH) {
+      estimator_ = ESTIMATOR_COLLISION;
+    }
+
+    const auto& deriv = model::tally_derivs[deriv_];
+    if (deriv.variable == DIFF_NUCLIDE_DENSITY
+      || deriv.variable == DIFF_TEMPERATURE) {
+      for (int i_nuc : nuclides_) {
+        if (has_energyout && i_nuc == -1) {
+          fatal_error("Error on tally " + std::to_string(id_)
+            + ": Cannot use a 'nuclide_density' or 'temperature' "
+            "derivative on a tally with an outgoing energy filter and "
+            "'total' nuclide rate. Instead, tally each nuclide in the "
+            "material individually.");
+          // Note that diff tallies with these characteristics would work
+          // correctly if no tally events occur in the perturbed material
+          // (e.g. pertrubing moderator but only tallying fuel), but this
+          // case would be hard to check for by only reading inputs.
+        }
+      }
+    }
+  }
+
+  // If settings.xml trigger is turned on, create tally triggers
+  if (settings::trigger_on) {
+    this->init_triggers(node);
+  }
+
+  // =======================================================================
+  // SET TALLY ESTIMATOR
+
+  // Check if user specified estimator
+  if (check_for_node(node, "estimator")) {
+    std::string est = get_node_value(node, "estimator");
+    if (est == "analog") {
+      estimator_ = ESTIMATOR_ANALOG;
+    } else if (est == "tracklength" || est == "track-length"
+      || est == "pathlength" || est == "path-length") {
+      // If the estimator was set to an analog estimator, this means the
+      // tally needs post-collision information
+      if (estimator_ == ESTIMATOR_ANALOG) {
+        throw std::runtime_error{"Cannot use track-length estimator for tally "
+          + std::to_string(id_)};
+      }
+
+      // Set estimator to track-length estimator
+      estimator_ = ESTIMATOR_TRACKLENGTH;
+
+    } else if (est == "collision") {
+      // If the estimator was set to an analog estimator, this means the
+      // tally needs post-collision information
+      if (estimator_ == ESTIMATOR_ANALOG) {
+        throw std::runtime_error{"Cannot use collision estimator for tally " +
+          std::to_string(id_)};
+      }
+
+      // Set estimator to collision estimator
+      estimator_ = ESTIMATOR_COLLISION;
+
+    } else {
+      throw std::runtime_error{"Invalid estimator '" + est + "' on tally " +
+        std::to_string(id_)};
+    }
+  }
+}
+
 Tally::~Tally()
 {
   model::tally_map.erase(id_);
@@ -262,7 +482,6 @@ Tally::create(int32_t id)
 void
 Tally::init_from_xml(pugi::xml_node node)
 {
-  if (check_for_node(node, "name")) name_ = get_node_value(node, "name");
 }
 
 void
@@ -680,221 +899,7 @@ void read_tallies_xml()
   }
 
   for (auto node_tal : root.children("tally")) {
-    // Copy and set tally id
-    if (!check_for_node(node_tal, "id")) {
-      fatal_error("Must specify id for tally in tally XML file.");
-    }
-    int32_t id = std::stoi(get_node_value(node_tal, "id"));
-
-    auto t = Tally::create(id);
-    t->init_from_xml(node_tal);
-
-    // =======================================================================
-    // READ DATA FOR FILTERS
-
-    // Check if user is using old XML format and throw an error if so
-    if (check_for_node(node_tal, "filter")) {
-      fatal_error("Tally filters must be specified independently of "
-        "tallies in a <filter> element. The <tally> element itself should "
-        "have a list of filters that apply, e.g., <filters>1 2</filters> "
-        "where 1 and 2 are the IDs of filters specified outside of "
-        "<tally>.");
-    }
-
-    // Determine number of filters
-    std::vector<int> filters;
-    if (check_for_node(node_tal, "filters")) {
-      filters = get_node_array<int>(node_tal, "filters");
-    }
-
-    // Allocate and store filter user ids
-    if (!filters.empty()) {
-      std::vector<Filter*> filter_ptrs;
-      for (int filter_id : filters) {
-        // Determine if filter ID is valid
-        auto it = model::filter_map.find(filter_id);
-        if (it == model::filter_map.end()) {
-          fatal_error("Could not find filter " + std::to_string(filter_id)
-            + " specified on tally " + std::to_string(t->id_));
-        }
-
-        // Store the index of the filter
-        filter_ptrs.push_back(model::tally_filters[it->second].get());
-      }
-
-      // Set the filters
-      t->set_filters(filter_ptrs);
-    }
-
-    // Check for the presence of certain filter types
-    bool has_energyout = t->energyout_filter_ >= 0;
-    int particle_filter_index = C_NONE;
-    for (int j = 0; j < t->filters().size(); ++j) {
-      int i_filter = t->filters(j);
-      const auto& f = model::tally_filters[i_filter].get();
-
-      auto pf = dynamic_cast<ParticleFilter*>(f);
-      if (pf) particle_filter_index = i_filter;
-
-      // Change the tally estimator if a filter demands it
-      std::string filt_type = f->type();
-      if (filt_type == "energyout" || filt_type == "legendre") {
-        t->estimator_ = ESTIMATOR_ANALOG;
-      } else if (filt_type == "sphericalharmonics") {
-        auto sf = dynamic_cast<SphericalHarmonicsFilter*>(f);
-        if (sf->cosine_ == SphericalHarmonicsCosine::scatter) {
-          t->estimator_ = ESTIMATOR_ANALOG;
-        }
-      } else if (filt_type == "spatiallegendre" || filt_type == "zernike"
-        || filt_type == "zernikeradial") {
-        t->estimator_ = ESTIMATOR_COLLISION;
-      }
-    }
-
-    // =======================================================================
-    // READ DATA FOR NUCLIDES
-
-    t->set_nuclides(node_tal);
-
-    // =======================================================================
-    // READ DATA FOR SCORES
-
-    t->set_scores(node_tal);
-
-    if (!check_for_node(node_tal, "scores")) {
-      fatal_error("No scores specified on tally " + std::to_string(t->id_)
-        + ".");
-    }
-
-    // Check if tally is compatible with particle type
-    if (settings::photon_transport) {
-      if (particle_filter_index == C_NONE) {
-        for (int score : t->scores_) {
-          switch (score) {
-          case SCORE_INVERSE_VELOCITY:
-            fatal_error("Particle filter must be used with photon "
-              "transport on and inverse velocity score");
-            break;
-          case SCORE_FLUX:
-          case SCORE_TOTAL:
-          case SCORE_SCATTER:
-          case SCORE_NU_SCATTER:
-          case SCORE_ABSORPTION:
-          case SCORE_FISSION:
-          case SCORE_NU_FISSION:
-          case SCORE_CURRENT:
-          case SCORE_EVENTS:
-          case SCORE_DELAYED_NU_FISSION:
-          case SCORE_PROMPT_NU_FISSION:
-          case SCORE_DECAY_RATE:
-            warning("Particle filter is not used with photon transport"
-              " on and " + reaction_name(score) + " score.");
-            break;
-          }
-        }
-      } else {
-        const auto& f = model::tally_filters[particle_filter_index].get();
-        auto pf = dynamic_cast<ParticleFilter*>(f);
-        for (auto p : pf->particles_) {
-          if (p == Particle::Type::electron ||
-              p == Particle::Type::positron) {
-            t->estimator_ = ESTIMATOR_ANALOG;
-          }
-        }
-      }
-    } else {
-      if (particle_filter_index >= 0) {
-        const auto& f = model::tally_filters[particle_filter_index].get();
-        auto pf = dynamic_cast<ParticleFilter*>(f);
-        for (auto p : pf->particles_) {
-          if (p != Particle::Type::neutron) {
-            warning("Particle filter other than NEUTRON used with photon "
-              "transport turned off. All tallies for particle type " +
-              std::to_string(static_cast<int>(p)) + " will have no scores");
-          }
-        }
-      }
-    }
-
-    // Check for a tally derivative.
-    if (check_for_node(node_tal, "derivative")) {
-      int deriv_id = std::stoi(get_node_value(node_tal, "derivative"));
-
-      // Find the derivative with the given id, and store it's index.
-      auto it = model::tally_deriv_map.find(deriv_id);
-      if (it == model::tally_deriv_map.end()) {
-        fatal_error("Could not find derivative " + std::to_string(deriv_id)
-          + " specified on tally " + std::to_string(t->id_));
-      }
-
-      t->deriv_ = it->second;
-
-      // Only analog or collision estimators are supported for differential
-      // tallies.
-      if (t->estimator_ == ESTIMATOR_TRACKLENGTH) {
-        t->estimator_ = ESTIMATOR_COLLISION;
-      }
-
-      const auto& deriv = model::tally_derivs[t->deriv_];
-      if (deriv.variable == DIFF_NUCLIDE_DENSITY
-        || deriv.variable == DIFF_TEMPERATURE) {
-        for (int i_nuc : t->nuclides_) {
-          if (has_energyout && i_nuc == -1) {
-            fatal_error("Error on tally " + std::to_string(t->id_)
-              + ": Cannot use a 'nuclide_density' or 'temperature' "
-              "derivative on a tally with an outgoing energy filter and "
-              "'total' nuclide rate. Instead, tally each nuclide in the "
-              "material individually.");
-            // Note that diff tallies with these characteristics would work
-            // correctly if no tally events occur in the perturbed material
-            // (e.g. pertrubing moderator but only tallying fuel), but this
-            // case would be hard to check for by only reading inputs.
-          }
-        }
-      }
-    }
-
-    // If settings.xml trigger is turned on, create tally triggers
-    if (settings::trigger_on) {
-      t->init_triggers(node_tal);
-    }
-
-    // =======================================================================
-    // SET TALLY ESTIMATOR
-
-    // Check if user specified estimator
-    if (check_for_node(node_tal, "estimator")) {
-      std::string est = get_node_value(node_tal, "estimator");
-      if (est == "analog") {
-        t->estimator_ = ESTIMATOR_ANALOG;
-      } else if (est == "tracklength" || est == "track-length"
-        || est == "pathlength" || est == "path-length") {
-        // If the estimator was set to an analog estimator, this means the
-        // tally needs post-collision information
-        if (t->estimator_ == ESTIMATOR_ANALOG) {
-          fatal_error("Cannot use track-length estimator for tally "
-            + std::to_string(t->id_));
-        }
-
-        // Set estimator to track-length estimator
-        t->estimator_ = ESTIMATOR_TRACKLENGTH;
-
-      } else if (est == "collision") {
-        // If the estimator was set to an analog estimator, this means the
-        // tally needs post-collision information
-        if (t->estimator_ == ESTIMATOR_ANALOG) {
-          fatal_error("Cannot use collision estimator for tally " +
-            std::to_string(t->id_));
-        }
-
-        // Set estimator to collision estimator
-        t->estimator_ = ESTIMATOR_COLLISION;
-
-      } else {
-        fatal_error("Invalid estimator '" + est + "' on tally " +
-          std::to_string(t->id_));
-      }
-    }
+    model::tallies.push_back(std::make_unique<Tally>(node_tal));
   }
 }
 

From c68052da6bad51e05f6ef9d0445da7dd9f552151 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 5 Jul 2019 21:41:35 -0500
Subject: [PATCH 026/127] Reorder declarations in Tally, Filter, and Material
 classes

---
 include/openmc/material.h       | 36 ++++++++++++++++++++++-----------
 include/openmc/tallies/filter.h | 34 ++++++++++++++++++++-----------
 include/openmc/tallies/tally.h  |  7 +++----
 src/tallies/tally.cpp           |  5 -----
 4 files changed, 49 insertions(+), 33 deletions(-)

diff --git a/include/openmc/material.h b/include/openmc/material.h
index 03d76f6cc..02c5380f3 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -36,6 +36,7 @@ extern std::unordered_map<int32_t, int32_t> material_map;
 class Material
 {
 public:
+  //----------------------------------------------------------------------------
   // Types
   struct ThermalTable {
     int index_table; //!< Index of table in data::thermal_scatt
@@ -43,12 +44,15 @@ public:
     double fraction; //!< How often to use table
   };
 
-  // Constructors and destructors
+  //----------------------------------------------------------------------------
+  // Constructors, destructors, factory functions
   Material() {};
   explicit Material(pugi::xml_node material_node);
   ~Material();
 
+  //----------------------------------------------------------------------------
   // Methods
+
   void calculate_xs(Particle& p) const;
 
   //! Assign thermal scattering tables to specific nuclides within the material
@@ -61,12 +65,25 @@ public:
   //! Finalize the material, assigning tables, normalize density, etc.
   void finalize();
 
+  //! Write material data to HDF5
+  void to_hdf5(hid_t group) const;
+
   //! Add nuclide to the material
   //
   //! \param[in] nuclide Name of the nuclide
   //! \param[in] density Density of the nuclide in [atom/b-cm]
   void add_nuclide(const std::string& nuclide, double density);
 
+  //! Set atom densities for the material
+  //
+  //! \param[in] name Name of each nuclide
+  //! \param[in] density Density of each nuclide in [atom/b-cm]
+  void set_densities(const std::vector<std::string>& name,
+    const std::vector<double>& density);
+
+  //----------------------------------------------------------------------------
+  // Accessors
+
   //! Get density in [atom/b-cm]
   //! \return Density in [atom/b-cm]
   double density() const { return density_; }
@@ -89,13 +106,6 @@ public:
   //! \return Densities in [atom/b-cm]
   gsl::span<const double> densities() const { return {atom_density_.data(), atom_density_.size()}; }
 
-  //! Set atom densities for the material
-  //
-  //! \param[in] name Name of each nuclide
-  //! \param[in] density Density of each nuclide in [atom/b-cm]
-  void set_densities(const std::vector<std::string>& name,
-    const std::vector<double>& density);
-
   //! Get ID of material
   //! \return ID of material
   int32_t id() const { return id_; }
@@ -113,9 +123,7 @@ public:
   //! \return Volume in [cm^3]
   double volume() const;
 
-  //! Write material data to HDF5
-  void to_hdf5(hid_t group) const;
-
+  //----------------------------------------------------------------------------
   // Data
   int32_t id_; //!< Unique ID
   std::string name_; //!< Name of material
@@ -146,6 +154,9 @@ public:
   std::unique_ptr<Bremsstrahlung> ttb_;
 
 private:
+  //----------------------------------------------------------------------------
+  // Private methods
+
   //! Calculate the collision stopping power
   void collision_stopping_power(double* s_col, bool positron);
 
@@ -158,7 +169,8 @@ private:
   void calculate_neutron_xs(Particle& p) const;
   void calculate_photon_xs(Particle& p) const;
 
-  // Data members
+  //----------------------------------------------------------------------------
+  // Private data members
   gsl::index index_;
 };
 
diff --git a/include/openmc/tallies/filter.h b/include/openmc/tallies/filter.h
index 905107790..7203a8161 100644
--- a/include/openmc/tallies/filter.h
+++ b/include/openmc/tallies/filter.h
@@ -45,8 +45,11 @@ namespace openmc {
 class Filter
 {
 public:
-  // Default constructor
+  //----------------------------------------------------------------------------
+  // Constructors, destructors, factory functions
+
   Filter();
+  virtual ~Filter();
 
   //! Create a new tally filter
   //
@@ -62,13 +65,14 @@ public:
   //! \return Pointer to the new filter object
   static Filter* create(pugi::xml_node node);
 
-  virtual ~Filter();
-
-  virtual std::string type() const = 0;
-
   //! Uses an XML input to fill the filter's data fields.
   virtual void from_xml(pugi::xml_node node) = 0;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
+  virtual std::string type() const = 0;
+
   //! Matches a tally event to a set of filter bins and weights.
   //!
   //! \param[out] match will contain the matching bins and corresponding
@@ -76,13 +80,6 @@ public:
   virtual void
   get_all_bins(const Particle* p, int estimator, FilterMatch& match) const = 0;
 
-  //! Assign a unique ID to the filter
-  //! \param[in]  Unique ID to assign. A value of -1 indicates that an ID should
-  //!   be automatically assigned
-  void set_id(int32_t id);
-
-  gsl::index index() const { return index_; }
-
   //! Writes data describing this filter to an HDF5 statepoint group.
   virtual void
   to_statepoint(hid_t filter_group) const
@@ -97,6 +94,19 @@ public:
   //! "Incoming Energy [0.625E-6, 20.0)".
   virtual std::string text_label(int bin) const = 0;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  //! Assign a unique ID to the filter
+  //! \param[in]  Unique ID to assign. A value of -1 indicates that an ID should
+  //!   be automatically assigned
+  void set_id(int32_t id);
+
+  gsl::index index() const { return index_; }
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   int32_t id_ {-1};
 
   int n_bins_;
diff --git a/include/openmc/tallies/tally.h b/include/openmc/tallies/tally.h
index 8fe277305..2a166738d 100644
--- a/include/openmc/tallies/tally.h
+++ b/include/openmc/tallies/tally.h
@@ -23,13 +23,15 @@ namespace openmc {
 
 class Tally {
 public:
+  //----------------------------------------------------------------------------
   // Constructors, destructors, factory functions
   explicit Tally(int32_t id);
   explicit Tally(pugi::xml_node node);
   ~Tally();
   static Tally* create(int32_t id = -1);
 
-  void init_from_xml(pugi::xml_node node);
+  //----------------------------------------------------------------------------
+  // Accessors
 
   void set_id(int32_t id);
 
@@ -43,9 +45,6 @@ public:
 
   void set_nuclides(const std::vector<std::string>& nuclides);
 
-  //----------------------------------------------------------------------------
-  // Methods for getting and setting filter/stride data.
-
   const std::vector<int32_t>& filters() const {return filters_;}
 
   int32_t filters(int i) const {return filters_[i];}
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index 1eda7da50..496c18ee4 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -479,11 +479,6 @@ Tally::create(int32_t id)
   return model::tallies.back().get();
 }
 
-void
-Tally::init_from_xml(pugi::xml_node node)
-{
-}
-
 void
 Tally::set_id(int32_t id)
 {

From 6984b695c060b0abfb4d7a6d46bd853388e8b387 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 8 Jul 2019 07:27:39 -0500
Subject: [PATCH 027/127] Make data members of filter protected/private

---
 include/openmc/tallies/filter.h | 12 ++++++++++--
 src/state_point.cpp             |  6 +++---
 src/tallies/filter.cpp          |  4 ++--
 src/tallies/tally.cpp           |  4 ++--
 src/tallies/tally_scoring.cpp   | 34 ++++++++++++++++-----------------
 5 files changed, 34 insertions(+), 26 deletions(-)

diff --git a/include/openmc/tallies/filter.h b/include/openmc/tallies/filter.h
index 7203a8161..ba6ca0883 100644
--- a/include/openmc/tallies/filter.h
+++ b/include/openmc/tallies/filter.h
@@ -97,20 +97,28 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  //! Get unique ID of filter
+  //! \return Unique ID
+  int32_t id() const { return id_; }
+
   //! Assign a unique ID to the filter
   //! \param[in]  Unique ID to assign. A value of -1 indicates that an ID should
   //!   be automatically assigned
   void set_id(int32_t id);
 
+  //! Get number of bins
+  //! \return Number of bins
+  int n_bins() const { return n_bins_; }
+
   gsl::index index() const { return index_; }
 
   //----------------------------------------------------------------------------
   // Data members
 
-  int32_t id_ {-1};
-
+protected:
   int n_bins_;
 private:
+  int32_t id_ {-1};
   gsl::index index_;
 };
 
diff --git a/src/state_point.cpp b/src/state_point.cpp
index 7516b0d48..6ea666fde 100644
--- a/src/state_point.cpp
+++ b/src/state_point.cpp
@@ -141,13 +141,13 @@ openmc_statepoint_write(const char* filename, bool* write_source)
       std::vector<int32_t> filter_ids;
       filter_ids.reserve(model::tally_filters.size());
       for (const auto& filt : model::tally_filters)
-        filter_ids.push_back(filt->id_);
+        filter_ids.push_back(filt->id());
       write_attribute(filters_group, "ids", filter_ids);
 
       // Write info for each filter
       for (const auto& filt : model::tally_filters) {
         hid_t filter_group = create_group(filters_group,
-          "filter " + std::to_string(filt->id_));
+          "filter " + std::to_string(filt->id()));
         filt->to_statepoint(filter_group);
         close_group(filter_group);
       }
@@ -188,7 +188,7 @@ openmc_statepoint_write(const char* filename, bool* write_source)
           std::vector<int32_t> filter_ids;
           filter_ids.reserve(tally.filters().size());
           for (auto i_filt : tally.filters())
-            filter_ids.push_back(model::tally_filters[i_filt]->id_);
+            filter_ids.push_back(model::tally_filters[i_filt]->id());
           write_dataset(tally_group, "filters", filter_ids);
         }
 
diff --git a/src/tallies/filter.cpp b/src/tallies/filter.cpp
index 913a4debc..c67eec830 100644
--- a/src/tallies/filter.cpp
+++ b/src/tallies/filter.cpp
@@ -193,7 +193,7 @@ openmc_filter_get_id(int32_t index, int32_t* id)
 {
   if (int err = verify_filter(index)) return err;
 
-  *id = model::tally_filters[index]->id_;
+  *id = model::tally_filters[index]->id();
   return 0;
 }
 
@@ -233,7 +233,7 @@ openmc_get_filter_next_id(int32_t* id)
 {
   int32_t largest_filter_id = 0;
   for (const auto& t : model::tally_filters) {
-    largest_filter_id = std::max(largest_filter_id, t->id_);
+    largest_filter_id = std::max(largest_filter_id, t->id());
   }
   *id = largest_filter_id + 1;
 }
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index 496c18ee4..a142c16f1 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -523,7 +523,7 @@ Tally::set_filters(gsl::span<Filter*> filters)
   for (int i = 0; i < n; ++i) {
     // Add index to vector of filters
     auto& f {filters[i]};
-    filters_.push_back(model::filter_map.at(f->id_));
+    filters_.push_back(model::filter_map.at(f->id()));
 
     // Keep track of indices for special filters.
     if (dynamic_cast<const EnergyoutFilter*>(f)) {
@@ -540,7 +540,7 @@ Tally::set_filters(gsl::span<Filter*> filters)
   int stride = 1;
   for (int i = n-1; i >= 0; --i) {
     strides_[i] = stride;
-    stride *= model::tally_filters[filters_[i]]->n_bins_;
+    stride *= model::tally_filters[filters_[i]]->n_bins();
   }
   n_filter_bins_ = stride;
 }
diff --git a/src/tallies/tally_scoring.cpp b/src/tallies/tally_scoring.cpp
index a69ab8ca5..4fb3718ec 100644
--- a/src/tallies/tally_scoring.cpp
+++ b/src/tallies/tally_scoring.cpp
@@ -69,7 +69,7 @@ FilterBinIter::FilterBinIter(const Tally& tally, bool end)
     if (!match.bins_present_) {
       match.bins_.clear();
       match.weights_.clear();
-      for (auto i = 0; i < model::tally_filters[i_filt]->n_bins_; ++i) {
+      for (auto i = 0; i < model::tally_filters[i_filt]->n_bins(); ++i) {
         match.bins_.push_back(i);
         match.weights_.push_back(1.0);
       }
@@ -216,7 +216,7 @@ score_fission_eout(const Particle* p, int i_tally, int i_score, int score_bin)
 
       // modify the value so that g_out = 1 corresponds to the highest energy
       // bin
-      g_out = eo_filt.n_bins_ - g_out;
+      g_out = eo_filt.n_bins() - g_out;
 
       // change outgoing energy bin
       simulation::filter_matches[i_eout_filt].bins_[i_bin] = g_out;
@@ -272,7 +272,7 @@ score_fission_eout(const Particle* p, int i_tally, int i_score, int score_bin)
           model::tally_filters[i_dg_filt].get())};
 
         // Loop over delayed group bins until the corresponding bin is found
-        for (auto d_bin = 0; d_bin < dg_filt.n_bins_; ++d_bin) {
+        for (auto d_bin = 0; d_bin < dg_filt.n_bins(); ++d_bin) {
           if (dg_filt.groups_[d_bin] == g) {
             // Find the filter index and weight for this filter combination
             double filter_weight = 1.;
@@ -632,7 +632,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 {*dynamic_cast<DelayedGroupFilter*>(
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
-              for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+              for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                 auto d = filt.groups_[d_bin];
                 auto yield = data::nuclides[p->event_nuclide_]
                   ->nu(E, ReactionProduct::EmissionMode::delayed, d);
@@ -670,7 +670,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
               {*dynamic_cast<DelayedGroupFilter*>(
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
-            for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+            for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
               auto d = filt.groups_[d_bin];
               score = simulation::keff * p->wgt_bank_ / p->n_bank_
                 * p->n_delayed_bank_[d-1] * flux;
@@ -693,7 +693,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
               {*dynamic_cast<DelayedGroupFilter*>(
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
-            for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+            for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
               auto d = filt.groups_[d_bin];
               auto yield = data::nuclides[i_nuclide]
                 ->nu(E, ReactionProduct::EmissionMode::delayed, d);
@@ -722,7 +722,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 auto j_nuclide = material.nuclide_[i];
                 auto atom_density = material.atom_density_(i);
                 // Tally each delayed group bin individually
-                for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+                for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                   auto d = filt.groups_[d_bin];
                   auto yield = data::nuclides[j_nuclide]
                     ->nu(E, ReactionProduct::EmissionMode::delayed, d);
@@ -770,7 +770,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 {*dynamic_cast<DelayedGroupFilter*>(
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
-              for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+              for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                 auto d = filt.groups_[d_bin];
                 auto yield
                   = nuc.nu(E, ReactionProduct::EmissionMode::delayed, d);
@@ -830,7 +830,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                   {*dynamic_cast<DelayedGroupFilter*>(
                   model::tally_filters[i_dg_filt].get())};
                 // Find the corresponding filter bin and then score
-                for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+                for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                   auto d = filt.groups_[d_bin];
                   if (d == g)
                     score_fission_delayed_dg(i_tally, d_bin, score,
@@ -852,7 +852,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
               {*dynamic_cast<DelayedGroupFilter*>(
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
-            for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+            for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
               auto d = filt.groups_[d_bin];
               auto yield
                 = nuc.nu(E, ReactionProduct::EmissionMode::delayed, d);
@@ -892,7 +892,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 if (nuc.fissionable_) {
                   const auto& rxn {*nuc.fission_rx_[0]};
                   // Tally each delayed group bin individually
-                  for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+                  for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                     auto d = filt.groups_[d_bin];
                     auto yield
                       = nuc.nu(E, ReactionProduct::EmissionMode::delayed, d);
@@ -1757,7 +1757,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
                 {*dynamic_cast<DelayedGroupFilter*>(
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
-              for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+              for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                 auto d = filt.groups_[d_bin];
                 score = p->wgt_absorb_ * flux;
                 if (i_nuclide >= 0) {
@@ -1807,7 +1807,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
               {*dynamic_cast<DelayedGroupFilter*>(
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
-            for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+            for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
               auto d = filt.groups_[d_bin];
               score = simulation::keff * p->wgt_bank_ / p->n_bank_
                 * p->n_delayed_bank_[d-1] * flux;
@@ -1839,7 +1839,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
             {*dynamic_cast<DelayedGroupFilter*>(
             model::tally_filters[i_dg_filt].get())};
           // Tally each delayed group bin individually
-          for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+          for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
             auto d = filt.groups_[d_bin];
             if (i_nuclide >= 0) {
               score = flux * atom_density
@@ -1879,7 +1879,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
                 {*dynamic_cast<DelayedGroupFilter*>(
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
-              for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+              for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                 auto d = filt.groups_[d_bin];
                 score = p->wgt_absorb_ * flux;
                 if (i_nuclide >= 0) {
@@ -1959,7 +1959,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
                   {*dynamic_cast<DelayedGroupFilter*>(
                   model::tally_filters[i_dg_filt].get())};
                 // Find the corresponding filter bin and then score
-                for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+                for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
                   auto d = filt.groups_[d_bin];
                   if (d == g)
                     score_fission_delayed_dg(i_tally, d_bin, score,
@@ -1978,7 +1978,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
             {*dynamic_cast<DelayedGroupFilter*>(
             model::tally_filters[i_dg_filt].get())};
           // Tally each delayed group bin individually
-          for (auto d_bin = 0; d_bin < filt.n_bins_; ++d_bin) {
+          for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
             auto d = filt.groups_[d_bin];
             if (i_nuclide >= 0) {
               score += atom_density * flux

From 26a0d7d972e76df2eaee9ce9c97d86ac13720cd1 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 8 Jul 2019 07:42:03 -0500
Subject: [PATCH 028/127] Add comments in filter headers

---
 include/openmc/tallies/filter_azimuthal.h     | 16 +++++++++++++--
 include/openmc/tallies/filter_cell.h          | 16 +++++++++++++--
 include/openmc/tallies/filter_cellborn.h      |  3 +++
 include/openmc/tallies/filter_cellfrom.h      |  3 +++
 include/openmc/tallies/filter_delayedgroup.h  | 16 +++++++++++++--
 include/openmc/tallies/filter_distribcell.h   | 16 +++++++++++++--
 include/openmc/tallies/filter_energy.h        | 16 +++++++++++++--
 include/openmc/tallies/filter_energyfunc.h    |  9 +++++++++
 include/openmc/tallies/filter_legendre.h      | 16 +++++++++++++--
 include/openmc/tallies/filter_material.h      | 11 ++++++++++
 include/openmc/tallies/filter_mesh.h          | 12 +++++++++++
 include/openmc/tallies/filter_meshsurface.h   |  6 ++++++
 include/openmc/tallies/filter_mu.h            | 16 +++++++++++++--
 include/openmc/tallies/filter_particle.h      | 16 +++++++++++++--
 include/openmc/tallies/filter_polar.h         | 16 +++++++++++++--
 include/openmc/tallies/filter_sph_harm.h      | 18 ++++++++++++++---
 include/openmc/tallies/filter_sptl_legendre.h | 18 ++++++++++++++---
 include/openmc/tallies/filter_surface.h       | 16 +++++++++++++--
 include/openmc/tallies/filter_universe.h      | 16 +++++++++++++--
 include/openmc/tallies/filter_zernike.h       | 20 ++++++++++++++++++-
 20 files changed, 247 insertions(+), 29 deletions(-)

diff --git a/include/openmc/tallies/filter_azimuthal.h b/include/openmc/tallies/filter_azimuthal.h
index f753bb280..1761c01bc 100644
--- a/include/openmc/tallies/filter_azimuthal.h
+++ b/include/openmc/tallies/filter_azimuthal.h
@@ -17,8 +17,14 @@ namespace openmc {
 class AzimuthalFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~AzimuthalFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "azimuthal";}
 
   void from_xml(pugi::xml_node node) override;
@@ -26,12 +32,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_bins(gsl::span<double> bins);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_bins(gsl::span<double> bins);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   std::vector<double> bins_;
 };
 
diff --git a/include/openmc/tallies/filter_cell.h b/include/openmc/tallies/filter_cell.h
index eb3ff5236..9c40d4259 100644
--- a/include/openmc/tallies/filter_cell.h
+++ b/include/openmc/tallies/filter_cell.h
@@ -18,8 +18,14 @@ namespace openmc {
 class CellFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~CellFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "cell";}
 
   void from_xml(pugi::xml_node node) override;
@@ -27,12 +33,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_cells(gsl::span<int32_t> cells);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_cells(gsl::span<int32_t> cells);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   //! The indices of the cells binned by this filter.
   std::vector<int32_t> cells_;
 
diff --git a/include/openmc/tallies/filter_cellborn.h b/include/openmc/tallies/filter_cellborn.h
index 400e82c28..706f6c47a 100644
--- a/include/openmc/tallies/filter_cellborn.h
+++ b/include/openmc/tallies/filter_cellborn.h
@@ -14,6 +14,9 @@ namespace openmc {
 class CellbornFilter : public CellFilter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "cellborn";}
 
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
diff --git a/include/openmc/tallies/filter_cellfrom.h b/include/openmc/tallies/filter_cellfrom.h
index bd3e08dcb..e86e34854 100644
--- a/include/openmc/tallies/filter_cellfrom.h
+++ b/include/openmc/tallies/filter_cellfrom.h
@@ -14,6 +14,9 @@ namespace openmc {
 class CellFromFilter : public CellFilter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "cellfrom";}
 
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
diff --git a/include/openmc/tallies/filter_delayedgroup.h b/include/openmc/tallies/filter_delayedgroup.h
index ae2ad0cb4..044e27944 100644
--- a/include/openmc/tallies/filter_delayedgroup.h
+++ b/include/openmc/tallies/filter_delayedgroup.h
@@ -19,8 +19,14 @@ namespace openmc {
 class DelayedGroupFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~DelayedGroupFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "delayedgroup";}
 
   void from_xml(pugi::xml_node node) override;
@@ -28,12 +34,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_groups(gsl::span<int> groups);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_groups(gsl::span<int> groups);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   std::vector<int> groups_;
 };
 
diff --git a/include/openmc/tallies/filter_distribcell.h b/include/openmc/tallies/filter_distribcell.h
index db4cd4b1a..7768af590 100644
--- a/include/openmc/tallies/filter_distribcell.h
+++ b/include/openmc/tallies/filter_distribcell.h
@@ -14,8 +14,14 @@ namespace openmc {
 class DistribcellFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~DistribcellFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "distribcell";}
 
   void from_xml(pugi::xml_node node) override;
@@ -23,12 +29,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_cell(int32_t cell);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_cell(int32_t cell);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   int32_t cell_;
 };
 
diff --git a/include/openmc/tallies/filter_energy.h b/include/openmc/tallies/filter_energy.h
index b2123d7e7..277357cdf 100644
--- a/include/openmc/tallies/filter_energy.h
+++ b/include/openmc/tallies/filter_energy.h
@@ -16,8 +16,14 @@ namespace openmc {
 class EnergyFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~EnergyFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "energy";}
 
   void from_xml(pugi::xml_node node) override;
@@ -25,12 +31,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_bins(gsl::span<const double> bins);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_bins(gsl::span<const double> bins);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   std::vector<double> bins_;
 
   //! True if transport group number can be used directly to get bin number
diff --git a/include/openmc/tallies/filter_energyfunc.h b/include/openmc/tallies/filter_energyfunc.h
index 6f5182626..4024b06db 100644
--- a/include/openmc/tallies/filter_energyfunc.h
+++ b/include/openmc/tallies/filter_energyfunc.h
@@ -15,6 +15,9 @@ namespace openmc {
 class EnergyFunctionFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   EnergyFunctionFilter()
     : Filter {}
   {
@@ -23,6 +26,9 @@ public:
 
   ~EnergyFunctionFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "energyfunction";}
 
   void from_xml(pugi::xml_node node) override;
@@ -34,6 +40,9 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Data members
+
   //! Incident neutron energy interpolation grid.
   std::vector<double> energy_;
 
diff --git a/include/openmc/tallies/filter_legendre.h b/include/openmc/tallies/filter_legendre.h
index 25cf99e15..9e1f32003 100644
--- a/include/openmc/tallies/filter_legendre.h
+++ b/include/openmc/tallies/filter_legendre.h
@@ -14,8 +14,14 @@ namespace openmc {
 class LegendreFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~LegendreFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "legendre";}
 
   void from_xml(pugi::xml_node node) override;
@@ -23,12 +29,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_order(int order);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_order(int order);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   int order_;
 };
 
diff --git a/include/openmc/tallies/filter_material.h b/include/openmc/tallies/filter_material.h
index 97d0b2f8d..65cf832a3 100644
--- a/include/openmc/tallies/filter_material.h
+++ b/include/openmc/tallies/filter_material.h
@@ -18,8 +18,14 @@ namespace openmc {
 class MaterialFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~MaterialFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "material";}
 
   void from_xml(pugi::xml_node node) override;
@@ -31,7 +37,9 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
   // Accessors
+
   std::vector<int32_t>& materials() { return materials_; }
 
   const std::vector<int32_t>& materials() const { return materials_; }
@@ -39,6 +47,9 @@ public:
   void set_materials(gsl::span<const int32_t> materials);
 
 private:
+  //----------------------------------------------------------------------------
+  // Data members
+
   //! The indices of the materials binned by this filter.
   std::vector<int32_t> materials_;
 
diff --git a/include/openmc/tallies/filter_mesh.h b/include/openmc/tallies/filter_mesh.h
index a6caa8f56..98dec5d50 100644
--- a/include/openmc/tallies/filter_mesh.h
+++ b/include/openmc/tallies/filter_mesh.h
@@ -16,8 +16,14 @@ namespace openmc {
 class MeshFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~MeshFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "mesh";}
 
   void from_xml(pugi::xml_node node) override;
@@ -29,11 +35,17 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
   virtual int32_t mesh() const {return mesh_;}
 
   virtual void set_mesh(int32_t mesh);
 
 protected:
+  //----------------------------------------------------------------------------
+  // Data members
+
   int32_t mesh_;
 };
 
diff --git a/include/openmc/tallies/filter_meshsurface.h b/include/openmc/tallies/filter_meshsurface.h
index 32393cfac..19d178c7f 100644
--- a/include/openmc/tallies/filter_meshsurface.h
+++ b/include/openmc/tallies/filter_meshsurface.h
@@ -8,6 +8,9 @@ namespace openmc {
 class MeshSurfaceFilter : public MeshFilter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "meshsurface";}
 
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
@@ -15,6 +18,9 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
   void set_mesh(int32_t mesh) override;
 };
 
diff --git a/include/openmc/tallies/filter_mu.h b/include/openmc/tallies/filter_mu.h
index 06044e760..16af26be7 100644
--- a/include/openmc/tallies/filter_mu.h
+++ b/include/openmc/tallies/filter_mu.h
@@ -17,8 +17,14 @@ namespace openmc {
 class MuFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~MuFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "mu";}
 
   void from_xml(pugi::xml_node node) override;
@@ -26,12 +32,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_bins(gsl::span<double> bins);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_bins(gsl::span<double> bins);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   std::vector<double> bins_;
 };
 
diff --git a/include/openmc/tallies/filter_particle.h b/include/openmc/tallies/filter_particle.h
index 05e3d0505..d718ad8b5 100644
--- a/include/openmc/tallies/filter_particle.h
+++ b/include/openmc/tallies/filter_particle.h
@@ -15,8 +15,14 @@ namespace openmc {
 class ParticleFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~ParticleFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "particle";}
 
   void from_xml(pugi::xml_node node) override;
@@ -24,12 +30,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_particles(gsl::span<Particle::Type> particles);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_particles(gsl::span<Particle::Type> particles);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   std::vector<Particle::Type> particles_;
 };
 
diff --git a/include/openmc/tallies/filter_polar.h b/include/openmc/tallies/filter_polar.h
index 93488e5b0..25c8c13ac 100644
--- a/include/openmc/tallies/filter_polar.h
+++ b/include/openmc/tallies/filter_polar.h
@@ -17,8 +17,14 @@ namespace openmc {
 class PolarFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~PolarFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "polar";}
 
   void from_xml(pugi::xml_node node) override;
@@ -26,12 +32,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_bins(gsl::span<double> bins);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_bins(gsl::span<double> bins);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   std::vector<double> bins_;
 };
 
diff --git a/include/openmc/tallies/filter_sph_harm.h b/include/openmc/tallies/filter_sph_harm.h
index 522e89e78..fbb572212 100644
--- a/include/openmc/tallies/filter_sph_harm.h
+++ b/include/openmc/tallies/filter_sph_harm.h
@@ -20,8 +20,14 @@ enum class SphericalHarmonicsCosine {
 class SphericalHarmonicsFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~SphericalHarmonicsFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "sphericalharmonics";}
 
   void from_xml(pugi::xml_node node) override;
@@ -29,13 +35,19 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void to_statepoint(hid_t filter_group) const override;
+
+  std::string text_label(int bin) const override;
+
+  //----------------------------------------------------------------------------
+  // Accessors
+
   void set_order(int order);
 
   void set_cosine(gsl::cstring_span cosine);
 
-  void to_statepoint(hid_t filter_group) const override;
-
-  std::string text_label(int bin) const override;
+  //----------------------------------------------------------------------------
+  // Data members
 
   int order_;
 
diff --git a/include/openmc/tallies/filter_sptl_legendre.h b/include/openmc/tallies/filter_sptl_legendre.h
index c65bb0cfc..642aaf00a 100644
--- a/include/openmc/tallies/filter_sptl_legendre.h
+++ b/include/openmc/tallies/filter_sptl_legendre.h
@@ -18,8 +18,14 @@ enum class LegendreAxis {
 class SpatialLegendreFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~SpatialLegendreFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "spatiallegendre";}
 
   void from_xml(pugi::xml_node node) override;
@@ -27,15 +33,21 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
+  void to_statepoint(hid_t filter_group) const override;
+
+  std::string text_label(int bin) const override;
+
+  //----------------------------------------------------------------------------
+  // Accessors
+
   void set_order(int order);
 
   void set_axis(LegendreAxis axis);
 
   void set_minmax(double min, double max);
 
-  void to_statepoint(hid_t filter_group) const override;
-
-  std::string text_label(int bin) const override;
+  //----------------------------------------------------------------------------
+  // Data members
 
   int order_;
 
diff --git a/include/openmc/tallies/filter_surface.h b/include/openmc/tallies/filter_surface.h
index 61b320ad6..7f8607225 100644
--- a/include/openmc/tallies/filter_surface.h
+++ b/include/openmc/tallies/filter_surface.h
@@ -18,8 +18,14 @@ namespace openmc {
 class SurfaceFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~SurfaceFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "surface";}
 
   void from_xml(pugi::xml_node node) override;
@@ -27,12 +33,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_surfaces(gsl::span<int32_t> surfaces);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_surfaces(gsl::span<int32_t> surfaces);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   //! The indices of the surfaces binned by this filter.
   std::vector<int32_t> surfaces_;
 
diff --git a/include/openmc/tallies/filter_universe.h b/include/openmc/tallies/filter_universe.h
index 0b43bb85c..a315df076 100644
--- a/include/openmc/tallies/filter_universe.h
+++ b/include/openmc/tallies/filter_universe.h
@@ -18,8 +18,14 @@ namespace openmc {
 class UniverseFilter : public Filter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
+
   ~UniverseFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "universe";}
 
   void from_xml(pugi::xml_node node) override;
@@ -27,12 +33,18 @@ public:
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
   const override;
 
-  void set_universes(gsl::span<int32_t> universes);
-
   void to_statepoint(hid_t filter_group) const override;
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  void set_universes(gsl::span<int32_t> universes);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   //! The indices of the universes binned by this filter.
   std::vector<int32_t> universes_;
 
diff --git a/include/openmc/tallies/filter_zernike.h b/include/openmc/tallies/filter_zernike.h
index 19fff1336..833422bf4 100644
--- a/include/openmc/tallies/filter_zernike.h
+++ b/include/openmc/tallies/filter_zernike.h
@@ -14,10 +14,16 @@ namespace openmc {
 class ZernikeFilter : public Filter
 {
 public:
-  std::string type() const override {return "zernike";}
+  //----------------------------------------------------------------------------
+  // Constructors, destructors
 
   ~ZernikeFilter() = default;
 
+  //----------------------------------------------------------------------------
+  // Methods
+
+  std::string type() const override {return "zernike";}
+
   void from_xml(pugi::xml_node node) override;
 
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
@@ -27,10 +33,16 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
   int order() const {return order_;}
 
   virtual void set_order(int order);
 
+  //----------------------------------------------------------------------------
+  // Data members
+
   //! Cartesian x coordinate for the origin of this expansion.
   double x_;
 
@@ -51,6 +63,9 @@ protected:
 class ZernikeRadialFilter : public ZernikeFilter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "zernikeradial";}
 
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
@@ -58,6 +73,9 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
   void set_order(int order) override;
 };
 

From 9632630c0ab3771d6e7857638f7f6eb3bac3cca6 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 8 Jul 2019 08:07:20 -0500
Subject: [PATCH 029/127] Make all filter data members private or protected

---
 include/openmc/capi.h                         |  6 +--
 include/openmc/tallies/filter_azimuthal.h     |  1 +
 include/openmc/tallies/filter_cell.h          |  3 ++
 include/openmc/tallies/filter_delayedgroup.h  |  3 ++
 include/openmc/tallies/filter_distribcell.h   |  3 ++
 include/openmc/tallies/filter_energy.h        |  7 ++++
 include/openmc/tallies/filter_energyfunc.h    |  1 +
 include/openmc/tallies/filter_legendre.h      |  3 ++
 include/openmc/tallies/filter_mu.h            |  1 +
 include/openmc/tallies/filter_particle.h      |  3 ++
 include/openmc/tallies/filter_polar.h         |  1 +
 include/openmc/tallies/filter_sph_harm.h      |  5 +++
 include/openmc/tallies/filter_sptl_legendre.h |  5 +++
 include/openmc/tallies/filter_surface.h       |  1 +
 include/openmc/tallies/filter_universe.h      |  1 +
 include/openmc/tallies/filter_zernike.h       | 14 +++++--
 src/geometry_aux.cpp                          |  2 +-
 src/tallies/filter_cell.cpp                   |  6 +--
 src/tallies/filter_energy.cpp                 |  6 +--
 src/tallies/filter_legendre.cpp               |  2 +-
 src/tallies/filter_material.cpp               |  2 +-
 src/tallies/filter_sph_harm.cpp               |  4 +-
 src/tallies/filter_sptl_legendre.cpp          | 11 +++---
 src/tallies/filter_zernike.cpp                | 12 +++---
 src/tallies/tally.cpp                         |  6 +--
 src/tallies/tally_scoring.cpp                 | 38 +++++++++----------
 26 files changed, 96 insertions(+), 51 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index 1f1d65cf5..148a28c88 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -10,14 +10,14 @@ extern "C" {
 #endif
 
   int openmc_calculate_volumes();
-  int openmc_cell_filter_get_bins(int32_t index, int32_t** cells, int32_t* n);
+  int openmc_cell_filter_get_bins(int32_t index, const int32_t** cells, int32_t* n);
   int openmc_cell_get_fill(int32_t index, int* type, int32_t** indices, int32_t* n);
   int openmc_cell_get_id(int32_t index, int32_t* id);
   int openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T);
   int openmc_cell_set_fill(int32_t index, int type, int32_t n, const int32_t* indices);
   int openmc_cell_set_id(int32_t index, int32_t id);
   int openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance);
-  int openmc_energy_filter_get_bins(int32_t index, double** energies, size_t* n);
+  int openmc_energy_filter_get_bins(int32_t index, const double** energies, size_t* n);
   int openmc_energy_filter_set_bins(int32_t index, size_t n, const double* energies);
   int openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end);
   int openmc_extend_filters(int32_t n, int32_t* index_start, int32_t* index_end);
@@ -57,7 +57,7 @@ extern "C" {
   int openmc_material_set_densities(int32_t index, int n, const char** name, const double* density);
   int openmc_material_set_id(int32_t index, int32_t id);
   int openmc_material_set_volume(int32_t index, double volume);
-  int openmc_material_filter_get_bins(int32_t index, int32_t** bins, size_t* n);
+  int openmc_material_filter_get_bins(int32_t index, const int32_t** bins, size_t* n);
   int openmc_material_filter_set_bins(int32_t index, size_t n, const int32_t* bins);
   int openmc_mesh_filter_get_mesh(int32_t index, int32_t* index_mesh);
   int openmc_mesh_filter_set_mesh(int32_t index, int32_t index_mesh);
diff --git a/include/openmc/tallies/filter_azimuthal.h b/include/openmc/tallies/filter_azimuthal.h
index 1761c01bc..84c2a2d8c 100644
--- a/include/openmc/tallies/filter_azimuthal.h
+++ b/include/openmc/tallies/filter_azimuthal.h
@@ -41,6 +41,7 @@ public:
 
   void set_bins(gsl::span<double> bins);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_cell.h b/include/openmc/tallies/filter_cell.h
index 9c40d4259..b570ee027 100644
--- a/include/openmc/tallies/filter_cell.h
+++ b/include/openmc/tallies/filter_cell.h
@@ -40,8 +40,11 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  const std::vector<int32_t>& cells() const { return cells_; }
+
   void set_cells(gsl::span<int32_t> cells);
 
+protected:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_delayedgroup.h b/include/openmc/tallies/filter_delayedgroup.h
index 044e27944..8a2bbeeaa 100644
--- a/include/openmc/tallies/filter_delayedgroup.h
+++ b/include/openmc/tallies/filter_delayedgroup.h
@@ -41,8 +41,11 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  const std::vector<int>& groups() const { return groups_; }
+
   void set_groups(gsl::span<int> groups);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_distribcell.h b/include/openmc/tallies/filter_distribcell.h
index 7768af590..9430a0906 100644
--- a/include/openmc/tallies/filter_distribcell.h
+++ b/include/openmc/tallies/filter_distribcell.h
@@ -36,8 +36,11 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  int32_t cell() const { return cell_; }
+
   void set_cell(int32_t cell);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_energy.h b/include/openmc/tallies/filter_energy.h
index 277357cdf..af7601721 100644
--- a/include/openmc/tallies/filter_energy.h
+++ b/include/openmc/tallies/filter_energy.h
@@ -38,8 +38,12 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  const std::vector<double>& bins() const { return bins_; }
   void set_bins(gsl::span<const double> bins);
 
+  bool matches_transport_groups() const { return matches_transport_groups_; }
+
+protected:
   //----------------------------------------------------------------------------
   // Data members
 
@@ -59,6 +63,9 @@ public:
 class EnergyoutFilter : public EnergyFilter
 {
 public:
+  //----------------------------------------------------------------------------
+  // Methods
+
   std::string type() const override {return "energyout";}
 
   void get_all_bins(const Particle* p, int estimator, FilterMatch& match)
diff --git a/include/openmc/tallies/filter_energyfunc.h b/include/openmc/tallies/filter_energyfunc.h
index 4024b06db..9b8d839f8 100644
--- a/include/openmc/tallies/filter_energyfunc.h
+++ b/include/openmc/tallies/filter_energyfunc.h
@@ -40,6 +40,7 @@ public:
 
   std::string text_label(int bin) const override;
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_legendre.h b/include/openmc/tallies/filter_legendre.h
index 9e1f32003..3a14ec3cf 100644
--- a/include/openmc/tallies/filter_legendre.h
+++ b/include/openmc/tallies/filter_legendre.h
@@ -36,8 +36,11 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  int order() const { return order_; }
+
   void set_order(int order);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_mu.h b/include/openmc/tallies/filter_mu.h
index 16af26be7..ae9c3e06a 100644
--- a/include/openmc/tallies/filter_mu.h
+++ b/include/openmc/tallies/filter_mu.h
@@ -41,6 +41,7 @@ public:
 
   void set_bins(gsl::span<double> bins);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_particle.h b/include/openmc/tallies/filter_particle.h
index d718ad8b5..61aa3106b 100644
--- a/include/openmc/tallies/filter_particle.h
+++ b/include/openmc/tallies/filter_particle.h
@@ -37,8 +37,11 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  const std::vector<Particle::Type>& particles() const { return particles_; }
+
   void set_particles(gsl::span<Particle::Type> particles);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_polar.h b/include/openmc/tallies/filter_polar.h
index 25c8c13ac..965950456 100644
--- a/include/openmc/tallies/filter_polar.h
+++ b/include/openmc/tallies/filter_polar.h
@@ -41,6 +41,7 @@ public:
 
   void set_bins(gsl::span<double> bins);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_sph_harm.h b/include/openmc/tallies/filter_sph_harm.h
index fbb572212..80f998b2f 100644
--- a/include/openmc/tallies/filter_sph_harm.h
+++ b/include/openmc/tallies/filter_sph_harm.h
@@ -42,10 +42,15 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  int order() const { return order_; }
+
   void set_order(int order);
 
+  SphericalHarmonicsCosine cosine() const { return cosine_; }
+
   void set_cosine(gsl::cstring_span cosine);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_sptl_legendre.h b/include/openmc/tallies/filter_sptl_legendre.h
index 642aaf00a..fea727515 100644
--- a/include/openmc/tallies/filter_sptl_legendre.h
+++ b/include/openmc/tallies/filter_sptl_legendre.h
@@ -40,12 +40,17 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
+  int order() const { return order_; }
   void set_order(int order);
 
+  LegendreAxis axis() const { return axis_; }
   void set_axis(LegendreAxis axis);
 
+  double min() const { return min_; }
+  double max() const { return max_; }
   void set_minmax(double min, double max);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_surface.h b/include/openmc/tallies/filter_surface.h
index 7f8607225..23b9be33d 100644
--- a/include/openmc/tallies/filter_surface.h
+++ b/include/openmc/tallies/filter_surface.h
@@ -42,6 +42,7 @@ public:
 
   void set_surfaces(gsl::span<int32_t> surfaces);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_universe.h b/include/openmc/tallies/filter_universe.h
index a315df076..fc2ace18f 100644
--- a/include/openmc/tallies/filter_universe.h
+++ b/include/openmc/tallies/filter_universe.h
@@ -42,6 +42,7 @@ public:
 
   void set_universes(gsl::span<int32_t> universes);
 
+private:
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/include/openmc/tallies/filter_zernike.h b/include/openmc/tallies/filter_zernike.h
index 833422bf4..e3ae89dec 100644
--- a/include/openmc/tallies/filter_zernike.h
+++ b/include/openmc/tallies/filter_zernike.h
@@ -36,13 +36,22 @@ public:
   //----------------------------------------------------------------------------
   // Accessors
 
-  int order() const {return order_;}
-
+  int order() const { return order_; }
   virtual void set_order(int order);
 
+  double x() const { return x_; }
+  void set_x(double x) { x_ = x; }
+
+  double y() const { return y_; }
+  void set_y(double y) { y_ = y; }
+
+  double r() const { return r_; }
+  void set_r(double r) { r_ = r; }
+
   //----------------------------------------------------------------------------
   // Data members
 
+protected:
   //! Cartesian x coordinate for the origin of this expansion.
   double x_;
 
@@ -52,7 +61,6 @@ public:
   //! Maximum radius from the origin covered by this expansion.
   double r_;
 
-protected:
   int order_;
 };
 
diff --git a/src/geometry_aux.cpp b/src/geometry_aux.cpp
index f02ee42b1..d195a9de3 100644
--- a/src/geometry_aux.cpp
+++ b/src/geometry_aux.cpp
@@ -309,7 +309,7 @@ prepare_distribcell()
   for (auto& filt : model::tally_filters) {
     auto* distrib_filt = dynamic_cast<DistribcellFilter*>(filt.get());
     if (distrib_filt) {
-      distribcells.insert(distrib_filt->cell_);
+      distribcells.insert(distrib_filt->cell());
     }
   }
 
diff --git a/src/tallies/filter_cell.cpp b/src/tallies/filter_cell.cpp
index 685d8ff74..7cc007756 100644
--- a/src/tallies/filter_cell.cpp
+++ b/src/tallies/filter_cell.cpp
@@ -80,7 +80,7 @@ CellFilter::text_label(int bin) const
 //==============================================================================
 
 extern "C" int
-openmc_cell_filter_get_bins(int32_t index, int32_t** cells, int32_t* n)
+openmc_cell_filter_get_bins(int32_t index, const int32_t** cells, int32_t* n)
 {
   if (int err = verify_filter(index)) return err;
 
@@ -91,8 +91,8 @@ openmc_cell_filter_get_bins(int32_t index, int32_t** cells, int32_t* n)
   }
 
   auto cell_filt = static_cast<CellFilter*>(filt);
-  *cells = cell_filt->cells_.data();
-  *n = cell_filt->cells_.size();
+  *cells = cell_filt->cells().data();
+  *n = cell_filt->cells().size();
   return 0;
 }
 
diff --git a/src/tallies/filter_energy.cpp b/src/tallies/filter_energy.cpp
index d4e26a1f0..dde9b692a 100644
--- a/src/tallies/filter_energy.cpp
+++ b/src/tallies/filter_energy.cpp
@@ -129,7 +129,7 @@ EnergyoutFilter::text_label(int bin) const
 //==============================================================================
 
 extern"C" int
-openmc_energy_filter_get_bins(int32_t index, double** energies, size_t* n)
+openmc_energy_filter_get_bins(int32_t index, const double** energies, size_t* n)
 {
   // Make sure this is a valid index to an allocated filter.
   if (int err = verify_filter(index)) return err;
@@ -145,8 +145,8 @@ openmc_energy_filter_get_bins(int32_t index, double** energies, size_t* n)
   }
 
   // Output the bins.
-  *energies = filt->bins_.data();
-  *n = filt->bins_.size();
+  *energies = filt->bins().data();
+  *n = filt->bins().size();
   return 0;
 }
 
diff --git a/src/tallies/filter_legendre.cpp b/src/tallies/filter_legendre.cpp
index 21939b7d4..088f59ac4 100644
--- a/src/tallies/filter_legendre.cpp
+++ b/src/tallies/filter_legendre.cpp
@@ -66,7 +66,7 @@ openmc_legendre_filter_get_order(int32_t index, int* order)
   }
 
   // Output the order.
-  *order = filt->order_;
+  *order = filt->order();
   return 0;
 }
 
diff --git a/src/tallies/filter_material.cpp b/src/tallies/filter_material.cpp
index c44ee0d28..bfc216244 100644
--- a/src/tallies/filter_material.cpp
+++ b/src/tallies/filter_material.cpp
@@ -77,7 +77,7 @@ MaterialFilter::text_label(int bin) const
 //==============================================================================
 
 extern "C" int
-openmc_material_filter_get_bins(int32_t index, int32_t** bins, size_t* n)
+openmc_material_filter_get_bins(int32_t index, const int32_t** bins, size_t* n)
 {
   // Make sure this is a valid index to an allocated filter.
   if (int err = verify_filter(index)) return err;
diff --git a/src/tallies/filter_sph_harm.cpp b/src/tallies/filter_sph_harm.cpp
index a01c2e87f..77f70c7ef 100644
--- a/src/tallies/filter_sph_harm.cpp
+++ b/src/tallies/filter_sph_harm.cpp
@@ -134,7 +134,7 @@ openmc_sphharm_filter_get_order(int32_t index, int* order)
   if (err) return err;
 
   // Output the order.
-  *order = filt->order_;
+  *order = filt->order();
   return 0;
 }
 
@@ -148,7 +148,7 @@ openmc_sphharm_filter_get_cosine(int32_t index, char cosine[])
   if (err) return err;
 
   // Output the cosine.
-  if (filt->cosine_ == SphericalHarmonicsCosine::scatter) {
+  if (filt->cosine() == SphericalHarmonicsCosine::scatter) {
     strcpy(cosine, "scatter");
   } else {
     strcpy(cosine, "particle");
diff --git a/src/tallies/filter_sptl_legendre.cpp b/src/tallies/filter_sptl_legendre.cpp
index e0aeff9c1..75a46348f 100644
--- a/src/tallies/filter_sptl_legendre.cpp
+++ b/src/tallies/filter_sptl_legendre.cpp
@@ -152,7 +152,7 @@ openmc_spatial_legendre_filter_get_order(int32_t index, int* order)
   if (err) return err;
 
   // Output the order.
-  *order = filt->order_;
+  *order = filt->order();
   return 0;
 }
 
@@ -167,9 +167,9 @@ openmc_spatial_legendre_filter_get_params(int32_t index, int* axis,
   if (err) return err;
 
   // Output the params.
-  *axis = static_cast<int>(filt->axis_);
-  *min = filt->min_;
-  *max = filt->max_;
+  *axis = static_cast<int>(filt->axis());
+  *min = filt->min();
+  *max = filt->max();
   return 0;
 }
 
@@ -199,8 +199,7 @@ openmc_spatial_legendre_filter_set_params(int32_t index, const int* axis,
 
   // Update the filter.
   if (axis) filt->set_axis(static_cast<LegendreAxis>(*axis));
-  if (min) filt->min_ = *min;
-  if (max) filt->max_ = *max;
+  if (min && max) filt->set_minmax(*min, *max);
   return 0;
 }
 
diff --git a/src/tallies/filter_zernike.cpp b/src/tallies/filter_zernike.cpp
index 125bfada8..21b9a6b32 100644
--- a/src/tallies/filter_zernike.cpp
+++ b/src/tallies/filter_zernike.cpp
@@ -165,9 +165,9 @@ openmc_zernike_filter_get_params(int32_t index, double* x, double* y,
   if (err) return err;
 
   // Output the params.
-  *x = filt->x_;
-  *y = filt->y_;
-  *r = filt->r_;
+  *x = filt->x();
+  *y = filt->y();
+  *r = filt->r();
   return 0;
 }
 
@@ -196,9 +196,9 @@ openmc_zernike_filter_set_params(int32_t index, const double* x,
   if (err) return err;
 
   // Update the filter.
-  if (x) filt->x_ = *x;
-  if (y) filt->y_ = *y;
-  if (r) filt->r_ = *r;
+  if (x) filt->set_x(*x);
+  if (y) filt->set_y(*y);
+  if (r) filt->set_r(*r);
   return 0;
 }
 
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index a142c16f1..1c9560404 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -312,7 +312,7 @@ Tally::Tally(pugi::xml_node node)
       estimator_ = ESTIMATOR_ANALOG;
     } else if (filt_type == "sphericalharmonics") {
       auto sf = dynamic_cast<SphericalHarmonicsFilter*>(f);
-      if (sf->cosine_ == SphericalHarmonicsCosine::scatter) {
+      if (sf->cosine() == SphericalHarmonicsCosine::scatter) {
         estimator_ = ESTIMATOR_ANALOG;
       }
     } else if (filt_type == "spatiallegendre" || filt_type == "zernike"
@@ -365,7 +365,7 @@ Tally::Tally(pugi::xml_node node)
     } else {
       const auto& f = model::tally_filters[particle_filter_index].get();
       auto pf = dynamic_cast<ParticleFilter*>(f);
-      for (auto p : pf->particles_) {
+      for (auto p : pf->particles()) {
         if (p == Particle::Type::electron ||
             p == Particle::Type::positron) {
           estimator_ = ESTIMATOR_ANALOG;
@@ -376,7 +376,7 @@ Tally::Tally(pugi::xml_node node)
     if (particle_filter_index >= 0) {
       const auto& f = model::tally_filters[particle_filter_index].get();
       auto pf = dynamic_cast<ParticleFilter*>(f);
-      for (auto p : pf->particles_) {
+      for (auto p : pf->particles()) {
         if (p != Particle::Type::neutron) {
           warning("Particle filter other than NEUTRON used with photon "
             "transport turned off. All tallies for particle type " +
diff --git a/src/tallies/tally_scoring.cpp b/src/tallies/tally_scoring.cpp
index 4fb3718ec..6bf9ca6e9 100644
--- a/src/tallies/tally_scoring.cpp
+++ b/src/tallies/tally_scoring.cpp
@@ -209,7 +209,7 @@ score_fission_eout(const Particle* p, int i_tally, int i_score, int score_bin)
     if (tally.deriv_ != C_NONE)
       apply_derivative_to_score(p, i_tally, 0, 0., SCORE_NU_FISSION, score);
 
-    if (!settings::run_CE && eo_filt.matches_transport_groups_) {
+    if (!settings::run_CE && eo_filt.matches_transport_groups()) {
 
       // determine outgoing energy group from fission bank
       auto g_out = static_cast<int>(bank.E);
@@ -231,11 +231,11 @@ score_fission_eout(const Particle* p, int i_tally, int i_score, int score_bin)
       }
 
       // Set EnergyoutFilter bin index
-      if (E_out < eo_filt.bins_.front() || E_out > eo_filt.bins_.back()) {
+      if (E_out < eo_filt.bins().front() || E_out > eo_filt.bins().back()) {
         continue;
       } else {
-        auto i_match = lower_bound_index(eo_filt.bins_.begin(),
-          eo_filt.bins_.end(), E_out);
+        auto i_match = lower_bound_index(eo_filt.bins().begin(),
+          eo_filt.bins().end(), E_out);
         simulation::filter_matches[i_eout_filt].bins_[i_bin] = i_match;
       }
 
@@ -273,7 +273,7 @@ score_fission_eout(const Particle* p, int i_tally, int i_score, int score_bin)
 
         // Loop over delayed group bins until the corresponding bin is found
         for (auto d_bin = 0; d_bin < dg_filt.n_bins(); ++d_bin) {
-          if (dg_filt.groups_[d_bin] == g) {
+          if (dg_filt.groups()[d_bin] == g) {
             // Find the filter index and weight for this filter combination
             double filter_weight = 1.;
             for (auto j = 0; j < tally.filters().size(); ++j) {
@@ -633,7 +633,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
               for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                auto d = filt.groups_[d_bin];
+                auto d = filt.groups()[d_bin];
                 auto yield = data::nuclides[p->event_nuclide_]
                   ->nu(E, ReactionProduct::EmissionMode::delayed, d);
                 score = p->wgt_absorb_ * yield
@@ -671,7 +671,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
             for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-              auto d = filt.groups_[d_bin];
+              auto d = filt.groups()[d_bin];
               score = simulation::keff * p->wgt_bank_ / p->n_bank_
                 * p->n_delayed_bank_[d-1] * flux;
               score_fission_delayed_dg(i_tally, d_bin, score, score_index);
@@ -694,7 +694,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
             for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-              auto d = filt.groups_[d_bin];
+              auto d = filt.groups()[d_bin];
               auto yield = data::nuclides[i_nuclide]
                 ->nu(E, ReactionProduct::EmissionMode::delayed, d);
               score = p->neutron_xs_[i_nuclide].fission * yield
@@ -723,7 +723,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 auto atom_density = material.atom_density_(i);
                 // Tally each delayed group bin individually
                 for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                  auto d = filt.groups_[d_bin];
+                  auto d = filt.groups()[d_bin];
                   auto yield = data::nuclides[j_nuclide]
                     ->nu(E, ReactionProduct::EmissionMode::delayed, d);
                   score = p->neutron_xs_[j_nuclide].fission * yield
@@ -771,7 +771,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
               for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                auto d = filt.groups_[d_bin];
+                auto d = filt.groups()[d_bin];
                 auto yield
                   = nuc.nu(E, ReactionProduct::EmissionMode::delayed, d);
                 auto rate = rxn.products_[d].decay_rate_;
@@ -831,7 +831,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                   model::tally_filters[i_dg_filt].get())};
                 // Find the corresponding filter bin and then score
                 for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                  auto d = filt.groups_[d_bin];
+                  auto d = filt.groups()[d_bin];
                   if (d == g)
                     score_fission_delayed_dg(i_tally, d_bin, score,
                       score_index);
@@ -853,7 +853,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
             for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-              auto d = filt.groups_[d_bin];
+              auto d = filt.groups()[d_bin];
               auto yield
                 = nuc.nu(E, ReactionProduct::EmissionMode::delayed, d);
               auto rate = rxn.products_[d].decay_rate_;
@@ -893,7 +893,7 @@ score_general_ce(Particle* p, int i_tally, int start_index,
                   const auto& rxn {*nuc.fission_rx_[0]};
                   // Tally each delayed group bin individually
                   for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                    auto d = filt.groups_[d_bin];
+                    auto d = filt.groups()[d_bin];
                     auto yield
                       = nuc.nu(E, ReactionProduct::EmissionMode::delayed, d);
                     auto rate = rxn.products_[d].decay_rate_;
@@ -1758,7 +1758,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
               for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                auto d = filt.groups_[d_bin];
+                auto d = filt.groups()[d_bin];
                 score = p->wgt_absorb_ * flux;
                 if (i_nuclide >= 0) {
                   score *=
@@ -1808,7 +1808,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
               model::tally_filters[i_dg_filt].get())};
             // Tally each delayed group bin individually
             for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-              auto d = filt.groups_[d_bin];
+              auto d = filt.groups()[d_bin];
               score = simulation::keff * p->wgt_bank_ / p->n_bank_
                 * p->n_delayed_bank_[d-1] * flux;
               if (i_nuclide >= 0) {
@@ -1840,7 +1840,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
             model::tally_filters[i_dg_filt].get())};
           // Tally each delayed group bin individually
           for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-            auto d = filt.groups_[d_bin];
+            auto d = filt.groups()[d_bin];
             if (i_nuclide >= 0) {
               score = flux * atom_density
                 * get_nuclide_xs(i_nuclide, MG_GET_XS_DELAYED_NU_FISSION,
@@ -1880,7 +1880,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
                 model::tally_filters[i_dg_filt].get())};
               // Tally each delayed group bin individually
               for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                auto d = filt.groups_[d_bin];
+                auto d = filt.groups()[d_bin];
                 score = p->wgt_absorb_ * flux;
                 if (i_nuclide >= 0) {
                   score *=
@@ -1960,7 +1960,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
                   model::tally_filters[i_dg_filt].get())};
                 // Find the corresponding filter bin and then score
                 for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-                  auto d = filt.groups_[d_bin];
+                  auto d = filt.groups()[d_bin];
                   if (d == g)
                     score_fission_delayed_dg(i_tally, d_bin, score,
                       score_index);
@@ -1979,7 +1979,7 @@ score_general_mg(const Particle* p, int i_tally, int start_index,
             model::tally_filters[i_dg_filt].get())};
           // Tally each delayed group bin individually
           for (auto d_bin = 0; d_bin < filt.n_bins(); ++d_bin) {
-            auto d = filt.groups_[d_bin];
+            auto d = filt.groups()[d_bin];
             if (i_nuclide >= 0) {
               score += atom_density * flux
                 * get_nuclide_xs(i_nuclide, MG_GET_XS_DECAY_RATE,

From 5b0d8ed80c7e0e7bdcb2cb5329a96aef7c625790 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 8 Jul 2019 14:07:40 -0500
Subject: [PATCH 030/127] Add temperature interface for Cell

---
 include/openmc/cell.h | 96 ++++++++++++++++++++++++++-----------------
 src/cell.cpp          | 80 +++++++++++++++++++++---------------
 2 files changed, 105 insertions(+), 71 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index ee1230595..afe40fe43 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -72,9 +72,66 @@ public:
 //! A geometry primitive that links surfaces, universes, and materials
 //==============================================================================
 
-class Cell
-{
+class Cell {
 public:
+  //----------------------------------------------------------------------------
+  // Constructors, destructors, factory functions
+
+  explicit Cell(pugi::xml_node cell_node);
+  Cell() {};
+  virtual ~Cell() = default;
+
+  //----------------------------------------------------------------------------
+  // Methods
+
+  //! \brief Determine if a cell contains the particle at a given location.
+  //!
+  //! The bounds of the cell are detemined by a logical expression involving
+  //! surface half-spaces. At initialization, the expression was converted
+  //! to RPN notation.
+  //!
+  //! The function is split into two cases, one for simple cells (those
+  //! involving only the intersection of half-spaces) and one for complex cells.
+  //! Simple cells can be evaluated with short circuit evaluation, i.e., as soon
+  //! as we know that one half-space is not satisfied, we can exit. This
+  //! provides a performance benefit for the common case. In
+  //! contains_complex, we evaluate the RPN expression using a stack, similar to
+  //! how a RPN calculator would work.
+  //! \param r The 3D Cartesian coordinate to check.
+  //! \param u A direction used to "break ties" the coordinates are very
+  //!   close to a surface.
+  //! \param on_surface The signed index of a surface that the coordinate is
+  //!   known to be on.  This index takes precedence over surface sense
+  //!   calculations.
+  virtual bool
+  contains(Position r, Direction u, int32_t on_surface) const = 0;
+
+  //! Find the oncoming boundary of this cell.
+  virtual std::pair<double, int32_t>
+  distance(Position r, Direction u, int32_t on_surface) const = 0;
+
+  //! Write all information needed to reconstruct the cell to an HDF5 group.
+  //! \param group_id An HDF5 group id.
+  virtual void to_hdf5(hid_t group_id) const = 0;
+
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  //! Get the temperature of a cell instance
+  //! \param[in] instance Instance index. If -1 is given, the temperature for
+  //!   the first instance is returned.
+  //! \return Temperature in [K]
+  double temperature(int32_t instance = -1) const;
+
+  //! Set the temperature of a cell instance
+  //! \param[in] T Temperature in [K]
+  //! \param[in] instance Instance index. If -1 is given, the temperature for
+  //!   all instances is set.
+  void set_temperature(double T, int32_t instance = -1);
+
+  //----------------------------------------------------------------------------
+  // Data members
+
   int32_t id_;                //!< Unique ID
   std::string name_;          //!< User-defined name
   int type_;                  //!< Material, universe, or lattice
@@ -116,41 +173,6 @@ public:
   std::vector<double> rotation_;
 
   std::vector<int32_t> offset_;  //!< Distribcell offset table
-
-  explicit Cell(pugi::xml_node cell_node);
-  Cell() {};
-
-  //! \brief Determine if a cell contains the particle at a given location.
-  //!
-  //! The bounds of the cell are detemined by a logical expression involving
-  //! surface half-spaces. At initialization, the expression was converted
-  //! to RPN notation.
-  //!
-  //! The function is split into two cases, one for simple cells (those
-  //! involving only the intersection of half-spaces) and one for complex cells.
-  //! Simple cells can be evaluated with short circuit evaluation, i.e., as soon
-  //! as we know that one half-space is not satisfied, we can exit. This
-  //! provides a performance benefit for the common case. In
-  //! contains_complex, we evaluate the RPN expression using a stack, similar to
-  //! how a RPN calculator would work.
-  //! \param r The 3D Cartesian coordinate to check.
-  //! \param u A direction used to "break ties" the coordinates are very
-  //!   close to a surface.
-  //! \param on_surface The signed index of a surface that the coordinate is
-  //!   known to be on.  This index takes precedence over surface sense
-  //!   calculations.
-  virtual bool
-  contains(Position r, Direction u, int32_t on_surface) const = 0;
-
-  //! Find the oncoming boundary of this cell.
-  virtual std::pair<double, int32_t>
-  distance(Position r, Direction u, int32_t on_surface) const = 0;
-
-  //! Write all information needed to reconstruct the cell to an HDF5 group.
-  //! @param group_id An HDF5 group id.
-  virtual void to_hdf5(hid_t group_id) const = 0;
-
-  virtual ~Cell() {}
 };
 
 //==============================================================================
diff --git a/src/cell.cpp b/src/cell.cpp
index 87b67ef85..04273eded 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -212,6 +212,39 @@ Universe::to_hdf5(hid_t universes_group) const
 // Cell implementation
 //==============================================================================
 
+double
+Cell::temperature(int32_t instance) const
+{
+  if (sqrtkT_.size() < 1) {
+    throw std::runtime_error{"Cell temperature has not yet been set."};
+  }
+
+  if (instance >= 0) {
+    double sqrtkT = sqrtkT_.size() == 1 ?
+      sqrtkT_.at(0) :
+      sqrtkT_.at(instance);
+    return sqrtkT * sqrtkT / K_BOLTZMANN;
+  } else {
+    return sqrtkT_[0] * sqrtkT_[0] / K_BOLTZMANN;
+  }
+}
+
+void
+Cell::set_temperature(double T, int32_t instance)
+{
+  if (instance >= 0) {
+    sqrtkT_.at(instance) = std::sqrt(K_BOLTZMANN * T);
+  } else {
+    for (auto& T_ : sqrtkT_) {
+      T_ = std::sqrt(K_BOLTZMANN * T);
+    }
+  }
+}
+
+//==============================================================================
+// CSGCell implementation
+//==============================================================================
+
 CSGCell::CSGCell() {} // empty constructor
 
 CSGCell::CSGCell(pugi::xml_node cell_node)
@@ -917,27 +950,18 @@ openmc_cell_set_fill(int32_t index, int type, int32_t n,
 extern "C" int
 openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance)
 {
-  if (index >= 0 && index < model::cells.size()) {
-    Cell& c {*model::cells[index]};
-
-    if (instance) {
-      if (*instance >= 0 && *instance < c.sqrtkT_.size()) {
-        c.sqrtkT_[*instance] = std::sqrt(K_BOLTZMANN * T);
-      } else {
-        strcpy(openmc_err_msg, "Distribcell instance is out of bounds.");
-        return OPENMC_E_OUT_OF_BOUNDS;
-      }
-    } else {
-      for (auto& T_ : c.sqrtkT_) {
-        T_ = std::sqrt(K_BOLTZMANN * T);
-      }
-    }
-
-  } else {
+  if (index < 0 || index >= model::cells.size()) {
     strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
+  int32_t instance_index = instance ? *instance : -1;
+  try {
+    model::cells[index]->set_temperature(T, instance_index);
+  } catch (const std::exception& e) {
+    set_errmsg(e.what());
+    return OPENMC_E_UNASSIGNED;
+  }
   return 0;
 }
 
@@ -949,25 +973,13 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  Cell& c {*model::cells[index]};
-
-  if (c.sqrtkT_.size() < 1) {
-    strcpy(openmc_err_msg, "Cell temperature has not yet been set.");
+  int32_t instance_index = instance ? *instance : -1;
+  try {
+    *T = model::cells[index]->temperature(instance_index);
+  } catch (const std::exception& e) {
+    set_errmsg(e.what());
     return OPENMC_E_UNASSIGNED;
   }
-
-  if (instance) {
-    if (*instance >= 0 && *instance < c.n_instances_) {
-      double sqrtkT = c.sqrtkT_.size() == 1 ? c.sqrtkT_[0] : c.sqrtkT_[*instance];
-      *T = sqrtkT * sqrtkT / K_BOLTZMANN;
-    } else {
-      strcpy(openmc_err_msg, "Distribcell instance is out of bounds.");
-      return OPENMC_E_OUT_OF_BOUNDS;
-    }
-  } else {
-    *T = c.sqrtkT_[0] * c.sqrtkT_[0] / K_BOLTZMANN;
-  }
-
   return 0;
 }
 

From fde8a867292689c8a008aeb48e7745c1ab42a4f6 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 9 Jul 2019 08:14:32 -0500
Subject: [PATCH 031/127] Reset ff13e98a0: write Material temperatures as
 attribute

---
 openmc/material.py | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/openmc/material.py b/openmc/material.py
index 7eb6de66c..f372dd663 100644
--- a/openmc/material.py
+++ b/openmc/material.py
@@ -841,8 +841,7 @@ class Material(IDManagerMixin):
 
         # Create temperature XML subelement
         if self.temperature is not None:
-            subelement = ET.SubElement(element, "temperature")
-            subelement.text = str(self.temperature)
+            element.set("temperature", str(self.temperature))
 
         # Create density XML subelement
         if self._density is not None or self._density_units == 'sum':
@@ -932,9 +931,8 @@ class Material(IDManagerMixin):
         mat = cls(mat_id)
         mat.name = elem.get('name')
 
-        temp_node = elem.find("temperature")
-        if temp_node is not None:
-            mat.temperature = float(temp_node.text)
+        if "temperature" in elem.attrib:
+            mat.temperature = float(elem.get("temperature"))
 
         if 'volume' in elem.attrib:
             mat.volume = float(elem.get('volume'))

From 76f3ddc5972e28ebc857a57b8f3f8301893d2492 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 9 Jul 2019 08:15:36 -0500
Subject: [PATCH 032/127] Update source regression test true input

pytest --update tests/regression/source

Temperature is written as an attribute for a material,
not a new subelement
---
 tests/regression_tests/source/inputs_true.dat | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/regression_tests/source/inputs_true.dat b/tests/regression_tests/source/inputs_true.dat
index 860a36bc8..7eeefbc00 100644
--- a/tests/regression_tests/source/inputs_true.dat
+++ b/tests/regression_tests/source/inputs_true.dat
@@ -5,8 +5,7 @@
 </geometry>
 <?xml version='1.0' encoding='utf-8'?>
 <materials>
-  <material depletable="true" id="1">
-    <temperature>294</temperature>
+  <material depletable="true" id="1" temperature="294">
     <density units="g/cm3" value="4.5" />
     <nuclide ao="1.0" name="U235" />
   </material>

From 8b963563047a35dded9ea702449e3d2d547b689d Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 9 Jul 2019 08:35:00 -0500
Subject: [PATCH 033/127] Update materials.xml format doc: temperature as
 attribute

---
 docs/source/io_formats/materials.rst | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/source/io_formats/materials.rst b/docs/source/io_formats/materials.rst
index cd198d006..ac2cfe271 100644
--- a/docs/source/io_formats/materials.rst
+++ b/docs/source/io_formats/materials.rst
@@ -42,8 +42,7 @@ Each ``material`` element can have the following attributes or sub-elements:
     Volume of the material in cm^3.
 
   :temperature:
-    An element with no attributes which is used to set the default temperature
-    of the material in Kelvin.
+    Temperature of the material in Kelvin.
 
     *Default*: If a material default temperature is not given and a cell
     temperature is not specified, the :ref:`global default temperature

From 05ce0e9f51fa27dc7fe18b8fd882a0a204bfd526 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 9 Jul 2019 08:45:01 -0500
Subject: [PATCH 034/127] Add depletion_chain element to cross_sections format

---
 docs/source/io_formats/cross_sections.rst | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/source/io_formats/cross_sections.rst b/docs/source/io_formats/cross_sections.rst
index 60f1d4f50..9f0759a3a 100644
--- a/docs/source/io_formats/cross_sections.rst
+++ b/docs/source/io_formats/cross_sections.rst
@@ -51,3 +51,20 @@ attributes:
   :type:
     The type of data contained in the file. Accepted values are 'neutron',
     'thermal', 'photon', and 'wmp'.
+
+.. _depletion_element:
+
+-----------------------------
+``<depletion_chain>`` Element
+-----------------------------
+
+The ``<depletion_chain>`` element indicates the location of the depletion chain file.
+This file contains information describing how nuclides decay and transmute to other
+nuclides through the depletion process. This element has a single attribute, ``path``,
+pointing to the location of the chain file.
+
+.. code-block:: xml
+
+    <depletion_chain path="/opt/data/chain_endfb7.xml"/>
+
+The structure of the depletion chain file is explained in :ref:`io_depletion_chain`.

From 044ac4ce2acb5f6fc257d02dd7761035502d430b Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 9 Jul 2019 20:23:54 -0500
Subject: [PATCH 035/127] Option to divide material volumes by pin divisions

---
 openmc/model/funcs.py        | 12 +++++++++++-
 tests/unit_tests/test_pin.py | 12 ++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index 4b44b450f..e0aabc872 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -448,7 +448,8 @@ def subdivide(surfaces):
     return regions
 
 
-def pin(surfaces, materials, subdivisions=None, universe_id=None, name=""):
+def pin(surfaces, materials, subdivisions=None, divide_vols=True,
+        universe_id=None, name=""):
     """Convenience function for building a fuel pin
 
     Parameters
@@ -466,6 +467,11 @@ def pin(surfaces, materials, subdivisions=None, universe_id=None, name=""):
         Dictionary describing which rings to subdivide and how
         many times. Keys are indexes of the annular rings
         to be divided. Will construct equal area rings
+    divide_vols : bool
+        If this evaluates to ``True``, then volumes of subdivided
+        materials will also be divided by the number of divisions.
+        Otherwise the volume of the original material will not be
+        modified before subdivision
     universe_id : None or int
         Identifier for this universe
     name : str
@@ -555,6 +561,10 @@ def pin(surfaces, materials, subdivisions=None, universe_id=None, name=""):
 
             surfaces = (
                     surfaces[:ring_index] + new_surfs + surfaces[ring_index:])
+
+            if divide_vols and materials[ring_index].volume is not None:
+                materials[ring_index].volume /= nr
+
             materials = (
                     materials[:ring_index]
                     + [materials[ring_index].clone() for _i in range(nr - 1)]
diff --git a/tests/unit_tests/test_pin.py b/tests/unit_tests/test_pin.py
index d2f7fa801..9a4fd19c2 100644
--- a/tests/unit_tests/test_pin.py
+++ b/tests/unit_tests/test_pin.py
@@ -23,7 +23,9 @@ def get_pin_radii(pin_univ):
 @pytest.fixture
 def pin_mats():
     fuel = openmc.Material(name="UO2")
+    fuel.volume = 100
     clad = openmc.Material(name="zirc")
+    clad.volume = 100
     water = openmc.Material(name="water")
     return fuel, clad, water
 
@@ -73,6 +75,11 @@ def test_subdivide(pin_mats, good_radii, surf_type):
     div0 = pin(surfs, pin_mats, {0: N})
     assert len(div0.cells) == len(pin_mats) + N - 1
 
+    # Check volume of fuel material
+    for mid, mat in div0.get_all_materials().items():
+        if mat.name == "UO2":
+            assert mat.volume == pytest.approx(100 / N)
+
     # check volumes of new rings
     radii = get_pin_radii(div0)
     bounds = [0] + radii[:N]
@@ -83,6 +90,11 @@ def test_subdivide(pin_mats, good_radii, surf_type):
     new_pin = pin(surfs, pin_mats, {1: N})
     assert len(new_pin.cells) == len(pin_mats) + N - 1
 
+    # Check volume of clad material
+    for mid, mat in div0.get_all_materials().items():
+        if mat.name == "zirc":
+            assert mat.volume == pytest.approx(100 / N)
+
     # check volumes of new rings
     radii = get_pin_radii(new_pin)
     sqrs = numpy.square(radii[:N + 1])

From 87fea9371472750539303ad2340087c84bc69c71 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 9 Jul 2019 20:25:34 -0500
Subject: [PATCH 036/127] Add opemc.model.pin to python api documentation

---
 docs/source/pythonapi/model.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/source/pythonapi/model.rst b/docs/source/pythonapi/model.rst
index ee038987b..1091d7cae 100644
--- a/docs/source/pythonapi/model.rst
+++ b/docs/source/pythonapi/model.rst
@@ -15,6 +15,7 @@ Convenience Functions
    openmc.model.hexagonal_prism
    openmc.model.rectangular_prism
    openmc.model.subdivide
+   openmc.model.pin
 
 TRISO Fuel Modeling
 -------------------

From 0db41d22810367ede353f128ed8b118ca226518b Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 10 Jul 2019 14:50:42 -0500
Subject: [PATCH 037/127] Update cylinder_from_points test based on @amandalund
 feedback

---
 tests/unit_tests/test_surface.py | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/tests/unit_tests/test_surface.py b/tests/unit_tests/test_surface.py
index 09bfa738e..1e3ae6f16 100644
--- a/tests/unit_tests/test_surface.py
+++ b/tests/unit_tests/test_surface.py
@@ -1,5 +1,7 @@
+from functools import partial
+from random import uniform, seed
+
 import numpy as np
-from random import random
 import openmc
 import pytest
 
@@ -330,11 +332,13 @@ def test_quadric():
 
 
 def test_cylinder_from_points():
-    for _ in range(10):
+    seed(1)  # Make random numbers reproducible
+    for _ in range(100):
         # Generate cylinder in random direction
-        p1 = np.array([random(), random(), random()])
-        p2 = np.array([random(), random(), random()])
-        r = random()
+        xi = partial(uniform, -10.0, 10.0)
+        p1 = np.array([xi(), xi(), xi()])
+        p2 = np.array([xi(), xi(), xi()])
+        r = uniform(1.0, 100.0)
         s = openmc.model.cylinder_from_points(p1, p2, r)
 
         # Points p1 and p2 need to be inside cylinder
@@ -342,16 +346,19 @@ def test_cylinder_from_points():
         assert p2 in -s
 
         # Points further along the line should be inside cylinder as well
-        t = 100*random() - 200
+        t = uniform(-100.0, 100.0)
         p = p1 + t*(p2 - p1)
         assert p in -s
 
-        # Check that a point outside cylinder is in positive half-space. We do
-        # this by constructing a plane that includes the cylinder's axis,
-        # finding the normal to the plane, and using it to find a point slightly
-        # more than one radius away from the axis.
+        # Check that points outside cylinder are in positive half-space and
+        # inside are in negative half-space. We do this by constructing a plane
+        # that includes the cylinder's axis, finding the normal to the plane,
+        # and using it to find a point slightly more/less than one radius away
+        # from the axis.
         plane = openmc.Plane.from_points(p1, p2, (0., 0., 0.))
         n = np.array([plane.a, plane.b, plane.c])
         n /= np.linalg.norm(n)
-        assert (p1 + 1.1*r*n) in +s
-        assert (p2 + 1.1*r*n) in +s
+        assert p1 + 1.1*r*n in +s
+        assert p2 + 1.1*r*n in +s
+        assert p1 + 0.9*r*n in -s
+        assert p2 + 0.9*r*n in -s

From a47dfedcc25b509d6f33929c8235369f43a5dbb2 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Wed, 10 Jul 2019 21:46:15 -0500
Subject: [PATCH 038/127] Allow from_njoy calls to use ace/xsdir keyword
 arguments

---
 openmc/data/neutron.py | 13 ++++++-------
 openmc/data/thermal.py |  9 ++++-----
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/openmc/data/neutron.py b/openmc/data/neutron.py
index 7b340f0b0..9c73152d4 100644
--- a/openmc/data/neutron.py
+++ b/openmc/data/neutron.py
@@ -801,15 +801,14 @@ class IncidentNeutron(EqualityMixin):
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Run NJOY to create an ACE library
-            ace_file = os.path.join(tmpdir, 'ace')
-            xsdir_file = os.path.join(tmpdir, 'xsdir')
-            pendf_file = os.path.join(tmpdir, 'pendf')
+            kwargs.setdefault('ace', os.path.join(tmpdir, 'ace'))
+            kwargs.setdefault('xsdir', os.path.join(tmpdir, 'xsdir'))
+            kwargs.setdefault('pendf', os.path.join(tmpdir, 'pendf'))
             kwargs['evaluation'] = evaluation
-            make_ace(filename, temperatures, ace_file, xsdir_file,
-                     pendf_file, **kwargs)
+            make_ace(filename, temperatures, **kwargs)
 
             # Create instance from ACE tables within library
-            lib = Library(ace_file)
+            lib = Library(kwargs['ace'])
             data = cls.from_ace(lib.tables[0])
             for table in lib.tables[1:]:
                 data.add_temperature_from_ace(table)
@@ -821,7 +820,7 @@ class IncidentNeutron(EqualityMixin):
 
             # Add 0K elastic scattering cross section
             if '0K' not in data.energy:
-                pendf = Evaluation(pendf_file)
+                pendf = Evaluation(kwargs['pendf'])
                 file_obj = StringIO(pendf.section[3, 2])
                 get_head_record(file_obj)
                 params, xs = get_tab1_record(file_obj)
diff --git a/openmc/data/thermal.py b/openmc/data/thermal.py
index 79cad3282..06e50c661 100644
--- a/openmc/data/thermal.py
+++ b/openmc/data/thermal.py
@@ -761,15 +761,14 @@ class ThermalScattering(EqualityMixin):
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Run NJOY to create an ACE library
-            ace_file = os.path.join(tmpdir, 'ace')
-            xsdir_file = os.path.join(tmpdir, 'xsdir')
+            kwargs.setdefault('ace', os.path.join(tmpdir, 'ace'))
+            kwargs.setdefault('xsdir', os.path.join(tmpdir, 'xsdir'))
             kwargs['evaluation'] = evaluation
             kwargs['evaluation_thermal'] = evaluation_thermal
-            make_ace_thermal(filename, filename_thermal, temperatures,
-                             ace_file, xsdir_file, **kwargs)
+            make_ace_thermal(filename, filename_thermal, temperatures, **kwargs)
 
             # Create instance from ACE tables within library
-            lib = Library(ace_file)
+            lib = Library(kwargs['ace'])
             data = cls.from_ace(lib.tables[0])
             for table in lib.tables[1:]:
                 data.add_temperature_from_ace(table)

From 9a248ad6fbe310dd710513dc11e0cbe24e00089e Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Thu, 11 Jul 2019 06:13:33 -0500
Subject: [PATCH 039/127] Fix bug in cylinder_from_points (for real this time)

---
 openmc/model/funcs.py            |  8 ++++----
 tests/unit_tests/test_surface.py | 28 ++++++++++++++++++++++++++++
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index 4e79617dd..268a649d8 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -409,10 +409,10 @@ def cylinder_from_points(p1, p2, r, **kwargs):
     kwargs['d'] = -2*dx*dy
     kwargs['e'] = -2*dy*dz
     kwargs['f'] = -2*dx*dz
-    kwargs['g'] = cy*dz - cz*dy
-    kwargs['h'] = cz*dx - cx*dz
-    kwargs['j'] = cx*dy - cy*dx
-    kwargs['k'] = -(dx*dx + dy*dy + dz*dz)*r*r
+    kwargs['g'] = 2*(cy*dz - cz*dy)
+    kwargs['h'] = 2*(cz*dx - cx*dz)
+    kwargs['j'] = 2*(cx*dy - cy*dx)
+    kwargs['k'] = cx*cx + cy*cy + cz*cz - (dx*dx + dy*dy + dz*dz)*r*r
 
     return openmc.Quadric(**kwargs)
 
diff --git a/tests/unit_tests/test_surface.py b/tests/unit_tests/test_surface.py
index 1e3ae6f16..8ce104021 100644
--- a/tests/unit_tests/test_surface.py
+++ b/tests/unit_tests/test_surface.py
@@ -362,3 +362,31 @@ def test_cylinder_from_points():
         assert p2 + 1.1*r*n in +s
         assert p1 + 0.9*r*n in -s
         assert p2 + 0.9*r*n in -s
+
+
+def test_cylinder_from_points_axis():
+    # Create axis-aligned cylinders and confirm the coefficients are as expected
+
+    # (x - 3)^2 + (y - 4)^2 = 2^2
+    # x^2 + y^2 - 6x - 8y + 21 = 0
+    s = openmc.model.cylinder_from_points((3., 4., 0.), (3., 4., 1.), 2.)
+    assert (s.a, s.b, s.c) == pytest.approx((1., 1., 0.))
+    assert (s.d, s.e, s.f) == pytest.approx((0., 0., 0.))
+    assert (s.g, s.h, s.j) == pytest.approx((-6., -8., 0.))
+    assert s.k == pytest.approx(21.)
+
+    # (y + 7)^2 + (z - 1)^2 = 3^2
+    # y^2 + z^2 + 14y - 2z + 41 = 0
+    s = openmc.model.cylinder_from_points((0., -7, 1.), (1., -7., 1.), 3.)
+    assert (s.a, s.b, s.c) == pytest.approx((0., 1., 1.))
+    assert (s.d, s.e, s.f) == pytest.approx((0., 0., 0.))
+    assert (s.g, s.h, s.j) == pytest.approx((0., 14., -2.))
+    assert s.k == 41.
+
+    # (x - 2)^2 + (z - 5)^2 = 4^2
+    # x^2 + z^2 - 4x - 10z + 13 = 0
+    s = openmc.model.cylinder_from_points((2., 0., 5.), (2., 1., 5.), 4.)
+    assert (s.a, s.b, s.c) == pytest.approx((1., 0., 1.))
+    assert (s.d, s.e, s.f) == pytest.approx((0., 0., 0.))
+    assert (s.g, s.h, s.j) == pytest.approx((-4., 0., -10.))
+    assert s.k == pytest.approx(13.)

From daf90d9db79271c81b0ca70715aa57ec2ca9e2e1 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Thu, 11 Jul 2019 06:31:12 -0500
Subject: [PATCH 040/127] Fix documentation of source_bank

---
 docs/source/io_formats/source.rst | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/docs/source/io_formats/source.rst b/docs/source/io_formats/source.rst
index cff77d2fa..6058241e1 100644
--- a/docs/source/io_formats/source.rst
+++ b/docs/source/io_formats/source.rst
@@ -13,8 +13,9 @@ is that documented here.
 :Attributes: - **filetype** (*char[]*) -- String indicating the type of file.
 
 :Datasets:
+
            - **source_bank** (Compound type) -- Source bank information for each
              particle. The compound type has fields ``wgt``, ``xyz``, ``uvw``,
-             ``E``, and ``delayed_group``, which represent the weight, position,
-             direction, energy, energy group, and delayed_group of the source
-             particle, respectively.
+             ``E``, ``delayed_group``, and ``particle``, which represent the
+             weight, position, direction, energy, energy group, delayed group,
+             and type of the source particle, respectively.

From 60d92f89d23b95beb32d71a4f968adc21ad66d0f Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 12 Jul 2019 14:17:46 -0500
Subject: [PATCH 041/127] Add temperatures to statepoints, Material.from_hdf5

Also include material attributes to summary format documentation
---
 docs/source/io_formats/summary.rst | 7 +++++++
 openmc/material.py                 | 2 ++
 src/material.cpp                   | 3 +++
 3 files changed, 12 insertions(+)

diff --git a/docs/source/io_formats/summary.rst b/docs/source/io_formats/summary.rst
index ee0d85fe3..cf0eca4aa 100644
--- a/docs/source/io_formats/summary.rst
+++ b/docs/source/io_formats/summary.rst
@@ -116,6 +116,13 @@ The current version of the summary file format is 6.0.
            - **sab_names** (*char[][]*) -- Names of
              S(:math:`\alpha,\beta`) tables assigned to the material.
 
+:Attributes: - **volume** (*double[]*) -- Volume of this material [cm^3]. Only
+               present if ``volume`` supplied
+             - **temperature** (*double[]*) -- Temperature of this material [K].
+               Only present in ``temperature`` supplied
+             - **depletable** (*int[]*) -- ``1`` if the material can be depleted,
+               ``0`` otherwise. Always present
+
 **/nuclides/**
 
 :Attributes: - **n_nuclides** (*int*) -- Number of nuclides in the problem.
diff --git a/openmc/material.py b/openmc/material.py
index f372dd663..375e1dca1 100644
--- a/openmc/material.py
+++ b/openmc/material.py
@@ -287,6 +287,8 @@ class Material(IDManagerMixin):
         material.depletable = bool(group.attrs['depletable'])
         if 'volume' in group.attrs:
             material.volume = group.attrs['volume']
+        if "temperature" in group.attrs:
+            material.temperature = group.attrs["temperature"]
 
         # Read the names of the S(a,b) tables for this Material and add them
         if 'sab_names' in group:
diff --git a/src/material.cpp b/src/material.cpp
index ccbbe57a8..f9116a935 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -898,6 +898,9 @@ void Material::to_hdf5(hid_t group) const
   if (volume_ > 0.0) {
     write_attribute(material_group, "volume", volume_);
   }
+  if (temperature_ > 0.0) {
+    write_attribute(material_group, "temperature", temperature_);
+  }
   write_dataset(material_group, "name", name_);
   write_dataset(material_group, "atom_density", density_);
 

From 0cebc507a96f6359e2ff9cdfeb218dbc9ac17d99 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 12 Jul 2019 16:45:48 -0500
Subject: [PATCH 042/127] Add support for Universe kwargs to openmc.model.pin

---
 openmc/model/funcs.py        | 14 ++++++++------
 tests/unit_tests/test_pin.py |  7 ++++++-
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index e0aabc872..1912b4215 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -449,7 +449,7 @@ def subdivide(surfaces):
 
 
 def pin(surfaces, materials, subdivisions=None, divide_vols=True,
-        universe_id=None, name=""):
+        **kwargs):
     """Convenience function for building a fuel pin
 
     Parameters
@@ -472,10 +472,9 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
         materials will also be divided by the number of divisions.
         Otherwise the volume of the original material will not be
         modified before subdivision
-    universe_id : None or int
-        Identifier for this universe
-    name : str
-        Name for this universe
+    kwargs:
+        Additional key-word arguments to be passed to
+        :class:`openmc.Universe`, like ``name="Fuel pin"``
 
     Returns
     -------
@@ -483,6 +482,9 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
         Universe of concentric cylinders filled with the desired
         materials
     """
+    if "cells" in kwargs:
+        raise SyntaxError(
+            "Cells will be set by this function, not from input arguments.")
     check_type("materials",  materials, Iterable, Material)
     check_length("surfaces", surfaces, len(materials) - 1, len(materials) - 1)
     # Check that all surfaces are of similar orientation
@@ -573,4 +575,4 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
     # Build the universe
     regions = subdivide(surfaces)
     cells = [Cell(fill=f, region=r) for r, f in zip(regions, materials)]
-    return Universe(universe_id=universe_id, name=name, cells=cells)
+    return Universe(cells=cells, **kwargs)
diff --git a/tests/unit_tests/test_pin.py b/tests/unit_tests/test_pin.py
index 9a4fd19c2..391ed816a 100644
--- a/tests/unit_tests/test_pin.py
+++ b/tests/unit_tests/test_pin.py
@@ -61,14 +61,19 @@ def test_failure(pin_mats, good_radii):
     with pytest.raises(TypeError, match="surfaces"):
         pin(surfs, pin_mats)
 
+    # Passing cells argument
+    with pytest.raises(SyntaxError, match="Cells"):
+        pin(surfs, pin_mats, cells=[])
+
 
 @pytest.mark.parametrize(
     "surf_type", [openmc.ZCylinder, openmc.XCylinder, openmc.YCylinder])
 def test_subdivide(pin_mats, good_radii, surf_type):
     """Test the subdivision with various orientations"""
     surfs = [surf_type(r=r) for r in good_radii]
-    fresh = pin(surfs, pin_mats)
+    fresh = pin(surfs, pin_mats, name="fresh pin")
     assert len(fresh.cells) == len(pin_mats)
+    assert fresh.name == "fresh pin"
 
     # subdivide inner region
     N = 5

From 768949a97274189076da51f1d2f7e3a4ca9a11bc Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 12 Jul 2019 17:08:17 -0500
Subject: [PATCH 043/127] Add support for non-Materials to be used in pin
 function

Anything that can be filled by a cell can be passed to
openmc.model.pin, including Universes and lattices.
Checks are included for the volume division, as not
all supported items, like Lattice instances, have volume
attributes.

A test was added to check this capability, where a universe
is used as one of the interior elements for the pin.

Various cosmetic changes to address reviewer comments.
---
 openmc/model/funcs.py        | 54 ++++++++++++++++++------------------
 tests/unit_tests/test_pin.py | 10 +++++++
 2 files changed, 37 insertions(+), 27 deletions(-)

diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index 1912b4215..865c3c4a9 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -448,7 +448,7 @@ def subdivide(surfaces):
     return regions
 
 
-def pin(surfaces, materials, subdivisions=None, divide_vols=True,
+def pin(surfaces, items, subdivisions=None, divide_vols=True,
         **kwargs):
     """Convenience function for building a fuel pin
 
@@ -456,22 +456,24 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
     ----------
     surfaces : iterable of :class:`openmc.Cylinder`
         Cylinders used to define boundaries
-        between materials. All cylinders must be
+        between items. All cylinders must be
         concentric and of the same orientation, e.g.
         all :class:`openmc.ZCylinder`
-    materials : iterable of :class:`openmc.Material`
-        Materials to go between ``surfaces``. There must be one
-        more material than surfaces, corresponding to the material
-        that spans all space outside the final ring.
+    items : iterable
+        Objects to go between ``surfaces``. These can be anything
+        that can fill a :class:`openmc.Cell`, including
+        :class:`openmc.Material`, or other :class:`openmc.Universe`
+        objects. There must be one more item than surfaces,
+        which will span all space outside the final ring.
     subdivisions : None or dict of int to int
         Dictionary describing which rings to subdivide and how
         many times. Keys are indexes of the annular rings
         to be divided. Will construct equal area rings
     divide_vols : bool
         If this evaluates to ``True``, then volumes of subdivided
-        materials will also be divided by the number of divisions.
-        Otherwise the volume of the original material will not be
-        modified before subdivision
+        :class:`openmc.Material`s will also be divided by the
+        number of divisions.  Otherwise the volume of the
+        original material will not be modified before subdivision
     kwargs:
         Additional key-word arguments to be passed to
         :class:`openmc.Universe`, like ``name="Fuel pin"``
@@ -480,13 +482,13 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
     -------
     :class:`openmc.Universe`
         Universe of concentric cylinders filled with the desired
-        materials
+        items
     """
     if "cells" in kwargs:
         raise SyntaxError(
             "Cells will be set by this function, not from input arguments.")
-    check_type("materials",  materials, Iterable, Material)
-    check_length("surfaces", surfaces, len(materials) - 1, len(materials) - 1)
+    check_type("items",  items, Iterable)
+    check_length("surfaces", surfaces, len(items) - 1, len(items) - 1)
     # Check that all surfaces are of similar orientation
     check_type("surface", surfaces[0], Cylinder)
     surf_type = type(surfaces[0])
@@ -511,8 +513,8 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
         if cur_rad <= prev_rad:
             raise ValueError(
                 "Surfaces do not appear to be increasing in radius. "
-                "Surface {} at index {} has radius {:7.3E} compared to "
-                "previous radius of {:7.5E}".format(
+                "Surface {} at index {} has radius {:7.3e} compared to "
+                "previous radius of {:7.5e}".format(
                     surf.id, ix, cur_rad, prev_rad))
         prev_rad = cur_rad
         centers.add(center_getter(surf))
@@ -536,8 +538,8 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
             "outer ring", max(subdivisions), len(surfaces), equality=True)
 
         # ensure ability to concatenate
-        if not isinstance(materials, list):
-            materials = list(materials)
+        if not isinstance(items, list):
+            items = list(items)
         if not isinstance(surfaces, list):
             surfaces = list(surfaces)
 
@@ -549,10 +551,8 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
             nr = subdivisions[ring_index]
             new_surfs = []
 
-            if ring_index == 0:
-                lower_rad = 0.0
-            else:
-                lower_rad = surfaces[ring_index - 1].r
+            lower_rad = 0.0 if ring_index == 0 else surfaces[ring_index - 1].r
+
             upper_rad = surfaces[ring_index].r
 
             area_term = (upper_rad ** 2 - lower_rad ** 2) / nr
@@ -564,15 +564,15 @@ def pin(surfaces, materials, subdivisions=None, divide_vols=True,
             surfaces = (
                     surfaces[:ring_index] + new_surfs + surfaces[ring_index:])
 
-            if divide_vols and materials[ring_index].volume is not None:
-                materials[ring_index].volume /= nr
+            filler = items[ring_index]
+            if (divide_vols and hasattr(filler, "volume")
+                    and filler.volume is not None):
+                filler.volume /= nr
 
-            materials = (
-                    materials[:ring_index]
-                    + [materials[ring_index].clone() for _i in range(nr - 1)]
-                    + materials[ring_index:])
+            items[ring_index:ring_index] = [
+                filler.clone() for _i in range(nr - 1)]
 
     # Build the universe
     regions = subdivide(surfaces)
-    cells = [Cell(fill=f, region=r) for r, f in zip(regions, materials)]
+    cells = [Cell(fill=f, region=r) for r, f in zip(regions, items)]
     return Universe(cells=cells, **kwargs)
diff --git a/tests/unit_tests/test_pin.py b/tests/unit_tests/test_pin.py
index 391ed816a..42241de5f 100644
--- a/tests/unit_tests/test_pin.py
+++ b/tests/unit_tests/test_pin.py
@@ -66,6 +66,16 @@ def test_failure(pin_mats, good_radii):
         pin(surfs, pin_mats, cells=[])
 
 
+def test_pins_of_universes(pin_mats, good_radii):
+    """Build a pin with a Universe in one ring"""
+    u1 = openmc.Universe(cells=[openmc.Cell(fill=pin_mats[1])])
+    new_items = pin_mats[:1] + (u1, ) + pin_mats[2:]
+    new_pin = pin(
+        [openmc.ZCylinder(r=r) for r in good_radii], new_items,
+        subdivisions={0: 2}, divide_vols=True)
+    assert len(new_pin.cells) == len(pin_mats) + 1
+
+
 @pytest.mark.parametrize(
     "surf_type", [openmc.ZCylinder, openmc.XCylinder, openmc.YCylinder])
 def test_subdivide(pin_mats, good_radii, surf_type):

From a8dc9dd562fe466b3b7d06216c9532cbc75efa52 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 09:10:13 -0500
Subject: [PATCH 044/127] Use warnings.warn when setting capture branching
 ratios

Remove calls to print for the following cases:
1) Parent nuclides not found in chain
2) Nuclides with requested branching ratios did not have capture
reactions
3) Product nuclides not found in chain
---
 openmc/deplete/chain.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/openmc/deplete/chain.py b/openmc/deplete/chain.py
index 0a52b78d7..37c53b853 100644
--- a/openmc/deplete/chain.py
+++ b/openmc/deplete/chain.py
@@ -10,6 +10,7 @@ import math
 import re
 from collections import OrderedDict, defaultdict
 from collections.abc import Mapping
+from warnings import warn
 
 from openmc.checkvalue import check_type, check_less_than
 from openmc.data import gnd_name, zam
@@ -537,7 +538,7 @@ class Chain(object):
             prod_flag = False
 
             for product in sub:
-                if product not in self.nuclide_dict:
+                if product not in self:
                     if strict:
                         raise KeyError(product)
                     missing_products[parent] = product
@@ -571,19 +572,19 @@ class Chain(object):
             sums[parent] = this_sum
 
         if len(missing_parents) > 0:
-            print("The following nuclides were not found in {}: {}".format(
-                self.__class__.__name__, ", ".join(sorted(missing_parents))))
+            warn("The following nuclides were not found in {}: {}".format(
+                 self.__class__.__name__, ", ".join(sorted(missing_parents))))
 
         if len(no_capture) > 0:
-            print("The following nuclides did not have capture reactions: "
-                  "{}".format(", ".join(sorted(no_capture))))
+            warn("The following nuclides did not have capture reactions: "
+                 "{}".format(", ".join(sorted(no_capture))))
 
         if len(missing_products) > 0:
             tail = ("{} -> {}".format(k, v)
                     for k, v in sorted(missing_products.items()))
-            print("The following products were not found in the {} and "
-                  "parents were unmodified: \n{}".format(
-                      self.__class__.__name__, ", ".join(tail)))
+            warn("The following products were not found in the {} and "
+                 "parents were unmodified: \n{}".format(
+                     self.__class__.__name__, ", ".join(tail)))
 
         # Insert new ReactionTuples with updated branch ratios
 

From ec2b1816100d97c5838ab54167f123ebafc08dd1 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 09:11:19 -0500
Subject: [PATCH 045/127] Fix all_meta logic in Chain.set_capture_branches

---
 openmc/deplete/chain.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/openmc/deplete/chain.py b/openmc/deplete/chain.py
index 37c53b853..03c7afdd6 100644
--- a/openmc/deplete/chain.py
+++ b/openmc/deplete/chain.py
@@ -602,16 +602,16 @@ class Chain(object):
             for ix in reversed(capt_index):
                 parent.reactions.pop(ix)
 
-            all_meta = False
+            all_meta = True
 
             for tgt, br in new_ratios.items():
-                all_meta |= ("_m" in tgt)
+                all_meta = all_meta and  ("_m" in tgt)
                 parent.reactions.append(ReactionTuple(
                     "(n,gamma)", tgt, capt_Q, br))
 
             if all_meta and sums[parent_name] != 1.0:
                 ground_br = 1.0 - sums[parent_name]
-                ground_tgt = grounds.get(parent_name, None)
+                ground_tgt = grounds.get(parent_name)
                 if ground_tgt is None:
                     pz, pa, pm = zam(parent_name)
                     ground_tgt = gnd_name(pz, pa + 1, 0)

From 0aebbc13791008e418adcac5f65405cd3be70117 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 11:13:45 -0500
Subject: [PATCH 046/127] Document nuclides attributes for Operator helpers

Remove some pass statements for abstract methods as well
---
 openmc/deplete/abc.py | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index 13be50812..565a04089 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -173,6 +173,12 @@ class ReactionRateHelper(ABC):
 
     Reaction rates are passed back to the operator for be used in
     an :class:`openmc.deplete.OperatorResult` instance
+
+    Attributes
+    ----------
+    nuclides : list of str
+        All nuclides with desired reaction rates. Ordered to be
+        consistent with :class:`openmc.deplete.Operator`
     """
 
     def __init__(self):
@@ -183,7 +189,6 @@ class ReactionRateHelper(ABC):
     @abstractmethod
     def generate_tallies(self, materials, scores):
         """Use the capi to build tallies needed for reaction rates"""
-        pass
 
     @property
     def nuclides(self):
@@ -222,6 +227,8 @@ class ReactionRateHelper(ABC):
 
         Parameters
         ----------
+        energy : float
+            Energy produced in this region [W]
         number : iterable of float
             Number density [#/b/cm] of each nuclide tracked in the calculation.
             Ordered identically to :attr:`nuclides`
@@ -242,6 +249,12 @@ class ReactionRateHelper(ABC):
 
 class FissionEnergyHelper(ABC):
     """Abstract class for normalizing fission reactions to a given level
+
+    Attributes
+    ----------
+    nuclides : list of str
+        All nuclides with desired reaction rates. Ordered to be
+        consistent with :class:`openmc.deplete.Operator`
     """
 
     def __init__(self):
@@ -258,12 +271,10 @@ class FissionEnergyHelper(ABC):
         :meth:`get_fission_energy`.
         ``materials`` should be a list of all materials tracked
         on the operator to which this object is attached"""
-        pass
 
     @abstractmethod
     def get_fission_energy(self, fission_rates, mat_index):
         """Return fission energy in this material given fission rates"""
-        pass
 
     @property
     def nuclides(self):

From f7628035130ff48e306729efb92048693acc27a5 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 11:14:16 -0500
Subject: [PATCH 047/127] DirectRxnRateHelper -> DirectReactionRateHelper

---
 openmc/deplete/helpers.py  | 2 +-
 openmc/deplete/operator.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index 4b79d5b3d..f039eeb70 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -13,7 +13,7 @@ from .abc import ReactionRateHelper, FissionEnergyHelper
 # -------------------------------------
 
 
-class DirectRxnRateHelper(ReactionRateHelper):
+class DirectReactionRateHelper(ReactionRateHelper):
     """Class that generates tallies for one-group rates"""
 
     def generate_tallies(self, materials, scores):
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index fab2a9f48..586a512ca 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -24,7 +24,7 @@ from . import comm
 from .abc import TransportOperator, OperatorResult
 from .atom_number import AtomNumber
 from .reaction_rates import ReactionRates
-from .helpers import DirectRxnRateHelper, ChainFissHelper
+from .helpers import DirectReactionRateHelper, ChainFissHelper
 
 
 def _distribute(items):
@@ -154,7 +154,7 @@ class Operator(TransportOperator):
             self.local_mats, self._burnable_nucs, self.chain.reactions)
 
         # Get class to assist working with tallies
-        self._rate_helper = DirectRxnRateHelper()
+        self._rate_helper = DirectReactionRateHelper()
         self._energy_helper = ChainFissHelper()
 
 

From d23fa7cf657c1bf902c078ad039cbddba33dab69 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 11:39:05 -0500
Subject: [PATCH 048/127] Improve documentation for Operator helpers

---
 openmc/deplete/abc.py     | 45 ++++++++++++++++++++++++++++-----------
 openmc/deplete/helpers.py | 10 ++++-----
 2 files changed, 37 insertions(+), 18 deletions(-)

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index 565a04089..62db6915e 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -214,10 +214,13 @@ class ReactionRateHelper(ABC):
     def get_material_rates(self, mat_id, nuc_index, react_index):
         """Return 2D array of [nuclide, reaction] reaction rates
 
-        ``nuc_index`` and ``react_index`` are orderings of nuclides
-        and reactions such that the ordering is consistent between
-        reaction tallies and energy deposition tallies"""
-        pass
+        Parameters
+        ----------
+        nuc_index : list of str
+            Ordering of desired nuclides
+        react_index : list of str
+            Ordering of reactions
+        """
 
     def divide_by_adens(self, number):
         """Normalize reaction rates by number of nuclides
@@ -230,12 +233,12 @@ class ReactionRateHelper(ABC):
         energy : float
             Energy produced in this region [W]
         number : iterable of float
-            Number density [#/b/cm] of each nuclide tracked in the calculation.
+            Number density [atoms/b/cm] of each nuclide tracked in the calculation.
             Ordered identically to :attr:`nuclides`
 
         Returns
         -------
-        results : :class:`numpy.ndarray`
+        results : `numpy.ndarray`
             2D array ``[n_nuclides, n_rxns]`` of reaction rates normalized by
             the number of nuclides
         """
@@ -265,16 +268,32 @@ class FissionEnergyHelper(ABC):
     def prepare(self, chain_nucs, rate_index, materials):
         """Perform work needed to obtain fission energy per material
 
-        ``chain_nucs`` is all nuclides tracked in the depletion chain,
-        while ``rate_index`` should be a mapping from nuclide name
-        to index in the reaction rate vector used in
-        :meth:`get_fission_energy`.
-        ``materials`` should be a list of all materials tracked
-        on the operator to which this object is attached"""
+        Parameters
+        ----------
+        chain_nucs : list of str
+            All nuclides to be tracked in this problem
+        rate_index : dict of str to int
+            Mapping from nuclide name to index in the
+            reaction rate vector used in :meth:`get_energy`.
+        materials : list of str
+            All materials tracked on the operator helped by this
+            object
+        """
 
     @abstractmethod
     def get_fission_energy(self, fission_rates, mat_index):
-        """Return fission energy in this material given fission rates"""
+        """Return fission energy in this material given fission rates
+
+        Parameters
+        ----------
+        fission_rates : numpy.ndarray
+            fission reaction rate for each isotope in the specified
+            material. Should be ordered corresponding to initial
+            ``rate_index`` used in :meth:`prepare`
+        mat_index : int
+            Index for the material requested.
+        """
+
 
     @property
     def nuclides(self):
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index f039eeb70..5e8b4146e 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -102,16 +102,16 @@ class ChainFissHelper(FissionEnergyHelper):
         self._fission_E = fiss_E
 
     def get_fission_energy(self, fiss_rates, _mat_index):
-        """Return a vector of the isotopic fission energy for this material
+        """Return fission energy for this material
 
-        parameters
+        Parameters
         ----------
         fission_rates : numpy.ndarray
             fission reaction rate for each isotope in the specified
-            material. should be ordered corresponding to initial
-            ``rate_index`` used in :meth:`set_fission_q`
+            material. Should be ordered corresponding to initial
+            ``rate_index`` used in :meth:`prepare`
         _mat_index : int
-            index for the material requested. Unused, as all
+            index for the material requested. Unused, as identical
             isotopes in all materials have the same Q value.
         """
         return dot(fiss_rates, self._fission_E)

From 3b8d9758bf77b5a89d94e3935ea138d60c8ebffa Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 11:53:01 -0500
Subject: [PATCH 049/127] Improve array filling/accessing for Operator.__call__

When possible, replaced ``x[:, :, :] = y`` with  ``x.fill(y)``.
Simple performance tests showed the approaches to be identical
with respect to process time. The latter maintains more
flexibility; whatever the shape of x becomes, no changes
need to be made, so long as x has a ``fill`` method.

Replaced ``rates[i, :, :] = ...`` with ``rates[i]`` per
reviewer comments
---
 openmc/deplete/operator.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index 586a512ca..73fad5093 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -513,7 +513,7 @@ class Operator(TransportOperator):
 
         """
         rates = self.reaction_rates
-        rates[:, :, :] = 0.0
+        rates.fill(0.0)
 
         # Get k and uncertainty
         k_combined = openmc.capi.keff()
@@ -527,7 +527,6 @@ class Operator(TransportOperator):
         react_ind = [rates.index_rx[react] for react in self.chain.reactions]
 
         # Compute fission power
-        # TODO : improve this calculation
 
         # Keep track of energy produced from all reactions in eV per source
         # particle
@@ -545,7 +544,7 @@ class Operator(TransportOperator):
             slab = materials.index(mat)
 
             # Zero out reaction rates and nuclide numbers
-            number[:] = 0.0
+            number.fill(0.0)
 
             # Get new number densities
             for nuc, i_nuc_results in zip(nuclides, nuc_ind):
@@ -559,7 +558,7 @@ class Operator(TransportOperator):
                 tally_rates[:, fission_ind], i)
 
             # Divide by total number and store
-            rates[i, :, :] = self._rate_helper.divide_by_adens(number)
+            rates[i] = self._rate_helper.divide_by_adens(number)
 
         # Reduce energy produced from all processes
         energy = comm.allreduce(energy)

From 88b28c6ff474a677936e4cd774119b4a4a2324c7 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Tue, 16 Jul 2019 06:21:42 -0500
Subject: [PATCH 050/127] Respond to @amandalund comments on #1286

---
 src/tallies/filter_legendre.cpp      |  3 +++
 src/tallies/filter_sptl_legendre.cpp |  3 +++
 src/tallies/filter_zernike.cpp       |  5 ++++-
 src/tallies/tally.cpp                | 20 +++++++++-----------
 4 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/tallies/filter_legendre.cpp b/src/tallies/filter_legendre.cpp
index 088f59ac4..3961e06d4 100644
--- a/src/tallies/filter_legendre.cpp
+++ b/src/tallies/filter_legendre.cpp
@@ -16,6 +16,9 @@ LegendreFilter::from_xml(pugi::xml_node node)
 void
 LegendreFilter::set_order(int order)
 {
+  if (order < 0) {
+    throw std::invalid_argument{"Legendre order must be non-negative."};
+  }
   order_ = order;
   n_bins_ = order_ + 1;
 }
diff --git a/src/tallies/filter_sptl_legendre.cpp b/src/tallies/filter_sptl_legendre.cpp
index 75a46348f..40d82f4c1 100644
--- a/src/tallies/filter_sptl_legendre.cpp
+++ b/src/tallies/filter_sptl_legendre.cpp
@@ -37,6 +37,9 @@ SpatialLegendreFilter::from_xml(pugi::xml_node node)
 void
 SpatialLegendreFilter::set_order(int order)
 {
+  if (order < 0) {
+    throw std::invalid_argument{"Legendre order must be non-negative."};
+  }
   order_ = order;
   n_bins_ = order_ + 1;
 }
diff --git a/src/tallies/filter_zernike.cpp b/src/tallies/filter_zernike.cpp
index 21b9a6b32..b732ef793 100644
--- a/src/tallies/filter_zernike.cpp
+++ b/src/tallies/filter_zernike.cpp
@@ -74,6 +74,9 @@ ZernikeFilter::text_label(int bin) const
 void
 ZernikeFilter::set_order(int order)
 {
+  if (order < 0) {
+    throw std::invalid_argument{"Zernike order must be non-negative."};
+  }
   order_ = order;
   n_bins_ = ((order+1) * (order+2)) / 2;
 }
@@ -111,7 +114,7 @@ ZernikeRadialFilter::text_label(int bin) const
 void
 ZernikeRadialFilter::set_order(int order)
 {
-  order_ = order;
+  ZernikeFilter::set_order(order);
   n_bins_ = order / 2 + 1;
 }
 
diff --git a/src/tallies/tally.cpp b/src/tallies/tally.cpp
index 1c9560404..27d6cc58c 100644
--- a/src/tallies/tally.cpp
+++ b/src/tallies/tally.cpp
@@ -279,18 +279,16 @@ Tally::Tally(pugi::xml_node node)
 
   // Allocate and store filter user ids
   std::vector<Filter*> filters;
-  if (!filter_ids.empty()) {
-    for (int filter_id : filter_ids) {
-      // Determine if filter ID is valid
-      auto it = model::filter_map.find(filter_id);
-      if (it == model::filter_map.end()) {
-        throw std::runtime_error{"Could not find filter " + std::to_string(filter_id)
-          + " specified on tally " + std::to_string(id_)};
-      }
-
-      // Store the index of the filter
-      filters.push_back(model::tally_filters[it->second].get());
+  for (int filter_id : filter_ids) {
+    // Determine if filter ID is valid
+    auto it = model::filter_map.find(filter_id);
+    if (it == model::filter_map.end()) {
+      throw std::runtime_error{"Could not find filter " + std::to_string(filter_id)
+        + " specified on tally " + std::to_string(id_)};
     }
+
+    // Store the index of the filter
+    filters.push_back(model::tally_filters[it->second].get());
   }
 
   // Set the filters

From 86dcdf75edbd9abd3368fd42f7eff6c87a1a56a0 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Tue, 16 Jul 2019 11:01:36 -0500
Subject: [PATCH 051/127] Fix type in SphericalHarmonicsFilter::set_cosine

Co-Authored-By: Amanda Lund <alund@anl.gov>
---
 src/tallies/filter_sph_harm.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tallies/filter_sph_harm.cpp b/src/tallies/filter_sph_harm.cpp
index 77f70c7ef..80d6878b7 100644
--- a/src/tallies/filter_sph_harm.cpp
+++ b/src/tallies/filter_sph_harm.cpp
@@ -37,7 +37,7 @@ SphericalHarmonicsFilter::set_cosine(gsl::cstring_span cosine)
     cosine_ = SphericalHarmonicsCosine::particle;
   } else {
     std::stringstream err_msg;
-    err_msg << "Unrecognized cosine type, \"" << cos
+    err_msg << "Unrecognized cosine type, \"" << cosine
             << "\" in spherical harmonics filter";
     throw std::invalid_argument{err_msg.str()};
   }

From b68e7ca9021b05a563a1c4c37a3c38e98b931618 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Mon, 6 May 2019 16:16:05 -0500
Subject: [PATCH 052/127] Adding bounding box methods to all Surface types.

---
 include/openmc/surface.h | 27 +++++++++++++--------------
 src/surface.cpp          | 35 ++++++++++++++++++++++++++++++++++-
 2 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 7b0ccefd1..78e02d994 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -31,6 +31,7 @@ extern "C" const int BC_PERIODIC;
 //==============================================================================
 
 class Surface;
+struct BoundingBox;
 
 namespace model {
   extern std::vector<std::unique_ptr<Surface>> surfaces;
@@ -105,6 +106,8 @@ public:
   //TODO: this probably needs to include i_periodic for PeriodicSurface
   virtual void to_hdf5(hid_t group_id) const = 0;
 
+  //! Get the BoundingBox for this surface.
+  virtual BoundingBox bounding_box() const = 0;
 };
 
 class CSGSurface : public Surface
@@ -126,9 +129,7 @@ protected:
 class DAGSurface : public Surface
 {
 public:
-  moab::DagMC* dagmc_ptr_;
   DAGSurface();
-  int32_t dag_index_;
 
   double evaluate(Position r) const;
   double distance(Position r, Direction u, bool coincident) const;
@@ -137,7 +138,8 @@ public:
   //! Get the bounding box of this surface.
   BoundingBox bounding_box() const;
 
-  void to_hdf5(hid_t group_id) const;
+  moab::DagMC* dagmc_ptr_;
+  int32_t dag_index_;
 };
 #endif
 //==============================================================================
@@ -165,9 +167,6 @@ public:
   //!   boundary condition.
   virtual bool periodic_translate(const PeriodicSurface* other, Position& r,
                                   Direction& u) const = 0;
-
-  //! Get the bounding box for this surface.
-  virtual BoundingBox bounding_box() const = 0;
 };
 
 //==============================================================================
@@ -269,7 +268,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double y0_, z0_, radius_;
 };
 
@@ -288,7 +287,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double x0_, z0_, radius_;
 };
 
@@ -307,7 +306,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double x0_, y0_, radius_;
 };
 
@@ -326,7 +325,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double x0_, y0_, z0_, radius_;
 };
 
@@ -345,7 +344,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -364,7 +363,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -383,7 +382,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -401,7 +400,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-
+  BoundingBox bounding_box() const;
   // Ax^2 + By^2 + Cz^2 + Dxy + Eyz + Fxz + Gx + Hy + Jz + K = 0
   double A_, B_, C_, D_, E_, F_, G_, H_, J_, K_;
 };
diff --git a/src/surface.cpp b/src/surface.cpp
index f364694a0..7b610031f 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -645,7 +645,6 @@ Direction SurfaceXCylinder::normal(Position r) const
   return axis_aligned_cylinder_normal<0, 1, 2>(r, y0_, z0_);
 }
 
-
 void SurfaceXCylinder::to_hdf5_inner(hid_t group_id) const
 {
   write_string(group_id, "type", "x-cylinder", false);
@@ -653,6 +652,9 @@ void SurfaceXCylinder::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceXCylinder::bounding_box() const {
+  return {-INFTY, INFTY, y0_ - radius_, y0_ + radius_, z0_ - radius_, z0_ + radius_};
+}
 //==============================================================================
 // SurfaceYCylinder implementation
 //==============================================================================
@@ -686,6 +688,10 @@ void SurfaceYCylinder::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceYCylinder::bounding_box() const {
+  return {x0_ - radius_, x0_ + radius_, -INFTY, INFTY, z0_ - radius_, z0_ + radius_};
+}
+
 //==============================================================================
 // SurfaceZCylinder implementation
 //==============================================================================
@@ -719,6 +725,11 @@ void SurfaceZCylinder::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceZCylinder::bounding_box() const {
+  return {x0_ - radius_, x0_ + radius_, y0_ - radius_, y0_ + radius_, -INFTY, INFTY};
+}
+
+
 //==============================================================================
 // SurfaceSphere implementation
 //==============================================================================
@@ -787,6 +798,12 @@ void SurfaceSphere::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceSphere::bounding_box() const {
+  return {x0_ - radius_, x0_ + radius_,
+          y0_ - radius_, y0_ + radius_,
+          z0_ - radius_, z0_ + radius_};
+}
+
 //==============================================================================
 // Generic functions for x-, y-, and z-, cones
 //==============================================================================
@@ -905,6 +922,10 @@ void SurfaceXCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceXCone::bounding_box() const {
+  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+}
+
 //==============================================================================
 // SurfaceYCone implementation
 //==============================================================================
@@ -938,6 +959,10 @@ void SurfaceYCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceYCone::bounding_box() const {
+  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+}
+
 //==============================================================================
 // SurfaceZCone implementation
 //==============================================================================
@@ -971,6 +996,10 @@ void SurfaceZCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceZCone::bounding_box() const {
+  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+}
+
 //==============================================================================
 // SurfaceQuadric implementation
 //==============================================================================
@@ -1064,6 +1093,10 @@ void SurfaceQuadric::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
+BoundingBox SurfaceQuadric::bounding_box() const {
+  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+}
+
 //==============================================================================
 
 void read_surfaces(pugi::xml_node node)

From 446e78cb87a68cb451839bf6cd642dd1174138dd Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 20 Jun 2019 09:54:13 -0500
Subject: [PATCH 053/127] Updating bounding box definitions for all surfaces.

---
 include/openmc/cell.h    |   5 ++
 include/openmc/surface.h |  61 +++++++++++++++--------
 src/cell.cpp             |   7 +++
 src/surface.cpp          | 102 ++++++++++++++++++++++++++++++---------
 4 files changed, 131 insertions(+), 44 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index afe40fe43..8329bc510 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -114,6 +114,9 @@ public:
   //! \param group_id An HDF5 group id.
   virtual void to_hdf5(hid_t group_id) const = 0;
 
+  //! Get the BoundingBox for this cell.
+  virtual BoundingBox bounding_box() const = 0;
+
   //----------------------------------------------------------------------------
   // Accessors
 
@@ -192,6 +195,8 @@ public:
 
   void to_hdf5(hid_t group_id) const;
 
+  BoundingBox bounding_box() const;
+
 protected:
   bool contains_simple(Position r, Direction u, int32_t on_surface) const;
   bool contains_complex(Position r, Direction u, int32_t on_surface) const;
diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 78e02d994..3c5ece4f9 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -44,12 +44,33 @@ namespace model {
 
 struct BoundingBox
 {
-  double xmin;
-  double xmax;
-  double ymin;
-  double ymax;
-  double zmin;
-  double zmax;
+  double xmin = INFTY;
+  double xmax = -INFTY;
+  double ymin = INFTY;
+  double ymax = -INFTY;
+  double zmin = INFTY;
+  double zmax = -INFTY;
+
+  // in-place update
+  inline void update(const BoundingBox& other) {
+    xmin = std::min(xmin, other.xmin);
+    xmax = std::max(xmax, other.xmax);
+    ymin = std::min(ymin, other.ymin);
+    ymax = std::max(ymax, other.ymax);
+    zmin = std::min(zmin, other.zmin);
+    zmax = std::max(zmax, other.zmax);
+  };
+
+  // in-place intersection
+  inline void intersect(const BoundingBox& other) {
+    xmin = std::max(xmin, other.xmin);
+    xmax = std::min(xmax, other.xmax);
+    ymin = std::max(ymin, other.ymin);
+    ymax = std::min(ymax, other.ymax);
+    zmin = std::max(zmin, other.zmin);
+    zmax = std::min(zmax, other.zmax);
+  }
+
 };
 
 //==============================================================================
@@ -107,7 +128,7 @@ public:
   virtual void to_hdf5(hid_t group_id) const = 0;
 
   //! Get the BoundingBox for this surface.
-  virtual BoundingBox bounding_box() const = 0;
+  virtual BoundingBox bounding_box(bool pos_side) const = 0;
 };
 
 class CSGSurface : public Surface
@@ -136,7 +157,7 @@ public:
   Direction normal(Position r) const;
   Direction reflect(Position r, Direction u) const;
   //! Get the bounding box of this surface.
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
 
   moab::DagMC* dagmc_ptr_;
   int32_t dag_index_;
@@ -185,7 +206,7 @@ public:
   void to_hdf5_inner(hid_t group_id) const;
   bool periodic_translate(const PeriodicSurface* other, Position& r,
                           Direction& u) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
 
   double x0_;
 };
@@ -206,7 +227,7 @@ public:
   void to_hdf5_inner(hid_t group_id) const;
   bool periodic_translate(const PeriodicSurface* other, Position& r,
                           Direction& u) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
 
   double y0_;
 };
@@ -227,7 +248,7 @@ public:
   void to_hdf5_inner(hid_t group_id) const;
   bool periodic_translate(const PeriodicSurface* other, Position& r,
                           Direction& u) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
 
   double z0_;
 };
@@ -248,7 +269,7 @@ public:
   void to_hdf5_inner(hid_t group_id) const;
   bool periodic_translate(const PeriodicSurface* other, Position& r,
                           Direction& u) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
 
   double A_, B_, C_, D_;
 };
@@ -268,7 +289,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double y0_, z0_, radius_;
 };
 
@@ -287,7 +308,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double x0_, z0_, radius_;
 };
 
@@ -306,7 +327,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double x0_, y0_, radius_;
 };
 
@@ -325,7 +346,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double x0_, y0_, z0_, radius_;
 };
 
@@ -344,7 +365,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -363,7 +384,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -382,7 +403,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -400,7 +421,7 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box() const;
+  BoundingBox bounding_box(bool pos_side) const;
   // Ax^2 + By^2 + Cz^2 + Dxy + Eyz + Fxz + Gx + Hy + Jz + K = 0
   double A_, B_, C_, D_, E_, F_, G_, H_, J_, K_;
 };
diff --git a/src/cell.cpp b/src/cell.cpp
index 04273eded..9afae2d60 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -567,6 +567,13 @@ CSGCell::to_hdf5(hid_t cell_group) const
   close_group(group);
 }
 
+BoundingBox CSGCell::bounding_box() const {
+  BoundingBox bbox;
+  for (int32_t token : rpn_) {
+    bbox.update(model::surfaces[abs(token)-1]->bounding_box(token > 0));
+  }
+}
+
 //==============================================================================
 
 bool
diff --git a/src/surface.cpp b/src/surface.cpp
index 7b610031f..e9d2f964e 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -271,7 +271,7 @@ Direction DAGSurface::reflect(Position r, Direction u) const
   return simulation::last_dir;
 }
 
-BoundingBox DAGSurface::bounding_box() const
+BoundingBox DAGSurface::bounding_box(bool pos_side) const
 {
   moab::ErrorCode rval;
   moab::EntityHandle surf = dagmc_ptr_->entity_by_index(2, dag_index_);
@@ -366,9 +366,13 @@ bool SurfaceXPlane::periodic_translate(const PeriodicSurface* other,
 }
 
 BoundingBox
-SurfaceXPlane::bounding_box() const
+SurfaceXPlane::bounding_box(bool pos_side) const
 {
-  return {x0_, x0_, -INFTY, INFTY, -INFTY, INFTY};
+  if (pos_side) {
+    return {x0_, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  } else {
+    return {-INFTY, x0_, -INFTY, INFTY, -INFTY, INFTY};
+  }
 }
 
 //==============================================================================
@@ -428,9 +432,13 @@ bool SurfaceYPlane::periodic_translate(const PeriodicSurface* other,
 }
 
 BoundingBox
-SurfaceYPlane::bounding_box() const
+SurfaceYPlane::bounding_box(bool pos_side) const
 {
-  return {-INFTY, INFTY, y0_, y0_, -INFTY, INFTY};
+  if (pos_side) {
+    return {-INFTY, INFTY, y0_, INFTY, -INFTY, INFTY};
+  } else {
+    return {-INFTY, INFTY, -INFTY, y0_, -INFTY, INFTY};
+  }
 }
 
 //==============================================================================
@@ -474,9 +482,13 @@ bool SurfaceZPlane::periodic_translate(const PeriodicSurface* other,
 }
 
 BoundingBox
-SurfaceZPlane::bounding_box() const
+SurfaceZPlane::bounding_box(bool pos_side) const
 {
-  return {-INFTY, INFTY, -INFTY, INFTY, z0_, z0_};
+  if (pos_side) {
+    return {-INFTY, INFTY, -INFTY, INFTY, z0_, INFTY};
+  } else {
+    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, z0_};
+  }
 }
 
 //==============================================================================
@@ -539,9 +551,34 @@ bool SurfacePlane::periodic_translate(const PeriodicSurface* other, Position& r,
 }
 
 BoundingBox
-SurfacePlane::bounding_box() const
+SurfacePlane::bounding_box(bool pos_side) const
 {
-  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  BoundingBox bbox = {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  if (A_ == 0.0 && B_ == 0.0) {
+    double val = D_ / C_;
+    if (pos_side) {
+      bbox.zmin = val;
+    } else {
+      bbox.zmax = val;
+    }
+  } else if (A_ == 0.0 && C_ == 0.0) {
+    double val = D_ / B_;
+    if (pos_side) {
+    bbox.ymin = val;
+    } else {
+    bbox.ymax = val;
+    }
+  } else if (B_ == 0.0 && C_ == 0.0) {
+    double val = D_ / A_;
+    if (pos_side) {
+    bbox.xmin = val;
+    } else {
+    bbox.xmax = val;
+    }
+  }
+
+  return bbox;
+
 }
 
 //==============================================================================
@@ -652,8 +689,12 @@ void SurfaceXCylinder::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceXCylinder::bounding_box() const {
-  return {-INFTY, INFTY, y0_ - radius_, y0_ + radius_, z0_ - radius_, z0_ + radius_};
+BoundingBox SurfaceXCylinder::bounding_box(bool pos_side) const {
+  if (pos_side) {
+    return {-INFTY, INFTY, y0_ - radius_, y0_ + radius_, z0_ - radius_, z0_ + radius_};
+  } else {
+    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  }
 }
 //==============================================================================
 // SurfaceYCylinder implementation
@@ -688,8 +729,12 @@ void SurfaceYCylinder::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceYCylinder::bounding_box() const {
-  return {x0_ - radius_, x0_ + radius_, -INFTY, INFTY, z0_ - radius_, z0_ + radius_};
+BoundingBox SurfaceYCylinder::bounding_box(bool pos_side) const {
+  if (pos_side) {
+    return {x0_ - radius_, x0_ + radius_, -INFTY, INFTY, z0_ - radius_, z0_ + radius_};
+  } else {
+    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  }
 }
 
 //==============================================================================
@@ -725,8 +770,12 @@ void SurfaceZCylinder::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceZCylinder::bounding_box() const {
-  return {x0_ - radius_, x0_ + radius_, y0_ - radius_, y0_ + radius_, -INFTY, INFTY};
+BoundingBox SurfaceZCylinder::bounding_box(bool pos_side) const {
+  if (pos_side) {
+    return {x0_ - radius_, x0_ + radius_, y0_ - radius_, y0_ + radius_, -INFTY, INFTY};
+  } else {
+    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  }
 }
 
 
@@ -798,10 +847,14 @@ void SurfaceSphere::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceSphere::bounding_box() const {
-  return {x0_ - radius_, x0_ + radius_,
-          y0_ - radius_, y0_ + radius_,
-          z0_ - radius_, z0_ + radius_};
+BoundingBox SurfaceSphere::bounding_box(bool pos_side) const {
+  if (pos_side) {
+    return {x0_ - radius_, x0_ + radius_,
+            y0_ - radius_, y0_ + radius_,
+            z0_ - radius_, z0_ + radius_};
+  } else {
+    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  }
 }
 
 //==============================================================================
@@ -922,7 +975,7 @@ void SurfaceXCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceXCone::bounding_box() const {
+BoundingBox SurfaceXCone::bounding_box(bool pos_side) const {
   return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
 }
 
@@ -959,7 +1012,7 @@ void SurfaceYCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceYCone::bounding_box() const {
+BoundingBox SurfaceYCone::bounding_box(bool pos_side) const {
   return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
 }
 
@@ -996,7 +1049,7 @@ void SurfaceZCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceZCone::bounding_box() const {
+BoundingBox SurfaceZCone::bounding_box(bool pos_side) const {
   return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
 }
 
@@ -1093,7 +1146,7 @@ void SurfaceQuadric::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceQuadric::bounding_box() const {
+BoundingBox SurfaceQuadric::bounding_box(bool pos_side) const {
   return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
 }
 
@@ -1194,7 +1247,8 @@ void read_surfaces(pugi::xml_node node)
       }
 
       // See if this surface makes part of the global bounding box.
-      BoundingBox bb = surf->bounding_box();
+      BoundingBox bb = surf->bounding_box(true);
+      bb.intersect(surf->bounding_box(false));
       if (bb.xmin > -INFTY && bb.xmin < xmin) {
         xmin = bb.xmin;
         i_xmin = i_surf;

From 470e26c78337585bb2b5e703ba4a464d3177865e Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 21 Jun 2019 00:27:18 -0500
Subject: [PATCH 054/127] Adding bbox defs for cells.

---
 include/openmc/cell.h    |  2 ++
 include/openmc/surface.h |  7 +++++++
 src/cell.cpp             | 10 ++++++++++
 src/surface.cpp          |  1 +
 4 files changed, 20 insertions(+)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index 8329bc510..b4848bb50 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -217,6 +217,8 @@ public:
   std::pair<double, int32_t>
   distance(Position r, Direction u, int32_t on_surface) const;
 
+  BoundingBox bounding_box() const;
+
   void to_hdf5(hid_t group_id) const;
 };
 #endif
diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 3c5ece4f9..f218f7ac7 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -139,6 +139,8 @@ public:
 
   void to_hdf5(hid_t group_id) const;
 
+  virtual BoundingBox bounding_box(bool pos_side) const = 0;
+
 protected:
   virtual void to_hdf5_inner(hid_t group_id) const = 0;
 };
@@ -159,6 +161,8 @@ public:
   //! Get the bounding box of this surface.
   BoundingBox bounding_box(bool pos_side) const;
 
+  void to_hdf5(hid_t group_id) const;
+
   moab::DagMC* dagmc_ptr_;
   int32_t dag_index_;
 };
@@ -188,6 +192,9 @@ public:
   //!   boundary condition.
   virtual bool periodic_translate(const PeriodicSurface* other, Position& r,
                                   Direction& u) const = 0;
+
+  //! Get the bounding box for this surface.
+  virtual BoundingBox bounding_box(bool pos_side) const = 0;
 };
 
 //==============================================================================
diff --git a/src/cell.cpp b/src/cell.cpp
index 9afae2d60..ebf466bd6 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -698,6 +698,16 @@ bool DAGCell::contains(Position r, Direction u, int32_t on_surface) const
 
 void DAGCell::to_hdf5(hid_t group_id) const { return; }
 
+BoundingBox DAGCell::bounding_box() const
+{
+  moab::ErrorCode rval;
+  moab::EntityHandle vol = dagmc_ptr_->entity_by_index(3, dag_index_);
+  double min[3], max[3];
+  rval = dagmc_ptr_->getobb(vol, min, max);
+  MB_CHK_ERR_CONT(rval);
+  return {min[0], max[0], min[1], max[1], min[2], max[2]};
+}
+
 #endif
 
 //==============================================================================
diff --git a/src/surface.cpp b/src/surface.cpp
index e9d2f964e..ae8a5b6c4 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -282,6 +282,7 @@ BoundingBox DAGSurface::bounding_box(bool pos_side) const
 }
 
 void DAGSurface::to_hdf5(hid_t group_id) const {}
+
 #endif
 //==============================================================================
 // PeriodicSurface implementation

From 08239a98d276e897f0bdffec6826727531817841 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 21 Jun 2019 14:51:06 -0500
Subject: [PATCH 055/127] Adding a bounding box method to the universe class.

---
 include/openmc/cell.h |  2 ++
 src/cell.cpp          | 22 ++++++++++++++++++++--
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index b4848bb50..a6432a304 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -65,6 +65,8 @@ public:
   //! \param group_id An HDF5 group id.
   void to_hdf5(hid_t group_id) const;
 
+  BoundingBox bounding_box() const;
+
   std::unique_ptr<UniversePartitioner> partitioner_;
 };
 
diff --git a/src/cell.cpp b/src/cell.cpp
index ebf466bd6..107724c61 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -208,6 +208,19 @@ Universe::to_hdf5(hid_t universes_group) const
   close_group(group);
 }
 
+BoundingBox Universe::bounding_box() const {
+  BoundingBox bbox;
+  if (cells_.size() == 0) {
+    bbox = {-INFTY, INFTY, -INFTY, -INFTY, INFTY};
+  } else {
+    for (const auto& cell : cells_) {
+      auto& c = model::cells[cell];
+      bbox.update(c->bounding_box());
+    }
+  }
+  return bbox;
+}
+
 //==============================================================================
 // Cell implementation
 //==============================================================================
@@ -569,9 +582,14 @@ CSGCell::to_hdf5(hid_t cell_group) const
 
 BoundingBox CSGCell::bounding_box() const {
   BoundingBox bbox;
-  for (int32_t token : rpn_) {
-    bbox.update(model::surfaces[abs(token)-1]->bounding_box(token > 0));
+  if (rpn_.size() == 0) {
+    bbox = {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  } else {
+    for (int32_t token : rpn_) {
+      bbox.update(model::surfaces[abs(token)-1]->bounding_box(token > 0));
+    }
   }
+  return bbox;
 }
 
 //==============================================================================

From ecbf7596c0f84f889e98969351070f4b2717803d Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 25 Jun 2019 12:33:22 -0500
Subject: [PATCH 056/127] Corrections to surface bounding boxes based on sign.
 Corrections to cell/universe bounding boxes and capi exposure.

---
 include/openmc/capi.h    |  1 +
 include/openmc/surface.h | 16 +++++++++------
 openmc/capi/core.py      | 17 ++++++++++++++++
 src/cell.cpp             |  4 ++--
 src/geometry.cpp         | 43 ++++++++++++++++++++++++++++++++++++++++
 src/surface.cpp          |  8 ++++----
 6 files changed, 77 insertions(+), 12 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index 148a28c88..ad2adae24 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -29,6 +29,7 @@ extern "C" {
   int openmc_filter_set_id(int32_t index, int32_t id);
   int openmc_finalize();
   int openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance);
+  int openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc);
   int openmc_fission_bank(void** ptr, int64_t* n);
   int openmc_get_cell_index(int32_t id, int32_t* index);
   int openmc_get_filter_index(int32_t id, int32_t* index);
diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index f218f7ac7..69c11476c 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -44,12 +44,12 @@ namespace model {
 
 struct BoundingBox
 {
-  double xmin = INFTY;
-  double xmax = -INFTY;
-  double ymin = INFTY;
-  double ymax = -INFTY;
-  double zmin = INFTY;
-  double zmax = -INFTY;
+  double xmin = -INFTY;
+  double xmax = INFTY;
+  double ymin = -INFTY;
+  double ymax = INFTY;
+  double zmin = -INFTY;
+  double zmax = INFTY;
 
   // in-place update
   inline void update(const BoundingBox& other) {
@@ -71,8 +71,12 @@ struct BoundingBox
     zmax = std::min(zmax, other.zmax);
   }
 
+
 };
 
+
+
+
 //==============================================================================
 //! A geometry primitive used to define regions of 3D space.
 //==============================================================================
diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index aae17e06a..5744e123c 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -74,6 +74,23 @@ _dll.openmc_statepoint_write.argtypes = [c_char_p, POINTER(c_bool)]
 _dll.openmc_statepoint_write.restype = c_int
 _dll.openmc_statepoint_write.errcheck = _error_handler
 
+_dll.openmc_bounding_box.argtypes = [c_char_p, c_int, POINTER(c_double),
+                                     POINTER(c_double)]
+_dll.openmc_bounding_box.restype = c_int
+_dll.openmc_bounding_box.errcheck = _error_handler
+
+def bounding_box(geom_type, geom_id):
+
+    geomt = c_char_p(geom_type.encode())
+    llc = np.zeros((3,), dtype=float)
+    urc = np.zeros((3,), dtype=float)
+    _dll.openmc_bounding_box(geomt,
+                             geom_id,
+                             llc.ctypes.data_as(POINTER(c_double)),
+                             urc.ctypes.data_as(POINTER(c_double)))
+
+    return llc, urc
+
 
 def calculate_volumes():
     """Run stochastic volume calculation"""
diff --git a/src/cell.cpp b/src/cell.cpp
index 107724c61..d646660fb 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -209,7 +209,7 @@ Universe::to_hdf5(hid_t universes_group) const
 }
 
 BoundingBox Universe::bounding_box() const {
-  BoundingBox bbox;
+  BoundingBox bbox = {INFTY, -INFTY, INFTY, -INFTY, INFTY, -INFTY};
   if (cells_.size() == 0) {
     bbox = {-INFTY, INFTY, -INFTY, -INFTY, INFTY};
   } else {
@@ -586,7 +586,7 @@ BoundingBox CSGCell::bounding_box() const {
     bbox = {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
   } else {
     for (int32_t token : rpn_) {
-      bbox.update(model::surfaces[abs(token)-1]->bounding_box(token > 0));
+      bbox.intersect(model::surfaces[abs(token)-1]->bounding_box(token > 0));
     }
   }
   return bbox;
diff --git a/src/geometry.cpp b/src/geometry.cpp
index 0f89a0ecd..ed75444ec 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -9,6 +9,7 @@
 #include "openmc/lattice.h"
 #include "openmc/settings.h"
 #include "openmc/simulation.h"
+#include "openmc/string_utils.h"
 #include "openmc/surface.h"
 
 
@@ -475,4 +476,46 @@ openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance)
   return 0;
 }
 
+extern "C" int
+openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc) {
+
+  BoundingBox bbox;
+
+  std::string gtype(geom_type);
+  to_lower(gtype);
+
+  std::cout << gtype << std::endl;
+
+  if (gtype == "universe") {
+    // negative ids only apply to surfaces
+    if (id < 0) { return OPENMC_E_GEOMETRY; }
+    const auto& u = model::universes[model::universe_map[id]];
+    bbox = u->bounding_box();
+  } else if (gtype == "cell") {
+    // negative ids only apply to surfaces
+    if (id < 0) { return OPENMC_E_GEOMETRY; }
+    const auto& c = model::cells[model::cell_map[id]];
+    bbox = c->bounding_box();
+  } else if (gtype == "surface") {
+    const auto& s = model::surfaces[model::surface_map[abs(id)]];
+    bbox = s->bounding_box(id > 0);
+  } else {
+    std::stringstream msg;
+    msg << "Geometry type: " << gtype << " is invalid.";
+    return OPENMC_E_GEOMETRY;
+  }
+
+  // set lower left corner values
+  llc[0] = bbox.xmin;
+  llc[1] = bbox.ymin;
+  llc[2] = bbox.zmin;
+
+  // set upper right corner values
+  urc[0] = bbox.xmax;
+  urc[1] = bbox.ymax;
+  urc[2] = bbox.zmax;
+
+  return 0;
+}
+
 } // namespace openmc
diff --git a/src/surface.cpp b/src/surface.cpp
index ae8a5b6c4..9eaccef3d 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -691,7 +691,7 @@ void SurfaceXCylinder::to_hdf5_inner(hid_t group_id) const
 }
 
 BoundingBox SurfaceXCylinder::bounding_box(bool pos_side) const {
-  if (pos_side) {
+  if (!pos_side) {
     return {-INFTY, INFTY, y0_ - radius_, y0_ + radius_, z0_ - radius_, z0_ + radius_};
   } else {
     return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
@@ -731,7 +731,7 @@ void SurfaceYCylinder::to_hdf5_inner(hid_t group_id) const
 }
 
 BoundingBox SurfaceYCylinder::bounding_box(bool pos_side) const {
-  if (pos_side) {
+  if (!pos_side) {
     return {x0_ - radius_, x0_ + radius_, -INFTY, INFTY, z0_ - radius_, z0_ + radius_};
   } else {
     return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
@@ -772,7 +772,7 @@ void SurfaceZCylinder::to_hdf5_inner(hid_t group_id) const
 }
 
 BoundingBox SurfaceZCylinder::bounding_box(bool pos_side) const {
-  if (pos_side) {
+  if (!pos_side) {
     return {x0_ - radius_, x0_ + radius_, y0_ - radius_, y0_ + radius_, -INFTY, INFTY};
   } else {
     return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
@@ -849,7 +849,7 @@ void SurfaceSphere::to_hdf5_inner(hid_t group_id) const
 }
 
 BoundingBox SurfaceSphere::bounding_box(bool pos_side) const {
-  if (pos_side) {
+  if (!pos_side) {
     return {x0_ - radius_, x0_ + radius_,
             y0_ - radius_, y0_ + radius_,
             z0_ - radius_, z0_ + radius_};

From 2ac505814e22019644459eedac70aa9eb24e7d08 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 9 Jul 2019 11:11:25 -0500
Subject: [PATCH 057/127] Adding test for universe bounding box.

---
 tests/unit_tests/test_capi.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index af86a054d..aa938f8b2 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -469,3 +469,18 @@ def test_position(capi_init):
     pos[2] = 3.3
 
     assert tuple(pos) == (1.3, 2.3, 3.3)
+
+def test_bounding_box(capi_init):
+
+    expected_llc = (-0.63, -0.63, -np.inf)
+    expected_urc = (0.63, 0.63, np.inf)
+
+    llc, urc = openmc.capi.bounding_box("Universe", 0)
+
+    assert llc[0] == expected_llc[0]
+    assert llc[1] == expected_llc[1]
+    assert llc[2] < 1.0E10
+
+    assert urc[0] == expected_urc[0]
+    assert urc[1] == expected_urc[1]
+    assert urc[2] > 1.E10

From a10570245520dee4d1aafcfcc42a356ffa7c8f91 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 9 Jul 2019 16:23:24 -0500
Subject: [PATCH 058/127] Updates to CAPI bounding box methods. Addition of
 global bounding box method. Adding tests for PWR pincell model.

---
 include/openmc/capi.h         |  1 +
 openmc/capi/core.py           | 14 +++++++-
 src/geometry.cpp              | 24 ++++++++++---
 tests/unit_tests/test_capi.py | 67 ++++++++++++++++++++++++++++++-----
 4 files changed, 92 insertions(+), 14 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index ad2adae24..11b8a6ef6 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -30,6 +30,7 @@ extern "C" {
   int openmc_finalize();
   int openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance);
   int openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc);
+  int openmc_global_bounding_box(double* llc, double* urc);
   int openmc_fission_bank(void** ptr, int64_t* n);
   int openmc_get_cell_index(int32_t id, int32_t* index);
   int openmc_get_filter_index(int32_t id, int32_t* index);
diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index 5744e123c..ed78b38b6 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -73,11 +73,23 @@ _dll.openmc_simulation_finalize.errcheck = _error_handler
 _dll.openmc_statepoint_write.argtypes = [c_char_p, POINTER(c_bool)]
 _dll.openmc_statepoint_write.restype = c_int
 _dll.openmc_statepoint_write.errcheck = _error_handler
-
 _dll.openmc_bounding_box.argtypes = [c_char_p, c_int, POINTER(c_double),
                                      POINTER(c_double)]
 _dll.openmc_bounding_box.restype = c_int
 _dll.openmc_bounding_box.errcheck = _error_handler
+_dll.openmc_global_bounding_box.argtypes = [POINTER(c_double),
+                                            POINTER(c_double)]
+_dll.openmc_global_bounding_box.restype = c_int
+_dll.openmc_global_bounding_box.errcheck = _error_handler
+
+def global_bounding_box():
+
+    llc = np.zeros((3,), dtype=float)
+    urc = np.zeros((3,), dtype=float)
+    _dll.openmc_global_bounding_box(llc.ctypes.data_as(POINTER(c_double)),
+                             urc.ctypes.data_as(POINTER(c_double)))
+
+    return llc, urc
 
 def bounding_box(geom_type, geom_id):
 
diff --git a/src/geometry.cpp b/src/geometry.cpp
index ed75444ec..43620644f 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -484,19 +484,18 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
   std::string gtype(geom_type);
   to_lower(gtype);
 
-  std::cout << gtype << std::endl;
-
   if (gtype == "universe") {
     // negative ids only apply to surfaces
-    if (id < 0) { return OPENMC_E_GEOMETRY; }
+    if (id <= 0) { return OPENMC_E_GEOMETRY; }
     const auto& u = model::universes[model::universe_map[id]];
     bbox = u->bounding_box();
   } else if (gtype == "cell") {
     // negative ids only apply to surfaces
-    if (id < 0) { return OPENMC_E_GEOMETRY; }
+    if (id <= 0) { return OPENMC_E_GEOMETRY; }
     const auto& c = model::cells[model::cell_map[id]];
     bbox = c->bounding_box();
   } else if (gtype == "surface") {
+    if (id == 0) { return OPENMC_E_GEOMETRY; }
     const auto& s = model::surfaces[model::surface_map[abs(id)]];
     bbox = s->bounding_box(id > 0);
   } else {
@@ -518,4 +517,21 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
   return 0;
 }
 
+extern "C" int openmc_global_bounding_box(double* llc, double* urc) {
+  auto bbox = model::universes[model::root_universe]->bounding_box();
+
+  // set lower left corner values
+  llc[0] = bbox.xmin;
+  llc[1] = bbox.ymin;
+  llc[2] = bbox.zmin;
+
+  // set upper right corner values
+  urc[0] = bbox.xmax;
+  urc[1] = bbox.ymax;
+  urc[2] = bbox.zmax;
+
+  return 0;
+}
+
+
 } // namespace openmc
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index aa938f8b2..d611c20c7 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -1,5 +1,6 @@
 from collections.abc import Mapping
 import os
+import sys
 
 import numpy as np
 import pytest
@@ -472,15 +473,63 @@ def test_position(capi_init):
 
 def test_bounding_box(capi_init):
 
-    expected_llc = (-0.63, -0.63, -np.inf)
-    expected_urc = (0.63, 0.63, np.inf)
+    inf = sys.float_info.max
 
-    llc, urc = openmc.capi.bounding_box("Universe", 0)
+    expected_llc = (-inf, -0.63, -inf)
+    expected_urc = (inf, inf, inf)
 
-    assert llc[0] == expected_llc[0]
-    assert llc[1] == expected_llc[1]
-    assert llc[2] < 1.0E10
+    llc, urc = openmc.capi.bounding_box("Surface", 5)
 
-    assert urc[0] == expected_urc[0]
-    assert urc[1] == expected_urc[1]
-    assert urc[2] > 1.E10
+    print(llc)
+    print(urc)
+
+    assert tuple(llc) == expected_llc
+    assert tuple(urc) == expected_urc
+
+
+    expected_llc = (-inf, -inf, -inf)
+    expected_urc = (inf, -0.63, inf)
+
+    llc, urc = openmc.capi.bounding_box("Surface", -5)
+
+    assert tuple(llc) == expected_llc
+    assert tuple(urc) == expected_urc
+
+    expected_llc = (-0.39218, -0.39218, -inf)
+    expected_urc = (0.39218, 0.39218, inf)
+
+    llc, urc = openmc.capi.bounding_box("Cell", 1)
+
+    assert tuple(llc) == expected_llc
+    assert tuple(urc) == expected_urc
+
+    expected_llc = (-0.45720, -0.45720, -inf)
+    expected_urc = (0.45720, 0.45720, inf)
+
+    llc, urc = openmc.capi.bounding_box("Cell", 2)
+
+    assert tuple(llc) == expected_llc
+    assert tuple(urc) == expected_urc
+
+    # make sure that proper assertions are raised
+    with pytest.raises(openmc.exceptions.GeometryError):
+        openmc.capi.bounding_box("Cell", -1)
+
+    with pytest.raises(openmc.exceptions.GeometryError):
+        openmc.capi.bounding_box("Surface", 0)
+
+    with pytest.raises(openmc.exceptions.GeometryError):
+        openmc.capi.bounding_box("Region", 1)
+
+
+def test_global_bounding_box(capi_init):
+
+    inf = sys.float_info.max
+
+    expected_llc = (-0.63, -0.63, -inf)
+    expected_urc = (0.63, 0.63, inf)
+
+    llc, urc = openmc.capi.global_bounding_box()
+
+    assert tuple(llc) == expected_llc
+    assert tuple(urc) == expected_urc

From 1d075cefdd2f295b917c274a9ee165cf6f7d3123 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Wed, 10 Jul 2019 07:53:44 -0500
Subject: [PATCH 059/127] Adding name property to CAPI cell/material classes.

---
 include/openmc/capi.h   |  4 ++++
 openmc/capi/cell.py     | 19 ++++++++++++++++++-
 openmc/capi/material.py | 19 ++++++++++++++++++-
 src/cell.cpp            | 26 ++++++++++++++++++++++++++
 src/material.cpp        | 25 +++++++++++++++++++++++++
 5 files changed, 91 insertions(+), 2 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index 11b8a6ef6..d81e1e722 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -14,6 +14,8 @@ extern "C" {
   int openmc_cell_get_fill(int32_t index, int* type, int32_t** indices, int32_t* n);
   int openmc_cell_get_id(int32_t index, int32_t* id);
   int openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T);
+  int openmc_cell_get_name(int32_t index, const char*& name);
+  int openmc_cell_set_name(int32_t index, const char* name);
   int openmc_cell_set_fill(int32_t index, int type, int32_t n, const int32_t* indices);
   int openmc_cell_set_id(int32_t index, int32_t id);
   int openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance);
@@ -58,6 +60,8 @@ extern "C" {
   int openmc_material_set_density(int32_t index, double density, const char* units);
   int openmc_material_set_densities(int32_t index, int n, const char** name, const double* density);
   int openmc_material_set_id(int32_t index, int32_t id);
+  int openmc_material_get_name(int32_t index, const char*& name);
+  int openmc_material_set_name(int32_t index, const char* name);
   int openmc_material_set_volume(int32_t index, double volume);
   int openmc_material_filter_get_bins(int32_t index, const int32_t** bins, size_t* n);
   int openmc_material_filter_set_bins(int32_t index, size_t n, const int32_t* bins);
diff --git a/openmc/capi/cell.py b/openmc/capi/cell.py
index 959ab08fc..5f38e823e 100644
--- a/openmc/capi/cell.py
+++ b/openmc/capi/cell.py
@@ -1,5 +1,5 @@
 from collections.abc import Mapping, Iterable
-from ctypes import c_int, c_int32, c_double, c_char_p, POINTER
+from ctypes import byref, c_int, c_int32, c_double, c_char_p, POINTER
 from weakref import WeakValueDictionary
 
 import numpy as np
@@ -28,6 +28,12 @@ _dll.openmc_cell_get_temperature.argtypes = [
     c_int32, POINTER(c_int32), POINTER(c_double)]
 _dll.openmc_cell_get_temperature.restype = c_int
 _dll.openmc_cell_get_temperature.errcheck = _error_handler
+_dll.openmc_cell_get_name.argtypes = [c_int32, POINTER(c_char_p)]
+_dll.openmc_cell_get_name.restype = c_int
+_dll.openmc_cell_get_name.errcheck = _error_handler
+_dll.openmc_cell_set_name.argtypes = [c_int32, c_char_p]
+_dll.openmc_cell_set_name.restype = c_int
+_dll.openmc_cell_set_name.errcheck = _error_handler
 _dll.openmc_cell_set_fill.argtypes = [
     c_int32, c_int, c_int32, POINTER(c_int32)]
 _dll.openmc_cell_set_fill.restype = c_int
@@ -102,6 +108,17 @@ class Cell(_FortranObjectWithID):
     def id(self, cell_id):
         _dll.openmc_cell_set_id(self._index, cell_id)
 
+    @property
+    def name(self):
+        name = c_char_p()
+        _dll.openmc_cell_get_name(self._index, byref(name))
+        return name.value.decode()
+
+    @name.setter
+    def name(self, name):
+        name_ptr = c_char_p(name.encode())
+        _dll.openmc_cell_set_name(self._index, name_ptr)
+
     @property
     def fill(self):
         fill_type = c_int()
diff --git a/openmc/capi/material.py b/openmc/capi/material.py
index 43959e244..3f98e9f67 100644
--- a/openmc/capi/material.py
+++ b/openmc/capi/material.py
@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from ctypes import c_int, c_int32, c_double, c_char_p, POINTER, c_size_t
+from ctypes import byref, c_int, c_int32, c_double, c_char_p, POINTER, c_size_t
 from weakref import WeakValueDictionary
 
 import numpy as np
@@ -48,6 +48,12 @@ _dll.openmc_material_set_densities.errcheck = _error_handler
 _dll.openmc_material_set_id.argtypes = [c_int32, c_int32]
 _dll.openmc_material_set_id.restype = c_int
 _dll.openmc_material_set_id.errcheck = _error_handler
+_dll.openmc_cell_get_name.argtypes = [c_int32, POINTER(c_char_p)]
+_dll.openmc_cell_get_name.restype = c_int
+_dll.openmc_cell_get_name.errcheck = _error_handler
+_dll.openmc_cell_set_name.argtypes = [c_int32, c_char_p]
+_dll.openmc_cell_set_name.restype = c_int
+_dll.openmc_cell_set_name.errcheck = _error_handler
 _dll.openmc_material_set_volume.argtypes = [c_int32, c_double]
 _dll.openmc_material_set_volume.restype = c_int
 _dll.openmc_material_set_volume.errcheck = _error_handler
@@ -124,6 +130,17 @@ class Material(_FortranObjectWithID):
     def id(self, mat_id):
         _dll.openmc_material_set_id(self._index, mat_id)
 
+    @property
+    def name(self):
+        name = c_char_p()
+        _dll.openmc_material_get_name(self._index, byref(name))
+        return name.value.decode()
+
+    @name.setter
+    def name(self, name):
+        name_ptr = c_char_p(name.encode())
+        _dll.openmc_material_set_name(self._index, name_ptr)
+
     @property
     def volume(self):
         volume = c_double()
diff --git a/src/cell.cpp b/src/cell.cpp
index d646660fb..5c1c90db5 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1018,6 +1018,32 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
   return 0;
 }
 
+extern "C" int
+openmc_cell_get_name(int32_t index, const char*& name) {
+  if (index < 0 || index >= model::cells.size()) {
+    strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
+    return OPENMC_E_OUT_OF_BOUNDS;
+  }
+
+  name = model::cells[index]->name_.c_str();
+
+  return 0;
+}
+
+extern "C" int
+openmc_cell_set_name(int32_t index, const char* name) {
+  if (index < 0 || index >= model::cells.size()) {
+    strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
+    return OPENMC_E_OUT_OF_BOUNDS;
+  }
+
+  std::string name_str(name);
+  model::cells[index]->name_ = name_str;
+
+  return 0;
+}
+
+
 //! Return the index in the cells array of a cell with a given ID
 extern "C" int
 openmc_get_cell_index(int32_t id, int32_t* index)
diff --git a/src/material.cpp b/src/material.cpp
index 0a6bebf17..fb29ba2b7 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1381,6 +1381,31 @@ openmc_material_set_id(int32_t index, int32_t id)
   return 0;
 }
 
+extern "C" int
+openmc_material_get_name(int32_t index, const char*& name) {
+  if (index < 0 || index >= model::materials.size()) {
+    strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
+    return OPENMC_E_OUT_OF_BOUNDS;
+  }
+
+  name = model::materials[index]->name_.c_str();
+
+  return 0;
+}
+
+extern "C" int
+openmc_material_set_name(int32_t index, const char* name) {
+  if (index < 0 || index >= model::materials.size()) {
+    strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
+    return OPENMC_E_OUT_OF_BOUNDS;
+  }
+
+  std::string name_str(name);
+  model::materials[index]->name_ = name_str;
+
+  return 0;
+}
+
 extern "C" int
 openmc_material_set_volume(int32_t index, double volume)
 {

From 542ce3f15e9a85e23103dd69ee71457e173a11f8 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 11 Jul 2019 21:52:09 -0500
Subject: [PATCH 060/127] Adding material/cell name tests.

---
 tests/unit_tests/test_capi.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index d611c20c7..a5e0e6a20 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -74,7 +74,7 @@ def test_cell(capi_init):
     assert isinstance(cell.fill, openmc.capi.Material)
     cell.fill = openmc.capi.materials[1]
     assert str(cell) == 'Cell[0]'
-
+    assert cell.name == "Fuel"
 
 def test_cell_temperature(capi_init):
     cell = openmc.capi.cells[1]
@@ -124,6 +124,7 @@ def test_material(capi_init):
     m.set_density(0.1, 'g/cm3')
     assert m.density == pytest.approx(0.1)
 
+    assert m.name == "Hot borated water"
 
 def test_material_add_nuclide(capi_init):
     m = openmc.capi.materials[3]

From e9ac00736748fbfa09cef3d396ef749047cc8166 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 12 Jul 2019 15:52:37 -0500
Subject: [PATCH 061/127] Removing complement from internal RPN.

---
 include/openmc/cell.h    |  2 ++
 include/openmc/surface.h |  3 --
 src/cell.cpp             | 71 ++++++++++++++++++++++++++++++++--------
 3 files changed, 59 insertions(+), 17 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index a6432a304..37db57bcf 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -202,6 +202,8 @@ public:
 protected:
   bool contains_simple(Position r, Direction u, int32_t on_surface) const;
   bool contains_complex(Position r, Direction u, int32_t on_surface) const;
+  BoundingBox bounding_box_simple() const;
+  BoundingBox bounding_box_complex() const;
 };
 
 //==============================================================================
diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 69c11476c..2b6c5cd0c 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -74,9 +74,6 @@ struct BoundingBox
 
 };
 
-
-
-
 //==============================================================================
 //! A geometry primitive used to define regions of 3D space.
 //==============================================================================
diff --git a/src/cell.cpp b/src/cell.cpp
index 5c1c90db5..aa937dae7 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -114,13 +114,19 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
   std::vector<int32_t> rpn;
   std::vector<int32_t> stack;
 
+  bool in_complement = false;
+
   for (int32_t token : infix) {
     if (token < OP_UNION) {
       // If token is not an operator, add it to output
+      if (in_complement) { token *= -1; }
       rpn.push_back(token);
-
     } else if (token < OP_RIGHT_PAREN) {
       // Regular operators union, intersection, complement
+      if (in_complement) {
+        if (token == OP_UNION) token = OP_INTERSECTION;
+        else if (token == OP_INTERSECTION) token = OP_UNION;
+      }
       while (stack.size() > 0) {
         int32_t op = stack.back();
 
@@ -133,14 +139,19 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
           // is less than that of op, move op to the output queue and push the
           // token on to the stack. Note that only complement is
           // right-associative.
-          rpn.push_back(op);
+          if (op == OP_COMPLEMENT) { in_complement = false; }
+          else { rpn.push_back(op); }
           stack.pop_back();
         } else {
           break;
         }
       }
 
-      stack.push_back(token);
+      if (token == OP_COMPLEMENT) {
+        in_complement = true;
+      } else {
+        stack.push_back(token);
+      }
 
     } else if (token == OP_LEFT_PAREN) {
       // If the token is a left parenthesis, push it onto the stack
@@ -158,8 +169,9 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
                   << cell_id;
           fatal_error(err_msg);
         }
-
-        rpn.push_back(stack.back());
+        int32_t op = stack.back();
+        if (op == OP_COMPLEMENT) { in_complement = false; }
+        else { rpn.push_back(op); }
         stack.pop_back();
       }
 
@@ -183,6 +195,10 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
     stack.pop_back();
   }
 
+  for (int32_t val : rpn) {
+    std::cout << val << std::endl;
+  }
+
   return rpn;
 }
 
@@ -580,18 +596,47 @@ CSGCell::to_hdf5(hid_t cell_group) const
   close_group(group);
 }
 
-BoundingBox CSGCell::bounding_box() const {
+BoundingBox CSGCell::bounding_box_simple() const {
   BoundingBox bbox;
-  if (rpn_.size() == 0) {
-    bbox = {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-  } else {
-    for (int32_t token : rpn_) {
-      bbox.intersect(model::surfaces[abs(token)-1]->bounding_box(token > 0));
-    }
+  for (int32_t token : rpn_) {
+    bbox.intersect(model::surfaces[abs(token)-1]->bounding_box(token > 0));
   }
   return bbox;
 }
 
+BoundingBox CSGCell::bounding_box_complex() const {
+
+  std::vector<BoundingBox> stack(rpn_.size());
+  int i_stack = -1;
+
+  for (int32_t token : rpn_) {
+    if (token == OP_UNION) {
+      stack[i_stack - 1].update(stack[i_stack]);
+      i_stack--;
+    } else if (token == OP_INTERSECTION) {
+      stack[i_stack - 1].intersect(stack[i_stack]);
+      i_stack--;
+    } else {
+      i_stack++;
+      stack[i_stack] = model::surfaces[abs(token)-1]->bounding_box(token > 0);
+    }
+  }
+  return stack[i_stack];
+}
+
+BoundingBox CSGCell::bounding_box() const {
+  if (rpn_.size() == 0) {
+    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+  } else {
+    if (simple_) {
+      return bounding_box_simple();
+    }
+    else {
+      return bounding_box_complex();
+    }
+  }
+}
+
 //==============================================================================
 
 bool
@@ -634,8 +679,6 @@ CSGCell::contains_complex(Position r, Direction u, int32_t on_surface) const
     } else if (token == OP_INTERSECTION) {
       stack[i_stack-1] = stack[i_stack-1] && stack[i_stack];
       i_stack --;
-    } else if (token == OP_COMPLEMENT) {
-      stack[i_stack] = !stack[i_stack];
     } else {
       // If the token is not an operator, evaluate the sense of particle with
       // respect to the surface and see if the token matches the sense. If the

From d223046b30760ed6847b9363c1bc51655c7147a1 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Mon, 15 Jul 2019 12:50:21 -0500
Subject: [PATCH 062/127] Adding complement operator back into internal cell
 RPN. Updating complex_cell bounding box algorithm to parse existing RPN.

---
 include/openmc/cell.h |  2 +-
 src/cell.cpp          | 93 ++++++++++++++++++++++++++-----------------
 2 files changed, 58 insertions(+), 37 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index 37db57bcf..aadd038d3 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -203,7 +203,7 @@ protected:
   bool contains_simple(Position r, Direction u, int32_t on_surface) const;
   bool contains_complex(Position r, Direction u, int32_t on_surface) const;
   BoundingBox bounding_box_simple() const;
-  BoundingBox bounding_box_complex() const;
+  BoundingBox bounding_box_complex(std::vector<int32_t> rpn) const;
 };
 
 //==============================================================================
diff --git a/src/cell.cpp b/src/cell.cpp
index aa937dae7..586ccf220 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -114,19 +114,12 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
   std::vector<int32_t> rpn;
   std::vector<int32_t> stack;
 
-  bool in_complement = false;
-
   for (int32_t token : infix) {
     if (token < OP_UNION) {
       // If token is not an operator, add it to output
-      if (in_complement) { token *= -1; }
       rpn.push_back(token);
     } else if (token < OP_RIGHT_PAREN) {
       // Regular operators union, intersection, complement
-      if (in_complement) {
-        if (token == OP_UNION) token = OP_INTERSECTION;
-        else if (token == OP_INTERSECTION) token = OP_UNION;
-      }
       while (stack.size() > 0) {
         int32_t op = stack.back();
 
@@ -139,19 +132,14 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
           // is less than that of op, move op to the output queue and push the
           // token on to the stack. Note that only complement is
           // right-associative.
-          if (op == OP_COMPLEMENT) { in_complement = false; }
-          else { rpn.push_back(op); }
+          rpn.push_back(op);
           stack.pop_back();
         } else {
           break;
         }
       }
 
-      if (token == OP_COMPLEMENT) {
-        in_complement = true;
-      } else {
-        stack.push_back(token);
-      }
+      stack.push_back(token);
 
     } else if (token == OP_LEFT_PAREN) {
       // If the token is a left parenthesis, push it onto the stack
@@ -169,9 +157,7 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
                   << cell_id;
           fatal_error(err_msg);
         }
-        int32_t op = stack.back();
-        if (op == OP_COMPLEMENT) { in_complement = false; }
-        else { rpn.push_back(op); }
+        rpn.push_back(stack.back());
         stack.pop_back();
       }
 
@@ -195,10 +181,6 @@ generate_rpn(int32_t cell_id, std::vector<int32_t> infix)
     stack.pop_back();
   }
 
-  for (int32_t val : rpn) {
-    std::cout << val << std::endl;
-  }
-
   return rpn;
 }
 
@@ -604,24 +586,61 @@ BoundingBox CSGCell::bounding_box_simple() const {
   return bbox;
 }
 
-BoundingBox CSGCell::bounding_box_complex() const {
+BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
 
-  std::vector<BoundingBox> stack(rpn_.size());
-  int i_stack = -1;
+  std::reverse(rpn.begin(), rpn.end());
 
-  for (int32_t token : rpn_) {
-    if (token == OP_UNION) {
-      stack[i_stack - 1].update(stack[i_stack]);
-      i_stack--;
-    } else if (token == OP_INTERSECTION) {
-      stack[i_stack - 1].intersect(stack[i_stack]);
-      i_stack--;
-    } else {
-      i_stack++;
-      stack[i_stack] = model::surfaces[abs(token)-1]->bounding_box(token > 0);
+  BoundingBox current = model::surfaces[abs(rpn.back()) - 1]->bounding_box(rpn.back() > 0);
+  rpn.pop_back();
+
+  while (rpn.size()) {
+    int32_t one = rpn.back(); rpn.pop_back();
+    int32_t two = rpn.back(); rpn.pop_back();
+
+    assert(one < OP_UNION);
+
+    if (two >= OP_UNION) {
+      if (two == OP_UNION) {
+        current.update(model::surfaces[abs(one)-1]->bounding_box(one > 0));
+      } else if (two == OP_INTERSECTION) {
+        current.intersect(model::surfaces[abs(one)-1]->bounding_box(one > 0));
+      }
+    } else { // two surfaces in a row, create sub-rpn for parenthesis
+      std::vector<int32_t> subrpn;
+      subrpn.push_back(one);
+      subrpn.push_back(two);
+      int32_t sone = one;
+      int32_t stwo = two;
+      // add until last two tokens are operators
+      while ((subrpn.back() < OP_UNION) || (*(subrpn.rbegin() + 1) < OP_UNION)) {
+        subrpn.push_back(rpn.back());
+        rpn.pop_back();
+      }
+
+      // handle complement case
+      if (subrpn.back() == OP_COMPLEMENT) {
+        subrpn.pop_back();
+        for (auto& token : subrpn) {
+          if (token < OP_UNION) { token *= -1; }
+          else if (token == OP_UNION) { token = OP_INTERSECTION; }
+          else if (token == OP_INTERSECTION) { token = OP_UNION; }
+        }
+        subrpn.push_back(rpn.back());
+        rpn.pop_back();
+      }
+      // get bbox for the subrpn
+      int32_t op = subrpn.back();
+      subrpn.pop_back();
+      BoundingBox sub_box = bounding_box_complex(subrpn);
+      if (op == OP_UNION) {
+        current.update(sub_box);
+      } else if (op == OP_INTERSECTION) {
+        current.intersect(sub_box);
+      }
     }
   }
-  return stack[i_stack];
+
+  return current;
 }
 
 BoundingBox CSGCell::bounding_box() const {
@@ -632,7 +651,7 @@ BoundingBox CSGCell::bounding_box() const {
       return bounding_box_simple();
     }
     else {
-      return bounding_box_complex();
+      return bounding_box_complex(rpn_);
     }
   }
 }
@@ -679,6 +698,8 @@ CSGCell::contains_complex(Position r, Direction u, int32_t on_surface) const
     } else if (token == OP_INTERSECTION) {
       stack[i_stack-1] = stack[i_stack-1] && stack[i_stack];
       i_stack --;
+    } else if (token == OP_COMPLEMENT) {
+      stack[i_stack] = !stack[i_stack];
     } else {
       // If the token is not an operator, evaluate the sense of particle with
       // respect to the surface and see if the token matches the sense. If the

From 77d40effb15aad4ee9d39883ca7b9bac8db75c0b Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Mon, 15 Jul 2019 14:35:02 -0500
Subject: [PATCH 063/127] Adding a test for complex cell bounding boxes.

---
 openmc/capi/cell.py                         |  8 +++++++
 tests/regression_tests/complex_cell/test.py | 25 +++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/openmc/capi/cell.py b/openmc/capi/cell.py
index 5f38e823e..1388d9732 100644
--- a/openmc/capi/cell.py
+++ b/openmc/capi/cell.py
@@ -183,6 +183,14 @@ class Cell(_FortranObjectWithID):
 
         _dll.openmc_cell_set_temperature(self._index, T, instance)
 
+    @property
+    def bounding_box(self):
+        llc = np.zeros((3,), dtype=float)
+        urc = np.zeros((3,), dtype=float)
+        _dll.openmc_bounding_box(b'Cell', self.id,
+                                 llc.ctypes.data_as(POINTER(c_double)),
+                                 urc.ctypes.data_as(POINTER(c_double)))
+        return llc, urc
 
 class _CellMapping(Mapping):
     def __getitem__(self, key):
diff --git a/tests/regression_tests/complex_cell/test.py b/tests/regression_tests/complex_cell/test.py
index 77cbd6cb7..816902b4c 100755
--- a/tests/regression_tests/complex_cell/test.py
+++ b/tests/regression_tests/complex_cell/test.py
@@ -1,6 +1,31 @@
 from tests.testing_harness import TestHarness
 
+import sys
+
+import openmc.capi
 
 def test_complex_cell():
     harness = TestHarness('statepoint.10.h5')
     harness.main()
+
+def test_complex_cell_capi():
+    # initialize
+    openmc.capi.init([])
+
+    inf = sys.float_info.max
+
+    expected_boxes = { 1 : (( -4.,  -4., -inf), ( 4.,  4., inf)),
+                       2 : (( -7.,  -7., -inf), ( 7.,  7., inf)),
+                       3 : ((-10., -10., -inf), (10., 10., inf)),
+                       4 : ((-10., -10., -inf), (10., 10., inf)) }
+
+    for cell_id, cell in openmc.capi.cells.items():
+        cell_box = cell.bounding_box
+
+        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
+        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
+
+        cell_box = openmc.capi.bounding_box("Cell", cell_id)
+
+        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
+        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]

From 9fab83c70c257ab02c1059412d3652ca97bb6b36 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Mon, 15 Jul 2019 14:35:20 -0500
Subject: [PATCH 064/127] Style fix in capi core.

---
 openmc/capi/core.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index ed78b38b6..a3ae6a219 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -87,7 +87,7 @@ def global_bounding_box():
     llc = np.zeros((3,), dtype=float)
     urc = np.zeros((3,), dtype=float)
     _dll.openmc_global_bounding_box(llc.ctypes.data_as(POINTER(c_double)),
-                             urc.ctypes.data_as(POINTER(c_double)))
+                                    urc.ctypes.data_as(POINTER(c_double)))
 
     return llc, urc
 

From 1d02c874660dea68c0ef248881f684ea8b239451 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Mon, 15 Jul 2019 15:02:07 -0500
Subject: [PATCH 065/127] Some self-review.

---
 include/openmc/surface.h | 13 +++++++++++--
 openmc/capi/core.py      |  3 ++-
 src/cell.cpp             | 21 +++++++++++----------
 3 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 2b6c5cd0c..6a688c240 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -31,6 +31,7 @@ extern "C" const int BC_PERIODIC;
 //==============================================================================
 
 class Surface;
+
 struct BoundingBox;
 
 namespace model {
@@ -51,7 +52,7 @@ struct BoundingBox
   double zmin = -INFTY;
   double zmax = INFTY;
 
-  // in-place update
+  // in-place update to include another bounding box
   inline void update(const BoundingBox& other) {
     xmin = std::min(xmin, other.xmin);
     xmax = std::max(xmax, other.xmax);
@@ -61,7 +62,7 @@ struct BoundingBox
     zmax = std::max(zmax, other.zmax);
   };
 
-  // in-place intersection
+  // in-place intersection with another bounding box
   inline void intersect(const BoundingBox& other) {
     xmin = std::max(xmin, other.xmin);
     xmax = std::min(xmax, other.xmax);
@@ -298,6 +299,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double y0_, z0_, radius_;
 };
 
@@ -317,6 +319,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double x0_, z0_, radius_;
 };
 
@@ -336,6 +339,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double x0_, y0_, radius_;
 };
 
@@ -355,6 +359,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double x0_, y0_, z0_, radius_;
 };
 
@@ -374,6 +379,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -393,6 +399,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -412,6 +419,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   double x0_, y0_, z0_, radius_sq_;
 };
 
@@ -430,6 +438,7 @@ public:
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
   BoundingBox bounding_box(bool pos_side) const;
+
   // Ax^2 + By^2 + Cz^2 + Dxy + Eyz + Fxz + Gx + Hy + Jz + K = 0
   double A_, B_, C_, D_, E_, F_, G_, H_, J_, K_;
 };
diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index a3ae6a219..d37e0de75 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -73,7 +73,8 @@ _dll.openmc_simulation_finalize.errcheck = _error_handler
 _dll.openmc_statepoint_write.argtypes = [c_char_p, POINTER(c_bool)]
 _dll.openmc_statepoint_write.restype = c_int
 _dll.openmc_statepoint_write.errcheck = _error_handler
-_dll.openmc_bounding_box.argtypes = [c_char_p, c_int, POINTER(c_double),
+_dll.openmc_bounding_box.argtypes = [c_char_p, c_int,
+                                     POINTER(c_double),
                                      POINTER(c_double)]
 _dll.openmc_bounding_box.restype = c_int
 _dll.openmc_bounding_box.errcheck = _error_handler
diff --git a/src/cell.cpp b/src/cell.cpp
index 586ccf220..a9c40ac24 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -594,9 +594,11 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
   rpn.pop_back();
 
   while (rpn.size()) {
+    // move through the rpn in twos
     int32_t one = rpn.back(); rpn.pop_back();
     int32_t two = rpn.back(); rpn.pop_back();
 
+    // the first token should always be a surface
     assert(one < OP_UNION);
 
     if (two >= OP_UNION) {
@@ -605,19 +607,20 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
       } else if (two == OP_INTERSECTION) {
         current.intersect(model::surfaces[abs(one)-1]->bounding_box(one > 0));
       }
-    } else { // two surfaces in a row, create sub-rpn for parenthesis
+    } else {
+    // two surfaces in a row, create sub-rpn for region in parenthesis
       std::vector<int32_t> subrpn;
       subrpn.push_back(one);
       subrpn.push_back(two);
       int32_t sone = one;
       int32_t stwo = two;
-      // add until last two tokens are operators
+      // add until last two tokens in the sub-rpn are operators
       while ((subrpn.back() < OP_UNION) || (*(subrpn.rbegin() + 1) < OP_UNION)) {
         subrpn.push_back(rpn.back());
         rpn.pop_back();
       }
 
-      // handle complement case
+      // handle complement case using De Morgan's laws
       if (subrpn.back() == OP_COMPLEMENT) {
         subrpn.pop_back();
         for (auto& token : subrpn) {
@@ -628,10 +631,12 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
         subrpn.push_back(rpn.back());
         rpn.pop_back();
       }
-      // get bbox for the subrpn
-      int32_t op = subrpn.back();
-      subrpn.pop_back();
+      // save the last operator, tells us how to combine this region
+      // with our current bounding box
+      int32_t op = subrpn.back(); subrpn.pop_back();
+      // get bounding box for the subrpn
       BoundingBox sub_box = bounding_box_complex(subrpn);
+      // combine the sub-rpn bounding box with our current cell box
       if (op == OP_UNION) {
         current.update(sub_box);
       } else if (op == OP_INTERSECTION) {
@@ -644,16 +649,12 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
 }
 
 BoundingBox CSGCell::bounding_box() const {
-  if (rpn_.size() == 0) {
-    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-  } else {
     if (simple_) {
       return bounding_box_simple();
     }
     else {
       return bounding_box_complex(rpn_);
     }
-  }
 }
 
 //==============================================================================

From 3e0dc41ea14e8402ec6f3a16330f57002dd91e0f Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Mon, 15 Jul 2019 20:05:47 -0500
Subject: [PATCH 066/127] Adding documentation to CAPI bounding box function.

---
 openmc/capi/core.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index d37e0de75..686dd7862 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -84,7 +84,7 @@ _dll.openmc_global_bounding_box.restype = c_int
 _dll.openmc_global_bounding_box.errcheck = _error_handler
 
 def global_bounding_box():
-
+    """Calculate a global bounding box for the model"""
     llc = np.zeros((3,), dtype=float)
     urc = np.zeros((3,), dtype=float)
     _dll.openmc_global_bounding_box(llc.ctypes.data_as(POINTER(c_double)),
@@ -93,7 +93,15 @@ def global_bounding_box():
     return llc, urc
 
 def bounding_box(geom_type, geom_id):
+    """Get a bounding box for a geometric object
 
+    Parameters
+    ----------
+    geom_type : str
+        Type of geometry object. One of ('surface', 'cell', 'universe')
+    geom_id : int
+        Id of the object. Can be positive or negative for surfaces.
+    """
     geomt = c_char_p(geom_type.encode())
     llc = np.zeros((3,), dtype=float)
     urc = np.zeros((3,), dtype=float)

From b373fd5931dca10f223feee5b5e7b3454c12f85e Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 10:11:58 -0500
Subject: [PATCH 067/127] Finalizing the capi after the complex cell test.

---
 tests/regression_tests/complex_cell/test.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/regression_tests/complex_cell/test.py b/tests/regression_tests/complex_cell/test.py
index 816902b4c..8074c0e05 100755
--- a/tests/regression_tests/complex_cell/test.py
+++ b/tests/regression_tests/complex_cell/test.py
@@ -29,3 +29,5 @@ def test_complex_cell_capi():
 
         assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
         assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
+
+    openmc.capi.finalize()

From 7409ad4632b219e20d26a9dad9207c19a86dfccf Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 10:12:24 -0500
Subject: [PATCH 068/127] Some doc strings for new capi functions.

---
 src/cell.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cell.cpp b/src/cell.cpp
index a9c40ac24..1242c650f 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1083,6 +1083,7 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
   return 0;
 }
 
+//! Get the name of a cell
 extern "C" int
 openmc_cell_get_name(int32_t index, const char*& name) {
   if (index < 0 || index >= model::cells.size()) {
@@ -1095,6 +1096,7 @@ openmc_cell_get_name(int32_t index, const char*& name) {
   return 0;
 }
 
+//! Set the name of a cell
 extern "C" int
 openmc_cell_set_name(int32_t index, const char* name) {
   if (index < 0 || index >= model::cells.size()) {

From d79a5edb8a4bedfa2aadeed995b5c7d5339a05d8 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 16:47:29 -0500
Subject: [PATCH 069/127] Small formatting fixes.

---
 tests/unit_tests/test_capi.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index a5e0e6a20..1c1da98a3 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -123,7 +123,6 @@ def test_material(capi_init):
 
     m.set_density(0.1, 'g/cm3')
     assert m.density == pytest.approx(0.1)
-
     assert m.name == "Hot borated water"
 
 def test_material_add_nuclide(capi_init):
@@ -473,7 +472,6 @@ def test_position(capi_init):
     assert tuple(pos) == (1.3, 2.3, 3.3)
 
 def test_bounding_box(capi_init):
-
     inf = sys.float_info.max
 
     expected_llc = (-inf, -0.63, -inf)
@@ -524,7 +522,6 @@ def test_bounding_box(capi_init):
 
 
 def test_global_bounding_box(capi_init):
-
     inf = sys.float_info.max
 
     expected_llc = (-0.63, -0.63, -inf)

From 676b8d48a3b28dd6c38a96fbefc1bcdee5765a5a Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 16 Jul 2019 16:50:58 -0500
Subject: [PATCH 070/127] Add a litle tolerance for capture branching ratios

When adding capture branching ratios to a ``Chain``,
the sum of ratios for a given parent nuclide was allowed to be no
greater than 1.0. This limit is very tight, and does not allow
for minor floating point precision differences, like
1.0000000002.

The maximum value the sum of branching ratios from a single
parent is now 1.00001, with no equality check. This has
been added to the method docstring for transparency.

Some content was removed from the docstring that implied that
``branch_ratios`` would be modified in place. This is not the case,
and thus the content was removed.
---
 openmc/deplete/chain.py | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/openmc/deplete/chain.py b/openmc/deplete/chain.py
index 03c7afdd6..1f16d9caf 100644
--- a/openmc/deplete/chain.py
+++ b/openmc/deplete/chain.py
@@ -484,14 +484,9 @@ class Chain(object):
     def set_capture_branches(self, branch_ratios, strict=True):
         """Set the capture branching ratios
 
-        ``branch_ratios`` may be modified in place, only to
-        insert missing ground state reactions. These will be
-        inserted only if:
-
-            1) There is no branch directly to a ground state
-               target, and
-            2) The sum of all ratios on this branch does not
-               equal 1.
+        To provide a buffer around floating point precisions,
+        the sum of all branching ratios from a single parent
+        cannot be greater than 1.00001.
 
         Parameters
         ----------
@@ -568,7 +563,7 @@ class Chain(object):
             capt_ix_map[parent] = indexes
 
             this_sum = sum(sub.values())
-            check_less_than(parent + " ratios", this_sum, 1.0, True)
+            check_less_than(parent + " ratios", this_sum, 1.00001)
             sums[parent] = this_sum
 
         if len(missing_parents) > 0:

From 08e78a3215e99f8ce6a0b8f36dc7c286f1a8badf Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 17:09:44 -0500
Subject: [PATCH 071/127] Removing unecessary forward declaration.

---
 include/openmc/surface.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 6a688c240..e78c49079 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -32,8 +32,6 @@ extern "C" const int BC_PERIODIC;
 
 class Surface;
 
-struct BoundingBox;
-
 namespace model {
   extern std::vector<std::unique_ptr<Surface>> surfaces;
   extern std::unordered_map<int, int> surface_map;

From df379471dd2b6bf5f83ceb79c023e9aa595a7325 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 12:19:13 -0500
Subject: [PATCH 072/127] Adding Cell accessors for name.

---
 include/openmc/cell.h |  8 ++++++++
 src/cell.cpp          | 19 ++++++++++++++++---
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index aadd038d3..0b219baa1 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -134,6 +134,14 @@ public:
   //!   all instances is set.
   void set_temperature(double T, int32_t instance = -1);
 
+  //! Get the name of a cell
+  //! \return Cell name
+  std::string name() const;
+
+  //! Set the temperature of a cell instance
+  //! \param[in] name Cell name
+  void set_name(const std::string& name);
+
   //----------------------------------------------------------------------------
   // Data members
 
diff --git a/src/cell.cpp b/src/cell.cpp
index 1242c650f..c339a54c1 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -252,6 +252,18 @@ Cell::set_temperature(double T, int32_t instance)
   }
 }
 
+std::string
+Cell::name() const
+{
+  return name_;
+}
+
+void
+Cell::set_name(const std::string& name)
+{
+  name_ = name;
+}
+
 //==============================================================================
 // CSGCell implementation
 //==============================================================================
@@ -1085,13 +1097,14 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
 
 //! Get the name of a cell
 extern "C" int
-openmc_cell_get_name(int32_t index, const char*& name) {
+openmc_cell_get_name(int32_t index, char*& name) {
   if (index < 0 || index >= model::cells.size()) {
     strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  name = model::cells[index]->name_.c_str();
+  auto name_str = model::cells[index]->name_;
+  strcpy(name, name_str.c_str());
 
   return 0;
 }
@@ -1105,7 +1118,7 @@ openmc_cell_set_name(int32_t index, const char* name) {
   }
 
   std::string name_str(name);
-  model::cells[index]->name_ = name_str;
+  model::cells[index]->set_name(name_str);
 
   return 0;
 }

From 54df6518887d2eabfe8954fa1951826aed87d598 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 12:25:53 -0500
Subject: [PATCH 073/127] Adding Material accessors for name.

---
 include/openmc/cell.h     |  4 ++--
 include/openmc/material.h |  7 +++++++
 src/cell.cpp              | 12 ------------
 src/material.cpp          |  7 ++++---
 4 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index 0b219baa1..3a0c81646 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -136,11 +136,11 @@ public:
 
   //! Get the name of a cell
   //! \return Cell name
-  std::string name() const;
+  std::string name() const { return name_; };
 
   //! Set the temperature of a cell instance
   //! \param[in] name Cell name
-  void set_name(const std::string& name);
+  void set_name(const std::string& name) { name_ = name; };
 
   //----------------------------------------------------------------------------
   // Data members
diff --git a/include/openmc/material.h b/include/openmc/material.h
index 02c5380f3..aa0a4bad0 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -92,6 +92,13 @@ public:
   //! \return Density in [g/cm^3]
   double density_gpcc() const { return density_gpcc_; }
 
+  //! Get name
+  //! \return Material name
+  std::string name() const { return name_; }
+
+  //! Set name
+  void set_name(const std::string& name) { name_ = name; }
+
   //! Set total density of the material
   //
   //! \param[in] density Density value
diff --git a/src/cell.cpp b/src/cell.cpp
index c339a54c1..9d5b2af9d 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -252,18 +252,6 @@ Cell::set_temperature(double T, int32_t instance)
   }
 }
 
-std::string
-Cell::name() const
-{
-  return name_;
-}
-
-void
-Cell::set_name(const std::string& name)
-{
-  name_ = name;
-}
-
 //==============================================================================
 // CSGCell implementation
 //==============================================================================
diff --git a/src/material.cpp b/src/material.cpp
index fb29ba2b7..f14bfc8f2 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1382,13 +1382,14 @@ openmc_material_set_id(int32_t index, int32_t id)
 }
 
 extern "C" int
-openmc_material_get_name(int32_t index, const char*& name) {
+openmc_material_get_name(int32_t index, char*& name) {
   if (index < 0 || index >= model::materials.size()) {
     strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  name = model::materials[index]->name_.c_str();
+  auto name_str = model::materials[index]->name();
+  strcpy(name, name_str.c_str());
 
   return 0;
 }
@@ -1401,7 +1402,7 @@ openmc_material_set_name(int32_t index, const char* name) {
   }
 
   std::string name_str(name);
-  model::materials[index]->name_ = name_str;
+  model::materials[index]->set_name(name);
 
   return 0;
 }

From 520b07a131ce41962ba965a3d90085231fb626f6 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 12:29:30 -0500
Subject: [PATCH 074/127] Using C-types only in capi function definitions.

---
 src/cell.cpp     | 4 ++--
 src/material.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cell.cpp b/src/cell.cpp
index 9d5b2af9d..7753e8333 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1085,14 +1085,14 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
 
 //! Get the name of a cell
 extern "C" int
-openmc_cell_get_name(int32_t index, char*& name) {
+openmc_cell_get_name(int32_t index, char** name) {
   if (index < 0 || index >= model::cells.size()) {
     strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
   auto name_str = model::cells[index]->name_;
-  strcpy(name, name_str.c_str());
+  strcpy(*name, name_str.c_str());
 
   return 0;
 }
diff --git a/src/material.cpp b/src/material.cpp
index f14bfc8f2..356c2bf21 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1382,14 +1382,14 @@ openmc_material_set_id(int32_t index, int32_t id)
 }
 
 extern "C" int
-openmc_material_get_name(int32_t index, char*& name) {
+openmc_material_get_name(int32_t index, char** name) {
   if (index < 0 || index >= model::materials.size()) {
     strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
   auto name_str = model::materials[index]->name();
-  strcpy(name, name_str.c_str());
+  strcpy(*name, name_str.c_str());
 
   return 0;
 }

From 15c2bc2de3d51715cb073016c5d8c58daebfe82a Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Thu, 18 Jul 2019 12:39:05 -0500
Subject: [PATCH 075/127] Use correct material index in operator unpacking

Fix a bug introduced where the material iteration index,

        for i, mat in enumerate(self.local_mats):

was used for the global __material__ index. The value of i
was used to extract reaction rate tallies for that material.
This causes an issue with multiple operators on MPI processes,
where an Operator`s material i does not equal the i-th burnable
material.
---
 openmc/deplete/operator.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index 73fad5093..a3c7c2ba8 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -551,7 +551,7 @@ class Operator(TransportOperator):
                 number[i_nuc_results] = self.number[mat, nuc]
 
             tally_rates = self._rate_helper.get_material_rates(
-                i, nuc_ind, react_ind)
+                slab, nuc_ind, react_ind)
 
             # Accumulate energy from fission
             energy += self._energy_helper.get_fission_energy(

From 6d971884139a5ca40a0874a68471a89ce170691c Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 12:57:23 -0500
Subject: [PATCH 076/127] Creating a default virtual definition for a surfce
 bounding box and removing redundant definitions of surfaces with unbounded
 boxes.

---
 include/openmc/surface.h | 13 +--------
 src/surface.cpp          | 57 ----------------------------------------
 2 files changed, 1 insertion(+), 69 deletions(-)

diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index e78c49079..10b4a4c27 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -128,7 +128,7 @@ public:
   virtual void to_hdf5(hid_t group_id) const = 0;
 
   //! Get the BoundingBox for this surface.
-  virtual BoundingBox bounding_box(bool pos_side) const = 0;
+  virtual BoundingBox bounding_box(bool pos_side) const { return {}; }
 };
 
 class CSGSurface : public Surface
@@ -139,8 +139,6 @@ public:
 
   void to_hdf5(hid_t group_id) const;
 
-  virtual BoundingBox bounding_box(bool pos_side) const = 0;
-
 protected:
   virtual void to_hdf5_inner(hid_t group_id) const = 0;
 };
@@ -158,8 +156,6 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   Direction reflect(Position r, Direction u) const;
-  //! Get the bounding box of this surface.
-  BoundingBox bounding_box(bool pos_side) const;
 
   void to_hdf5(hid_t group_id) const;
 
@@ -193,8 +189,6 @@ public:
   virtual bool periodic_translate(const PeriodicSurface* other, Position& r,
                                   Direction& u) const = 0;
 
-  //! Get the bounding box for this surface.
-  virtual BoundingBox bounding_box(bool pos_side) const = 0;
 };
 
 //==============================================================================
@@ -276,7 +270,6 @@ public:
   void to_hdf5_inner(hid_t group_id) const;
   bool periodic_translate(const PeriodicSurface* other, Position& r,
                           Direction& u) const;
-  BoundingBox bounding_box(bool pos_side) const;
 
   double A_, B_, C_, D_;
 };
@@ -376,7 +369,6 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box(bool pos_side) const;
 
   double x0_, y0_, z0_, radius_sq_;
 };
@@ -396,7 +388,6 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box(bool pos_side) const;
 
   double x0_, y0_, z0_, radius_sq_;
 };
@@ -416,7 +407,6 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box(bool pos_side) const;
 
   double x0_, y0_, z0_, radius_sq_;
 };
@@ -435,7 +425,6 @@ public:
   double distance(Position r, Direction u, bool coincident) const;
   Direction normal(Position r) const;
   void to_hdf5_inner(hid_t group_id) const;
-  BoundingBox bounding_box(bool pos_side) const;
 
   // Ax^2 + By^2 + Cz^2 + Dxy + Eyz + Fxz + Gx + Hy + Jz + K = 0
   double A_, B_, C_, D_, E_, F_, G_, H_, J_, K_;
diff --git a/src/surface.cpp b/src/surface.cpp
index 9eaccef3d..b53590e08 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -271,16 +271,6 @@ Direction DAGSurface::reflect(Position r, Direction u) const
   return simulation::last_dir;
 }
 
-BoundingBox DAGSurface::bounding_box(bool pos_side) const
-{
-  moab::ErrorCode rval;
-  moab::EntityHandle surf = dagmc_ptr_->entity_by_index(2, dag_index_);
-  double min[3], max[3];
-  rval = dagmc_ptr_->getobb(surf, min, max);
-  MB_CHK_ERR_CONT(rval);
-  return {min[0], max[0], min[1], max[1], min[2], max[2]};
-}
-
 void DAGSurface::to_hdf5(hid_t group_id) const {}
 
 #endif
@@ -551,37 +541,6 @@ bool SurfacePlane::periodic_translate(const PeriodicSurface* other, Position& r,
   return false;
 }
 
-BoundingBox
-SurfacePlane::bounding_box(bool pos_side) const
-{
-  BoundingBox bbox = {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-  if (A_ == 0.0 && B_ == 0.0) {
-    double val = D_ / C_;
-    if (pos_side) {
-      bbox.zmin = val;
-    } else {
-      bbox.zmax = val;
-    }
-  } else if (A_ == 0.0 && C_ == 0.0) {
-    double val = D_ / B_;
-    if (pos_side) {
-    bbox.ymin = val;
-    } else {
-    bbox.ymax = val;
-    }
-  } else if (B_ == 0.0 && C_ == 0.0) {
-    double val = D_ / A_;
-    if (pos_side) {
-    bbox.xmin = val;
-    } else {
-    bbox.xmax = val;
-    }
-  }
-
-  return bbox;
-
-}
-
 //==============================================================================
 // Generic functions for x-, y-, and z-, cylinders
 //==============================================================================
@@ -976,10 +935,6 @@ void SurfaceXCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceXCone::bounding_box(bool pos_side) const {
-  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-}
-
 //==============================================================================
 // SurfaceYCone implementation
 //==============================================================================
@@ -1013,10 +968,6 @@ void SurfaceYCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceYCone::bounding_box(bool pos_side) const {
-  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-}
-
 //==============================================================================
 // SurfaceZCone implementation
 //==============================================================================
@@ -1050,10 +1001,6 @@ void SurfaceZCone::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceZCone::bounding_box(bool pos_side) const {
-  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-}
-
 //==============================================================================
 // SurfaceQuadric implementation
 //==============================================================================
@@ -1147,10 +1094,6 @@ void SurfaceQuadric::to_hdf5_inner(hid_t group_id) const
   write_dataset(group_id, "coefficients", coeffs);
 }
 
-BoundingBox SurfaceQuadric::bounding_box(bool pos_side) const {
-  return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
-}
-
 //==============================================================================
 
 void read_surfaces(pugi::xml_node node)

From 07c9083446b95fcebcd44d849cfdb808f724ed47 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 13:02:08 -0500
Subject: [PATCH 077/127] Using default constructor when returning unbounded
 boxes.

---
 src/cell.cpp    | 4 ++--
 src/surface.cpp | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cell.cpp b/src/cell.cpp
index 7753e8333..1dff5caf9 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -207,9 +207,9 @@ Universe::to_hdf5(hid_t universes_group) const
 }
 
 BoundingBox Universe::bounding_box() const {
-  BoundingBox bbox = {INFTY, -INFTY, INFTY, -INFTY, INFTY, -INFTY};
+  BoundingBox bbox;
   if (cells_.size() == 0) {
-    bbox = {-INFTY, INFTY, -INFTY, -INFTY, INFTY};
+    return {};
   } else {
     for (const auto& cell : cells_) {
       auto& c = model::cells[cell];
diff --git a/src/surface.cpp b/src/surface.cpp
index b53590e08..45cd025ba 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -653,7 +653,7 @@ BoundingBox SurfaceXCylinder::bounding_box(bool pos_side) const {
   if (!pos_side) {
     return {-INFTY, INFTY, y0_ - radius_, y0_ + radius_, z0_ - radius_, z0_ + radius_};
   } else {
-    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+    return {};
   }
 }
 //==============================================================================
@@ -693,7 +693,7 @@ BoundingBox SurfaceYCylinder::bounding_box(bool pos_side) const {
   if (!pos_side) {
     return {x0_ - radius_, x0_ + radius_, -INFTY, INFTY, z0_ - radius_, z0_ + radius_};
   } else {
-    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+    return {};
   }
 }
 
@@ -734,7 +734,7 @@ BoundingBox SurfaceZCylinder::bounding_box(bool pos_side) const {
   if (!pos_side) {
     return {x0_ - radius_, x0_ + radius_, y0_ - radius_, y0_ + radius_, -INFTY, INFTY};
   } else {
-    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+    return {};
   }
 }
 
@@ -813,7 +813,7 @@ BoundingBox SurfaceSphere::bounding_box(bool pos_side) const {
             y0_ - radius_, y0_ + radius_,
             z0_ - radius_, z0_ + radius_};
   } else {
-    return {-INFTY, INFTY, -INFTY, INFTY, -INFTY, INFTY};
+    return {};
   }
 }
 

From d0d4a05c7599bc7a150e7fb76118b34309d2df96 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Thu, 18 Jul 2019 13:13:13 -0500
Subject: [PATCH 078/127] Add a dictionary to map local to global burnable
 materials

Removes the need to call self.burnable_mats.index
for every local material at every depletion step
---
 openmc/deplete/operator.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index a3c7c2ba8..03c9813f5 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -138,6 +138,7 @@ class Operator(TransportOperator):
         openmc.reset_auto_ids()
         self.burnable_mats, volume, nuclides = self._get_burnable_mats()
         self.local_mats = _distribute(self.burnable_mats)
+        self._mat_index_map = {}
 
         # Determine which nuclides have incident neutron data
         self.nuclides_with_data = self._get_nuclides_with_data()
@@ -386,6 +387,10 @@ class Operator(TransportOperator):
         self._energy_helper.prepare(
             self.chain.nuclides, self.reaction_rates.index_nuc, materials)
 
+        # Generate map from local materials => material index
+        self._mat_index_map = {
+            lm: self.burnable_mats.index(lm) for lm in self.local_mats}
+
         # Return number density vector
         return list(self.number.get_mat_slice(np.s_[:]))
 
@@ -519,7 +524,6 @@ class Operator(TransportOperator):
         k_combined = openmc.capi.keff()
 
         # Extract tally bins
-        materials = self.burnable_mats
         nuclides = self._rate_helper.nuclides
 
         # Form fast map
@@ -541,7 +545,7 @@ class Operator(TransportOperator):
         # Extract results
         for i, mat in enumerate(self.local_mats):
             # Get tally index
-            slab = materials.index(mat)
+            mat_index = self._mat_index_map[mat]
 
             # Zero out reaction rates and nuclide numbers
             number.fill(0.0)
@@ -551,7 +555,7 @@ class Operator(TransportOperator):
                 number[i_nuc_results] = self.number[mat, nuc]
 
             tally_rates = self._rate_helper.get_material_rates(
-                slab, nuc_ind, react_ind)
+                mat_index, nuc_ind, react_ind)
 
             # Accumulate energy from fission
             energy += self._energy_helper.get_fission_energy(
@@ -561,7 +565,10 @@ class Operator(TransportOperator):
             rates[i] = self._rate_helper.divide_by_adens(number)
 
         # Reduce energy produced from all processes
+        print("Energy - {}: {:9.7e}".format(comm.rank, energy))
         energy = comm.allreduce(energy)
+        if comm.rank == 0:
+            print("Energy: {:9.7e}".format(energy))
 
         # Determine power in eV/s
         power /= JOULE_PER_EV

From 81bf0a67daf332d51b1479a60bcc8077388300f2 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 13:15:26 -0500
Subject: [PATCH 079/127] Implementing intersection and union operators for
 BoundingBox.

---
 include/openmc/surface.h | 34 +++++++++++++++++++++++-----------
 src/cell.cpp             | 12 ++++++------
 src/surface.cpp          |  3 +--
 3 files changed, 30 insertions(+), 19 deletions(-)

diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 10b4a4c27..a7d107ee3 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -50,26 +50,38 @@ struct BoundingBox
   double zmin = -INFTY;
   double zmax = INFTY;
 
-  // in-place update to include another bounding box
-  inline void update(const BoundingBox& other) {
-    xmin = std::min(xmin, other.xmin);
-    xmax = std::max(xmax, other.xmax);
-    ymin = std::min(ymin, other.ymin);
-    ymax = std::max(ymax, other.ymax);
-    zmin = std::min(zmin, other.zmin);
-    zmax = std::max(zmax, other.zmax);
-  };
 
-  // in-place intersection with another bounding box
-  inline void intersect(const BoundingBox& other) {
+  inline BoundingBox operator &(const BoundingBox& other) {
+    BoundingBox result = *this;
+    return result &= other;
+  }
+
+  inline BoundingBox operator |(const BoundingBox& other) {
+    BoundingBox result = *this;
+    return result |= other;
+  }
+
+  // intersect operator
+  inline BoundingBox& operator &=(const BoundingBox& other) {
     xmin = std::max(xmin, other.xmin);
     xmax = std::min(xmax, other.xmax);
     ymin = std::max(ymin, other.ymin);
     ymax = std::min(ymax, other.ymax);
     zmin = std::max(zmin, other.zmin);
     zmax = std::min(zmax, other.zmax);
+    return *this;
   }
 
+  // union operator
+  inline BoundingBox& operator |=(const BoundingBox& other) {
+    xmin = std::min(xmin, other.xmin);
+    xmax = std::max(xmax, other.xmax);
+    ymin = std::min(ymin, other.ymin);
+    ymax = std::max(ymax, other.ymax);
+    zmin = std::min(zmin, other.zmin);
+    zmax = std::max(zmax, other.zmax);
+    return *this;
+  }
 
 };
 
diff --git a/src/cell.cpp b/src/cell.cpp
index 1dff5caf9..fc9a25e2e 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -213,7 +213,7 @@ BoundingBox Universe::bounding_box() const {
   } else {
     for (const auto& cell : cells_) {
       auto& c = model::cells[cell];
-      bbox.update(c->bounding_box());
+      bbox |= c->bounding_box();
     }
   }
   return bbox;
@@ -581,7 +581,7 @@ CSGCell::to_hdf5(hid_t cell_group) const
 BoundingBox CSGCell::bounding_box_simple() const {
   BoundingBox bbox;
   for (int32_t token : rpn_) {
-    bbox.intersect(model::surfaces[abs(token)-1]->bounding_box(token > 0));
+    bbox &= model::surfaces[abs(token)-1]->bounding_box(token > 0);
   }
   return bbox;
 }
@@ -603,9 +603,9 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
 
     if (two >= OP_UNION) {
       if (two == OP_UNION) {
-        current.update(model::surfaces[abs(one)-1]->bounding_box(one > 0));
+        current |= model::surfaces[abs(one)-1]->bounding_box(one > 0);
       } else if (two == OP_INTERSECTION) {
-        current.intersect(model::surfaces[abs(one)-1]->bounding_box(one > 0));
+        current &= model::surfaces[abs(one)-1]->bounding_box(one > 0);
       }
     } else {
     // two surfaces in a row, create sub-rpn for region in parenthesis
@@ -638,9 +638,9 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
       BoundingBox sub_box = bounding_box_complex(subrpn);
       // combine the sub-rpn bounding box with our current cell box
       if (op == OP_UNION) {
-        current.update(sub_box);
+        current |= sub_box;
       } else if (op == OP_INTERSECTION) {
-        current.intersect(sub_box);
+        current &= sub_box;
       }
     }
   }
diff --git a/src/surface.cpp b/src/surface.cpp
index 45cd025ba..14d077cff 100644
--- a/src/surface.cpp
+++ b/src/surface.cpp
@@ -1191,8 +1191,7 @@ void read_surfaces(pugi::xml_node node)
       }
 
       // See if this surface makes part of the global bounding box.
-      BoundingBox bb = surf->bounding_box(true);
-      bb.intersect(surf->bounding_box(false));
+      auto bb = surf->bounding_box(true) & surf->bounding_box(false);
       if (bb.xmin > -INFTY && bb.xmin < xmin) {
         xmin = bb.xmin;
         i_xmin = i_surf;

From 808a41b4e395c0c86ff0cfb957b82fc1d5dfa9d9 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Thu, 18 Jul 2019 14:35:39 -0500
Subject: [PATCH 080/127] Improve energy calculation with EnergyHelper.update

EnergyHelper (was FissionEnergyHelper) has a new
``update`` method that replaces get_energy. This method
is no longer abstract and defaults to not performing any actions.
This works in conjunction with a new private ``_energy`` atribute
and ``reset`` method to streamline the energy normalization procedure.
For the current concrete ChainFissionHelper class, the reset method
sets _energy to zero, while the update method updates the energy
with the dot product fission_rates X fission_q_vector.
The total energy produced is made accessible, but not publically
writable with an energy property. After cycling through all
local materials on an operator, the total system energy is computed
by

        energy = comm.allreduce(self._energy_helper.energy)

For a concrete class where the system energy is computed via tallies
and not with Q-values, the update methods could continue to do
nothing. The total system energy could be stored either in the
reset method or returned directly from the energy attribute/property.
---
 openmc/deplete/abc.py      | 43 ++++++++++++++++++++++++++++----------
 openmc/deplete/helpers.py  | 24 ++++++++++++---------
 openmc/deplete/operator.py | 16 ++++++--------
 3 files changed, 52 insertions(+), 31 deletions(-)

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index 62db6915e..b171d9356 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -250,23 +250,44 @@ class ReactionRateHelper(ABC):
         return results
 
 
-class FissionEnergyHelper(ABC):
-    """Abstract class for normalizing fission reactions to a given level
+class EnergyHelper(ABC):
+    """Abstract class for obtaining energy produced
+
+    The ultimate goal of this helper is to provide instances of
+    :class:`openmc.deplete.Operator` with the total energy produced
+    in a transport simulation. This information, provided with the
+    power requested by the user and reaction rates from a
+    :class:`ReactionRateHelper` will scale reaction rates to the
+    correct values.
 
     Attributes
     ----------
     nuclides : list of str
         All nuclides with desired reaction rates. Ordered to be
         consistent with :class:`openmc.deplete.Operator`
+    energy : float
+        Total energy [eV/s] produced in a transport simulation.
+        Updated in the material iteration with :meth:`update`.
     """
 
     def __init__(self):
         self._nuclides = None
-        self._fission_E = None
+        self._energy = 0.0
+
+    @property
+    def energy(self):
+        return self._energy
+
+    def reset(self):
+        """Reset energy produced prior to unpacking tallies"""
+        self._energy = 0.0
 
     @abstractmethod
     def prepare(self, chain_nucs, rate_index, materials):
-        """Perform work needed to obtain fission energy per material
+        """Perform work needed to obtain energy produced
+
+        This method is called prior to the transport simulations
+        in :meth:`openmc.deplete.Operator.initial_condition`.
 
         Parameters
         ----------
@@ -274,15 +295,15 @@ class FissionEnergyHelper(ABC):
             All nuclides to be tracked in this problem
         rate_index : dict of str to int
             Mapping from nuclide name to index in the
-            reaction rate vector used in :meth:`get_energy`.
+            `fission_rates` for :meth:`update`.
         materials : list of str
             All materials tracked on the operator helped by this
-            object
+            object. Should correspond to
+            :attr:`openmc.deplete.Operator.burnable_materials`
         """
 
-    @abstractmethod
-    def get_fission_energy(self, fission_rates, mat_index):
-        """Return fission energy in this material given fission rates
+    def update(self, fission_rates, mat_index):
+        """Update the energy produced
 
         Parameters
         ----------
@@ -291,10 +312,10 @@ class FissionEnergyHelper(ABC):
             material. Should be ordered corresponding to initial
             ``rate_index`` used in :meth:`prepare`
         mat_index : int
-            Index for the material requested.
+            Index for the specific material in the list of all burnable
+            materials.
         """
 
-
     @property
     def nuclides(self):
         """List of nuclides with requested reaction rates"""
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index 5e8b4146e..da85312a8 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -6,7 +6,7 @@ from itertools import product
 from numpy import dot, zeros
 
 from openmc.capi import Tally, MaterialFilter
-from .abc import ReactionRateHelper, FissionEnergyHelper
+from .abc import ReactionRateHelper, EnergyHelper
 
 # -------------------------------------
 # Helpers for generating reaction rates
@@ -68,9 +68,13 @@ class DirectReactionRateHelper(ReactionRateHelper):
 # ------------------------------------
 
 
-class ChainFissHelper(FissionEnergyHelper):
+class ChainFissionHelper(EnergyHelper):
     """Fission Q-values are pulled from chain"""
 
+    def __init__(self):
+        super().__init__()
+        self._fission_q_vector = None
+
     def prepare(self, chain_nucs, rate_index, _materials):
         """Populate the fission Q value vector from a chain.
 
@@ -86,23 +90,23 @@ class ChainFissHelper(FissionEnergyHelper):
         _materials : list of str
             Unused. Materials to be tracked for this helper.
         """
-        if (self._fission_E is not None
-                and self._fission_E.shape == (len(rate_index),)):
+        if (self._fission_q_vector is not None
+                and self._fission_q_vector.shape == (len(rate_index),)):
             return
 
-        fiss_E = zeros(len(rate_index))
+        fission_qs = zeros(len(rate_index))
 
         for nuclide in chain_nucs:
             if nuclide.name in rate_index:
                 for rx in nuclide.reactions:
                     if rx.type == "fission":
-                        fiss_E[rate_index[nuclide.name]] = rx.Q
+                        fission_qs[rate_index[nuclide.name]] = rx.Q
                         break
 
-        self._fission_E = fiss_E
+        self._fission_q_vector = fission_qs
 
-    def get_fission_energy(self, fiss_rates, _mat_index):
-        """Return fission energy for this material
+    def update(self, fission_rates, _mat_index):
+        """Update energy produced with fission rates in a material
 
         Parameters
         ----------
@@ -114,4 +118,4 @@ class ChainFissHelper(FissionEnergyHelper):
             index for the material requested. Unused, as identical
             isotopes in all materials have the same Q value.
         """
-        return dot(fiss_rates, self._fission_E)
+        self._energy += dot(fission_rates, self._fission_q_vector)
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index 03c9813f5..815602247 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -24,7 +24,7 @@ from . import comm
 from .abc import TransportOperator, OperatorResult
 from .atom_number import AtomNumber
 from .reaction_rates import ReactionRates
-from .helpers import DirectReactionRateHelper, ChainFissHelper
+from .helpers import DirectReactionRateHelper, ChainFissionHelper
 
 
 def _distribute(items):
@@ -154,9 +154,9 @@ class Operator(TransportOperator):
         self.reaction_rates = ReactionRates(
             self.local_mats, self._burnable_nucs, self.chain.reactions)
 
-        # Get class to assist working with tallies
+        # Get classes to assist working with tallies
         self._rate_helper = DirectReactionRateHelper()
-        self._energy_helper = ChainFissHelper()
+        self._energy_helper = ChainFissionHelper()
 
 
     def __call__(self, vec, power, print_out=True):
@@ -534,7 +534,7 @@ class Operator(TransportOperator):
 
         # Keep track of energy produced from all reactions in eV per source
         # particle
-        energy = 0.0
+        self._energy_helper.reset()
 
         # Create arrays to store fission Q values, reaction rates, and nuclide
         # numbers, zeroed out in material iteration
@@ -558,17 +558,13 @@ class Operator(TransportOperator):
                 mat_index, nuc_ind, react_ind)
 
             # Accumulate energy from fission
-            energy += self._energy_helper.get_fission_energy(
-                tally_rates[:, fission_ind], i)
+            self._energy_helper.update(tally_rates[:, fission_ind], mat_index)
 
             # Divide by total number and store
             rates[i] = self._rate_helper.divide_by_adens(number)
 
         # Reduce energy produced from all processes
-        print("Energy - {}: {:9.7e}".format(comm.rank, energy))
-        energy = comm.allreduce(energy)
-        if comm.rank == 0:
-            print("Energy: {:9.7e}".format(energy))
+        energy = comm.allreduce(self._energy_helper.energy)
 
         # Determine power in eV/s
         power /= JOULE_PER_EV

From c1d8f06ac1ced6a9b40c6971538c4148dea6311b Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 14:49:45 -0500
Subject: [PATCH 081/127] Restoring initial universe bounding box.

---
 src/cell.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cell.cpp b/src/cell.cpp
index fc9a25e2e..35187fa9b 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -207,7 +207,7 @@ Universe::to_hdf5(hid_t universes_group) const
 }
 
 BoundingBox Universe::bounding_box() const {
-  BoundingBox bbox;
+  BoundingBox bbox = {INFTY, -INFTY, INFTY, -INFTY, INFTY, -INFTY};
   if (cells_.size() == 0) {
     return {};
   } else {

From 72e92e9ad05e8498de26910bc9c8ef1aa747e5b6 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 18:14:57 -0500
Subject: [PATCH 082/127] More updates. Adding complex cell test to unit tests.

---
 include/openmc/capi.h                       |  4 +-
 src/cell.cpp                                |  5 +-
 src/material.cpp                            |  5 +-
 tests/regression_tests/complex_cell/test.py | 24 ------
 tests/unit_tests/test_capi.py               |  3 -
 tests/unit_tests/test_complex_cell_capi.py  | 93 +++++++++++++++++++++
 6 files changed, 99 insertions(+), 35 deletions(-)
 create mode 100644 tests/unit_tests/test_complex_cell_capi.py

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index d81e1e722..3dd9ae697 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -14,7 +14,7 @@ extern "C" {
   int openmc_cell_get_fill(int32_t index, int* type, int32_t** indices, int32_t* n);
   int openmc_cell_get_id(int32_t index, int32_t* id);
   int openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T);
-  int openmc_cell_get_name(int32_t index, const char*& name);
+  int openmc_cell_get_name(int32_t index, const char** name);
   int openmc_cell_set_name(int32_t index, const char* name);
   int openmc_cell_set_fill(int32_t index, int type, int32_t n, const int32_t* indices);
   int openmc_cell_set_id(int32_t index, int32_t id);
@@ -60,7 +60,7 @@ extern "C" {
   int openmc_material_set_density(int32_t index, double density, const char* units);
   int openmc_material_set_densities(int32_t index, int n, const char** name, const double* density);
   int openmc_material_set_id(int32_t index, int32_t id);
-  int openmc_material_get_name(int32_t index, const char*& name);
+  int openmc_material_get_name(int32_t index, const char** name);
   int openmc_material_set_name(int32_t index, const char* name);
   int openmc_material_set_volume(int32_t index, double volume);
   int openmc_material_filter_get_bins(int32_t index, const int32_t** bins, size_t* n);
diff --git a/src/cell.cpp b/src/cell.cpp
index 35187fa9b..d77e0ead7 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1085,14 +1085,13 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
 
 //! Get the name of a cell
 extern "C" int
-openmc_cell_get_name(int32_t index, char** name) {
+openmc_cell_get_name(int32_t index, const char** name) {
   if (index < 0 || index >= model::cells.size()) {
     strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  auto name_str = model::cells[index]->name_;
-  strcpy(*name, name_str.c_str());
+  *name = model::cells[index]->name_.c_str();
 
   return 0;
 }
diff --git a/src/material.cpp b/src/material.cpp
index 356c2bf21..292f71b40 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1382,14 +1382,13 @@ openmc_material_set_id(int32_t index, int32_t id)
 }
 
 extern "C" int
-openmc_material_get_name(int32_t index, char** name) {
+openmc_material_get_name(int32_t index, const char** name) {
   if (index < 0 || index >= model::materials.size()) {
     strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  auto name_str = model::materials[index]->name();
-  strcpy(*name, name_str.c_str());
+  *name = model::materials[index]->name_.data();
 
   return 0;
 }
diff --git a/tests/regression_tests/complex_cell/test.py b/tests/regression_tests/complex_cell/test.py
index 8074c0e05..b43ccd72f 100755
--- a/tests/regression_tests/complex_cell/test.py
+++ b/tests/regression_tests/complex_cell/test.py
@@ -7,27 +7,3 @@ import openmc.capi
 def test_complex_cell():
     harness = TestHarness('statepoint.10.h5')
     harness.main()
-
-def test_complex_cell_capi():
-    # initialize
-    openmc.capi.init([])
-
-    inf = sys.float_info.max
-
-    expected_boxes = { 1 : (( -4.,  -4., -inf), ( 4.,  4., inf)),
-                       2 : (( -7.,  -7., -inf), ( 7.,  7., inf)),
-                       3 : ((-10., -10., -inf), (10., 10., inf)),
-                       4 : ((-10., -10., -inf), (10., 10., inf)) }
-
-    for cell_id, cell in openmc.capi.cells.items():
-        cell_box = cell.bounding_box
-
-        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
-        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
-
-        cell_box = openmc.capi.bounding_box("Cell", cell_id)
-
-        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
-        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
-
-    openmc.capi.finalize()
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index 1c1da98a3..b02e43815 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -479,9 +479,6 @@ def test_bounding_box(capi_init):
 
     llc, urc = openmc.capi.bounding_box("Surface", 5)
 
-    print(llc)
-    print(urc)
-
     assert tuple(llc) == expected_llc
     assert tuple(urc) == expected_urc
 
diff --git a/tests/unit_tests/test_complex_cell_capi.py b/tests/unit_tests/test_complex_cell_capi.py
new file mode 100644
index 000000000..20cda54ae
--- /dev/null
+++ b/tests/unit_tests/test_complex_cell_capi.py
@@ -0,0 +1,93 @@
+import sys
+
+import numpy as np
+import openmc.capi
+
+
+def test_complex_cell(run_in_tmpdir):
+
+    openmc.reset_auto_ids()
+
+    model = openmc.model.Model()
+
+    u235 = openmc.Material()
+    u235.set_density('g/cc', 4.5)
+    u235.add_nuclide("U235", 1.0)
+
+    u238 = openmc.Material()
+    u238.set_density('g/cc', 4.5)
+    u238.add_nuclide("U238", 1.0)
+
+    zr90 = openmc.Material()
+    zr90.set_density('g/cc', 2.0)
+    zr90.add_nuclide("Zr90", 1.0)
+
+    n14 = openmc.Material()
+    n14.set_density('g/cc', 0.1)
+    n14.add_nuclide("N14", 1.0)
+
+    model.materials = (u235, u238, zr90, n14)
+
+    s1 = openmc.XPlane(x0=-10.0, boundary_type='vacuum')
+    s2 = openmc.XPlane(x0=-7.0)
+    s3 = openmc.XPlane(x0=-4.0)
+    s4 = openmc.XPlane(x0=4.0)
+    s5 = openmc.XPlane(x0=7.0)
+    s6 = openmc.XPlane(x0=10.0, boundary_type='vacuum')
+    s7 = openmc.XPlane(x0=0.0)
+
+    s11 = openmc.YPlane(y0=-10.0, boundary_type='vacuum')
+    s12 = openmc.YPlane(y0=-7.0)
+    s13 = openmc.YPlane(y0=-4.0)
+    s14 = openmc.YPlane(y0=4.0)
+    s15 = openmc.YPlane(y0=7.0)
+    s16 = openmc.YPlane(y0=10.0, boundary_type='vacuum')
+    s17 = openmc.YPlane(y0=0.0)
+
+    c1 = openmc.Cell(fill=u235)
+    c1.region = +s3 & -s4 & +s13 & -s14
+
+    c2 = openmc.Cell(fill=u238)
+    c2.region = +s2 & -s5 & +s12 & -s15 & ~(+s3 & -s4 & +s13 & -s14)
+
+    c3 = openmc.Cell(fill=zr90)
+    c3.region = ((+s1 & -s7 & +s17 & -s16) | (+s7 & -s6 & +s11 & -s17)) & (-s2 | +s5 | -s12 | +s15)
+
+    c4 = openmc.Cell(fill=n14)
+    c4.region = ((+s1 & -s7 & +s11 & -s17) | (+s7 & -s6 & +s17 & -s16)) & ~(+s2 & -s5 & +s12 & -s15)
+
+    model.geometry.root_universe = openmc.Universe()
+    model.geometry.root_universe.add_cells([c1, c2, c3, c4])
+
+    model.settings.batches = 10
+    model.settings.inactive = 5
+    model.settings.particles = 100
+    model.settings.source = openmc.Source(space=openmc.stats.Box(
+        [-10., -10., -1.], [10., 10., 1.]))
+
+    model.settings.verbosity = 1
+
+    model.export_to_xml()
+
+    openmc.capi.finalize()
+    openmc.capi.init()
+
+    inf = sys.float_info.max
+
+    expected_boxes = { 1 : (( -4.,  -4., -inf), ( 4.,  4., inf)),
+                       2 : (( -7.,  -7., -inf), ( 7.,  7., inf)),
+                       3 : ((-10., -10., -inf), (10., 10., inf)),
+                       4 : ((-10., -10., -inf), (10., 10., inf)) }
+
+    for cell_id, cell in openmc.capi.cells.items():
+        cell_box = cell.bounding_box
+
+        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
+        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
+
+        cell_box = openmc.capi.bounding_box("Cell", cell_id)
+
+        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
+        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
+
+    openmc.capi.finalize()

From 933a5c47704c5d2074e156a829f7fb00d41076d0 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 22:21:55 -0500
Subject: [PATCH 083/127] Updates based on suggestions from @paulromano.

---
 include/openmc/cell.h                       |  7 ++++---
 include/openmc/surface.h                    |  4 ++--
 openmc/capi/cell.py                         |  8 ++++----
 openmc/capi/core.py                         | 10 ++++++----
 openmc/capi/material.py                     | 16 +++++++--------
 src/cell.cpp                                | 22 ++++++++++-----------
 src/geometry.cpp                            |  1 +
 tests/regression_tests/dagmc/legacy/test.py |  3 +--
 8 files changed, 36 insertions(+), 35 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index 3a0c81646..752945cee 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -211,7 +211,7 @@ protected:
   bool contains_simple(Position r, Direction u, int32_t on_surface) const;
   bool contains_complex(Position r, Direction u, int32_t on_surface) const;
   BoundingBox bounding_box_simple() const;
-  BoundingBox bounding_box_complex(std::vector<int32_t> rpn) const;
+  static BoundingBox bounding_box_complex(std::vector<int32_t> rpn);
 };
 
 //==============================================================================
@@ -220,9 +220,7 @@ protected:
 class DAGCell : public Cell
 {
 public:
-  moab::DagMC* dagmc_ptr_;
   DAGCell();
-  int32_t dag_index_;
 
   bool contains(Position r, Direction u, int32_t on_surface) const;
 
@@ -232,6 +230,9 @@ public:
   BoundingBox bounding_box() const;
 
   void to_hdf5(hid_t group_id) const;
+
+  moab::DagMC* dagmc_ptr_; //!< Pointer to DagMC instance
+  int32_t dag_index_;      //!< DagMC index of cell
 };
 #endif
 
diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index a7d107ee3..5feb35701 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -171,8 +171,8 @@ public:
 
   void to_hdf5(hid_t group_id) const;
 
-  moab::DagMC* dagmc_ptr_;
-  int32_t dag_index_;
+  moab::DagMC* dagmc_ptr_; //!< Pointer to the DagMC instance
+  int32_t dag_index_;      //!< DagMC index of surface
 };
 #endif
 //==============================================================================
diff --git a/openmc/capi/cell.py b/openmc/capi/cell.py
index 1388d9732..af948c92d 100644
--- a/openmc/capi/cell.py
+++ b/openmc/capi/cell.py
@@ -1,5 +1,5 @@
 from collections.abc import Mapping, Iterable
-from ctypes import byref, c_int, c_int32, c_double, c_char_p, POINTER
+from ctypes import c_int, c_int32, c_double, c_char_p, POINTER
 from weakref import WeakValueDictionary
 
 import numpy as np
@@ -111,7 +111,7 @@ class Cell(_FortranObjectWithID):
     @property
     def name(self):
         name = c_char_p()
-        _dll.openmc_cell_get_name(self._index, byref(name))
+        _dll.openmc_cell_get_name(self._index, name)
         return name.value.decode()
 
     @name.setter
@@ -185,8 +185,8 @@ class Cell(_FortranObjectWithID):
 
     @property
     def bounding_box(self):
-        llc = np.zeros((3,), dtype=float)
-        urc = np.zeros((3,), dtype=float)
+        llc = np.zeros(3)
+        urc = np.zeros(3)
         _dll.openmc_bounding_box(b'Cell', self.id,
                                  llc.ctypes.data_as(POINTER(c_double)),
                                  urc.ctypes.data_as(POINTER(c_double)))
diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index 686dd7862..0e226d3a1 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -83,15 +83,17 @@ _dll.openmc_global_bounding_box.argtypes = [POINTER(c_double),
 _dll.openmc_global_bounding_box.restype = c_int
 _dll.openmc_global_bounding_box.errcheck = _error_handler
 
+
 def global_bounding_box():
     """Calculate a global bounding box for the model"""
-    llc = np.zeros((3,), dtype=float)
-    urc = np.zeros((3,), dtype=float)
+    llc = np.zeros(3)
+    urc = np.zeros(3)
     _dll.openmc_global_bounding_box(llc.ctypes.data_as(POINTER(c_double)),
                                     urc.ctypes.data_as(POINTER(c_double)))
 
     return llc, urc
 
+
 def bounding_box(geom_type, geom_id):
     """Get a bounding box for a geometric object
 
@@ -103,8 +105,8 @@ def bounding_box(geom_type, geom_id):
         Id of the object. Can be positive or negative for surfaces.
     """
     geomt = c_char_p(geom_type.encode())
-    llc = np.zeros((3,), dtype=float)
-    urc = np.zeros((3,), dtype=float)
+    llc = np.zeros(3)
+    urc = np.zeros(3)
     _dll.openmc_bounding_box(geomt,
                              geom_id,
                              llc.ctypes.data_as(POINTER(c_double)),
diff --git a/openmc/capi/material.py b/openmc/capi/material.py
index 3f98e9f67..f0ecac761 100644
--- a/openmc/capi/material.py
+++ b/openmc/capi/material.py
@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from ctypes import byref, c_int, c_int32, c_double, c_char_p, POINTER, c_size_t
+from ctypes import c_int, c_int32, c_double, c_char_p, POINTER, c_size_t
 from weakref import WeakValueDictionary
 
 import numpy as np
@@ -48,12 +48,12 @@ _dll.openmc_material_set_densities.errcheck = _error_handler
 _dll.openmc_material_set_id.argtypes = [c_int32, c_int32]
 _dll.openmc_material_set_id.restype = c_int
 _dll.openmc_material_set_id.errcheck = _error_handler
-_dll.openmc_cell_get_name.argtypes = [c_int32, POINTER(c_char_p)]
-_dll.openmc_cell_get_name.restype = c_int
-_dll.openmc_cell_get_name.errcheck = _error_handler
-_dll.openmc_cell_set_name.argtypes = [c_int32, c_char_p]
-_dll.openmc_cell_set_name.restype = c_int
-_dll.openmc_cell_set_name.errcheck = _error_handler
+_dll.openmc_material_get_name.argtypes = [c_int32, POINTER(c_char_p)]
+_dll.openmc_material_get_name.restype = c_int
+_dll.openmc_material_get_name.errcheck = _error_handler
+_dll.openmc_material_set_name.argtypes = [c_int32, c_char_p]
+_dll.openmc_material_set_name.restype = c_int
+_dll.openmc_material_set_name.errcheck = _error_handler
 _dll.openmc_material_set_volume.argtypes = [c_int32, c_double]
 _dll.openmc_material_set_volume.restype = c_int
 _dll.openmc_material_set_volume.errcheck = _error_handler
@@ -133,7 +133,7 @@ class Material(_FortranObjectWithID):
     @property
     def name(self):
         name = c_char_p()
-        _dll.openmc_material_get_name(self._index, byref(name))
+        _dll.openmc_material_get_name(self._index, name)
         return name.value.decode()
 
     @name.setter
diff --git a/src/cell.cpp b/src/cell.cpp
index d77e0ead7..35e295f78 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1,11 +1,12 @@
 
 #include "openmc/cell.h"
 
+#include <cctype>
 #include <cmath>
 #include <sstream>
 #include <set>
 #include <string>
-#include <cctype>
+#include <gsl/gsl>
 
 #include "openmc/capi.h"
 #include "openmc/constants.h"
@@ -586,7 +587,7 @@ BoundingBox CSGCell::bounding_box_simple() const {
   return bbox;
 }
 
-BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
+BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) {
 
   std::reverse(rpn.begin(), rpn.end());
 
@@ -599,7 +600,7 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
     int32_t two = rpn.back(); rpn.pop_back();
 
     // the first token should always be a surface
-    assert(one < OP_UNION);
+    Expects(one < OP_UNION);
 
     if (two >= OP_UNION) {
       if (two == OP_UNION) {
@@ -608,14 +609,16 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
         current &= model::surfaces[abs(one)-1]->bounding_box(one > 0);
       }
     } else {
-    // two surfaces in a row, create sub-rpn for region in parenthesis
+      // two surfaces in a row (left parenthesis),
+      // create sub-rpn for region in parenthesis
       std::vector<int32_t> subrpn;
       subrpn.push_back(one);
       subrpn.push_back(two);
       int32_t sone = one;
       int32_t stwo = two;
       // add until last two tokens in the sub-rpn are operators
-      while ((subrpn.back() < OP_UNION) || (*(subrpn.rbegin() + 1) < OP_UNION)) {
+      // (indicates a right parenthesis)
+      while (!((subrpn.back() >= OP_UNION) && (*(subrpn.rbegin() + 1) >= OP_UNION))) {
         subrpn.push_back(rpn.back());
         rpn.pop_back();
       }
@@ -649,12 +652,7 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) const {
 }
 
 BoundingBox CSGCell::bounding_box() const {
-    if (simple_) {
-      return bounding_box_simple();
-    }
-    else {
-      return bounding_box_complex(rpn_);
-    }
+  return simple_ ? bounding_box_simple() : bounding_box_complex(rpn_);
 }
 
 //==============================================================================
@@ -1091,7 +1089,7 @@ openmc_cell_get_name(int32_t index, const char** name) {
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  *name = model::cells[index]->name_.c_str();
+  *name = model::cells[index]->name_.data();
 
   return 0;
 }
diff --git a/src/geometry.cpp b/src/geometry.cpp
index 43620644f..b699f2268 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -501,6 +501,7 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
   } else {
     std::stringstream msg;
     msg << "Geometry type: " << gtype << " is invalid.";
+    set_errmsg(msg);
     return OPENMC_E_GEOMETRY;
   }
 
diff --git a/tests/regression_tests/dagmc/legacy/test.py b/tests/regression_tests/dagmc/legacy/test.py
index b6f2f55e2..d48ae9871 100644
--- a/tests/regression_tests/dagmc/legacy/test.py
+++ b/tests/regression_tests/dagmc/legacy/test.py
@@ -45,5 +45,4 @@ def test_dagmc():
     mats = openmc.Materials([u235, water])
     model.materials = mats
 
-    harness = PyAPITestHarness('statepoint.5.h5', model=model)
-    harness.main()
+    model.export_to_xml()

From 5b9debe542d2bd36be5ad6630aff51bedf9da1b7 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <shriwise@wisc.edu>
Date: Thu, 18 Jul 2019 22:23:03 -0500
Subject: [PATCH 084/127] Update src/geometry.cpp

Co-Authored-By: Paul Romano <paul.k.romano@gmail.com>
---
 src/geometry.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/geometry.cpp b/src/geometry.cpp
index b699f2268..cc67741fd 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -519,7 +519,7 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
 }
 
 extern "C" int openmc_global_bounding_box(double* llc, double* urc) {
-  auto bbox = model::universes[model::root_universe]->bounding_box();
+  auto bbox = model::universes.at(model::root_universe)->bounding_box();
 
   // set lower left corner values
   llc[0] = bbox.xmin;

From 6850d4ce62a15680944bb8fe1d62dd473fd5327f Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <shriwise@wisc.edu>
Date: Thu, 18 Jul 2019 22:30:35 -0500
Subject: [PATCH 085/127] Apply suggestions from @paulromano

Co-Authored-By: Paul Romano <paul.k.romano@gmail.com>
---
 openmc/capi/core.py | 2 +-
 src/geometry.cpp    | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index 0e226d3a1..c3f5ea1b6 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -102,7 +102,7 @@ def bounding_box(geom_type, geom_id):
     geom_type : str
         Type of geometry object. One of ('surface', 'cell', 'universe')
     geom_id : int
-        Id of the object. Can be positive or negative for surfaces.
+        ID of the object. Can be positive or negative for surfaces.
     """
     geomt = c_char_p(geom_type.encode())
     llc = np.zeros(3)
diff --git a/src/geometry.cpp b/src/geometry.cpp
index cc67741fd..15118cd04 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -487,16 +487,16 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
   if (gtype == "universe") {
     // negative ids only apply to surfaces
     if (id <= 0) { return OPENMC_E_GEOMETRY; }
-    const auto& u = model::universes[model::universe_map[id]];
+    const auto& u = model::universes[model::universe_map.at(id)];
     bbox = u->bounding_box();
   } else if (gtype == "cell") {
     // negative ids only apply to surfaces
     if (id <= 0) { return OPENMC_E_GEOMETRY; }
-    const auto& c = model::cells[model::cell_map[id]];
+    const auto& c = model::cells[model::cell_map.at(id)];
     bbox = c->bounding_box();
   } else if (gtype == "surface") {
     if (id == 0) { return OPENMC_E_GEOMETRY; }
-    const auto& s = model::surfaces[model::surface_map[abs(id)]];
+    const auto& s = model::surfaces[model::surface_map.at(abs(id))];
     bbox = s->bounding_box(id > 0);
   } else {
     std::stringstream msg;

From c1ca3028cbfe24b47861098a81b172b205f1f9b3 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 22:43:21 -0500
Subject: [PATCH 086/127] A few more small updates.

---
 include/openmc/surface.h | 2 +-
 src/cell.cpp             | 4 ++--
 src/material.cpp         | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/openmc/surface.h b/include/openmc/surface.h
index 5feb35701..d61ae07ce 100644
--- a/include/openmc/surface.h
+++ b/include/openmc/surface.h
@@ -171,7 +171,7 @@ public:
 
   void to_hdf5(hid_t group_id) const;
 
-  moab::DagMC* dagmc_ptr_; //!< Pointer to the DagMC instance
+  moab::DagMC* dagmc_ptr_; //!< Pointer to DagMC instance
   int32_t dag_index_;      //!< DagMC index of surface
 };
 #endif
diff --git a/src/cell.cpp b/src/cell.cpp
index 35e295f78..c3877d03b 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1085,7 +1085,7 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
 extern "C" int
 openmc_cell_get_name(int32_t index, const char** name) {
   if (index < 0 || index >= model::cells.size()) {
-    strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
+    set_errmsg("Index in cells array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
@@ -1098,7 +1098,7 @@ openmc_cell_get_name(int32_t index, const char** name) {
 extern "C" int
 openmc_cell_set_name(int32_t index, const char* name) {
   if (index < 0 || index >= model::cells.size()) {
-    strcpy(openmc_err_msg, "Index in cells array is out of bounds.");
+    set_errmsg("Index in cells array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
diff --git a/src/material.cpp b/src/material.cpp
index 292f71b40..4f3177907 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1384,7 +1384,7 @@ openmc_material_set_id(int32_t index, int32_t id)
 extern "C" int
 openmc_material_get_name(int32_t index, const char** name) {
   if (index < 0 || index >= model::materials.size()) {
-    strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
+    set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
@@ -1396,7 +1396,7 @@ openmc_material_get_name(int32_t index, const char** name) {
 extern "C" int
 openmc_material_set_name(int32_t index, const char* name) {
   if (index < 0 || index >= model::materials.size()) {
-    strcpy(openmc_err_msg, "Index in materials array is out of bounds.");
+    set_errmsg("Index in materials array is out of bounds.");
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 

From 3be192cd232f8c952ca51c52e2b30d5d5f649269 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 19 Jul 2019 07:15:36 -0500
Subject: [PATCH 087/127] Update many of the Jupyter notebooks

---
 examples/jupyter/candu.ipynb                  |  695 ++---
 examples/jupyter/mdgxs-part-i.ipynb           |  550 ++--
 examples/jupyter/mdgxs-part-ii.ipynb          |  460 ++--
 examples/jupyter/mgxs-part-i.ipynb            |   80 +-
 examples/jupyter/mgxs-part-ii.ipynb           | 2412 +++++++++++------
 examples/jupyter/mgxs-part-iii.ipynb          |  871 +++---
 .../nuclear-data-resonance-covariance.ipynb   |  162 +-
 examples/jupyter/nuclear-data.ipynb           |  142 +-
 examples/jupyter/pandas-dataframes.ipynb      | 1233 ++++++---
 examples/jupyter/pincell.ipynb                |  557 ++--
 examples/jupyter/post-processing.ipynb        |  515 +++-
 examples/jupyter/search.ipynb                 |   26 +-
 examples/jupyter/tally-arithmetic.ipynb       |  498 ++--
 examples/jupyter/triso.ipynb                  |   62 +-
 openmc/mgxs/mgxs.py                           |    2 +-
 15 files changed, 4818 insertions(+), 3447 deletions(-)

diff --git a/examples/jupyter/candu.ipynb b/examples/jupyter/candu.ipynb
index 8f10b13b3..1349e80ad 100644
--- a/examples/jupyter/candu.ipynb
+++ b/examples/jupyter/candu.ipynb
@@ -10,9 +10,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -31,9 +29,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "fuel = openmc.Material(name='fuel')\n",
@@ -62,9 +58,7 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Outer radius of fuel and clad\n",
@@ -91,13 +85,11 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# These are the surfaces that will divide each of the rings\n",
-    "radial_surf = [openmc.ZCylinder(R=r) for r in\n",
+    "radial_surf = [openmc.ZCylinder(r=r) for r in\n",
     "               (ring_radii[:-1] + ring_radii[1:])/2]\n",
     "\n",
     "water_cells = []\n",
@@ -123,18 +115,28 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAAFdCAYAAAA0bhdFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fa0cfb86be0>"
+       "<matplotlib.image.AxesImage at 0x154b1fe8f438>"
       ]
      },
+     "execution_count": 5,
      "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -154,12 +156,10 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "surf_fuel = openmc.ZCylinder(R=r_fuel)\n",
+    "surf_fuel = openmc.ZCylinder(r=r_fuel)\n",
     "\n",
     "fuel_cell = openmc.Cell(fill=fuel, region=-surf_fuel)\n",
     "clad_cell = openmc.Cell(fill=clad, region=+surf_fuel)\n",
@@ -170,18 +170,28 @@
   {
    "cell_type": "code",
    "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAAFdCAYAAAA0bhdFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fa0dcce2320>"
+       "<matplotlib.image.AxesImage at 0x154b1de334a8>"
       ]
      },
+     "execution_count": 7,
      "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -199,9 +209,7 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "num_pins = [1, 6, 12, 18]\n",
@@ -214,7 +222,7 @@
     "        x = r*cos(theta)\n",
     "        y = r*sin(theta)\n",
     "        \n",
-    "        pin_boundary = openmc.ZCylinder(x0=x, y0=y, R=r_clad)\n",
+    "        pin_boundary = openmc.ZCylinder(x0=x, y0=y, r=r_clad)\n",
     "        water_cells[i].region &= +pin_boundary\n",
     "        \n",
     "        # Create each fuel pin -- note that we explicitly assign an ID so \n",
@@ -228,18 +236,28 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWQAAAFdCAYAAAA0bhdFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAIABJREFUeJzt3X+sXVd1J/DvSuzWkKjEKiX1c1o6mQzx2LixE5qOZ4St\nAm5UUPCjqC0UI02QgVSPGgWjDFGNaFFmQlGcoFdeCsQDUXlUNJU6702kVKlpJs4EAg//Sj120mkm\n4Yd/NDSJJ1M7mDrJnj/u3df7nnd+7XP23mfve78fKQLfd+87+5177rrrrLP3OqKUAhERde+CrgdA\nREQ9DMhERJFgQCYiigQDMhFRJBiQiYgiwYBMRBQJBmQiokgs6XoAJhH5WQDXAfgegLPdjoaIyIll\nAH4JwANKqefKnhhVQEYvGH+t60EQEXnwPgB/XvaE2ALy9wDgPWs/htdd/AtWL7zvid24ftU2H2Py\njmPvBsfejXEb+49O/xBfP3wH0I9vZWILyGcB4HUX/wIue80VVi9ctuQi69fEgmPvBsfejTEee2UZ\nlhf1iIgiwYBMRBQJBmQiokiMTEBet2Jj10NojGPvBsfeDY69mMTUD1lErgawf/uGO5Mt+hMRmY69\n8CSmH70JAK5RSh0oe+7IZMhERKnzHpBFZEJEvioiz4rIiyLyWD8TJiIig9d5yCJyCYBvAvhb9Fbh\nPQvg3wA45XO7REQp8r0w5BMAfqCUMpe2fN/zNomIkuS7ZHE9gH0icq+IPCMiB0QkzTWTRESe+Q7I\nlwP4PQB/D+DXAfwpgGkReb/n7RIRJcd3yeICAAtKqU/2//2YiLwRwI0Avlr0ovue2I1lSy4aemzd\nio1YP7HJ20CJiNo6eGIvDp18eOixsy+dqf163wH5JIDHM489DuA3y150/aptnIdMRMlZP7FpUeJo\nzEOu5Ltk8U0AV2YeuxK8sEdEtIjvgHwngH8nIreIyL8Wkd8FsA3A5z1vl4goOV4DslJqH4B3AXgv\ngMMA/gDAR5VSX/e5XSKiFHlvUK+Uuh/A/b63Q0SUOvayICKKBAMyEVEkGJCJiCLBgExEFAkGZCKi\nSDAgExFFggGZiCgSDMhERJFgQCYiigQDMhFRJBiQiYgiwYBMRBQJBmQiokgwIBMRRYIBmYgoEgzI\nRESRYEAmIooEAzIRUSS838KJyJXZa3csemzrwq4ORtIT23gofQzIFK3Za3dgcn568G/z/2unjf8/\nt2U7AD9BUQdf2/EwQJMNliyIiCIhSqmuxzAgIlcD2L99w5247DVXdD0c6kA2K27KRbaclxW3GQ+z\n5fF07IUnMf3oTQBwjVLqQNlzmSETEUWCNWSKgsts1Pw9sw0zU1eZujmeWY81bhoNDMjUKdeBOMs2\nEPocj/klUXc8NF5YsiAiigQzZBp5g2x3xbn6zyXqADNk6oyu04YKgnkLOWx+7or+m0Ntj9LBgExE\nFAkGZCKiSHBhCJWqc1rddLbA6ZNLG72ujYtL6sixjaeMz/eF3OLCECKiBHGWBQ3JZl51Lridht/G\nPtRjzpGu877o+c4a35v4MSDTQJvVafp1uttZrL0bdFAzx+Z7cUob5ntiO77s85uuWqRwWLIgIooE\nM2TykiHG2rshbyz6sdOLftKdcXpP6LxgGbKIfEJEXhGRO0Jtk4goJUEyZBH5FQAfAvBYiO1Rfa67\nmpmqlizPbdkeZd02lLI6u+/3hPXkOHnPkEXkYgCzALYB+L++t0f1zF67w2swzm4rBnOZWQe2Pw8l\nxP7SS7djeW+oJ0TJYgbAfUqpBwNsi4goWV5LFiLyHgDrALzJ53YobpPz07lli60Lu6K6kBZa6HIF\nxc/b0mkRuQzAPgBvU0r9r/5j/wPAQaXUxwpeczWA/f9q+RosW3LR0M/WrdiI9RObvIx1HIVeJly0\ncCTEHGCbRStdjqer+dBNl2/TYgdP7MWhkw8PPXb2pTN4+tQRoMbSaZ8Z8jUAfg7AARGR/mMXAtgo\nIh8B8NOq4Nvg+lXb2MuCiJKzfmLTosTR6GVRyWdA/gaAtZnH7gHwOIDPFAVj8i/Uxbw6dJao58e6\nHpftikFzPD7GYm4jFrPX7ohuTOPKW0BWSp0BcNR8TETOAHhOKfW4r+1SmlwHwrbBb+vCLqdfErEu\nJae4hF46zayYiKhA0KXTSqm3hNwepcdFZuoqG3WRtcdapqA4sZcFRWcQvFacy124YAZHczGHfp3r\n4Ld1Yddg2p45nqJxmK9jICYb7PZGRBQJZshjKKUFGbkZpjFvtioD3bDyy423/ejxD5SPx2IcMUt5\n7KOGGTIRUSSYIVMQrrOwNpmv623kZdJNxNiXmcJiQB5Tc54WYhRtq2lADhF42yoaY9NAHaotKWeA\nxIclCyKiSDBDTkzZXaHzpoAV8blEuGhbdWSzzamVR2q/dub4mtrPbcpqPBj+W+pmzCEuutqctdSd\n6sdMuz1v3d6a0N3etm+4k82F+tp2AKtzWuqr81vVtotO9c2g1+Tvntuy3Wlwnlp5pPE4tKLxFAVp\n353fyjq8hTjmxonRXKiy2xtLFkREkWCGHDGXXdnqnKKG2F7VRbqm2Wje9oF2ZQydqbsaT9VY8rLl\nUTwGxo1NhsyAHKEUT1fLTlPrzJRwGfyyNr/pi9av2bPvw87HYfMlURScAbfvjdZV2WocsGRBRJQg\nZsiRCdE8vukV9iJNs2LAb2as2WSmsY0HKM+Wy9i8xzEdc6OGJYuEhbrXnetTyaYLOHyUBopU1XFd\n1a/ralJKAdytDAx9D79xvXcfSxZERAliQI7E7LU7ap2GxqhpdmyzyGIUNf37U1hOniflYzwUBmQi\nokhw6fSYGtQNG9b1UszSJuengZK6bSx34q7D3P9Na8op/b3jggE5Eql8OFIMxCZdJjAv7g1mVuzr\nZEit6ffE1cU+X9omAeOAJQsiokgwII85m4ssrrPjVM4KfHH999u8P7y4FieWLKhU6iWKceOitkzd\nYYZMRBQJZsiRCHlLJVObXsV5bLqrhbpVkSlvfPqxPUFH0vv7N1vsL9t9X3axr4s7j7PRUDUGZBpS\ndseOyfnpypkIOqi5bhI/rszl3HX2fV5T/FRmYRBLFkRE0WCGPKbyTh/N7Lht17PJ+WlMOWgS71JV\niaCLEkqRpvvffH52/29Y+eWhLLmrMhkVY7e3yIRohQgMd95yGYiLFLWcDNHuUqvTXS1E97nQ+yJv\ne2ZgDtFhkO032e2NiCgpzJAj5DtjMbOVbHbsO1MtylJ9ZqaxNajvYh8Aiy+06iw5xFnZuPZCBpgh\nExEliRf1IuTrYot5IS9E3TjP1MojuZmqz7/Z5qKifu6Uhwt8+m/Mu7A4tfKI9+ZG2Qutg2NgYRdm\nAxxzVI0BOUL64J015pS2/aDEclGlqAWm60Boe9+6vPFMOQxSVV8MXc90MI85F8da9vdSPSxZEBFF\nghf1EmF256qTwZSdKmZX44W80ShQP3u1vciYt0rNhexqRZvx1PkbbX+vC9kLi2V3trY53gBmxVnR\n3HVaRG4B8C4AqwD8GMC3APwnpdT/Lng+A7KFbAvFqg9CXn+K0HdaBpqVE2z7OOzc7O7k79Y9r7Qa\nS5muAnLRl0XV8mrbY47immXxZgB/AuBXAbwNwFIAfyMir/K8XSKi5Hi9qKeUerv5bxH5jwB+BOAa\nAI/43HZM6pQbmpzy2WQnqfc1Lso6dSa8c7W/bWez7eVYC2Bx5jwKssurs5pmxL4+A6Mm9CyLSwAo\nAM8H3m5wtjVf8zm6LWIsMyNi4bIM4ULeeEYxSDdlLjix/QzMjmlwDnaEi4gA+ByAR5RSR0Ntl4go\nFSEz5LsArAbwH6qeeN8Tu7FsyUVDj61bsRHrJzZ5Gpo7Nlemq0zOTw8yhaZZQuqlitiy4irmeFPN\nltv2T3bxGcjLllPIlA+e2ItDJx8eeuzsS2dqvz5IQBaRzwN4O4A3K6VOVj3/+lXbkpxl4aMngP59\ntgdlyoFYB7VTRw8D/XOpqv1q1h+Xr17rfEynjh4e/P+6Y5laeX4sKQZn28DsMhkxmZ+B2IPy+olN\nixJHY5ZFJe8BuR+MtwDYpJT6ge/tERGlyvc85LsAvBfAOwGYc49fUEqdzXl+0vOQY+ora5Mhh14Y\nUtaXeOfmCwbZaJtMS2epbbJl1+Moy5Jjeg+y6mTIXfTxTkVM85BvBPAzAB4CcML477c9b5eIKDlc\nOu2Ar9pZkaoswbZ+HHK1WHaFWPai3amjh52OY27L9kZZcohxmBlzqBWTTZsuVWXJIc4OgTS7x0Wz\ndNpWqgE51MGoVR2UTS/ohW5QbwZjF+WBIjbli9DjMINy6Ab1NooCcuhkREupdBFTyYKIiGpiP+QR\n0naq28zxNdjjaCxZZnP2UJmxpn/33tV3136uz3HM4XymrPfFrXte8X4X6DYd8NrOTaZ6mCG3lO1+\nlbq5LduH5vS6+p0zx9dgJhOMgV7wCXW6a84lbvJzV/L+5p2bLxjsIx/73/Xv7Nqofe40BmQiokiw\nZJGgQXZlXNhwtTJvcFrbv/jW9EKfeQEpW6bQQmWk2uT8dGnZIvSFqVNHDw9d4NP7aGbPGuf735Vs\nN7iubz01ahiQExRy6s/M8eHgUOv5GA4CqfWj6NrOzRcMZl+42P8++a57jxt+UoiIIsEMOXFVpYq8\nrMrMZrIXe8quxNtepa/KjLvIqnSZxCwVhC6daGUlFHP2hdb2PoHZY6HsOCjbHmdc+MOA3NLWhV2D\nhvKxMOuOk/vKn5sNilMNV3JlsUzhhlm+aKrOSsy8n+kpkG0WlPiS0ko9G/zUEBFFghmyA6EvbBRl\nBy56UujXxpwdUTWbs6Qqk/PThWdO+lgMdZaYYi8LG8yQiYgiweZCDoXuh2xe0PPZGMimQ5hN7dh1\nR7U69t5SPA95020fDDgS+050dWrJvjv3Zc+Y9IU99kMuZtNciCULh+a2bPceFLOnaiFaZw5+d0Vj\n+djNbdmO5SgOgD7fPxfyZl5k+R5/Ufli68KuwW3GfH4GRrVUocX/KSIiGhPMkB3ykSXEdBFjauUR\npxf4lq9eC8w7+3XJcX0z1qmVR1pfwGtDH6Oj/BnwjTVkT1zU1IpO0XTtONRdJkx592JrU64I0X4z\nlgb1TcZTJK9sEfq+fGY9OW+RiM/PQErYoJ6IKEEsWXiydWHXoBub2bu1KmMwM4IYMwN9EdFV6UJn\nibppe8wX1dpykRnnGVzY7bBckSf7Gahz7A+9FnF+BnxiQA5g6KCqmLaT0gHocmaFGZi7vMlpLOOo\nUmfGRUzM4Fz6nDHHkgURUSSYIVNUlq9e27p8YWajZfOOq8ahO7G1WcDiq0xBo4kBOTGu7gwSMx28\n9q6+e6g1ZllQNOuP2eB3eOnD1mNYe27j0O/TXxK242j6hZCa7J1EqBmWLIiIIsEM2bG6d8NN/QKG\nbc+KIlWn8ubPy+6Hl81E87Liyx5bXrotADh21alFr197bmPjcZRps1+0nZsvAI7W3mSUxuUzUwcz\nZCKiSDBDdsBmnrF2GmkuCdXzj3euzv953ZrvQH/pdFkN2JaZ3V722HK7C3LGeMxs2awpN+Fzv+j3\nZE/uT+OkPzOT89O135/ZnHnKo4YBuaU2y0P165oG55nja4J+COe2bC+8m3HbJcdD93dDs5kJOhCb\npYk24zEv5B2+qve7bQNzyP0Sulud7eKgJkHYZL5mdgSWVOdhyYKIKBLMkBsyv+1d0L/H9ps/9O2j\n8rhuNK9/1xzqr247vPThQWbs+j3RYwF6mXLdLDmG/eKDPuaKzpbyuG5gPzk/PShhjFKmzIBsyXUg\nzrI90PRp41SA5vgzx9cMza7w3RnNLBsUBaAmc4zb0tssCsyh94t+T2b2rBk0jw91x5AqPj8vZhID\njEZgZsmCiCgSzJAthLpvWJ6qFXq+LvCVZUQh9oXeRtncX6DBbIqG45jD+dkXVc/1qWi/+D5jKsuO\n9TEaesVe03JfjBiQI9T0ANPN4100rq+6sWnZogYfTh09PFS2yJYqQn1RTs5P4/NXvX9oDGbpouv9\nos0cd1e+sC1TaF0mMKliyYKIKBJBMmQRmQLwcQA/D+AxAL+vlPpuiG27lMq3vZkdaXXGbmZCVVfQ\nY9kXdZZD+9pmVekihMn56cJyziCrtTxzmsscOy7vo+jT5Px0Zc/l2HkPyCLyOwB2AfgQgAUANwF4\nQETeoJR61vf2XfA9s8KHRR+iN31xcGeJoufZTGMKrSzwxCTmY2Tm+JpBcAZQeDzEfBxU0Z/VVGvJ\nIUoWNwH4olLqz5RSTwC4EcCLANirj4jI4DVDFpGlAK4B8F/0Y0opJSLfALDB57ZHgetTMBennqEv\nWlG18++J3fvruxQR89lCrHxnyK8FcCGAZzKPP4NePZmIiPqinPZ23xO7sWzJRUOPrVuxEesnNnU0\nIiKiagdP7MWhk8NTMs++dKb2630H5GcBvAzg0szjlwL4x6IXXb9qGy57zRU+x5WEOccT3asu6tUx\nmPM672JE5MLgPTludwdqF8dDmdDd52KwfmLTosTx2AtPYvrRm2q93mvJQil1DsB+AG/Vj4mI9P/9\nLZ/bJiJKTYiSxR0A7hGR/Tg/7e3VAO4JsG0ndJZ6uuNx2MhmP5Pz05jct/h55nLrpiuyQpjbsj2J\nG4bGnBVm5yEXHQ+pzkMG0p3upnkPyEqpe0XktQA+jV6p4hCA65RS/+R7267F/GEzNV06PTk/PQjQ\nVUunY9kXg8UZAUsoMSwI0cq+qPSXsn6f8gJwnuz7OhXxF7XJdYmvC0Eu6iml7gJwV4htERGlKspZ\nFuOu6b329uz7MID6mVAZnSUVZUfLV68NmpVmG+johj66wU+ojN08nc/rh9z1ftFcNJjSzDOnzcZK\nvypbF3YNehXHcDaVAgZkC10eYLqlYVEbzqmVR5wE4qzJ+elBX4xsYA5xtxK9jar68bGrTg2atvsY\njx5HnXJFl/slW6ZwbWrlkcLyRei2m1qKNwsuwm5vRESRYIZsSX8L+8qUbS9M+M6IzN89tWU7Zvb0\nsqOdmy8YnC7PwU+5YG5L9b3jsqWLEKruqRd6v9y6pzf/2GWZokjZGVMe8/Pi47NibmMUMCA35PpA\na3pwxVCbW756rdNyweB03OJGnmvPbcThq/r1ZJyv87YZj1kv1qWKujc4BeLYLz4M/pYO68mjMKMi\nD0sWRESRYIbckvnND9h9+5tZcZNve18X8opMzk8XZkXmafrQ82sys9GmGeCgfHHV+fJF07LB3Jbh\ne+fZZMamkPsl9NlS2QW+PINjfMW5Rj3GzX0xitkxwIDshHlwmMG56jUpHlS6Zl0068EMGrqhfFnL\nTv18l6vw1p7bOKgpH7vq1OAeeHXuLpI3i6JpMDb53C+D6wgBv5zbygvOtV8zwliyICKKBDNkx8bh\nWxzoXdnfubne93mbi1BmFll2eps9tTezWjNbriubFTcdRxkXF+du3fMKpla2/jWdGpfPTB3MkImI\nIsEMOTGPHv9A4Wq9UaGzUZsLPuZz5zA8T7dtDfjU0cO1xzL0vPl4pqr51tUqvVHDgExRsQl+RSbn\npwf9JOosLvE1jsFYsPhLgigPSxZERJFghhyAOa2nKutKaQWSXrJb9+JemSZlijom56cHc4DrZKix\njKOK3vepmL12R61jX0vlM+AaA7In5gFoWwvVdyaJMTi7blTuKwDGyCxfAO7qyvo92VPxvNBsPwPm\nc2L+DPjEkgURUSREKdX1GAZE5GoA+7dvuDPZu043WRJapqzp0IaVXw7S7c0cS1GG3LRssem2D7YZ\nkpWqC3yuLuTVtfeWuxu9rqhcEaLbGzB8e6+82RUhPwMpMO46fY1S6kDZc1mycKhOncyW/n2zERyU\nvsoV4+rU0cNOZ17MHF/TadnCdSDWzM9AqkG5LpYsiIgiwQzZoRBN4rNZgs5apzzeU06fMm4uyZBd\nzrjwZXJ+etDYp+jnMaszs8L37aOKylY+zg6zJuengRXnvG6ja6whO+DrVK3IxcZBaa7a81FPLqsb\nl6kTmEPWj7W8lXNdzvSoU0duMsXNdT3ZrBtrZv349MmlzrZVZxwplS5sasjxpjNERGOGJQsHQmdW\nOiPPZgkuyhfZTKisTEHxmjm+ZnAzgbZnTmVnSaHPDgfbGdHSBTNkIqJIMENuKcTFDFt52ZFpqDNa\n5g4nrqa22fRLpmIulkibZ06msuPAfF2MZ0mz1+5Iqo5cFwNy4vSFlaKWnLkB1rgvns2HLS+4l22v\naubFnMeZIUXy5v0OHpsPOpTeQpWCWzTlBWLb/V/5s4bHAVtt+sMUhogoEsyQExTywoY5farOTTT1\nSjHzQhDLF3bM7NjF/vcptnJd6hiQE5Q3F9PVnUSyV+Sb3sl4cn56ODjs6QUHMzAvX702aJmgrESg\nfx4ywGTLJzoQ2wbhPNn9D7i5PpAtV/heiDJumLYQEUWCGXJLWxd2DXq3jgIfmc7k/PTgCv/MnjVD\nWXLIDKvWXaADZOyD1YJGtt67e7Sfzn2D32dcxEvdKM6wABiQR0rVjIsqUyuPND5FrmIGBXP2hQ6S\numm7j8CcFwCrnut1HKuHA7Hm+0tpauWRxmULzqwIgyULIqJIMEN2IPSFDdenayGb3JtZmjn7wsyU\nXTfFsek5HHIci2ZTeDo70YZKR45mYOhjMVTZLsXmQjbY7c2hEB2v6t5jzKZssWffh9sMydrmklrm\nzs0XOOm+llcesOV6HGWr7mJ6D7LqlCtCrVi9OMEeFlF0exOR14vIbhF5SkReFJF/EJE/FJEwffqI\niBLjs2SxCoAA+CCA/wPgjQB2A3g1gJs9brczPuex+jpVC3GqnLdNIP+0uVfGGL7QB1RnqWYvhuWr\n19a6gFdFZ9d7V989dLsp27EA5ffBA5rPN26qzQW+PFsXdg1uM+bzMzCqpQrNW0BWSj0A4AHjoe+J\nyO0AbsSIBmQiojZCX9S7BMDzgbcZjI8soWlm3HYKXJfOZ5Pn5yyX3XoJqDelrQ2zFl13LLfueQU4\n3r5bW1dsp7rpYzSWz0CKggVkEbkCwEcAfCzUNruQPSiBdo3B2x6EKQdmYPhUP4V+GC7aZXat7Zxj\n8zPQ9kYJ5u8bB9ZHuIjcJiKvlPz3soi8IfOalQD+GsBfKKXSjAxERJ41yZBvB/CViuc8pf+PiEwA\neBDAI0qpWnN77ntiN5YtuWjosXUrNmL9xCbLoXbH/Favky3nZQTjlBnUkZd9dpk1j0I27NPWhV2D\njoT6Vk+A3WcgNQdP7MWhkw8PPXb2pTO1X28dkJVSzwF4rs5z+5nxgwC+C6D2edD1q7YlOQ+5yNDB\nVTCPsskBaB7kVb/DVTe4rhQ2Zz/a+5/sjAGXgTobePVYplbmPz9E20tfqsoVNsdc4fMcfgZis35i\n06LE0ZiHXMlbDbmfGT8E4Gn0ZlW8TkQAAEqpZ3xtl4goVT4v6m0GcHn/vx/2HxMACsCFHrc7kvJO\n+bKnfuby1aKeycDwBb6Z42sGfXNjY9MXeA+GT3l1/2VX49Am56drjQUI1yS+iey48jLjvDtKFx1z\no1BuiAGXTkesTt2truyMDTMoh+xlAZQv2zWDcBsumrK73C9VwTnU0um8/WIGYxdLoBmch0WxdJqI\niOyw21uE8k4V25qcnx7M9ugya5nbsj33Dseus3T9e6Yalg1cZermeMo6rXVxB26Ty2PO/B0xHHMp\nYckiQr67xpnli2zpwndQKCpX+DxltylfhCjfdLEPgMVlE12qCNGpLcUuba6wZEFElCBmyJHpoq9s\niAt8RVlqyAuKdXoAh7i4FnpfVF3Ii6mP9yhihkxElCBmyJHwcSGvTN48ZdeZclXtNkTNOjuesjpy\nTOPxtf+zU9zabqPJeMYtU7bJkDnLYkwNPoRG6cJcXq0/xFM1+nDkiXFRxOT8NFBStuhylkOWuf9t\n93v2d2jZxR8x/b3Uw5IFEVEkmCHTkOzy6qEs601fLG7y06efnzfXmOzNHF8zyOrr7Pu8/d62vzGF\nwxpyJEJc6c5TdfXbZ4e40HdaBvLrqqGXjpts7v5sqywQh5rNk2fc5iRzlgURUYJYsqBSZpaVcj/l\nccHyRNqYIY85mylIrj/s5oyAceT677d5f8Zt6lkqGJCJiCLBkkUkdLYU+9zQ1O9inTc3Wj8Wa6P+\nKqmUKcZ1YYgNBuQx1fbDkWJtuaj1p/nz2L8QNRdBOJUkYJywZEFEFAlmyJHQmerpiufFqOkdrWO+\nn18ITZeWp1KiyGKpohozZCKiSDBDjkyIOqZNb1rzRqtFti7sWpS11c2YQ9Qx694xZOb4mkEzpRDj\nqbu8vOyO0GWq3mP989nIjrlxxqXTEfLdFrFs6WrTbZddJKwTnH0uX26yPNnHsm6bW0mVBWGX743m\na+k+Z1Zw6TQRUZKYIUfMZQOYOqeMIbZXlS27ahJvk42WjQVwk7XX6Q9dlBWP2jEwbmwyZAbkyLUt\nX8R8uloUnM02k03+btfN8Zt+SZQ1i9eKZkykWLbSWKYYxpIFEVGCmCEnJnt13cxizIzMZhaF7yvs\nNv1vs1lzVVN2U4hbRrUZj838Yd/9sZvOtCk63gBmxEVYsqBKIW9w2aaWmMqy7DxNF3CEah7P0kIY\nLFkQESWIGfKYCn3LKNe37Ykpc3a9lDn194aG2WTIXKlHQegSiavT47pBsE3gDt0zImQZieLEkgUR\nUSSYIY+hLu84bCuvZ4PNzBLXWW7dGQdF44nR7LU7khnrqGOGTEQUCWbIFB2zllqVyZs/172kXS/Z\nNc8oisaT9/hpcGoZ2WFApqi4KKdMzk9j1kEgdHGRTb92ln0dqIYgJQsR+SkROSQir4jIL4fYJhFR\nakJlyJ8FcAzA2kDbo8S4nvLVNjN1feHTVdZOo817QBaR3wCwGcC7Abzd9/ao2taFXdHcu8/33Fvb\nQOhzPOaXRN3xhBDLOMhzQBaRSwF8CcA7AfzY57aIiFLndem0iNwP4H8qpW4TkdcDeBrAOqXU3xU8\nn0unAwm9KqxoeW7IZcJVsy9Cz8/uep9wBkgYXpsLicht/YtzRf+9LCJvEJHtAC4G8Mf6pdZ/CY2E\nvEUTQL1x2f/kAAAJNklEQVQbdY6yor+/aH/R6GtSsrgdwFcqnvM0gF8DsAHAT0SGYvE+EfmaUuqG\nohff98RuLFty0dBj61ZsxPqJTQ2GS0QUxsETe3Ho5MNDj5196Uzt13srWYjIZQB+xnhoAsAD6F3c\nW1BKnch5DUsWgXXZoL6LJdxlnc1Cd1krK6HE1KCe2omi25tS6pj5bxE5g17Z4qm8YEzd2Lqwa3DV\n33VwrKpRptJPw5fJ+Wmg4AtirqP3hLoVupdFPM2XiYgiE2zptFLq+wAuDLU9qk9nS7Nbto/8LeDz\n+jLH2Id4nN4TOo/d3oiIIsFbONGQsrtal2lSmwx9EQ2I66IeYHf7JNtMnneFjkMUF/UoTdkP7WyN\nObFbF3bxwx7AYB+vOFdrDjffk/SwZEFEFAlmyFTKZ5Y15/CCVd3tlf09sY2nDLPf0cQMmYgoEgzI\nRESRYMmCOuNzlWDR9qp+HqJPNFfLUREGZBp5NgHQ15JlojpYsiAiigQzZOqUuUQY8NNMx6Y04GPJ\nsjkWcxtEWQzIFAXXgbBt8HNd32YfCaqDJQsiokiwlwVFy7aBvc+SQJOOcMyKCfB8Tz0iIvKDGTIl\nI6+hTpcZaGzjoTix2xuNpNiCXWzjofSxZEFEFAkGZCKiSDAgExFFggGZiCgSDMhERJFgQCYiigQD\nMhFRJBiQiYgiwYBMRBQJBmQiokgwIBMRRYIBmYgoEgzIRESRYEAmIooEAzIRUSQYkImIIsGATEQU\nCQZkIqJIMCATEUXCa0AWkXeIyLdF5EUReV5E/srn9oiIUubtJqci8m4AXwLwCQAPAlgK4I2+tkdE\nlDovAVlELgTwOQA7lFL3GD96wsf2iIhGga+SxdUAJgBARA6IyAkRuV9E1njaHhFR8nwF5MsBCIBP\nAfg0gHcAOAXgIRG5xNM2iYiSZhWQReQ2EXml5L+XReQNxu+9VSk1p5Q6COAGAArAbzn+G4iIRoJt\nDfl2AF+peM5T6JcrADyuH1RK/YuIPAXgF6s2ct8Tu7FsyUVDj61bsRHrJzbZjZaIKKCDJ/bi0MmH\nhx47+9KZ2q+3CshKqecAPFf1PBHZD+AnAK4E8K3+Y0sB/BKA71e9/vpV23DZa66wGRoRUefWT2xa\nlDgee+FJTD96U63Xe5lloZT6ZxH5AoA/EpFj6AXhm9ErWfylj20SEaXO2zxkAB8HcA7AnwF4FYDv\nAHiLUuoFj9skIkqWt4CslHoZvaz4Zl/bICIaJexlQUQUCQZkIqJIjExAPnhib9dDaIxj7wbH3g2O\nvdjIBOTs3L+UcOzd4Ni7wbEXG5mATESUOgZkIqJIMCATEUXC58KQJpYBwI9O/9D6hWdfOoNjLzzp\nfEAhcOzd4Ni7MW5jN+LZsqrnilKqwbD8EJHfBfC1rsdBROTB+5RSf172hNgC8s8CuA7A9wCc7XY0\nREROLEOvsdoD/QZthaIKyERE44wX9YiIIsGATEQUCQZkIqJIMCATEUWCAZmIKBIjGZBF5B0i8m0R\neVFEnheRv+p6TDZE5KdE5FD/Tt6/3PV4qojI60Vkt4g81d/n/yAif9i/j2KURGRKRJ4WkR/3j5Vf\n6XpMVUTkFhFZEJH/JyLPiMh/69/lPSki8on+sX1H12OpS0QmROSrIvJs/xh/TESudr2dkQvIIvJu\n9G4b9V8BrAXw7wGUTsaO0GcBHEPvHoQpWAVAAHwQwGoANwG4EcB/7nJQRUTkdwDsAvApAOsBPAbg\nARF5bacDq/ZmAH8C4FcBvA3AUgB/IyKv6nRUFvpffB9Cb58nQUQuAfBN9G7cfB2AfwtgB4BTzrc1\nSvOQReRC9BaVfFIpdU+3o2lGRH4DwO0A3g3gKIB1Sqm/63ZU9kTk4wBuVEpFd/twEfk2gO8opT7a\n/7cA+CGAaaXUZzsdnIX+F8iPAGxUSj3S9XiqiMjFAPYD+D0AnwRwUCn1sW5HVU1EPgNgg1JqU+WT\nWxq1DPlqABMAICIHROSEiNwvIms6HlctInIpgC8B2Argxx0Pp61LADzf9SCy+mWUawD8rX5M9bKS\nbwDY0NW4GroEvbOo6PZzgRkA9ymlHux6IJauB7BPRO7tl4oOiMg2HxsatYB8OXqnzp8C8GkA70Dv\ntOKh/mlH7L4C4C6l1MGuB9KGiFwB4CMAvtD1WHK8FsCFAJ7JPP4MgJ8PP5xm+ln95wA8opQ62vV4\nqojIewCsA3BL12Np4HL0svq/B/DrAP4UwLSIvN/1hpIIyCJyW/8iQNF/L/cvbui/51al1Fw/sN2A\nXhbxWzGPXUS2A7gYwB/rl3YxXpPFfjdfsxLAXwP4C6XUl7sZ+Vi4C716/Xu6HkgVEbkMvS+P9yml\nznU9ngYuALBfKfVJpdRjSqm7AdyN3nUSp2Jrv1nkdvSyxzJPoV+uAPC4flAp9S8i8hSAX/Q0tip1\nxv40gF9D75T5J73kZ2CfiHxNKXWDp/GVqbvfAfSuRAN4EL2s7cM+B9bCswBeBnBp5vFLAfxj+OHY\nE5HPA3g7gDcrpU52PZ4argHwcwAOyPmD+0IAG0XkIwB+WsV9MeskjJjS9ziA33S9oSQCcr9DUmmX\nJAAQkf3oXQm9EsC3+o8tRa/T0vc9DrGQxdh/H8AfGA9NAHgAwG8DWPAzunJ1xw4MMuMHAXwXwAd8\njqsNpdS5/nHyVgD/HRic/r8VwHSXY6ujH4y3ANiklPpB1+Op6RvozXgy3YNeUPtM5MEY6M2wuDLz\n2JXwEFOSCMh1KaX+WUS+AOCPROQYejvsZvRKFn/Z6eAqKKWOmf8WkTPolS2eUkqd6GZU9fQz44fQ\ny/RvBvA6nQgppbK12hjcAeCefmBeQG+a3qvRCxLREpG7ALwXwDsBnOlfBAaAF5RS0barVUqdQW/G\n0ED/+H5OKZXNPGN0J4BvisgtAO5Fb9rhNvSmeTo1UgG57+MAzqE3F/lVAL4D4C1KqRc6HVUzsWcO\n2mb0Lnxcjt70MaD3ZaLQOzWNilLq3v6UsU+jV6o4BOA6pdQ/dTuySjeit08fyjx+A3rHe0pSObah\nlNonIu8C8Bn0pus9DeCjSqmvu97WSM1DJiJKWRKzLIiIxgEDMhFRJBiQiYgiwYBMRBQJBmQiokgw\nIBMRRYIBmYgoEgzIRESRYEAmIooEAzIRUSQYkImIIvH/AcxZd0K5V2SNAAAAAElFTkSuQmCC\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fa0cc068470>"
+       "<matplotlib.image.AxesImage at 0x154b1ddaadd8>"
       ]
      },
+     "execution_count": 9,
      "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -257,15 +275,13 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "pt_inner = openmc.ZCylinder(R=pressure_tube_ir)\n",
-    "pt_outer = openmc.ZCylinder(R=pressure_tube_or)\n",
-    "calendria_inner = openmc.ZCylinder(R=calendria_ir)\n",
-    "calendria_outer = openmc.ZCylinder(R=calendria_or, boundary_type='vacuum')\n",
+    "pt_inner = openmc.ZCylinder(r=pressure_tube_ir)\n",
+    "pt_outer = openmc.ZCylinder(r=pressure_tube_or)\n",
+    "calendria_inner = openmc.ZCylinder(r=calendria_ir)\n",
+    "calendria_outer = openmc.ZCylinder(r=calendria_or, boundary_type='vacuum')\n",
     "\n",
     "bundle = openmc.Cell(fill=bundle_universe, region=-pt_inner)\n",
     "pressure_tube = openmc.Cell(fill=clad, region=+pt_inner & -pt_outer)\n",
@@ -285,9 +301,7 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "geom = openmc.Geometry(root_universe)\n",
@@ -300,19 +314,18 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQAgMAAAD90d5fAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
+     "execution_count": 12,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -323,7 +336,7 @@
     "    clad: 'silver',\n",
     "    heavy_water: 'blue'\n",
     "}\n",
-    "openmc.plot_inline(p)"
+    "p.to_ipython_image()"
    ]
   },
   {
@@ -338,9 +351,7 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "settings = openmc.Settings()\n",
@@ -354,9 +365,7 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "fuel_tally = openmc.Tally()\n",
@@ -370,21 +379,8 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "metadata": {},
+   "outputs": [],
    "source": [
     "openmc.run(output=False)"
    ]
@@ -399,9 +395,7 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "sp = openmc.StatePoint('statepoint.{}.h5'.format(settings.batches))"
@@ -410,14 +404,25 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr>\n",
@@ -463,12 +468,12 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>100</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>0</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -477,12 +482,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>200</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>1</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -491,12 +496,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>201</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>2</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -505,12 +510,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>202</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>3</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -519,12 +524,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>203</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>4</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -533,12 +538,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>204</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>5</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -547,12 +552,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>205</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>6</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -561,12 +566,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>7</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>300</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>7</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -575,12 +580,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>8</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>301</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>8</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -589,12 +594,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>302</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>9</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -603,12 +608,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>10</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>303</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>10</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -617,12 +622,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>11</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>304</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>11</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -631,12 +636,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>12</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>305</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>12</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -645,12 +650,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>13</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>306</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>13</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -659,12 +664,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>14</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>307</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>14</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -673,12 +678,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>15</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>308</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>15</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -687,12 +692,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>16</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>309</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>16</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -701,12 +706,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>17</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>310</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>17</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -715,12 +720,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>18</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>311</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>18</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -729,12 +734,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>19</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>400</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>19</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -743,12 +748,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>20</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>401</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>20</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -757,12 +762,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>21</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>402</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>21</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -771,12 +776,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>22</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>403</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>22</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -785,12 +790,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>23</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>404</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>23</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -799,12 +804,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>24</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>405</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>24</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -813,12 +818,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>406</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>25</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -827,12 +832,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>26</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>407</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>26</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -841,12 +846,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>27</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>408</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>27</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -855,12 +860,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>28</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>409</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>28</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -869,12 +874,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>29</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>410</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>29</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -883,12 +888,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>30</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>411</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>30</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -897,12 +902,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>31</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>412</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>31</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -911,12 +916,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>32</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>413</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>32</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -925,12 +930,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>33</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>414</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>33</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -939,12 +944,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>34</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>415</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>34</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -953,12 +958,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>35</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>416</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>35</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -967,12 +972,12 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>36</th>\n",
-       "      <td>10002</td>\n",
-       "      <td>10043</td>\n",
-       "      <td>10000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>44</td>\n",
+       "      <td>1</td>\n",
        "      <td>417</td>\n",
-       "      <td>10001</td>\n",
-       "      <td>10004</td>\n",
+       "      <td>2</td>\n",
+       "      <td>5</td>\n",
        "      <td>36</td>\n",
        "      <td>total</td>\n",
        "      <td>flux</td>\n",
@@ -984,87 +989,87 @@
        "</div>"
       ],
       "text/plain": [
-       "   level 1        level 2      level 3        distribcell nuclide score  \\\n",
-       "      univ   cell    univ cell    univ   cell                             \n",
-       "        id     id      id   id      id     id                             \n",
-       "0    10002  10043   10000  100   10001  10004           0   total  flux   \n",
-       "1    10002  10043   10000  200   10001  10004           1   total  flux   \n",
-       "2    10002  10043   10000  201   10001  10004           2   total  flux   \n",
-       "3    10002  10043   10000  202   10001  10004           3   total  flux   \n",
-       "4    10002  10043   10000  203   10001  10004           4   total  flux   \n",
-       "5    10002  10043   10000  204   10001  10004           5   total  flux   \n",
-       "6    10002  10043   10000  205   10001  10004           6   total  flux   \n",
-       "7    10002  10043   10000  300   10001  10004           7   total  flux   \n",
-       "8    10002  10043   10000  301   10001  10004           8   total  flux   \n",
-       "9    10002  10043   10000  302   10001  10004           9   total  flux   \n",
-       "10   10002  10043   10000  303   10001  10004          10   total  flux   \n",
-       "11   10002  10043   10000  304   10001  10004          11   total  flux   \n",
-       "12   10002  10043   10000  305   10001  10004          12   total  flux   \n",
-       "13   10002  10043   10000  306   10001  10004          13   total  flux   \n",
-       "14   10002  10043   10000  307   10001  10004          14   total  flux   \n",
-       "15   10002  10043   10000  308   10001  10004          15   total  flux   \n",
-       "16   10002  10043   10000  309   10001  10004          16   total  flux   \n",
-       "17   10002  10043   10000  310   10001  10004          17   total  flux   \n",
-       "18   10002  10043   10000  311   10001  10004          18   total  flux   \n",
-       "19   10002  10043   10000  400   10001  10004          19   total  flux   \n",
-       "20   10002  10043   10000  401   10001  10004          20   total  flux   \n",
-       "21   10002  10043   10000  402   10001  10004          21   total  flux   \n",
-       "22   10002  10043   10000  403   10001  10004          22   total  flux   \n",
-       "23   10002  10043   10000  404   10001  10004          23   total  flux   \n",
-       "24   10002  10043   10000  405   10001  10004          24   total  flux   \n",
-       "25   10002  10043   10000  406   10001  10004          25   total  flux   \n",
-       "26   10002  10043   10000  407   10001  10004          26   total  flux   \n",
-       "27   10002  10043   10000  408   10001  10004          27   total  flux   \n",
-       "28   10002  10043   10000  409   10001  10004          28   total  flux   \n",
-       "29   10002  10043   10000  410   10001  10004          29   total  flux   \n",
-       "30   10002  10043   10000  411   10001  10004          30   total  flux   \n",
-       "31   10002  10043   10000  412   10001  10004          31   total  flux   \n",
-       "32   10002  10043   10000  413   10001  10004          32   total  flux   \n",
-       "33   10002  10043   10000  414   10001  10004          33   total  flux   \n",
-       "34   10002  10043   10000  415   10001  10004          34   total  flux   \n",
-       "35   10002  10043   10000  416   10001  10004          35   total  flux   \n",
-       "36   10002  10043   10000  417   10001  10004          36   total  flux   \n",
+       "   level 1      level 2      level 3      distribcell nuclide score     mean  \\\n",
+       "      univ cell    univ cell    univ cell                                      \n",
+       "        id   id      id   id      id   id                                      \n",
+       "0        3   44       1  100       2    5           0   total  flux 2.08e-01   \n",
+       "1        3   44       1  200       2    5           1   total  flux 1.97e-01   \n",
+       "2        3   44       1  201       2    5           2   total  flux 1.90e-01   \n",
+       "3        3   44       1  202       2    5           3   total  flux 1.95e-01   \n",
+       "4        3   44       1  203       2    5           4   total  flux 1.91e-01   \n",
+       "5        3   44       1  204       2    5           5   total  flux 1.90e-01   \n",
+       "6        3   44       1  205       2    5           6   total  flux 1.82e-01   \n",
+       "7        3   44       1  300       2    5           7   total  flux 1.66e-01   \n",
+       "8        3   44       1  301       2    5           8   total  flux 1.69e-01   \n",
+       "9        3   44       1  302       2    5           9   total  flux 1.60e-01   \n",
+       "10       3   44       1  303       2    5          10   total  flux 1.59e-01   \n",
+       "11       3   44       1  304       2    5          11   total  flux 1.49e-01   \n",
+       "12       3   44       1  305       2    5          12   total  flux 1.51e-01   \n",
+       "13       3   44       1  306       2    5          13   total  flux 1.54e-01   \n",
+       "14       3   44       1  307       2    5          14   total  flux 1.66e-01   \n",
+       "15       3   44       1  308       2    5          15   total  flux 1.57e-01   \n",
+       "16       3   44       1  309       2    5          16   total  flux 1.65e-01   \n",
+       "17       3   44       1  310       2    5          17   total  flux 1.57e-01   \n",
+       "18       3   44       1  311       2    5          18   total  flux 1.60e-01   \n",
+       "19       3   44       1  400       2    5          19   total  flux 9.66e-02   \n",
+       "20       3   44       1  401       2    5          20   total  flux 1.18e-01   \n",
+       "21       3   44       1  402       2    5          21   total  flux 1.06e-01   \n",
+       "22       3   44       1  403       2    5          22   total  flux 1.11e-01   \n",
+       "23       3   44       1  404       2    5          23   total  flux 1.12e-01   \n",
+       "24       3   44       1  405       2    5          24   total  flux 1.10e-01   \n",
+       "25       3   44       1  406       2    5          25   total  flux 1.00e-01   \n",
+       "26       3   44       1  407       2    5          26   total  flux 9.54e-02   \n",
+       "27       3   44       1  408       2    5          27   total  flux 9.26e-02   \n",
+       "28       3   44       1  409       2    5          28   total  flux 9.55e-02   \n",
+       "29       3   44       1  410       2    5          29   total  flux 1.14e-01   \n",
+       "30       3   44       1  411       2    5          30   total  flux 1.08e-01   \n",
+       "31       3   44       1  412       2    5          31   total  flux 1.07e-01   \n",
+       "32       3   44       1  413       2    5          32   total  flux 1.12e-01   \n",
+       "33       3   44       1  414       2    5          33   total  flux 1.15e-01   \n",
+       "34       3   44       1  415       2    5          34   total  flux 1.14e-01   \n",
+       "35       3   44       1  416       2    5          35   total  flux 1.14e-01   \n",
+       "36       3   44       1  417       2    5          36   total  flux 1.11e-01   \n",
        "\n",
-       "       mean std. dev.  \n",
-       "                       \n",
-       "                       \n",
-       "0  2.08e-01  7.04e-03  \n",
-       "1  1.97e-01  5.27e-03  \n",
-       "2  1.90e-01  7.82e-03  \n",
-       "3  1.95e-01  6.47e-03  \n",
-       "4  1.91e-01  6.43e-03  \n",
-       "5  1.90e-01  4.89e-03  \n",
-       "6  1.82e-01  3.85e-03  \n",
-       "7  1.66e-01  5.82e-03  \n",
-       "8  1.69e-01  8.30e-03  \n",
-       "9  1.60e-01  3.09e-03  \n",
-       "10 1.59e-01  5.91e-03  \n",
-       "11 1.49e-01  5.31e-03  \n",
-       "12 1.51e-01  6.65e-03  \n",
-       "13 1.54e-01  3.67e-03  \n",
-       "14 1.66e-01  4.73e-03  \n",
-       "15 1.57e-01  6.54e-03  \n",
-       "16 1.65e-01  5.94e-03  \n",
-       "17 1.57e-01  5.73e-03  \n",
-       "18 1.60e-01  4.58e-03  \n",
-       "19 9.66e-02  4.47e-03  \n",
-       "20 1.18e-01  5.45e-03  \n",
-       "21 1.06e-01  4.72e-03  \n",
-       "22 1.11e-01  4.21e-03  \n",
-       "23 1.12e-01  5.08e-03  \n",
-       "24 1.10e-01  4.15e-03  \n",
-       "25 1.00e-01  5.08e-03  \n",
-       "26 9.54e-02  3.62e-03  \n",
-       "27 9.26e-02  4.00e-03  \n",
-       "28 9.55e-02  4.02e-03  \n",
-       "29 1.14e-01  9.53e-03  \n",
-       "30 1.08e-01  7.24e-03  \n",
-       "31 1.07e-01  5.72e-03  \n",
-       "32 1.12e-01  5.00e-03  \n",
-       "33 1.15e-01  6.24e-03  \n",
-       "34 1.14e-01  4.92e-03  \n",
-       "35 1.14e-01  5.32e-03  \n",
-       "36 1.11e-01  5.05e-03  "
+       "   std. dev.  \n",
+       "              \n",
+       "              \n",
+       "0   7.04e-03  \n",
+       "1   5.27e-03  \n",
+       "2   7.82e-03  \n",
+       "3   6.47e-03  \n",
+       "4   6.43e-03  \n",
+       "5   4.89e-03  \n",
+       "6   3.85e-03  \n",
+       "7   5.82e-03  \n",
+       "8   8.30e-03  \n",
+       "9   3.09e-03  \n",
+       "10  5.91e-03  \n",
+       "11  5.31e-03  \n",
+       "12  6.65e-03  \n",
+       "13  3.67e-03  \n",
+       "14  4.73e-03  \n",
+       "15  6.54e-03  \n",
+       "16  5.94e-03  \n",
+       "17  5.73e-03  \n",
+       "18  4.58e-03  \n",
+       "19  4.47e-03  \n",
+       "20  5.45e-03  \n",
+       "21  4.72e-03  \n",
+       "22  4.21e-03  \n",
+       "23  5.08e-03  \n",
+       "24  4.15e-03  \n",
+       "25  5.08e-03  \n",
+       "26  3.62e-03  \n",
+       "27  4.00e-03  \n",
+       "28  4.02e-03  \n",
+       "29  9.53e-03  \n",
+       "30  7.24e-03  \n",
+       "31  5.72e-03  \n",
+       "32  5.00e-03  \n",
+       "33  6.24e-03  \n",
+       "34  4.92e-03  \n",
+       "35  5.32e-03  \n",
+       "36  5.05e-03  "
       ]
      },
      "execution_count": 17,
@@ -1102,7 +1107,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/mdgxs-part-i.ipynb b/examples/jupyter/mdgxs-part-i.ipynb
index 4ca079b31..239b0f2df 100644
--- a/examples/jupyter/mdgxs-part-i.ipynb
+++ b/examples/jupyter/mdgxs-part-i.ipynb
@@ -27,13 +27,11 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAEgCAYAAADVKCZpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nfmI+3IqsCwAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -90,7 +88,7 @@
     "\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](https://mit-crpg.github.io/openmc/pythonapi/filter.html) on the energy range and spatial zone (material, cell, universe, or mesh) define the bounds of integration for both numerator and denominator."
+    "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](https://docs.openmc.org/en/stable/usersguide/tallies.html#filters) on the energy range and spatial zone (material, cell, universe, or mesh) define the bounds of integration for both numerator and denominator."
    ]
   },
   {
@@ -121,9 +119,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -138,50 +134,24 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First we need to define materials that will be used in the problem. Before defining a material, we must create nuclides that are used in the material."
+    "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": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "# Instantiate some Nuclides\n",
-    "h1 = openmc.Nuclide('H1')\n",
-    "o16 = openmc.Nuclide('O16')\n",
-    "u235 = openmc.Nuclide('U235')\n",
-    "u238 = openmc.Nuclide('U238')\n",
-    "pu239 = openmc.Nuclide('Pu239')\n",
-    "zr90 = openmc.Nuclide('Zr90')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
    "metadata": {},
-   "source": [
-    "With the nuclides we defined, we will now create a material for the homogeneous medium."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
    "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)"
+    "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)"
    ]
   },
   {
@@ -193,15 +163,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 4,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a Materials collection and export to XML\n",
     "materials_file = openmc.Materials([inf_medium])\n",
-    "materials_file.default_xs = '71c'\n",
     "materials_file.export_to_xml()"
    ]
   },
@@ -214,10 +181,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 5,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate boundary Planes\n",
@@ -236,10 +201,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a Cell\n",
@@ -256,40 +219,17 @@
    "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."
+    "We now must create a geometry and export it to XML."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# Instantiate Universe\n",
-    "root_universe = openmc.Universe(universe_id=0, name='root universe')\n",
-    "root_universe.add_cell(cell)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
+   "execution_count": 7,
    "metadata": {},
-   "source": [
-    "We now must create a geometry that is assigned a root universe and export it to XML."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "collapsed": false
-   },
    "outputs": [],
    "source": [
     "# Create Geometry and set root Universe\n",
-    "openmc_geometry = openmc.Geometry()\n",
-    "openmc_geometry.root_universe = root_universe\n",
+    "openmc_geometry = openmc.Geometry([cell])\n",
     "\n",
     "# Export to \"geometry.xml\"\n",
     "openmc_geometry.export_to_xml()"
@@ -304,10 +244,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# OpenMC simulation parameters\n",
@@ -340,10 +278,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 9,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a 100-group EnergyGroups object\n",
@@ -391,10 +327,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a few different sections\n",
@@ -422,22 +356,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "OrderedDict([('delayed-nu-fission', Tally\n",
-       "              \tID             =\t10000\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             =\t10001\n",
+       "              \tID             =\t2\n",
        "              \tName           =\t\n",
        "              \tFilters        =\tCellFilter, DelayedGroupFilter, EnergyFilter\n",
        "              \tNuclides       =\tU235 Pu239 \n",
@@ -445,7 +377,7 @@
        "              \tEstimator      =\ttracklength)])"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -463,11 +395,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "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",
@@ -503,84 +450,75 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
+   "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",
-      "                 ####################     %%%%%%%%%%%%%%%%%\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",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.8.0\n",
-      "          Git SHA1 | 5e313cf5f1d601074ad95c17ae589bf564972adb\n",
-      "         Date/Time | 2017-02-26 06:05:10\n",
-      "    OpenMP Threads | 8\n",
-      "\n",
-      " ===========================================================================\n",
-      " ========================>     INITIALIZATION     <=========================\n",
-      " ===========================================================================\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 geometry XML file...\n",
-      " Reading materials XML file...\n",
       " Reading cross sections XML file...\n",
-      " Reading H1 from /opt/xsdata/nndc/H1.h5\n",
-      " Reading O16 from /opt/xsdata/nndc/O16.h5\n",
-      " Reading U235 from /opt/xsdata/nndc/U235.h5\n",
-      " Reading U238 from /opt/xsdata/nndc/U238.h5\n",
-      " Reading Pu239 from /opt/xsdata/nndc/Pu239.h5\n",
-      " Reading Zr90 from /opt/xsdata/nndc/Zr90.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for H1\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",
-      " Building neighboring cells lists for each surface...\n",
+      " Writing summary.h5 file...\n",
       " Initializing source particles...\n",
       "\n",
-      " ===========================================================================\n",
       " ====================>     K EIGENVALUE SIMULATION     <====================\n",
-      " ===========================================================================\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",
+      "  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",
@@ -622,47 +560,32 @@
       "       50/1    1.24724    1.23260 +/- 0.00345\n",
       " Creating state point statepoint.50.h5...\n",
       "\n",
-      " ===========================================================================\n",
-      " ======================>     SIMULATION FINISHED     <======================\n",
-      " ===========================================================================\n",
-      "\n",
-      "\n",
       " =======================>     TIMING STATISTICS     <=======================\n",
       "\n",
-      " Total time for initialization     =  3.8846E-01 seconds\n",
-      "   Reading cross sections          =  3.0221E-01 seconds\n",
-      " Total time in simulation          =  1.2666E+01 seconds\n",
-      "   Time in transport only          =  1.2196E+01 seconds\n",
-      "   Time in inactive batches        =  5.1652E-01 seconds\n",
-      "   Time in active batches          =  1.2150E+01 seconds\n",
-      "   Time synchronizing fission bank =  5.1914E-03 seconds\n",
-      "     Sampling source sites         =  3.6297E-03 seconds\n",
-      "     SEND/RECV source sites        =  1.5222E-03 seconds\n",
-      "   Time accumulating tallies       =  5.2027E-04 seconds\n",
-      " Total time for finalization       =  4.8293E-02 seconds\n",
-      " Total time elapsed                =  1.3117E+01 seconds\n",
-      " Calculation Rate (inactive)       =  96801.2 neutrons/second\n",
-      " Calculation Rate (active)         =  16461.5 neutrons/second\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",
+      " 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"
      ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -686,10 +609,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 14,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Load the last statepoint file\n",
@@ -712,10 +633,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 15,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Load the tallies from the statepoint into each MGXS object\n",
@@ -750,28 +669,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 16,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[[  5.14223507e-06,   1.16426087e-06]],\n",
+       "array([[[5.14223507e-06, 1.16426087e-06]],\n",
        "\n",
-       "       [[  2.65426350e-05,   7.58220468e-06]],\n",
+       "       [[2.65426350e-05, 7.58220468e-06]],\n",
        "\n",
-       "       [[  2.53399053e-05,   5.73796202e-06]],\n",
+       "       [[2.53399053e-05, 5.73796202e-06]],\n",
        "\n",
-       "       [[  5.68141581e-05,   1.04757933e-05]],\n",
+       "       [[5.68141581e-05, 1.04757933e-05]],\n",
        "\n",
-       "       [[  2.32930026e-05,   5.45658817e-06]],\n",
+       "       [[2.32930026e-05, 5.45658817e-06]],\n",
        "\n",
-       "       [[  9.75735783e-06,   1.65150949e-06]]])"
+       "       [[9.75735783e-06, 1.65150949e-06]]])"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -789,9 +706,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "metadata": {
-    "collapsed": false,
     "scrolled": true
    },
    "outputs": [
@@ -799,6 +715,19 @@
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -818,8 +747,8 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>9.534320e-11</td>\n",
-       "      <td>4.789291e-11</td>\n",
+       "      <td>9.345817e-08</td>\n",
+       "      <td>6.616216e-08</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>199</th>\n",
@@ -827,8 +756,8 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>Pu239</td>\n",
-       "      <td>1.606580e-11</td>\n",
-       "      <td>8.071486e-12</td>\n",
+       "      <td>1.574816e-08</td>\n",
+       "      <td>1.114955e-08</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>398</th>\n",
@@ -836,8 +765,8 @@
        "      <td>2</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>1.224152e-09</td>\n",
-       "      <td>6.149552e-10</td>\n",
+       "      <td>4.824023e-07</td>\n",
+       "      <td>3.415087e-07</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>399</th>\n",
@@ -845,8 +774,8 @@
        "      <td>2</td>\n",
        "      <td>1</td>\n",
        "      <td>Pu239</td>\n",
-       "      <td>2.602562e-10</td>\n",
-       "      <td>1.307612e-10</td>\n",
+       "      <td>1.025593e-07</td>\n",
+       "      <td>7.261101e-08</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>598</th>\n",
@@ -854,8 +783,8 @@
        "      <td>3</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>9.032969e-10</td>\n",
-       "      <td>4.537585e-10</td>\n",
+       "      <td>4.605432e-07</td>\n",
+       "      <td>3.260339e-07</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>599</th>\n",
@@ -863,8 +792,8 @@
        "      <td>3</td>\n",
        "      <td>1</td>\n",
        "      <td>Pu239</td>\n",
-       "      <td>1.522290e-10</td>\n",
-       "      <td>7.648238e-11</td>\n",
+       "      <td>7.761348e-08</td>\n",
+       "      <td>5.494962e-08</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>798</th>\n",
@@ -872,8 +801,8 @@
        "      <td>4</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>1.749268e-09</td>\n",
-       "      <td>8.787082e-10</td>\n",
+       "      <td>1.032576e-06</td>\n",
+       "      <td>7.309948e-07</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>799</th>\n",
@@ -881,8 +810,8 @@
        "      <td>4</td>\n",
        "      <td>1</td>\n",
        "      <td>Pu239</td>\n",
-       "      <td>2.400495e-10</td>\n",
-       "      <td>1.206032e-10</td>\n",
+       "      <td>1.416989e-07</td>\n",
+       "      <td>1.003215e-07</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>998</th>\n",
@@ -890,8 +819,8 @@
        "      <td>5</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>2.724017e-10</td>\n",
-       "      <td>1.368376e-10</td>\n",
+       "      <td>4.233415e-07</td>\n",
+       "      <td>2.996976e-07</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>999</th>\n",
@@ -899,8 +828,8 @@
        "      <td>5</td>\n",
        "      <td>1</td>\n",
        "      <td>Pu239</td>\n",
-       "      <td>4.749191e-11</td>\n",
-       "      <td>2.386080e-11</td>\n",
+       "      <td>7.380753e-08</td>\n",
+       "      <td>5.225504e-08</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -908,19 +837,19 @@
       ],
       "text/plain": [
        "     cell  delayedgroup  group in nuclide          mean     std. dev.\n",
-       "198     1             1         1    U235  9.534320e-11  4.789291e-11\n",
-       "199     1             1         1   Pu239  1.606580e-11  8.071486e-12\n",
-       "398     1             2         1    U235  1.224152e-09  6.149552e-10\n",
-       "399     1             2         1   Pu239  2.602562e-10  1.307612e-10\n",
-       "598     1             3         1    U235  9.032969e-10  4.537585e-10\n",
-       "599     1             3         1   Pu239  1.522290e-10  7.648238e-11\n",
-       "798     1             4         1    U235  1.749268e-09  8.787082e-10\n",
-       "799     1             4         1   Pu239  2.400495e-10  1.206032e-10\n",
-       "998     1             5         1    U235  2.724017e-10  1.368376e-10\n",
-       "999     1             5         1   Pu239  4.749191e-11  2.386080e-11"
+       "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": 19,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -932,15 +861,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 18,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1082,7 +1022,7 @@
        "11     1             6         1   Pu239  2.729700   0.010858"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1101,10 +1041,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 19,
+   "metadata": {},
    "outputs": [],
    "source": [
     "beta.export_xs_data(filename='beta', format='excel')"
@@ -1119,20 +1057,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/nelsonag/git/openmc/openmc/tallies.py:1835: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n"
-     ]
-    }
-   ],
+   "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)"
@@ -1160,29 +1087,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 21,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fcb1e0dd588>"
+       "<matplotlib.legend.Legend at 0x14ac6a8999b0>"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuIAAAGHCAYAAAD1MjdLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xd8VFX6+PHPmZkkkzLpQEhCEkICKSQ0KUKUptJEERd1\n/cHaG+6K8HVFVBBkEdZF1lUXdbHBKgKCBQQpFhAQkBBBICTUFEqA9D6Zcn5/3EkhTEJLgqzn7Ssv\nZ+69c8+5dy7Jc899zjlCSomiKIqiKIqiKC1Ld7UroCiKoiiKoii/RyoQVxRFURRFUZSrQAXiiqIo\niqIoinIVqEBcURRFURRFUa4CFYgriqIoiqIoylWgAnFFURRFURRFuQpUIK78ZgghBgghjl+Fcj8S\nQvytpctVFEVRFOX3TQXiSpMRQmQIISqEECVCiEIhxE9CiMeFENfsdSaEuF8IIYUQf623/LgQYkAT\n7H+6EOLjK93PJZYphRBlQohSIcQJIcQ8IYS+JevQ0q6Fa9NxI2p3fC8lQoh0IcQDl/D5Fr+WFEVR\nlCvzm/kjpPzPGCmlNAHhwBxgMvD+1a3SFcsHJgshvFu6YKFpjn+nXaSUXsBg4F7gESdlG5qhXKea\nqqwLnK9r4do86fhevIGJwAIhRKerXCdFURSlmahAXGkWUsoiKeVK4G7gPiFEZwAhhJsQYq4QIksI\ncVoI8Y4Qwt3ZPoQQzwkhjjhaB1OFEHfU2Ue+ECKhzratHS2erRzvbxVC7K7T+plYZ9tuQogUx36X\nAsYLHM4BYBtaYOSsnro6dc0TQiwTQvg71p2XbuNonb1JCDEUeB6429EKusexfqMQYpYQYitQDkQK\nIYKFECsdx31YCPFInf1Nd5S5yHFM+4UQ113gmACQUqYBm4Hq7ydDCDFZCPErUCaEMDjKXiGEOCuE\nOCaEeKpO2XohxPN1vqddQoh2QogIR8u7oc62G4UQDzte3y+E2CqE+KcQIh+YLoSIEkJsEkIUCSFy\nHd9N9Wf7CiF2OtbtFEL0rbffc87XBY75sq5NIcTtjmuq2HG8Qx3LHxBCHHAc/1EhxGN1PrNPCDGy\nznsXx7F1vUAdpZRyDdpNYN1r919CiGxHHXYJIW5wLG/oWvIRQrwvhDgltKcffxOOpx+NnW9FURSl\nZahAXGlWUsqfgePADY5Ffwc6Al2BKCAEmNbAx484PucDzAA+FkK0lVKagSXA2Drb/hH4Vkp5VgjR\nHfgAeAwIAN4FVjoCLVfgS+C/gD/wGXDnRRzKVGBidYBdz1PAKKA/EAwUAP++0A6llGuBV4ClUkov\nKWWXOqvHAY8CJiAT+BTtPAYDfwBeEUIMrrP9bWjnxBdYCbx1EceEECIO7Rz/UmfxH4ERjn3ZgVXA\nHrTvajDwtBBiiGPbSY7th6O14j6IFgxfjN7AUaA1MAuYCawH/IBQ4E1HHf2B1cAbaN/nPGC1ECKg\nzr7qn68LupRrUwjRC1gE/BXtvNwIZDg+dwa41XH8DwD/dFyDOD5T9zodDpySUu5urG6Om7vbgEDg\ncJ1VOx318wcWA58JIYyNXEsLAavjeLoBtwAPO9Y5Pd+KoihKy1GBuNISTgL+QgiBlgIxUUqZL6Us\nQQse7nH2ISnlZ1LKk1JKu5RyKXAI6OVYvRC4V9SmIYxDC65xlPGulHKHlNImpVwImIE+jh8X4HUp\npUVKuRwtuGmUI3Baj5bOUN9jwAtSyuOOm4TpwB/ElaVbfCSl3C+ltAJBQBIwWUpZ6ajLe45jrrZF\nSrlGSmlDOw9dzt/lOVKEEAVoQfZ7wId11r0hpcyWUlYAPYFWUsqXpZRVUsqjwAJqv7OHgRellOmO\nVtw9Usq8izzGk1LKN6WUVkdZFrS0kWDHcW5xbDcCOCSl/K9j20+BNGBknX3VnC8ppeUiy4eLvzYf\nAj6QUm5wXI8nHE8TkFKullIecRz/JrTrpDq4/xgYLmrTmupep84ECyEKgQrgC2CSlLLmJklK+bGU\nMs9xnK8BboDT1BUhRBtgGPC0lLJMSnkG+GedY2rofCuKoigtRAXiSksIQXvE3grwAHYJLWWkEFjr\nWH4eIcSfRG16SSFa+kQggJRyB1AG9BdCxKC1+K10fDQc+L/qzzk+2w6tNTkYOCGllHWKuqgWVLTW\n0SeEEEH1locDX9Qp6wBgA9pc5H6dya7zOhioDg6rZaKd12o5dV6XA8YL3Ah0l1L6SSk7SClflFLa\nGyg7HEdwWOf4nqf22NqhPbm4HNn13j8LCOBnR3rNg47lwZz/HdU//vr7ulgXe202eJxCiGFCiO1C\nSxsqRGv1rr5OTwJbgTuFEL5ogfEnjdTnpJTSF611/Q1gUL2y/s+RBlPkKMunuiwnwtFuOk/VOaZ3\n0Z5AQMPnW1EURWkhLdYZS/l9EkL0RAt2tgC5aC198VLKExf4XDhay+tgYJuU0iaE2I0WOFRbiPbY\nPwdYLqWsdCzPBmZJKWc52W9/IEQIIeoE42FcRDAppUwTQnyOFojWlQ08KKXc6qS8YLQAr/q9nnNv\nPGT9zzhZXt1qa6oTjIcBjZ7DK1C37GzgmJQyuoFts4EOwL56y8sc//cAih2v69/AnHPsUsocHJ1G\nhRBJwLdCiB/Rjj+83mfD0AJlp/u6GJd4bVYfZ/19uAErgD8BX0kpLUKILzn/On0Y7ffttgtd+wBS\nSrMQYjKQLoQYJaX80pEPPhnt38R+KaXd8VSjuqz65yAb7UlQoOPJSv0ynJ5vKeXh+tsqiqIozUO1\niCvNQgjhLYS4FS1v+WMp5V5Hq+sCtBza1o7tQurkG9fliRZYnHVs9wCODoV1/Be4Ay0YX1Rn+QLg\ncSFEb6HxFEKMEEKY0DpdWoGnhNYRcTS16S4XYwZaHrBvnWXvALMcNw8IIVoJIW53rDuI1jo9Qgjh\nAryIlk5Q7TQQIRoZGUVKmQ38BMwWQhiF1vH0IRpvWW0qPwPFQuvA6S60zpmdHUEsaGktM4UQ0Y5z\nnSiECJBSnkW7URjr+MyDOAlk6xJCjBFChDreFqB9/zZgDdBRCHGv4zu7G4gDvr6cA7rMa/N94AEh\nxGBH/naI40mMK9r3eRawCiGGoeVh1/Ul0B2YwLnXaaOklFXAa9T2oTChXbtnAYMQYhpay3m1c64l\nKeUptDSZ1xzHrBNCdHDcjDZ2vhVFUZQWogJxpamtEkKUoLXGvYDWsa7uWMiT0TqfbRdCFAPf4iTH\nVUqZihaEbEMLMBLQHvHX3eY4kIIWQGyuszwZraXvLbQA4zBwv2NdFTDa8b4AbeSMzy/24KSUx9Bu\nADzrLP4XWlrMesexb0friIiUsggYjxawnkBrKa47ispnjv/nCSFSGin6j0AEWuvwF8BLUsoNF1vv\ny+XIOR+J1kHwGFrL8XtoKRGgfb/L0AK+YrSAtXqkkUfQOjfmAfFoNxON6QnsEEKUop3PCVLKY46c\n81uB/3Ps61ngVill7iUezmVfm46OnQ+g5VgXAZuAcMcTiqcc56AAbSjIlXX2iSP/fQXQnku41hw+\nAMKENvLKOuAbtJu7TKCSc1NynF1Lf0K7WUh11G850Naxzun5vsT6KYqiKFdAnJsqqyjXFiHEB2h5\ntS9e7booSkMcrdcdpZRjL7ixoiiK8ruhcsSVa5YQIgKtdbvb1a2JojRMaMMvPsS5o9woiqIoikpN\nUa5NQoiZaB0E/6Eepyu/VUKbeCkb+EZK+ePVro+iKIry26JSUxRFURRFURTlKlAt4oqiKIqiKIpy\nFahAXFEURVEURVGugmuus2ZgYKCMiIi42tVQFEVRlBaxa9euXCml0xmIFUW5tl1zgXhERATJyclX\nuxqKoiiK0iKEEJlXuw6KojQPlZqiKIqiKIqiKFeBCsQVRVEURVEU5SpQgbiiKIqiKIqiXAUqEFcU\nRVEURVGUq0AF4oqiKIqiKIpyFahAXFEURVEURVGuAhWIK4qiKIqiKMpVoAJxRVEURVEURbkKVCCu\nKIqiKIqiKFdBswXiQogPhBBnhBD7GlgvhBBvCCEOCyF+FUJ0b666KIqiKIqiKMpvTXO2iH8EDG1k\n/TAg2vHzKPB2M9ZFURRFURRFUX5TDM21Yynlj0KIiEY2uR1YJKWUwHYhhK8Qoq2U8lRz1cmZWdcv\nJfhkAFIvKPOykN+qGCkkUkqCTgZS6W4jt00eQX3hL1Pv5Zm7/oF7QSSepV7YdWBxsVEYeAKpk9j1\nEkOlL5Veedh1Nrw9yimvKKdK541F74rZJRirwY7FxY5nZRroLBgsZegNUOyuQ+psWAwuuFeWo5N2\npLSTFRGDTtox2GyEHD+KW2kl7y/4iBemzCTvzH4qvH2xurjhfzIDnd2GzmbDbvJHJ3S4WKuwlxQx\nd/laAJZ/uoasD17EZLHjbq4gU9gBibDZaF94lqCKSopcDSR3GcnfVnwGwP/d+wC9Uz7BKgQWPfzq\n15YCdz+sOh3elbn4Wko46tMBjK1Z/PlqHpw4g6PHt+JbuQ+bvopyg458Qzjlxg5Y9Ho8jP6UmQup\n0rsghZ6ebXuRcvJXBDry5EHMLqdB6nGzBBEsuhIZEM4XL91Ptwl/Q6DjdNUxfAjB17UNOgzkVuaQ\nZzuGkAZc8OK2jrex8KWbAPjTtI1sO5RGcUUZoV6RdAgMwyBcKSu3kZp5FoPdAz8Pb9b+Nw5vkx6A\n51+wk5wsMOgFQUHQtSvo9aDTwfbt4O8PPXrAoEEQHAx79sDu3ZCTA25uYDJBYiK4umo/paXQtq32\n2mQCg0Hbl17fkle5oiiKoii/Rc0WiF+EECC7zvvjjmUtGojP3/lXTtq0arjiSiCBuDr+yyILd9xp\nT3uSjCMAyEvOIefY9+SQgxEjJkz0pS+ejv/yDMcItbbBE08O9M8juKQ9XVNaOym5DQAZ7csp8C+l\n2y5tm9OtrXiWGahyBYsB/AvArgObHrJDe3EqNB+AipNeuJY8TvBBMFZCSg8o94AyTwjIA7MrFPhB\npWdeTYmH83OY8sI85ydCSgB0djs37txes/hkaw8envclepsNV6uVbgcPEnH6NH6VlRR6eZHt40Pf\nffvAXAJAt91reeJUAbneofiUlRGcm0vbgj24WZIBSPV3Iy7fDECVDhZ3/oHXso9QaYCAcvCuAosO\ncrxgZ8jXHPMKo9J8LxN3zaDcBfwrIDUQDgZCsRu0tWjLTnvBCRN8UfAzC9EC8WWlf8Ycsx+AM0BK\n9UH5AsG1h55TfAZvUysA/lERh/X6dG1FlSccDAOLO1iNELwXqkywPp7XjTOZ8IfeTHxnJT9krQX/\no2D2gvJA+PtIqPQFsw+u3vlUFQSB2Zvpk/3IPOrGhx9qgbjNBkJogXlEBHh6QvfuEBcH332nvXd1\n1YJ/T0/w8IDkZPDyAm9v6NMHEhKgZ08t4K+o0Ja7uTn/ihVFURRF+W25moG4cLJMOt1QiEfR0lcI\nCwtr0kpYpaXmdRVVnOTkOesrqaSAAnpYBwGwvzCZnfx4zjYb2FDz2s3qhhkt0ByUfRuUSP7BLowY\nySEHd9zxwIMbuZE2tEGa/dCVumAnmwACEFY/2pT5QNn5de10CFzsWpTlf9pE0rradb2SnR9fvp8P\nPKO9djnhwsrnwMUCVa6wtzMU+EOxN3iVCKSArHA9VSbPms8fDwmlxMOj5v263r3PK2Nlv36EnMlh\nMvDVTcN4qt+N56zXW634l5TgW1pK25wTWN29CCgqIqC4mKBjadhCOxFYVMQuT0/cq6pIOHKE9jk5\nxORZ2N62EGtZOY/vcn589f3Sej+8rr3+/MsMuuSC3g672sLWMMjzgHIDdMyHI36QFgjGOpei1Jlr\nr0y3Mmh14NwCjCXgfRKz+CsAxzyWQ6//nrtNz3drXlZZ3MGlAoCtuhmc8rLAY6uxWYwQcBBZZcJW\n6cuRX8dCURjiTDhndUbWHSiGkraE+gZz/Ji702NdsAB69YIdO2DRInjySW25EBAUpAXwgYFw6pS2\nzM8PBgyA2bO17cxmOHoUwsO1IF9RFEVRlJZ1NQPx40C7Ou9DoV4U7CCl/A/wH4DrrrvOabB+uSyu\nFqi88HY33NITAEMroKDh7exC1txORMe0Z9/+PecE9+WUk0cen/AJAJ2K4wiyBbOJbwFoUxiEG64E\nOP5LIw0//AgiiEEMIsQYB0B8u46A/YL1ttVpHY0Li8W9tBQAoxn6bXP+mUM9Y+EV7fWQH7vw/FSo\ncNcC9l09ID0GcoLgTCs42wrsBjDqtEtJF3z+jZLNYOCsnx9n/fxwkXZSw8Jr1g37NYQ5iYnnfcZg\ntdIpO5vEE8d5127mvueeIyg/HxerlQG7d9Nv3z7cq6rO+5yrf6ua112LdQRrDfWMOKz9OFM8tfYC\n+GpVDvGntdb1n8Lgve6Q6QNmF3C1QpXjX0xoa+1mxdO3rPGvQdRerr5GH9JdfoKAX2rXVz+xaLsb\ngIzivhTY28OD2vWRUxQNhW2gJASKgyF8s/a6oD3sGYvJuzsgKCqq3aWUWvB9ysmzpZyc2kB8926t\nVR20Vvn4eC0oDw6GkhJtWY8ecOed0MT3v4qiKIqicHUD8ZXAn4UQS4DeQFFL54cDnC09TXl5OYWF\nhVRWagFZZWUlJSUlpKamotfrCQ0NpWdPLRB/ZvYE1qyJ5uDBg5SVlSGEICwsjKKiIoqKijh79iye\nnp4UFxeT9MfryPwkHTIbLr/ToCgsFgt8o713C3ElKzuLLLJqtjnOcfaylw1s4DpxHeO4jeNt9vB8\n2/m4VLkQqA/ksYGP0cHYAfdKdwo3FWIvtWO32InuHFiznx4BYaSSesFz0rdbbaA8oKwNVnMJ7mbw\nL4SIrHO3teugLNJAZbcI+AMMcO1J4J4SdvlUciQMbPW6A5viO2tRHmAQAlufPlBefl4drAYD+9u3\nJywsjHIvTxYNGVKzbta4cQAEFxfjWVZGkdFI2/x8Oh89yjP5+TXbBdsuIhFbCLzb1eapDC/yRhRV\nElEE/Y7DX3/SlpsD/XHLzafK3Y3yTu3R36Q99Xj+9tF8t8+FA8VHKZFay3eodyhFlUUUVhZSZC7C\nw8WDosoiRg72p2hvIVlHGq7OdbGtqLTmkXXacb58zRT4bKm3lePxx/Wvc0j2Bzbyi1yI4dH/YC03\nQUEkbH4eikOo/+DJz6/29ck6t712O+zdq/3U9cknsG0bLFumvf/HP+CDD7SAPTYW7rpLS40xXM3f\nJIqiKIpyjWq2P59CiE+BAUCgEOI48BLgAiClfAdYAwwHDgPlwAPNVZfG6PV6TCYTJpPpvHV9+/Y9\nb9no0aMZPXr0Re9/+PDhnD17loyMDPbu3cuJEyfIzc0lODiY3NxcunbtyunTpykrK+PUqVOUOwlK\n6+qY2BGAY+XHSDuVVrP8h6U/ABAeHk5RZRHe/t7ExMTw+OOP05WuAATcGkDXH7tSebQS82kz7hHu\nWPItWPOt5K/NpzKzEmEQ+CbWnguXHCvWRuqjs4PpsJXQIC3ovfUTG32/qW1h1nnp8Oxlwm2AD5aO\nrlQFGTF3MJBnsVBms5FntRJcWkquxUJycTH5VitVsrYVOTgkhFMN9Gw86e2tJUUDZ/z82NOhA2d8\nfVnvWH/L2rWUFBTQLj+fB3JyGHL6NLrcXDhwANLToaxMy93Q1d4tiFInOUGAW64W4LtWmHHdnQY+\nWsv7va+s4t5vv4X8fAgI0JqQ//GqFqU6iU4HRAwgpzSHjMIMfj39KydLTpJbnksbrzbklufSJ7QP\nZ8rOYDUUcKr0FBabBUobPv9JiSEAhPbYg9XyU+2Knm9jcvGlvXsixwqPoa8KwL2gBzdEjAe0kUKr\nqrQcdCcPFs4RGVn7evlySEvTftatg9df13LS4+K0VJiAABg7Frp0Ua3oiqIoinIhzTlqyh8vsF4C\nTzZX+b8V/v7++Pv706lTJ4bUadVtSH5+PidOnODkyZMcPHiQrVu3kp2dzYkTJ3B1dSU2NhaAY8eO\nOf18ZqbW/F5YWEhWVhbl5eXccccdAOz4ZQez5swiKSmJESNGEJYQhhBai2n48+FO95fwVQKFmwqp\nOFRBxeEKjJFGzFlmKjMqKd1TijRrQbMxwghAWeq5gay91E7J90WUfK/lTph6mxDFNmL7eOPdxxuf\nG/0wtmuL3rM22LZLSa7FwgmzGU+9Hj+Dgfc7deKk2cyHOTkgJZlmMzYn9U308tLqYbPxbUUF0mhk\ne3AwnwUH46nT0dnTk3CjkXKbjVGBgdwaGOjoNuvwt79pPSKPHNEi1Lw8yM7Wmoyr6XQQFaW93rNH\n2wYgN1eLTtet05Kur7sODh+Gbt20ZuNx42gXGUk7n3b0DOnJmPgxTs95XUfyj5BZlMmJ4hOk56Wz\nLXsbp0pPcabsDGarmSg/rR5HC46e99kSSyG/Wn7UBik1ZlPYdjfJrQ8AWwGITNrJuM/e5caQmwmq\nugEfXTAnT2ot5V98AceOgYuLFlRXc3bZmc3wS51sm2XLoH9/2LhRS4OxWrUOpmPGQGjoBQ9ZURRF\nUX43hJRNmnLd7K677jqZnNxAz8Tfkfz8fI4cOcKrr75KXl4eeXl5HDhwQEtzqWPSpEm89tprAMyY\nMYPp06cD2pOAu+66i6SkJJKSkigrK6Nz585Onww0REqJpcCCOdOMzk2HR4wHh/58iOKfiynd5bwZ\n16e/D0WbtKDcPVrrhFhxpALPzp7oTXq8+3gT8pcQ3MOdd1CsZrXbyTKb2VZUxM6SEg6Ul1NmszE5\nLIyRgYEkFxfTMyWl0X0AeOn1FCcl1dyQZFRU0M5oRC/qpHRYLHDiBBw6pAXhbm6QlKQt9/TU/n8x\nNm2CDRugdWvtp7ISbrlFG9/wMkgpsdqtuOhdOF58nIO5B3nxhxfJr8gnpzSHInPReZ+Z2Gci84Zo\nI+e8vOllXtr4EgBuejdmDJjBgIgBdG/bnePFxwnzCUOvO/dpxAcfwJo1WifPM2e0fPSTTnp2/PnP\n8MYbWuBdd73RCKNGwejR0K+flo+uKErjhBC7pJTXXe16KIrS9FQg/j+kqqqKtLQ0vv/+e7Zs2cK+\nfft46623uOkmbTi/gQMHsnHjxgY/L4Sge/fu/Otf/6Jfv35XVBdpl5T8UkLBtwXoTXoq0ioo3VOK\nrdRGaYoWpLca04qzn511+nljpJE2Y9vQ5t42eHS69CE9zHY7O4uLmZWZyYHycsptNs5az0+y6eHl\nRfJ12t83q92O248/4iIEvby9eaV9e5J8fRsvqLxcS3XZtQu2btVazw8dguPHz91OCDh9GkJCzg/c\ne/XSxit0tOY3BSkl2cXZ7Dyxk++OfsfOUzs5nHeYRXcsYmSnkQAMWjiIHzJ+OO+z7gZ3qmxVuOpd\nuSnyJqYPmE73tg1PfJuXB/v2wfvvaw8OTpyAhx/WAu327Ruv5+23a/cht90GAwdqgbqiKOf6vQbi\nu3btam0wGN4DOtO8ExAqSnOxA/usVuvDPXr0OONsAxWI/44sX76cKVOmcOzYMWw2Z4kdms2bN5OU\nlISUktWrV+Pp6UlSUhIuLi5XXAdbuY2SlBKKtxej99Jz4q0TlKeWNzBwJcR+HIvOXUfhxkL8hvrh\nGeeJe0TjreUNOV1VRUpJCf/NyWFLcTHHzWamhYcz3REtrszN5fZ9+2q21wOD/fy4PTCQLp6ehLi5\nEeF+kWWfOAE//QTt2mmBeWYmDB4MTvodAFqydv/+MHUqvPIK3HQT3H13s+ZyzN85n2c3PEuZxXle\nfLWN922kf0R/AA7nHUan0xHpF9noZwCKimDVKli8WEtTqag4f5uuXbXRWwBGjIA2bWDoUBgypCb9\nX1F+936vgfiePXtWBgUFxbZq1apYp9NdW8GKogB2u12cPXvWJycnJ7VLly63OdtGBeK/Q1arlT17\n9rBlyxa2bNnC999/T75jtBE/Pz/OnDmDwWBg9+7ddOvWDQA3Nzduv/12lixZUpPG0WT1KbaS+1Uu\nJ98+SenuUuwVjnxsAX1P9+Xg4wfJ/Ty3Znv/of60ua8NgbcHone//CkqzXY7rkLUHM/Ew4d5vX5L\ndj3R7u481LYtky+nJ+LJk7BiBfz4I3z9tZaaUt/bb8MTT2ivhYC1a7X0lWYipeRw/mF+zPyRH7N+\nZFPGJjKLaof58TX6cvavZzHoDBzMO0j3d7tTZimjvW97JvSewIQ+Ey66rOxsWL0asrK0hwepqVBY\nqOWQg5bO8tZb2muDQXtAMGAAzJwJnTs34UEryjXmdxyIH01ISChQQbhyLbPb7WLv3r1+Xbp0cdqC\npQJxBSklaWlpbNiwgfj4eAYPHgzASy+9xMsvv3zOtt26dePxxx9nzJgxlJSUNPkESwAVGRWU7Cyh\nPLWcsOfD2Bq4FVvx+S34Om8dHh09CHsujFajW13xDYJdSnaXlPCfU6dYX1DAMWeBMvB4cDBvd+xI\nqdWKDtAJgfFS56y3WrVxAb/8Etav13I7QkK0VvB5jtlPW7XSOoAOGQIPPKAlZYeFaU3Grq5XdKyN\nySzMZGPGRrZmb2Vo1FBGx2qjBM3ePJvnv3++ZjsPFw/GXzeeJ3o+QYRvBJXWSjxcLj6NqKoKtm+H\nlSu1lvO+feGjj5xve+ed8NRTcMMN2v2Jovye/I4D8YwuXbrkXnhLRflt27NnT2CXLl0inK1TgbjS\noL/85S+8/fbbTtNYjEYjlZWV3HzzzTz88MPceeed6C81GL0Idqudwo2F5H+TT86HOVgLnA+mqHPX\n0e65dkRMjWiyFvusykpW5uby2ZkzbC4uRqAle+3q0YPuJhNzMjN5JTMTC3BPq1b8NSyMOE/PC+y1\nAcePaz0gO3SAb76BpUu1dJZDh87f1sdHi1hHjbr8g7sMN354I5uzNp+3XCDoFdKLfWf2cX/X+3m0\nx6Mktjl/kqYL+fVX7YHBypW16Sp1eXtrDxWWLdMyd9q1O38bRflfpAJxRbm2qUBcuWzl5eWsX7+e\nDz/8kPXr19dMelRXhw4dOOQIGJs6baW+iowKTv/3NDkLc6g8cm5d/G7xo8s6baw9u9mOzq3p+vYU\nWCxkVVaSY7EwxN8fu5R02LGDjDrnw00I/hsby6jAQFx0V1i2zQbDh2ut5c507AgzZsA999QOCN7M\nLDYLGzOieZuiAAAgAElEQVQ2snTfUpYfWO50VBaAdt7tyHg6A524/HOweze89hp89VXN/E+MHw9P\nP60duk6n5Zc/+6w2qZBqJVf+l6lAXFGubY0F4qoXstIoDw8PRo0axVdffcXJkyd5/fXXiYmJAWqD\n7gcffBDQRmV56aWXmDx5MscvkGt9udwj3ImYGkHvQ72JeDkCt1C3mnVB9wcBYCm0sD1iOyn9Ushd\n0zS/w/1cXOhiMjHE3x/QWsvr38SapeSu1FTCt2/nH5mZLDx1iqq6449fCr1eG4/82DGYPv38cf4O\nHoRvv9VeP/64lky9dq02nmAzcdG7cHOHm3nv9vfIezaPr//4NUOjhp633cPdH0YndMzbNo99Z/bx\n0e6PqLQ6T/NpSNeu8N//QnGxNiDNY49pP++9p6232yElRbsP6dVLu1+5xtoUFEW5BqSnp7tGR0fH\n1102adKk4GnTpp0zBcXhw4ddevfu3TEyMjI+KioqfubMma2r15WXl4uEhITYTp06xUVFRcVPnDix\n5hd6SEhIQseOHeNiYmLiOnfuHNtQPY4cOeKyYMECv4bWN5eG6jdmzJgIf3//LvXPTX0zZ85sHR0d\nHR8VFRX/8ssv15yTGTNmtI6KioqPjo6OHzlyZPvy8vLfZHOKs++6qakWceWSSSnZsmULwcHBfPzx\nxzz88MMcP36cPn361Gyj1+t59NFHmTt3Lh4elz784KUoP1JO4aZC2vyxDXp3PRkzM8iYllGz3qe/\nD5GzIvHp59Ok5dqkZG1eHjMzM9lR3WxbT4TRyEvh4YwLCjp3bPJLZbdrQ4+8/76Wv2G1asG4i4uW\nzlI9JOKsWfD8843uqqkdyjvE+ynvM6D9AD7a/RFzb5lLibmEuPlxCAQSSZBXENP7T+eh7g9h0F3+\nPGKrV2uzeVbfg9QVEgJ/+YvWSq5ayJX/JapF/OpJT093vfXWW6MPHTq0v3rZpEmTgr28vGwvv/zy\n6eplmZmZLtnZ2S5JSUnlBQUFum7dusWtWLHicI8ePSrtdjslJSU6Hx8fu9lsFj179uz0z3/+M3vw\n4MFlISEhCcnJyQfatm3b2CTWvPnmmwGpqanGt99++0RzHm99DdXvm2++8TKZTPYHHnigfd1zU9fO\nnTuN9957b4eUlJQDRqPR3r9//47vvvtuppeXlz0pKSkmPT19n5eXlxw+fHjk0KFDi5566qm8ljmq\ni+fsu74cqkVcaVJCCG644QY6dOjASy+9REhICMuXLz9nG5vNxnvvvcfixYuxOhm/uyl5dPAg+MFg\n9O56pJQUbT43ZaJoUxG/JP3C7oG7Ofvl2fNasi+XXghGBAayvUcPMvv04cXwcIIcKSLV2fIZlZX8\nLTMTs812ZeXqdDBoEHzyCZw6pQXjkZGwZcu5TcH/+Q8sWqQF6qWlLdJMHB0QzZyb5zA0aihL/rCE\nUO9Q/r3z3wBIx7iUOaU5TPluCsWVxVdU1ogR2pxIa9dqreF1xx0/cQKeew78/bXOn4qiKC0lPDzc\nkpSUVA7g5+dn79ChQ0VWVpYrgE6nw8fHxw5QVVUlrFaruJQ0znXr1nlNnTq13ddff+0XExMTl5aW\n1vy5iBcwbNiw0latWjX6x33v3r3u3bt3LzWZTHYXFxf69etXsnTpUl8Am80mysrKdBaLhYqKCl1o\naOh5M+MVFxfrBgwYENWpU6e46Ojo+OonAvPnz/dPSEiIjYmJibv33nvDq2OMt956K6Bjx45xnTp1\nihs1alTNLBbTp09vEx0dHR8dHV3TKp+enu4aGRkZf88994RHRUXF9+vXL7q0tFQATJ48OSgiIqJz\n3759Ox46dMitsbo0BRWIK01izpw5fPDBB7Rq1apmmcVi4ZFHHiEhIYGPP/6YKVOmkJvbvI0bQggS\n1yUSPT8aQ4AB6vyuK9xYyP479rOt3TaKU64sIKwvzGhkZvv2ZPbpw7+iorizVSsCDFrL7/SICOYe\nP06flBTW5uWxKjf3yoJyPz9tJhyAP/4R0tOheuKhzEy47z6IjdWGPbzxRm1ElhZ2b8K93BR50znL\nCioLiJ0fyzvJ71BiLuGrtK8u+zwMGQKffgqHD2uZOXX/phUWwv33Ox+3XFEUpbmlp6e7pqamevTv\n379mimmr1UpMTExcmzZtuvTv37940KBBNRM4DB48ODo+Pj527ty5gc72N2TIkNKEhISyzz///HBa\nWlpqTExM1eXWrUePHp1iYmLi6v98+eWXDU6rfaH6NaRr164VO3bsMOXk5OhLSkp0GzZs8MnOznZt\n37695cknn8xp3759YuvWrbuYTCbb6NGjz/uj/Pnnn3sHBQVZ0tPTUw8dOrR/9OjRxSkpKcbly5f7\nJycnp6WlpaXqdDr5zjvvBCQnJxvnzp3bdtOmTQfT09NT33333SyAzZs3eyxevDhg165dB5KTkw8s\nWrSo1datW90BsrKyjE899dSZw4cP7/fx8bEtWrTIb/PmzR5ffPGF/969e1O//vrrw3v27PFsqC6X\nduYbpgJxpUno9XoeeOABsrOzef311/HxqU0DSUtLY9asWcyZM4fY2FiWLl3aZK3SzgghCHkihH5n\n+9ErrZeWO15nQJeqE1X8cv0vWAovcmr6S+Cq0/FUaChL4+M51qcPb0RFcZOfH3Ozs/m5pIRhe/dy\n2759dEtOJr28vGkKDQ6GSZNqg3HQItRt27QW827dtBb0FtS3XV82jNvA+rHr6dy6dhDwM2VneGL1\nE9zw4Q2MWjqK3u/1Zk/OnssuJyREG3p92zZwdF0AtPQUd3etz+uECdpoK4qiXNsmTSJYCHo09NO6\nNYmXsv2kSQQ3VFa1hlquG1peVFSkGz16dIc5c+Zk+/v713QSMhgMpKWlpWZlZf2akpLiuXPnTiPA\n1q1b01JTUw+sX7/+0IIFC1p/8803TqdYPnr0qDExMdEMkJqa6nrXXXeFDx06tGZc6jfffDNg6tSp\nbe65557wwYMHd/j888+dTom2a9eu9LS0tNT6P6NGjXKaX3mx9XOme/fulRMmTMgZNGhQx4EDB0bH\nxcWVGwwGzp49q1+9erXv4cOH9+bk5PxaXl6umz9/vr+Tz1ds3rzZ+4knnghZu3atV0BAgG3t2rWm\nffv2eXTp0iU2JiYmbsuWLd5Hjx51W7dunffIkSMLqlNo2rRpYwPYuHGj1/Dhwwu9vb3tPj4+9hEj\nRhT88MMPJoCQkBBz3759KwC6detWnpGR4fbDDz94DR8+vNBkMtn9/f3tt9xyS2FDdbnY83AhKhBX\nmpSbmxsTJkwgOzubl19+GW/H9IgnTmhpbbm5ubz66qtY6k/z3gyEEHh09CDmwxh6pfXCNaT2aZ7/\nMH9cfK98ptDGmAwG/hIays8lJed12txTVsaNv/yCpZEZTi+a0ajNyJmRoc1+41fviZnNVjtrTgu7\nucPN7H5sNx/d/hGh3rWzhGYUZgCw8+RO7v38XuzyMju1OvTuDQcOaJ02x47VJgcCLZPnjTcgPFxL\nnb/GusQoinKVtWnTxlpUVHTO2Lz5+fn6wMBA6+zZs1tVtyhnZGS4mM1mMWLEiA5jxozJv++++wqd\n7S8wMNCWlJRUsmrVKh+AiIgIC0BISIh1xIgRhdu2bTtvDNycnBy9yWSyubm5SYC4uLiqZcuWZdbd\nZteuXR4zZsw4vWTJkswlS5ZkLFmyxGnqxKW2iF9M/RozceLE3NTU1APJycnp/v7+tujo6MpVq1Z5\nh4WFmYODg61ubm5y1KhRhT/99NN5AX5iYqI5JSUlNSEhoeKFF14IeeaZZ9pKKcWYMWPyqm8gMjIy\n9s2bN++klBIhxHm/4Rtr9HN1da1ZqdfrpdVqFeD8JstZXS7lPDRGBeJKszCZTEydOpWjR4+yePFi\nFi5cSGhoKC4uLkyYMIGePXvyyy+/YLFYmrV1vJpHlAfXZ19P+9ntcQ12JebD2ubTs1+cZffNu7EU\nN8/NwW2BgRzs3Zt7W7c+Z/kZi4Ubdu/mUFO1jPv4wIsvaiOtjB9fu9zVFa6/XnstJbzwgrZNC9Hr\n9NzX9T4O/vkgswfP5g9xf+CR7o9gNBgRCGYNnMXHv37cJNfBzTdro614emr9W2fM0JZbrTB7tjby\nSllZ4/tQFEWp5uPjY2/durXlq6++MgGcPn1av3HjRp9BgwaVTpky5Wx1QBgWFma55557wjt27Fg5\nffr0czr2nTx50pCbm6sHKC0tFRs3bvSOjY2tLC4u1hUUFOhAy0H+4YcfvBMTE89Lqjt48KBbmzZt\nGkxHMZvNwmAwSJ1j2Nznn3++7VNPPXXW2baX0iJ+sfVrzIkTJwwAhw4dcl29erXvQw89lB8REVGV\nkpLiVVJSorPb7Xz//fem2NjY84bWysjIcDGZTPbx48fnP/3006d3797tMXTo0OKvv/7ar3q/p0+f\n1h88eNB16NChxStXrvTPycnRVy8HGDRoUOmaNWt8S0pKdMXFxbo1a9b4DRw40PnoCo7tV69e7Vta\nWioKCgp0GzZs8G2oLpdyHhqjRk1RWkxxcTHr1q1jypQpHDlyBIPBQK9evfDz8+Pdd98lJCSkRerh\nuHMGwFZlY2vAVuyldoSbIPrNaIIfueDTysu2v6yMsamp7K4TDYa6ufFUSAjuOh3jQ0LQNdWQHz/+\nCA89pA2+/eST2rJFi7QccqMRpk3TcjiaYSKmi3Ew7yDfHfuOFakr+O7Yd9wVfxfxreLxdPHk6T5P\no9ddeb1WrdLmPar7QKJDB20+pKSkK969orQINWrK1bVr1y7j+PHjw4qKigwAEyZMyHniiSfy626z\nbt06r6FDh3aKjo6uqA6IZ8yYceLuu+8u2rFjh/v999/f3qZ12he33357/ty5c0+lpqa63nHHHVGg\ndV6888478/7+97/n1C+/qKhIl5SU1KmyslI3f/78jJtvvrkMYOjQoZFr1649+tVXX5mKior0Y8eO\nLXzyySdDhgwZUtxQqsmlaKx+I0eObL99+3ZTQUGBISAgwPrcc8+dnDhxYi5A//79oxYuXJgZERFh\n6dGjR6fCwkKDwWCQr776avbtt99eAjBx4sTgL7/80s9gMBAfH1/+6aefZri7u58TkK5YscJ7ypQp\noTqdDoPBIOfPn5954403li9YsMDvtddea2u323FxcZFvvPFG1uDBg8vefPPNgDfeeCNIp9PJzp07\nl69YsSIDtM6an3zySSDAuHHjzk6bNu1M/dFwpk2b1qa0tFQ/b968k5MnTw5aunRpYEhIiDk4ONgS\nGxtb0aVLlwpndbnYc6km9FF+MzZt2sTw4cMpr9cKbDKZWLZsGUOHnj8udXM6+OeDnPz3uQnEre9p\nTcd3O2Lwvvxh9hpjk5JXs7KYlpGBVUpejYzkhWPHsEjJAF9fPuzUiQh396YprKIC3Ny0UVcqK7Uc\njTNntHW+vrB///ljlLegd5Lf4YnVT5y3vF+7fiwctZAO/h2uuIwjR7RJf1JSzl0eF6cNg9i2yR4w\nKkrzUIG4UldOTo5+0qRJIZs3b/YeO3ZsblFRkX727Nmn3nzzzcBPP/00oEuXLmVdu3atePbZZ522\niistTw1fqPxm9O/fn927d58z5jhASUkJO3bswH65E+Bcpsi/R+I//Nw+ImeWnCGlbwoVR5tn2A29\nEEwJD+fn7t15ISyMPaWlWBw3xFuKivjibBP+7nR314Jw0FrB+/atXVdaCt9/33RlXYZxieN4pPsj\n5y3fdnwbhZVOUywvWYcOkJwMCxeCd53uS6mpEBYGixc3STGKoigtIigoyLZ48eKs7OzsfbNnz84p\nLS3V+/j42F988cUz+/fvP7B48eIsFYRfO1QgrrS46OhoNm/ezCuvvIK+TlrE9OnTa1rLzWZzi9TF\n4GkgcXUiid8m4j+sNiAv31/Oz/E/c3rZFY3h36huJhN/i4zk/ZgYpoSFoQM6ursz6ehR7j9wgPKm\n6MhZl5TQs6c2CRBoidPjxmkdPZcsgaVLm7a8i+Dp6sl/Rv6HFXetwNetdtQXu7Tz5JonOZJ/pEnK\nEQL+9CdtJMeoqNrlVutVfSCgKIpyxRYtWpR1teugXD4ViCtXhcFgYMqUKSQnJxMXF1ezvHXr1iQn\nJxMVFcW2bdtarD7+g/1JXJNIzH9jEG5ajraslKT9KY3iHU075nh9bjodr0RG8rf27Ul1pOwsPH2a\nvikpjNq7l+KmGvFECG3okD17tLyMan/7mzbUyD33wF//elVGWBkdO5q94/cyMGJgzbIdJ3bw7LfP\nkno2lZGfjiSv/MonXWvXTht2/dFHtdMxbhwMGHDFu1UURVGUy6ICceWq6tq1KykpKfz1r3/llltu\nYfLkydxxxx0cP36cgQMHsrSFW2mDxgYR90ltkCrNkvSH05G25u9L8URwMP+vzsgqe8rK+Covj94p\nKRyvPK9D+eWLjYWffoK6+fjVre9z58L27U1X1iUI9Q5lw7gNzBk8B4POQKBHIFNvmMqwT4bx9cGv\n6ftBX44WHL3icnQ6ePddbaj1BQtql2/dqo1F3pSZQYqiKIrSGBWIK1edm5sbr776KmvWrKG0tJTq\nHudms7lFW8WrtbqzFXHL4tD76tF764lbFofQC4q2FWHJa77xz31dXPg4Lo436uZOAGnl5byS1cRP\nHn18tCFFnnrq3OXPP39VhxPR6/RMTprMtoe28emdn7L/7H6yi7IBbZSVRXsWNVlZkZFaP1bQRnMc\nNEhrLY+M1MYkVxRFUZTmpgJx5TdDr9fTu3dvtm/fTrt27dDpdLz99tt89tlnLV6X1mNac13ydXT+\nsjOesZ6Up5fz67Bf+Tn+Z4p3Nm+qyl9CQ1kWF1d3MlA+zslhU2HTdF6sYTDAv/4F//43BAXBP/+p\nTQhULT8fvvuuacu8SNcFX8dNkTfx/xL/H8vGLMNN74aniycVlopmGXf+xRehyjFKb2mplq7imINK\nURRFUZqNCsSV35yIiAiMRiN2u52qqiruvvtuZs2axX333Ud+fv6Fd9BE3Du44zfQD7vFzr5R+7AV\n2bCctpDSJ4XTS5uvEyfAmNat2dClCx6OpwNSCEx6PeU2W9OOqgLa5D+HDmnjjVePsLJlCyQkwLBh\nsGZN05Z3iW6KvIl2Pu0os5Tx6k+v8uiqRymuLGbZ/mVNVsbHH8Po0bXvz5zR5kDav7/JilAURVGU\n86hAXPnN0ev1rF+/nk6dOgHaBDwvvvgiixYtok+fPmQ1dZrGBehcdLSb3K52gR0O/PEABRsLmrXc\ngX5+/NS9O+FubnweH08XLy/GHjjA6P37efHo0aZtGfaqM7twbi4MGQInT4LFokWoP/3UdGVdIje9\nG7GBsTXv3/vlPWL+HcPdy+9m8obJ2OWVD3kpBKxYoWXmVA/kk52tjfb4979f8e4VRVEUxSkViCu/\nSREREWzdupXrq6dmdzh06BATJ05s8fq0vb8tEdMjahdI2H/Hfkr3lDZruV28vEjv3Zub/f15/fhx\nvsjV5raYlZXFc0evvOOiU7NnQ90Jl0JCoEuX5inrIri7uLPirhWMSxxXs+xU6SkAXv3pVSatm9Rk\nZc2apT0AqL4vKS6G556DBx5osiIURVEUpYYKxJXfrICAAL777jtGjRp1znK9Xt8secIXEvFSBB1e\n74DepDWZWgut7LllD+UHL3qW28vi5kgXebRtW4b6+dUsz6mqap7zMHs23H577fujR+HTT5u+nEvg\nonfho1Ef8XTvp89Z7qZ3Y2zC2CYt65ZbYPNmMJlql330EXzySZMWoyiKoigqEFd+29zd3Vm+fDnj\nx4+vWWa1Wqly9Kxr6YC83YR2dN3UFb2PFoxbzlj49dZfsVc1/4ygJoOBof61kw4tOn2afx0/3vQF\nubpqE/zUHWD7sce03I1p0+AqjGQDoBM65g2Zx8yBtR1KzTYzz333XJOX1bWrNpxhq1ba+5AQLWVe\nURRFUZqSCsSV3zy9Xs9bb73Fo48+yoQJE/jss89wdXVl1qxZjBs3Dru9+YPgukzdTCSuSUQYBTp3\nHZWHKkm7L61Fxhp/MiSEMdXRITDpyBGeO3KENXlXPtnNOYxG+Oor6N5de2+3w113aaOqDB0KO3c2\nbXkXSQjBize+yPzh8xEI4lrF8Z+R/wFgeepylqcub7KyEhLg4EG4+27t3iMxEQoKtNR5RVF+P/R6\nfY+YmJi46Ojo+GHDhkWWlJRcVOx0+PBhl969e3eMjIyMj4qKip85c2bNRBHl5eUiISEhtlOnTnFR\nUVHxEydOrJnjd+bMma2jo6Pjo6Ki4l9++eXWzvcOR44ccVmwYIFfQ+ubS0hISELHjh3jYmJi4jp3\n7hwLjR9rXQ1t19j5+K2ZNGlS8LRp09o01f4MTbUjRWlOQgjefvttdDoddrudCRMm8OabbwLQqlUr\n5s2bhxCixerj09eH4EeDOfGGNsbdmSVnMPU20e7pdhf45JUx6HQsionhhNnMT8XFSODv2dn868QJ\nfuzalZ7e3k1XmLc3fPMN3HCDFpFW3/AUF2uzcKalgYtL05V3CZ7o+QQRvhH0bdcXH6MPb+x4g6fX\nPo2r3pXWnq25MfzGJinH11d7OACQmakNIlNZqd2jqBZyRfl9cHNzs6elpaUC3Hbbbe1fe+21VtOn\nT7/g0FkuLi689tprx5OSksoLCgp03bp1ixs+fHhxjx49Ko1Go9yyZUu6j4+P3Ww2i549e3b67rvv\niry9vW2LFi1qlZKScsBoNNr79+/f8Y477ihKSEgw19//mjVrvFNTU41A844c4MSmTZsOtm3btmYa\n5saOte7nGtquW7dulc7Ox+DBg8ta+thammoRV64Z1RP9CCGwWGon1nnnnXc4duxYi9cn6vUogp/U\nbtoDbg3Ap68Pe0ftxVrSvFPEG/V6vurcmUijsWZZpd3OsF9/pbipp6dv3Ro2bIDQUOjYEfz9tZ/l\ny69aEF5tWPQwfIw+lFvKmb9zPhKJ2WbmjqV3UFjZtGOuV1bCjTdqE/0cOwZ9+kBOTpMWoSjKNSAp\nKan08OHDbunp6a7R0dHx1cunTZvWZtKkSee04oaHh1uSkpLKAfz8/OwdOnSoyMrKcgXt75mPj48d\noKqqSlitViGEYO/eve7du3cvNZlMdhcXF/r161eydOlS3/r1WLdundfUqVPbff31134xMTFxaWlp\nrs175I1r7FgvZruGzkd9xcXFugEDBkR16tQpLjo6Or76icD8+fP9ExISYmNiYuLuvffecKvjb+Fb\nb70V0LFjx7hOnTrFjRo1qn31fqZPn94mOjo6Pjo6uuapQ3p6umtkZGT8PffcEx4VFRXfr1+/6NLS\nUgEwefLkoIiIiM59+/bteOjQIbfG6nKpVIu4cs0RQnD99dfzzjvvAODh4YFer7/Ap5qnHtFvROOV\n4IVHvAe/DvkVa6GVfaP2kbA6Ab2x+eoU6OrK2sREeu3aRaFjenpPvR6v5jgPYWHw/fdawvSxY9r4\nfomJTV/OZfJw8eCt4W8x9OOh2KSN8T3H42s87+/WFTEaYdIkbah10AaVSUzU0lQM6reoovwuWCwW\n1q1b533LLbdc8qxu6enprqmpqR79+/evGWrLarXSuXPnuKysLLf77rvvzKBBg8pSUlJsL7/8ckhO\nTo7e09NTbtiwwadLly7ntQoPGTKkNCEhoWzevHnZPXv2rKy//lL06NGjU1lZ2Xl/PObMmZM9atSo\nEmefGTx4cLQQggceeODsM888k3uhY3Wm/nbOzkf9z3z++efeQUFBlo0bNx4GyMvL06ekpBiXL1/u\nn5ycnObm5ibHjh0b9s477wT06dOnbO7cuW23bduW1rZtW+vp06f1AJs3b/ZYvHhxwK5duw5IKenR\no0fs4MGDSwIDA21ZWVnGjz/++Gjfvn0zhw8fHrlo0SK/hISEyi+++MJ/7969qRaLha5du8Z169at\n3FldLvac16VaxJVrUs+ePfHx8QEgPz+fYcOGUVBQQGXlFf0+umRCJwh+LJiyfWVYC7U78MLvC/ml\n3y/N3pE02sODVQkJGACTTsfHsbHomis9Jzpay9Po1k2LQLOy4LbbYP16eOSR2rSVq2TOljnYpHZD\n8uaON0nLTWvyMiZM0NLkq509q/VdVRSlZUyaRLAQ9BCCHvHxxNZd17o1idXr5s4lsHr54sX4VC8X\ngh51P7N5Mx4XU67ZbNbFxMTEJSQkxIWGhlZNmDAh98KfqlVUVKQbPXp0hzlz5mT7+/vX/LI0GAyk\npaWlZmVl/ZqSkuK5c+dOY/fu3SsnTJiQM2jQoI4DBw6MjouLKzc0cLd/9OhRY2JiohkgNTXV9a67\n7gofOnRoZPX6N998M2Dq1Klt7rnnnvDBgwd3+Pzzz53mLu7atSs9LS0ttf5PQ0H41q1b01JTUw+s\nX7/+0IIFC1p/8803NRNRNHSsF3NOnJ2P+p/r3r17xebNm72feOKJkLVr13oFBATY1q5da9q3b59H\nly5dYmNiYuK2bNniffToUbd169Z5jxw5sqA6haZNmzY2gI0bN3oNHz680Nvb2+7j42MfMWJEwQ8/\n/GACCAkJMfft27cCoFu3buUZGRluP/zwg9fw4cMLTSaT3d/f337LLbcUNlSXho63MSoQV65JsbGx\nrFy5EldX7cnXgQMHGDRoEJGRkWzdurXF6xPyeAgRMyNq3pemlHLk2SPNXm6Sry8rOncm+brruMFX\nawXOqKhg/MGDWJorOD5wAPr1g1WrtI6b772nDcB9FS0ctZBgk/ZUuMhcxK2LbyX5RDKPrHyEKltV\nk5WzZIk2yU+12bPB8WBGUZT/UdU54mlpaakLFy7MNhqN0mAwyLoDBVRWVuoAZs+e3SomJiYuJiYm\nLiMjw8VsNosRI0Z0GDNmTP59993nNGcuMDDQlpSUVLJq1SofgIkTJ+ampqYeSE5OTvf397dFR0ef\n18KUk5OjN5lMNjc3NwkQFxdXtWzZssy62+zatctjxowZp5csWZK5ZMmSjCVLljhNnejRo0en6jrX\n/RtXLDYAACAASURBVPnyyy9NzraPiIiwAISEhFhHjBhRuG3bNk+AiznWi9mu/vmoKzEx0ZySkpKa\nkJBQ8cILL4Q888wzbaWUYsyYMXnV31FGRsa+efPmnZRSIoQ4r0WssUYyV1fXmpV6vV5arVYBOO2D\n5qwuDe64ESoQV65ZN954Ix999FHN+927d3Pq1CnGjBlDbu4lNVg0idCnQ3EJrM2bPj73OMU7L/kJ\n5iW7LTCQjh5aw84vJSVc/8svvH3yJI8fPNg8Baan1w4dUv0L7aWXICWlecq7CCHeIaz64yo8XLTz\ncKTgCH0/6Mt7v7zHg1892GRPJ4SATZtgxIjaZePHw//9X5PsXlGUa0RoaKg1Pz/fkJOTo6+oqBDr\n1q3zAZgyZcrZ/8/enYc1ca1/AP9OFkD2fTEKCAkJCYuCWwE3uCqCu9IirrW37a3+6oJeva51aatt\nldpq6eJtq7RFbN2rVEqtWOxVi1CpGokgIgiyCQJhD5nfH0MAFRA0Q9Sez/PkcWaSzHsmKpycec97\nNB1CR0fHxvDwcCc3N7e6Byd3FhQU8EpLS7kAoFQqqaSkJFN3d/c6AMjPz+cBQGZmpt6JEyfMX3nl\nlbIH41+/fl3fzs6uw1GG+vp6isfj0Zq5VatXr3ZYtGhRSXuv7c6IeGVlJae8vJyj2T59+rSpl5dX\nrVqtRkfX2lZHr+vs82grJyeHb2Jiol6wYEHZkiVLii5dumQYHBxcefz4cQvN51ZUVMS9fv26XnBw\ncOWxY8csCwsLuZrjABAYGKiMj483r6qq4lRWVnLi4+MtRo0a1e7ov+b1J06cMFcqlVR5eTknMTHR\nvKO2dHSOzpCOOPFMmzFjBrZu3XrfsTt37uDzzz/v8bbwjHnof6b/ff+rrkVcY33yZlsHS0pQ2Fxj\n/avCQvxQXKz9IJMnA+++e/+xf/2LSVvRIR8HH3w75duW/UY1M6H3u8vf4etLX2stDo8H7N8PDBzY\nuv/hh8Bvv2ktBEEQ7YiKQgFNI5WmkXr1Kq61fa64GH9pnlu+HC0jMRERqNAcp2mktn3PsGF47NXY\n9PX16WXLlt0ZPHiwe1BQkFAoFD7UaUxMTDQ+cuSI1dmzZ000o8z79+83A4C8vDz+sGHDxG5ubtIB\nAwZIR40aVTljxowKAJg4caKrq6urbPz48cIdO3bk2tjYPJTy4O3tXVdWVsYXiUSyxMREowefP3ny\npPHw4cOVarUab7zxhiA0NLRCM0nySdy+fZs3dOhQiVgslvr4+LiPGTPm3vTp0ys7u1YAGDFihDAn\nJ4ff0es6+zzaSk1N7dW/f393iUQife+99xzWr19/x9fXt27t2rX5QUFBbm5ubtLAwEC3vLw8/sCB\nA+uWLVt2Z9iwYRKxWCxdsGBBXwAICAioiYiIuOvj4+Pu6+vrPnv27BJ/f//ajq45ICCgZsqUKWUe\nHh6y8ePHuw4ePFjZUVse5zOldLFC4ZMYOHAgffHiRV03g3iK0DSNhQsX4tNPPwUAiMViXLlyBR3l\n1bGtKK4Iin8qoK5mblv2WdYHwm3CHom9QKHAp3eYnwUcAP/z8cEQbZY01FCrmSUoT51i9gUCID0d\nsLLSfqxueu/se/ct8uPXxw8JsxNgrGfcybu6r6iI6Yxr1lRycmI+ArOHbqYSxJOhKCqVpumBum5H\nT0tPT8/x9vbu+dubz6DCwkJuZGSkIDk52XTWrFmlFRUV3C1bttzZuXOn9b59+6y8vb2r+/fvX7ti\nxYp2R8UJdqWnp1t7e3s7t/cc6YgTzwWVSoVJkybhhRdewOrVq1tKHepKUWwRrs28BpuXbND71d7Q\n76MPQ/Fj3bXqlkqVCi+kpUFewwx8+Bgb47yPD/hsfB4FBYC3N6BJA5o0Cfj6a+DYMWDuXO3H6yKa\npvHy0ZexN30vhJZCJM1NgsBUwEqs/Hymnnh5OVNjfM8epuIjQWgT6YgT3TVnzhzHmJiYXF23g2B0\n1hEnqSnEc4HH4+H48eNYu3ZtSye8vLwcq1atQn39Q+sgsM4uwg7ev3rDuL8x/gr+C1dfuoqmusea\nUN0tpjwevpfJoN88sSRNqcTbt24hpZKFXPXevZmep8bRo0yt8XnzgEOHtB+viyiKwufjP8dbI97C\npdcvtXTCm9RNSL6VrNVYAgHwxRdAdDSwfTuTtUPGCQiC0DXSCX92kI448dxoO6v5t99+g1gsxtat\nW7F69WqdtEe/jz5yNuSAVtGoTq/G9deuo6mW/c64zMgIb/drWbcAm2/dgt+ff+LPqg7nojy+0FBg\n0SJm28amdXT85ZeBrCztx+sifZ4+NozcACM9JnXyZvlNjNwzEiP3jsS5vHNajTV9OmBnB/j4AOfO\nAbNmAXfvajUEQRAE8ZwiHXHiuVNTU4O1a9eipIRJhYuKisIvv/zS4+0wFBlCGMXkhlM8CsX7i5G1\npGc6p0v79kVAc7IyDUBF05h57Rpqm1j4IvDee8CnnwJyOeDszBwbMeKpyBfXmHtkLs7mnYWaVmP2\n4dlQNnS6zkS39e/furCPQsF0yp+xrD+CIAhCB0hHnHjuVFdXIyOjdUEXgUCAATqq6NH7jd6wCbMB\nraJBN9C488UdFH/PQiWTB3ApCnskEvRqc5egtqkJdxq0V1O7hYEBUzXF2ho4cIDpmH/3HWDxWKv9\nal3s5Vj8nttaW57P5aNI2WF1rcfi4sLUFNfIzW29UUAQBEEQHSEdceK5Y2Njg//+978t+/n5+UhM\nTNRJWyiKgnS/FDYv2rQcy/hnBmquP3EVqUdy7dULUUIhPI2M8LKdHa4OHgyXXr3YDerryzzEYuDw\nYeYYGykx3TDSeSRMDVorx4xyHgVXS1etx1m4kOmQa3z6KVNZhSAIgiA6QjrixHNp4sSJmD9/fsv+\nggULcPv2bcjl8h5vC0VREH8hhoELs1qvukqNSyMvQd3I/rLwr/fujfSBA/GVuzsMudyW46xVS4qL\nA0aPBu7cYfLEp05l8jTqHiqx22N6m/TGjrE7WvY/vfgpzuScAQCoae39HVAU8OuvgOZjbmoClizR\n2ukJgiCI5xDpiBPPrQ8//BDOzTnL5eXl8PHxga+vr0464zwzHhxXObbsN9xpQPaqbNbjUhR13yTW\nO/X1mHT5MiKuXWOnMz52LNC3L7NdUcGMimdlAe+/r/1Y3TDHew5CRCEt+/OPzseKxBWY9v00rX4O\nTk7A3r2t+3FxwA8/aO30BEEQxHOGdMSJ55apqSn27NnT0hEtKSlBXV0dZs6cCZWq51a71HB42aFl\nVBwA8j/OR0MxCznbHfi+qAiO58/j2N27iCsuRgwbeRMWFkx++IN1yz/7DKjtcOEy1lEUhS/GfwEz\nfWYCa/a9bHzwvw9wJOMI/pv230e8u3tmzgQ0N2NmzmQW/Dl/XqshCIIgiOcE6YgTz7URI0YgMjLy\nvmN5eXn3TebsKRSXgsdRD6A5dYFupFHwWUGPxd9fUgJVm9HfNzMzUdbYqP1AAQHAf1pXtoSBAZCc\nDLCdn/4IAlMBPhz74UPH1/y6BjWN2s3Z37GDWduovByIjARmzwaqq7UagiAIgngOkI448dx7++23\nMW3aNCxatAhLly5FZmYmPDw8dNIWYw9jeBzyAN+aD7fdbnBa49RjsT91c4O1psYeAH9TU1jy+ewE\nW72aWe0GYPLDd+9mJ043zes/D+OE4wAAFgYWGGA/AL+9/BsM+dpd9dTEBBg5kvn+ATDZOe++q9UQ\nBEEQxHOAdMSJ556BgQEOHDiAjz76CFFRUbDQcVk964nWGHJzCHr/szeaappQllDWI3Ft9fTwhVjc\nsn+yvBwJZSzFNjJiyhhqfPgh0xs9eFCnQ8MUReGLCV/g1zm/4tK/LuHCPy9AYi1hJZazMzMyDjAl\n1X/4AVBqt3w5QRAsUygUeiKRSNb2WGRkZO/169fbtT2WlZXFHzJkiJuLi4tMKBTKNm/ebKt5rqam\nhvL09HQXi8VSoVAoW7p0aW/NcwKBwNPNzU0qkUikHh4e7h2148aNG/zdu3f36C+vzq4pLCzM2dLS\n0vvBz+ZB7b0uPT1dXyKRSDUPY2PjAZs2bbLt7Dy60t7ftbaRjjjxt6NSqbBnzx58/fXXyMzM1Ekb\nuIZcFO4txB9uf+DypMtQpvdMD22KjQ1m2bX+TFlx4wZu1NayM3EzIgJ44QVATw+YOxd49VVmGcp3\n3tF+rG7oY9oHo/qNgqOZI/jc1jsC1+9eR5NauwsezZsHeHszK21mZgLbt2v19ARBPCX4fD62b99+\nOzs7+2pKSsq1L7/80jY1NdUAAAwMDOizZ88qFAqF/OrVq/JTp06Znjp1ykjz3jNnzlzPyMiQX7ly\n5VpH54+PjzdNS0vT7q27R+jsmubPn1967NixR/4Cbe913t7e9RkZGfLma5YbGBiow8PD77F1HU87\n0hEn/lYSExMhFovx8ssvY/78+fj3v/+ts7bkf5KPhsIG0PU0UoemQlXZMxNIP3BxgVHzZMq/qqsh\nvnABhzRL02sTRQH//S+z4ubQoUBSEnN82zZABzn67VGpVdj+v+3o91E/uH/ijm/++kar5+dw7l/Y\n54MPmMqOBEE8X5ycnBoDAgJqAMDCwkLt6upam5ubqwcAHA4HZmZmagBoaGigVCoV1baa1aMkJCQY\nr1u3ru/x48ctJBKJNCMjQ4+Vi3hAZ9c0btw4pY2NzSN/aT3qdceOHTN1dHSsd3Nze6hyQWVlJWfk\nyJFCsVgsFYlEMs0dgejoaEtPT093iUQijYiIcNIUX9i1a5eVm5ubVCwWSydPntxPc54NGzbYiUQi\nmUgkkmlG3hUKhZ6Li4ssPDzcSSgUyvz9/UVKpZICgJUrV9o7Ozt7+Pn5uWVmZup31hZtYLUjTlFU\nMEVRCoqisiiK+k87zztSFHWaoqg/KYr6i6KokPbOQxDakpGRgezs1rKBR48exa+//trj7aA4FIQf\nCVv26ToaORtyeiS2vb4+lmlKDAJoArDyxg00qFmoay6VAq6uzNDwCy8wxxwcgJIS7cfqpiZ1EwZ+\nMRDLE5cj514O1LSalYmbc+cCnp7MdnU14O8PsFXGnSAI3VMoFHpyudxwxIgRLbc6VSoVJBKJ1M7O\nznvEiBGVgYGBLTl6QUFBIplM5r5t2zbr9s43duxYpaenZ/WhQ4eyMjIy5BKJ5LHLbfn6+orbpoVo\nHkeOHDHp7jVpw759+yynT59+t73nDh06ZGpvb9+oUCjkmZmZV6dOnVqZlpZmcODAAcuLFy9mZGRk\nyDkcDv3ZZ59ZXbx40WDbtm0OZ86cua5QKOSff/55LgAkJycbxsbGWqWmpl67ePHitZiYGJvff/+9\nFwDk5uYaLFq0qDgrK+uqmZlZU0xMjEVycrLh4cOHLS9fviw/fvx4Vnp6ulFHbdHWZ8B79EseD0VR\nXACfABgN4DaAFIqijtE03baI81oA39M0/SlFUVIA8QCc2WoTQbz++uv4+OOPkZWVBQAwNzdHd0Ym\ntMnsBTNYTbbC3SPMz6D8Xfno/XpvGIrZv/u4vG9fHCgpwc26OtSq1cirr8f5ykoMNzdnJyCHwyRM\nr1gBvPQSMGwYO3G6gcvh4h8u/0B6UXrLsbLaMly4fQGj+o3SXhwuk40zcSKzf/MmEB3NrMRJEETX\nRSZE9v7w/IcOHT1vY2jTWPzv4r+6+vqlQ5feiRob1Wnpqo5+P3R0vKKigjN16lTXrVu35llaWraM\nbvB4PGRkZMhLS0u5oaGhrikpKQaDBg2q+/333zOcnZ0b8/PzeYGBgW4ymaxu3LhxD3V2s7OzDby8\nvOoBQC6X623YsMGhsrKSe/LkyWwA2Llzp1VxcTEvMzPToKSkhLdw4cKS9jqLqampis6utzvX9KTq\n6uqoX375xSwqKup2e8/7+PjUrlmzpu8bb7whmDRpUkVwcLDy888/t7xy5Yqht7e3e/M5OLa2tqqK\nigruhAkTyh0cHFQAYGdn1wQASUlJxiEhIfdMTU3VABAaGlp++vRpk7CwsHsCgaDez8+vFgAGDBhQ\nk5OTo19aWsoLCQm5Z2JiogaAMWPG3OuoLdr6HNgcER8MIIum6WyaphsAxAGY9MBraACatafNAPRc\nLTfib0lPTw9bt25t2a+urm5Z9EcXPA55wNSf+S9AN9LIXJzJ3qqXbZjweLgyaBDe6dcPL9rYIGPw\nYPY64QCTihIeDpw5A6xbB7A1SbSbVgWsgqm+acv+5lGbtdoJ15gwoXWdI4Cp7tik3XR0giBYYGdn\np6qoqOC2PVZWVsa1trZWbdmyxUYzopyTk8Ovr6+nQkNDXcPCwsrmzp3bbs6ztbV1U0BAQNWPP/5o\nBgDOzs6NACAQCFShoaH3zp07Z/TgewoLC7kmJiZN+vr6NABIpdKG77///lbb16Smphpu3LixKC4u\n7lZcXFxOXFxcu6kT3R0R78o1Pa4DBw6YSaXSmr59+7abuuLl5VWflpYm9/T0rF2zZo1g+fLlDjRN\nU2FhYXc1OeY5OTlXoqKiCmiaBkVRD/3y7Oz3qZ6eXsuTXC6XVqlUFND+l6z22vI419weNjviAgB5\nbfZvNx9rawOAWRRF3QYzGv4mi+0hCADA1KlT8UJzmkRjYyNWr16ts7ZQFAXRThHQ/P++PKEcRd+x\nsNBOB7GX9OmD/TIZ+vXqhXI2aoprtP2yc/cu8NZbTCWV9evZi9kFVoZW+Ldf6zyBjy58hDpVHSux\n2q64qVQCp0+zEoYgCC0yMzNT29raNh49etQEAIqKirhJSUlmgYGBylWrVpVoOoSOjo6N4eHhTm5u\nbnUbNmy474d4QUEBr7S0lAsASqWSSkpKMnV3d6+rrKzklJeXcwAmB/n06dOmXl5eD618dv36dX07\nO7sO01Hq6+spHo9Hc5rn/qxevdph0aJF7eb/paamKjRtbvuYPHly1YOvVavV6OiatCEuLs7yxRdf\n7HBUJicnh29iYqJesGBB2ZIlS4ouXbpkGBwcXHn8+HGL/Px8HsD8fVy/fl0vODi48tixY5aFhYVc\nzXEACAwMVMbHx5tXVVVxKisrOfHx8RajRo166Fo1AgMDlSdOnDBXKpVUeXk5JzEx0byjtmjrc2At\nNQUtXYv7PPjVZAaAPTRNb6co6gUA31AU5UHT9H23PiiKeg3AawDg6OgIgngSFEVh27Zt8Pf3BwDE\nxcXBysoKdnZ2WLduXY+3x2SACcyGm6HiTAUAIHNBJmym24BrwH3EO58cRVEorK/Hxlu38E1hIb6S\nSDDQxAQu2l58x8CAmaQ5bRqzv2sX8yeXC4SFtSZR68CSoUuw84+dKK4uxu3K24hOiYa3nTcEpgKt\nljYcNQqYMgU4fBgwNmZW3CQIouuixkYVPCqV5Ele35G9e/feXLBggePKlSv7AsDKlSsLZDJZfdvX\nJCYmGh85csRKJBLVSiQSKQBs3Lgx/6WXXqrIy8vjz5s3r19TUxNomqYmTZpUNmPGjAq5XK43ZcoU\nIQA0NTVR06ZNuzt9+vSH0km8vb3rysrK+CKRSBYdHZ0zevTo+2rAnjx50nj48OFKtVqNhQsXCkJD\nQys0kyyfRGfXNGHChH7nz583KS8v59nZ2Xn95z//KVi6dGkpAIwYMUK4d+/eW87Ozo0dva6qqopz\n9uxZ0717997qKH5qamqvVatW9eFwOODxeHR0dPQtX1/furVr1+YHBQW5qdVq8Pl8+uOPP84NCgqq\nXrZs2Z1hw4ZJOBwO7eHhUXPw4MGcgICAmoiIiLs+Pj7uADB79uwSf3//WoVC0e6E14CAgJopU6aU\neXh4yAQCQf3gwYOVHbXlST9fDYqt2+DNHesNNE2Pbd5fBQA0TW9p85qrAIJpms5r3s8GMJSm6eKO\nzjtw4ED64sWLrLSZ+HuZNm0aDh061LKvp6eHa9euwcXFpcfbUhhbiIyZrZVEei/sDbddbj0S+x+X\nLuHUvdY7jlOtrXGQjQWPaBoIDGytntIScCpTX1yHdv2xC2/+xNyQ43P4aFQ3YpxwHOJnxms1Tn4+\nsHUrsHYtYGcHVFUxi/8QRGcoikqlaXqgrtvR09LT03O8vb1ZKOn0bCssLORGRkYKkpOTTWfNmlVa\nUVHB3bJly52dO3da79u3z8rb27u6f//+tStWrND9rHgCAJCenm7t7e3t3N5zbKampAAQURTVj6Io\nPQDhAI498JpcAEEAQFGUOwADAOQfDtEjtm7dCiMjIzg4MKleDQ0NWLlypU7aYjfDDoZS5k4X35YP\n60ntTp5nxVsP5MgfKi1F8j0WSrpSFDNhk9Pmx45QyFRU0bHXfF+Ds7kzAKBRzaTo/JT1ExJvJGo1\njkAA7NzJlFZftozJGycj4wRBdIe9vX1TbGxsbl5e3pUtW7YUKpVKrpmZmXrt2rXFV69evRYbG5tL\nOuHPDtY64jRNqwD8H4AEANfAVEe5SlHUJoqimusHYBmAVymKSgewD8A8uidmqhEEAJFIhPz8/JZR\n8YCAAJ11xCmKguygDC7vu8Dvjh8sR1v2WOxh5uaYaGXVss+nKBQ1PHZ1rM55ezML+7Q1diw7sbpB\nj6uHrUFb8R///2CW5ywAgK2RLaoaOkwlfCIvvghERQEVFQ9/HARBEN0RExOTq+s2EI+PtdQUtpDU\nFIIN58+fx5AhQ0DTNDicv986V/LqanikpLRM4vjZywujLVn6MlBSAohETC/U0hL46Sdg8GB2Yj2G\ngqoCfHbxM/zb798w0Wcnb+SXX4DRo1v3//pLp2nyxFOOpKYQxLNNV6kpBPHMGDBgAKKiouDh4QGl\nUtkjJQQ7U5lSiUtBl3DjPzd6JJ7UyAivOLRWY1qZnQ01W5+BjQ1TMWXHDiA3l1nwZ+3a+5eg1KHe\nJr2xadQmNNFNKFKyU8Fm5EhmwqbGZ5+xEoYgCIJ4ypERcYIAMHz4cCQnJwMAhg4dCj09PSQlJelk\nsZ/c93KR/Z/m1T+5gH+JP/gWfNbjFtTXQ3jhAmqbV9h8o3dvDDQxwXwHrZVLfdjt24BEwiw5yeUC\n168DOpgs21ZNYw12/bELW89uRYgoBEH9glDTWIOFg7W7As+RI0wVFYC59CtXmI+CIB5ERsQJ4tlG\nRsQJ4hHmz5/fsn3+/Hn89ttvOHXqlE7aYvOSTetOE3BjZc+MivfW10dknz4AAEMOB58WFGDNzZuo\nV2ttIbWH9ekDDBnCbDc1AVu2dP76HnCp8BJW/rIS5XXl+O7yd5h/bD7W/LoGVfXazRefNIkpIgMw\nl758OVNYhiAIgvj7IB1xggAwe/ZseHl53Xfs/fff10lbejn3gmlA62qPpQdL0VTTM8swrnB0xLfu\n7jDnMUsMFDY0ILaIxQWG7twBbG2ZbT8/YMEC9mJ1kV9fP4x3G3/fsYr6Cnz555dajUNRwAcftO6f\nOAHs36/VEARBEMRTjnTECQIAl8vFxo0bW/b19PTwzjvv6Kw90n1S6PVl1htQlalw5793eiSuKY+H\nmXZ2WNQ8Mu5qYABjLosLC33wARAXx2zzeMCAAezF6oZ3At8B1WZNMmczZ/Qx7aP1OD4+zE0BjVWr\ntB6CIAiCeIqRjjhBNJswYQKEQiEApqb4hQsXdNYWgz4GcFrp1LKf90Ee1A0spog84HUHBxyQyXDM\n0xPOBgbsBVq6lOmAA8BvvwHnzzPbOs7R8LLzwkyvmS37TuZOmC6dzkqsDRtat3NygMxMVsIQBEEQ\nTyHSESeIZlwuF0uWLGnZ37FjB5qXJNZJe+zn24Nnw3RS62/X4/ZHPbfyS2ljI76+cweylBS8yWbP\nsG9fICKidX/tWmDOHEBH9dzb2jRyE3gc5vM/c+sM/rzzJytx5s8HLCyYKiqrVwP29qyEIQiCIJ5C\npCNOEG3MmzcPFhYWAIDi4mKEhIQgMjJSJ23h9uLCwLF1NPrWu7dAq3vmS4EJj4fE8nIAwIWqKizP\nysJfSiU7wVasaN0+dQr45htg1y6guJideF3Uz6IfwqRhLfsf/O8DfHjuQ5y/fV6rcSgKSEkBSkuB\nd94hS94TBEH8nZCOOEG0YWRkhA0bNiAyMhJVVVX4+eef8cUXX+Du3bs6aY/T2tb0FHWNGo2ljT0S\n105PDzPt7Fr2t9++jfdyWVq8TSYDJky4/1htLVNrXMcWD1kMALA0sMThjMOI/DkSW85qv7KLqyug\nr89s0zSQn6/1EARBPCYul+srkUikIpFINm7cOJeqqqou9Z2ysrL4Q4YMcXNxcZEJhULZ5s2bbTXP\n1dTUUJ6enu5isVgqFAplS5cu7a15bvPmzbYikUgmFAplmzZtsm3/7MCNGzf4u3fvtniyq+uejq6p\ns2ttj0qlgru7u3TUqFFCzTGBQODp5uYmlUgkUg8PD3e2r+VxRUZG9l6/fr3do1/ZNaQjThAPWLRo\nEbZt29ZSRaWmpgbR0dE6aYv1JGsYeRmhl1svuEW7gWfG67HYS/vcPzlxf3Excuvq2An2YCrKP/8J\nvPkmO7G6YUifIYiPiEfSvCTUqZhrP6Y4BkWpQuuxmpqAH34ABg1qLa1OEITu6evrqzMyMuSZmZlX\n+Xw+vX37dptHvwvg8/nYvn377ezs7KspKSnXvvzyS9vU1FQDADAwMKDPnj2rUCgU8qtXr8pPnTpl\neurUKaOUlBSDmJgYm7S0tGvXrl27evLkSfPLly/rt3f++Ph407S0NENtXuvjXlNn19qet99+204o\nFNY+ePzMmTPXMzIy5FeuXLnG7pU8PUhHnCDaQVEUVqxYAQsLC6xevRqvv/66ztrhFe+FwfLBcHjF\nARz9nvsv62lsjH9YtA622OvpoUKlYieYvz/zAAAnJ2DePKB3707f0lPGicbB086zpaThP1z+gfqm\neq3HoWnglVeA1FRAqQTWrNF6CIIgnlBAQIAyKytLX6FQ6IlEIpnm+Pr16+0iIyPv+6Hl5OTUGBAQ\nUAMAFhYWaldX19rc3Fw9AOBwODAzM1MDQENDA6VSqSiKonD58uVePj4+ShMTEzWfz4e/v3/Vj2C8\nyQAAIABJREFU/v37zR9sR0JCgvG6dev6Hj9+3EIikUgzMjL02L3yzq+ps2t90I0bN/gJCQlmr776\narcXa6qsrOSMHDlSKBaLpSKRSKa5IxAdHW3p6enpLpFIpBEREU6q5t9Vu3btsnJzc5OKxWLp5MmT\n+2nOs2HDBjuRSCQTiUQtdx0UCoWei4uLLDw83EkoFMr8/f1FSqWSAoCVK1faOzs7e/j5+bllZmbq\nd9aW7uq54TWCeMb4+/tj7ty5+OKLL3TWEQcAfQEzGELTNMoTy1GWUAbhduEj3qUdS/v0wS/NueJV\nTU1wYrOCyrvvMnXFp01rraQCMEPFbJZQ7KItQVuw/IXlsDK0goeth9bPz+MBXl7A778z+zExwI4d\nWg9DEMRjamxsREJCgumYMWMqu/tehUKhJ5fLDUeMGNEy2UalUsHDw0Oam5urP3fu3OLAwMDqtLS0\npk2bNgkKCwu5RkZGdGJiopm3t/dD98fGjh2r9PT0rI6KisobNGjQE92q9PX1FVdXVz/0Q3br1q15\nkydP7nAls/auqbPjGgsXLuz7/vvv366oqHgoZlBQkIiiKLz88ssly5cvf6ijfujQIVN7e/vGpKSk\nLAC4e/cuNy0tzeDAgQOWFy9ezNDX16dnzZrl+Nlnn1kNHTq0etu2bQ7nzp3LcHBwUBUVFXEBIDk5\n2TA2NtYqNTX1Gk3T8PX1dQ8KCqqytrZuys3NNfj222+z/fz8boWEhLjExMRYeHp61h0+fNjy8uXL\n8sbGRvTv3186YMCAmvba8qjPuj2kI04QHXjttdeQmJgIAPj444/xQfPqK7pY9l6tUuNPvz9RlcL8\nTLSaYAWLkeynBgZbWkLcqxcUtbWobGrCV3fuYEnfvuwEGz68dZummYmbmzcDY8bofHi4oKoAH1/4\nGN/+9S1ktjL88c8/WPl3sGtXayn18nJALgekUq2HIYhnUmRCZO8Pz3/oAABSG2nN1QVXW9IXbD+w\n9SqpKeEDwAejP7i13I/pxMVejjWbeWhmy8gF/RadqtlOvpVsOMxpWM2j4tbX13MkEokUAIYMGVK1\nePHi0lu3bvG72u6KigrO1KlTXbdu3ZpnaWnZUoeWx+MhIyNDXlpayg0NDXVNSUkxGDRoUN3ixYsL\nAwMD3QwNDdVSqbSGx2u/q5adnW3g5eVVDwByuVxvw4YNDpWVldyTJ09mA8DOnTutiouLeZmZmQYl\nJSW8hQsXlkydOvWhLxGpqandzrXr6Jo6Oq6xb98+M2tra9WwYcNqjh8/ft/U9N9//z3D2dm5MT8/\nnxcYGOgmk8nqxo0bd19n3sfHp3bNmjV933jjDcGkSZMqgoODlZ9//rnllStXDL29vd0BoK6ujmNr\na6uqqKjgTpgwodzBwUEFAHZ2dk0AkJSUZBwSEnLP1NRUDQChoaHlp0+fNgkLC7snEAjq/fz8agFg\nwIABNTk5OfqlpaW8kJCQeyYmJmoAGDNmzL2O2tLdzxEgqSkE0aHFixe3bEdHR2Pw4ME4cOCATtpC\ncSnUZrWm02UtzuqRuByKwtLmjvdYCws4GhhgU04OGthc9h4AfvwRGD2aqS0eHQ2wlRLTRXwOHzHp\nMahV1eJiwUUczjiMVb+sQm3jQymOT6R/f2Dy5Nb9qCitnp4giMegyRHPyMiQ7927N8/AwIDm8Xi0\nus3Pwbq6Og4AbNmyxUYikUglEok0JyeHX19fT4WGhrqGhYWVzZ07915757e2tm4KCAio+vHHH80A\nYOnSpaVyufzaxYsXFZaWlk0ikeihEe/CwkKuiYlJk76+Pg0AUqm04fvvv7/V9jWpqamGGzduLIqL\ni7sVFxeXExcX1+7oja+vr1jT5raPI0eOtFvDqaNr6sq1nj171jgxMdFcIBB4zps3z+X8+fMmkyZN\n6gcAzs7OjQAgEAhUoaGh986dO2f04Pu9vLzq09LS5J6enrVr1qwRLF++3IGmaSosLOyu5u8oJyfn\nSlRUVAFN06Ao6qFSY52VJNbT02t5ksvl0iqVigLaH4Brry0dnrgTpCNOEB0YN24cxGIxAKC2thYX\nL17Ee++9p5O64hRFweGfrf/Hq/+qRtWlDu8YatVsOztcGTQI3sbGCJfL8VZODvazWVowIwM4eLB1\nv6AAOH6cvXhdYGNkg5merQv8TP9+Orb+vhUx6TFaj7VsWet2TAwzKk4QxNOlT58+qrKyMl5hYSG3\ntraWSkhIMAOAVatWlWg6hI6Ojo3h4eFObm5udRs2bChq+/6CggJeaWkpFwCUSiWVlJRk6u7uXgcA\n+fn5PADIzMzUO3HihPkrr7xS9mD869ev69vZ2TV01L76+nqKx+PRHA7TzVu9erXDokWLStp7bWpq\nqkLT5raP9tJS1Go12rumjo4/6JNPPskvKir6Kz8///KePXuyhw4dWnX06NGblZWVnPLycg7A5F6f\nPn3a1MvL66GRjpycHL6JiYl6wYIFZUuWLCm6dOmSYXBwcOXx48ctNJ9bUVER9/r163rBwcGVx44d\nsywsLORqjgNAYGCgMj4+3ryqqopTWVnJiY+Ptxg1alSHv1ADAwOVJ06cMFcqlVR5eTknMTHRvKO2\ndHSOzpDUFILoAIfDwdKlS/Gvf/2r5VhqaiqSkpIwatSoHm+P0zon3N5xG3Qj80Ugb3sepN+wn7dg\nyOVCZmQEMx4Pjc1fQrbl5WGWnR07aToJCUwPFGASpzdvbp3IqUOLhizCV5e+AgDQYD6HqPNReNX3\nVXAo7Y1p+PsDvr7MpM3GRiAsDLh6VWunJ4hnVtTYqIKosVEF7T1X/O/iv9o7HuEZURHhGZHa3nNd\nSUvpiL6+Pr1s2bI7gwcPdu/Tp0+9UCh8aNQ6MTHR+MiRI1YikahWk9qycePG/JdeeqkiLy+PP2/e\nvH7Ni8ZRkyZNKpsxY0YFAEycONH13r17PB6PR+/YsSPXxsam6cFze3t715WVlfFFIpEsOjo6Z/To\n0fflkZ88edJ4+PDhSrVajYULFwpCQ0MrNJMpn0RH12Rubt7U0bUCwIgRI4R79+69pRn1ftDt27d5\nU6ZMEQJAU1MTNW3atLvTp09vL42m16pVq/pwOBzweDw6Ojr6lq+vb93atWvzg4KC3NRqNfh8Pv3x\nxx/nBgUFVS9btuzOsGHDJBwOh/bw8Kg5ePBgTkBAQE1ERMRdHx8fdwCYPXt2ib+/f61CoWh3cmlA\nQEDNlClTyjw8PGQCgaB+8ODByo7a8jifKaWrVQMf18CBA+mLFy/quhnE30RtbS369u3bUkf89ddf\nx44dO2DA5qTFTtz96S4uh1wGAFD6FPwK/MC37HKq4hMpa2yE47lzqFOrMc7SErFSKUw6yF18ItXV\ngKMjUNY8CBQbC8yYof04j2HknpE4c+sMAIBLcTHHew52BO+Aqb6pVuO8//79FR3lcsD9qa2qS7CN\noqhUmqYH6rodPS09PT3H29u725U1/o4KCwu5kZGRguTkZNNZs2aVVlRUcLds2XJn586d1vv27bPy\n9vau7t+/f+2KFSvaHRUn2JWenm7t7e3t3N5zJDWFIDrRq1cvLFiwoGX/0qVL0Ndvt6Rrj7AaZwWT\ngUzaHl1Po+i7Du8Aal1GTQ3s9fTQBMCYx2OnEw4ARkbA//1f6/5TVDpEs8APAJjqm+KTkE+03gkH\ngMhIoO13PR1NTSAI4hlhb2/fFBsbm5uXl3dly5YthUqlkmtmZqZeu3Zt8dWrV6/Fxsbmkk7404l0\nxAniERYsWAA9PeaOVWFhIUpKdPuzrG2u+K13bvVYznovDgc3mhf0+aG4GHlsLe4DMB1xfvNI/x9/\nAJs2AaGhTK6GDk0UT4SzuTMAoLyuHLGXY1mJw+MBX3zBzFc9eRJYu5aVMARBPKdiYmJYWgqZ0DbS\nESeIR7C3t8fmzZvxww8/4Pz589i3bx9eeOEFVFX1zGTJB/Vy69Wyra5Tg27omY74ABMTjDAzAwA0\nAVh78yY+Y2stdhub+8uHvPUWEB+v80mbXA4X/zeIGa33tPWEtaE1Lty+gI/Of6T1WLNnAz//DIwd\nC+igYiZBEATRA0hHnCC6YMWKFZg+fTpCQkKwZMkSnD9/Hj/88INO2mI+whz6Tkx6TFNFE0qP9FwK\nZWSbGuIxRUVYnJWFMrZGqefPf/jY55+zE6sbXvF5Bb/O+RXnXjmHD/73AYZ+ORTLfl6G25W3WYuZ\nnQ1s28asbUQQBEE8P0hHnCC6YebM1hJ2X331lU7aQHEoZrl7Aw7sZtuhl7jXo9+kJeOtrCDs1Rqv\ngaYRx1Ypw9GjgbaLB/n4ALNmsROrG8wNzDGq3ygY6RlBj8ukLDXRTfgm/Rutx6JpYNw4wNUV+Pe/\nAR39kyMIgiBYQjriBNFFNE3D1dUVHA6nZRKnrqoOCd4U4IU7L0C8W4za67UoS3iozCwrOBSFxQJB\n6z6ACrYW2+FymcV8UlKAmzeZen5PQUe8rVcGvAIAMNc3Z+X8FAVktVm76cMPWQlDEARB6AjpiBNE\nF6nVavzf//0f1Go1amtrYWRkpJPl7gGAb86H8pIS/xP8D/KX5MjZkNNjsefZ28O4eZEINYCR5ux0\nQgEA48cDAwcCzs7sxXhMaXfSEHuFmaw523s2Vg1bxUqcN99s3b52DWiupEkQBEE8B0hHnCC6iMvl\nYs6cOS37e/fu1WFrACOZEVQVzGh05flKVKX3zORRYx4PL9nawoDDwQxbWxhzuT0SFwAzMv7OO8yi\nPzpWpCxCfGY8AGBv+l4oG5SsxHnjjdYCMgBAllEgCIJ4fpCOOEF0w9y5c1u2f/zxRyxbtgynT5/W\nSVv0bPTuW8wn562cHou9qV8/FPr5IVYqhczICL/duweVWs1OsMZGppB2//6AiwtTy2/7dnZidcNY\n4Vi4WbkBACrrK3FQfhA/3/gZtY0Prcr8RPh8YOHC1n3NoqMEQRDEs490xAmiG8RiMYYMGQIAUKlU\niIqKwieffKKz9pgNM2vZLosvg7qepc7wA3rr68OMx8Mn+fkQXbiAEZcu4WQZS3nqKhXw6qtAenrr\nscRE4MYNduJ1EYfi4OX+L7fsv378dYz9diyOZBzReqw23/9w6BBQUaH1EARBEIQOkI44QXRT21Fx\nADh27BhKS3WzCrPzRueWbbqRRvEhliqYdCCvrg7ZzQv77CksZCdIr15ARETrPkUBU6fqfHEfAJjp\nORMUmHkC9U31AIA96Xu0Hqd/f8DLi9muq3vq5qwSBEEQj4l0xAmim1566aWWlTYBIDg4GNXV1Tpp\ni7HMGHZz7Vr2C79kqTPcDjVNo6JNYes/qqrQwFZ6yiuvtG7r6QFffglIJOzE6oa+Zn0x0nnkfcey\nyrK0np4CAEOHtm6fO0dqihNET1AoFHoikUjW9lhkZGTv9evX27U9lpWVxR8yZIibi4uLTCgUyjZv\n3myrea6mpoby9PR0F4vFUqFQKFu6dGlvzXMCgcDTzc1NKpFIpB4eHu4dtePGjRv83bt3W2jz2rri\nUe1LT0/Xl0gkUs3D2Nh4wKZNm2zbvkalUsHd3V06atQoYc+1vHva+zvtKaQjThDdZGlpiYkTJ7bs\nDx48GE5OTjprT7/N/Vr+J987dQ+12drvBLaHQ1G4rGydoLikTx/ocVj6keLjwwwLA0B9PbBvHztx\nHsMsr9bhaVcLV2S+mYlefO3Xdn/7bcDamtm+exf45RethyAI4jHx+Xxs3779dnZ29tWUlJRrX375\npW1qaqoBABgYGNBnz55VKBQK+dWrV+WnTp0yPXXqlJHmvWfOnLmekZEhv3LlyrWOzh8fH2+alpZm\n2BPX8qDO2uft7V2fkZEhb35ebmBgoA4PD7/X9jVvv/22nVAo7JlfTM8g0hEniMfw2muv4ZVXXsFv\nv/2GNWvW6LQtBn0NYBlsCX5vPmxetEFdbl2PxZ5rb9+y/V1REbvB2o6Kf/klcOUKsHMnuzG7YLp0\nOgx4BgAAO2M71qqn2NgAc+YATk7AunWAVMpKGIIgHoOTk1NjQEBADQBYWFioXV1da3Nzc/UAgMPh\nwMzMTA0ADQ0NlEqlorpT+jYhIcF43bp1fY8fP24hkUikGRkZeo9+V887duyYqaOjY72bm1uD5tiN\nGzf4CQkJZq+++mq7+ZuVlZWckSNHCsVisVQkEsnajvpHR0dbenp6ukskEmlERISTqnnNil27dlm5\nublJxWKxdPLkyf0AYMOGDXYikUgmEolkmhF5hUKh5+LiIgsPD3cSCoUyf39/kVKpbPngV65cae/s\n7Ozh5+fnlpmZqf+o9rCFx3YAgngejR49GqNHjwbALPRz4cIF3Lx5E+Hh4Tppj02YDZR/KlHyfQm4\nhlxYjOyZO5hhNjZ4MzMT9TSNNKUSf1ZWol+vXjBvW29PWyIigOXLmRHx1FTA05M5Pm4cINTdHU9T\nfVN8M+UbDLAfAFdLVwBAbWMtlA1K2BjZaDXWpk3ABx8AHA4glwNqNbNNEMTTQ6FQ6MnlcsMRI0a0\nfCtXqVTw8PCQ5ubm6s+dO7c4MDCwJZ8xKChIRFEUXn755ZLly5c/1GEdO3as0tPTszoqKipv0KBB\nTzTS4uvrK66urn6o5uzWrVvzJk+e3G4N3Ee1T2Pfvn2W06dPv2+lg4ULF/Z9//33b1dUVLRb5/bQ\noUOm9vb2jUlJSVkAcPfuXS4ApKWlGRw4cMDy4sWLGfr6+vSsWbMcP/vsM6uhQ4dWb9u2zeHcuXMZ\nDg4OqqKiIm5ycrJhbGysVWpq6jWapuHr6+seFBRUZW1t3ZSbm2vw7bffZvv5+d0KCQlxiYmJsViw\nYEFZcnKy4eHDhy0vX74sb2xsRP/+/aUDBgyo6ag9bCI/wgniCRQUFMDDwwNDhw7FG2+8gbq6nhuN\nbsvI3QgNd5hBiOLvi6GqZGm1yweY8/mYrMmXAOB/6RI23brFTjBLS2DKlIeP797NTrxumC6dDldL\nVyhKFXj9x9dhv90ea39dq/U4RkbAt98CgwYBMhmQlKT1EATx9IqM7A2K8u3wYWvr1a3XR0b27iBS\ni45Grjs6XlFRwZk6darr1q1b8ywtLVsmzfB4PGRkZMhzc3P/SktLM0pJSTEAgN9//z1DLpdf+/nn\nnzN3795t+9NPPxm3d97s7GwDLy+vegCQy+V6L774olNwcLCL5vmdO3darVu3zi48PNwpKCjI9dCh\nQ6btnSc1NVWhSSVp++ioE97V9tXV1VG//PKL2ezZs8s1x/bt22dmbW2tGjZsWE27HxYAHx+f2uTk\nZNM33nhDcPLkSWMrK6smADh58qTJlStXDL29vd0lEon07NmzptnZ2foJCQmmEyZMKHdwcFABgJ2d\nXVNSUpJxSEjIPVNTU7WZmZk6NDS0/PTp0yYAIBAI6v38/GoBYMCAATU5OTn6AHD69GnjkJCQeyYm\nJmpLS0v1mDFj7nXWHjaRjjhBPAErKyuUNZftu3fvHo4c0X7puq4wGWwCIw8m5VDPQQ+FMT03aXNO\nm/SUWrUa3xYVoZGtSZsLFwKrVgGff87sm5gwkzefEiU1Jfgi7QtU1ldi/9X9rEzavHixdVGftvXF\nCYLQPjs7O9WDo7llZWVca2tr1ZYtW2w0kxRzcnL49fX1VGhoqGtYWFjZ3Llz77V3Pmtr66aAgICq\nH3/80QwAnJ2dGwFAIBCoQkND7507d87owfcUFhZyTUxMmvT19WkAkEqlDd9///19Ix6pqamGGzdu\nLIqLi7sVFxeXExcX1+5tUV9fX3HbyZWax5EjR0zae31X2gcABw4cMJNKpTV9+/ZtGQU6e/ascWJi\norlAIPCcN2+ey/nz500mTZrUr+37vLy86tPS0uSenp61a9asESxfvtwBAGiapsLCwu5qvijk5ORc\niYqKKqBpGhRF0W3PQdP37d5HT0+v5Ukul0urVKqWb1DtfZnqqD1sIh1xgngCEyZMQGFz2T5jY2NU\nVlbqpB0URaHf+/1gEWyB+vx6ZC3JQv2d+h6JPcbCAra81iy3ksZG/Hqv3d9BTy4gAHj3XSZffO9e\n4M4dYPNmdmJ1U0VdBa4UXWnJF6+or8Cpm6e0HmfGjNbtjAwmS4cgCHaYmZmpbW1tG48ePWoCAEVF\nRdykpCSzwMBA5apVq0o0HUVHR8fG8PBwJzc3t7oNGzbcN2GmoKCAV1paygUApVJJJSUlmbq7u9dV\nVlZyysvLOQCTm3z69GlTLy+vh769X79+Xd/Ozq7hweMa9fX1FI/HoznNeWqrV692WLRoUUl7r+3O\niHhX2wcAcXFxli+++OJ9i0l88skn+UVFRX/l5+df3rNnT/bQoUOrjh49erPta3JycvgmJibqBQsW\nlC1ZsqTo0qVLhgAQHBxcefz4cYv8/HwewHzu169f1wsODq48duyYZWFhIVdzPDAwUBkfH29eVVXF\nqays5MTHx1uMGjWq06WmAwMDlSdOnDBXKpVUeXk5JzEx0byz9rCJ5IgTxBMICQlBYmIiAMDLywuv\nvfaaztpiPc4aee/lga5jBgAK9xbC6T/sV3PhcTiYZW+PqNu3oUdRWNG3L8ZYsJyjzuUyMxefItfv\nXscb8W8AAPgcPpLnJ2OIYIjW4wwdCpiaAprvfOvXAydOaD0MQTx9oqIKEBVVwNrrO7B3796bCxYs\ncFy5cmVfAFi5cmWBTCa7b6QjMTHR+MiRI1YikahWIpFIAWDjxo35L730UkVeXh5/3rx5/ZqamkDT\nNDVp0qSyGTNmVMjlcr0pU6YIAaCpqYmaNm3a3enTpz80muPt7V1XVlbGF4lEsujo6JzRo0ffVy/3\n5MmTxsOHD1eq1WosXLhQEBoaWqGZOPokbt++zeuofSNGjBDu3bv3lrOzc2NVVRXn7Nmzpnv37u12\nXmJqamqvVatW9eFwOODxeHR0dPQtAPD19a1bu3ZtflBQkJtarQafz6c//vjj3KCgoOply5bdGTZs\nmITD4dAeHh41Bw8ezImIiLjr4+PjDgCzZ88u8ff3r1UoFB3eLg0ICKiZMmVKmYeHh0wgENQPHjxY\n2Vl72ER1NqT/NBo4cCB9UXNfliB0rLi4GAKBAJrZ3FlZWXB1ddVZewq/LUTG7AwAgJ5ADy/kvdBh\nLqM2Xa+pQbpSiQlWVjDgsj63BaiqAuLigK+/BmJjgeJiwNsb0NdnP3YHaJqG+yfuUNxVAABip8Zi\nhueMR7zr8cyfz1w6AIjFzMg48fyiKCqVpumBum5HT0tPT8/x9vbWzWppT7HCwkJuZGSkIDk52XTW\nrFmlFRUV3C1bttzZuXOn9b59+6y8vb2r+/fvX7tixYp2R8WJnpeenm7t7e3t3N5zj+yIUxQV2c7h\nCgCpNE1fevLmdQ/piBNPm4kTJ+LHH38EAKxduxYBAQEYPXo0ODooZ1FfVI/zjudBNzD/r/uf7Q9z\nf/MebwfALPjDYetLwMSJQPNnDnNz4N49Zn/8eHbiddHbv72NdafXAQDGCcchfmY8VGoVeBzt3nzM\nywOcnZmqKQCQlQXo8PsfwTLSESc6M2fOHMeYmJhcXbeD6FhnHfGu9BQGAvgXAEHz4zUAIwHspihq\nhZbaSBDPrLZL3m/ZsgXBwcE4c+aMTtqiZ6MHit/a+c3bntej8ZtoGollZYiQy+H/55+dTqJ5IjNn\ntm5r8tHj4tiJ1Q1tF/dJyErA+Njx8PncR+ufQ9++TNVGjZgYrZ6eIIhnCOmEP9u60hG3AuBD0/Qy\nmqaXgemY2wAYDmAei20jiGfC+PHjYdGcE93UvO7415q8gR5GcShYjrVs2b936h57neF2nK2oQMjl\ny9hXXIzzlZW4pGRncRtMngw8mIf+v/+1DhHriLO5M4Y5DgMAqKHGicwTuFx8GRfyL2g9lub7H4/H\nlDFka34sQRAEwZ6udMQdAbSdrdsIwImm6VoAPVOWgSCeYvr6+pgx4/5c4HPnzkGto06h4ypHcAyY\n/9pNlU2oSul08rhWvZ+bC1Wbjv/XhSyVUdTXv7+m+LRpgELxVKxu03ZUXOPrP7X/xWzCBGDMGICi\ngN9+A77/XushCIIgCJZ15bdWLIDzFEW9RVHUWwB+B7CPoigjAHJWW0cQz4g5c+bAxsYGfn5+2Lt3\nLxQKhU5yxAHAdKApbMNtAQC93Hqhsayxx2K3rSluweNhsUDAXrCwsNbtixeZoeGnQJg0DHrc1sn6\nK/xWYO1w7S/uY2AAhIYCjc1/vTq6CUMQBEE8gUf+5qJpejNFUT8B8AdAAfgXTdOa2ZIzO34nQfx9\nDB48GPn5+eCzsbT7Y+i7si/6RPaBkYcRaFXPpaZMtLKCKYeDSrUa5SoVihobwdocwsDA1omat24x\nBbX79wdoGtDh34NFLwtEDo2EtaE1wj3CITBl78tIRASwfDmgUgHGxoBSyfxJEARBPBu6OmT3J4Af\nABwCUExRlCN7TSKIZw9FUQ91whsbG1vKGva0XsJeUF5S4srkKzjvfB7qxp5Jk+nF5eIlO7uW/b1s\npaYAzIqakya17r/2GiAQAIcOsRezi7b8YwuW+S1jtRMOANbWwEcfAcuWMd9Fjh1jNRxBEAShZY/s\niFMU9SaAIgCJAI4DONH8J0EQ7UhISEBgYCBsbGxw8uRJnbSB4lK4ueYm7h67i4aCBpT/Ut5jsee0\n6Yh/U1iIWXI5VGzly7/4IjBoEDB6NPDnn0w98acsWfpuzV3subQH076fhprGJ15j4+Hz3wW2bQMy\nM4HDh7V+eoIgCIJFXRkRXwxATNO0jKZpL5qmPWma9mK7YQTxLNqwYQPGjx+P06dPo6KiAgcOHNBJ\nOyiKgvUU65Z9+Qx5j1VP8TczQ7/mhXVqaRrfFRfjt4oKdoKFhAB//AF8/HHrsfj41mUndexO1R14\nfuqJl4++jEPXDuHnGz9rPcbUqa3bJ04A+flaD0EQBEGwpCsd8TwwC/gQBPEIZmZm96WjHD16FA0N\nDZ28gz0202yA5kUumyqaUHWxZ6qnUBSFF21t7zt2sITlBd4kEqaw9uLFwK+/PhWJ0lcEr0LVAAAg\nAElEQVSLr6LPh31wR3mn5diha9pPm3F3B3r3ZrZra4F167QegiAIgmBJVzri2QCSKIpaRVFUpObB\ndsMI4lk0pU1JPQ6HgyNHjuhsAqf5cHPYzWpNEyn5oedWO37R1hYhlkw98wHGxvAwMmI/6FdfAT4+\nwNChT0UZQ6mNFM7mzi37Yisx/Pv6az0ORTFzVDWOk8RBgiCIZ0ZXflvlgskP1wNg0uZBEMQDnJ2d\n4ePjAwBQq9UoKCgAxdYy711gG9Y6Ml3yQ0mPpaf4mJjgmKcnsocMQdrAgXiDzTKGNM0U1e7dm1nl\n5soV9mJ1A0VRmOnZWljKt7cvXh/4Oiuxlixp3S4pYVLlCYLQDi6X6yuRSKQikUg2btw4l6qqqi59\n08/KyuIPGTLEzcXFRSYUCmWbN29u+YFcU1NDeXp6uovFYqlQKJQtXbq0t+a5zZs324pEIplQKJRt\n2rTJtv2zAzdu3ODv3r3boqPn2VJaWsoNDg526devn8zFxUX2yy+/tDvSEhYW5mxpaektEolkXTn+\ntImMjOy9fv16u0e/8sk88h8TTdMb23uw3TCCeFZNbZO0e0jHFTwsRluAY8L8N6/LqUPlhZ7LneZS\nFPr16sV+IIpiUlE0XzLefReYMwfYv5/92I8wzX1ay/aJ6yfQ0MROmtI//gGYmrbup6ezEoYg/pb0\n9fXVGRkZ8szMzKt8Pp/evn27TVfex+fzsX379tvZ2dlXU1JSrn355Ze2qampBgBgYGBAnz17VqFQ\nKORXr16Vnzp1yvTUqVNGKSkpBjExMTZpaWnXrl27dvXkyZPmly9f1m/v/PHx8aZpaWmG2rzWrnjt\ntdf6jhkzpvLmzZtX5XK5vH///nXtvW7+/Pmlx44dy+zq8b+rDjviFEXtaP7zR4qijj346LkmEsSz\npW16yo8//ojp06fj7NmzOmkLxaeAptb92x/e7tH4KrUav5aXY0lmJr4rLGRvRH769NbtuDjgm2+A\nPXvYidUNXnZeLekpFfUVOHztMHan7kaTuqnzN3YTRQHz57fuPwUVHAniuRQQEKDMysrSVygUem1H\ndNevX28XGRnZu+1rnZycGgMCAmoAwMLCQu3q6lqbm5urBzCpi2ZmZmoAaGhooFQqFUVRFC5fvtzL\nx8dHaWJioubz+fD396/av3+/+YPtSEhIMF63bl3f48ePW0gkEmlGRobeg69hQ1lZGefChQsmS5Ys\nKQWYLxTW1tbt/kAbN26c0sbG5qEavh0d16isrOSMHDlSKBaLpSKRSNZ21D86OtrS09PTXSKRSCMi\nIpw0c7J27dpl5ebmJhWLxdLJkyf3A4ANGzbYiUQimUgkarmzoFAo9FxcXGTh4eFOQqFQ5u/vL1Iq\nlS23rVeuXGnv7Ozs4efn55aZman/qPZoQ2cL+nzT/Oe2xz05RVHBAD4CM2XsvzRNb23nNS8C2ACA\nBpBO03TE48YjiKeBu7s7xGIxFAoF6uvrcfDgQdjb2yMgIKDH20JRFMwDzVF2vAwAUPZTGWia7pF0\nGZqmIUtJwfXa2pZj7kZG8DFhIbNt3DjA0BCoaVMe8JdfmNp+Vlbaj9dFFEVhsngydlzYAQAIPxgO\nABBbizHcabhWY4WFATdvMlVUxo9nbhDoMCuKIJ47jY2NSEhIMB0zZky3by0qFAo9uVxuOGLECKXm\nmEqlgoeHhzQ3N1d/7ty5xYGBgdVpaWlNmzZtEhQWFnKNjIzoxMREM29v7+oHzzd27Filp6dndVRU\nVN6gQYPaHZHuKl9fX3F1dTX3weNbt27Nmzx58n2z/DMyMvQtLS1VYWFhznK53NDLy6t69+7deaam\nplqrUXvo0CFTe3v7xqSkpCwAuHv3LhcA0tLSDA4cOGB58eLFDH19fXrWrFmOn332mdXQoUOrt23b\n5nDu3LkMBwcHVVFRETc5OdkwNjbWKjU19RpN0/D19XUPCgqqsra2bsrNzTX49ttvs/38/G6FhIS4\nxMTEWCxYsKAsOTnZ8PDhw5aXL1+WNzY2on///tIBAwbUdNQebelwRJym6dTmP8+093jUiSmK4gL4\nBMA4AFIAMyiKkj7wGhGAVQD8aZqWAVjy0IkI4hlDUdR96SkAk6KiZquW9iP0WdynZbupqgnVfz30\nM50VFEXhhbb5EgAOsVU9xdCQKWWoYWkJrFwJ6Ogzb2uyZPJDx9ionuLnB2zfDty+DYwZA8TEaD0E\nQehWZGRvUJQvKMoXMpn7fc/Z2nq1PLdtW2vt1thYs5bjFOV733uSk7uU1lFfX8+RSCRST09PaZ8+\nfRoWL15c2p1mV1RUcKZOneq6devWPEtLy5YfSjweDxkZGfLc3Ny/0tLSjFJSUgx8fHzqFi9eXBgY\nGOg2atQokVQqreHx2h8zzc7ONvDy8qoHALlcrvfiiy86BQcHu2ie37lzp9W6devswsPDnf6fvTOP\ni6re///rMwsgMizDLooIDAzDJuJSgpqQipBreVOzrNvvdlO7lujN65pm92pl1jfLSrOb3K5LV9Fc\nCEUDU7MSSFJ2RAQRkB2GZWBmPr8/hoFBWcaaM2P6eT4e58HnrO/352Rn3ud93ktkZKRXfHy8dU/X\nSUtLy83Jycm6c7nTCAcApVJJsrOzLZcsWVKZnZ2dZWlpqV63bp3LvdyP/hgxYkTLuXPnrBctWuSW\nmJhoZW9vrwKAxMRE0dWrVy2Dg4P9pFKp7Pz589aFhYXmJ0+etJ42bVqtq6urEgCcnZ1VKSkpVtHR\n0XXW1tZqGxsbdUxMTG1ycrIIANzc3BRjx45tAYCQkJDmoqIicwBITk62io6OrhOJRGqxWKyePHly\nXV/6GAp9GvqEEUKSCCF5hJBCQsh1QkihHtceDaCAUlpIKW0DsB/AjDuO+QuAjymltQBAKWUpRowH\ngpdffhk///wzHB0dERwcjEWLFkGhUJhEF7uJdhgcOxgeGzwwKnMUrIKNV9pvlmP3UMpiLu+BbnjK\noEHAW28BjnqFcnJKmHsYnAc6I8hZ036BT/ioaanhRNahQ8CaNUBaGgtPYTAMhTZGPCcnJ2vPnj0l\nFhYWVCAQUF3nSmtrKw8ANm/e7CiVSmVSqVRWVFQkVCgUJCYmxmvOnDk1CxcurOvp+g4ODqrw8PDG\nY8eO2QDAsmXLqrKysrJTU1NzxWKxSiKR3OXxLi8v54tEIpW5uTkFAJlM1vb111/f0D0mLS3NcuPG\njRX79++/sX///qL9+/f3GFIRGhrqq9VZdzly5Mhdny89PDzanJ2d2yIiIpoA4Omnn67NyMgwaJx6\nUFCQIj09PSswMLBlzZo1bitWrHAFAEopmTNnTrX2v0VRUdHVbdu23er4ytst7rGvMEgzM7POnXw+\nnyqVys5vhz19Le5NH0OhT+bvbgDbAIQDGAVgZMff/nCDpga5lpsd23TxAeBDCLlACPmxI5TlLggh\nLxFCUgkhqZVc1yNmMAyAu7s7Ro0ahZycHFy+fBnr1q3DAGMkLvYA4RN4v+cNjzc8MFBmhDKCOky2\ns8MAnQfbKnd37oTFxAAWFprx1atAbi53su4BAU+AoteKkPqXVPx7xr9RvqIccbO4cVfrfoi5j/oa\nMRgPHIMHD1bW1NQIysvL+S0tLeTkyZM2ALBq1apKraHo7u7ePnfu3KE+Pj6tGzZsqNA9/9atW4Kq\nqio+AMjlcpKSkmLt5+fXCgClpaUCAMjPzzc7ceKE7YsvvnjXm3teXp65s7Nzr9nfCoWCCAQCyuso\n5bp69WrXpUuX9mhA3YtH3N3dXeni4tKWkZFhDgCnTp2y9vX1/V2hMXdSVFQkFIlE6sWLF9e89tpr\nFZcvX7YEgKioqIbjx4/bae9PRUUFPy8vzywqKqrh6NGj4vLycr52e0REhDwhIcG2sbGR19DQwEtI\nSLCbOHFin800IiIi5CdOnLCVy+WktraWl5SUZNuXPoairxhxLfWU0m9/w7V7ik688xVFAEAC4DEA\ngwGcI4QEUEq7vTVSSncC2AkAI0eONE79NQbDAIg7ammr1Wrw7oPa1q3Fraj6pgpui91A+NwHEA/g\n8xFtb49DVZovuYerquDHVU1xKytNrPjhw5pa4mVlmrb3trZAVI/v+EbDQqB5QXh++POcyvHyAgYO\nBJqaAKUSyMrS3AoG44Fg27Zb2LbtVo/7bt/+tcft8+fXY/78tB73jRvX3ON2PTA3N6fLly8vGz16\ntN/gwYMV3t7edxmjSUlJVkeOHLGXSCQtUqlUBgAbN24sffrpp+tLSkqEzz///DCVSgVKKZkxY0bN\nvHnz6gFg+vTpXnV1dQKBQEA/+OCDYkdHx7tCIYKDg1tramqEEonEf8eOHUWTJk3qFnOYmJhoNX78\neLlarcaSJUvcYmJi6rWJo7+X7du3Fz/zzDOebW1txN3dXbFv374iAJgwYYL3nj17bnh4eLQDwLRp\n04b9+OOPotraWoGzs3PQP/7xj1vLli2r6m279vppaWkDVq1aNZjH40EgENAdO3bcAIDQ0NDWtWvX\nlkZGRvqo1WoIhUL64YcfFkdGRjYtX768bNy4cVIej0cDAgKaDx06VDR//vzqESNG+AHAs88+WxkW\nFtaSm5vba1JreHh486xZs2oCAgL83dzcFKNHj5b3pY+hIP1VMSCEbIEm2TIeQOd3ZUppej/nPQpg\nA6V0Ssf6qo7zNusc8ymAHymlX3asnwHwD0rppd6uO3LkSJqamtr3rBiM+4D29nYcPHgQ8fHxSE9P\nx9q1a/HII4/Az8+v/5M54MqMK6g+Wg0AcP+HOzw3e/ZzhmH4b0UFFmRnAwBGikRICAyEoxlHCf45\nORpLNDNT4x5uaQHGjwfO9pvWYjRK6kswQDgALe0tGGw92OCJswsWAP/9r2a8di2waZNBL88wAYSQ\nNErpSFPrYWwyMjKKgoOD7yke+2GlvLycHxsb63bu3DnrBQsWVNXX1/M3b95ctn37dod9+/bZBwcH\nNw0fPrzl9ddfZ2EFJiAjI8MhODjYo6d9+hjiyT1sppTSiH7OEwDIAxAJoBTAJQDzKaWZOsdEAZhH\nKV1ICHEA8AuA4ZTS6t6uywxxxh8FpVIJV1dXVFV1/Y68/vrrePvtt02iz9Unr6IqXqMLX8RHeH24\nUaqn1LW3w/GHH6DseNYQAAVjxsCTy1CdigpNnLharSkdcvNmVx94E3Ew6yC2nN+CtLI0uIncUNpY\niiuLriDAKcCgcg4f7gpRkck07ySMPzbMEGfcK88995x7XFxcsan1YGjoyxDXp6HPxB6WPo3wjvOU\nAF4BcBJANoCvKaWZhJA3CSHTOw47CaCaEJIFIBnA3/sywhmMPxICgQAzZnTPTz506JDRulveyaCX\nugxRVaMK8nR5H0cbDluhEBG2tjDrMPopOKyeosXZGXjsMc1YJgOKTf971NTWhLQyzRfy0sZSANxU\nT5kypStUPiuLVU9hMB5GmBH+x6Gvhj4LOv7G9rToc3FKaQKl1IdS6kUp/WfHtvWU0qMdY0opjaWU\nyiilgZTS/YaYFINxv3BnGUMnJyfU1taaRBe7x+1gHdZVver2/4xXpCjOzw87fHw61w9XcejkamgA\nPvgAqKkBgoI0iZv3QaD0Ez5PgEe6P3KP5R0zuBxLS8BTJ+ro//7P4CIYDAaDYSD68ohrM6pEvSwM\nBqMfIiMjIdJpYPPpp592JnAaG8IncF/ZVbWk8n+VRvPOO5uZYaaDA56wt8duX198E2DYcIxuqNXA\n668Dly8Dv/4KFBVxJ+sesLe079bE58WQF3HmuTOcyHr66a5xRgbQ3s6JGAaDwWD8Tvpq6PNZx9+N\nPS3GU5HB+ONibm6OmJiYzvXDhw+bUBtAPFkMvrWmKVhrYSsa0/qs5mRQ7IVCHAsMxHPOzjBsg/c7\nsLUFJk3qWj90SOMlLyvjUqpezPTtau5zq/EWrM177K/xu3nlla6xSsXixBkMBuN+RZ+GPhaEkCWE\nkB2EkC+0izGUYzAeBHTDU+Lj41FeXg5T1cPnmfNg6dNVArV0R6nRZBc0N+OFnBy4/PAD/h/XNb51\nm/ts2gQ4OABvvMGtTD2YIe3KGThz/QwaFNwU+haLgfBwwNwcmD4d4KpIDYPBYDB+H/oUNv4PABcA\nUwCchabet/HcaAzGH5ypU6fC3NwcAPDrr79i0KBB+OSTT0ymj9YjDgC13xovXp0Qgi/Ly1GtVOLb\n6mqEpqaisq3XfhS/jxkzAG1b6Pp6TWzG8eMmb3nvYeuB4S7DAQBtqjb8+Zs/I+iTIJQ2GP6FKC4O\nqKoCvvlGk6/KYDAYjPsPfQxxb0rpOgBNlNI9AGIABHKrFoPx4GBlZYVFixZh1qxZADStdw8dOmQy\nfVxedOkcU1CjxYl7DRiAoI5mPioA6XI5jlZzVCRJLAYi7ijuVFZ2X8Ro6IanHMo+hCu3r+BIzhGD\nyxk2TNPjSK0GfvwRuHbN4CIYDAaD8TvRxxDXpvnUEUICANgA8OBMIwbjAeT999/Hnj17unnGS0pK\nTKKL4wxHOD3jBP+D/hiTO8YotcS1zHJw6LbOaRnD6dO7xjKZJmkz0PQ+hGeCnsEX07/A24931ZOP\nzzF8GUMA2LcPcHcHHn1UU0iGwWAwGPcX+rS430kIsQOwDsBRAFYA1nOqFYPxACISibBx40Y4OTkh\nKioKrq6uJtGDP5AP2VemiVWY5eiIjTc03YEFABY4O3MnLDq6a1xYqKktfh/gLfaGt9gbZY1l2HJ+\nC2J8YvCU31P9n/gbUKmA0o6ol927gQ8/1PQ3YjAYDMb9Qb+GOKX0847hWQDG6YnNYDygvPzyyzhx\n4gSuXLliMkP8TpQNSvAG8MAT6vOB7PcRNHAghllY4HprK5QAbAX6+AJ+I8OGAS+/rKklPnVqV5eb\n+wRXkStu//02BDzu7sGYMV3jlhYgO5vFizMYDMb9hD5VU2wJIUsJIdsIIR9qF2Mox2A8SBw9ehSO\njo545pln8O6775pUF0opCtcU4uLQizhvcx61ScZJ2iSEdAtP4bSxDwB88gmwaJHGDfzBB0BkJPDv\nf3MrUw8opciuzMa7F95F9H+joabcJJFKJICHR9d6ejonYhiMB5bc3FwziUTir7stNjZ20Pr167t9\nYisoKBCOGTPGx9PT09/b29t/06ZNTtp9zc3NJDAw0M/X11fm7e3tv2zZss42x25uboE+Pj4yqVQq\nCwgI8OtNj2vXrgl37dplZ8i59Udfc9L3mE2bNjlJJBJ/b29v/zfffPOu8+8Xevpvaiz0cYElQBMT\nfgVAms7CYDDugdDQULR3dFY5c+YMHnnkEZw4ccIkuhBCcOuTW1AUKwAAt3beMprs2Y6OneMztbV4\n+8YNqLhOGI2PB5YtA777Djhi+MTIe0VN1Rj/5Xis/m41vi34Fl/88gXeSH4DrcpWg8t66aWu8THD\nN/JkMBgAhEIh3nvvvZuFhYWZly5dyt69e7dTWlqaBQBYWFjQ8+fP5+bm5mZlZmZmnTlzxvrMmTPa\npok4e/ZsXk5OTtbVq1eze7t+QkKCdXp6umVv+7mgrznpc8ylS5cs4uLiHNPT07Ozs7MzExMTba9c\nuWJuzDn8EdDHELfoaEP/b0rpHu3CuWYMxgOGm5sbxnTEClBK8dNPP+GYCS0j24m2neO6lDqjyX3U\n2hr/cHeH74ABKGxtxT+uX8fPDdzU0+4kOLhrfPq0Jk7DhPB5fEz36Uom/cuxv+DN79/E2aKzBpc1\nbVrX+ORJk0+dwXggGTp0aHt4eHgzANjZ2am9vLxaiouLzQCAx+PBxsZGDQBtbW1EqVSSe0mSP3ny\npNW6deuGHD9+3E4qlcpycnKM0hmgrznpc8yVK1cGjBgxQi4SidRCoRBhYWGNBw4csNU9v6GhgffY\nY495+/r6yiQSib+u13/Hjh3iwMBAP6lUKps/f/5QpVIJAPjoo4/sfXx8ZL6+vrKZM2cOA4ANGzY4\nSyQSf4lE0ul5z83NNfP09PSfO3fuUG9vb/+wsDCJXC7vvPErV6508fDwCBg7dqxPfn6+eX/6cIVe\ndcQJIX8hhLgSQsTahWvFGIwHEd0umwCQkJBgtPKBd+L6UleMuqpehea8ZqPI5RGCzZ6eCLOx6dyW\nUFPDncBXX9WEpACAVAps3WryeuIAMFM6865t3xZ8a3A5/v6A9iNEfT3w1lsGF8FgMHTIzc01y8rK\nspwwYYJcu02pVEIqlcqcnZ2DJ0yY0BAREdGk3RcZGSnx9/f327p1q0NP15syZYo8MDCwKT4+viAn\nJydLKpX+5gYMoaGhvlKpVHbncuTIEdG9zqm/Y4YPH97y008/icrLy/mNjY28pKQkm5KSkm6GfHx8\nvLWLi0t7bm5uVn5+fubs2bMbACA9Pd3i4MGD4tTU1JycnJwsHo9HP/30U/vU1FSLrVu3up49ezYv\nNzc367PPPis+d+6c5d69e+3T0tKyU1NTs+Pi4hwvXLgwAACKi4stli5derugoCDTxsZGFRcXZwcA\n586dszx8+LD4ypUrWcePHy/IyMgY2Jc+XKKPId4G4F0AF9EVlpLKpVIMxoPK1KlTO8dmZmZ44403\noFJx2vC9V8STxBBP63qnrj7BUU3vXoi2twcAiPh8tHNpGIeEdI2dnTUx4wMH9n68kXjc83FYCru+\nNNta2MJCYPiEUkK6x4kfPmxwEQzGA0tvnuvettfX1/Nmz57ttWXLlhKxWNz5YBMIBMjJyckqLi7+\nNT09feClS5csAODChQs5WVlZ2adOncrftWuX07fffmvV03ULCwstgoKCFACQlZVl9qc//WloVFRU\nZwGN7du3269bt8557ty5QyMjI73i4+Ote7pOWlpabk5OTtady8yZM3tt1NjbnPo7ZsSIEa2vvvpq\neUREhM/EiRMlMpmsWXBHgv6IESNazp07Z71o0SK3xMREK3t7exUAJCYmiq5evWoZHBzsJ5VKZefP\nn7cuLCw0P3nypPW0adNqXV1dlQDg7OysSklJsYqOjq6ztrZW29jYqGNiYmqTk5NFAODm5qYYO3Zs\nCwCEhIQ0FxUVmQNAcnKyVXR0dJ1IJFKLxWL15MmT6/rSh0v0SdePhaapD8dZVQzGg8+IESPg5OSE\n27dvo62tDUFBQbjzwWQsCI/A4QkH1BzTeKOrT1RjyLIhRpMfZm2Nf3p44IZCgVfc3LgTFBXVNT5/\nHqirA2xtez/eSAwQDkCUdxTiszU1xP8+9u9YPW41J7KeeQa4dEkzzssDlMquxqMMxh+F2IKCQe/f\nvNlruSlHobD9dljYr/oev2zw4LJt3t59Jsg4Ozsr6+vr+brbampq+MOGDVNs3rzZcc+ePY4AkJiY\nmO/q6qqMiYnxmjNnTs3ChQt7jPdzcHBQhYeHNx47dsxm1KhRrR4eHu0A4ObmpoyJiam7ePHiwKlT\np3bzOpeXl/NFIpHK3NycAoBMJmv7+uuvb+ga4mlpaZZffPFFCY/HQ2VlJX/JkiWDe/LmhoaG+jY1\nNfHv3L5ly5aSnoxxhUJB+ptTX8csW7asatmyZVUA8Morr7gNHjy4mzc/KChIkZ6ennXo0CGbNWvW\nuJ0+fbph69atZZRSMmfOnOqPP/64W9vht956y4kQ0u0zcl9flc3MzDp38vl82tLS0umA7ullqjd9\nehVgAPTxiGcCMM43awbjAYfH4yFKxzD89lvDhyLcC/Yx9p3juuQ6KBuVRpP9Qm4u1hQVYWdZGb7l\nMjTFxQUYOVIzVqmAPXuAbduA3FzuZOqJbpfN43nHOZPzwguAmxswY4am5T2rJc5g6IeNjY3aycmp\n/ZtvvhEBQEVFBT8lJcUmIiJCvmrVqkqtR9nd3b197ty5Q318fFo3bNhQoXuNW7duCaqqqvgAIJfL\nSUpKirWfn19rQ0MDr7a2lgdoYpOTk5Otg4KC7sriyMvLM3d2du41HEWhUBCBQEB5PI1Jt3r1atel\nS5f22C3tXjziarUavc1J32NKS0sFAJCfn2924sQJ2xdffLHbw76oqEgoEonUixcvrnnttdcqLl++\nbAkAUVFRDcePH7fTnl9RUcHPy8szi4qKajh69Ki4vLycr90eEREhT0hIsG1sbOQ1NDTwEhIS7CZO\nnNirhx8AIiIi5CdOnLCVy+WktraWl5SUZNuXPlyij09EBeAyISQZgEK7kVK6lDOtGIwHmKlTpyIu\nLg5SqRQtLS3417/+hUWLFsHOzqiVqQAAfBs+wIfm/3I1UJNQA6enjVNhapKdHRI7DPCE6mpEicUY\nwlWt75gYILUjou611zR/W1qANWu4kacnUyVTQUBAQfFT6U+oaqpCdUs1fB18DSrH2hq4edOgl2Qw\nHhr27NlzffHixe4rV64cAgArV6685e/vr9A9JikpyerIkSP2EomkRSqVygBg48aNpU8//XR9SUmJ\n8Pnnnx+mUqlAKSUzZsyomTdvXn1WVpbZrFmzvAFApVKRJ598svqpp566y4sdHBzcWlNTI5RIJP47\nduwomjRpUpPu/sTERKvx48fL1Wo1lixZ4hYTE1OvTaD8PfQ1pwkTJnjv2bPnRm5urnlvxwDA9OnT\nverq6gQCgYB+8MEHxY6Ojt1CPdLS0gasWrVqMI/Hg0AgoDt27LgBAKGhoa1r164tjYyM9FGr1RAK\nhfTDDz8sjoyMbFq+fHnZuHHjpDwejwYEBDQfOnSoaP78+dUjRozwA4Bnn322MiwsrCU3N7fXpNbw\n8PDmWbNm1QQEBPi7ubkpRo8eLe9LHy4h/SWKEUIW9rTdVJVTRo4cSVNTWYg644+LXC5HdXU1lixZ\n0lm+8MCBA/jTn/5kEn1+9PwRrdc1ZfNk+2VGM8Szm5og64iXIACs+XxUhoVByOOgsdDPP3fvbgMA\njzwCXLxoeFn3SGRcJCyFlqiQV6CwthBN7U2oeb0GA4QDTK0a4z6BEJJGKR1paj2MTUZGRlFwcDAL\ni72D8vJyfmxsrNu5c+esFyxYUFVfX8/fvHlz2fbt2x327dtnHxwc3DR8+PCW1/3dfysAACAASURB\nVF9/vUevOMP4ZGRkOAQHB3v0tK/fX7wOg/trAD+y8oUMxu/HysoKQ4cOxciRXb+rCQkJJtPHZaEL\nAMDMxQwqufESR6WWlnA30zgsKIB6lQoXuSpjOHJkV+kQADA3B5ycNMHSJub0s6dxbN4xyNvkqG6p\nRquyFSlFKZzIqqkBNm8GQkOBG5z7eRgMBhe4uLio9u7dW1xSUnJ18+bN5XK5nG9jY6Neu3bt7czM\nzOy9e/cWMyP8j4M+nTWnAbgMILFjfTgh5CjXijEYDzrR0dEAAJFIBAsTtl93+bMLQlND8Wjpo3B9\nsde8JoNDCEG0Q/dqXSe5ihXn8TRt7gUCYPhw4MQJTbD0fZCxqE0YmurdVVHndOFpTmR5eACrV2s6\nbO7YwYkIBoNhZOLi4opNrQPjt6PPN+ANAEYDqAMASullAMM41InBeOBRKBS4ePEiRo8eDVtbW+ww\noVVkMcQColARFKUKlH5aitsHbhtN9lRxV/nEYRYWeEO3zp6h+ec/gaoq4JdfuuqK30c8HfA0Xhn9\nCo7PO453Jr3DiQx/nUbd90GDUQaDwXjo0ccQV1JK6+/YZpoOJAzGA4JQKMS//vUv/PzzzygpKYGp\n8x6qT1TjR/cfkb8oHzf+ZbyYhQhbW5h1eISvt7bidttv7lPRP4MHAzpNhEApkJMDKBS9n2Mk4jLi\nsCB+AT76+SNcvX0VfN5d1cUMwjPPdI3r73yqMxgMBsPo6GOIXyWEzAfAJ4RICCHbAfzAsV4MxgPN\nnWUMExISkJeXZzJ9zIeaazImATT92oS2Cg4NYh2sBAKMs7HBMAsLLB40CEbrd/nOO4BEAvj5Ad9/\nbyypvUIpRX5NPgAg8VoiZ3IWLuyKxqmoAEpL+z6ewWAwGNyijyH+NwD+0JQu3AugAcBrXCrFYDwM\n6HbZ/Ne//gWpVIrKStPk11i4d49Rr9jbY8lYTjgcEIArI0dikp0d3rpxA0u4fCG5eRNYv17T5v7a\nNc22Y8e4k6cnU7yndI6/v/E95h2ch2fin+njjN+GSARMmNC1buIy9gwGg/HQo0/VlGZK6RpK6aiO\nZQ0AZyPoxmA80EyePBnaBgzt7e2glCIxkTtvaF8IrAWw8Ooyxiv+azxDXCQQoEShwKzMTOwqK8N/\nKirQxlXL+/p6YNMmQPeF57vvuJF1D7hYuSDEJQQAoKZq7M/cj4NZB9HU1tTPmfeOzvsfvvzS4Jdn\nMBgMxj3QpyFOCHmUEPIUIcSpYz2IELIXwHmjaMdgPMCIxWI88sgj3bYlJSWZSBtg0MuDOsfNuc1Q\ntxktUAS+lpYY1lE5plGlwgWuAphlMsDdvWt98+au3u8mJso7qtt6m6oNyUXJBpeja4hfuAAUFhpc\nBIPBYDD0pFdDnBDyLoAvADwJ4AQh5A0ASQB+AiAxjnoMxoONbnhKZGQkPv/8c5PpMiR2CCw8NMaw\nWq5G/XnjZfNpDW8egFEiEQaZm3MjiBBNl00tNTXAgPujcY6uIW7GM8Pq8NXwtTdsh01AExavWy2T\nVU9hMBgM09GXRzwGQAildB6AyQD+ASCcUvp/lNJWo2jHYDzg6BriGRkZEJiwrjUhBPZP2HeuVx+v\nNprsaqUS11tboQagUKvha2nJnTBdQ7yjs+n9wKODH4W1uTUAoE3dhgVBCyCxN7zPgxBg2bKu9aIi\ng4tgMBgMhp70ZYi3aA1uSmktgFxKab5x1GIwHg5CQkIwc+ZMvPPOO0hOTu5s7mIqbMbbAAQQOgjR\nUtBiNLkRtrYQdsz916Ym3OKypODEiV0u4aws4IUXgKAgQC7nTqYeCPlCPO75OABAwBMgoyKDM1kv\nvQR8+qnGCP/wQ87EMBgMBqMf+jLEvQghR7ULAI871hkMxu+Ex+Ph8OHDWLp0Ka5du4aXX34ZMboe\nW2PrY8kDKNBe1Y7m7GajyRV1lDHUsvnGDZytq+NGmKWlxhjX8uWXwJUrQEoKN/LugdfGvIbDTx9G\n9evVmOI1BQeuHkBigeETeD08gL/+FRg6VFNOXak0uAgG44GBz+eHSqVSmUQi8Z86dapnY2OjPhXn\nUFBQIBwzZoyPp6env7e3t/+mTZuctPuam5tJYGCgn6+vr8zb29t/2bJlnUk6mzZtcpJIJP7e3t7+\nb775plPPVweuXbsm3LVrl93vm9290decdOltfhkZGeZSqVSmXaysrEL6mqMpiY2NHbR+/XrOi5P0\n9R18xh3r73GpCIPxMNPW1oY5c+agvb0dAHDz5k0MHjzY6HqIHxeDN5AHdZMaLQUtaM5rhqUPh2Ei\nOkwVi/Fdh/H90a1buKFQYIKtLTfCYmLurt136hTwxBPcyNOTcUPHAQC+yfkGs7+eDTVVI3JY5F2J\nnIbghx+AuDjNbVi1Cnj5ZYOLYDAeCMzNzdU5OTlZADB9+vRh7733nuOGDRv6LS0lFArx3nvv3QwP\nD2+ura3lhYSEyKKjoxtCQ0NbLSws6Pnz53NtbGzUCoWCjBo1yvfMmTP11tbWqri4OMf09PRsCwsL\n9YQJE3xmzZpVHxgYeNdnwoSEBOusrCwLALUcTPue56R7XG/zi4yMbNLeS6VSCRcXl+C5c+dy5HX5\nY9DrWx2l9GxfizGVZDAedEQiER599NHO9W9NVOCZZ86DeLIYotEieGz0AOEbL1QmSqfdPQCcqa1F\nq0rFjbCYGGDOHODvf9e4hxctAmbO5EbWb2DkoJFQU03Vmu9vfA95m+HDZs6eBT77DCguBv7xD4Nf\nnsF4IAkPD5cXFBSY5+bmmkkkEn/t9vXr1zvHxsYO0j126NCh7eHh4c0AYGdnp/by8mopLi42AzRf\nQ21sbNQA0NbWRpRKJSGE4MqVKwNGjBghF4lEaqFQiLCwsMYDBw7c5ZE4efKk1bp164YcP37cTiqV\nynJycsy4nXn/c9Klt/npcvToUWt3d3eFj49Ptw5yDQ0NvMcee8zb19dXJpFI/HW9/jt27BAHBgb6\nSaVS2fz584cqOz7nffTRR/Y+Pj4yX19f2cyZM4cBwIYNG5wlEom/RCLp/LKQm5tr5unp6T937tyh\n3t7e/mFhYRK5XN6p2MqVK108PDwCxo4d65Ofn2/enz6GQK/PKwwGg1v+3//7f/i+o8NjdHQ0Ro8e\nbTJdZPtkEEeJUfNtDVKHp0LVypExfAf+AwdisE61FAehEMVcxYp7eABffw28/TZw/TqwYwcQEcGN\nrHtEqVaiqK4ITgM1X2v9nfxxs+GmweVM6eohhPp6oKDA4CIYjAeK9vZ2nDx50jowMPCeE2hyc3PN\nsrKyLCdMmND5Vq1UKiGVSmXOzs7BEyZMaIiIiGgaPnx4y08//SQqLy/nNzY28pKSkmxKSkruMnSn\nTJkiDwwMbIqPjy/IycnJkkqlv7kdcmhoqK9uuIh2OXLkiOhe56RLT/PT3b9v3z7xU089dVdVgPj4\neGsXF5f23NzcrPz8/MzZs2c3AEB6errFwYMHxampqTk5OTlZPB6Pfvrpp/apqakWW7dudT179mxe\nbm5u1meffVZ87tw5y71799qnpaVlp6amZsfFxTleuHBhAAAUFxdbLF269HZBQUGmjY2NKi4uzg4A\nzp07Z3n48GHxlStXso4fP16QkZExsC99DIXpSjQwGIxOPDw8Osd2dnYIDg42mS48cx5uH7iNllzN\nb03DhQbYRXIfhkgIwVSxGLvKygAAL7i4wIfL6ikaodxe/zdwtugsHv+PJmnTw9YDv/z1F07khIRo\nKje2dJgUH38MvP8+J6IYjD80CoWCJ5VKZQAwZsyYxldffbXqxo0bQn3Pr6+v582ePdtry5YtJWKx\nuLNBg0AgQE5OTlZVVRU/JibG69KlSxajRo1qffXVV8sjIiJ8LC0t1TKZrLm3alqFhYUWQUFBCgDI\nysoy27Bhg2tDQwM/MTGxEAC2b99uf/v2bUF+fr5FZWWlYMmSJZU9GZFpaWm593hLep2TLr3NDwBa\nW1vJ6dOnbbZt23aXl2HEiBEta9asGbJo0SK3GTNm1EdFRckBIDExUXT16lXL4OBgv45r8JycnJT1\n9fX8adOm1bq6uioBwNnZWbVz506r6OjoOmtrazUAxMTE1CYnJ4vmzJlT5+bmphg7dmwLAISEhDQX\nFRWZA0BycrJVdHR0nUgkUgPA5MmT6/rSx1AwjziDcR+gW8bw5MmTUHPVWVJPxJO7wkTK/1tuNLkL\nnJ3xpocHLo0YgfU6LyecQSlw9Srw0UeaGPH7oNVkuHs4LIWaF5CiuiIU1HDjqiYE0P3w0mK8IjkM\nxm8itqBgEElJCSUpKaH+P//sp7vP6cKFIO2+rcXFDtrteysqbLTbSUpKqO455+rq9HrT18aI5+Tk\nZO3Zs6fEwsKCCgQCqvucbm1t5QHA5s2bHbUe5aKiIqFCoSAxMTFec+bMqVm4cGGPsdAODg6q8PDw\nxmPHjtkAwLJly6qysrKyU1NTc8VisUoikdxVMrq8vJwvEolU5ubmFABkMlnb119/fUP3mLS0NMuN\nGzdW7N+//8b+/fuL9u/f36NH5V494vrMqa/5AcDBgwdtZDJZ85AhQ+5KFQ8KClKkp6dnBQYGtqxZ\ns8ZtxYoVrgBAKSVz5syp1v63KCoqurpt27ZblFIQQqjuNSild162EzMzs86dfD6fKpXKTo9MT5XL\netPHUPRriBNCfAghuwghpwgh32kXQyrBYDzshISEwNlZk5xdVVWF999/H4cPHzaZPsr6rmdjzfEa\no8kdb2uLdR4eGGltDR4hkCuVaOSqpIdaDfj4AIGBwN/+ponVeO01k5cQMReYI2JYV5jMyYKTqG2p\nRW2L4fOx/v73rvF51i+ZwdCbwYMHK2tqagTl5eX8lpYWcvLkSRsAWLVqVaXWUHR3d2+fO3fuUB8f\nn9Y7kztv3bolqKqq4gOAXC4nKSkp1n5+fq0AUFpaKgCA/Px8sxMnTti++OKLdz2E8/LyzJ2dnXsN\nR1EoFEQgEFAeT2PmrV692nXp0qWVPR2blpaWq9VZd5k5c2bjnceq1Wr0Nid95wcA+/fvF//pT3/q\n8celqKhIKBKJ1IsXL6557bXXKi5fvmwJAFFRUQ3Hjx+3096fiooKfl5enllUVFTD0aNHxeXl5Xzt\n9oiICHlCQoJtY2Mjr6GhgZeQkGA3ceLEu+ajS0REhPzEiRO2crmc1NbW8pKSkmz70sdQ6OMR/x+A\ndABrAfxdZ2EwGAaCx+MhKqqrMsaKFSvwxhtvmEwf3cY+7ZXtUJRzWNe7B76pqsKkjAzYX7iAPeUc\neeR5PMDbu/u2+vr7ouV9lFfXv4X1Kevh+K4jPk83fNfViRMBbVh+ZqYmcZPBYPSPubk5Xb58edno\n0aP9IiMjvb29ve/yWiclJVkdOXLE/vz58yKtl/nAgQM2AFBSUiIcN26cr4+PjywkJEQ2ceLEhnnz\n5tUDwPTp0728vLz8n3jiCe8PPvig2NHR8a5EneDg4NaamhqhRCLxT0pKGnjn/sTERKvx48fL1Wo1\nFi1a5BYTE1OvTbL8PfQ1pwkTJngXFRUJ+5tfY2Mj7/z589YLFizo0ZuelpY2YPjw4X5SqVT29ttv\nu65fv74MAEJDQ1vXrl1bGhkZ6ePj4yOLiIjwKSkpEY4cObJ1+fLlZePGjZP6+vrKFi9ePCQ8PLx5\n/vz51SNGjPALDQ31e/bZZyvDwsL6/O4XHh7ePGvWrJqAgAD/J554wmv06NHyvvQxFKQv9z0AEELS\nKKWhfR5kREaOHElTU1NNrQaDYXAOHDiAuXPndtt269YtuLoa9CuYXijlSpy3Pg90PB58dvtg0J8H\n9X2SAXm3uBivFxYC0JQ1TAgK4kbQ++8DsbFd60OGaMJUpk/nRp6eFNYWwutDr27bHvN4DMkLkw0u\na8oUTVQOADzzDPDVVwYXwfiddPwOjzS1HsYmIyOjKDg4uMrUevwRKC8v58fGxrqdO3fOesGCBVX1\n9fX8zZs3l23fvt1h37599sHBwU3Dhw9vef3113v0ijO4JSMjwyE4ONijp336JGseI4QsBnAYQKdb\njFJqvO/VDMZDwKRJk8Dj8Trjw728vFBSUmISQ1xgJYDLQheUf6nxRten1BvNEL/W0oKVHUY4AJyt\nq4NCrYY5j4OUlsmTu8YiEVBYCPSSGGVMPO08IRFLkF/T1cz4fPF5NLU1YaDZXc6v30VISJchnpZm\n0EszGAwj4eLiotq7d2/nN63nnnvO3cbGRr127drba9euvW1K3Rh9o88v20JoQlF+AJDWsTCXNINh\nYMRiMR555BEAQEBAAOLj401axnDQ4i7Du+ZUTZ/JL4bE08ICg8y6qnXt9vWFGVfVTWQyYFDHPBsb\n7ytLVLeJz2SvyShcWmhwIxwA3nijKzwlJwcoKTG4CAaDYWTi4uJYoNkfhH4NcUrpsB4WT2Mox2A8\nbHz66acoLy/HlStXEMRVOIaeiEaI4PK8C3x3+yI4yXjlFAkhmGrfFaN+tampx0x2Awnr7hU/dQpo\nawOq7ypta3SivKMgHiDG3IC5eGXUKxhiM4QTOQMGAOPGAZaWQHQ00GDQCrkMBoPB6At9qqYICSFL\nCSEHO5ZXCCF6189kMBj6ExgY2Fk9BQCam5vR2NhnojdnED6Bpb8lbn12C6nBqWi60tT/SQZiqk6X\nzcQajqPgdA3x998HxGJNz3cTM9lrMm6vuI19T+7DNN9pnMr697+BsjJNFZUyg6YhMRgMBqMv9AlN\n+QRAKIAdHUtoxzYGg8ERx44dw+OPPw6xWIydO3eaTI/GS41o/LkRoJrwFGMRaWcHfsc4TS7H45cv\no6rtNzeO60dYpOavmRlQWws0NWk840YKxekNAU8APk9zF34p+wWbz21GxJ4IFNcb/ovz9euAq6um\nisratQa/PIPBYDB6QR9DfBSldCGl9LuO5QUAo7hWjMF4WMnPz8eXX36JM2fOQKFQ4JQ2k84E6Db2\nKdtVBlWLcdrd2wgEGG1t3bl+pq4OZ+r67Rvx23ByAi5cAKqqNAmbAHDjBpCf3/d5RmTl6ZVY/d1q\nJBcl43ThaYNf39+/q6HPzz8DuffcZ4/BYDAYvwV9DHEVIaSzjhYhxBOAcX6NGYyHkJSUFMTHx3eu\nf//992htvatErVGwm2IHoYsmEq0lrwX15+qNJnuSXfcmcElchqiMHasxwlesALZuBX79FZBIuJOn\nJy3tLfjL0b/g59KfO7edumb4FzOxGBg6VDOmFNi0yeAiGAwGg9ED+hjifweQTAhJIYScBfAdgOXc\nqsVgPLxMmjSpcywUCpGamgpzbVkLI2Mx2AJOf3LqXDdmeMrkjjhxAsBnwACMs7XlXuj69cDy5Zpu\nm1wliN4DFgILnCo8hXqF5gVovPt4POHzBCeyAgK6xsmGL1fOYDAYjB7Qp2rKGQASAEs7Fl9KKXtM\nMxgc4eHhAUmHN7a9vR0VFRXcVQ3RA93wlNpThm+z3htjRCIUP/IIWsaPR+6YMVjo4sKtwO++6zLC\ni4q4laUnhBBM8ux6MXvM4zEsCFrAiayFC7vGZWWa4jEMBoPB4JZeDXFCSETH39kAYgB4A/ACENOx\njcFgcISuVzwpKcmEmgDW4dbQZk42XWmCosw47e4FPB6GWFhw08inJ959F9i2Dbh6VZOxOHs2cP68\ncWT3ga4hnlTI3b+F6dMBYUc9LEpZPXEGg8EwBn39wk3o+Duth4Wbb6MMBgNAd0P8q6++QnR0NCoq\nKkyiC+ETQN21Xvk/43dIppQit7kZJ7is761bxvC//wUOHwZOnOBOnp5EekaCQPNF5KebP+GHkh9w\n4OoBg8sxM+t+C0z8/sdgMBgPBb0a4pTSNzqGb1JKX9BdALBUHgaDQyZOnAg+X+OGvnnzJr799luc\nPm34ahn6ILASwMLDonO9Yr/xXgiUajXeKirCwHPnIP35Z8zNykK7Wt3/ib8FXStUy8mT3Mi6Bxws\nHTDCdQQAQA01wr4Iw3NHnkNze7PBZWlvgZMToDDOhw8G474mNzfXTCKR+Otui42NHbR+/Xpn3W0F\nBQXCMWPG+Hh6evp7e3v7b9q0qTO5prm5mQQGBvr5+vrKvL29/ZctW9bZttjNzS3Qx8dHJpVKZQEB\nAX696XHt2jXhrl277HrbzxUHDx609vDwCHB3dw9YvXp1j/GBGzdudPL29vaXSCT+06ZNG9bc3EyA\nvu/J/UZP/02NhT7ffA/1sO2goRVhMBhd2NjYYMyYMd22mbSMYXRXnHhzdjOo2jg1tvmEYNetW2jp\nML7lKhV+5Kr1o267ewAYMQJ4+mmT1xMHuoenAECbqg3f3/je4HLmzgW2bweeegrYsYM192Ew9EUo\nFOK99967WVhYmHnp0qXs3bt3O6WlpVkAgIWFBT1//nxubm5uVmZmZtaZM2esz5w5M1B77tmzZ/Ny\ncnKyrl69mt3b9RMSEqzT09MtjTEXLUqlEsuWLXNPSEjIy8vLyzx06JBYOyct169fF+7cudP58uXL\nWfn5+ZkqlYp8/vnnYqDve8Looq8YcSkh5EkANoSQ2TrL8wD0upGEkChCSC4hpIAQ8o8+jnuKEEIJ\nISPveQYMxgPKrFmzEB4eDqFQiIkTJ+Kxxx4zmS6eWzzBF/NBzAmsR1pDWas0ilxCCCbrtLvnA8jT\nFrw2vDBAJyQIs2YBK1feF9VTJnl1N8QHCgeipN7wQdxOTsChQxojPC8PMNFHGAbjD8fQoUPbw8PD\nmwHAzs5O7eXl1VJcXGwGADweDzY2NmoAaGtrI0qlktxLAv7Jkyet1q1bN+T48eN2UqlUlpOTY8bJ\nJO4gJSVl4NChQxUymazNwsKCzp49u+bgwYN3la9SqVSkqamJ197ejpaWFt7gwYPbgb7viZaGhgbe\nY4895u3r6yuTSCT+ul7/HTt2iAMDA/2kUqls/vz5Q5VKze/ORx99ZO/j4yPz9fWVzZw5cxgAbNiw\nwVkikfhLJBL/N9980wnQfM3w9PT0nzt37lBvb2//sLAwiVwu77zxK1eudPHw8AgYO3asT35+vnl/\n+nCFoI99vtDEgttCExeupRHAX/q7MCGED+BjAJMA3ARwiRBylFKadcdxImiqsfx0b6ozGA82K1as\nQGxsLNrb201WvlCLwEqAkO9CMEAyAHxLfv8nGJBJdnb4vMM1GyoS4UVXV+6ETZ4M7NmjGZ86dd+0\nmQwbEoYVj66Ar4MvhlgPwcRhE2HG5+a3eNIkICVFM05KAp59lhMxDMYDS25urllWVpblhAkT5Npt\nSqUSAQEBsuLiYvOFCxfejoiIaNLui4yMlBBC8MILL1SuWLGi6s7rTZkyRR4YGNi0bdu2klGjRv2u\nphKhoaG+TU1Ndz3Et2zZUjJz5sxG3W0lJSVmbm5unfWTBg8e3PbTTz9Z6R4zbNiw9iVLlpQPGzYs\nyNzcXD1u3LiG2bNn3/XZsqd7AgDx8fHWLi4u7SkpKQUAUF1dzQeA9PR0i4MHD4pTU1NzzM3N6YIF\nC9w//fRT+0ceeaRp69atrhcvXsxxdXVVVlRU8M+dO2e5d+9e+7S0tGxKKUJDQ/0iIyMbHRwcVMXF\nxRZfffVV4dixY29ER0d7xsXF2S1evLjm3LlzlocPHxZfuXIlq729HcOHD5eFhIQ096YPl/RqiFNK\nvwHwDSHkUUrpxd9w7dEACiilhQBACNkPYAaArDuO2wTgHQArfoMMBuOBhsfjmdwI12IVbAWqpmhM\nbwRtp7AeY93/SQYg0s4OBAAFkNbYiLr2dthqy3sYmscf7xpfvAhkZ2taTT73nEk94+YCc7w7+V2j\nyAoP17S7t7a+b6o4MhgmozfPdW/b6+vrebNnz/basmVLiVgs7kxoEQgEyMnJyaqqquLHxMR4Xbp0\nyWLUqFGtFy5cyPHw8GgvLS0VRERE+Pj7+7dOnTpVfud1CwsLLYKCghQAkJWVZbZhwwbXhoYGfmJi\nYiEAbN++3f727duC/Px8i8rKSsGSJUsqezKI09LS9O6bS3sIyyOEdNtYWVnJP3HihG1BQcEVe3t7\nVUxMjOeOHTvEixcv7mw60ds9AYARI0a0rFmzZsiiRYvcZsyYUR8VFSUHgMTERNHVq1ctg4OD/QCg\ntbWV5+TkpKyvr+dPmzat1tXVVQkAzs7Oqp07d1pFR0fXWVtbqwEgJiamNjk5WTRnzpw6Nzc3xdix\nY1sAICQkpLmoqMgcAJKTk62io6PrRCKRGgAmT55c15c+XNKXR1zLy4SQbEppHQAQQuwAvEcp/XM/\n57kB0P12ehNAt6BXQkgIgCGU0uOEEGaIMxi9UFRUhOzsbLS3t2P69Okm0aHubB0y52SivbIddo/b\nITgp2Chy7YVChIpESG1shApAcl0dnrC3h5CLsoZOTsATT3S1vZfJNNtDQoCgIMPL+x1QStGibIGl\n0LBho35+mtjwsjKgoABoaNAY5QyGqSmILRh08/2bvX4SEzoK28Nuh/2q7/GDlw0u897mfasvmc7O\nzsr6+vpuXtGamhr+sGHDFJs3b3bcs2ePIwAkJibmu7q6KmNiYrzmzJlTs3Dhwrqerufg4KAKDw9v\nPHbsmM2oUaNaPTw82gHAzc1NGRMTU3fx4sWBdxri5eXlfJFIpDI3N6cAIJPJ2r7++usbUVFRntpj\n0tLSLL/44osSHo+HyspK/pIlSwb3ZIjfi0fc3d29rbS0tPPT282bN80GDRrUrnvMsWPHrN3d3RWD\nBg1SAsDMmTPrfvjhByutIa5QKEhf9yQoKEiRnp6edejQIZs1a9a4nT59umHr1q1llFIyZ86c6o8/\n/rhU9/i33nrL6c6XgZ5eGLSYmZl17uTz+bSlpaXzh6Onl6ne9OlVgAHQ55csSGuEAwCltBZAiB7n\n9fS62HlDCCE8AO9Djy6dhJCXCCGphJDUykrjl05jMEzF999/Dy8vLwwbNgzR0dGYO3euydrdW3hZ\noL1S8wyuPVOLqm/u+oLKGbrt7l/IycHf8vO5E3bsGLB7NxCs86JhwkRZf1X4FAAAIABJREFUXVra\nW7A7fTdCPguBx/954KVjLxlchqOj5r0DAFSqrjAVBuNhxMbGRu3k5NT+zTffiACgoqKCn5KSYhMR\nESFftWpVZU5OTlZOTk6Wu7t7+9y5c4f6+Pi0btiwoVtpqVu3bgmqqqr4ACCXy0lKSoq1n59fa0ND\nA6+2tpYHaGKTk5OTrYOCgu5KgsnLyzN3dnbutcWWQqEgAoGA8jqcE6tXr3ZdunRpj8ZSWlparlZn\n3eVOIxwAJkyY0FRUVGSRk5Nj1traSuLj48VPPvlkN2Paw8OjLT093aqxsZGnVqvx3Xffifz8/FoB\nQK1Wo7d7oqWoqEgoEonUixcvrnnttdcqLl++bAkAUVFRDcePH7crLS0VaO97Xl6eWVRUVMPRo0fF\n5eXlfO32iIgIeUJCgm1jYyOvoaGBl5CQYDdx4sS75qNLRESE/MSJE7ZyuZzU1tbykpKSbPvSh0v0\n8YjzCCF2HQY4CCFiPc+7CWCIzvpgALpvniIAAQBSOt5KXAAcJYRMp5Sm6l6IUroTwE4AGDlypOlL\nGDAYRsLV1RWFhYWd6y0tLbhw4QIiIyONrovFYAsIxAIoa5QABW4fvA2HGQ5GkT3Jzg6bi4sBAPUq\nFU7W1oJSym3H0SlTgK+/Bvh84FafTjOj4b/DH9frrneuny48DTVVg0cM+3Vg0iTgl180423bNM1+\nGIyHlT179lxfvHix+8qVK4cAwMqVK2/5+/t3K/CZlJRkdeTIEXuJRNIilUplALBx48bSp59+ur6k\npET4/PPPD1OpVKCUkhkzZtTMmzevPisry2zWrFnegCbh8cknn6x+6qmn7vJiBwcHt9bU1AglEon/\njh07iiZNmtSkuz8xMdFq/PjxcrVajSVLlrjFxMTUa5Mkfw8dVU+Ko6KifFQqFebPn181cuTIVgCY\nMGGC9549e25EREQ0TZs2rTYoKMhPIBDA39+/OTY2trK/e6KVkZaWNmDVqlWDeTweBAIB3bFjxw0A\nCA0NbV27dm1pZGSkj1qthlAopB9++GFxZGRk0/Lly8vGjRsn5fF4NCAgoPnQoUNF8+fPrx4xYoQf\nADz77LOVYWFhLbm5ub0m0oSHhzfPmjWrJiAgwN/NzU0xevRoeV/6cAnpy6UPAISQ5wCsQlfJwjkA\n/kkp/U8/5wkA5AGIBFAK4BKA+ZTSzF6OTwGw4k4j/E5GjhxJU1P7PITBeGCglGLYsGG4cUPzLBAK\nhfjoo4/w0kuG94TqQ9GbRSh6owgAMDBgIEZdGWUUuQq1Gk9evYqk2lq0dTyz8kePhrclh86K8nLg\nP/8BnnwS8PTs/3gj8OzhZ/HVr19123b5r5cR7GLYMKGDB4E5czRjQoDmZsCCFR0zGYSQNErpQ1dV\nLCMjoyg4ONh4n97+IJSXl/NjY2Pdzp07Z71gwYKq+vp6/ubNm8u2b9/usG/fPvvg4OCm4cOHt7z+\n+usshOA+ISMjwyE4ONijp339erYppXGEkDQAE6EJN5l9Z+WTXs5TEkJeAXASmqpjX1BKMwkhbwJI\npZQevZdJMBgPI4QQTJ48Gbt27QIALF++3GRGOAAMWT4EN/55A7SNoulqExS3FDAfxH0yqTmPh+NB\nQViSlwceIZhsZ4dBXCaxvv22puV9dTVga3vfGOKTPCd1GuJDrIfg8+mfw9fB1+BynnhCY4BTqlni\n44H58w0uhsFg/AZcXFxUe/fuLdauP/fcc+42NjbqtWvX3l67du1tU+rGuHf0+p7Z4cX+GsA3AOSE\nEHc9z0uglPpQSr0opf/s2La+JyOcUvpYf95wBuNhRLfdfYqJA3b5A/mwCbfpXK/+lsOW8z3wsY8P\ntkskmObgAEs+h1WlhEKNEQ50xYebKDZfl8c9u6q6lMvLETYkDBYCw7uqLSyAwYO71s+fN7gIBoNh\nIOLi4or7P4pxv9KvIU4ImU4IyQdwHcBZAEUAvuVYLwaD0UFERERnLPTPP/+M2tpatLX1mrfDOQM8\nB3SOy3YZv/VimUKBr8rLoeKy46Vuu/tjxzSJm488wp08PRkkGoQApwAAQLu6HWdvnOVM1oIFXeNq\n475vMRgMxkODPh7xTQAeAZBHKR0GTcz3BU61YjAYndjb2yM0NBSAJgs9ICAAf/3rX02mD29A12ND\nfllutHb3ADAlIwODLl7Eszk5eC47G5cb+0yM/+34+2uKaQOAQgH8+iuQkaGJGzcxuu3uP7n0CRaf\nWIwfSn4wuJx58zTVU1auBP72N4NfnsFgMBjQzxBvp5RWQ1M9hUcpTQYwnGO9GAyGDpN1PLS3bt1C\nUlJSn7VTucT5OefOMVVQNP7CkTHcAy5mXUnwe2/fxjdcuWrvbHev5T7o+a5riB/PP45PUj/BkZwj\nBpcTGAikpwNbtgCjRgGsciyDwWAYHn0M8TpCiBWA7wH8lxDyfwCU3KrFYDB0efbZZ3Hw4EHY2Gji\ns0tLS5GdnW0SXUQjRDB3N4dloCXc17h3C1Xhmslicbf1pJqaXo40hDCd8BQXF+DAASAmhjt5ejJ+\n6HiY8c1gZ9FVWz2pMIkTWT/+CEydCojFGs84g8FgMAyLPvXAZwBoAbAMwDMAbAC8yaVSDAajO1Kp\nFFKpFBcuXEB7ezsmTZqEoUOHmkQXwiN49MajJpH9uE5jHwCQDRzIXT1x3Xb3VVVAVNR90WJyoNlA\n5L6SC7GFGPbv2sNb7I3x7uM5qSdOKZCYqBkfP65Z57J0O4PBYDxs9GmIE0L4AL6hlD4OQA1gj1G0\nYjAYPbJt2zZTq2BSnM3MEDRwIH5t0vSzmOHgwF1TH2dnYPhw4PJlYMAAIDsbGDOGG1n3iIetBwDg\nVuwtOA505ExOUBAgEABKpSY0JT0d6EhXYDAYDIYB6NN9QilVAWgmhNj0dRyDweCe9vZ2XLhwARs2\nbMC6detMrQ7aa9px+8BtXH3yKuRX5UaTqxuecorL0BRAU0/83DmgrAxoaQHWrAH27+dW5j3gONAR\naqrmLF9g4EBNWIqW+yBXlcFgMB4o9AlNaQVwhRCSBKCzrSqldClnWjEYjLvIz89HeHg4AGDgwIGQ\ny+WYN28eRo8ebRJ9UoNTobjZ0eWZAgHxAUaRO8nODltLSgAAJ2tqcKG+HmE2HPkKtHHiu3YB2kZK\nUVHA3LncyLsH/pf5PxzOOYzThadxdN5R1LfWY7LXZIN/IViwQNPmHtDkqt4HYfIMBoPxwKBPQOEJ\nAOugSdZM01kYDIYR8fPzw6BBgwAATU1N+OCDD3D48GGT6WMVatU5rvu+zmhyx9nYQFs7Jb+lBeG/\n/ILrLS3cCtWtoHL2rKakoYk5mH0Q+67uQ2VzJcK/CEfUf6OQVdlv0+N7Rnfq2t5GDAaDwTAMvRri\n2u6ZlNI9PS3GU5HBYACadveT7iipd8qElpHLcy6dY2W1EopbxjFOB/D5SAwORqStLdQd207V1nIn\nsKFBU0PcxkbT7v6pp4D6eu7k6YluGUMVVQEATl0z/L+H8eM1jUYBICsLOGL4SokMBoPx0NKXR7zz\ncUsIOWQEXRgMRj/o1hM3NzfHqFGjoFar+ziDO8TRYliHdVURqU3i0Bi+g4l2dnjC3r5z/aeGBu6E\n7d4NzJypMb4jI4G4OMDJiTt5eqJriGv59favBpdjaQk46uSDfv65wUUwGPc1fD4/VCqVyiQSif/U\nqVM9Gxsb9SpPVFBQIBwzZoyPp6env7e3t/+mTZs6HxzNzc0kMDDQz9fXV+bt7e2/bNmyQdp9mzZt\ncpJIJP7e3t7+b775Zq8Pm2vXrgl37dpl19t+rjh48KC1h4dHgLu7e8Dq1atdejtu48aNTt7e3v4S\nicR/2rRpw5qbmwkAzJkzx0MsFgdLJBJ/42l978TGxg5av369c/9H/j76+sekG2joybUiDAajfx7X\nKanX3t6Od955BzyeYUvW6Qvfgg+HaQ6d6zWnOE6cvIPpDg5438sLmaNGYbevL3eCdOuJnzkDqFTc\nyboHhtoOhUQs6Vz/z6z/4N8z/s2JrMjIrvEPhm/iyWDc15ibm6tzcnKy8vPzM4VCIX3vvff0KlUk\nFArx3nvv3SwsLMy8dOlS9u7du53S0tIsAMDCwoKeP38+Nzc3NyszMzPrzJkz1mfOnBl46dIli7i4\nOMf09PTs7OzszMTERNsrV66Y93T9hIQE6/T0dEtDzrU/lEolli1b5p6QkJCXl5eXeejQIbF2Trpc\nv35duHPnTufLly9n5efnZ6pUKvL555+LAeDPf/5z1dGjR/ONqff9TF+/4LSXMYPBMBFOTk4ICQkB\noGl3/91335lUH7tJXc6Ymm9rjNruXq5SoVmtxqK8PFyWc1i1RSYDOmLzUVen6XJz8eJ9F56SeTuT\nMznaPFVA4yE3UVNXBsPkhIeHywsKCsxzc3PNdD2669evd46NjR2ke+zQoUPbw8PDmwHAzs5O7eXl\n1VJcXGwGADweDzY2NmoAaGtr+//s3XlcVPX+P/DXmRmYYRmGfReQdRg2RTITFIVUlFTELKUsu2Xd\n8mZuLWqay71ZfdVKu97M/JXermkpmiKBZqJEagKB6Dgs4gCiIMg67DNzfn8cGQYFFJszo/B5Ph4+\nPOfMmXl/Brvcz3zm/Xm/KaVSSVEUhby8PJPQ0FCFUChUGxkZITw8vHHfvn2Wd44jNTXVfNWqVUOS\nkpKsxGKxRCaTGd95DxvS0tLM3N3d2yQSSbtAIKDj4+Nr9u/ff9f4AEClUlFNTU2cjo4OtLS0cFxd\nXTsAYPLkyQo7O7teG0M2NDRwxo0b5+3n5yfx8fEJ0F7137Ztm3VQUJC/WCyWJCQkuCuVzMt88cUX\nNr6+vhI/Pz9JXFzcUABYs2aNg4+PT4CPj4/mm4X8/HxjT0/PgNmzZ7t7e3sHhIeH+ygUCs3C87vv\nvuvo4eEROHr0aN/CwkL+vcajC31NxEMoimqgKKoRQPDt4waKohopimLxe2CCIPoyadIkzXFycjJO\nnTplsHb3xi7GoHjM7zBlrRKNOfprd/9xaSlWXr2K0/X1SGGzjCFFdV8Vf/JJYPTork43BjTBq2si\nfqyYyQ9n47+F8HBgyxZAJgPKykhTH2Jw6ujoQGpqqkVQUFC/d4fn5+cbS6VS08jISM2qgVKphFgs\nljg4OIRERkY2REVFNQ0bNqzl3LlzwoqKCm5jYyPn+PHjorKysrsm2ZMmTVIEBQU1JSYmFslkMqlY\nLG5/0Pc1YsQIP7FYLLnzz6FDh4R33ltWVmbs4uKiieXq6tpeXl5+1/iGDh3asWDBgoqhQ4cG29vb\nhwiFQlV8fPx9zR0TExMtHB0dO/Lz86WFhYWXOp+XnZ0t2L9/v3VmZqZMJpNJORwO/eWXX9pkZmYK\nNm7c6HTq1KmC/Px86fbt20vT09NN9+zZY5OVlXU5MzPz8u7du+0yMjJMAKC0tFSwcOHCm0VFRZdE\nIpFq9+7dVgCQnp5uevDgQeu8vDxpUlJSUW5urllf49GVXifiNE1zaZq2oGlaSNM07/Zx57nh28sR\nxCA1adIkWFlZwc3NDbt378a4ceNw8eJFg4zF2M4Y4Had153QX/WUSVoFrjeVlWFSbi57wbQn4q2t\nzN/H2Wkr3x/jPcaDSzH/ANk3sjF+13g8sVP3XU8pCnjzTcDPj0zCCcMpWlLknEaljUij0kb8EfCH\nv/ZjGfYZwZ2PlW4s1eTMVe6pFHVeT6PSurWjqkuvu6+0jra2No5YLJYEBQVJXF1d2996663q/oy7\nvr6eEx8f7/XRRx+VWVtbazb18Hg8yGQyaWlp6YXs7Gyz8+fPC0JDQ1vfeuutiqioKN/x48f7SCSS\nZh6v50rTxcXFguDg4DYAkEqlxs8884x7TEyMJpV469atNqtWrXKYPXu2e3R0tFdiYmKPc7esrKx8\nmUwmvfNPXFzcXSsrPX3QpyjqrotVVVXco0ePWhYVFeVVVFRcaG5u5mzbts36rif3IDQ0tCU9Pd3i\n9ddfd0lJSTG3sbFRAUBKSorw4sWLpiEhIf5isVjy22+/WRQXF/NTU1Mtpk6dWuvk5KQEAAcHB1Va\nWpr5lClT6iwsLNQikUgdGxtbe/LkSSEAuLi4tI0ePboFAIYPH94sl8v5AHDy5EnzKVOm1AmFQrW1\ntbV64sSJdX2NR1cMk1xKEMQDGzNmDKqqqvD444+j7XYZPUNVT6E4FCwju76V5Aq5fdytWxO12t3f\nUirxS20tajs62AmmnSTdKTubnVj9IBKI8PLwl/H26LfB4/CQJk/DufJzuNF4g7WYJSXAt9+S9BRi\n8OjMEZfJZNJdu3aVCQQCmsfj0dob5VtbWzkAsGHDBrvOFWW5XG7U1tZGxcbGes2aNavmxRdf7HGl\nwtbWVhUREdF45MgREQAsXry4WiqVXs7MzMy3trZW+fj4tN75nIqKCq5QKFTx+XwaACQSSfsPP/xQ\non1PVlaW6dq1ayv37t1bsnfvXvnevXt7TKnoz4q4m5tbtxXwa9euGTs7O9/1i/fIkSMWbm5ubc7O\nzko+n0/HxcXV/f777+Z33teT4ODgtuzsbGlQUFDLypUrXZYtW+YEADRNU7NmzbrV+W8hl8svbt68\n+TpN03d9GOjrm0FjY2PNg1wul1YqlZrlhZ76MPQ2Hl0hE3GCeMRwuVxwudxuFVQyMzMNNh6399zg\nu8MXo+Sj4PJ3F73FdeTzEWJmpjlXAzjBVhlDe3vgdm4+AKbDjQF/5tq2T92OTyZ8ggi3CM01NsoY\nAkx7ew8P4KWXmFR5ghisXF1dlTU1NbyKigpuS0sLlZqaKgKA5cuXV3VOFN3c3Dpmz57t7uvr27pm\nzZpK7edfv36dV11dzQUAhUJBpaWlWfj7+7cCQHl5OQ8ACgsLjY8ePWr58ssv35V7V1BQwHdwcOg1\nHaWtrY3i8Xh052b+FStWOC1cuLCqp3v7syIeGRnZJJfLBTKZzLi1tZVKTEy0njlz5l0fMDw8PNqz\ns7PNGxsbObf3Mwk739+9yOVyI6FQqH7jjTdqFi1aVJmTk2MKADExMQ1JSUlWnT+fyspKbkFBgXFM\nTEzD4cOHrSsqKrid16OiohTJycmWjY2NnIaGBk5ycrLV+PHj+8ydjIqKUhw9etRSoVBQtbW1nOPH\nj1v2NR5duZ/OmgRBPISmTJmCzZs3Y9iwYRg3bpzBxmE13gpW4/VeQQsAk56S28Q0/H1CKMQI4V0L\nOLozcSKgUDB/R0UBBqpW05s4vziYGZlhotdEjB86npUYxcVdx199BTyh+ywYguiV92bv696bva/3\n9Fj4zfAea3c6JDjUOyQ49NiE0HKMZfODjoXP59NLly69MXLkSH9XV9c2b2/vuyaZx48fNz906JCN\nj49Pi1gslgDA2rVry5999tn6srIyo3nz5g1VqVSgaZqaPn16zZw5c+oBYNq0aV51dXU8Ho9Hf/bZ\nZ6V2dnZ3pUKEhIS01tTUGPn4+ARs27ZNPmHChCbtx1NSUszHjh2rUKvVWLBggUtsbGx958bRv+J2\nJZjSmJgYX5VKhYSEhOqwsLBWAIiMjPTetWtXiYeHR0dUVFTT1KlTa4ODg/15PB4CAgKalyxZUgUA\nU6dOHXr27FlhbW0tz8HBIfi99967vnjxYk26T1ZWlsny5ctdORwOeDwevW3bthIAGDFiROv7779f\nHh0d7atWq2FkZERv2bKlNDo6umnp0qU3xowZI+ZwOHRgYGDzgQMH5AkJCbdCQ0P9AWDu3LlV4eHh\nLfn5+b1uao2IiGieMWNGTWBgYICLi0vbyJEjFX2NR1coQ23yelBhYWG0IVf/COJh0NraijfffBOp\nqamora3FrVu3YGysl03zPVIqlKhLq0PtsVoIPAQYsmSIXuL+WluL6Nu54V4CAYpGjWIvWEdHV2eb\nTjT90CRNN7Y14qT8JEIcQuBu6c5KjMmTu/aohoQAOTmshCHuQFFUFk3TYYYeh77l5ubKQ0JC+pWP\nPVhVVFRwlyxZ4pKenm7x/PPPV9fX13M3bNhwY+vWrbbff/+9TUhISNOwYcNa3nnnnR5XxQl25ebm\n2oaEhHj09BhZESeIRxCfz8eJEydQVlYGADhz5gzGjh3bY36bPlTtr0L+S/kAACM7I71NxMNFIphy\nOGhWq3GltRVXWlrgZWLCTrDOSbhKBezaxfR7/+MPID//7gm6nq0/tR7rT69Hh7oDHz/5Md4Jf4eV\nOPPnd03E2awYSRBE/zg6Oqr27NlT2nn+wgsvuIlEIvX7779/8/33379pyLERfXu4vlslCOK+UBTV\nrYzh/PnzMXbsWIONh2fR9Zm+o6oDbTf00+6ez+Fguq0tptvY4J8eHjhSXY2fb91iNyiHA6xfD+zb\nB1y9+lAkSw8RDUGHmtkvdVB2EFvPbcUBqe4bIsfGMnXEAeDKFeYPQRAPn927d5fe+y7iYUAm4gTx\niNLerFlYWIjffvsNN26wVy2jL9aTrLv14q36UX/ffu6RSPC0nR3el8ux+MoV/Lu8nL1gublMu3vt\nGA9BGcOJXl3/LZy9dhYLUxbii/Nf6DwOnw+M10o/T0rSeQiCIIhBhUzECeIRFRUVBS63e7nAX375\nxSBj4ZpxYSru2khen6HfrpOjRSLN8cm6OrRplRXTKSMj4PBhJl+cywVWrwaefpqdWP3gLHRGsENw\nt2sZpRlQtOs+fySiqzgLVq3S+csTBEEMKmQiThCPKJFIhCe0ylbMnj0bo0ePNth4/P/b1V+j7lSd\nXtvde5qYwEsgAI+iEGRmhpvtD9xkrm/+/oDL7RKNKhWzezE4uO/n6Mkkr65UJS7Fxfih41HVpPtv\nJmJiuo4bG5nsHIIgCOLBkIk4QTzCtPPEjY2N4eXlZbCxmA83B8+GyRXvqOxAU17TPZ6hO3srK9Gm\nVkNJ04i2ssIQgYCdQHe2uzdQI6WexHh3zZDdRG5IfT4VQ62G6jxOSAigvR/25591HoIgCGLQIBNx\ngniEaeeJnz59us9uYmyjOBQso7u6bFbuqezjbt0y5nBw7fYqeGrNXb0vdEt7Ip6UBPz3v0yrSQML\nHxIOUyMmPehq3VUU1RSxEoeigM8+A159FThwAEhIYCUMQRDEoEDKFxLEI2zEiBF45513MG7cOHh6\nemLnzp2wt7fHtGnTDDKejsquTseqxrt6ULAm2soKXAAqANkKBfIUCgwVCGDOY+FX3JNPMrNRmgbO\nnwdeeAHw9ATmzdN9rH7g8/gY7zEeRwuPwtPKE+UN5eBSXFgKLGFlotuGS6++qtOXIwiCGLTIijhB\nPMK4XC4+/vhjKBQKiMVizJ8/H1u3bjXYeBznOmqOWwpb9BZXxONhlIUFAIAGEJyZicNslTG0tQVC\nQ7tfKy4GithZge6PD6M/ROGbhXh79Nt45cgr8NziiR+lP7Ias64OaP7L/foIgiAGJzIRJ4gBQHuT\nZnp6OpoNNDOymsSsvHJMOeBacPWaKjPJ2rrb+TE2U1S001MA4PHHAbZTYu5DsEMwvK290dLRoklN\nOXaFnTz2r78GAgMBa2tg6VJWQhAEQQx4ZCJOEAOAra0tPDw8wOFwEBYWhoqKCoOMQ+AqwPCM4Yio\niYBknwRt1/TT2Ae4eyJ+oq6OvQ8Cs2YBH37IJElXVDBNfUaOZCfWA5jk3bWJN700HWpa9+Ucf/4Z\nuHSJydA5eFDnL08QBDEokIk4QQwAERERkMvlUKvVWLlyJTw9PQ02Fv4QPqQJUmTYZiDvqTy9xR0h\nFMJKq676Hn9/UBTVxzP+guHDgeXLgfh4wMGBnRgPqEJRgVPyU/C18cVzQc/hysIr4FC6/1X/t791\nHVdWAvX6LR1PEHqRn59v7OPjE6B9bcmSJc6rV6/u9j/8oqIio8cff9zX09MzwNvbO2D9+vX2nY81\nNzdTQUFB/n5+fhJvb++AxYsXO3c+5uLiEuTr6ysRi8WSwMBAf/TiypUrRjt27NDtZo/7sH//fgsP\nD49ANze3wBUrVjje+Xhf77uTUqmEv7+/ZPz48d76GXX/9fRvqi9kIk4QA4B2e/vU1FQDjgTgWfFw\n68gtqOpVaLrQpLd291yKwsTbq+I8ikJpm/5W4wEAVVVAWZl+Y/bgj/I/8EbyGyi4VYC8m3kwNzZn\nJc6kSUxPo07Z2ayEIYhHgpGRETZt2nStuLj40vnz5y/v3LnTPisrSwAAAoGA/u233/Lz8/Olly5d\nkp44ccLixIkTZp3PPXXqVIFMJpNevHjxcm+vn5ycbJGdnW3a2+NsUCqVWLx4sVtycnJBQUHBpQMH\nDlh3vqdOfb3vTv/85z8dvL299bdp6BFDJuIEMQBolzFMTU3F9evX0dDQYJCxcM24MLIz0pzf/P6m\n3mIvdHXFocBA3AoPx3P6WKmurgZWrgQ8PJiV8X/9i/2Y9zDeYzyMOMzP/0LlBVxvvM5KHB6P6WfU\nKSeHlTAE8Uhwd3fviIiIaAYAKysrtZeXV0tpaakxAHA4HIhEIjUAtLe3U0qlkurPt3Wpqanmq1at\nGpKUlGQlFoslMpnMmJU3cYe0tDQzd3f3NolE0i4QCOj4+Pia/fv3W2rf09f7BpiV/NTUVNH8+fOr\ne4rR0NDAGTdunLefn5/Ex8cnQHvVf9u2bdZBQUH+YrFYkpCQ4K5UKgEAX3zxhY2vr6/Ez89PEhcX\nNxQA1qxZ4+Dj4xPg4+MTsG7dOnuA+TbD09MzYPbs2e7e3t4B4eHhPgqFQvODf/fddx09PDwCR48e\n7VtYWMi/13jYQibiBDEAjB07FoLbTWxkMhlcXFxw4MABg4yFoihwTLp+tVT+T3/1xEeLRJhua4us\nxkYsLy7GE9nZaFGxVEbx6lXA3p7JFS8pYZKlk5OZvw1IyBci3C1cc/7SoZcQ9J8g1LbU6jyWdpVM\nA38RQxAPjfz8fGOpVGoaGRmp6LymVCohFoslDg4OIZGRkQ1RUVGajmfR0dE+AQEB/hs3brTt6fUm\nTZqkCAoKakpMTCySyWRSsVj8wK2DR4wY4ScWiyV3/jl06JDwznvJCZBZAAAgAElEQVTLysqMXVxc\nNLFcXV3by8vLe/0Q0NP7XrBgwZBPPvnkGofT83QzMTHRwtHRsSM/P19aWFh4KT4+vgEAsrOzBfv3\n77fOzMyUyWQyKYfDob/88kubzMxMwcaNG51OnTpVkJ+fL92+fXtpenq66Z49e2yysrIuZ2ZmXt69\ne7ddRkaGCQCUlpYKFi5ceLOoqOiSSCRS7d692woA0tPTTQ8ePGidl5cnTUpKKsrNzTXrazxsIhNx\nghgATExMuqWnAMAxA3Z9tJtppzluutAEdZvuNwv2ZUFhIT4qLcXZhgacZit52cOjq919p2vXgCtX\n2InXDzFeXV02jxUfw8WbF/Hr1V91Hke7eMzJk4BcrvMQBKGxZMkSZ4qiRvT2x97ePrg/9y9ZssS5\nt1idelu57u16fX09Jz4+3uujjz4qs7a21vzi4/F4kMlk0tLS0gvZ2dlm58+fFwBARkaGTCqVXj52\n7Fjhjh077H/++ecec8mKi4sFwcHBbQAglUqNn3nmGfeYmBjNZqCtW7farFq1ymH27Nnu0dHRXomJ\niRY9vU5WVla+TCaT3vknLi6u8c57e9rsTlFUjysNPb3v77//XmRra6scM2ZMr2W8QkNDW9LT0y1e\nf/11l5SUFHMbGxsVAKSkpAgvXrxoGhIS4i8WiyW//fabRXFxMT81NdVi6tSptU5OTkoAcHBwUKWl\npZlPmTKlzsLCQi0SidSxsbG1J0+eFAKAi4tL2+jRo1sAYPjw4c1yuZwPACdPnjSfMmVKnVAoVFtb\nW6snTpxY19d42EQm4gQxQGi3uwcM22nT6RUncEVMAjGtpFF3uk5vsZVqNQLNNOmX7JUxpChgypSu\n89hYZteit+H3I2m3u++UekX3S9bu7kxZdQBobwe2bNF5CIIwKAcHB2V9fT1X+1pNTQ3X1tZWuWHD\nBrvOFWW5XG7U1tZGxcbGes2aNavmxRdf7PGXnq2trSoiIqLxyJEjIgDw8PDoAAAXFxdlbGxs3Zkz\nZ8zufE5FRQVXKBSq+Hw+DQASiaT9hx9+KNG+Jysry3Tt2rWVe/fuLdm7d6987969PaZU9GdF3M3N\nrdsK+LVr14ydnZ077ryvt/f922+/mR8/ftzSxcUlaN68eZ5nz54VTp8+faj2c4ODg9uys7OlQUFB\nLStXrnRZtmyZEwDQNE3NmjXrVucHBblcfnHz5s3XaZq+68NAX/8/Z2xsrHmQy+XSSqVS8wmqpw9T\nvY2HTWQiThADhHaeuKmpKfLy8tirGnIPpj6mcJzXtcH+VhJLzXV6kFZXhx+rqgAAFlwuJlixmOI3\ndWrXcXExYGfX+716FOwQDEfzrp9/vDgesySzWImlvSpeXMxKCIIwGJFIpLa3t+/46aefhABQWVnJ\nTUtLE0VFRSmWL19e1TlRdHNz65g9e7a7r69v65o1a7rl412/fp1XXV3NBQCFQkGlpaVZ+Pv7tzY0\nNHBqa2s5AJObfPLkSYvg4OC7NjUWFBTwHRwcek1HaWtro3g8Ht2Z/rFixQqnhQsXVvV0b39WxCMj\nI5vkcrlAJpMZt7a2UomJidYzZ87s9gFDrVajt/f973//u7yysvJCeXl53rfffls8atSoxp9++umq\n9j1yudxIKBSq33jjjZpFixZV5uTkmAJATExMQ1JSklV5eTmv8+deUFBgHBMT03D48GHriooKbuf1\nqKgoRXJysmVjYyOnoaGBk5ycbDV+/Pi73o+2qKgoxdGjRy0VCgVVW1vLOX78uGVf42ETaXFPEANE\nQEAAXFxcoFKpuk3KDcXmKRuUf14OAGj8o8/fiToVIRJBQFFopWk0qFQQm7L4ezQqChAIgNZW4PJl\nJi3Fy4u9ePeJoihM8pqEXbm7AAAhjiGY4DWBlVirVwN79jDHUimTIm+gz3/EALd58+brmzdvvu/d\nx/29vze7du26+sYbb7i9++67QwDg3XffvR4QENCtLNPx48fNDx06ZOPj49MiFoslALB27dryZ599\ntr6srMxo3rx5Q1UqFWiapqZPn14zZ86ceqlUajxjxgxvAFCpVNTMmTNvPf3003flJIeEhLTW1NQY\n+fj4BGzbtk0+YcKEJu3HU1JSzMeOHatQq9VYsGCBS2xsbH3nBsq/4nZFlNKYmBhflUqFhISE6rCw\nsFYAiIyM9N61a1dJfn4+v7f3fT8xsrKyTJYvX+7K4XDA4/Hobdu2lQDAiBEjWt9///3y6OhoX7Va\nDSMjI3rLli2l0dHRTUuXLr0xZswYMYfDoQMDA5sPHDggT0hIuBUaGuoPAHPnzq0KDw9vyc/P7zWf\nPSIionnGjBk1gYGBAS4uLm0jR45U9DUeNlGG+ur6QYWFhdGZmZmGHgZBPJTKy8vh7OxssJVwbapm\nFfLn50PdpkZ7ZTuGnx6ut3FNvnABKbdTUr709cVrzvdMBX1wU6cCSUnMcUwM02Fz2TKm6Y8B/Xjp\nR2z5YwsmeU3CDPEMBNgH3PtJD4CmgS++AMaMAYKDgV72ZBF/AUVRWTRNhxl6HPqWm5srDwkJ6bHa\nxmBWUVHBXbJkiUt6errF888/X11fX8/dsGHDja1bt9p+//33NiEhIU3Dhg1reeedd3pcFSf0Lzc3\n1zYkJMSjp8fIRJwgBqBz587h0KFDOHLkCI4cOYKhQ4fe+0k6pu5QI8M2A6oGZq9LWF4YzAPZqWl9\np8/KyrD49qbJMSIRXnR0xMtOLKX6ffUV8Npr3a+98AKwaxc78R5Au6odJ6+eRP6tfCx8fKHOX5+m\ngcJCpnKKWAxMYGfxfdAiE3GiLy+88ILb7t27Sw09DqJ3fU3EydoFQQxA69atw0cffYRLly7hyJEj\nBhkDx4gD65iutvP6zBPXbnefXl+PfxQWoomtMoZPPcX8rZ2S8vPPgFq/lWJ6U9daB7v/s0PM/2Kw\n7Ngy1LfqvorMf/4D+PkBCxcCW7fq/OUJgugDmYQ/2shEnCAGmLS0NNy61TXpPXz4sMHGYvOUDQQe\nAlhPsUZ9ej06au7acM8KsakpXPl8zXmrWo3jbFVPcXYGysuBggJmNvrss8CmTQBbE/9+shRYwsPS\nAwDQoe7Az0U/6zzGk092HR85Aly4oPMQBEEQAxKZiBPEAHPu3DmcO3cOAODm5oaFC3WfinC/HBIc\nYORkhJrkGuZPKkuT4TtQFIXJWqviZhwO6tmcGDs7M8nRly8De/cCc+cCRkb3fh7LyhvKMerrUbhQ\nycyM3UXuaFc9cC+QXvn6AuZaWUeffqrzEARBEAMSmYgTxAAzffp0zfGtW7cwwYAJuxSXgs0Um67x\nHNVfesp0W1uYcziYaGWFHwMC8KKj472f9FdRFNDY+NCshjuYO0BWLdOcJ81JwgshL7ASa8yYruOf\ndb/oThAEMSCRiThBDDBisRh+fn4AgKamJpw4ccKg47F5qmsiXn2wGmqlfnKnJ1lZ4VZEBFJDQjDZ\nxubeT/irvvsOmDQJsLEBvvkGWLeOafBjQDwOD096duWNpFxJYS3WP/7Rddze/tB8FiEIgniokYk4\nQQxA2qvi27dvx8qVK6FUKg0yFp41D7hdtVDdrEZdun66bPI4HBhr1dLrUKtxteWuXhm6k54OHDsG\ndHQA8+cDH3zwUCwNT/aerDk+nH8YrcpWSKukOo8TEwM4ODDHtbXA2bM6D0EQBDHgkIk4QQxAcXFx\nmuOkpCR8+OGHyMjIMMhYBEME4Jp3dYi+sf2GXuPfaGtDglQKm4wMTGZzF6F2l81OR4+yF+8+TfWb\nCur2J6H00nTYfGKDyf+b3Gdb6AfB4XT/Efz0k05fniAIYkAiE3GCGIAef/xxOHQuT95mqOopFEVB\nNFakOa//Xffl83pD0zQ+LC3F3ps30ahSIb+lBfnNf7nhXM86u2x2srAAtDaMGoq9mT0i3CI0580d\nzSitL0VuZa7OY8XFAVwuIJEAp08DbP2oCYIgBgoyESeIAYjD4WDatGmaczMzMwiFQoONx+sTL1DG\nzKpse1k7Wq6ymCKihaIo5Dc3Q3vt9xhbZQxNTbvX8fvgA2D7dnZi9VO8f/xd1369+qvO40yYAPj4\nMK3uz50DfvlF5yEIgiAGFDIRJ4gB6rnnnsOiRYuwfft21NbWYs2aNQYbi5nEDFZPWsHU3xRDlg0B\nxdNPq3sAiLO11RyPFArxDxcX9oJp52YkJ7MXp59miGdojt1F7rjw9wtYPGqxzuMYGwNa2xNIegpB\nEMQ9sDoRpygqhqKofIqiiiiKeq+Hx5dQFCWlKOoCRVEnKIpyZ3M8BDGYREZG4tNPP8Wrr74Ko4eg\npnXAjwEYKR0Jj7UeoJW6zU/uyzStiinZCgXq2Ny02tllEwBOnWJ2LeblsRfvPrlbuuO7Gd+hdFEp\n5IvkCHIIAkWx82Fo+nSmiuPo0Ux/I4J41HG53BFisVji4+MTMHnyZM/Gxsb7mjsVFRUZPf74476e\nnp4B3t7eAevXr7fvfKy5uZkKCgry9/Pzk3h7ewcsXrzYufOx9evX2/v4+AR4e3sHrFu3zr7nVweu\nXLlitGPHDqu/9u76b//+/RYeHh6Bbm5ugStWrOixLmxf793FxSXI19dXIhaLJYGBgf76G3n/LFmy\nxHn16tUO977zr2FtIk5RFBfAvwFMBiABMIeiKMkdt/0JIIym6WAA+wF8wtZ4CGKwUyqVyM7ONlj8\n1tJWXHjqAjJsMiB7SXbvJ+iIq0CAx26n5ShpGslspaYATGOfESOYY6WSaXsfHAyUlLAX8z49F/wc\nhoiGdLum6w2bADByJPD220BTE/Dee0BFhc5DEIRe8fl8tUwmkxYWFl4yMjKiN23aZHc/zzMyMsKm\nTZuuFRcXXzp//vzlnTt32mdlZQkAQCAQ0L/99lt+fn6+9NKlS9ITJ05YnDhxwuz8+fOC3bt322Vn\nZ1++fPnypZSUFMu8vDx+T6+fnJxskZ2dbarL93ovSqUSixcvdktOTi4oKCi4dODAAevO96Str/cO\nAKdOnSqQyWTSixcvXtbn+B9GbK6IjwRQRNN0MU3T7QD2ApiufQNN0ydpmu7cznMWgCuL4yGIQUmh\nUGD8+PGwsLDAY489hlu39NdURxvPkoeaozVQt6pR/1s9mvP1t5NPOz3lveJizLvM4u/+t94CNm4E\nxo5lVsSBhypNpaGtATuzd2La99MwY9+Mez+hn7hcJj88NxegaablPUEMFBEREYqioiJ+fn6+sY+P\nT0Dn9dWrVzssWbLEWfted3f3joiIiGYAsLKyUnt5ebWUlpYaA8w+HpFIpAaA9vZ2SqlUUhRFIS8v\nzyQ0NFQhFArVRkZGCA8Pb9y3b5/lneNITU01X7Vq1ZCkpCQrsVgskclkxuy+c0ZaWpqZu7t7m0Qi\naRcIBHR8fHzN/v377xpfX+/9XhoaGjjjxo3z9vPzk/j4+ARor/pv27bNOigoyF8sFksSEhLcO8vy\nfvHFFza+vr4SPz8/SVxc3FAAWLNmjYOPj0+Aj4+P5puF/Px8Y09Pz4DZs2e7e3t7B4SHh/soFArN\n14Pvvvuuo4eHR+Do0aN9CwsL+fcajy6wORF3AVCmdX7t9rXevAzA8EV3CWIAaWlpgbOzM9LS0tDS\n0gK1Wo1kA00K+Y58mEpuL96ogMJ/FOottvZE/FpbG36sqkILWx1n5s4Fli4FZs3quvar7jdGPojS\n+lJs+n0TXjnyCo4UHEFyYTLqW3VfxUY7T3zbNp2/PEEYREdHB1JTUy2CgoL6vds8Pz/fWCqVmkZG\nRio6rymVSojFYomDg0NIZGRkQ1RUVNOwYcNazp07J6yoqOA2NjZyjh8/LiorK7trAjtp0iRFUFBQ\nU2JiYpFMJpOKxeL2B31fI0aM8BOLxZI7/xw6dOiuHf5lZWXGLi4umliurq7t5eXlfU6we3rv0dHR\nPgEBAf4bN260vfP+xMREC0dHx478/HxpYWHhpfj4+AYAyM7OFuzfv986MzNTJpPJpBwOh/7yyy9t\nMjMzBRs3bnQ6depUQX5+vnT79u2l6enppnv27LHJysq6nJmZeXn37t12GRkZJgBQWloqWLhw4c2i\noqJLIpFItXv3bisASE9PNz148KB1Xl6eNCkpqSg3N9esr/HoCpsT8Z4SEHv8HpSiqOcBhAH4v14e\nf5WiqEyKojKrqqp0OESCGNhMTEwQFhbW7VpaWpphBgPA7umub3SbLjWBVusnV9zf1BS+Jiaa82a1\nGr/WsdxYaOpUJjfj9Gng++/ZjXWfvsr6CutOr9Ocd6g78HOR7tc/tAr2ICcHMGBGFDGALFmyxJmi\nqBEURY0ICAjolltsb28f3PmY9uRuz549os7rFEWN0H5Oenr6faV1tLW1ccRisSQoKEji6ura/tZb\nb1X3Z9z19fWc+Ph4r48++qjM2tpa01qYx+NBJpNJS0tLL2RnZ5udP39eEBoa2vrWW29VREVF+Y4f\nP95HIpE083i8Hl+3uLhYEBwc3AYAUqnU+JlnnnGPiYnx7Hx869atNqtWrXKYPXu2e3R0tFdiYqJF\nT6+TlZWVL5PJpHf+iYuLa7zz3p7S2SiK6vUXeU/vPSMjQyaVSi8fO3ascMeOHfY///yzufZzQkND\nW9LT0y1ef/11l5SUFHMbGxsVAKSkpAgvXrxoGhIS4i8WiyW//fabRXFxMT81NdVi6tSptU5OTkoA\ncHBwUKWlpZlPmTKlzsLCQi0SidSxsbG1J0+eFAKAi4tL2+jRo1sAYPjw4c1yuZwPACdPnjSfMmVK\nnVAoVFtbW6snTpxY19d4dIXNifg1ANoJia4Art95E0VRTwJYCWAaTdNtPb0QTdNf0TQdRtN0mJ3d\nfaVmEQRxm3ZznyeeeAI7duww2Fg8VnuAZ8P8n0r7jXYo/lTc4xm6QVEUNnh64mlbW4wwN8d6Dw8E\nmLKcWmlkBAwdCly9CvTyf6T6pl3GkEtx8VH0RwgfEq7zOF5egHa1zM8+03kIgtCbzhxxmUwm3bVr\nV5lAIKB5PB6tVmvm1GhtbeUAwIYNG+w6V5TlcrlRW1sbFRsb6zVr1qyaF198scdP/7a2tqqIiIjG\nI0eOiABg8eLF1VKp9HJmZma+tbW1ysfHp/XO51RUVHCFQqGKz+fTACCRSNp/+OGHbptRsrKyTNeu\nXVu5d+/ekr1798r37t3bY0pFf1bE3dzcuq2AX7t2zdjZ2bmjp9ft7b17eHh0AICLi4syNja27syZ\nM2bazwsODm7Lzs6WBgUFtaxcudJl2bJlTgBA0zQ1a9asW53/FnK5/OLmzZuv0zR914eBvva/GBsb\nax7kcrm0UqnULBz3tIm9t/HoCpsT8fMAfCiKGkpRlDGA2QC6dRShKGo4gO1gJuE3WRwLQQxa2u3u\nMzMzoVDoZ/LbE4pLwWZKVxWTW0n6y1ePt7PDvoAAZIaF4X0PD3horZDr3KlTgIsL8NprwEcfMdfY\nSoXph+GOw+EuYopTqWgVQp1C79rAqSuRkV3Hf/zBSgiCMBhXV1dlTU0Nr6KigtvS0kKlpqaKAGD5\n8uVVnRNFNze3jtmzZ7v7+vq2rlmzplL7+devX+dVV1dzAUChUFBpaWkW/v7+rQBQXl7OA4DCwkLj\no0ePWr788st37TAvKCjgOzg49JqO0tbWRvF4PJrDYaZ5K1ascFq4cGGPKQX9WRGPjIxsksvlAplM\nZtza2kolJiZaz5w5864PGGq1Gj2994aGBk5tbS2n8/jkyZMWwcHB3VJ95HK5kVAoVL/xxhs1ixYt\nqszJyTEFgJiYmIakpCSrzp9PZWUlt6CgwDgmJqbh8OHD1hUVFdzO61FRUYrk5GTLxsZGTkNDAyc5\nOdlq/Pjxd70fbVFRUYqjR49aKhQKqra2lnP8+HHLvsajK6wt09A0raQo6h8AUgFwAfw/mqYvURS1\nDkAmTdOHwaSimAP48fankFKapqf1+qIEQfSbu7s7hg0bhpycHHR0dCAlJQWzZs1irXzdvYgiRKj8\nL/N7+fr26/D4wENvsTn6es8jRwImJkBLC3D5MhAfD5w/DxQWdu++qWcURWGGeAY+O8csUSdeTsQE\nrwmsxHrrLSApiTmuqmKKyDwkXwwQj6jNmzdf37x5813frAPAzZs3L/R0PSEhoT4hISGrp8fGjBnz\nwDvG+Xw+vXTp0hsjR470d3V1bfP29r5r1fr48ePmhw4dsvHx8WkRi8USAFi7dm35s88+W19WVmY0\nb968oSqVCjRNU9OnT6+ZM2dOPQBMmzbNq66ujsfj8ejPPvus1M7O7q5P8SEhIa01NTVGPj4+Adu2\nbZNPmDChSfvxlJQU87FjxyrUajUWLFjgEhsbW9+5efKvuF0NpTQmJsZXpVIhISGhOiwsrBUAIiMj\nvXft2lXi4eHR0dt7DwoKapkxY4Y3AKhUKmrmzJm3nn766W4511lZWSbLly935XA44PF49LZt20oA\nYMSIEa3vv/9+eXR0tK9arYaRkRG9ZcuW0ujo6KalS5feGDNmjJjD4dCBgYHNBw4ckCckJNwKDQ31\nB4C5c+dWhYeHt+Tn5/eazx4REdE8Y8aMmsDAwAAXF5e2kSNHKvoaj65QbJSvYlNYWBidmZlp6GEQ\nxCNlzZo1WLt2LQDAzc0NlpaWyMnJMchkvHJvJS7P6apa8sT1J8B36rE6l851qNU4XV+P7ysrUa9U\nYoadHRIcWCoTO23a3SVDEhOBGbqvVNIf6SXpGPvtWACArYkt1o1fBw7FwWthr+k0Dk0DQ4YA5eVM\nJZXz54Hhw3UaYtCgKCqLpumwe985sOTm5spDQkL6lY89WFVUVHCXLFnikp6ebvH8889X19fXczds\n2HBj69attt9//71NSEhI07Bhw1reeecdstHOAHJzc21DQkI8enqMTMQJYhDIycnB8DtmQTk5OQgJ\nCdH7WFTNKqQL04Hb6ZUe//SAx0oPvcROuXULk7Ua7ASYmuLiyJHsBPvqKyY1RdvTTwM//shOvPuk\nUqvgvNkZN5u6sgGHWAxByaISnX8w+/prgM8HpkwBOBzASu+tRwYGMhEn+uuFF15w2717d6mhx0Ew\n+pqIkxb3BDEIhISEwN3dHWZmXXtijhiowDPXlAuzwK5xtBT0uxLYAxtvZQVzTtevvUvNzbjSwlJ8\n7S6bAFPScM0admL1A5fDRZxfXLdrZQ1lyKnI0Xmsl15i9qpOnMikzDc13fs5BEH8dWQS/uggE3GC\nGAQoisK5c+fw1VdfISwsDGvXrsXMmTMNNp6gn4PgttwNj0kfg/8u/XU45nM4iNVqeT+Ez0dNR48b\n/v867S6bAPDYY0BAQO/369HTkqcxzmMcRjiNAJfiYrzHeLSpeixa9ZdwucC+fUz5wpYW4PhxnYcg\nCIJ4pJGtMwQxSDg4OGDOnDlISEgw9FAgcBbA80PPe9/IgjhbW+y73Y/AzsgIj1n0WFpXN6ZNA7Ju\n7xP77jvg2WfZi9UPE7wmYILXBJTUlUDIF8LaxJq1WNOmAVIpc7xpExAX1/f9BEEQgwlZESeIQaQz\nB7ilpQV1bDe0uQ9t5W0o/aQU17Zc01vMyTY2MLr9c8hWKFDaelexA9157jnm71GjgJgY4IcfmAoq\nNx+Oaq3ulu6sTsKB7nnhBqycSRAE8VAiE3GCGEQyMjIwc+ZM2NraYu7cuZg/f77BxlJ/th5nhpxB\n8bvFuPL2FTT8odOuwb0S8XiIsrTUnP+3ogJFzX+5qlfPvLwAuRw4cwb46SdmRfzgQYNv2NRWWl+K\nb/78BqX1pcirzLv3E/rp1Ve7yhbm5DBVVAiCIAgGmYgTxCBSWVmJxMRENDc3IykpCV9//TUuXOix\n/C7rhCOE4PCZX0F0O42SDTotzdqnGVodet+Xy/FWURF7wdyZBjrdcjIegpb3NE1j7Ddj4f6ZO/52\n+G9w/8wdi1MX6zyOpWX35j6HD/d+L0HcQa1Wqw3T8IAgdOT2f8Pq3h4nE3GCGEQmTpwIPr97ze5v\nvvnGIGPhGHFgPaUrLaIurQ7qjl5/V+nUNBsb2BoZac5TampQ3qb7zYrdzJrF7F6USIDp05lC2wZE\nURRsTG26Xfv16q8ordd9sQXtzyDvvss09yGI+3CxqqpKRCbjxKNKrVZTVVVVIgAXe7uHbNYkiEHE\n3NwcEyZMQNLtlodubm4YNWqUwcbjs8UH9Rn16KjsgKpOhdpjtbCJtbn3E/8iJz4fN0ePxpO5ufi1\nrg7GHA7ONzTARWulXKdOnQJWr2ba3E+cCLz9Njtx+ileHI9DskOac1MjU+RU5MBN5KbTONOnA2++\nyRw3NgL/7/8xKSsE0RelUvlKRUXF1xUVFYEgC4fEo0kN4KJSqXyltxtIQx+CGGT27duH2bNnA2Am\n4sXFxeByuQYbz5V3rqDs/8oAAHbP2iFgr/5K/KXW1KCopQUJ9vaw0loh17ljx4BJk5hjOzsmUZrN\nePeptqUW9hvtoVQzS9SX3rgEiZ2ElVg+PkBnBpC3N1BYyEqYAWmwNvQhiMGAfMIkiEEmLi4Otra2\nAIDS0lIcO3bMoONxmNvVYr76QDWU9frLW5hkbY1XnZxworYWJWxWT4mOZjraAEBVFVM9ZceOrpmp\ngViZWCFqaJTm/JfiX1iLtWxZ1/GtWwBb5dsJgiAeJWQiThCDDJ/Px4svvqg5//zzz/Hxxx+jsrLS\nIOMx9TMFx/T2pk0ljetfXddb7O8qKjDkzBnMkkqx7do1XGWryyaXCzz/fNf53LlMbsa337ITrx9m\n+nc1dvpR+iNomoa0SqrzOC+/DLi6AlOnArt2MS3vCYIgBjuSmkIQg1B+fj7EYnG3axs3bsTSpUsN\nMp5zfuc0re4FQwUYVayfvPUj1dWYdpHZQ8MFwKMo3Bg9mp00lcuXmY2a2jw9mVVxynB70SoVlXDZ\n7AIVrQIAuIvccb3xOq4tuQZ7M3udxmppAUxMdPqSgwJJTSGIgYusSRDEIOTn54eNGzdi9erVmmvf\nfPMNDPXB3GUhk7ZBGVOwmc7+Zs1Ok62t4Xq7iowKQBtNY2tM/xwAACAASURBVA9bzXb8/YGRI7tf\nc3UFamrYiXefHMwdMF08HRQoWAmsUFJfgg51B/6b+1+dxzIxYYrFnD0LvPIKcPq0zkMQBEE8UshE\nnCAGqaVLl2LZsmUwNTUFj8eDt7c3FAZqfeg0zwn+//NHRG0EfD710VtcHoeDV5ycul1LrKpiL6BW\nShCCg5lqKjb6++DRmw3RG3Bl4RVsnLhRc+1o4VFWYq1fDzzxBLBzJ7BqFSshCIIgHhmkfCFBDGJC\noRAHDhxAaGgorK2tweMZ5lcC14wLhwSHe9/IgpcdHbFWLkfndwGfe3uzF2z2bGDxYmanoqMj0NwM\nmJqyF+8++dr4AgDszOyQUpSCucFzMdlnMiuxhg3rOj59mtm7ylbVSIIgiIcdWREniEGsvb0djY2N\neO6555CQkGDo4QAA2m62oXBRIRr+1E/Le1eBANO0VqW/rahgL5i1NbB3L1BWBqSmMpPwa9eAq1fZ\ni9kP5sbm2Pf0PtiZ2YFLsVPSctKkrpb3AHDiBCthCIIgHglkIk4Qg1hRURGeeeYZ/PLLLzh48CBO\nnz6NP//802DjuRh/EWcczqD883LIV8v1Fvc1Z2fN8bcVFVAolehQs9Tlc8YMppRhRgYwbhzg5sbk\nazwEdufuRsiXIXhi5xNIk6ehXdWOVqVuyzry+cC8eV3nP/yg05cnCIJ4pJCJOEEMYhKJBOHh4QAA\npVKJyMhILF++3GDjofhd1UNqj9dCrdRPy/uJ1tZw5/Nhw+PBz9QUvn/8gR/ZzBUHmGXhU6eY3YuJ\niQCbdczv09lrZ5F3Mw8A8FrSa3DZ7IJdObt0HmfJkq7jI0cANr+EIAiCeJiRiThBDHLz58/vdn7s\n2DFcu3bNIGNxX+muOabbaNw6eksvcbkUhdSQECx0dcXvDQ240d6Or2/cYC9gTQ2zIm5szJw3NQHZ\n2ezFu08LHlugOS6sKUR1czW+/vNrncfx9wciIphjpRL4+991HoIgCOKRQCbiBDHIzZo1CyKRSHMu\nEAiQm5trkLGYB5pD+LhQc161l+VVaS1+pqZ42clJ80vxZF0ditlq8FNWBixdCrS3MyvjBQXA6NHs\nxOqHAPsARLpHdruWeT0Tl25e0nmsmV19hHD4MNDYqPMQBEEQDz0yESeIQc7U1BTPa3V9jI2NRWxs\nrMHG4/eVn+a4+lA1lA36a3nvwucj3s4Os+3s8IW3N4YKBOwECgnpKh+iVAK/sNdavr+0V8VNeCZI\nfykdEjtJH894MPPnd3XXpOmHJk2eIAhCr8hEnCCIbukphw8fRnV1tcHGYh5sDrNgMwCAulWNyu8q\n9Ra7UamEJZeLI7du4X25HK1sbdgEutcU37ULUKmA339nL959ihPHwVnIbF5tUbbgWsM1UCx0/jQz\nA0bdbqBqYUFKGBIEMTiRiThBEAgJCcHjjz8OAOjo6MCvv/6KoqIig43HapKV5rjknyV66/hpxuXi\n17o6NKnVqFMq2d2wmZDQVccvIwPw9WUSpy9fZi/mfTDiGuG1Ea9pzv99/t8AwMq/wddfA0lJQF0d\n8PbbOn95giCIhx6ZiBMEAYDptPnee+9h8eLFWLFiBYYPH46mpiaDjMXUt6vJjUqhgrJeP+kpHIrC\nfK1Om29fuYJ5bE2M7e2BKVO6zouLmRyNf/2LnXj9MD90PngcHvhcPoTGQjyf+Dye+v4pncfx9wdi\nYwEWFtwJgiAeCWQiThAEAGbT5ocffoijR4/iypUrUCgU+PHHHw0yFscXHcF35QMAVE0q1P1ap7fY\nLzk5obOVzc2ODvzv5k1UtrezE0w7PaVTTo7BSxk6CZ2Q+Ewisl/LRuqVVPwv739ILkxGUQ1735LU\n1gLLlhn8rRMEQegVmYgTBKFBURReeuklzfmZM2cMMg6OEQeeH3nCNt4Wj+U9Brt4/SUQOxgbI14r\nYVlJ0/gvW4Wup05lUlIAwMQEWLMGyM0F2Nok2g9T/aZCYidBrE/Xxt2d2TtZiRUVBdjYAJs2ARs3\nshKCIAjioUQm4gRBdPPMM8/A09MTfn5++PDDDw02DofnHBB4IBBmEjMoLihQ8HoB1B36afCj3WnT\nmKIQbWXVx91/gZER8H//B6xeDVRWAh98AHDZaS3/oF4JfQVO5k54Pex1vBL6Cisx6uqYrBwA2LaN\nlRAEQRAPJTIRJwiimxdffBHFxcXIz8/HN998Y+jhoGBBATKHZeL6l9dR9mmZXmKOt7SE1+1V6Xaa\nxp8KBXvBpk0D1q4FhF3106FQAMeOsRfzPjW0NSCnIgcUKJy4egJDrYayEmf16q7jmzeBwkJWwhAE\nQTx0yEScIIhutGuK/+tf/8LFixdx8OBBg42HY8oBbq+WlqwtgapVxX5MitKsivuamMCMy4VSrUaD\nkuVNo0olsGIF4OYGPPUU0/jHgDgUB5vObMJ1xXUU3CrAieITaFe1o65Vtzn706cDLi7MsUoFvPee\nTl+eIAjioUUm4gRBdPPCCy/A09MTAFBXV4fhw4djzpw5KCkpMch4rKK70kLUzWqUrNXPOP7m5IST\nISGQjRwJGx4PwzIzsYjNko5NTcCHHwKffMLsXOzoYI4NyNzYHPNC5mnOV59cjaD/BGHhzwt1Goei\ngH37us4TE4Hjx3UagiAI4qFEJuIEQXQjEAiwZcsWzblSqURbWxtWrlxpkPHYxNjAVNxVzrB8WzlU\nTeyvitsYGWGclRVyFApMuHABl5qb8U1FBc43NLAT8OpVZrOmSuu9lZR0JU8byBuPvaE5Plt+FgW3\nCvDfC//FmTLdbuQNDwdeeKHrPD4euHZNpyEIgiAeOmQiThDEXWJjYzFt2rRu1/h8PlQq9ifAPfH7\nxg9cc2YTo6pBhWtb9DdDGy4UYpqNjeZ8+/Xr7AQKDOxeztDfH/jpJ4MX2faz9cMUnyl3Xf8251ud\nx/r4Y4DPVK2EQgHMmaPzEARBEA8VMhEnCKJHn332GQRaZfRGjBgBroEqeohGieD1qZfmvOyTMnTU\ndegltpqmIdR63zPZ7MW+dm3XTPTyZeDAAfZi9cPnMZ/DhGeiOY8Xx+M/T/1H53EcHYG5c7vOMzKA\nrCydhyEIgnhokIk4QRA9Gjp0KFasWAEAcHR0hL29vUHH4/iiI0x8mMmgsk6Jsk362cjIoShQWqvS\nC4uK0MrWNwNubsCbb3adr1jBdNw8fJidePfJ29ob68ev15wfKTiCkjp2cvW3bQMmTGA+j6xcCYjF\nrIQhCIJ4KJCJOEEQvXr77bexZs0ayGQyPP3008jLy8P8+fPR0aGf1WhtHCMOnOY7gStiVqdrU2pB\n6yl/eqOXFyx5PABAUUsL1srlOF5Tw06w5csBS0vmuLCQafjz3HPArVvsxLtPi0YtwkiXkbAxscG3\ncd/Cw9IDtS21OCQ7pNM4RkbAjh2AVAqsXw+YmTH7VgmCIAYiMhEnCKJXAoEAH3zwAUQiEZYuXYph\nw4bh66+/xldffWWQ8djPtoe6lWnq05jZiOrEar3EdTA2xoahXTW0Pyorw9S8PJSw0Y/d2pqZjHdS\nqZiE6c8/132sfuByuNgTvwfSBVLMDpyNHdk74PuFL2b9OAuXqy7rNJa7O+DpyTT6WbQIGD2a+REQ\nBEEMNGQiThDEfXFwcIBazUyC16xZg/r6er2PQTBEANc3XQEA/CF8gAO91BUHgFednfGYubnmvI2m\n8c6VK+wEe/NNwNUVsLVlzk1NgdBQdmL1g5e1F+zN7EGBwp68PahuroZSrcSi1EU6/3aivR0YNoz5\n/JGZyVRRIQiCGGjIRJwgiPtibGysyZUeOXIkeLdTNfTN7T03eH/mDb+dfijbVIaiN1ms7a2FQ1HY\n7ucH7RomhS0taLv94USnTEyAlBSmfOGUKcyuxbg43cd5QBRF4YNxH4C6/dMwNzZHi7JFpzGMjYHo\n6K7z48eBs2d1GoIgCMLgyEScIIj7olAoNKuev//+O5qamgwyDiMbI4giRLgw8QIaMhpw4+sbuLZV\nP+UMhwuFWNjZAhJArI0N+ByWfo0GBDAr4UePMkvDnbkZV68CbKTE9ENjWyPm7J8D+nbL04meE2Fq\nZHqPZ/XfF190FZEBgPnzdR6CIAjCoMhEnCCI+7Js2TJ4e3sDYDpuvvfee8jJyYGS7bbvPTAPNYd1\nrLXmvGhhEW7suqGX2OuGDsUUa2ucDQ3Feq28cVYVFgISCbBwITBiBPDKKwZt9CPkCzFv2DzN+dvH\n30ZZve6r2JiYAB991HV+8SKQna3zMARBEAZD6avqgK6EhYXRmZmZhh4GQQxKKSkpmDx5subc2NgY\nM2bMwHfffaf3VBVlvRJnh56Fsvb2BwEKCDwSCNtYW72O41prK9bI5Vjk6opArRxynSksBCIjgRt3\nfND48MPumzr1rKWjBcO2D0PBrQIAwDiPcXAyd8LKMSsRYB+gszg0DUya1NXy/vHHgfR0prrKYEFR\nVBZN02GGHgdBELpHVsQJgrhvMTExmDFjhua8vb0d+/btQ0JCgt5KCXbiiXjw/tS76wINSGdLocjV\nX3mN/5SXw++PP7CzogJjcnJwrqFB90EcHJj64ne6edOgq+ImRibYOW2nJk88TZ6G7y9+j3G7xuF8\n+XmdxaEoJkWlc+J97hxT0ZGtBqcEQRD6RCbiBEH0y6effgoTE5Nu1wIDA7s1vdEXxxcd4bnRE7jd\n+FKtUONCzAW0yHW7cbA3Ag4Hrbc3a9YplfiuokL3QSwsmI2b2lVTKIqp6WeAn7m2CLcILHhsQbdr\n1c3VSL2SqtM4vr5MbyOAmZDL5UB4OPNlAUEQxKOMTMQJgugXd3d3HDx4EKamzOa8CRMmYPXq1QYb\nj9tSN4T+Hqpp9GMaYIq20jaolSxUM7lDs1oN7Sh7b97E72yUdbS0BI4dA4KCmHOaBhISmI6bra1A\ntX7qqfdkw5Mb4C5y15z72/pj5ZiVOo/zwQfACy90fQkglwPffQewUbSGIAhCX8hEnCCIfps0aRJO\nnz6NJUuWIDW1a/Xz5s2bWLp0Kdrb2/U6HouRFgg6EgSHuQ5wesUJuU/mIv+VfNBqdlM3Fri44H/+\n/uhMV65WKhGVk4Nvb9xAkq4nxzY2wC+/dPV8VyqBp59mVsqnTTNYJRVzY3PsitsFAU8AXxtfnH35\nrObbkfrWeuy7uE8ncSgK2LUL+OknZhPn3LlMbfHgYGYTJ0EQxKOIbNYkCEInqqurERwcjBs3biA2\nNhYHDhwAX7v2nB40/NGA7Cey0blM7TDXAb5f+YIr4LIaN6O+HnEXL6L6jl7sn3t7Y6Grq26DXb/O\nbN4sKmKKbXd+6Jk3D/jmG93G6oc/b/wJM2Mz+Nr4AgBala0Y9fUo5FbmYt24dXh/7Ps6S1/Ky2Mq\nO0ZGAuXlgEgErFoFLF2qk5d/6JDNmgQxcJEVcYIgdGLp0qW4cbuyx9GjR7Fu3Tq9j0H4mBBOf3Ni\nTiigan8VLs28hNZSdleLw0UinAsNhdi0ey3tt4qK8P/urHbyVzk7A7/+CsyezeRrdPLy0m2cfhru\nNFwzCQeAN5PfRG5lLgBgddpq/Pv8v3UWKyiIKSLTuTe2vh5Ytgz4+991FoIgCEIvyEScIAidUKm6\nt5r/5ZdfUF1dDZqm73qMLRRFwfdLX9hMswHFo6BuUaMmuQZnPc8iOzwbDZksVDW5zdPEBGeGD8dY\nCwvNNT8TE8TZslBOccgQ4PvvmfKF8+czk/PKSuD555l+8CdOAEeOGKyqSoeqA2klad2utXa06rSy\nTkQEcOoUszLeafv27nnkBEEQDzuSmkIQhE6o1WosW7YMn376qeaatbU1IiIicO7cOfzjH//A/Pnz\n4eDgoJfxXHn3Cso+ubvJjImfCfx2+sEy3JKVuB1qNRYWFqKyowNf+PjAmc+HmqaxoKAAJW1tWOTq\nimgrK3B1VfFErWa63IwbB3R2OzUxAVpagDFjgE8/ZZoA6VlKUQrm7J+DurY6zbXngp7DJK9JSLmS\nghdDXkT00GhwOX8tbSgzk5mUt7V1XfPxATZvBry9AT8/gxeX+ctIagpBDFxkIk4QhE59/vnnWLx4\ncY+rn0OGDIFcLgeHrbbwd6g5VoOSD0tQf+ruSia+O3zh/IqzXsZxpr4eo//8U3PuYmyMlOBgBJiZ\n6SZv+n//Y1bDezJnDrBtG1N5Rc/kdXLM/GEmsm/03A7zCdcn8PvLv//lOFevAmFhQE1N17W9e5ns\nHYkEeO455tjT8y+HMggyESeIgYvViThFUTEAPgdT5fdrmqY/uuNxPoDdAEYAuAXgWZqm5X29JpmI\nE8TD76effsJbb72FkpKSbtdXrlyJf/7zn7hw4QL27duH+vp6+Pv7IyQkBBEREayMhaZpFC8vRvkX\n5VA3Mbs4OQIORslHgWvBxeXnLgMUABqwf94eZn5mEHgJdLrB882CAnzRQwcasakp4mxtYUxRGG9p\niSECAbzuqNF+37KygM8/Z1JWlMruj5mZAefPA6+8wuRyeHkxs9MxYx4sVj+0Klvxj+R/YOefO+96\nbEXECvwr+l/IrchFRmkGalprEOkeCVcLVwy1GtqvOAoF8O67TElDKyvgpZeANWuYx4yMmC8Opkxh\nPpeoVMwEPSAA0PN+4gdCJuIEMXCxNhGnKIoLoADABADXAJwHMIemaanWPW8ACKZp+u8URc0GMIOm\n6Wf7el0yESeIR4Narcbvv/+O7777DiUlJWhqasJ3330HNzc3LFmypFsKCwDY2NjA0dERjo6OqKur\nQ2BgIJycnPDMM89ALpfj/7d378Fxlecdx7/ParWSJRvZstaOLpblC/KlvmILTCm+TEiatDSpiULj\nIZ02OKSkIb1kOmlJmQzTSSd0poWxS0lKbk48SRNKMqkppMC0dTIJaWoXIjAXNQRsLNtCsiVs62LJ\nkp7+satdrepda82ujrT6fWbO+Jyz77776NHZs49ev2fPyZMn6erqorW1lUgkQklJCdu3b8fMqK+v\np7+/n87OTgDOnTvH3PgI8IULF2hpacFHnPPPnmdJ7xKWL1lO83eaefqep3nmr5/hKEcBaKAhEU9r\nuBUPO0VlRWx75zbueOSO2P6DrTz4qQfp6euhqLiILTu2YCEDgyP/c4RzPeeoqqpi5x072fLBLQB8\n7s+/xlOPPc25+Fz5i43L8LJYBVh8vB0bGmZwSS3ltVEO3f+HfPyzX+fosXa6DrcQcieMUb18KQtq\nFhACSkqKGRy4SJEZxZFiqt8xn1PH34zFd7iFvs5O6OtnflGI+qIRGiuKefc/P8hD7/oYAK8Mhagv\ncsoiYSgv51j/MGd6e8BClJeW8Js3b2X3338KgHt+69O82HqUvoELLKqpJrqgEoCOzm7aTsYuRJ1X\nUcG3W76RyN2HN++mM/71jfMr57F4cS1dF7p5s7uDM8fPUjIrQlEU7nng09y4ZRu333o7R587xWBf\n7A+IcHERs2tLCIfChENhzp3qY17tHCKhCDd/+F08+8PnOX2ym7fO9ND1ZjcAFjKWr6rHMaKLFnHs\ntV462roYcSiij2GPTSZ3BhjsSV5AO2tONZW1y/nOwc/wl3+wh9bnWul68yRmUFVdk5jWcurY0cT/\n8jSsuJpv/OdeAL6297t88/79DA4OYGbULW3gzns/yo3vHHMDprdJhbhIAXP3vCzA9cCTY7bvBu4e\n1+ZJ4Pr4ehg4TfyPg3TLpk2bXESmr6GhIa+pqXEg7RKJRBLr+/fv9x07dmRsv2vXLt+6dWtiu66u\n7rLtR0ZGfNfcXRnbjS7rZq9LxP/QXQ9N6Dm7N+9OPGd12eoJPWfFnI3u7r5y9oaM7ZaX/UpifRaz\nfMVl2l8b3e4H/u5bE4oB8GsrtyZiL6X0su2LKEr5HZdRPqHXeeJLj7m7e2Ppmsv2P7r+kR0f9cZZ\nmdtvmndDSptKq8rY/pq5N7i7+9bq904o7mUlqxI/661Nu//f4/d+4oGcvmeAw56nz2otWrQEu+Rz\nomYtMPZKqbb4vku2cfch4Cwwf3xHZvYxMztsZodHR7xEZHpyd/bs2UNTUxNVVVWX/K7xsTcEikQi\nDI2fapEDZkb0lugEGydX/aLnPJZRRfHXyfl9iIqLYXFDjjvNjeGR4ezmycenEeVD/n6zIiKXFs5j\n35c6s44/z02kDe7+MPAwxKamvP3QRCQo4XCY5uZmmpubE/uGh4c5ffo07e3tHD9+nDfeeINwOExH\nRwdr165l586drFmzhhMnTtDa2srwcKx427BhAwBbtmzhzJkziW9kGRwc5LrrrsPd6e/vp6WlJfFa\n69evp6mpCYCNN27klrdu4aWXYjPmVq9eDYAPOz/78c8YGhjCh5xNTclvHVm6cSkNsxroudhDiBDr\nqtclzlq/6PgFvUO9zI3MZd016xLPaWpsouP5jsT2ysqVlEZKAWjrbmPIh2iobGDVslUA/Nq6X2XB\n6/N4peMIIx7rfEF5LXPK5uFAxdwoc9+K4kBxcYRodT3lxyoAaO9+nf7h2LenVJTMp3JONY1rNhBd\nOJdrotsSbSrn1BAJR8CdrnPtnL0Yu9JxVqiMqxvjd+90Z13VFtq6f0n/SB/R0mpml8S+nrFn4Byd\nF2JTPK4qnpfyO64rbaBzoD0WQ3EllWWxr3AcHBrkRO9RZoevIlr+DqpqqigKFdFYt5KBY/2cvdid\niGHh7NEbITld/aepnFWFA8tWLObE652Udc2mb6CHzoFYDCELsWhO7GrMRXW19PZUUtZVHju+Rkao\nDy2Lx3CRU33JaxdqyhZTVxcbI1pYs5D1vdfR2XsScKLlybGjtvOvMRK/U9SCiuT+hfXV1Dy7iP6R\nPkIWom72UmoaqhERmYh8zhG/HrjX3X89vn03gLt/fkybJ+NtfmpmYaAdiHqGoDRHXEREZhLNERcp\nXPmcmnIIuNrMlphZBPgQcGBcmwPA78XXm4H/yFSEi4iIiIgUirxNTXH3ITO7i9gFmUXAV939RTP7\nK2IXnhwAvgLsN7NXgS5ixbqIiIiISMHL5xxx3P0J4Ilx+z47Zv0C8MF8xiAiIiIiMhVNzu3tRERE\nREQkhQpxEREREZEAqBAXEREREQmACnERERERkQCoEBcRERERCYAKcRERERGRAKgQFxEREREJgApx\nEREREZEAqBAXEREREQmAuXvQMWTFzDqBY+N2VwBnL/PUdG2qgNM5CC3bePLZ3+XaZ3o81/nIdS6u\npM9Czkeuc5Gpjd4rqab6sXElfRZyPqbze2UxcLu7P5bDPkVkKnD3ab8AD19pG+BwEPHks7/Ltc/0\neK7zketcKB/5zUWmNnqvTK9jQ/nIby4ytZkO7xUtWrRMjaVQpqZMZJRgMkcScv1a2fZ3ufbTORdX\n0mch5yPXubiSPt+OqZ6P6ZyLK+mzkPOh94qITDnTbmpKrpnZYXffHHQcU4XykUr5SFIuUikfqZSP\nJOVCRCaqUEbE346Hgw5gilE+UikfScpFKuUjlfKRpFyIyITM+BFxEREREZEgaERcRERERCQAKsRF\nRERERAKgQlxEREREJAAqxDMws1Vm9kUze9TMPh50PEEzs982sy+Z2b+Y2buDjidIZrbUzL5iZo8G\nHUtQzKzczL4ePyZuCzqeoOmYSNK5IpU+S0QknYItxM3sq2bWYWZHxu1/j5m1mtmrZvYXmfpw95fd\n/U7gVmBafxVVjvLxfXe/A/h94HfyGG5e5SgXr7n77vxGOvmyzM0twKPxY+J9kx7sJMgmH4V6TIzK\nMhcFca7IJMt8FMxniYjkVsEW4sA+4D1jd5hZEfAPwHuB1cAuM1ttZmvN7F/HLQviz3kf8GPg3yc3\n/JzbRw7yEXdP/HnT1T5yl4tCs48J5gaoA47Hmw1PYoyTaR8Tz0eh20f2uZju54pM9pFFPgros0RE\ncigcdAD54u4/MrOGcbuvBV5199cAzOzbwPvd/fPAzWn6OQAcMLPHgW/lL+L8ykU+zMyA+4AfuPuz\n+Y04f3J1bBSibHIDtBErxn9Ogf5Rn2U+Xprc6CZXNrkws5cpgHNFJtkeG4XyWSIiuVWQH54Z1JIc\nwYNYIVGbrrGZbTezvWb2j8AT+Q4uAFnlA/gkcBPQbGZ35jOwAGR7bMw3sy8CG83s7nwHF7B0ufke\n8AEz+wIz6/bbl8zHDDsmRqU7Ngr5XJFJumOj0D9LROQKFeyIeBp2iX1p72jk7geBg/kKZgrINh97\ngb35CydQ2ebiDDBTCoxL5sbde4GPTHYwU0C6fMykY2JUulwU8rkik3T5OEhhf5aIyBWaaSPibcCi\nMdt1wMmAYpkKlI8k5SI95SaV8pGkXKRSPkQkKzOtED8EXG1mS8wsAnwIOBBwTEFSPpKUi/SUm1TK\nR5JykUr5EJGsFGwhbmb/BPwUWGFmbWa2292HgLuAJ4GXgUfc/cUg45wsykeScpGecpNK+UhSLlIp\nHyKSC+aedhqsiIiIiIjkScGOiIuIiIiITGUqxEVEREREAqBCXEREREQkACrERUREREQCoEJcRERE\nRCQAKsRFRERERAKgQlxEREREJAAqxEUKlJnNN7Ofx5d2MzsxZvuZPL3mRjP7cobHo2b2b/l4bRER\nkekmHHQAIpIf7n4G2ABgZvcCPe7+t3l+2c8An8sQU6eZnTKzG9z9J3mORUREZErTiLjIDGRmPfF/\nt5vZD83sETP7XzO7z8xuM7P/NrMXzGxZvF3UzL5rZofiyw2X6HMOsM7dW+Lb28aMwD8Xfxzg+8Bt\nk/SjioiITFkqxEVkPfDHwFrgd4FGd78W+DLwyXibPcAD7t4EfCD+2HibgSNjtv8M+IS7bwBuBPrj\n+w/Ht0VERGY0TU0RkUPufgrAzH4JPBXf/wKwI75+E7DazEafc5WZzXH382P6qQY6x2z/BLjfzL4J\nfM/d2+L7O4Ca3P8YIiIi04sKcREZGLM+MmZ7hOQ5IgRc7+79pNcPlI5uuPt9ZvY48BvAf5nZTe7+\nSrxNpn5ERERmBE1NEZGJeAq4a3TDzDZcos3LwPIxijCDKwAAALZJREFUbZa5+wvu/jfEpqOsjD/U\nSOoUFhERkRlJhbiITMQfAZvN7Hkzewm4c3yD+Gh3xZiLMv/EzI6YWQuxEfAfxPfvAB6fjKBFRESm\nMnP3oGMQkQJhZn8KnHf3TN8l/iPg/e7ePXmRiYiITD0aEReRXPoCqXPOU5hZFLhfRbiIiIhGxEVE\nREREAqERcRERERGRAKgQFxEREREJgApxEREREZEAqBAXEREREQmACnERERERkQD8H+w9uRlRyFeM\nAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fcb1e15a518>"
+       "<Figure size 576x432 with 1 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -1222,15 +1149,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 22,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1386,7 +1324,7 @@
        "11  (((delayed-nu-fission / nu-fission) * (delayed... 6.99e-11   3.48e-13  "
       ]
      },
-     "execution_count": 24,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1410,10 +1348,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 23,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -1429,18 +1365,20 @@
        "(0, 7)"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAEWCAYAAABbgYH9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUXFWRrt2AGEAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fcb1df13860>"
+       "<Figure size 432x288 with 1 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -1481,10 +1419,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 24,
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -1492,18 +1428,20 @@
        "(1000.0, 20000000.0)"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEaCAYAAADg2nttAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ncrAwM7NSDhZmZlbqBy72En+5o4CmAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fcb1e2aa320>"
+       "<Figure size 432x288 with 1 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -1548,9 +1486,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.0"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
 }
diff --git a/examples/jupyter/mdgxs-part-ii.ipynb b/examples/jupyter/mdgxs-part-ii.ipynb
index 23ee4d251..77b5b5525 100644
--- a/examples/jupyter/mdgxs-part-ii.ipynb
+++ b/examples/jupyter/mdgxs-part-ii.ipynb
@@ -45,9 +45,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# 1.6 enriched fuel\n",
@@ -102,8 +100,8 @@
    "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",
+    "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",
@@ -124,9 +122,7 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create a Universe to encapsulate a fuel pin\n",
@@ -322,7 +318,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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\nMDB/tUH+AAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -386,7 +382,26 @@
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "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",
@@ -417,7 +432,7 @@
     "mgxs_lib.add_to_tallies_file(tallies_file, merge=True)\n",
     "\n",
     "# Instantiate a current tally\n",
-    "mesh_filter = openmc.MeshFilter(mesh)\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",
@@ -445,145 +460,135 @@
      "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",
-      "                   #################     %%%%%%%%%%%%%%%%%\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",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.8.0\n",
-      "          Git SHA1 | f7edad68f0654d775ed363bfdcbe4aa5d3cfba23\n",
-      "         Date/Time | 2017-04-03 21:15:56\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 geometry XML file...\n",
-      " Reading materials XML file...\n",
       " Reading cross sections XML file...\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 O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n",
-      " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n",
-      " Reading B10 from /home/romano/openmc/scripts/nndc_hdf5/B10.h5\n",
-      " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for U235\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",
-      " Building neighboring cells lists for each surface...\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",
+      "  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.02684    1.02662 +/- 0.00889\n",
-      "       18/1    0.97234    1.01984 +/- 0.01026\n",
-      "       19/1    0.99754    1.01736 +/- 0.00938\n",
-      "       20/1    0.98964    1.01459 +/- 0.00884\n",
-      "       21/1    1.04140    1.01703 +/- 0.00836\n",
-      "       22/1    1.03854    1.01882 +/- 0.00784\n",
-      "       23/1    1.05917    1.02192 +/- 0.00785\n",
-      "       24/1    1.02413    1.02208 +/- 0.00727\n",
-      "       25/1    1.03113    1.02268 +/- 0.00679\n",
-      "       26/1    1.05113    1.02446 +/- 0.00660\n",
-      "       27/1    1.03252    1.02494 +/- 0.00622\n",
-      "       28/1    1.05196    1.02644 +/- 0.00605\n",
-      "       29/1    0.99663    1.02487 +/- 0.00593\n",
-      "       30/1    1.01820    1.02454 +/- 0.00564\n",
-      "       31/1    1.02753    1.02468 +/- 0.00537\n",
-      "       32/1    1.02162    1.02454 +/- 0.00512\n",
-      "       33/1    1.04083    1.02525 +/- 0.00494\n",
-      "       34/1    1.03335    1.02558 +/- 0.00474\n",
-      "       35/1    1.01304    1.02508 +/- 0.00458\n",
-      "       36/1    0.99299    1.02385 +/- 0.00457\n",
-      "       37/1    1.04936    1.02479 +/- 0.00450\n",
-      "       38/1    1.02856    1.02493 +/- 0.00433\n",
-      "       39/1    1.03706    1.02535 +/- 0.00420\n",
-      "       40/1    1.08118    1.02721 +/- 0.00447\n",
-      "       41/1    1.00149    1.02638 +/- 0.00440\n",
-      "       42/1    1.00233    1.02563 +/- 0.00433\n",
-      "       43/1    1.03023    1.02577 +/- 0.00419\n",
-      "       44/1    1.03230    1.02596 +/- 0.00407\n",
-      "       45/1    0.98123    1.02468 +/- 0.00416\n",
-      "       46/1    1.02126    1.02458 +/- 0.00404\n",
-      "       47/1    0.99772    1.02386 +/- 0.00400\n",
-      "       48/1    1.02773    1.02396 +/- 0.00389\n",
-      "       49/1    1.01690    1.02378 +/- 0.00379\n",
-      "       50/1    1.02890    1.02391 +/- 0.00370\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     =  3.7616E-01 seconds\n",
-      "   Reading cross sections          =  3.2363E-01 seconds\n",
-      " Total time in simulation          =  5.8159E+01 seconds\n",
-      "   Time in transport only          =  5.7959E+01 seconds\n",
-      "   Time in inactive batches        =  3.9349E+00 seconds\n",
-      "   Time in active batches          =  5.4224E+01 seconds\n",
-      "   Time synchronizing fission bank =  3.6903E-03 seconds\n",
-      "     Sampling source sites         =  2.4990E-03 seconds\n",
-      "     SEND/RECV source sites        =  1.1328E-03 seconds\n",
-      "   Time accumulating tallies       =  1.7598E-01 seconds\n",
-      " Total time for finalization       =  3.5126E-03 seconds\n",
-      " Total time elapsed                =  5.8551E+01 seconds\n",
-      " Calculation Rate (inactive)       =  6353.42 neutrons/second\n",
-      " Calculation Rate (active)         =  1844.20 neutrons/second\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.02621 +/-  0.00393\n",
-      " k-effective (Track-length)  =  1.02391 +/-  0.00370\n",
-      " k-effective (Absorption)    =  1.02077 +/-  0.00423\n",
-      " Combined k-effective        =  1.02331 +/-  0.00353\n",
-      " Leakage Fraction            =  0.00000 +/-  0.00000\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"
      ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -658,26 +663,23 @@
    "execution_count": 18,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1875: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1876: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1877: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  new_tally._mean = data['self']['mean'] / data['other']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1869: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1870: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n"
-     ]
-    },
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr>\n",
@@ -710,8 +712,8 @@
        "      <td>1</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.011301</td>\n",
-       "      <td>0.003184</td>\n",
+       "      <td>0.000099</td>\n",
+       "      <td>2.275247e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
@@ -721,8 +723,8 @@
        "      <td>2</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.000854</td>\n",
-       "      <td>0.000078</td>\n",
+       "      <td>0.001260</td>\n",
+       "      <td>2.852271e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -732,8 +734,8 @@
        "      <td>3</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.007267</td>\n",
-       "      <td>0.000713</td>\n",
+       "      <td>0.000800</td>\n",
+       "      <td>1.795615e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -743,8 +745,8 @@
        "      <td>4</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.088903</td>\n",
-       "      <td>0.005501</td>\n",
+       "      <td>0.000630</td>\n",
+       "      <td>1.397151e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -754,8 +756,8 @@
        "      <td>5</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.044257</td>\n",
-       "      <td>0.002890</td>\n",
+       "      <td>0.000023</td>\n",
+       "      <td>4.861639e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
@@ -765,52 +767,52 @@
        "      <td>6</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.001897</td>\n",
-       "      <td>0.000282</td>\n",
+       "      <td>0.000002</td>\n",
+       "      <td>3.879558e-07</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
-       "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
+       "      <td>1</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.007362</td>\n",
-       "      <td>0.001968</td>\n",
+       "      <td>0.000091</td>\n",
+       "      <td>2.062544e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>7</th>\n",
-       "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>1</td>\n",
+       "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.000872</td>\n",
-       "      <td>0.000064</td>\n",
+       "      <td>0.001162</td>\n",
+       "      <td>2.584797e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>8</th>\n",
-       "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>1</td>\n",
+       "      <td>1</td>\n",
        "      <td>3</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.007015</td>\n",
-       "      <td>0.000702</td>\n",
+       "      <td>0.000737</td>\n",
+       "      <td>1.626991e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9</th>\n",
-       "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>1</td>\n",
+       "      <td>1</td>\n",
        "      <td>4</td>\n",
        "      <td>total</td>\n",
        "      <td>(((delayed-nu-fission / nu-fission) * (delayed...</td>\n",
-       "      <td>0.101115</td>\n",
-       "      <td>0.007008</td>\n",
+       "      <td>0.000581</td>\n",
+       "      <td>1.265708e-04</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -825,23 +827,23 @@
        "3      1  1  1            4   total   \n",
        "4      1  1  1            5   total   \n",
        "5      1  1  1            6   total   \n",
-       "6      1  2  1            1   total   \n",
-       "7      1  2  1            2   total   \n",
-       "8      1  2  1            3   total   \n",
-       "9      1  2  1            4   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.011301  0.003184  \n",
-       "1  (((delayed-nu-fission / nu-fission) * (delayed...  0.000854  0.000078  \n",
-       "2  (((delayed-nu-fission / nu-fission) * (delayed...  0.007267  0.000713  \n",
-       "3  (((delayed-nu-fission / nu-fission) * (delayed...  0.088903  0.005501  \n",
-       "4  (((delayed-nu-fission / nu-fission) * (delayed...  0.044257  0.002890  \n",
-       "5  (((delayed-nu-fission / nu-fission) * (delayed...  0.001897  0.000282  \n",
-       "6  (((delayed-nu-fission / nu-fission) * (delayed...  0.007362  0.001968  \n",
-       "7  (((delayed-nu-fission / nu-fission) * (delayed...  0.000872  0.000064  \n",
-       "8  (((delayed-nu-fission / nu-fission) * (delayed...  0.007015  0.000702  \n",
-       "9  (((delayed-nu-fission / nu-fission) * (delayed...  0.101115  0.007008  "
+       "                                               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,
@@ -896,12 +898,24 @@
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr>\n",
        "      <th></th>\n",
-       "      <th colspan=\"3\" halign=\"left\">mesh 1</th>\n",
-       "      <th>surface</th>\n",
+       "      <th colspan=\"4\" halign=\"left\">mesh 1</th>\n",
        "      <th>nuclide</th>\n",
        "      <th>score</th>\n",
        "      <th>mean</th>\n",
@@ -912,7 +926,7 @@
        "      <th>x</th>\n",
        "      <th>y</th>\n",
        "      <th>z</th>\n",
-       "      <th></th>\n",
+       "      <th>surf</th>\n",
        "      <th></th>\n",
        "      <th></th>\n",
        "      <th></th>\n",
@@ -936,7 +950,7 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>x-max out</td>\n",
+       "      <td>x-min in</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
        "      <td>0.00000</td>\n",
@@ -947,29 +961,29 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>y-min out</td>\n",
+       "      <td>x-max out</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
-       "      <td>0.03153</td>\n",
-       "      <td>0.000566</td>\n",
+       "      <td>0.03245</td>\n",
+       "      <td>0.000677</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>y-max out</td>\n",
+       "      <td>x-max in</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
-       "      <td>0.03153</td>\n",
-       "      <td>0.000593</td>\n",
+       "      <td>0.03180</td>\n",
+       "      <td>0.000659</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>z-min out</td>\n",
+       "      <td>y-min out</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
        "      <td>0.00000</td>\n",
@@ -980,7 +994,7 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>z-max out</td>\n",
+       "      <td>y-min in</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
        "      <td>0.00000</td>\n",
@@ -991,29 +1005,29 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>x-min in</td>\n",
+       "      <td>y-max out</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
-       "      <td>0.03265</td>\n",
-       "      <td>0.000753</td>\n",
+       "      <td>0.03072</td>\n",
+       "      <td>0.000677</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>7</th>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>x-max in</td>\n",
+       "      <td>y-max in</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
-       "      <td>0.03216</td>\n",
-       "      <td>0.000698</td>\n",
+       "      <td>0.03104</td>\n",
+       "      <td>0.000652</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>8</th>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>y-min in</td>\n",
+       "      <td>z-min out</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
        "      <td>0.00000</td>\n",
@@ -1024,7 +1038,7 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
-       "      <td>y-max in</td>\n",
+       "      <td>z-min in</td>\n",
        "      <td>total</td>\n",
        "      <td>current</td>\n",
        "      <td>0.00000</td>\n",
@@ -1035,18 +1049,18 @@
        "</div>"
       ],
       "text/plain": [
-       "  mesh 1          surface nuclide    score     mean std. dev.\n",
-       "       x  y  z                                               \n",
+       "  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-max out   total  current  0.00000  0.000000\n",
-       "2      1  1  1  y-min out   total  current  0.03153  0.000566\n",
-       "3      1  1  1  y-max out   total  current  0.03153  0.000593\n",
-       "4      1  1  1  z-min out   total  current  0.00000  0.000000\n",
-       "5      1  1  1  z-max out   total  current  0.00000  0.000000\n",
-       "6      1  1  1   x-min in   total  current  0.03265  0.000753\n",
-       "7      1  1  1   x-max in   total  current  0.03216  0.000698\n",
-       "8      1  1  1   y-min in   total  current  0.00000  0.000000\n",
-       "9      1  1  1   y-max in   total  current  0.00000  0.000000"
+       "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,
@@ -1077,22 +1091,10 @@
    "execution_count": 20,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1875: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1876: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1877: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  new_tally._mean = data['self']['mean'] / data['other']['mean']\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "<matplotlib.text.Text at 0x7fecd32c1da0>"
+       "Text(0.5, 1.0, 'Beta - delayed group 6')"
       ]
      },
      "execution_count": 20,
@@ -1101,12 +1103,14 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABBYAAAIYCAYAAADZ+G/gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fecd5b15e80>"
+       "<Figure size 1296x648 with 12 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -1166,7 +1170,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/mgxs-part-i.ipynb b/examples/jupyter/mgxs-part-i.ipynb
index 90beeaae2..264f8967c 100644
--- a/examples/jupyter/mgxs-part-i.ipynb
+++ b/examples/jupyter/mgxs-part-i.ipynb
@@ -28,9 +28,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -134,9 +132,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -224,9 +220,7 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a Cell\n",
@@ -268,9 +262,7 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create Geometry and set root Universe\n",
@@ -326,9 +318,7 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a 2-group EnergyGroups object\n",
@@ -365,9 +355,7 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a few different sections\n",
@@ -390,9 +378,7 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -431,9 +417,7 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
@@ -473,9 +457,7 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -645,9 +627,7 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Load the last statepoint file\n",
@@ -671,9 +651,7 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Load the tallies from the statepoint into each MGXS object\n",
@@ -706,9 +684,7 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -741,9 +717,7 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -807,9 +781,7 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "absorption.export_xs_data(filename='absorption-xs', format='excel')"
@@ -825,9 +797,7 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "total.build_hdf5_store(filename='mgxs', append=True)\n",
@@ -852,9 +822,7 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -931,9 +899,7 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -1003,9 +969,7 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -1082,9 +1046,7 @@
   {
    "cell_type": "code",
    "execution_count": 24,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -1168,9 +1130,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.0"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
 }
diff --git a/examples/jupyter/mgxs-part-ii.ipynb b/examples/jupyter/mgxs-part-ii.ipynb
index 797a357f0..9e5cde42d 100644
--- a/examples/jupyter/mgxs-part-ii.ipynb
+++ b/examples/jupyter/mgxs-part-ii.ipynb
@@ -8,7 +8,7 @@
     "\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](http://openmc.readthedocs.io/en/latest/io_formats/settings.html#trigger-element)** with multi-group cross sections\n",
+    "* The use of **[tally precision triggers](http://docs.openmc.org/en/latest/io_formats/settings.html#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",
@@ -26,23 +26,8 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/miniconda3/envs/python3/lib/python3.6/site-packages/matplotlib/__init__.py:1401: UserWarning:  This call to matplotlib.use() has no effect\n",
-      "because the backend has already been chosen;\n",
-      "matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n",
-      "or matplotlib.backends is imported for the first time.\n",
-      "\n",
-      "  warnings.warn(_use_error_msg)\n"
-     ]
-    }
-   ],
+   "metadata": {},
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
@@ -68,9 +53,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# 1.6% enriched fuel\n",
@@ -102,9 +85,7 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a Materials collection\n",
@@ -124,22 +105,15 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
+   "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",
+    "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')"
+    "# Create box to surround the geometry\n",
+    "box = openmc.model.rectangular_prism(1.26, 1.26, boundary_type='reflective')"
    ]
   },
   {
@@ -152,9 +126,7 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create a Universe to encapsulate a fuel pin\n",
@@ -175,7 +147,7 @@
     "# 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",
+    "moderator_cell.region = +clad_outer_radius & box\n",
     "pin_cell_universe.add_cell(moderator_cell)"
    ]
   },
@@ -183,44 +155,17 @@
    "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."
+    "We now must create a geometry with the pin cell universe and export it to XML."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# Create root Cell\n",
-    "root_cell = openmc.Cell(name='root cell')\n",
-    "root_cell.region = +min_x & -max_x & +min_y & -max_y\n",
-    "root_cell.fill = pin_cell_universe\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": 7,
-   "metadata": {
-    "collapsed": true
-   },
    "outputs": [],
    "source": [
     "# Create Geometry and set root Universe\n",
-    "openmc_geometry = openmc.Geometry(root_universe)\n",
+    "openmc_geometry = openmc.Geometry(pin_cell_universe)\n",
     "\n",
     "# Export to \"geometry.xml\"\n",
     "openmc_geometry.export_to_xml()"
@@ -235,10 +180,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# OpenMC simulation parameters\n",
@@ -275,10 +218,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a \"coarse\" 2-group EnergyGroups object\n",
@@ -298,10 +239,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 9,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Extract all Cells filled by Materials\n",
@@ -329,14 +268,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
+   "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",
+    "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",
@@ -353,28 +290,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/romano/openmc/openmc/mixin.py:61: IDWarning: Another CellFilter instance already exists with id=48.\n",
+      "/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:61: IDWarning: Another CellFilter instance already exists with id=18.\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:61: IDWarning: Another EnergyFilter instance already exists with id=2.\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:61: IDWarning: Another EnergyoutFilter instance already exists with id=3.\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:61: IDWarning: Another CellFilter instance already exists with id=40.\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:61: IDWarning: Another CellFilter instance already exists with id=43.\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:61: IDWarning: Another EnergyFilter instance already exists with id=13.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=15.\n",
       "  warn(msg, IDWarning)\n"
      ]
     }
@@ -410,78 +345,74 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "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",
-      "                 ####################     %%%%%%%%%%%%%%%%%\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",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.9.0\n",
-      "          Git SHA1 | da61fb4a55e1feaa127799ad9293a766161fbb3e\n",
-      "         Date/Time | 2017-12-11 16:37:11\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",
-      " Building neighboring cells lists for each surface...\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 O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n",
-      " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n",
-      " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for U235\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",
+      "  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",
@@ -521,82 +452,138 @@
       "       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 58\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 58\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",
-      "       74/1    1.21314    1.22263 +/- 0.00190\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     =  4.1610E-01 seconds\n",
-      "   Reading cross sections          =  3.7942E-01 seconds\n",
-      " Total time in simulation          =  1.1100E+02 seconds\n",
-      "   Time in transport only          =  1.1076E+02 seconds\n",
-      "   Time in inactive batches        =  5.8101E+00 seconds\n",
-      "   Time in active batches          =  1.0519E+02 seconds\n",
-      "   Time synchronizing fission bank =  3.8707E-02 seconds\n",
-      "     Sampling source sites         =  2.7232E-02 seconds\n",
-      "     SEND/RECV source sites        =  1.1284E-02 seconds\n",
-      "   Time accumulating tallies       =  1.0514E-03 seconds\n",
-      " Total time for finalization       =  1.4526E-02 seconds\n",
-      " Total time elapsed                =  1.1150E+02 seconds\n",
-      " Calculation Rate (inactive)       =  17211.3 neutrons/second\n",
-      " Calculation Rate (active)         =  6844.60 neutrons/second\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",
+      " 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"
      ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -620,10 +607,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 13,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Load the last statepoint file\n",
@@ -639,10 +624,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 14,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Iterate over all cells and cross section types\n",
@@ -674,10 +657,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 15,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -712,14 +693,6 @@
       "\n",
       "\n"
      ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1798: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n"
-     ]
     }
    ],
    "source": [
@@ -736,10 +709,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 16,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -778,23 +749,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 17,
+   "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1798: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n"
-     ]
-    },
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -916,7 +890,7 @@
        "119     3         1          5     O16  0.000000   0.000000"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -936,10 +910,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 18,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Extract the 8-group transport cross section for the fuel\n",
@@ -958,10 +930,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 19,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -997,15 +967,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 20,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1080,7 +1061,7 @@
        "2     1         2     O16    3.788383   0.007676"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1106,10 +1087,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 21,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create an OpenMOC Geometry from the OpenMC Geometry\n",
@@ -1125,24 +1104,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1798: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1799: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1800: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  new_tally._mean = data['self']['mean'] / data['other']['mean']\n"
-     ]
-    }
-   ],
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Get all OpenMOC cells in the gometry\n",
     "openmoc_cells = openmoc_geometry.getRootUniverse().getAllCells()\n",
@@ -1183,250 +1147,530 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 23,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[  NORMAL ]  Importing ray tracing data from file...\n",
+      "[  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:\tk_eff = 0.423134\tres = 0.000E+00\n",
-      "[  NORMAL ]  Iteration 1:\tk_eff = 0.475951\tres = 5.769E-01\n",
-      "[  NORMAL ]  Iteration 2:\tk_eff = 0.491466\tres = 1.248E-01\n",
-      "[  NORMAL ]  Iteration 3:\tk_eff = 0.487444\tres = 3.260E-02\n",
-      "[  NORMAL ]  Iteration 4:\tk_eff = 0.483929\tres = 8.184E-03\n",
-      "[  NORMAL ]  Iteration 5:\tk_eff = 0.477278\tres = 7.213E-03\n",
-      "[  NORMAL ]  Iteration 6:\tk_eff = 0.468936\tres = 1.374E-02\n",
-      "[  NORMAL ]  Iteration 7:\tk_eff = 0.460317\tres = 1.748E-02\n",
-      "[  NORMAL ]  Iteration 8:\tk_eff = 0.450589\tres = 1.838E-02\n",
-      "[  NORMAL ]  Iteration 9:\tk_eff = 0.441375\tres = 2.113E-02\n",
-      "[  NORMAL ]  Iteration 10:\tk_eff = 0.431988\tres = 2.045E-02\n",
-      "[  NORMAL ]  Iteration 11:\tk_eff = 0.422929\tres = 2.127E-02\n",
-      "[  NORMAL ]  Iteration 12:\tk_eff = 0.414483\tres = 2.097E-02\n",
-      "[  NORMAL ]  Iteration 13:\tk_eff = 0.406704\tres = 1.997E-02\n",
-      "[  NORMAL ]  Iteration 14:\tk_eff = 0.399374\tres = 1.877E-02\n",
-      "[  NORMAL ]  Iteration 15:\tk_eff = 0.393064\tres = 1.802E-02\n",
-      "[  NORMAL ]  Iteration 16:\tk_eff = 0.387423\tres = 1.580E-02\n",
-      "[  NORMAL ]  Iteration 17:\tk_eff = 0.382664\tres = 1.435E-02\n",
-      "[  NORMAL ]  Iteration 18:\tk_eff = 0.378737\tres = 1.228E-02\n",
-      "[  NORMAL ]  Iteration 19:\tk_eff = 0.375638\tres = 1.026E-02\n",
-      "[  NORMAL ]  Iteration 20:\tk_eff = 0.373485\tres = 8.180E-03\n",
-      "[  NORMAL ]  Iteration 21:\tk_eff = 0.372353\tres = 5.734E-03\n",
-      "[  NORMAL ]  Iteration 22:\tk_eff = 0.371970\tres = 3.031E-03\n",
-      "[  NORMAL ]  Iteration 23:\tk_eff = 0.372577\tres = 1.027E-03\n",
-      "[  NORMAL ]  Iteration 24:\tk_eff = 0.374052\tres = 1.632E-03\n",
-      "[  NORMAL ]  Iteration 25:\tk_eff = 0.376380\tres = 3.959E-03\n",
-      "[  NORMAL ]  Iteration 26:\tk_eff = 0.379559\tres = 6.223E-03\n",
-      "[  NORMAL ]  Iteration 27:\tk_eff = 0.383579\tres = 8.447E-03\n",
-      "[  NORMAL ]  Iteration 28:\tk_eff = 0.388377\tres = 1.059E-02\n",
-      "[  NORMAL ]  Iteration 29:\tk_eff = 0.393934\tres = 1.251E-02\n",
-      "[  NORMAL ]  Iteration 30:\tk_eff = 0.400230\tres = 1.431E-02\n",
-      "[  NORMAL ]  Iteration 31:\tk_eff = 0.407231\tres = 1.598E-02\n",
-      "[  NORMAL ]  Iteration 32:\tk_eff = 0.414881\tres = 1.749E-02\n",
-      "[  NORMAL ]  Iteration 33:\tk_eff = 0.423169\tres = 1.879E-02\n",
-      "[  NORMAL ]  Iteration 34:\tk_eff = 0.432048\tres = 1.998E-02\n",
-      "[  NORMAL ]  Iteration 35:\tk_eff = 0.441469\tres = 2.098E-02\n",
-      "[  NORMAL ]  Iteration 36:\tk_eff = 0.451428\tres = 2.181E-02\n",
-      "[  NORMAL ]  Iteration 37:\tk_eff = 0.461851\tres = 2.256E-02\n",
-      "[  NORMAL ]  Iteration 38:\tk_eff = 0.472728\tres = 2.309E-02\n",
-      "[  NORMAL ]  Iteration 39:\tk_eff = 0.484004\tres = 2.355E-02\n",
-      "[  NORMAL ]  Iteration 40:\tk_eff = 0.495652\tres = 2.385E-02\n",
-      "[  NORMAL ]  Iteration 41:\tk_eff = 0.507633\tres = 2.406E-02\n",
-      "[  NORMAL ]  Iteration 42:\tk_eff = 0.519913\tres = 2.417E-02\n",
-      "[  NORMAL ]  Iteration 43:\tk_eff = 0.532458\tres = 2.419E-02\n",
-      "[  NORMAL ]  Iteration 44:\tk_eff = 0.545234\tres = 2.413E-02\n",
-      "[  NORMAL ]  Iteration 45:\tk_eff = 0.558210\tres = 2.400E-02\n",
-      "[  NORMAL ]  Iteration 46:\tk_eff = 0.571353\tres = 2.380E-02\n",
-      "[  NORMAL ]  Iteration 47:\tk_eff = 0.584635\tres = 2.354E-02\n",
-      "[  NORMAL ]  Iteration 48:\tk_eff = 0.598027\tres = 2.325E-02\n",
-      "[  NORMAL ]  Iteration 49:\tk_eff = 0.611501\tres = 2.291E-02\n",
-      "[  NORMAL ]  Iteration 50:\tk_eff = 0.625030\tres = 2.253E-02\n",
-      "[  NORMAL ]  Iteration 51:\tk_eff = 0.638591\tres = 2.212E-02\n",
-      "[  NORMAL ]  Iteration 52:\tk_eff = 0.652160\tres = 2.170E-02\n",
-      "[  NORMAL ]  Iteration 53:\tk_eff = 0.665712\tres = 2.125E-02\n",
-      "[  NORMAL ]  Iteration 54:\tk_eff = 0.679230\tres = 2.078E-02\n",
-      "[  NORMAL ]  Iteration 55:\tk_eff = 0.692690\tres = 2.031E-02\n",
-      "[  NORMAL ]  Iteration 56:\tk_eff = 0.706077\tres = 1.982E-02\n",
-      "[  NORMAL ]  Iteration 57:\tk_eff = 0.719372\tres = 1.933E-02\n",
-      "[  NORMAL ]  Iteration 58:\tk_eff = 0.732558\tres = 1.883E-02\n",
-      "[  NORMAL ]  Iteration 59:\tk_eff = 0.745622\tres = 1.833E-02\n",
-      "[  NORMAL ]  Iteration 60:\tk_eff = 0.758549\tres = 1.783E-02\n",
-      "[  NORMAL ]  Iteration 61:\tk_eff = 0.771326\tres = 1.734E-02\n",
-      "[  NORMAL ]  Iteration 62:\tk_eff = 0.783943\tres = 1.684E-02\n",
-      "[  NORMAL ]  Iteration 63:\tk_eff = 0.796387\tres = 1.636E-02\n",
-      "[  NORMAL ]  Iteration 64:\tk_eff = 0.808649\tres = 1.587E-02\n",
-      "[  NORMAL ]  Iteration 65:\tk_eff = 0.820722\tres = 1.540E-02\n",
-      "[  NORMAL ]  Iteration 66:\tk_eff = 0.832597\tres = 1.493E-02\n",
-      "[  NORMAL ]  Iteration 67:\tk_eff = 0.844268\tres = 1.447E-02\n",
-      "[  NORMAL ]  Iteration 68:\tk_eff = 0.855727\tres = 1.402E-02\n",
-      "[  NORMAL ]  Iteration 69:\tk_eff = 0.866972\tres = 1.357E-02\n",
-      "[  NORMAL ]  Iteration 70:\tk_eff = 0.877995\tres = 1.314E-02\n",
-      "[  NORMAL ]  Iteration 71:\tk_eff = 0.888795\tres = 1.272E-02\n",
-      "[  NORMAL ]  Iteration 72:\tk_eff = 0.899368\tres = 1.230E-02\n",
-      "[  NORMAL ]  Iteration 73:\tk_eff = 0.909712\tres = 1.190E-02\n",
-      "[  NORMAL ]  Iteration 74:\tk_eff = 0.919823\tres = 1.150E-02\n",
-      "[  NORMAL ]  Iteration 75:\tk_eff = 0.929703\tres = 1.112E-02\n",
-      "[  NORMAL ]  Iteration 76:\tk_eff = 0.939349\tres = 1.074E-02\n",
-      "[  NORMAL ]  Iteration 77:\tk_eff = 0.948762\tres = 1.038E-02\n",
-      "[  NORMAL ]  Iteration 78:\tk_eff = 0.957942\tres = 1.002E-02\n",
-      "[  NORMAL ]  Iteration 79:\tk_eff = 0.966889\tres = 9.676E-03\n",
-      "[  NORMAL ]  Iteration 80:\tk_eff = 0.975605\tres = 9.339E-03\n",
-      "[  NORMAL ]  Iteration 81:\tk_eff = 0.984090\tres = 9.015E-03\n",
-      "[  NORMAL ]  Iteration 82:\tk_eff = 0.992347\tres = 8.698E-03\n",
-      "[  NORMAL ]  Iteration 83:\tk_eff = 1.000378\tres = 8.391E-03\n",
-      "[  NORMAL ]  Iteration 84:\tk_eff = 1.008186\tres = 8.093E-03\n",
-      "[  NORMAL ]  Iteration 85:\tk_eff = 1.015772\tres = 7.804E-03\n",
-      "[  NORMAL ]  Iteration 86:\tk_eff = 1.023139\tres = 7.524E-03\n",
-      "[  NORMAL ]  Iteration 87:\tk_eff = 1.030292\tres = 7.253E-03\n",
-      "[  NORMAL ]  Iteration 88:\tk_eff = 1.037231\tres = 6.991E-03\n",
-      "[  NORMAL ]  Iteration 89:\tk_eff = 1.043963\tres = 6.736E-03\n",
-      "[  NORMAL ]  Iteration 90:\tk_eff = 1.050489\tres = 6.490E-03\n",
-      "[  NORMAL ]  Iteration 91:\tk_eff = 1.056814\tres = 6.252E-03\n",
-      "[  NORMAL ]  Iteration 92:\tk_eff = 1.062941\tres = 6.021E-03\n",
-      "[  NORMAL ]  Iteration 93:\tk_eff = 1.068875\tres = 5.798E-03\n",
-      "[  NORMAL ]  Iteration 94:\tk_eff = 1.074618\tres = 5.582E-03\n",
-      "[  NORMAL ]  Iteration 95:\tk_eff = 1.080176\tres = 5.373E-03\n",
-      "[  NORMAL ]  Iteration 96:\tk_eff = 1.085552\tres = 5.172E-03\n",
-      "[  NORMAL ]  Iteration 97:\tk_eff = 1.090750\tres = 4.977E-03\n",
-      "[  NORMAL ]  Iteration 98:\tk_eff = 1.095775\tres = 4.789E-03\n",
-      "[  NORMAL ]  Iteration 99:\tk_eff = 1.100631\tres = 4.607E-03\n",
-      "[  NORMAL ]  Iteration 100:\tk_eff = 1.105322\tres = 4.432E-03\n",
-      "[  NORMAL ]  Iteration 101:\tk_eff = 1.109852\tres = 4.262E-03\n",
-      "[  NORMAL ]  Iteration 102:\tk_eff = 1.114225\tres = 4.098E-03\n",
-      "[  NORMAL ]  Iteration 103:\tk_eff = 1.118446\tres = 3.940E-03\n",
-      "[  NORMAL ]  Iteration 104:\tk_eff = 1.122519\tres = 3.788E-03\n",
-      "[  NORMAL ]  Iteration 105:\tk_eff = 1.126446\tres = 3.641E-03\n",
-      "[  NORMAL ]  Iteration 106:\tk_eff = 1.130234\tres = 3.499E-03\n",
-      "[  NORMAL ]  Iteration 107:\tk_eff = 1.133885\tres = 3.362E-03\n",
-      "[  NORMAL ]  Iteration 108:\tk_eff = 1.137404\tres = 3.231E-03\n",
-      "[  NORMAL ]  Iteration 109:\tk_eff = 1.140795\tres = 3.103E-03\n",
-      "[  NORMAL ]  Iteration 110:\tk_eff = 1.144060\tres = 2.981E-03\n",
-      "[  NORMAL ]  Iteration 111:\tk_eff = 1.147205\tres = 2.863E-03\n",
-      "[  NORMAL ]  Iteration 112:\tk_eff = 1.150233\tres = 2.749E-03\n",
-      "[  NORMAL ]  Iteration 113:\tk_eff = 1.153147\tres = 2.639E-03\n",
-      "[  NORMAL ]  Iteration 114:\tk_eff = 1.155952\tres = 2.533E-03\n",
-      "[  NORMAL ]  Iteration 115:\tk_eff = 1.158650\tres = 2.432E-03\n",
-      "[  NORMAL ]  Iteration 116:\tk_eff = 1.161245\tres = 2.334E-03\n",
-      "[  NORMAL ]  Iteration 117:\tk_eff = 1.163741\tres = 2.240E-03\n",
-      "[  NORMAL ]  Iteration 118:\tk_eff = 1.166140\tres = 2.149E-03\n",
-      "[  NORMAL ]  Iteration 119:\tk_eff = 1.168446\tres = 2.061E-03\n",
-      "[  NORMAL ]  Iteration 120:\tk_eff = 1.170663\tres = 1.978E-03\n",
-      "[  NORMAL ]  Iteration 121:\tk_eff = 1.172792\tres = 1.897E-03\n",
-      "[  NORMAL ]  Iteration 122:\tk_eff = 1.174838\tres = 1.819E-03\n",
-      "[  NORMAL ]  Iteration 123:\tk_eff = 1.176803\tres = 1.745E-03\n",
-      "[  NORMAL ]  Iteration 124:\tk_eff = 1.178689\tres = 1.672E-03\n",
-      "[  NORMAL ]  Iteration 125:\tk_eff = 1.180500\tres = 1.603E-03\n",
-      "[  NORMAL ]  Iteration 126:\tk_eff = 1.182238\tres = 1.537E-03\n",
-      "[  NORMAL ]  Iteration 127:\tk_eff = 1.183907\tres = 1.473E-03\n",
-      "[  NORMAL ]  Iteration 128:\tk_eff = 1.185508\tres = 1.411E-03\n",
-      "[  NORMAL ]  Iteration 129:\tk_eff = 1.187044\tres = 1.352E-03\n",
-      "[  NORMAL ]  Iteration 130:\tk_eff = 1.188517\tres = 1.296E-03\n",
-      "[  NORMAL ]  Iteration 131:\tk_eff = 1.189930\tres = 1.241E-03\n",
-      "[  NORMAL ]  Iteration 132:\tk_eff = 1.191285\tres = 1.189E-03\n",
-      "[  NORMAL ]  Iteration 133:\tk_eff = 1.192584\tres = 1.139E-03\n",
-      "[  NORMAL ]  Iteration 134:\tk_eff = 1.193829\tres = 1.090E-03\n",
-      "[  NORMAL ]  Iteration 135:\tk_eff = 1.195022\tres = 1.044E-03\n",
-      "[  NORMAL ]  Iteration 136:\tk_eff = 1.196165\tres = 9.990E-04\n",
-      "[  NORMAL ]  Iteration 137:\tk_eff = 1.197260\tres = 9.567E-04\n",
-      "[  NORMAL ]  Iteration 138:\tk_eff = 1.198310\tres = 9.157E-04\n",
-      "[  NORMAL ]  Iteration 139:\tk_eff = 1.199315\tres = 8.769E-04\n",
-      "[  NORMAL ]  Iteration 140:\tk_eff = 1.200278\tres = 8.387E-04\n",
-      "[  NORMAL ]  Iteration 141:\tk_eff = 1.201200\tres = 8.029E-04\n",
-      "[  NORMAL ]  Iteration 142:\tk_eff = 1.202082\tres = 7.680E-04\n",
-      "[  NORMAL ]  Iteration 143:\tk_eff = 1.202927\tres = 7.346E-04\n",
-      "[  NORMAL ]  Iteration 144:\tk_eff = 1.203735\tres = 7.025E-04\n",
-      "[  NORMAL ]  Iteration 145:\tk_eff = 1.204509\tres = 6.720E-04\n",
-      "[  NORMAL ]  Iteration 146:\tk_eff = 1.205250\tres = 6.427E-04\n",
-      "[  NORMAL ]  Iteration 147:\tk_eff = 1.205958\tres = 6.153E-04\n",
-      "[  NORMAL ]  Iteration 148:\tk_eff = 1.206636\tres = 5.875E-04\n",
-      "[  NORMAL ]  Iteration 149:\tk_eff = 1.207283\tres = 5.623E-04\n",
-      "[  NORMAL ]  Iteration 150:\tk_eff = 1.207903\tres = 5.369E-04\n",
-      "[  NORMAL ]  Iteration 151:\tk_eff = 1.208496\tres = 5.133E-04\n",
-      "[  NORMAL ]  Iteration 152:\tk_eff = 1.209063\tres = 4.911E-04\n",
-      "[  NORMAL ]  Iteration 153:\tk_eff = 1.209605\tres = 4.693E-04\n",
-      "[  NORMAL ]  Iteration 154:\tk_eff = 1.210123\tres = 4.478E-04\n",
-      "[  NORMAL ]  Iteration 155:\tk_eff = 1.210618\tres = 4.283E-04\n",
-      "[  NORMAL ]  Iteration 156:\tk_eff = 1.211091\tres = 4.091E-04\n",
-      "[  NORMAL ]  Iteration 157:\tk_eff = 1.211544\tres = 3.910E-04\n",
-      "[  NORMAL ]  Iteration 158:\tk_eff = 1.211976\tres = 3.738E-04\n",
-      "[  NORMAL ]  Iteration 159:\tk_eff = 1.212389\tres = 3.565E-04\n",
-      "[  NORMAL ]  Iteration 160:\tk_eff = 1.212783\tres = 3.406E-04\n",
-      "[  NORMAL ]  Iteration 161:\tk_eff = 1.213160\tres = 3.252E-04\n",
-      "[  NORMAL ]  Iteration 162:\tk_eff = 1.213519\tres = 3.108E-04\n",
-      "[  NORMAL ]  Iteration 163:\tk_eff = 1.213863\tres = 2.962E-04\n",
-      "[  NORMAL ]  Iteration 164:\tk_eff = 1.214191\tres = 2.837E-04\n",
-      "[  NORMAL ]  Iteration 165:\tk_eff = 1.214505\tres = 2.699E-04\n",
-      "[  NORMAL ]  Iteration 166:\tk_eff = 1.214804\tres = 2.585E-04\n",
-      "[  NORMAL ]  Iteration 167:\tk_eff = 1.215089\tres = 2.463E-04\n",
-      "[  NORMAL ]  Iteration 168:\tk_eff = 1.215362\tres = 2.349E-04\n",
-      "[  NORMAL ]  Iteration 169:\tk_eff = 1.215622\tres = 2.247E-04\n",
-      "[  NORMAL ]  Iteration 170:\tk_eff = 1.215871\tres = 2.140E-04\n",
-      "[  NORMAL ]  Iteration 171:\tk_eff = 1.216107\tres = 2.044E-04\n",
-      "[  NORMAL ]  Iteration 172:\tk_eff = 1.216334\tres = 1.948E-04\n",
-      "[  NORMAL ]  Iteration 173:\tk_eff = 1.216549\tres = 1.861E-04\n",
-      "[  NORMAL ]  Iteration 174:\tk_eff = 1.216755\tres = 1.769E-04\n",
-      "[  NORMAL ]  Iteration 175:\tk_eff = 1.216952\tres = 1.697E-04\n",
-      "[  NORMAL ]  Iteration 176:\tk_eff = 1.217139\tres = 1.615E-04\n",
-      "[  NORMAL ]  Iteration 177:\tk_eff = 1.217317\tres = 1.541E-04\n",
-      "[  NORMAL ]  Iteration 178:\tk_eff = 1.217487\tres = 1.462E-04\n",
-      "[  NORMAL ]  Iteration 179:\tk_eff = 1.217650\tres = 1.398E-04\n",
-      "[  NORMAL ]  Iteration 180:\tk_eff = 1.217805\tres = 1.335E-04\n",
-      "[  NORMAL ]  Iteration 181:\tk_eff = 1.217953\tres = 1.274E-04\n",
-      "[  NORMAL ]  Iteration 182:\tk_eff = 1.218094\tres = 1.217E-04\n",
-      "[  NORMAL ]  Iteration 183:\tk_eff = 1.218228\tres = 1.159E-04\n",
-      "[  NORMAL ]  Iteration 184:\tk_eff = 1.218356\tres = 1.100E-04\n",
-      "[  NORMAL ]  Iteration 185:\tk_eff = 1.218478\tres = 1.048E-04\n",
-      "[  NORMAL ]  Iteration 186:\tk_eff = 1.218595\tres = 1.003E-04\n",
-      "[  NORMAL ]  Iteration 187:\tk_eff = 1.218706\tres = 9.574E-05\n",
-      "[  NORMAL ]  Iteration 188:\tk_eff = 1.218811\tres = 9.094E-05\n",
-      "[  NORMAL ]  Iteration 189:\tk_eff = 1.218912\tres = 8.629E-05\n",
-      "[  NORMAL ]  Iteration 190:\tk_eff = 1.219007\tres = 8.297E-05\n",
-      "[  NORMAL ]  Iteration 191:\tk_eff = 1.219099\tres = 7.863E-05\n",
-      "[  NORMAL ]  Iteration 192:\tk_eff = 1.219186\tres = 7.491E-05\n",
-      "[  NORMAL ]  Iteration 193:\tk_eff = 1.219269\tres = 7.150E-05\n",
-      "[  NORMAL ]  Iteration 194:\tk_eff = 1.219348\tres = 6.807E-05\n",
-      "[  NORMAL ]  Iteration 195:\tk_eff = 1.219422\tres = 6.487E-05\n",
-      "[  NORMAL ]  Iteration 196:\tk_eff = 1.219495\tres = 6.123E-05\n",
-      "[  NORMAL ]  Iteration 197:\tk_eff = 1.219563\tres = 5.915E-05\n",
-      "[  NORMAL ]  Iteration 198:\tk_eff = 1.219628\tres = 5.636E-05\n",
-      "[  NORMAL ]  Iteration 199:\tk_eff = 1.219690\tres = 5.317E-05\n",
-      "[  NORMAL ]  Iteration 200:\tk_eff = 1.219749\tres = 5.112E-05\n",
-      "[  NORMAL ]  Iteration 201:\tk_eff = 1.219805\tres = 4.824E-05\n",
-      "[  NORMAL ]  Iteration 202:\tk_eff = 1.219859\tres = 4.589E-05\n",
-      "[  NORMAL ]  Iteration 203:\tk_eff = 1.219910\tres = 4.396E-05\n",
-      "[  NORMAL ]  Iteration 204:\tk_eff = 1.219958\tres = 4.158E-05\n",
-      "[  NORMAL ]  Iteration 205:\tk_eff = 1.220004\tres = 3.979E-05\n",
-      "[  NORMAL ]  Iteration 206:\tk_eff = 1.220049\tres = 3.760E-05\n",
-      "[  NORMAL ]  Iteration 207:\tk_eff = 1.220090\tres = 3.661E-05\n",
-      "[  NORMAL ]  Iteration 208:\tk_eff = 1.220130\tres = 3.402E-05\n",
-      "[  NORMAL ]  Iteration 209:\tk_eff = 1.220168\tres = 3.256E-05\n",
-      "[  NORMAL ]  Iteration 210:\tk_eff = 1.220204\tres = 3.124E-05\n",
-      "[  NORMAL ]  Iteration 211:\tk_eff = 1.220238\tres = 2.947E-05\n",
-      "[  NORMAL ]  Iteration 212:\tk_eff = 1.220271\tres = 2.821E-05\n",
-      "[  NORMAL ]  Iteration 213:\tk_eff = 1.220302\tres = 2.666E-05\n",
-      "[  NORMAL ]  Iteration 214:\tk_eff = 1.220332\tres = 2.561E-05\n",
-      "[  NORMAL ]  Iteration 215:\tk_eff = 1.220360\tres = 2.450E-05\n",
-      "[  NORMAL ]  Iteration 216:\tk_eff = 1.220387\tres = 2.299E-05\n",
-      "[  NORMAL ]  Iteration 217:\tk_eff = 1.220413\tres = 2.190E-05\n",
-      "[  NORMAL ]  Iteration 218:\tk_eff = 1.220437\tres = 2.109E-05\n",
-      "[  NORMAL ]  Iteration 219:\tk_eff = 1.220460\tres = 1.982E-05\n",
-      "[  NORMAL ]  Iteration 220:\tk_eff = 1.220482\tres = 1.916E-05\n",
-      "[  NORMAL ]  Iteration 221:\tk_eff = 1.220503\tres = 1.792E-05\n",
-      "[  NORMAL ]  Iteration 222:\tk_eff = 1.220523\tres = 1.701E-05\n",
-      "[  NORMAL ]  Iteration 223:\tk_eff = 1.220541\tres = 1.615E-05\n",
-      "[  NORMAL ]  Iteration 224:\tk_eff = 1.220559\tres = 1.526E-05\n",
-      "[  NORMAL ]  Iteration 225:\tk_eff = 1.220576\tres = 1.439E-05\n",
-      "[  NORMAL ]  Iteration 226:\tk_eff = 1.220592\tres = 1.418E-05\n",
-      "[  NORMAL ]  Iteration 227:\tk_eff = 1.220608\tres = 1.350E-05\n",
-      "[  NORMAL ]  Iteration 228:\tk_eff = 1.220623\tres = 1.269E-05\n",
-      "[  NORMAL ]  Iteration 229:\tk_eff = 1.220637\tres = 1.193E-05\n",
-      "[  NORMAL ]  Iteration 230:\tk_eff = 1.220650\tres = 1.161E-05\n",
-      "[  NORMAL ]  Iteration 231:\tk_eff = 1.220663\tres = 1.090E-05\n",
-      "[  NORMAL ]  Iteration 232:\tk_eff = 1.220675\tres = 1.033E-05\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"
      ]
     }
    ],
@@ -1449,25 +1693,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 24,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "openmc keff = 1.224484\n",
-      "openmoc keff = 1.220675\n",
-      "bias [pcm]: -380.9\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[0]\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",
@@ -1484,24 +1726,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1798: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1799: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  other_rel_err = data['other']['std. dev.'] / data['other']['mean']\n",
-      "/home/romano/openmc/openmc/tallies.py:1800: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  new_tally._mean = data['self']['mean'] / data['other']['mean']\n"
-     ]
-    }
-   ],
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "openmoc_geometry = get_openmoc_geometry(sp.summary.geometry)\n",
     "openmoc_cells = openmoc_geometry.getRootUniverse().getAllCells()\n",
@@ -1537,357 +1764,760 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 26,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[  NORMAL ]  Importing ray tracing data from file...\n",
+      "[  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:\tk_eff = 0.366885\tres = 0.000E+00\n",
-      "[  NORMAL ]  Iteration 1:\tk_eff = 0.391184\tres = 6.331E-01\n",
-      "[  NORMAL ]  Iteration 2:\tk_eff = 0.392990\tres = 6.623E-02\n",
-      "[  NORMAL ]  Iteration 3:\tk_eff = 0.381099\tres = 4.617E-03\n",
-      "[  NORMAL ]  Iteration 4:\tk_eff = 0.375018\tres = 3.026E-02\n",
-      "[  NORMAL ]  Iteration 5:\tk_eff = 0.369593\tres = 1.596E-02\n",
-      "[  NORMAL ]  Iteration 6:\tk_eff = 0.365543\tres = 1.446E-02\n",
-      "[  NORMAL ]  Iteration 7:\tk_eff = 0.363055\tres = 1.096E-02\n",
-      "[  NORMAL ]  Iteration 8:\tk_eff = 0.361474\tres = 6.809E-03\n",
-      "[  NORMAL ]  Iteration 9:\tk_eff = 0.361280\tres = 4.354E-03\n",
-      "[  NORMAL ]  Iteration 10:\tk_eff = 0.362004\tres = 5.348E-04\n",
-      "[  NORMAL ]  Iteration 11:\tk_eff = 0.363719\tres = 2.003E-03\n",
-      "[  NORMAL ]  Iteration 12:\tk_eff = 0.366339\tres = 4.737E-03\n",
-      "[  NORMAL ]  Iteration 13:\tk_eff = 0.369805\tres = 7.203E-03\n",
-      "[  NORMAL ]  Iteration 14:\tk_eff = 0.373990\tres = 9.461E-03\n",
-      "[  NORMAL ]  Iteration 15:\tk_eff = 0.378924\tres = 1.132E-02\n",
-      "[  NORMAL ]  Iteration 16:\tk_eff = 0.384480\tres = 1.319E-02\n",
-      "[  NORMAL ]  Iteration 17:\tk_eff = 0.390638\tres = 1.466E-02\n",
-      "[  NORMAL ]  Iteration 18:\tk_eff = 0.397339\tres = 1.602E-02\n",
-      "[  NORMAL ]  Iteration 19:\tk_eff = 0.404534\tres = 1.715E-02\n",
-      "[  NORMAL ]  Iteration 20:\tk_eff = 0.412185\tres = 1.811E-02\n",
-      "[  NORMAL ]  Iteration 21:\tk_eff = 0.420255\tres = 1.891E-02\n",
-      "[  NORMAL ]  Iteration 22:\tk_eff = 0.428688\tres = 1.958E-02\n",
-      "[  NORMAL ]  Iteration 23:\tk_eff = 0.437464\tres = 2.007E-02\n",
-      "[  NORMAL ]  Iteration 24:\tk_eff = 0.446540\tres = 2.047E-02\n",
-      "[  NORMAL ]  Iteration 25:\tk_eff = 0.455885\tres = 2.075E-02\n",
-      "[  NORMAL ]  Iteration 26:\tk_eff = 0.465470\tres = 2.093E-02\n",
-      "[  NORMAL ]  Iteration 27:\tk_eff = 0.475267\tres = 2.103E-02\n",
-      "[  NORMAL ]  Iteration 28:\tk_eff = 0.485247\tres = 2.105E-02\n",
-      "[  NORMAL ]  Iteration 29:\tk_eff = 0.495387\tres = 2.100E-02\n",
-      "[  NORMAL ]  Iteration 30:\tk_eff = 0.505663\tres = 2.090E-02\n",
-      "[  NORMAL ]  Iteration 31:\tk_eff = 0.516053\tres = 2.074E-02\n",
-      "[  NORMAL ]  Iteration 32:\tk_eff = 0.526536\tres = 2.055E-02\n",
-      "[  NORMAL ]  Iteration 33:\tk_eff = 0.537094\tres = 2.031E-02\n",
-      "[  NORMAL ]  Iteration 34:\tk_eff = 0.547708\tres = 2.005E-02\n",
-      "[  NORMAL ]  Iteration 35:\tk_eff = 0.558363\tres = 1.976E-02\n",
-      "[  NORMAL ]  Iteration 36:\tk_eff = 0.569042\tres = 1.945E-02\n",
-      "[  NORMAL ]  Iteration 37:\tk_eff = 0.579732\tres = 1.913E-02\n",
-      "[  NORMAL ]  Iteration 38:\tk_eff = 0.590419\tres = 1.879E-02\n",
-      "[  NORMAL ]  Iteration 39:\tk_eff = 0.601090\tres = 1.843E-02\n",
-      "[  NORMAL ]  Iteration 40:\tk_eff = 0.611734\tres = 1.807E-02\n",
-      "[  NORMAL ]  Iteration 41:\tk_eff = 0.622340\tres = 1.771E-02\n",
-      "[  NORMAL ]  Iteration 42:\tk_eff = 0.632899\tres = 1.734E-02\n",
-      "[  NORMAL ]  Iteration 43:\tk_eff = 0.643402\tres = 1.697E-02\n",
-      "[  NORMAL ]  Iteration 44:\tk_eff = 0.653840\tres = 1.659E-02\n",
-      "[  NORMAL ]  Iteration 45:\tk_eff = 0.664206\tres = 1.622E-02\n",
-      "[  NORMAL ]  Iteration 46:\tk_eff = 0.674492\tres = 1.585E-02\n",
-      "[  NORMAL ]  Iteration 47:\tk_eff = 0.684691\tres = 1.549E-02\n",
-      "[  NORMAL ]  Iteration 48:\tk_eff = 0.694799\tres = 1.512E-02\n",
-      "[  NORMAL ]  Iteration 49:\tk_eff = 0.704810\tres = 1.476E-02\n",
-      "[  NORMAL ]  Iteration 50:\tk_eff = 0.714718\tres = 1.441E-02\n",
-      "[  NORMAL ]  Iteration 51:\tk_eff = 0.724520\tres = 1.406E-02\n",
-      "[  NORMAL ]  Iteration 52:\tk_eff = 0.734212\tres = 1.371E-02\n",
-      "[  NORMAL ]  Iteration 53:\tk_eff = 0.743790\tres = 1.338E-02\n",
-      "[  NORMAL ]  Iteration 54:\tk_eff = 0.753250\tres = 1.304E-02\n",
-      "[  NORMAL ]  Iteration 55:\tk_eff = 0.762592\tres = 1.272E-02\n",
-      "[  NORMAL ]  Iteration 56:\tk_eff = 0.771809\tres = 1.240E-02\n",
-      "[  NORMAL ]  Iteration 57:\tk_eff = 0.780904\tres = 1.209E-02\n",
-      "[  NORMAL ]  Iteration 58:\tk_eff = 0.789871\tres = 1.178E-02\n",
-      "[  NORMAL ]  Iteration 59:\tk_eff = 0.798711\tres = 1.148E-02\n",
-      "[  NORMAL ]  Iteration 60:\tk_eff = 0.807422\tres = 1.119E-02\n",
-      "[  NORMAL ]  Iteration 61:\tk_eff = 0.816003\tres = 1.091E-02\n",
-      "[  NORMAL ]  Iteration 62:\tk_eff = 0.824453\tres = 1.063E-02\n",
-      "[  NORMAL ]  Iteration 63:\tk_eff = 0.832771\tres = 1.035E-02\n",
-      "[  NORMAL ]  Iteration 64:\tk_eff = 0.840957\tres = 1.009E-02\n",
-      "[  NORMAL ]  Iteration 65:\tk_eff = 0.849011\tres = 9.830E-03\n",
-      "[  NORMAL ]  Iteration 66:\tk_eff = 0.856933\tres = 9.577E-03\n",
-      "[  NORMAL ]  Iteration 67:\tk_eff = 0.864723\tres = 9.331E-03\n",
-      "[  NORMAL ]  Iteration 68:\tk_eff = 0.872381\tres = 9.090E-03\n",
-      "[  NORMAL ]  Iteration 69:\tk_eff = 0.879908\tres = 8.856E-03\n",
-      "[  NORMAL ]  Iteration 70:\tk_eff = 0.887304\tres = 8.628E-03\n",
-      "[  NORMAL ]  Iteration 71:\tk_eff = 0.894569\tres = 8.405E-03\n",
-      "[  NORMAL ]  Iteration 72:\tk_eff = 0.901706\tres = 8.188E-03\n",
-      "[  NORMAL ]  Iteration 73:\tk_eff = 0.908713\tres = 7.978E-03\n",
-      "[  NORMAL ]  Iteration 74:\tk_eff = 0.915593\tres = 7.771E-03\n",
-      "[  NORMAL ]  Iteration 75:\tk_eff = 0.922346\tres = 7.571E-03\n",
-      "[  NORMAL ]  Iteration 76:\tk_eff = 0.928973\tres = 7.376E-03\n",
-      "[  NORMAL ]  Iteration 77:\tk_eff = 0.935476\tres = 7.186E-03\n",
-      "[  NORMAL ]  Iteration 78:\tk_eff = 0.941856\tres = 7.000E-03\n",
-      "[  NORMAL ]  Iteration 79:\tk_eff = 0.948114\tres = 6.820E-03\n",
-      "[  NORMAL ]  Iteration 80:\tk_eff = 0.954252\tres = 6.645E-03\n",
-      "[  NORMAL ]  Iteration 81:\tk_eff = 0.960270\tres = 6.473E-03\n",
-      "[  NORMAL ]  Iteration 82:\tk_eff = 0.966171\tres = 6.307E-03\n",
-      "[  NORMAL ]  Iteration 83:\tk_eff = 0.971955\tres = 6.145E-03\n",
-      "[  NORMAL ]  Iteration 84:\tk_eff = 0.977625\tres = 5.987E-03\n",
-      "[  NORMAL ]  Iteration 85:\tk_eff = 0.983181\tres = 5.833E-03\n",
-      "[  NORMAL ]  Iteration 86:\tk_eff = 0.988626\tres = 5.684E-03\n",
-      "[  NORMAL ]  Iteration 87:\tk_eff = 0.993961\tres = 5.538E-03\n",
-      "[  NORMAL ]  Iteration 88:\tk_eff = 0.999186\tres = 5.396E-03\n",
-      "[  NORMAL ]  Iteration 89:\tk_eff = 1.004306\tres = 5.258E-03\n",
-      "[  NORMAL ]  Iteration 90:\tk_eff = 1.009320\tres = 5.124E-03\n",
-      "[  NORMAL ]  Iteration 91:\tk_eff = 1.014230\tres = 4.993E-03\n",
-      "[  NORMAL ]  Iteration 92:\tk_eff = 1.019038\tres = 4.865E-03\n",
-      "[  NORMAL ]  Iteration 93:\tk_eff = 1.023746\tres = 4.740E-03\n",
-      "[  NORMAL ]  Iteration 94:\tk_eff = 1.028355\tres = 4.621E-03\n",
-      "[  NORMAL ]  Iteration 95:\tk_eff = 1.032868\tres = 4.502E-03\n",
-      "[  NORMAL ]  Iteration 96:\tk_eff = 1.037284\tres = 4.388E-03\n",
-      "[  NORMAL ]  Iteration 97:\tk_eff = 1.041606\tres = 4.275E-03\n",
-      "[  NORMAL ]  Iteration 98:\tk_eff = 1.045837\tres = 4.167E-03\n",
-      "[  NORMAL ]  Iteration 99:\tk_eff = 1.049976\tres = 4.062E-03\n",
-      "[  NORMAL ]  Iteration 100:\tk_eff = 1.054027\tres = 3.958E-03\n",
-      "[  NORMAL ]  Iteration 101:\tk_eff = 1.057990\tres = 3.858E-03\n",
-      "[  NORMAL ]  Iteration 102:\tk_eff = 1.061867\tres = 3.760E-03\n",
-      "[  NORMAL ]  Iteration 103:\tk_eff = 1.065660\tres = 3.665E-03\n",
-      "[  NORMAL ]  Iteration 104:\tk_eff = 1.069370\tres = 3.572E-03\n",
-      "[  NORMAL ]  Iteration 105:\tk_eff = 1.072999\tres = 3.482E-03\n",
-      "[  NORMAL ]  Iteration 106:\tk_eff = 1.076548\tres = 3.394E-03\n",
-      "[  NORMAL ]  Iteration 107:\tk_eff = 1.080020\tres = 3.307E-03\n",
-      "[  NORMAL ]  Iteration 108:\tk_eff = 1.083415\tres = 3.225E-03\n",
-      "[  NORMAL ]  Iteration 109:\tk_eff = 1.086734\tres = 3.143E-03\n",
-      "[  NORMAL ]  Iteration 110:\tk_eff = 1.089979\tres = 3.064E-03\n",
-      "[  NORMAL ]  Iteration 111:\tk_eff = 1.093153\tres = 2.986E-03\n",
-      "[  NORMAL ]  Iteration 112:\tk_eff = 1.096256\tres = 2.912E-03\n",
-      "[  NORMAL ]  Iteration 113:\tk_eff = 1.099289\tres = 2.838E-03\n",
-      "[  NORMAL ]  Iteration 114:\tk_eff = 1.102254\tres = 2.767E-03\n",
-      "[  NORMAL ]  Iteration 115:\tk_eff = 1.105153\tres = 2.697E-03\n",
-      "[  NORMAL ]  Iteration 116:\tk_eff = 1.107986\tres = 2.630E-03\n",
-      "[  NORMAL ]  Iteration 117:\tk_eff = 1.110755\tres = 2.564E-03\n",
-      "[  NORMAL ]  Iteration 118:\tk_eff = 1.113462\tres = 2.500E-03\n",
-      "[  NORMAL ]  Iteration 119:\tk_eff = 1.116107\tres = 2.437E-03\n",
-      "[  NORMAL ]  Iteration 120:\tk_eff = 1.118693\tres = 2.376E-03\n",
-      "[  NORMAL ]  Iteration 121:\tk_eff = 1.121219\tres = 2.316E-03\n",
-      "[  NORMAL ]  Iteration 122:\tk_eff = 1.123687\tres = 2.258E-03\n",
-      "[  NORMAL ]  Iteration 123:\tk_eff = 1.126100\tres = 2.202E-03\n",
-      "[  NORMAL ]  Iteration 124:\tk_eff = 1.128457\tres = 2.148E-03\n",
-      "[  NORMAL ]  Iteration 125:\tk_eff = 1.130760\tres = 2.093E-03\n",
-      "[  NORMAL ]  Iteration 126:\tk_eff = 1.133010\tres = 2.041E-03\n",
-      "[  NORMAL ]  Iteration 127:\tk_eff = 1.135208\tres = 1.990E-03\n",
-      "[  NORMAL ]  Iteration 128:\tk_eff = 1.137357\tres = 1.941E-03\n",
-      "[  NORMAL ]  Iteration 129:\tk_eff = 1.139455\tres = 1.892E-03\n",
-      "[  NORMAL ]  Iteration 130:\tk_eff = 1.141505\tres = 1.845E-03\n",
-      "[  NORMAL ]  Iteration 131:\tk_eff = 1.143507\tres = 1.799E-03\n",
-      "[  NORMAL ]  Iteration 132:\tk_eff = 1.145464\tres = 1.754E-03\n",
-      "[  NORMAL ]  Iteration 133:\tk_eff = 1.147374\tres = 1.711E-03\n",
-      "[  NORMAL ]  Iteration 134:\tk_eff = 1.149240\tres = 1.668E-03\n",
-      "[  NORMAL ]  Iteration 135:\tk_eff = 1.151063\tres = 1.626E-03\n",
-      "[  NORMAL ]  Iteration 136:\tk_eff = 1.152844\tres = 1.586E-03\n",
-      "[  NORMAL ]  Iteration 137:\tk_eff = 1.154583\tres = 1.547E-03\n",
-      "[  NORMAL ]  Iteration 138:\tk_eff = 1.156281\tres = 1.508E-03\n",
-      "[  NORMAL ]  Iteration 139:\tk_eff = 1.157940\tres = 1.471E-03\n",
-      "[  NORMAL ]  Iteration 140:\tk_eff = 1.159560\tres = 1.435E-03\n",
-      "[  NORMAL ]  Iteration 141:\tk_eff = 1.161142\tres = 1.399E-03\n",
-      "[  NORMAL ]  Iteration 142:\tk_eff = 1.162687\tres = 1.364E-03\n",
-      "[  NORMAL ]  Iteration 143:\tk_eff = 1.164195\tres = 1.330E-03\n",
-      "[  NORMAL ]  Iteration 144:\tk_eff = 1.165669\tres = 1.297E-03\n",
-      "[  NORMAL ]  Iteration 145:\tk_eff = 1.167107\tres = 1.266E-03\n",
-      "[  NORMAL ]  Iteration 146:\tk_eff = 1.168512\tres = 1.234E-03\n",
-      "[  NORMAL ]  Iteration 147:\tk_eff = 1.169883\tres = 1.203E-03\n",
-      "[  NORMAL ]  Iteration 148:\tk_eff = 1.171222\tres = 1.174E-03\n",
-      "[  NORMAL ]  Iteration 149:\tk_eff = 1.172530\tres = 1.144E-03\n",
-      "[  NORMAL ]  Iteration 150:\tk_eff = 1.173807\tres = 1.117E-03\n",
-      "[  NORMAL ]  Iteration 151:\tk_eff = 1.175054\tres = 1.089E-03\n",
-      "[  NORMAL ]  Iteration 152:\tk_eff = 1.176271\tres = 1.062E-03\n",
-      "[  NORMAL ]  Iteration 153:\tk_eff = 1.177459\tres = 1.036E-03\n",
-      "[  NORMAL ]  Iteration 154:\tk_eff = 1.178619\tres = 1.010E-03\n",
-      "[  NORMAL ]  Iteration 155:\tk_eff = 1.179752\tres = 9.854E-04\n",
-      "[  NORMAL ]  Iteration 156:\tk_eff = 1.180858\tres = 9.608E-04\n",
-      "[  NORMAL ]  Iteration 157:\tk_eff = 1.181938\tres = 9.371E-04\n",
-      "[  NORMAL ]  Iteration 158:\tk_eff = 1.182992\tres = 9.147E-04\n",
-      "[  NORMAL ]  Iteration 159:\tk_eff = 1.184020\tres = 8.915E-04\n",
-      "[  NORMAL ]  Iteration 160:\tk_eff = 1.185025\tres = 8.696E-04\n",
-      "[  NORMAL ]  Iteration 161:\tk_eff = 1.186005\tres = 8.487E-04\n",
-      "[  NORMAL ]  Iteration 162:\tk_eff = 1.186962\tres = 8.268E-04\n",
-      "[  NORMAL ]  Iteration 163:\tk_eff = 1.187896\tres = 8.073E-04\n",
-      "[  NORMAL ]  Iteration 164:\tk_eff = 1.188808\tres = 7.869E-04\n",
-      "[  NORMAL ]  Iteration 165:\tk_eff = 1.189698\tres = 7.679E-04\n",
-      "[  NORMAL ]  Iteration 166:\tk_eff = 1.190567\tres = 7.487E-04\n",
-      "[  NORMAL ]  Iteration 167:\tk_eff = 1.191415\tres = 7.301E-04\n",
-      "[  NORMAL ]  Iteration 168:\tk_eff = 1.192243\tres = 7.126E-04\n",
-      "[  NORMAL ]  Iteration 169:\tk_eff = 1.193051\tres = 6.949E-04\n",
-      "[  NORMAL ]  Iteration 170:\tk_eff = 1.193840\tres = 6.775E-04\n",
-      "[  NORMAL ]  Iteration 171:\tk_eff = 1.194610\tres = 6.613E-04\n",
-      "[  NORMAL ]  Iteration 172:\tk_eff = 1.195361\tres = 6.454E-04\n",
-      "[  NORMAL ]  Iteration 173:\tk_eff = 1.196095\tres = 6.290E-04\n",
-      "[  NORMAL ]  Iteration 174:\tk_eff = 1.196810\tres = 6.136E-04\n",
-      "[  NORMAL ]  Iteration 175:\tk_eff = 1.197509\tres = 5.981E-04\n",
-      "[  NORMAL ]  Iteration 176:\tk_eff = 1.198191\tres = 5.840E-04\n",
-      "[  NORMAL ]  Iteration 177:\tk_eff = 1.198857\tres = 5.694E-04\n",
-      "[  NORMAL ]  Iteration 178:\tk_eff = 1.199507\tres = 5.556E-04\n",
-      "[  NORMAL ]  Iteration 179:\tk_eff = 1.200141\tres = 5.422E-04\n",
-      "[  NORMAL ]  Iteration 180:\tk_eff = 1.200760\tres = 5.284E-04\n",
-      "[  NORMAL ]  Iteration 181:\tk_eff = 1.201364\tres = 5.157E-04\n",
-      "[  NORMAL ]  Iteration 182:\tk_eff = 1.201954\tres = 5.031E-04\n",
-      "[  NORMAL ]  Iteration 183:\tk_eff = 1.202528\tres = 4.908E-04\n",
-      "[  NORMAL ]  Iteration 184:\tk_eff = 1.203090\tres = 4.782E-04\n",
-      "[  NORMAL ]  Iteration 185:\tk_eff = 1.203638\tres = 4.671E-04\n",
-      "[  NORMAL ]  Iteration 186:\tk_eff = 1.204172\tres = 4.552E-04\n",
-      "[  NORMAL ]  Iteration 187:\tk_eff = 1.204694\tres = 4.442E-04\n",
-      "[  NORMAL ]  Iteration 188:\tk_eff = 1.205204\tres = 4.335E-04\n",
-      "[  NORMAL ]  Iteration 189:\tk_eff = 1.205701\tres = 4.227E-04\n",
-      "[  NORMAL ]  Iteration 190:\tk_eff = 1.206186\tres = 4.128E-04\n",
-      "[  NORMAL ]  Iteration 191:\tk_eff = 1.206660\tres = 4.025E-04\n",
-      "[  NORMAL ]  Iteration 192:\tk_eff = 1.207121\tres = 3.925E-04\n",
-      "[  NORMAL ]  Iteration 193:\tk_eff = 1.207571\tres = 3.824E-04\n",
-      "[  NORMAL ]  Iteration 194:\tk_eff = 1.208011\tres = 3.729E-04\n",
-      "[  NORMAL ]  Iteration 195:\tk_eff = 1.208440\tres = 3.641E-04\n",
-      "[  NORMAL ]  Iteration 196:\tk_eff = 1.208859\tres = 3.558E-04\n",
-      "[  NORMAL ]  Iteration 197:\tk_eff = 1.209268\tres = 3.467E-04\n",
-      "[  NORMAL ]  Iteration 198:\tk_eff = 1.209667\tres = 3.379E-04\n",
-      "[  NORMAL ]  Iteration 199:\tk_eff = 1.210056\tres = 3.299E-04\n",
-      "[  NORMAL ]  Iteration 200:\tk_eff = 1.210436\tres = 3.221E-04\n",
-      "[  NORMAL ]  Iteration 201:\tk_eff = 1.210807\tres = 3.139E-04\n",
-      "[  NORMAL ]  Iteration 202:\tk_eff = 1.211169\tres = 3.064E-04\n",
-      "[  NORMAL ]  Iteration 203:\tk_eff = 1.211522\tres = 2.988E-04\n",
-      "[  NORMAL ]  Iteration 204:\tk_eff = 1.211866\tres = 2.916E-04\n",
-      "[  NORMAL ]  Iteration 205:\tk_eff = 1.212203\tres = 2.840E-04\n",
-      "[  NORMAL ]  Iteration 206:\tk_eff = 1.212530\tres = 2.779E-04\n",
-      "[  NORMAL ]  Iteration 207:\tk_eff = 1.212850\tres = 2.701E-04\n",
-      "[  NORMAL ]  Iteration 208:\tk_eff = 1.213162\tres = 2.638E-04\n",
-      "[  NORMAL ]  Iteration 209:\tk_eff = 1.213466\tres = 2.575E-04\n",
-      "[  NORMAL ]  Iteration 210:\tk_eff = 1.213764\tres = 2.507E-04\n",
-      "[  NORMAL ]  Iteration 211:\tk_eff = 1.214054\tres = 2.452E-04\n",
-      "[  NORMAL ]  Iteration 212:\tk_eff = 1.214337\tres = 2.392E-04\n",
-      "[  NORMAL ]  Iteration 213:\tk_eff = 1.214614\tres = 2.331E-04\n",
-      "[  NORMAL ]  Iteration 214:\tk_eff = 1.214884\tres = 2.278E-04\n",
-      "[  NORMAL ]  Iteration 215:\tk_eff = 1.215146\tres = 2.221E-04\n",
-      "[  NORMAL ]  Iteration 216:\tk_eff = 1.215403\tres = 2.161E-04\n",
-      "[  NORMAL ]  Iteration 217:\tk_eff = 1.215654\tres = 2.114E-04\n",
-      "[  NORMAL ]  Iteration 218:\tk_eff = 1.215898\tres = 2.063E-04\n",
-      "[  NORMAL ]  Iteration 219:\tk_eff = 1.216136\tres = 2.009E-04\n",
-      "[  NORMAL ]  Iteration 220:\tk_eff = 1.216369\tres = 1.962E-04\n",
-      "[  NORMAL ]  Iteration 221:\tk_eff = 1.216596\tres = 1.912E-04\n",
-      "[  NORMAL ]  Iteration 222:\tk_eff = 1.216817\tres = 1.863E-04\n",
-      "[  NORMAL ]  Iteration 223:\tk_eff = 1.217033\tres = 1.820E-04\n",
-      "[  NORMAL ]  Iteration 224:\tk_eff = 1.217245\tres = 1.774E-04\n",
-      "[  NORMAL ]  Iteration 225:\tk_eff = 1.217450\tres = 1.735E-04\n",
-      "[  NORMAL ]  Iteration 226:\tk_eff = 1.217651\tres = 1.692E-04\n",
-      "[  NORMAL ]  Iteration 227:\tk_eff = 1.217847\tres = 1.651E-04\n",
-      "[  NORMAL ]  Iteration 228:\tk_eff = 1.218039\tres = 1.610E-04\n",
-      "[  NORMAL ]  Iteration 229:\tk_eff = 1.218225\tres = 1.570E-04\n",
-      "[  NORMAL ]  Iteration 230:\tk_eff = 1.218407\tres = 1.533E-04\n",
-      "[  NORMAL ]  Iteration 231:\tk_eff = 1.218585\tres = 1.496E-04\n",
-      "[  NORMAL ]  Iteration 232:\tk_eff = 1.218758\tres = 1.454E-04\n",
-      "[  NORMAL ]  Iteration 233:\tk_eff = 1.218927\tres = 1.419E-04\n",
-      "[  NORMAL ]  Iteration 234:\tk_eff = 1.219092\tres = 1.387E-04\n",
-      "[  NORMAL ]  Iteration 235:\tk_eff = 1.219253\tres = 1.357E-04\n",
-      "[  NORMAL ]  Iteration 236:\tk_eff = 1.219410\tres = 1.322E-04\n",
-      "[  NORMAL ]  Iteration 237:\tk_eff = 1.219563\tres = 1.287E-04\n",
-      "[  NORMAL ]  Iteration 238:\tk_eff = 1.219713\tres = 1.259E-04\n",
-      "[  NORMAL ]  Iteration 239:\tk_eff = 1.219859\tres = 1.226E-04\n",
-      "[  NORMAL ]  Iteration 240:\tk_eff = 1.220001\tres = 1.197E-04\n",
-      "[  NORMAL ]  Iteration 241:\tk_eff = 1.220140\tres = 1.165E-04\n",
-      "[  NORMAL ]  Iteration 242:\tk_eff = 1.220275\tres = 1.137E-04\n",
-      "[  NORMAL ]  Iteration 243:\tk_eff = 1.220407\tres = 1.110E-04\n",
-      "[  NORMAL ]  Iteration 244:\tk_eff = 1.220536\tres = 1.083E-04\n",
-      "[  NORMAL ]  Iteration 245:\tk_eff = 1.220662\tres = 1.055E-04\n",
-      "[  NORMAL ]  Iteration 246:\tk_eff = 1.220785\tres = 1.032E-04\n",
-      "[  NORMAL ]  Iteration 247:\tk_eff = 1.220904\tres = 1.006E-04\n",
-      "[  NORMAL ]  Iteration 248:\tk_eff = 1.221022\tres = 9.809E-05\n",
-      "[  NORMAL ]  Iteration 249:\tk_eff = 1.221135\tres = 9.592E-05\n",
-      "[  NORMAL ]  Iteration 250:\tk_eff = 1.221247\tres = 9.321E-05\n",
-      "[  NORMAL ]  Iteration 251:\tk_eff = 1.221355\tres = 9.097E-05\n",
-      "[  NORMAL ]  Iteration 252:\tk_eff = 1.221462\tres = 8.887E-05\n",
-      "[  NORMAL ]  Iteration 253:\tk_eff = 1.221565\tres = 8.723E-05\n",
-      "[  NORMAL ]  Iteration 254:\tk_eff = 1.221666\tres = 8.475E-05\n",
-      "[  NORMAL ]  Iteration 255:\tk_eff = 1.221765\tres = 8.255E-05\n",
-      "[  NORMAL ]  Iteration 256:\tk_eff = 1.221861\tres = 8.043E-05\n",
-      "[  NORMAL ]  Iteration 257:\tk_eff = 1.221955\tres = 7.865E-05\n",
-      "[  NORMAL ]  Iteration 258:\tk_eff = 1.222046\tres = 7.688E-05\n",
-      "[  NORMAL ]  Iteration 259:\tk_eff = 1.222135\tres = 7.466E-05\n",
-      "[  NORMAL ]  Iteration 260:\tk_eff = 1.222223\tres = 7.284E-05\n",
-      "[  NORMAL ]  Iteration 261:\tk_eff = 1.222308\tres = 7.152E-05\n",
-      "[  NORMAL ]  Iteration 262:\tk_eff = 1.222391\tres = 6.950E-05\n",
-      "[  NORMAL ]  Iteration 263:\tk_eff = 1.222471\tres = 6.795E-05\n",
-      "[  NORMAL ]  Iteration 264:\tk_eff = 1.222551\tres = 6.597E-05\n",
-      "[  NORMAL ]  Iteration 265:\tk_eff = 1.222628\tres = 6.472E-05\n",
-      "[  NORMAL ]  Iteration 266:\tk_eff = 1.222703\tres = 6.301E-05\n",
-      "[  NORMAL ]  Iteration 267:\tk_eff = 1.222776\tres = 6.133E-05\n",
-      "[  NORMAL ]  Iteration 268:\tk_eff = 1.222847\tres = 5.983E-05\n",
-      "[  NORMAL ]  Iteration 269:\tk_eff = 1.222916\tres = 5.841E-05\n",
-      "[  NORMAL ]  Iteration 270:\tk_eff = 1.222985\tres = 5.693E-05\n",
-      "[  NORMAL ]  Iteration 271:\tk_eff = 1.223051\tres = 5.580E-05\n",
-      "[  NORMAL ]  Iteration 272:\tk_eff = 1.223116\tres = 5.434E-05\n",
-      "[  NORMAL ]  Iteration 273:\tk_eff = 1.223179\tres = 5.309E-05\n",
-      "[  NORMAL ]  Iteration 274:\tk_eff = 1.223241\tres = 5.180E-05\n",
-      "[  NORMAL ]  Iteration 275:\tk_eff = 1.223301\tres = 5.028E-05\n",
-      "[  NORMAL ]  Iteration 276:\tk_eff = 1.223360\tres = 4.919E-05\n",
-      "[  NORMAL ]  Iteration 277:\tk_eff = 1.223417\tres = 4.820E-05\n",
-      "[  NORMAL ]  Iteration 278:\tk_eff = 1.223473\tres = 4.688E-05\n",
-      "[  NORMAL ]  Iteration 279:\tk_eff = 1.223528\tres = 4.559E-05\n",
-      "[  NORMAL ]  Iteration 280:\tk_eff = 1.223581\tres = 4.450E-05\n",
-      "[  NORMAL ]  Iteration 281:\tk_eff = 1.223633\tres = 4.364E-05\n",
-      "[  NORMAL ]  Iteration 282:\tk_eff = 1.223683\tres = 4.228E-05\n",
-      "[  NORMAL ]  Iteration 283:\tk_eff = 1.223733\tres = 4.136E-05\n",
-      "[  NORMAL ]  Iteration 284:\tk_eff = 1.223781\tres = 4.026E-05\n",
-      "[  NORMAL ]  Iteration 285:\tk_eff = 1.223827\tres = 3.920E-05\n",
-      "[  NORMAL ]  Iteration 286:\tk_eff = 1.223873\tres = 3.823E-05\n",
-      "[  NORMAL ]  Iteration 287:\tk_eff = 1.223918\tres = 3.753E-05\n",
-      "[  NORMAL ]  Iteration 288:\tk_eff = 1.223962\tres = 3.644E-05\n",
-      "[  NORMAL ]  Iteration 289:\tk_eff = 1.224004\tres = 3.550E-05\n",
-      "[  NORMAL ]  Iteration 290:\tk_eff = 1.224046\tres = 3.466E-05\n",
-      "[  NORMAL ]  Iteration 291:\tk_eff = 1.224086\tres = 3.402E-05\n",
-      "[  NORMAL ]  Iteration 292:\tk_eff = 1.224126\tres = 3.307E-05\n",
-      "[  NORMAL ]  Iteration 293:\tk_eff = 1.224164\tres = 3.223E-05\n",
-      "[  NORMAL ]  Iteration 294:\tk_eff = 1.224202\tres = 3.152E-05\n",
-      "[  NORMAL ]  Iteration 295:\tk_eff = 1.224238\tres = 3.065E-05\n",
-      "[  NORMAL ]  Iteration 296:\tk_eff = 1.224274\tres = 2.986E-05\n",
-      "[  NORMAL ]  Iteration 297:\tk_eff = 1.224309\tres = 2.910E-05\n",
-      "[  NORMAL ]  Iteration 298:\tk_eff = 1.224343\tres = 2.846E-05\n",
-      "[  NORMAL ]  Iteration 299:\tk_eff = 1.224376\tres = 2.759E-05\n",
-      "[  NORMAL ]  Iteration 300:\tk_eff = 1.224409\tres = 2.719E-05\n",
-      "[  NORMAL ]  Iteration 301:\tk_eff = 1.224440\tres = 2.648E-05\n",
-      "[  NORMAL ]  Iteration 302:\tk_eff = 1.224471\tres = 2.590E-05\n",
-      "[  NORMAL ]  Iteration 303:\tk_eff = 1.224501\tres = 2.516E-05\n",
-      "[  NORMAL ]  Iteration 304:\tk_eff = 1.224530\tres = 2.465E-05\n",
-      "[  NORMAL ]  Iteration 305:\tk_eff = 1.224559\tres = 2.396E-05\n",
-      "[  NORMAL ]  Iteration 306:\tk_eff = 1.224587\tres = 2.342E-05\n",
-      "[  NORMAL ]  Iteration 307:\tk_eff = 1.224614\tres = 2.290E-05\n",
-      "[  NORMAL ]  Iteration 308:\tk_eff = 1.224641\tres = 2.223E-05\n",
-      "[  NORMAL ]  Iteration 309:\tk_eff = 1.224667\tres = 2.184E-05\n",
-      "[  NORMAL ]  Iteration 310:\tk_eff = 1.224692\tres = 2.128E-05\n",
-      "[  NORMAL ]  Iteration 311:\tk_eff = 1.224717\tres = 2.079E-05\n",
-      "[  NORMAL ]  Iteration 312:\tk_eff = 1.224741\tres = 2.012E-05\n",
-      "[  NORMAL ]  Iteration 313:\tk_eff = 1.224765\tres = 1.973E-05\n",
-      "[  NORMAL ]  Iteration 314:\tk_eff = 1.224788\tres = 1.914E-05\n",
-      "[  NORMAL ]  Iteration 315:\tk_eff = 1.224810\tres = 1.873E-05\n",
-      "[  NORMAL ]  Iteration 316:\tk_eff = 1.224832\tres = 1.829E-05\n",
-      "[  NORMAL ]  Iteration 317:\tk_eff = 1.224853\tres = 1.789E-05\n",
-      "[  NORMAL ]  Iteration 318:\tk_eff = 1.224874\tres = 1.741E-05\n",
-      "[  NORMAL ]  Iteration 319:\tk_eff = 1.224894\tres = 1.709E-05\n",
-      "[  NORMAL ]  Iteration 320:\tk_eff = 1.224914\tres = 1.658E-05\n",
-      "[  NORMAL ]  Iteration 321:\tk_eff = 1.224933\tres = 1.610E-05\n",
-      "[  NORMAL ]  Iteration 322:\tk_eff = 1.224952\tres = 1.591E-05\n",
-      "[  NORMAL ]  Iteration 323:\tk_eff = 1.224971\tres = 1.536E-05\n",
-      "[  NORMAL ]  Iteration 324:\tk_eff = 1.224989\tres = 1.503E-05\n",
-      "[  NORMAL ]  Iteration 325:\tk_eff = 1.225006\tres = 1.462E-05\n",
-      "[  NORMAL ]  Iteration 326:\tk_eff = 1.225024\tres = 1.423E-05\n",
-      "[  NORMAL ]  Iteration 327:\tk_eff = 1.225040\tres = 1.403E-05\n",
-      "[  NORMAL ]  Iteration 328:\tk_eff = 1.225057\tres = 1.356E-05\n",
-      "[  NORMAL ]  Iteration 329:\tk_eff = 1.225073\tres = 1.327E-05\n",
-      "[  NORMAL ]  Iteration 330:\tk_eff = 1.225088\tres = 1.311E-05\n",
-      "[  NORMAL ]  Iteration 331:\tk_eff = 1.225103\tres = 1.278E-05\n",
-      "[  NORMAL ]  Iteration 332:\tk_eff = 1.225118\tres = 1.230E-05\n",
-      "[  NORMAL ]  Iteration 333:\tk_eff = 1.225132\tres = 1.199E-05\n",
-      "[  NORMAL ]  Iteration 334:\tk_eff = 1.225146\tres = 1.169E-05\n",
-      "[  NORMAL ]  Iteration 335:\tk_eff = 1.225160\tres = 1.134E-05\n",
-      "[  NORMAL ]  Iteration 336:\tk_eff = 1.225173\tres = 1.111E-05\n",
-      "[  NORMAL ]  Iteration 337:\tk_eff = 1.225186\tres = 1.073E-05\n",
-      "[  NORMAL ]  Iteration 338:\tk_eff = 1.225199\tres = 1.067E-05\n",
-      "[  NORMAL ]  Iteration 339:\tk_eff = 1.225211\tres = 1.050E-05\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"
      ]
     }
    ],
@@ -1903,25 +2533,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 27,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "openmc keff = 1.224484\n",
-      "openmoc keff = 1.225211\n",
-      "bias [pcm]: 72.7\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[0]\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",
@@ -1962,37 +2590,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 28,
+   "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/romano/openmc/openmc/tallies.py:1798: RuntimeWarning: invalid value encountered in true_divide\n",
-      "  self_rel_err = data['self']['std. dev.'] / data['self']['mean']\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "(1.0000000000000001e-05, 20000000.0)"
+       "(1e-05, 20000000.0)"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xd4VHXWwPHvpEEKoYbQm8ABRLoVFeyFYm+IDbsrlndX\nV9eyunZ33bVgQ0Ws2NaCZW0oYhcB6Rx6Db2XQOr7x50Jk8nMZJLMZCYz5/M8PMzcueXcEO6ZX3eV\nlpZijDEmcSVFOwBjjDHRZYnAGGMSnCUCY4xJcJYIjDEmwVkiMMaYBGeJwBhjElxKtAMwsUtEOgCL\nVTXFZ/ulwEhVPd7PMdnAM8AAnC8ab6nq3e7PBgGPAg2BPcBNqjrFfb4ngLVepxqjqmN8zj0Y+BJY\n6nPZd4HngC9UtWc17vN6IFdV76rqsUHOeRHwf0A6kAb8DNyiqnnhukaIcZwA3As0wfn/vhy4QVXn\nVfN8hwL5qjorEj83Ex2WCEy4PQgUAD2ATOAPEfke+AH4L3CSqk4TkdOAd0Skpfu4D1T10hDOv1JV\nuwX4rMpJAMA34dSUiFyLkwSGq+p8EUkF7gSmiEhPVd0bzusFiaMRTpI8VlWnu7fdDPxXRHqoanUG\nEV2G8285K9w/NxM9lghMuL0PLFLVEmCniMwEDgR+Ay5X1Wnu/SYBuUCjcFzUu/QiIq2BV4GWQD2c\nUskdQbbfA7RR1StEpB3wAtABKAQeVdVX3ef/GXgIuBLnG/b/qerbPnEkAX8HLlbV+QCqWgj8XURm\nAKXuEtBwnJLRNFW9VURuAK7BKUUpcIWqbnSXov4D1AdcwN2q+m6g7T4/li5AKTDTa9uT7vsuFREX\ncBdwofs8H7rvqVhEOgHjgVbAVuBq4BDgYmC4iDQHssP1czPRZW0EJqxU9RtVXQVl1URHAL+q6nZV\n/ci93QVcDnyvqlvdh/YRkckislBEXhKRhjUI4yZgiqr2AA4COrlLHoG2exsLTFZVAYYAT7ofZgDN\ngBJVPch9rvv9XLsb0Bj4yvcDVf1QVfe5354IXONOAocBtwCD3aWdlTgPToB/ATe7Yx4OnFHJdm9z\ngR3AZBEZISItVbVYVT1VcCOBc3Ee8Ae4/1zr9XOYoKqdgQeA11T1OZyEfquq/jvMPzcTRZYITESI\nSBrwJjBRVX/22n42TlvAtTjfgAEWAh8Bw4A+ON80/xPg1O1EZIHPnyt99tkAnCQiRwL7VPUC98Mv\n0HZPbKnACThtHKjqCuBb4Fj3LinAy+7X04F2fuJrAmwModploaoucr8eArynqhvc71/ESRSee7lY\nRLqp6iJVHVHJ9jKqugc4HOfhfS+QJyK/uksT4Py8x7mTdJH7umeKSH3gGGCCe7+PgEMD3UiYfm4m\niqxqyARTArhExOXzYEsGigFEZBLQGsBTdy8iWThVRKvZ/7DHvc97wHsicizwrYj0VtWfgJ88+4jI\nQ8DnAWLy20bg9e0TnCSSjPNgaiUiTwP3BNnu0RRwqep2r21bgebu18Wqutvz2n0uX5uAXBFJcT9c\nA9ni9ToH8G5E9r7mKJz2ha9FJB+43f0zDLS9HHfj9J+BP7t/Rn8CPhORtjjVcn8Rkavcu6cAG3GS\nWRKw3X2OUmBXkHsJx8/NRJElAhPMJpw65rY41RUeXT3vVfU47wNEJAX4AJijqjd7bW8L9FfVD93H\nfSMiq4HDRGQasFdVN7p3T8GpZ64W9wP4YeBhEekK/A/4QVW/8rfd535LRKSxV5VVU2B9FS6/EOfb\n+nCcZFhGRO4GnvVzzHr3dTzKrqmq64HRwGgRORF4X0Q+D7K97IHtvscsT0Oxqi4HbhGRUUAnnOQz\n0U/vrHo4/+5NgU3uqrwDgCUB7jkcPzcTRVY1ZAJyVy28AvzDXdWDiPQFLgGeCnDYDcBO7yTglgaM\nF5ED3efpAnTGqce+FhgrIqkikozzgPu0unGLyPPubpPgPLzW4TTS+t3udb9FwBc4DaOIyAHA0cDX\noV7b3Uh+J04d+cHu86SKyP049fg7/Bz2KU6VjCcZXA186j5uslc7xjScBJkcYHuJz3n74pS+Onn9\nbIYARcB8nCqfi0Qkw/3Z1SJyibsd40vgUvdhJwGfuUsGhfg08Ifj52aiyxKBqcwNONUYf4jIfGAM\nMEJVZwXY/2rgEJ86/PtUdQlOr5EJIrIAmAjc6K4nvx+nGmKe+08RTuNpdT0HPOC+zjycXiuTgmz3\ndg0w2L3PBzi9d1ZV5eKq+rI7/hdEZCEwG6fB9FivxmLv/X/DKal8775uI+AOd2+jF4FJIjIP+A4Y\n7a6C8bd9j89533af9wMRURFZgvPvebK7quZD4GNguvu6w3Ee6ABXAMNEZCnOv4+nDeID4BER8W0s\nrvHPzUSPy9YjMMaYxGYlAmOMSXCWCIwxJsFZIjDGmARnicAYYxKcJQJjjElwdW5A2caNO62bkzHG\nVEFOTgNXsM+tRGCMMQnOEoExxiQ4SwTGGJPgLBEYY0yCs0RgjDEJzhKBMcYkOEsExhiT4CwRGGNM\ngqtzieCnZVsq38kYYyqxatVKbrnlRq688mJGjRrJf/7zKAUFBVU6x7ffOmvvLFqkvPTS85EIs1bU\nuURw4/tzePaHZRSV2ABjY0z1FBcXc+edtzJixMW88MKrvPTSawC8/PILVTrP66+/AkCXLsLll18d\n9jhrS52bYuK0ni0Y9+sqZubt4P4h3WmWmRbtkIwxdczUqb/Srl0H+vbtD4DL5eK6627A5UrinXcm\nMGnSlwAcddQgRo68lAceuIemTZuxcOEC1q9fx91338+0ab+xePFC/va3Wzj77PN4//13uP/+Rznv\nvNM58shBzJkzi6ysBvzzn4/z8ssv0KhRI8466zyWLl3Mv//9KGPGjGXSpK94++03SE5ORqQ7N930\nF1566Xm/+z7++D9ZsGA+xcXFnHHG2Zx66rCw/TzqXIngzpO68veTuzJn7U4ufHUav6/cFu2QjDF1\nzMqVy+nSpWu5bfXq1WfTpo38738f8/TTL/D00y/wzTdfsWbNagAKCwv597/HcM455/P5558yYsTF\nZGVl8eCD/yx3nry8NZxyylCef/5ldu7cwZIli/zGsGfPHsaOfZrHH3+GZ599iby8NUyf/rvffXfs\n2M5PP/3Ac8+N49lnX6KoqCgMP4X96lyJAGDogS3oltuA2z+ex5/em8XVR3Tg0kPbkuQKOq+SMSbG\nfDp3PRPnrAvrOYf3bMGQA3Mr2ctFSUlJha2LFikHHngQKSnOo/Ggg3qzePFCAHr37gtATk4u8+bN\nDXjmzMxMOnfuAkDz5s3ZtWuX3/1WrVpJmzbtyMjIAKBv3/4sXLjA777Z2Q1p27Y9t932fxxzzPGc\nfPKQSu6vaupcicCjc7NMXrmwHydIDs/+uJyb3p/Dtj2F0Q7LGFMHtG/focLDvKCggGXLluK9jnth\nYSEul/OYTE5OLtsebK137/08+7q8vqR6vs27XOXPU1RUSFJSkt99AR577Ekuu+wqFi1ayF//enNI\n9xmqOlki8MhIS+a+U7vRr01D/vXtEi58bRoPDu1O79YNox2aMSYEQw7MDeHbe/gdfPChPPPME/zw\nwxSOPPJoSkpKePbZp9ixYxuLFy8uewDPmzeXiy8exfffT/Z7npIQO61kZmayadMmAGbN+gOAtm3b\ns3r1Svbs2U1GRiYzZkznkksuZ8GCuRX2Xbs2jx9+mMI555yPSDdGjRpZk9uvoE4nAnAaec7s3Yoe\nLRpw28fzufqdWYw+qiMj+rcul1mNMcYjKSmJxx4bw6OPPsDLL79AamoqBx98KKNH38wHH7zH6NFX\nUVJSyrBhp9GiRcuA5+naVbjyyou59tobgl5v0KBjueWWG5k/fy59+vQDID09nT/96Ub+/OfRuFxJ\n9OrVh969+5Cbm1th32bNcpgzZyaTJn1JamoqQ4YMD98PA3AFK+LEomAL0+zcW8Q/vlAmL97M4M5N\nufskoUH9Op/rjDGmRipbmCauEgE4dW4Tpq/hySnLyG1Qj4eHdad7boPaCs8YY2JOwq1Q5nK5GNG/\nDWPP601RcQmXT/iD9/7IC9q4Y4wxiSzuSgTetu0p5O+fL+CnZVs5UXL424ldyEyzqiJjTGJJuKoh\nXyWlpbzy2yqe+3E5bRul8/CwHnTOyYxUeMYYE3MSrmrIV5LLxWWHtuOZc3qxq6CYS9+cwcdhHsBi\njDF1WdyXCLxt3l3AnZ8t4PeV2xh2YC63HteZ+qnJlR9ojDF1WMKXCLw1zUxjzFkHcflh7fhk7nou\ne/MPlm/ZE+2wjDG1bO3aPI48cgBz5swut/2KKy7mgQfu8XvMZ599zJgxjwOhTT/9668/c+21o7j2\n2lGMGnUhzz//NMXFxeG7iTBKqEQAkJzk4pqBHXjirJ5s2l3AJa/P4MsFG6IdljGmlrVq1Zqvv/6i\n7P3q1avYuXNHSMdWNv302rV5PPXUf7jvvkd49tlxjB37CsuWLeGTTz4KT/BhFlNVQyKSCXwH3KOq\nn/jbpyZVQ77W79zH3z6Zz6y8HZzduyU3Dz6AtJSEy43GJJy1a/MYO/YZFi1SXnnlLZKTkxk//kU2\nbdrEvn17mTFjGq+++jYZGRmMGfM4nTodAMDSpUto0qQJzz//NAMHHl1u+mlvzz77FK1bt2H48DPK\nthUVFZVNZnf++Wdw2GEDady4MaecMpSHHvoHhYXOXEO33XYXLpeLO+/8a9k6CZdffhH33/8I48aN\nJT09nRUrVrB9+zb+9re76dq1W6X3G9WqIREZJyIbRGSOz/aTRURFZLGI3Ob10V+BdyIZk7fcBvV4\n/txejBzQhvdmruWKt/5gzfb82rq8MSaKUlJS6NGjZ9nUzz/8MIXDDx9Y6XGBpp/2tnLlcjp16lzh\neh5FRUUcdtgRXHLJ5bz44nMMHXoaY8aM5YwzzmbcuLFBr19cXMwTTzzDFVdcw8svv1hpvKGIdKf6\n8cAY4FXPBhFJBp4GTgBWA1NFZCLQGpgH1I9wTOWkJCdx46BO9Gmdzb2fL2Tka9O552RhUOdmtRmG\nMQkp/ZmnyPjnQyTt9j9Vc3WUZGax55bbyb9udKX7HnPMcXz99Rc0bdqUnJwc0tPTwxKDy5VU1h6Q\nl7eGBx+8l+LiYrKzs3nkkf8A0KPHgQCozueaa64HoF+/AYwfH/zhPmDAIQD07NmL5557KizxRrRE\noKpTAN9Fhg8BFqvqUlUtAN4CTgMGA4cBI4ArRaRW62gGdW7Gaxf1pW2jdP7y0Twen7yUouKK85Ub\nY8In/dmnwpoEAJJ27yL92dAekAMGHMr06dP4+usvGTz4uLLtgaaCDiQvbw3XX38V119/FQsWzKdj\nx04sWOBMc92qVWvGjBnL3XffVzarKEBKSqrnamUzHxQWFuFyJVWYMNM7Bs+Mp84x4ZlYMxoV4q2B\nVV7vVwOtVfUOVb0JeBN4QVVr/SncumE6L57fh3P6tOKNaau5+p1ZrN+5r7bDMCZh5F87mpLMrLCe\nsyQzi/xrKy8NAKSmptKnT18+/fQjBg48umx7RkYmmzdvori4mLlzZ1c4znf6ac/DfsyYsXTr1p3T\nTz+L999/l1WrVpbt8/vvv5GWVnFp3e7de5RVT/3xxzS6detORkYmW7duobS0lM2bN5GXt7ps/1mz\nZgAwd+4sOnToGNJ9Vibm5ltQ1fHRvH5aShK3HteZPq2zeeDLRVz46jTuG9KNwzs0iWZYxsSl/OtG\nh1SFE0nHHHM827ZtJStrf0I666xz+etfb6Zdu/Z07NipwjGVTT+dk9Oce+99iIcfvo/i4mKKiopo\n374D99zzQIV9r7jiGh566D4+/vhDUlJSuf32u8jOzmbAgEO44oqL6dy5C126SNn+BQUF3HrrTaxf\nv567774vDD+BWug1JCIdgE9Utaf7/eE4vYJOcr+/HUBVHwrlfOHsNVSZ5Vv2cPvH81myaTeXHdaO\nqw5vT3KSrXFgjImOBx64h8GDj2PgwKOqdFwsDiibCnQRkY4ikgacD0yMQhyV6tAkg5dH9GFYz1zG\n/bKS69+bxabdBdEOyxhjwiqiJQIRmYDTCNwMWA/8XVVfEpFTgceBZGCcqlYsLwVQmyUCbx/PWccj\nkxaTVS+FB4Z0o3/bRtEIwxhjqizhZx8Np8WbdnPbxHms2pbPNQM7cMkhbUmy5TCNMTHOEkGY7S4o\n4sEvF/GlbuSIjo2595RuNEpPrfxAY4yJEksEEVBaWsr7s9by2LdLaJKRxoNDu9OrVXa0wzLGGL9i\nsbG4znO5XJzVuxXjLuhDcpKLq96eyZvTVttymMaYOslKBDW0c28R//hCmbx4M4M7N+Xuk4QG9WNu\neIYxJoFZ1VAtKC0tZcL0NTw5ZRktGtTj4WHd6ZbbINphGWMMYFVDtcLlcjGifxvGntebwuISRk34\ng//OzLOqImNMnWAlgjDbtqeQu/+3gJ+Xb+WkbjncfkIXMtOsqsgYEz1WNRQFJaWlvPLbKp77cTlt\nG6Xz8PAedG6WGe2wjDEJyqqGoiDJ5eKyQ9vxzDm92FVQzKVvzOCTueuiHZYxxvgVsEQgIr4L+Xoy\nSqnX+xJVzY1QbH7VhRKBt027C7jr0/n8vmo7w3vmcsuxnamfmhztsIwxCaSyEkGwyuu5qnpMsINF\n5NtqRZVAmmWmMebsXoz9eQXjflnJvHW7eHhYd9o3yYh2aMYYAwRPBBd6XojIgYDglAbmq+oC331M\nYMlJLq4d2IHerbK5+7MFXPz6DO44sQsndmse7dCMMabyxmIReQ7ohzN9NMDBwI+qenOEY/OrrlUN\n+Vq3Yy93fLqAWXk7OKdPK24a1Im0FGuqMcZETk2qhjz6quohnjfutYR/qmlgiapFdn2eP7cXY75f\nzhvTVjNn7Q4eGtad1g3Ds2i2McZUVShfRVVEWnm9zwHmRCiehJCSnMRNgzvxr9N6sGpbPhe9NoPv\nFm+OdljGmAQVrNfQVJw2gTSgB7DI/dEBwB+qelitROijrlcN+Vq9LZ+/fTKf+et3MXJAG/50ZAdS\nkq2qyBgTPjWpGjofKAp2sIh0UtWl1QnMONo0SueF8/vw+OQlvP77ambl7eDBod3JbVAv2qEZYxJE\nsBLBd8DJ7B8/4M//VHVQJAILJN5KBN6+XLCBB75cRFpKEvedKhzWoUm0QzLGxIGalAjaA3PxnwhK\nA2w3NXBit+Z0bZ7F7R/P54b/zmHUYe248vD2JCfZj9oYEzk211AM2ltYzKOTFvPx3PUMaNeI+07t\nRrPMtGiHZYypo2zSuTps4px1PDppMQ3qpfDQ0O70adMw2iEZY+ogm3SuDhveswXjR/QlPTWJa96d\nZcthGmMiwkoEdcCufUXc+7mzHOYJksOdJ3YlI80mrjPGhKbGVUMicjcwmvKzjpaqalQmyknERADO\ncpivTV3N0z8so33jDB4d3oMOTW3iOmNM5cKRCGYCR6jq7nAGVl2Jmgg8pq7cyh2fLGBfUQl3ndSV\n4yUn2iEZY2JcONoIlEoGlpnac3C7xrx+UT8OaJbJ7Z/M5z+Tl1BUXBLtsIwxdVgoJYJ3cWYcnY6T\nEDxVQ+dGPryKEr1E4FFYXMIT3y3l7Rl59G2dzYNDu9Msy0YjG2MqCkfVkN+Rw6r6XQ3iqjZLBOV9\nMX8D93+5kEx3F9O+1sXUGOMjHFVDM4FjgJuBG4GBwLSah2bC4aTuzXn5wr5kpiVz7TszeeN362Jq\njKmaUBLBK8BO4B/Ao0Ax8HIkgzJV07lZJq9c2JejOzfj8e+Wcvsn89ldYM06xpjQhLIwTQNVfczr\n/S8i8nWkAjLVk1UvhUeGdef131fz9PfLWLJpN48M70GnppnRDs0YE+NCKREki8gAzxsROTTE40wt\nc7lcXHRwW54+pxc79hZx6Rsz+HLBhmiHZYyJcaE0Fh8EPI6zOA3AbOBGVZ0fzkBEpDtOG0QzYJKq\nPutvP2ssDs3GXfu4/eP5zMzbwYj+rRl9dCdSbBZTYxJSVCedE5FxwFBgg6r29Np+MvAEkAy8qKoP\ne32WBLyqqiP9ndMSQeiKikt43N3FtH/bhjw0tDuNM2wWU2MSTbV7DYnIB+6/N4rIBq8/G0Uk1PqG\n8TiL23ifNxl4GjgFp5RxgYj0cH82HPgU+CzE85sgUpKT+Muxnbn3FGHO2p1c9PoM5q/fGe2wjDEx\nJmAiUNUz3C/7qWpzrz85wOBQTq6qU4AtPpsPARar6lJVLQDeAk5z7z9RVU8BLqzifZggTu2Ry4vn\n98YFXDHhDz6duz7aIRljYkjAXkMi0gzIBcaJyKXsX5EsBXgP6FrNa7YGVnm9Xw0cKiKDgTOBeliJ\nIOy65Tbg1ZF9+dunC7jnc2X++p3cNKgTKcnW7m9MogvWfbQ7MArngf+M1/YS4PVwB6Kqk4HJ4T6v\n2a9xRhpPnXUQT01ZypvT1rBw424eGtqdprb6mTEJLWAiUNXvge9F5A3ge1XdByAiDVV1ew2uuQZo\n6/W+jXubqQUpSS5uHnwA3XMbcP+XC7n49ek8etqBHNiiQbRDM8ZESSj1AgcC73q9f11EbqjBNacC\nXUSko4ikAecDE2twPlMNJ3dvzksX9CElycVVb/3BxDnroh2SMSZKQkkE5wGne70f7t5WKRGZAPzs\nvJTVInK5qhYB1wNfAPOBd1R1btXCNuEgzbN4ZWQ/erduyH1fLOSRrxdRaFNaG5NwQpliIgVoxP7e\nPy3Y33AclKpeEGD7Z1iDcExolJ7Kk2cdxDPfL+O131ezaONuHh7eg2bWbuDX7oIidMMu+rVpFHS/\nLXsKaJyeistlg/hM7AulRHAHzvxCM0VkDjAJ+FtkwzK1KSXJxQ2DOvHAkG4s2LCLi1+fzty1O6Id\nVky645MFXP32LLbnFwbcZ/W2fE569hde/311LUZmTPVVmghU9StV7QocDxytqj3cPXxMnDmxW3Ne\nHtGH1OQkrn5nls1T5MeijbsA2FcUuAotb/teAH5a5juExpjYVGnVkIj0BP6NMwvp4SJyEzBFVadH\nPDo/mnZsRdLuXdG4dELIAX7yvHkg9ONKMrPYc8vt5F83OgJRxY4kd1VPSZCpWaw2yNQ1oVQNPYUz\nGdxe9/svgScjFlElLAnEpqTdu8j450PRDiPiPPP2hTLhlU2KZeqKUBJBkfdMo6o6D2dQWVSUZGZF\n69KmEomQpF2hlAjcfSlsoThTV4TSa2ibiIwCMt1rEZwBRK3yePOyvGhdOmFNXrSJuz5bQMP0VP59\n+oF0bV4+Gec0z45SZLXPU+0T7CFfWdXQ3sJi0lKSyqqZjIm2UEoElwGtgE3AbcA24NIIxmRizOAu\nzXjx/D6UlpZy1dszmbpya7RDihrPw7u4pPKv+/72KCgq4agnf+TxyUvDHJkx1Rc0EYhIrqruUtX7\nceYd+gBnuon4rwMw5UhuFi+P6EuL7Hrc+P4cvtKN0Q4pqkLIA34VuAfs2UhuE0uCrUdwE84so4hI\nI2AaMAi4S0RuqZ3wTCxp3qAeY8/rTc8WDbjjk/m8PT3xpojyVOYUh9IA4GcfazcwsShYiWAkztgB\ngBHAr6p6OXAq7vUDTOLJru+MRB7UuSn/+nYJz/ywLNoh1SpPtX6Ju0iwfuc+/vXN4nJVRa4QehZZ\n84CJJcESwS7PjKPACTjVQqhqCbAv4FEm7tVPTeahYT04o1cLXv51VeUHxBHfHkH3f7GQt2fkMW3V\ntoD7+GMlAxNLgvUaShKRXCAbOAa4GkBEMoHMWojNxLCUJBe3H98lYddA9lQNef7292D3963fSgIm\nFgVLBHcBU4DGwG2qukFE6gO/AQ8HOc4kCJfLxbUDO5TbVlRcEt+rnnmqhtxP/v0DzEJrD7CSgIlF\nwRam+Q4Qn217ReQ0VV0c8chMnXT7J/N5cGh3UuM0GZQ1FrvbBMqqgUI83pMwrGRgYkmV/7daEjDB\nTF68mVsnzgs6KVtdVtZY7PPkD/WbvpUITCwKZWSxMSFb/shQ58XV/j+v65PTeUoAnqohfz2Egn3Z\nD5QHSktLKSopjduSlIltVfqtE5Ek95gCY8pUZf6nuj45nefBX2Fkceh1Q85fPvu/+PNKjnj8B3YX\nFNUoPmOqo9JEICK3icjVItIAZ73hd0TkH5EPzdQVe265vcrJoK4LNumch789SgJkDM9I4x17LRGY\n2hdKiWCYqj6Ps8j8h6p6InBEZMMydUn+daPZvCyPjRt2lPvz6neL6HTbJ5z51PesWB1f8xMFm2Ii\nWEOwJ38E2sfaEEw0hJIIkkUkCWd08dvubQ0iF5KJF6d0z+W+U7sxc812bnx/drTDCQvP8zuUEsGs\nvB3MXLO93LZS93G79hVz4jM/7z+v9SIyURRKIvgAWAfMU9WFInIX8GtkwzLx4sRuzXlgaHdmr90Z\n7VDCwlU2+6jvB/73f2TS/k52m3YXcMrz+//rbHWve7x1TwFrd9hgfRM9lfYaUtVHgEfAaSwGxqtq\nYs0rYGrkuK45zvTNdbeNuExVSgS+lmza7Xf7Ba/uX/XV38A0YyItlDWLbwO2Am8A3wGbReRnVf17\npIMz8eOYLs3Kvc/bvpdWDeuXvS8pLeWt6Wv478y1HNyuEX85tjMpSbFXX+LyGVkcDpt3F+w/f9DO\np8ZERijjCIap6kARuRKnsfg+Efk60oGZ+Na7S/MK2250/9mVls60i66nx0N31XpcoQplYRpfoTzi\nYzD3mQRgjcWm1oTaxTSrIJ8Br41hb2FxhCOquv1rFlf9WKv0MbHKGotNranKeIPMgny+W7w5whFV\nXShtBNYF1NQ1ITcWi0gjEckGHlfV+OgCYmpV/nWjK51aIqd5dtnriXPWcVL3ilVIscCTCPw98723\nVTUpuKwfqYmCUEYWHy8iitNQ/Bvwi4gMjHhkJuFNXbmNjbtiq1vl/hXKfLZ7va5Jzx9LAyYaQqka\n+gcwWFV7q2o34GRsPQJTC0qBLxdsjGoMewuLue8LZZu7z3+gNYsDlQIKikuq3Nbxwk8rQl7cfu66\nnWzYGVvJ0tQ9oSSCAlVd63njHkNQGLmQjHF0z83i8/kbohrDxDnrmThnPWN/WuHeUn720cqs3JrP\nUU/+WKURzB8TAAAgAElEQVRrjv15Bfd9sbDC9tLSUnbtKz8X0aVvzGD4i7+Vvd+eX8hj3y6hqMKI\nN2MCCyURLBWRp0XkHBE5V0SeBZZEOjBjTumRy4INu1i2eU8Uo3Ae+L7TTvs+Z8tVDdWgsTjYoR/N\nXscxY35i+ZbyPw/vrqxPfLeUt6av4auF0S1JmbollHEEVwEXAEfi/J7+ALwViWBE5HRgCM46yS+p\n6peRuI6pG244uTs3gHtce3m1t66By++76au3cW7fVn6PqEkbQWmQLPL90i0ArNiyhw5NMvzuU1QS\neA1lYwIJJRFMUNVzgNeqcwERGQcMBTaoak+v7ScDTwDJwIuq+rCqfgh8KCKNgX8BlggSTElmVkjT\nVHvWNfBNBAs37GJvUQm9WmUHOLJqyhae8Zk1dNLCTe4PKh4Trofw4o276ZyTWaVj7PlvqiOUqqEt\nIvKgiJwuIqd6/lThGuNxGpjLiEgy8DRwCtADuEBEenjtcqf7c5NgqjLWwF/CuPC16Vw+4Y+wxeOb\nAELp1ePvYTxlyWZmrdlRYfuegvINyVNXbit7fcGr0zj+6Z8qHPOVbqywgM1/Ji8JWpowJphQSgRp\nQEvgNK9tpcBnoVxAVaeISAefzYcAi1V1KYCIvAWcJiLzcXok/U9Vp2MSju9Yg90FRZz07C8MOzCX\nvx7fBSg/1sCbdwPp7oIiMtNqvhKr5+EaMAH4+8DP8/jPH871e/gFr/xe7v2LP68o9367n4Vqvliw\nkdJSeGBo97Jtb05bw5WHtw8UpTFBBS0RiEhDVb3M8we4ErhFVUfV8LqtAe8ZTFe7t40GjgfOFpFr\nangNEwcy01IY3Lkpny/YUOkyjmu27y17vXVP1Tq2vftHHrq+YgnD80x/b+Za5q7bWXHhAH9VQ1Wo\noMnzmX461CPX+eky6h3ae3+srfC5MYEETAQiMgiY5R5N7NEdmCIiPQMcViOq+qSq9lfVa1T1uUhc\nw9Q95/drza59xXw0O3jf+uVb8ste+3azrMyjkxYz8vWKhVDvbqKXvjGjQgHA89D/Sjey3N27afR/\n51Tp2pEwe23FaihjAglWIrgfOF5Vy36jVHU2cAZOQ25NrAHaer1v495mTAU9W2bTt01D3py2Jmj/\n+JVb93er3FnFRBCIb7V7oBkgPpm7nrv/t4APZtXsm/i+our3//9ywUZrJzDVEiwRlKrqIt+NqqpA\nfT/7V8VUoIuIdBSRNJz1kCfW8Jwmjl1ycFvW79wXdMTtiq3eJYLQR/MGe3hWNnBs8+79VVDz1+/i\nwa8q/Jepki1+qrTy/YxMnpW3o8L2B79axC/L968NXVpayqSFG6s1ZbZJLMESQaaIVGhtE5EMoHGo\nFxCRCcDPzktZLSKXq2oRcD3wBTAfeEdV/bemGQMc0bExfVpn8/xPKwLus2prPs2z0oCqlQiKqvCg\n9N518+4CFgdYdSycjn7yRz6du75Cwnrj99UV9vVuXP5KN3Lbx/P97meMt2DdKiYA74nIX92lAESk\nL0610BOhXkBVLwiw/TNC7HlkjMvl4sZBnbjszcBdQ5dv2UPPltls2LW5QrfMYIIlAt+PvB/GVW2Q\nrol7PlcyUpPLbdtdyT1udse3IcYm7jOxJ2AiUNV/iUgeMN6r++dSnGmo362N4Izx1rNlNkN6+J+W\net2OvWzZU0i/Ng2ZsqRqiaAwSLuDb9WQJzE0y0wL+fzhssenKuj1Sr7pW3uBCVXQjtaq+ibwZi3F\nYkyl/u+YA/xun5Xn9Gno17YhqcmuSr8tewtWIvB9lnoernWp3t3WODCVCWVksTExI7t+arn3ngfy\nN4s20SQjlS45WWSkJvttYA2kqDj0xmLP8993Guq6YsH6nVz19swa9U4y8afmQy+NiaI/fziXQZ2b\n8u2iTYzo34aUJBcZacnsqWTwmbdgJQLfzzyJIVjyiBXe01UAfLtoE7dOnAfAoo276NkyPPMxmbqv\n0kQgIi5ggKpOdb8/FvhWVWP/f4KJe7+v2saPy7bQsWkGlx3qDE3JSEsOuWrold9WMeb7ZQE/r5gI\nnL/rQongB/dspR6eJAA2O6kpL5QSwStAHk7ff4BBwCXuP8ZE1SdXHsrKbfl0a55FWopT05mRmhJy\nY3GwJAAVB3jtLxHUraoVzwprHqMm/EF6ahJTbjgyShGZWBJKG0F7Vb3N80ZV/w60i1xIxoSuUUYq\nvVpllyUBgIy0pCq1EQTjex5Pm0Rxac3WHahtQ57/pcK2/EInmW3dU2A9jBJcKCWCEhEZAvyEkziO\nBcIzft+YCMhIS2HjroKwnMu3a6l343Fd6Tn01vTAs7es2prPmeOmcuOgTowc0KYWozKxJJQSwSU4\nU0D8AHwLnARcFsmgjKkJp7E4PCWCwmL/bQRArYwqjrQ894ytr01dVcmeJp4FLBGISD1V3QdsAq5m\n/8zrdeNrkElYmanJFQZfVZdvicC78fjezysuMF9XbdlTyObdBTSNwkA5E33BqoZeBkYAcyn/8He5\n33eKYFzGVFt6JEsEdaQ6KFTfLt5U9np3QTFNM2H1tnzW79xH/7aNohiZqU2uUBqJ3F1Im+EkgM3R\n7Dq6cePO+PqfaKos0Apl4VCSmcWeW24vWyXtundnleuP3zwrjQ1han+IReNH9OFS93xOU/98dJSj\nMeGSk9Mg6PDyStsIROQSYCUwCaeNYJmIjAhPeMZUXahrGldH0u5dZPzzobL3vlVDdWAcWY18s2hT\n5TuZuBNKY/HNQB9V7aWqBwEDgFsjG5YxgVVlgfvqSNq9f8nKeK8aMgZC6z66BvAeorgZWBKZcIyp\nnO8C974mLXTm4Z9wcX8652QGPdfBj00pe738kaEVPi+oUCJInESwbsdeWmTXdA0qUxeEUiLYAfwh\nIk+KyBjgdwAReVREHo1odMZUQ0aaM29/ZYvdhzI6uELVUEkp/do0rH5wMc67S+ywF36LYiSmNoVS\nIvjc/cdjaqAdjYkFngVcfLuQ/rF6OwXFJRzS3llgb28IM3BWHEdQWpZo4tFPy7ZWvpOJO6Ekggk4\n3Uj7AsU4JYK3VLVuTbZiEobnQe3bhfTKt2cC+3vD7Nhb+QD5iiOLoV5K4s3ePn/9TrrmZJGcZGsb\nxKNQEsFLwFZgMpCGM+ncMcCVkQvLmOrbXzUUfCzB1vzKl5r0nX20uKQ0oRLB/+avZ/mWfMb9spIr\nD2/HVUd0iHZIJgJCSQRtVPUir/dvicg3kQrImJpqnJ6GC1i/I/havVv3BB4P4BmrMD2cgdVFjzh/\n3V2DU/iOzTCxJ5SvNmki0srzRkTaAKlB9jcmqjLSkunQNIN563cG3W+Lz+Lzu9PSIxlWwvIdm2Fi\nTyiJ4A5gkojMFZH5wBfAbZUcY0xU9WjRgHnrdgadXnmbTyIYe8xFER2fkMi8x2aY2FNp1ZCqThaR\nvkA6zhQTpaq6PeKRGVMDB7ZowKdz17N+574KfeFLS0txuVxs2VNIvZSkssVnXj38LEa+9i9OevZn\ntuwp5NOrDmXI2F8rnPvqI9rz/E8rauU+YtWkPx1eYf1ofyI5HYgJn1CmmLgReEdVt6rqNuB1Ebkh\n8qEZU309WjQAYO66itVDngf/9r2FNKy//7uQZ62BJJfTM8Z3MJlHanLiNBYH4sJ6D8WTUH6jzwNO\n93o/3L3NmJjVpVkmKUku5rkTgXfvn73ulbnyC4vJrJfCu5cN4ATJKVtrwNND8o3fV/s9t3WhNPEm\nlESQAnjPR9sC7OuAiW1pKUlI8yx+XbGN0tJS9noNLvMMNNtTUEx6ajIdmmTQLDOt3OpjAO/NXOv3\n3JYHYOc+W6QwnoTaWPyLiMwUkTk4s5DeEdmwjKm54Qe1QDfsYvLizeUeXJ5EkF9YTEaq818gyeUq\nW3rS5Qr+pE+u5PNEcNqLNv1EPAmlsfgroKuI5OCUBApV1cahm5g3tEcuH8xcy31fLOSmQfvXUcov\n8CSCEppnOStyJSftbyOo7DGfZEUCE2dCaSy+TUSuBvKB/wFvi8g/Ih6ZMTWUlpLEI8N7kFUvmfu+\n3L+sZLkSgXsUcpLLVbbWgPcX/tFHdaxw3mQX3H9qt3LbEnGJx/wwLQdqoi+UqqFhqvo8cAHwoaqe\nCBwR2bCMCY9WDesz9rzeDOzYhI5NMgDY6h4/sKegmPqpnkRA2ZgD7+/7mfUqTjCX5HJVmHrilmMP\niED0se3uzxZEOwQTJqEkgmQRScKZeO5t97YGkQvJmPBqkV2fx8/syesX9SPZBUvcUy07bQT7SwQl\npVQYgJaZVrH2NCnJRb+2+6eifn/UwZW2K8SjWXk7oh2CCZNQEsEHwDpgnqouFJG7gIqjbGpIRDqJ\nyEsi8l64z20MOFVFvVplM3nxJkpLS51eQ56qIXe9f0kp5eqGMv1MOZ2S5KJldn1GHdqWpplptGlU\nP6T/SPFmWwiT9pm6IZTG4keAR0SkkYhkA4+ravBJXNxEZBwwFNigqj29tp8MPAEkAy+q6sOquhS4\n3BKBiaRhPVvwjy8W8tOyrZSyf+0CT0+gktLSSquGPAPKrh7YgWsGdsDlciVkicBW7YwfoTQWHy8i\nCnwH/IbTlXRgiOcfD5zsc75k4GngFKAHcIGI9KhK0MZU1wmSQ8P6KYz/bSUA6WXdR53Pi0tKyzUW\n+6saSnHvnFQuAZR/Kt56XOfwBm5MBIVSov0HMFhVe6tqN5wH+8OhnFxVp1B+vWOAQ4DFqrpUVQuA\nt4DTqhCzMdVWPzWZ03u15I81O8rew/5pJUrxaSz2UzWUmlzx27/vt2NPggHo1DSjZkEbE2GhJIIC\nVS0bYqmqq4CaVA62BlZ5vV8NtBaRpiLyHNBXRG6vwfmNCepEySl7nenTRlDs80TP8lMiSE2q+N/G\nt5HZey6eW47tzPn9Wlc/YGMiLJSFaZaKyNM4K5S5cFYnWxLuQFR1M3BNuM9rjK8DmmWWvd4/jsB5\nX+KemdT3c28pfkoEvusfe1cvuVw2J4uJbaEkgqtwxhAciVNy/gGnOqe61gBtvd63cW8zplZ4TxpX\nobHYZ8LRND/LUqaEMLI4ySsTuFzlE4MxsSakxetV9RzgtTBdcyrQRUQ64iSA83HGKBhTa47t0oxv\nFm2iSYYzIrisasin15A/KX6moT6sQ+Ny771zhQtXucRgTKwJJRFsEZEHcXoMlS3yqqqfVXagiEwA\nBgPNRGQ18HdVfUlErsdZ6SwZGKeqc6sTvDHVdfPgTvRv25A2jZxFazwPbmfRmuDHpvopEXgSiod3\nU0OSy2YsNbEtlESQBrSkfM+eUqDSRKCqFwTY/lkoxxsTKS2y63Nu3/0NuJ5v7MWllS+64q+NwFdh\nsW+bQfljzu7dkkbpqbz4i9ON9YXzetMiux7DXrBZPU3tCyURXA70V9WpACJyHPBNRKMyppZ5Dygr\nJfhIKX+9hnx5z0WU5KqYWv56fBeAskTQp01DjImWULqPjgfO8np/tHubMXHD82wvLiklyHr3QGgl\nAu9E4LKqIRPjQkkE7VX1Ns8bVf070C5yIRlT+5LKSgS+Y4Qr8tdG4Ku4XCKI3ykodMOuaIdgwiCU\nqqESERkC/ISTOI4FbJ06E1e8q4Y8D/GDWmb73ddfryFfh3v1IkpJit+l3ke/N5vPrz3MekXVcaGU\nCC7B6eL5A/AtcBJwWSSDMqa2eZ5jJaWlZNVzvh/99Xj/8wVVNo6gS04m7Zvsn1YiNdkVt+MItuYX\nstCrVLBrXxFb9xQEOcLEooAlAhGpp6r7gE3A1ewfHGlzDpq44xlkVlICRSUlDO7cFGmeBUC/Ng2Z\nvnp72b6plZQIfL8dpyQlVdoTqS57/LuldM3JYmbeDnT9TopL4V+n9WBQ52bRDs2EKNhv9Mvuv+cC\nc4DZ7j+e98bEjf3dR0vZubeIBvX2f0d67PQDObNXy7L3lZUIRvQvP69QanLgOSaeO7cXr47sW82o\no+/agR1YvHE3E6avYd66nWXLff7lo3nMtoVr6oyAJQJVHeH+u+KircbEmSSvNoLte4vIrp9a9llW\nvRQ6es0gmhwgEfRt05AZq7dzao/cctuDtRH0b9uoZoFH2ajD2nHUAU0Y8er0Cp9t2m1VRHVFsKqh\nccEOVNVR4Q/HmOjw1Pas2prPvqIS2jauX+7zRumpfo4q78kze7Jjb8V+FClJ8dtGANAlJ4t3Lh1A\nfmExl7wxo2z717qRc6MYlwldsF5DBwGNcKaC+AzYXSsRGRMFnu6dv6/aBjjf7r01yag8EdRPTS5b\n38BbRlpKXLcRAGUlpn8O78EtE+cBMHnxpmiGZKogYBuBqh6MswjNWuAe4EactQSmq+p3tRKdMbXE\nM0Zs2qrtNEpPpWOT8ovJNG9Qr9rnrpeSFNclAm+DuzTjn8N7MLhzUwqKrV9JXRG0+4OqLlHVB1T1\nEOAuoDuwQEQ+rpXojKklnnr/lVvz6dM6u8IAsHp+pqOuzJWHt6NrTmblO8aZwV2a8fCwHhWq0+au\n28nLv66ssIiPib5KB5SJiGcxmhHuv78E3o1wXMbUqjSvLqH+BpJVJxFcdUQHrjqiA5B4C9MkJ7n4\n4trDnLoEt0vd7QdDeuTWqIRlwi9YY/EhOAvSnAD8ivPwv1ZVa7JMpTExybtuv1tuVoXP00IYTRxM\nvE4xEUyg0cb//GYxR3Zqwiu/reL583qTk2VJIdqClQh+wVmS8lecKqTzgHNFBLBeQya+eH/jb9Mo\nvcLnoaxKZkIzefFmJi/eDMCdny7g+qM60rFpBkXFpaSnJVer9GVqJlgisPEDJmHU93r4+OshVNlo\n4spYvbgzeO75H5czY83+gWbTV29n1IQ/OKhlA2av3clh7Rvz1NkHRTHKxBRsQNmK2gzEmGjyrhry\n1wU00CCyUFU3DWSkJrOnsLhG144V/ds24vnzenPIv7+v8NnstTsB+GXFVu7/ciF3nti1tsNLaFYG\nM4byJYJIqG6BIIQ1cOoUl8tFC3dDcccmGdw4qBOXHNK23D4fzV5HcUkpK7fms2prPjv3FrGvqMTf\n6UyYhDINtTFxLy3SiaCaZYJ4HIj26si+bNlTyAHNnK61paWlvPLbKgA6NEln+ZZ8Rr42ncWb9o9h\n7dumIWPP6x2VeBOBJQJjCNzDJVz6tK7eUpTx2NmocUYajTPSyt67XC6eO7cX+YXFNM1M4+LXZ5RL\nAgAzVm9ne34hDUOY6sNUXZwVPI2pvuE9c7n3FAn4+XPn9uKjKw6p1rm9J5cLZbqKULVuWL/yneqA\n/m0bcWSnpnTPbcDbl/anfeN0ercqP57j+Gd+psQa3UNSUFTCryu2hrw2hJUIjHG766TASQDCN1Po\nC+f3CXlf3wLBdUd24Jkflpe9j8derZ2aZvL2pQNIcsEpz//KZq9ZTI9/+meO7tyUozs14egDmoa0\nWlyi+Uo38sjXi9i+t4isesmMHNCG24b1DHqM/RSNqWU1eXg3rF/+u1tlA9Xq6viH5CRnnedxF/Th\nL8ccAMDAjk04vENjfliymb9+PJ9hL/zGCz+vsOmuvewpKObRSYvJbVCPB4d2p3erhjz3Y+UdQK1E\nYEyMOqhlA1ZuzQdg0AFN+W7J5iqf49qBHXjq+2XhDq3WtGpYn/P6tea8fvsX+ykuKeWX5Vt5e8Ya\nxv60gnG/rOS4rs04vEMTDmqVTdtG9RNiJHdBUQnFpaWke3V3fnvGGrblF/LY6QfSq1U2J0gOedv3\nVnouSwTGxKAR/Vsz+uhOnPzszwAkVeGbvWeBHAitsdl7/7ogOcnFwE5NGNipCSu27OHdP/L4bN4G\nvliwEXBKTQe1yuaMXi05slOTiHcEiIY5a3fwfx/MZWt+Ia0b1qdzs0xaN6rPhGlrOKpTE3p5ta+0\nCqEdyRKBMbWkZXY91u7YF/ThfKLk8KVupE2j9HLVOlUamey1b8P6lTdMX31Ee655Z1bo548h7Ztk\n8JdjO3Pz4ANYtmUPc/J2MGftTn5evoU/fziXjk0yGHlwG07p3rzGo8Njxbb8Qq5/bzaN0lM5p28r\nlm3eg27YxXdLNpORmsyNgzpV+ZyWCIypJZ7nc7CxAWf0asmXupH+bZ3upqFWcbx72QDOefn3CttT\nkis/3ncRnkjJaV5xVtdwagEcHtErhKYkM4s9t9xO/nWjI3L+d2fksbugmBcv6EPnZvunOV+62ely\n295nLY1QxEeKNKYOCfZsH9CuEVP/fDSdmjr/wVtmO6Nwy6a4CHRwqd+XIYlk1UlJZsWZXONd0u5d\nZPzzoYicu7S0lA9nr+WIjo3LJQFwelt5fm+qyhKBMbXE84CuymP38TN78vCw7jSo57/w7u9csdTV\nfs8ttydsMoiEhRt3s2FXAcd1zQnrea1qyJhaUp0ZSJtkpHFc1xx+Wb61Wtf092X/z8ccQPfcLK54\na2alx5/frzVvTV9TrWsD5F83OmJVJDVRXFLKrLwdTFmymSlLNpf1zjqgWQbHdcnheMkpW4e5KkKt\n/tq1r4hd+4rIyapXpQkNf1y6BYAjOjapcmzBWCIwppZVp2ujdwp559IBnDv+94Cfe79O9nOt8/u1\nZnt+Yq8vlZzkom+bhvRt05Abju7IvPW7+G3FVr5fspmxP69g7M8rOLJTE47p3IzkJBfZ9VM4sGUD\nmnhNjRGqHXsLWbhhN/PX72TeOudP3o59gDPOo1XD+nRqmsGxXZsx6IBmZKRVnP3W44elW+iem0Wz\nzKrHEUzMJAIRyQSeAQqAyar6RpRDMiasDmqVzaSFm2o802nHphlMuKQ/xSWl3Pnp/ID79WvTkGO7\n5sCnC6p9rUAp66hOTbj8sHbVPm8scblcHNiiAQe2aMClh7Rl9tqdfLd4E5/MXc8P7m/gHi2z63FU\np6ZcemjbSldW85QOcoADgFPCEGvZYvH/V8UDKymNRjQRiMg4YCiwQVV7em0/GXgCSAZeVNWHgTOB\n91T1YxF5G7BEYOLKPScLlx3aLiwTp/k2FHrz/J+/7sgOAUcWV6d9+OTuzfl8/gYA/n1G8CkL6iqX\ny0WvVtn0apXNtUd2ZN0OZzDWpl0FzFm3k9l5O/jvrLX8d9Za2jaqT5tG6eS6p9XeU1DMf+pnUH/v\nnmjeQrVEukQwHhgDvOrZICLJwNM4ayGvBqaKyESgDTDbvVt8rMRhjJf6qclI8+o1nHoe6L69Qa84\nrD13frag7GEUCacd1IKPZq8jLYSuqPEkJclVtmxpm0bp9HF3s129LZ+Jc9axfEs+q7flMzvPWXEt\nMy2Z5waP5OpvXyN9X37U4q6OiCYCVZ0iIh18Nh8CLFbVpQAi8hZwGk5SaAP8gfVmMqac647sQGpy\nEqf2yC23/aTuzTmpe3OfvStvlPaMZciqF7g+2uOc3q34aPY6DuvQhIlz1occc7xq0yid644MsJLv\nlYeyi38Rrj5DRcUlvD9rHWN/Ws72vUVcdXh7rjyifZXPU1kfo2i0EbQGVnm9Xw0cCjwJjBGRIXhV\nhRljILt+Kn92T74WqlAapT3VSM+e04tHv1nMss0VqzUkN4vJo48gMy2Fv30SuE3ChF9KchLn9m3F\nkAObs2bbXjoFqRKs0XUictZqUNXdwGXRjsOYui6UTqq+OWJAu0YM6ZHLGPcEda+N7MtFr89gWE+n\nBJKZFjOPioSUmZZC12pWK4YiGv+6awDvRUrbuLcZY8LAU+0TrDxQz91zaUT//bN6evdm6pbbgKl/\nPrrCcbce17na7RwmdkUjEUwFuohIR5wEcD4wIgpxGBOX7hsiTJi2hh4tGgTcJzU5qcKD/szeLfnX\nt0uCnvucPq3CEqOJLRFtlBWRCcDPzktZLSKXq2oRcD3wBTAfeEdV50YyDmMSSeuG6fzl2M5VGrEK\nTnL4x6lSYYlIE/8i3WvoggDbPwM+i+S1jTEVNapkDMMp3XM5pXtu0H1M/LEWIGPiRPOsNDbsCrxs\n472nCL1b27d9U5ElAmPixCsj+7Fqa+CBTL5jEIzxsERgTJxolpkW9snITGKwEbzGGJPgLBEYY0yC\ns0RgjDEJzhKBMXEuM8hCJ8YAuKqzfF40bdy4s24FbEyUbd1TwLb8omotvWjiQ05Og6CjC63XkDFx\nrnFGGo2rscSiSRxWNWSMMQnOEoExxiQ4SwTGGJPgLBEYY0yCs0RgjDEJzhKBMcYkOEsExhiT4CwR\nGGNMgqtzI4uNMcaEl5UIjDEmwVkiMMaYBGeJwBhjEpwlAmOMSXBxM/uoiAwG7gPmAm+p6uSoBhRG\nItIduBFoBkxS1WejHFJYiEgn4A6goaqeHe14aire7scjjn//BhO/z4yjgAtxnvE9VPWIYPvHRCIQ\nkXHAUGCDqvb02n4y8ASQDLyoqg8HOU0psAuoD6yOYLhVEo57U9X5wDUikgS8CkT9P2KY7mspcLmI\nvBfpeKurKvdZF+7Ho4r3FXO/f4FU8fcyJp8ZgVTx3+x74HsROR2YWtm5YyIRAOOBMTi/ZACISDLw\nNHACzj/SVBGZiHOzD/kcPwr4XlW/E5Fc4N842TAWjKeG96aqG0RkOHAt8FptBB2C8YThvmon1BoZ\nT4j3qarzohJh9YynCvcVg79/gYwn9N/LWH1mBDKeqv8ujgAur+zEMZEIVHWKiHTw2XwIsNj9LQsR\neQs4TVUfwsmKgWwF6kUk0GoI172p6kRgooh8CrwZwZBDEuZ/s5hVlfsE6kwiqOp9xdrvXyBV/L30\n/HvF1DMjkKr+m4lIO2C7qu6s7NwxkQgCaA2s8nq/Gjg00M4iciZwEtAIJ2vGsqre22DgTJxf1s8i\nGlnNVPW+mgIPAH1F5HZ3wqgL/N5nHb4fj0D3NZi68fsXSKD7qkvPjECC/Z+7HHg5lJPEciKoElV9\nH3g/2nFEgrsRa3KUwwg7Vd0MXBPtOMIl3u7HI45//+L2mQGgqn8Pdd9Y7j66Bmjr9b6Ne1s8iNd7\ni9f78hWv92n3VfeE5d5iuUQwFegiIh1xbux8nIaPeBCv9xav9+UrXu/T7qvuCcu9xUSJQEQmAD87\nL5VFQE0AAALiSURBVGW1iFyuqkXA9cAXwHzgHVWdG804qyNe7y1e78tXvN6n3Vfdui+I7L3Z7KPG\nGJPgYqJEYIwxJnosERhjTIKzRGCMMQnOEoExxiQ4SwTGGJPgLBEYY0yCi+UBZcaEhXuirtnANJ+P\nzlTVLbUcy3KcuWEuU9XFPp8lAcuAg71nZnX3H/8EuAVngrG4WevAxAZLBCZRqKoOjnYQbqeo6i7f\njapa4l7L4Czcc/6LSDpwFHAZzsjR62szUJMYLBGYhCYi44G1QD+gHXChqk4XkT/hDNUvAT5U1cdE\n5B6gE9AROB5nXvj2wE/AuThzwo9V1aPc574D2KmqTwa4doVr4Ezx/Bj7F385FfhKVfeKSJjv3hiH\ntREYA2mqehLOKk8Xu+dtORs4EjgaOMs9t7tn36OAE4H6qnoY8A3Qyr2SVz0RaePedyjwtr8LBrqG\nqk4DmotIS/eu5xLD8/+b+GAlApMoREQme71XVb3a/fp799+eudwPAboA37q3NwA6uF//5v67O/Cj\n+/VnQJH79evAue4FQrar6voA8QS6xkqc5HG2iLwE9Cd+JkgzMcoSgUkUwdoIirxeu4AC4FOvRAGA\niBzr/syzX7H7dan7D8AE4L/AbvfrQPxew+1N4CUgz71PsZ99jAkbqxoypqJpwDEikiEiLhF5wt1o\n620JMMD9+kTcX6pUdSOwBbiI4IueBLyGqi4CUoGLsWohUwusRGAShW/VEMCt/nZU1ZUi8jgwBedb\n/4eqmu/TWPsJMEpEfsBZvWuz12fvAcOCrRUb6Bpeu7wD/ElVfw3l5oypCZuG2phqEJEmwDGq+l8R\naQ1MUtVu7s9eAcar6rd+jlsO9PTXfTSEaw4GrrdxBCbcrGrImOrZidMo/AvwAXCziNR3v9/hLwl4\n+Z+IdK7KxURkCPB49cM1JjArERhjTIKzEoExxiQ4SwTGGJPgLBEYY0yCs0RgjDEJzhKBMcYkOEsE\nxhiT4P4fD4z+wrudGZ0AAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7f37c6c1a470>"
+       "<Figure size 432x288 with 1 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -2033,10 +2653,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 29,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Construct a Pandas DataFrame for the microscopic nu-scattering matrix\n",
@@ -2065,19 +2683,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 30,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADRCAYAAADcxUm6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nK8T/B194ISi0+XToAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7f378a84d7b8>"
+       "<Figure size 432x288 with 2 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -2118,9 +2736,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.0"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
 }
diff --git a/examples/jupyter/mgxs-part-iii.ipynb b/examples/jupyter/mgxs-part-iii.ipynb
index 5ffb66d3a..a4c440b3a 100644
--- a/examples/jupyter/mgxs-part-iii.ipynb
+++ b/examples/jupyter/mgxs-part-iii.ipynb
@@ -25,20 +25,7 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/nelsonag/python/openmc/lib/python3.6/site-packages/matplotlib/__init__.py:1405: UserWarning: \n",
-      "This call to matplotlib.use() has no effect because the backend has already\n",
-      "been chosen; matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n",
-      "or matplotlib.backends is imported for the first time.\n",
-      "\n",
-      "  warnings.warn(_use_error_msg)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import math\n",
     "import pickle\n",
@@ -124,8 +111,8 @@
    "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",
+    "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",
@@ -345,68 +332,32 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let us also create a `Plots` file that we can use to verify that our fuel assembly geometry was created successfully."
+    "Let us also create a plot to verify that our fuel assembly geometry was created successfully."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Instantiate a Plot\n",
-    "plot = openmc.Plot(plot_id=1)\n",
-    "plot.filename = 'materials-xy'\n",
-    "plot.origin = [0, 0, 0]\n",
-    "plot.pixels = [250, 250]\n",
-    "plot.width = [-10.71*2, -10.71*2]\n",
-    "plot.color_by = 'material'\n",
-    "\n",
-    "# Instantiate a Plots object, add Plot, and export to \"plots.xml\"\n",
-    "plot_file = openmc.Plots([plot])\n",
-    "plot_file.export_to_xml()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With the plots.xml file, we can now generate and view the plot. OpenMC outputs plots in .ppm format, which can be converted into a compressed format like .png with the convert utility."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run openmc in plotting mode\n",
-    "openmc.plot_geometry(output=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# Convert OpenMC's funky ppm to png\n",
-    "!convert materials-xy.ppm materials-xy.png\n",
-    "\n",
-    "# Display the materials plot inline\n",
-    "Image(filename='materials-xy.png')"
+    "# 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()"
    ]
   },
   {
@@ -432,7 +383,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -450,7 +401,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -488,7 +439,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -507,7 +458,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -527,7 +478,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -544,7 +495,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -563,7 +514,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -581,7 +532,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -605,28 +556,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=126.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=126.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=21.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=21.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=3.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=3.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=4.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=4.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=96.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=96.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=15.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=15.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/nelsonag/git/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=114.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=114.\n",
       "  warn(msg, IDWarning)\n"
      ]
     }
@@ -638,142 +589,140 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "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",
-      "                 ####################     %%%%%%%%%%%%%%%%%\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-2018 Massachusetts Institute of Technology\n",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.10.0\n",
-      "          Git SHA1 | 6c2d82a4d7dfe10312329d5969568fc03a698416\n",
-      "         Date/Time | 2018-04-24 19:20:48\n",
-      "    OpenMP Threads | 8\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",
-      " Building neighboring cells lists for each surface...\n",
-      " Reading U235 from /opt/xsdata/nndc/U235.h5\n",
-      " Reading U238 from /opt/xsdata/nndc/U238.h5\n",
-      " Reading O16 from /opt/xsdata/nndc/O16.h5\n",
-      " Reading H1 from /opt/xsdata/nndc/H1.h5\n",
-      " Reading B10 from /opt/xsdata/nndc/B10.h5\n",
-      " Reading Zr90 from /opt/xsdata/nndc/Zr90.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for U235\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.00795                       \n",
-      "        8/1    1.02418                       \n",
-      "        9/1    1.02241                       \n",
-      "       10/1    1.03731                       \n",
-      "       11/1    1.01477                       \n",
-      "       12/1    1.05315    1.03396 +/- 0.01919\n",
-      "       13/1    1.02824    1.03205 +/- 0.01124\n",
-      "       14/1    1.02858    1.03118 +/- 0.00800\n",
-      "       15/1    1.02176    1.02930 +/- 0.00647\n",
-      "       16/1    1.06046    1.03449 +/- 0.00741\n",
-      "       17/1    1.02066    1.03252 +/- 0.00657\n",
-      "       18/1    1.03088    1.03231 +/- 0.00569\n",
-      "       19/1    1.02021    1.03097 +/- 0.00520\n",
-      "       20/1    1.02717    1.03059 +/- 0.00466\n",
-      "       21/1    1.03455    1.03095 +/- 0.00423\n",
-      "       22/1    1.02917    1.03080 +/- 0.00387\n",
-      "       23/1    1.02800    1.03058 +/- 0.00356\n",
-      "       24/1    1.02935    1.03050 +/- 0.00330\n",
-      "       25/1    1.01612    1.02954 +/- 0.00322\n",
-      "       26/1    1.00549    1.02803 +/- 0.00336\n",
-      "       27/1    1.02824    1.02805 +/- 0.00316\n",
-      "       28/1    1.01487    1.02731 +/- 0.00307\n",
-      "       29/1    1.05544    1.02879 +/- 0.00326\n",
-      "       30/1    1.00467    1.02759 +/- 0.00332\n",
-      "       31/1    1.03942    1.02815 +/- 0.00321\n",
-      "       32/1    1.02587    1.02805 +/- 0.00306\n",
-      "       33/1    1.02938    1.02811 +/- 0.00292\n",
-      "       34/1    1.02838    1.02812 +/- 0.00280\n",
-      "       35/1    1.00052    1.02701 +/- 0.00290\n",
-      "       36/1    1.01722    1.02664 +/- 0.00281\n",
-      "       37/1    1.01881    1.02635 +/- 0.00272\n",
-      "       38/1    1.03928    1.02681 +/- 0.00266\n",
-      "       39/1    1.03802    1.02720 +/- 0.00260\n",
-      "       40/1    1.00710    1.02653 +/- 0.00260\n",
-      "       41/1    1.02558    1.02650 +/- 0.00251\n",
-      "       42/1    1.03499    1.02676 +/- 0.00245\n",
-      "       43/1    1.01128    1.02629 +/- 0.00242\n",
-      "       44/1    1.00442    1.02565 +/- 0.00243\n",
-      "       45/1    1.03444    1.02590 +/- 0.00238\n",
-      "       46/1    1.01799    1.02568 +/- 0.00232\n",
-      "       47/1    1.00814    1.02521 +/- 0.00231\n",
-      "       48/1    1.00500    1.02467 +/- 0.00231\n",
-      "       49/1    1.01960    1.02454 +/- 0.00225\n",
-      "       50/1    1.02431    1.02454 +/- 0.00219\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     =  2.8179E-01 seconds\n",
-      "   Reading cross sections          =  2.5741E-01 seconds\n",
-      " Total time in simulation          =  2.5787E+01 seconds\n",
-      "   Time in transport only          =  2.5724E+01 seconds\n",
-      "   Time in inactive batches        =  1.7591E+00 seconds\n",
-      "   Time in active batches          =  2.4028E+01 seconds\n",
-      "   Time synchronizing fission bank =  1.3217E-02 seconds\n",
-      "     Sampling source sites         =  1.0464E-02 seconds\n",
-      "     SEND/RECV source sites        =  2.6486E-03 seconds\n",
-      "   Time accumulating tallies       =  2.7351E-04 seconds\n",
-      " Total time for finalization       =  5.5454E-05 seconds\n",
-      " Total time elapsed                =  2.6109E+01 seconds\n",
-      " Calculation Rate (inactive)       =  56847.1 neutrons/second\n",
-      " Calculation Rate (active)         =  16647.3 neutrons/second\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.02204 +/-  0.00176\n",
-      " k-effective (Track-length)  =  1.02454 +/-  0.00219\n",
-      " k-effective (Absorption)    =  1.02370 +/-  0.00186\n",
-      " Combined k-effective        =  1.02329 +/-  0.00157\n",
-      " Leakage Fraction            =  0.00000 +/-  0.00000\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"
      ]
     }
@@ -799,7 +748,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -816,7 +765,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -849,7 +798,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -867,25 +816,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
-       "<style>\n",
-       "    .dataframe thead tr:only-child th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: left;\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
        "    }\n",
        "\n",
        "    .dataframe tbody tr th {\n",
        "        vertical-align: top;\n",
        "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
        "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
@@ -904,16 +853,16 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>8.093482e-03</td>\n",
-       "      <td>1.597406e-05</td>\n",
+       "      <td>8.089079e-03</td>\n",
+       "      <td>1.461462e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>U238</td>\n",
-       "      <td>7.347745e-03</td>\n",
-       "      <td>2.082526e-05</td>\n",
+       "      <td>7.358661e-03</td>\n",
+       "      <td>2.302063e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
@@ -928,16 +877,16 @@
        "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>U235</td>\n",
-       "      <td>3.615911e-01</td>\n",
-       "      <td>1.206052e-03</td>\n",
+       "      <td>3.617174e-01</td>\n",
+       "      <td>9.467633e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>1</td>\n",
        "      <td>2</td>\n",
        "      <td>U238</td>\n",
-       "      <td>6.743056e-07</td>\n",
-       "      <td>2.229534e-09</td>\n",
+       "      <td>6.744743e-07</td>\n",
+       "      <td>1.750450e-09</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -953,15 +902,15 @@
       ],
       "text/plain": [
        "   cell  group in nuclide          mean     std. dev.\n",
-       "3     1         1    U235  8.093482e-03  1.597406e-05\n",
-       "4     1         1    U238  7.347745e-03  2.082526e-05\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.615911e-01  1.206052e-03\n",
-       "1     1         2    U238  6.743056e-07  2.229534e-09\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": 29,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -980,7 +929,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
@@ -993,13 +942,13 @@
       "\tDomain ID      =\t1\n",
       "\tNuclide        =\tU235\n",
       "\tCross Sections [cm^-1]:\n",
-      "            Group 1 [0.625      - 20000000.0eV]:\t8.09e-03 +/- 1.97e-01%\n",
-      "            Group 2 [0.0        - 0.625     eV]:\t3.62e-01 +/- 3.34e-01%\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.35e-03 +/- 2.83e-01%\n",
-      "            Group 2 [0.0        - 0.625     eV]:\t6.74e-07 +/- 3.31e-01%\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",
@@ -1014,7 +963,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/nelsonag/git/openmc/openmc/tallies.py:1269: RuntimeWarning: invalid value encountered in true_divide\n",
+      "/home/romano/openmc/openmc/tallies.py:1269: RuntimeWarning: invalid value encountered in true_divide\n",
       "  data = self.std_dev[indices] / self.mean[indices]\n"
      ]
     }
@@ -1032,7 +981,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1049,7 +998,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1059,7 +1008,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1076,7 +1025,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1089,25 +1038,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
-       "<style>\n",
-       "    .dataframe thead tr:only-child th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: left;\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
        "    }\n",
        "\n",
        "    .dataframe tbody tr th {\n",
        "        vertical-align: top;\n",
        "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
        "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
@@ -1126,16 +1075,16 @@
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
-       "      <td>0.074672</td>\n",
-       "      <td>0.000179</td>\n",
+       "      <td>0.074556</td>\n",
+       "      <td>0.000144</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>1</td>\n",
        "      <td>1</td>\n",
        "      <td>U238</td>\n",
-       "      <td>0.005964</td>\n",
-       "      <td>0.000017</td>\n",
+       "      <td>0.005976</td>\n",
+       "      <td>0.000019</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -1151,12 +1100,12 @@
       ],
       "text/plain": [
        "   cell  group in nuclide      mean  std. dev.\n",
-       "0     1         1    U235  0.074672   0.000179\n",
-       "1     1         1    U238  0.005964   0.000017\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": 35,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1185,7 +1134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1202,7 +1151,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1219,7 +1168,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 36,
    "metadata": {
     "scrolled": true
    },
@@ -1228,133 +1177,301 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[  NORMAL ]  Importing ray tracing data from file...\n",
+      "[  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:\tk_eff = 0.823436\tres = 0.000E+00\n",
-      "[  NORMAL ]  Iteration 1:\tk_eff = 0.780042\tres = 1.941E-01\n",
-      "[  NORMAL ]  Iteration 2:\tk_eff = 0.739063\tres = 6.559E-02\n",
-      "[  NORMAL ]  Iteration 3:\tk_eff = 0.710328\tres = 5.301E-02\n",
-      "[  NORMAL ]  Iteration 4:\tk_eff = 0.689038\tres = 3.942E-02\n",
-      "[  NORMAL ]  Iteration 5:\tk_eff = 0.674339\tres = 3.021E-02\n",
-      "[  NORMAL ]  Iteration 6:\tk_eff = 0.665075\tres = 2.149E-02\n",
-      "[  NORMAL ]  Iteration 7:\tk_eff = 0.660373\tres = 1.387E-02\n",
-      "[  NORMAL ]  Iteration 8:\tk_eff = 0.659460\tres = 7.242E-03\n",
-      "[  NORMAL ]  Iteration 9:\tk_eff = 0.661679\tres = 1.995E-03\n",
-      "[  NORMAL ]  Iteration 10:\tk_eff = 0.666463\tres = 3.649E-03\n",
-      "[  NORMAL ]  Iteration 11:\tk_eff = 0.673324\tres = 7.367E-03\n",
-      "[  NORMAL ]  Iteration 12:\tk_eff = 0.681842\tres = 1.039E-02\n",
-      "[  NORMAL ]  Iteration 13:\tk_eff = 0.691660\tres = 1.273E-02\n",
-      "[  NORMAL ]  Iteration 14:\tk_eff = 0.702469\tres = 1.447E-02\n",
-      "[  NORMAL ]  Iteration 15:\tk_eff = 0.714008\tres = 1.569E-02\n",
-      "[  NORMAL ]  Iteration 16:\tk_eff = 0.726057\tres = 1.649E-02\n",
-      "[  NORMAL ]  Iteration 17:\tk_eff = 0.738428\tres = 1.693E-02\n",
-      "[  NORMAL ]  Iteration 18:\tk_eff = 0.750965\tres = 1.709E-02\n",
-      "[  NORMAL ]  Iteration 19:\tk_eff = 0.763536\tres = 1.703E-02\n",
-      "[  NORMAL ]  Iteration 20:\tk_eff = 0.776034\tres = 1.679E-02\n",
-      "[  NORMAL ]  Iteration 21:\tk_eff = 0.788369\tres = 1.641E-02\n",
-      "[  NORMAL ]  Iteration 22:\tk_eff = 0.800470\tres = 1.594E-02\n",
-      "[  NORMAL ]  Iteration 23:\tk_eff = 0.812280\tres = 1.539E-02\n",
-      "[  NORMAL ]  Iteration 24:\tk_eff = 0.823753\tres = 1.479E-02\n",
-      "[  NORMAL ]  Iteration 25:\tk_eff = 0.834854\tres = 1.416E-02\n",
-      "[  NORMAL ]  Iteration 26:\tk_eff = 0.845560\tres = 1.351E-02\n",
-      "[  NORMAL ]  Iteration 27:\tk_eff = 0.855851\tres = 1.286E-02\n",
-      "[  NORMAL ]  Iteration 28:\tk_eff = 0.865717\tres = 1.220E-02\n",
-      "[  NORMAL ]  Iteration 29:\tk_eff = 0.875152\tres = 1.156E-02\n",
-      "[  NORMAL ]  Iteration 30:\tk_eff = 0.884153\tres = 1.093E-02\n",
-      "[  NORMAL ]  Iteration 31:\tk_eff = 0.892725\tres = 1.031E-02\n",
-      "[  NORMAL ]  Iteration 32:\tk_eff = 0.900872\tres = 9.722E-03\n",
-      "[  NORMAL ]  Iteration 33:\tk_eff = 0.908602\tres = 9.152E-03\n",
-      "[  NORMAL ]  Iteration 34:\tk_eff = 0.915926\tres = 8.605E-03\n",
-      "[  NORMAL ]  Iteration 35:\tk_eff = 0.922853\tres = 8.083E-03\n",
-      "[  NORMAL ]  Iteration 36:\tk_eff = 0.929399\tres = 7.586E-03\n",
-      "[  NORMAL ]  Iteration 37:\tk_eff = 0.935576\tres = 7.114E-03\n",
-      "[  NORMAL ]  Iteration 38:\tk_eff = 0.941398\tres = 6.666E-03\n",
-      "[  NORMAL ]  Iteration 39:\tk_eff = 0.946880\tres = 6.242E-03\n",
-      "[  NORMAL ]  Iteration 40:\tk_eff = 0.952037\tres = 5.841E-03\n",
-      "[  NORMAL ]  Iteration 41:\tk_eff = 0.956883\tres = 5.463E-03\n",
-      "[  NORMAL ]  Iteration 42:\tk_eff = 0.961434\tres = 5.107E-03\n",
-      "[  NORMAL ]  Iteration 43:\tk_eff = 0.965705\tres = 4.771E-03\n",
-      "[  NORMAL ]  Iteration 44:\tk_eff = 0.969708\tres = 4.456E-03\n",
-      "[  NORMAL ]  Iteration 45:\tk_eff = 0.973460\tres = 4.159E-03\n",
-      "[  NORMAL ]  Iteration 46:\tk_eff = 0.976972\tres = 3.881E-03\n",
-      "[  NORMAL ]  Iteration 47:\tk_eff = 0.980259\tres = 3.620E-03\n",
-      "[  NORMAL ]  Iteration 48:\tk_eff = 0.983333\tres = 3.375E-03\n",
-      "[  NORMAL ]  Iteration 49:\tk_eff = 0.986206\tres = 3.146E-03\n",
-      "[  NORMAL ]  Iteration 50:\tk_eff = 0.988890\tres = 2.932E-03\n",
-      "[  NORMAL ]  Iteration 51:\tk_eff = 0.991396\tres = 2.731E-03\n",
-      "[  NORMAL ]  Iteration 52:\tk_eff = 0.993735\tres = 2.543E-03\n",
-      "[  NORMAL ]  Iteration 53:\tk_eff = 0.995917\tres = 2.368E-03\n",
-      "[  NORMAL ]  Iteration 54:\tk_eff = 0.997952\tres = 2.204E-03\n",
-      "[  NORMAL ]  Iteration 55:\tk_eff = 0.999848\tres = 2.050E-03\n",
-      "[  NORMAL ]  Iteration 56:\tk_eff = 1.001616\tres = 1.907E-03\n",
-      "[  NORMAL ]  Iteration 57:\tk_eff = 1.003262\tres = 1.774E-03\n",
-      "[  NORMAL ]  Iteration 58:\tk_eff = 1.004795\tres = 1.650E-03\n",
-      "[  NORMAL ]  Iteration 59:\tk_eff = 1.006222\tres = 1.534E-03\n",
-      "[  NORMAL ]  Iteration 60:\tk_eff = 1.007550\tres = 1.425E-03\n",
-      "[  NORMAL ]  Iteration 61:\tk_eff = 1.008785\tres = 1.325E-03\n",
-      "[  NORMAL ]  Iteration 62:\tk_eff = 1.009934\tres = 1.231E-03\n",
-      "[  NORMAL ]  Iteration 63:\tk_eff = 1.011002\tres = 1.143E-03\n",
-      "[  NORMAL ]  Iteration 64:\tk_eff = 1.011995\tres = 1.062E-03\n",
-      "[  NORMAL ]  Iteration 65:\tk_eff = 1.012918\tres = 9.859E-04\n",
-      "[  NORMAL ]  Iteration 66:\tk_eff = 1.013775\tres = 9.153E-04\n",
-      "[  NORMAL ]  Iteration 67:\tk_eff = 1.014571\tres = 8.497E-04\n",
-      "[  NORMAL ]  Iteration 68:\tk_eff = 1.015311\tres = 7.886E-04\n",
-      "[  NORMAL ]  Iteration 69:\tk_eff = 1.015997\tres = 7.318E-04\n",
-      "[  NORMAL ]  Iteration 70:\tk_eff = 1.016635\tres = 6.790E-04\n",
-      "[  NORMAL ]  Iteration 71:\tk_eff = 1.017226\tres = 6.300E-04\n",
-      "[  NORMAL ]  Iteration 72:\tk_eff = 1.017775\tres = 5.844E-04\n",
-      "[  NORMAL ]  Iteration 73:\tk_eff = 1.018285\tres = 5.420E-04\n",
-      "[  NORMAL ]  Iteration 74:\tk_eff = 1.018757\tres = 5.026E-04\n",
-      "[  NORMAL ]  Iteration 75:\tk_eff = 1.019195\tres = 4.660E-04\n",
-      "[  NORMAL ]  Iteration 76:\tk_eff = 1.019602\tres = 4.321E-04\n",
-      "[  NORMAL ]  Iteration 77:\tk_eff = 1.019979\tres = 4.005E-04\n",
-      "[  NORMAL ]  Iteration 78:\tk_eff = 1.020328\tres = 3.713E-04\n",
-      "[  NORMAL ]  Iteration 79:\tk_eff = 1.020652\tres = 3.441E-04\n",
-      "[  NORMAL ]  Iteration 80:\tk_eff = 1.020952\tres = 3.189E-04\n",
-      "[  NORMAL ]  Iteration 81:\tk_eff = 1.021230\tres = 2.955E-04\n",
-      "[  NORMAL ]  Iteration 82:\tk_eff = 1.021488\tres = 2.738E-04\n",
-      "[  NORMAL ]  Iteration 83:\tk_eff = 1.021727\tres = 2.536E-04\n",
-      "[  NORMAL ]  Iteration 84:\tk_eff = 1.021948\tres = 2.350E-04\n",
-      "[  NORMAL ]  Iteration 85:\tk_eff = 1.022153\tres = 2.177E-04\n",
-      "[  NORMAL ]  Iteration 86:\tk_eff = 1.022344\tres = 2.016E-04\n",
-      "[  NORMAL ]  Iteration 87:\tk_eff = 1.022520\tres = 1.867E-04\n",
-      "[  NORMAL ]  Iteration 88:\tk_eff = 1.022683\tres = 1.729E-04\n",
-      "[  NORMAL ]  Iteration 89:\tk_eff = 1.022833\tres = 1.601E-04\n",
-      "[  NORMAL ]  Iteration 90:\tk_eff = 1.022973\tres = 1.482E-04\n",
-      "[  NORMAL ]  Iteration 91:\tk_eff = 1.023102\tres = 1.372E-04\n",
-      "[  NORMAL ]  Iteration 92:\tk_eff = 1.023222\tres = 1.271E-04\n",
-      "[  NORMAL ]  Iteration 93:\tk_eff = 1.023333\tres = 1.176E-04\n",
-      "[  NORMAL ]  Iteration 94:\tk_eff = 1.023436\tres = 1.089E-04\n",
-      "[  NORMAL ]  Iteration 95:\tk_eff = 1.023531\tres = 1.008E-04\n",
-      "[  NORMAL ]  Iteration 96:\tk_eff = 1.023619\tres = 9.327E-05\n",
-      "[  NORMAL ]  Iteration 97:\tk_eff = 1.023700\tres = 8.632E-05\n",
-      "[  NORMAL ]  Iteration 98:\tk_eff = 1.023775\tres = 7.988E-05\n",
-      "[  NORMAL ]  Iteration 99:\tk_eff = 1.023845\tres = 7.391E-05\n",
-      "[  NORMAL ]  Iteration 100:\tk_eff = 1.023910\tres = 6.838E-05\n",
-      "[  NORMAL ]  Iteration 101:\tk_eff = 1.023969\tres = 6.329E-05\n",
-      "[  NORMAL ]  Iteration 102:\tk_eff = 1.024024\tres = 5.855E-05\n",
-      "[  NORMAL ]  Iteration 103:\tk_eff = 1.024076\tres = 5.415E-05\n",
-      "[  NORMAL ]  Iteration 104:\tk_eff = 1.024123\tres = 5.011E-05\n",
-      "[  NORMAL ]  Iteration 105:\tk_eff = 1.024166\tres = 4.634E-05\n",
-      "[  NORMAL ]  Iteration 106:\tk_eff = 1.024207\tres = 4.290E-05\n",
-      "[  NORMAL ]  Iteration 107:\tk_eff = 1.024244\tres = 3.966E-05\n",
-      "[  NORMAL ]  Iteration 108:\tk_eff = 1.024279\tres = 3.669E-05\n",
-      "[  NORMAL ]  Iteration 109:\tk_eff = 1.024311\tres = 3.392E-05\n",
-      "[  NORMAL ]  Iteration 110:\tk_eff = 1.024341\tres = 3.137E-05\n",
-      "[  NORMAL ]  Iteration 111:\tk_eff = 1.024368\tres = 2.904E-05\n",
-      "[  NORMAL ]  Iteration 112:\tk_eff = 1.024393\tres = 2.686E-05\n",
-      "[  NORMAL ]  Iteration 113:\tk_eff = 1.024417\tres = 2.481E-05\n",
-      "[  NORMAL ]  Iteration 114:\tk_eff = 1.024438\tres = 2.296E-05\n",
-      "[  NORMAL ]  Iteration 115:\tk_eff = 1.024458\tres = 2.121E-05\n",
-      "[  NORMAL ]  Iteration 116:\tk_eff = 1.024477\tres = 1.961E-05\n",
-      "[  NORMAL ]  Iteration 117:\tk_eff = 1.024494\tres = 1.815E-05\n",
-      "[  NORMAL ]  Iteration 118:\tk_eff = 1.024510\tres = 1.679E-05\n",
-      "[  NORMAL ]  Iteration 119:\tk_eff = 1.024524\tres = 1.551E-05\n",
-      "[  NORMAL ]  Iteration 120:\tk_eff = 1.024538\tres = 1.435E-05\n",
-      "[  NORMAL ]  Iteration 121:\tk_eff = 1.024550\tres = 1.326E-05\n",
-      "[  NORMAL ]  Iteration 122:\tk_eff = 1.024561\tres = 1.226E-05\n",
-      "[  NORMAL ]  Iteration 123:\tk_eff = 1.024572\tres = 1.133E-05\n",
-      "[  NORMAL ]  Iteration 124:\tk_eff = 1.024582\tres = 1.047E-05\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"
      ]
     }
    ],
@@ -1377,16 +1494,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "openmc keff = 1.023293\n",
-      "openmoc keff = 1.024582\n",
-      "bias [pcm]: 128.8\n"
+      "openmc keff = 1.024078\n",
+      "openmoc keff = 1.028742\n",
+      "bias [pcm]: 466.4\n"
      ]
     }
    ],
@@ -1428,7 +1545,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1452,7 +1569,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1482,27 +1599,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.text.Text at 0x7f6dafba74a8>"
+       "Text(0.5, 1.0, 'OpenMOC Fission Rates')"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 40,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7f6dafd978d0>"
+       "<Figure size 432x288 with 2 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -1540,7 +1659,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/nuclear-data-resonance-covariance.ipynb b/examples/jupyter/nuclear-data-resonance-covariance.ipynb
index 2c44b6f7f..d8bca235d 100644
--- a/examples/jupyter/nuclear-data-resonance-covariance.ipynb
+++ b/examples/jupyter/nuclear-data-resonance-covariance.ipynb
@@ -208,7 +208,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x14feb768f550>"
+       "<matplotlib.colorbar.Colorbar at 0x14cf90c73550>"
       ]
      },
      "execution_count": 5,
@@ -217,17 +217,19 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
    "source": [
-    "plt.imshow(covariance,cmap='seismic',vmin=-0.08, vmax=0.08)\n",
+    "plt.imshow(covariance, cmap='seismic',vmin=-0.008, vmax=0.008)\n",
     "plt.colorbar()"
    ]
   },
@@ -246,7 +248,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x14feb7574d68>"
+       "<matplotlib.colorbar.Colorbar at 0x14cf90b682e8>"
       ]
      },
      "execution_count": 6,
@@ -255,12 +257,14 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUMAAAD8CAYAAADt2MYTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvX2cZVV55/t9Th1OF0XZFE1hN9i2LTbIECREW2WSXGMUDSYMOHMZL3pNiC8fEq/GcZy8+HLHnJCQD8kkOjEmGmKImheJl5kkODJj8G0cR1FQCTTYQqdtsYGiKZqiUxTVxTln3T/WWvs8e52199mnzqmul16/z+d8aq+9nr3Ws9bZZ9V6nvW8iDGGhISEhOMdtdVmICEhIWEtIC2GCQkJCaTFMCEhIQFIi2FCQkICkBbDhISEBCAthgkJCQlAWgwTEhJWASJyvYgcEpE9BfUiIh8UkX0icqeIPF/VXSki97nPlaPiacUWQxG5WES+6wbzrpXqJyEhYV3iY8DFJfWvAs5yn6uADwOIyBbg14EXAy8Cfl1EThkFQyuyGIrIGPBH2AGdC7xWRM5dib4SEhLWH4wxXwYOl5BcBnzCWNwKTInI6cBPAbcYYw4bYx4DbqF8Ua2M+igaieBFwD5jzH4AEbkBO7h7YsQTIuZU4CAnA/D85+9iaQk2dZ6EE0+k07F0Nbd0P/EEnHRS93ldXlqyfxsN+/fJJ2F8HERseWEBTjzRlhcWunT1uqXdtKnbj352YcFeez48rQgcPWrvn3ACjI3B4mK3zve5aVO3LqT112DL9br9+HY8jh7Nt+v589d6LIuLtlyr9c7JU0/Z+75PAIwBERYWbHF83NKEY/H9jI1158DPiab14/RlzaufTz8nTz7Z5c/PiZ8DP3+eHz3OsTE7J40GCNaTqmOEWs0OR/MXfi8x/hqN3u/shBO6tHqu9TsVzlEZ9Pfir/386ffP96nfBf2eHD1q7xe9U/U61MfsnLTaQr0O3/zmN2eNMaf15zKOXSJmoSLtQ3A3sKhuXWeMuW6A7p4B/ECVD7p7RfeHxkothjGGX6wJROQq7PaXHTt28Ib77+c3eD0AX/vah5iZgR3z98A557CwaFenifEOHWrs2QPnn9fJ2rpzTy0r33/Q0m7fbuv27YOdO7s/rD174JxzbHnPni7d1BTs3Wtp/Uu/dy/s2tWl3bXL3h8f79LW63DgAFmfE+Md9h+osX17vs+dO2Fy0vLjacfHbdlfg21rasp+PO8eBw7kx+L589eedvOk5WHbNtvuzIy9f8Y2O3+PPAJPe5pa3OlAq0Wn3mCP0+Ds2tXlb+dOaNTt/N6z145tcjLf58R4h3v31TLa/Qfs9+DrNa96Pv1celrf57Zttg89tonxTta/H+f9B+04G9gVf6HVyL0nvn8/937+/Pfg+b1nby03t9/+tq3belrxWPyc3Luvxq5ddh47EWGrRvddvXdfLffd+zY1D74OYHoatkzZudVzcvCgfUf8d+1pfXlqCrZM2jk5PN9gy1QHGRv7fg9zA2AB+IWKtE1YNMbsHqa/Y42VWgz7wv2XuA5g9+7dpvm972X/9hq8nx2tg9zZOpfzgAns/6MOE9TocP7i7XR4UdbW+YvfyMo7Wvvd3Z0AnL24BzgHP9TzW3cA5wF1d73T0U9xbmsPsAuwq8S5iyHtOY52XNHWObvl3tzWdjps5szWva5d3ecuYJKzW3szWlrj9tnWdsC+5We29kFrCph2tLuycVranVB3/LX82OD81h5bB3TY4njYDoxzRuugu7+DGh22tmegNZn12aFGiwYNOo5XXLvj2fx1aLg+73Rjm1RzYL+bs1v3ALvo0HD94/it53jN5rO1S7XjaP0ctbYBU+p7OIcOE6p/6LDZfd/bWXL8TbBg35PWkp2TbP4m1XzWu9+D4/fc1p2uf/udvbh9B8guOjy9OxbXlh+Ln5OzW/dAaxedeiO38HnoBfLsxTvx79jZi3vcHECn7sfm6jL+ttFhi5vb7nuyo3UAmFbvm6f15WmW2ALAFg7TcdfDQDimJ64PAM9U5e3u3gPAS4P7XxpFhys1tqKBJCQkrFMI9l9Flc8IcBPwc+5U+ULgcWPMQ8BngVeKyCnu4OSV7t7QkJWIWiMideBe4OXYRfA24HXGmLtj9Lt37za3f+MbWbk5NsZ7jhoWF+22X6NDrUcc8WX9X1mX+9HG2i9rp+jZ2POrgSIeyu5D/3GV0YTztBJzUPW7GbT/Ub0P/eZX0w7Dw3L461BjbEy+OYzoul3E/FJF2ndBaV8i8knsDm8aeBh7QnwCgDHmIyIiwIewhyMLwBuMMbe7Z98IvMc1dY0x5s+XMZwerMjO0BjTAt6GXbG/A3yqaCGModlu89ubhJNPfij3ImVf9Pw8tfkj9kMHZmeptZYs7dwczM11F8yZGWqtJWp0LK0rd6hZxcviYlcDPTtLbVGpiB2tvtZlWq3sOWZnc+1kdZ5W15XRhnUaus+wHBlLVufmJMP8fL4djYMH7cfXx/r0ffi6GK0fZ8ir5lc/p5/VfYTt+jpfPzeX509fh3Pilae6zxh/rZZV0M7P94zFv0M5hOUyhGPpN3+adz0n4XsSljWtvh4StYqffjDGvNYYc7ox5gRjzHZjzJ8ZYz5ijPmIqzfGmLcaY55jjHmeXwhd3fXGmF3uM5KFEFZoZzgowp2hR3NsjGa73fvA/DwL9c2AO2VcXGCpPpEptKHkv2mrBfW6rW8tdTXmqk6XMz2Qu4bugUOOtqzfAtqhodtV10W7tEo7Q/9jDPjNaMI5U/UD7QwHmRP9nQ2yM6zYR9m70G9X5vsM+YnRadooD2t8Z/hMEfOOirS/3GdnuBaxagcoVdBst2mOjXGFK+8Exv/kT+i8+So+8p/tvXe+o8MCE0wsHoHJyZ6dJORfQK3k9otbhkg522Hq51w5huiJYgHt0NDtquuQh/BHEaLKuLK2Koy7qJ9C3vtB0cZUHv7a1+vvrApqdArfhbKxFC06y6Ht92zZfIZ1VRfp5WAju6yt6cUQugsiwBXAOXfcQW3uMH/6p/Z07J3vcJuZ+XmYnIy+dBq6XPUFidGVPbucF6+K3m6Qtpa9M4y0M+jOpmi3EmunbGdT1kesHV+O0ZWNvd9iUWVnqNuJLUaxOS7b0S13Tsp2hsPiGJ8mH3Os+cUwISFh7WCsP8m6xbpYDL3esDk2RnPnTmi1eNrTAiJnQRwTGaqcMhch9p++7Nlh/wuP4j/4UGJyH36qjDvWT1m5ah9hXV8xuc9YYu0MWqfbLZr3GA/9xOSqInSsn9icjAJCWgzXDLzI/Ktv+1U+8hF7r0ONzZMdOmzpEUHKfvhF5WEWzzJRsIw2xmsVsbLKD6aKKFaV5/WAKu/AWsR64XN9cLk8rLuxNdttfvck4QUvuJEXvOBGqy9cXKQ2fwQgM39ZWLQ/9tr8EZZata7eZnaWpZarm3kwa9fXaf0PMzPdH5S7zj4zD3avZw9Rmz2UtVWbPZT/Uc482DXv8bStVlYG8m058x3fTtaW4yHXrq8/eDC77lCjNne4awYUMa3J6kI405ocP0VjUf13qGW02bXiP8drrB1Xn41bmUNF6/wcuXFm35k7DQ/nRI9Ffw8Zv54/13btwP6s3drcYfvRPKj3JNeO7k9/d5F3I/x+o/x5HsI5Cd+TsKzmJGcuNgS8znAUpjVrEWvatKYM/lCl2W7Dvn3cuXg2551HtihSr9MZn7Avgvb6X1yE8XH7kugFoV6PmtbETFeysn7O9+nbLTPZCVHU73KeIzgxp/xwwNNAsEsu4iE0vdF9unHn5rZszoI2etot6SMcW2xnXfZsdBzhXC8u2ncoHIsyuwHy4+4z14VzUMRD2bvQ533NmYIBMjY2lLnLThHzHyvSvjmZ1iQkJGxUeHe8jYp1OzZ9qHLVA4bzZ74Ms+dw79zTAftP8txzOnTGJ2i1oOH/Y7tdIdD7nzb8767Leifgyvq5sJ1YObZz6FCjpuhz5X4Gw/36DVBp5xK2VXFspdcrTVuGqu1EjMxrPqzPIHNQkZ/wey9sp+xdqPpdjBDrVQSugnU/tma7zXXPEOQnvgtTU0xP21BGPtRRbXGB+Xll6zUzQ6ul3KoCd6icztDpnICc/smXM4TuZKEbnXM9y/pUtFpvmZW1e5ZGWdnHEfNw7ng1Or06w9CFzcGPuWds5Ocv51IX9qmvdVnRZv3odg4e7NaFLoAhP+47y8amaGuLC/nvSNPq+VL85fr09PvujboWZrQafdzxtAbR04b89LSr3pPonLjv1+u6e8qadnGxR42wHMgAn/WIdaszDNEcG6P5/e9zz/wOAP75n+HFL7Q/iqVWLeeqB2qXFOr71M6p6PQ1KytdERQb/OpnPPq1GwsHVdb2UquWxfSr6iUS8lVUX8RDET+FO+A+81I6J5G51feLxur1fcvRoxZ9D1X57tt+CW2ojyx7voiP8P6wOsMzRcw1FWlfl3SGqwdvdtP5j3Zxn56GF77QvhSNeq8ZS/bilLixhS9UT537ocR+DLGXPfZDLmvX0/n7ZYutHWNeYR6ibCwx/svmJORd91m0EJbNbZU+Y+MoGm/WZ3CIEFtQw3Fl5WAhLDuwKeOvaP6K6nLP1uPf6SDzF+N3OdjoHigbamzNdpvabwq13xTevvur9iWZn++a0tDJmc8wN2fFKi9azc3lI9y46DfhtaYFrCugM1fpULPX+uXVopyi9eVcn/PzXVMI107WluMh16669mYhnocMKnJLjY41RVJ9+lFpkTocd9iP5iebT9dndu3KZfOX69OXwzkJ+4yMMxNDnaiY6yPgN5u7oJyzLnARjPRYyr6H8J9B4a6vYP56ypH3JCf6hnWRdypDUYSiZWAjm9ZsmJ1hQkLCymKjnyZvGJ1hiObYGM0nnqAzPsHMjM3/AUTtr8pQppvpR79aKBLXy3R8UG0+Bu1zlOin04X+etsq7Q5S5/scJe0gPPR7Tvc5rM5wl4j5/Yq0r16HOsNl72hF5Jki8kURuUdE7haRf+fubxGRW1yC51tGldN0UDTbbZonndR7cFqvd0+TyZ/0+ZdHl0MxMqZv0uVYuzGEOqaw/6I6fa+oXPTD0bqkcIxleqYq/PXTGRa1UzSO5fSZ0/eV9BHjraiu6Pvu104R72G7VeakrM+y+Svib7nY6B4ow/DdAv6DMeZc4ELgrS438ruAzxtjzgI+78qrgma7zQdPFS6/XN0MTDi0ztCbtWSvpzN70XU5Mxyvl3GmDTradk4/FolgrJ/t0Y95naHTb2Z1ylwma1fz53SDnofMpMTplLIfYaCTyy0uyqTD95lb3Aqif3eoxc096JqRZK5uuqz6zMpOX6fH2TNfOrI5BTrDMDq5Hov/HnzZ9+G/44MHqc0f6fah9YLhnATl3HcWIvbdR96FjD/9Lmi3Ov2eKJ1rTx2MNNJ1Mq2p0pDI32NzFnwIeKkx5iGX9PlLxpjnlj27EmKyRi5i9vw8989tZsf2Tn93qNWOdF2Bv36RrvvyRiBOFUS6rtRnmVtaP94r9Kn7CMejx5Ddr9hn2G5PnwVjyfqs4I4XpQ3HUmZGU1BXhtz3yvBi8lki5oMVaX+6gpgsIhcDf4ANhvNRY8y1Qf0HgJ90xQng6caYKVfXBu5ydfcbYy6tyFohRqIPFZGdwI8AXwe2uixWADPA1oJncnmTVxI6QGzziSfYsW0JqPe+XOoFB/IeAgN4lfRgud4AFTxkwrqh0W9cg3jelNUN4i3h6mt0luXtUanPimPpUNFzJEDRd5arH2T+VgGjPEARkTHgj4BXYPOq3yYiNxlj7vE0xph/r+h/CbvGeDxpjLlgROwAIxDvRWQS+C/AO4wxR3SdsdvO6NbTGHOdMWa3MWb3aaedNiwbCQkJK4wR6wxfBOwzxuw3xiwBNwCXldC/FvjkMlmvhKEWQxE5AbsQ/pUx5r+62w878Rj391DR88cSzXY7O1SRTS5peSR7Wk8mPf8f/eDBaHY8rd/J6QVDd7Iwk1kRbZgRTUPrzhQPGX9O/9nT7jKy4+XGidLJrWJ2vFz/6yg7Xu6QRL83qk9dl+uzT3a8nH5Wl4PseCORGhjpYvgM4AeqfNDd64GIPAt4NvAFdXtcRG4XkVtF5NUDDaIAy971urymfwZ8xxjzflV1E3AlcK37+/dDcThiNNttGBujg6G2bVte/JieznsdTE11xUVXB2Tl7NmpKftXl3W7up9+tNPT8WtfDml9ORyLbtf36eEdt2PYti3Pn+MhmxPdZxk/YZ8hrebXj7NKu2Fd2E9RH7qf8DrW7vbtxX3Eni1B7qTe9dOhRq3K/JXNiWtb02ZlTTs+3l+VUxEDLKnTInK7Kl9njLlumd1eAdxojNGpMp9ljHlARM4EviAidxlj/mmZ7QPDqQB+DPhZ4C4RucPdew92EfyUiLwJ+D7wmmEYXAlYHaLwnqOGhot/2JncTM2Z3dTr7isfn7B11GB8Iv9C1fMRbTxdjXimtVBnpJ8NzWL6tZPRB9nxcmYgEf9k/Wx4+pmZZARZ4WqBnrITjCV3cKHcE4vaCWm1Di6rD/WfBX3mngkOUjrUCDMa6rH0uGGGPsiqnxitRs9YI4c6YbtFPGTlPu9U7rssmL/c2EewGA7ojjfb5wDlAeCZqrzd3YvhCuCt+oYx5gH3d7+IfAmrTxxqMVz23tkY8xVjjBhjzjfGXOA+NxtjHjXGvNwYc5Yx5iJjzOFhGFwp+ET1cvKJyMkn2pflwAHqdWUacWA/4MoH7883UGJa0xOV+OD9eXEnZiriRXNlQpGLpk3c9Cd71vfh3e40Dy5Ss/9R1OaP5MTJ3GJ88H7blhLlcuY33oRHzUE2bsdfNgcqindo5hL2EZraaNMaT5v1qdQBYaTrrP1gTkK1h46urXnXYnIWPV1FxdbfSzZnup3gn0zun1fw3mTfn5q/mGlNVqfNjQKzm5gZTjYn3q1wBBihac1twFki8mwRaWAXvJt6+hM5BzgF+Jq6d4qIbHLX09iN2T3hs4Ni9Y+oVhFeZLawO/B9+2DXLv8fHR55BE47rUZtcpKllr3fqHesqOlFES926nIoyvnYeKH4E9JOTvbS6nbKRGH/XNhuKBaPjxefTsbE+LBe81fET9hnTB0wiOqgyjh1GzFaPZZ+czs93X02NpaychlcPx1q1KrMX9m4Q/50eZDT+ooQ4ISRtATGmJaIvA34LNa05npjzN0icjVwuzHGL4xXADeYvA3gvwD+REQ62J/ptfoUerk4rhfDhISEwTBK7xJjzM3AzcG99wXlZuS5rwLPGyErQFoMcxGz39c2nH1gPx3OtJVTU93/hJOT+X+wk5NdsUj/x4best5Z9KPV5UhdThQLdgo5UUjXDWJD53itNLZl1nVQUaT7tVPSbpFtXjY/sR1x1T4LvrMe3mPPlmEE8zcw7Qh3huvV1a4KNvLYBkKz3ebqMUGe89XuzXqdLeNdl6eY65S/7jFl0YiZTBSZ1szN5c1wNCJuYLqPnGlNJGxYhgLTmlB/V8RDYUTvskjX6jpnVqJpi+YkpNXmKOFc+/v6uRi/ZaY/zh0vZ76j+ykbdz/oCOT95labyMTek9B0SpcD05pRYSP7Jh/3O0MNr0Os8Tp74+BB7mydy/nn2R3Skgue2iDQGYamDWX6sn76sVi7up2icpkuLbZzGFBnqM2NKvHXj/dhdIbhfGkUPdePvzIzF9VHzpSlqK0AuUOUfvM34HuSe9+K9NCD7FxLsNF3hmkxDKBd994yYzj/7i/Q4WXU6P7jbdQpFEOj7lqDiKx9XMYqu+MN4npWxOsy+Kvc50rRjqqd5X5n/aBNZlZgTvqqDoZEWgwTEhKOe2z04K4beaFfNrzr3oe3CfLyu+2OcH6e8XG1YZid7e7ECvRjORcsXRfqqjTKdHLaPTB81tVl9TGdkkeBzrBDrTc7XmwsRdn7+unkdD9hO8rtrycTXIHbXI1OVGeoXSgH4i90x4vMX+buVtRuBLkdu3brq6JzLXPbPMbZ8SzfG1dnuGEjXY8KzbExmkePwvw8C+NbAJgYD0Jd6RcvJjLFQlQVhMLKlWOhv/o9B8vKBAeBKKV50LyXlcNQW7Exa9oB56RTb/QN4eWRjUXPiQ6D1W9cYBeR8YnesSwjhFfhHBSNP7zX710Iy63eiO7DhvB6nkgWgKAfzl6Hka438q53JPA6xF99wjDxxc8A0HnVz1ADlmhQh94k8OEPIrZAVtEPRZ4L3eEyqJdfI+eiV+XH2o+HgnKPDmzQMferL5kTjR6PD0ffo0vrp+eFrhgwAp1hzHWu570pmJOyusLyIHrMAbBed31VsJHHNjI0221+9yRBLjmIXHIwJ55p16kMZWJyLFqKRlky+rJoKWGS+2VErYmKybGoNUX8rJSYPEAS+cz1LnyuCn9VxeSycUcQuuNBgZhckEQ+6yOJySuKJCYPAH/K/L62sSHhJzfblzoUkwvE10KReiXE5AFEt5yYHBtLyGvRWMrE5LJ2+81JOC7PdzBOjQ0pJof8HWMx+XwR85mKtDuSmJyQkLCRsV7zm1RBWgwHQNd1T2zC+j13wnnnZfWZPi/cJUR0OYVhsSLtAKVtRcsFOqPY7iWnZ1umfVtfneGgvBbV92m3SGc4EO8e61BnmH2/K6AzFGxEhY2K9Sreryr8oYr8sAufFma805nUoFJ2vAxhndYD9tEZ5lzPdHY8p/PKfiiBzjC3eFTRGQ5pWqPnJGtTl2PueMFzZaY1sTnp0dEV6Qw9DhyIuuONxLSmzB0v5G9AnWGUNukMK2FonaFL7HI78IAx5hIReTY2n8GpwDeBn3U5DgqxXnSGIXxwB794ZTqaxYW8B8PiYrcc01VF9EQ9Oq4YbYH+MNPZDaMzrKJb0wtqqKesojOsok+M9VkwTj+GbMxV+izjt9VaMZ1hpe/X3cvpSot0y5H5G7XO8AIRc0tF2qevQ53hKBbxfwd8R5V/B/iAMWYX8BjwphH0sSbhgzvwsY/Bxz5G7aUvofbqS/njj03wutfnRbWllttZ1evZD8eX/bUWVbWYrO+HIqAuh7TQa1qjkQX/1D/gCH+xsqbV/IbtZP0qWs1fWNfTR8CTvt9XHIy1G/YZ4TcrazF5EBVAgNz3WzBf4dh62g55cPcqzR+93/1ysZF3hkPxLSLbgZ8BPurKArwMuNGRfBwYSbKWtYpmu03zF36B5i/8Apvv+DJcfjkXXghXXKGI5ua672Ys4bcWk3XEkVAEDMVvHcUmjKoTRqmJRK2JRmL2YrwXzytGremJIKNEy8oRWspEwvA5LyLqcUGveB2qDjw/sUg0oYhdNWpN+D2VoWrUn1gkGs1fv6g1gZg8Cnh3vCqf9YhhF/H/DPwqZL/QU4E5Y4z/Jg5SnPHqKpfd6vZHHnlkSDYSEhJWGiNOFbrmsOxFXEQuAQ4ZY74pIi8d9HmXKes6sDrD5fKxFuBPmRkTmP19pqbg2mvh0kscwfg4rZZKFwBdUUmHYoKeoKK5nWAY3DWgzXmg9Av+WSTaFYS4rxTCSz/bL1S+Hne/7G6ah0jmtxzC57S6oB9/+lmfJbDqWEqQ+w7DsP9F7YZtxtJD1HtDeEVDyK1Odrx1h2F2tD8GXCoiPw2MA5uBPwCmRKTudofbKc54teHgT5kPH3gnn/50935ncjONxQU69QkIMqnFMt5lJjcuO5+nL418HcTcK3Tbc+WYsr9DN4qz5kcjl+UuPLjQYyvJjgdQc7z7dnSfPbS6XJDVTo8l61P10TOWggx3YZ96LOHYwmd7VA4xROYoxkM4J0X8xcZCcHAyKn2hbXPjYtljM8a82xiz3RizE5u05QvGmP8b+CJwuSNbc3mTVxrNdpstfyhcc406oJg9lP13DrPG5a7pUJs7nOl7anOH8z/0Mp2hy4iWZVPTGfBCneHiYl5P6aBdCzU/uT69btLRar2jp82u5w7n2u0eI3QyE6Jcn76s+tC0QDfrn88o51O9OmqvS8z1obME6nGpsYUZDX3kcD2WcJzZvOm63HFJfpHOaP1Ygu83Vw50y/65rH5+Pl8XtqszBvro50Ni1GKyiFwsIt8VkX0i8q5I/c+LyCMicof7vFnVXSki97nPlUMOzbY5Cnc8Jyb/sjOtORNrWrMF+DbwemPM0bLn16tpTRmaY2Nd8Xl+noef3MzW0zp50wo6XdMJ/6Pp425XhbbIxKPsPhSY1oSImX/Qa+ZSycSkqmFw6OYXGWehaU2ZKZIbZ9iuru/JpxzwAwOa1jgU9lk0t8sQc3PfK8Ob1rxAxNxakbbRx7TGmeTdC7wCe7ZwG/BaneVORH4e2G2MeVvw7BasOd9uwGBN+F5gjHlsgOH0YCQHP8aYLwFfctf7gReNot31DB0xu3n0KFtn7oXTdvWYU8RExAz9FovgBxi+/GUoFJMLFtQofxF+qkD3Uwla7xea1vR5Ljcng5jHFPAX5b3CWKLfTcG7MAyWu3BWwYiDu74I2OfWC0TkBuAyquU//ingFp+TXURuAS4GPjkMQxtZBZCQkDBiiEilDzDtrUXc56qgqWcAP1DlIsuT/1NE7hSRG0XkmQM+OxDSYriC8BGzm5s2Ic992N702eciurNMf1Y1O56OfK2y43UIXNoiIbwKdYbOHS+rLwsxFss+F9oO6ud0P7EQXrqsbeNC1z1tZxja1AW2gjnby34Rx/1YWi6El9ezVnEtLEHuAMP1k5uDcD51n/pd0HPiytl3Hc59kB1vJIcoInnj+bIPzBpjdqvPdcvo8dPATmPM+cAtWLvlFcN6tY9cV/BZ96CdnfoutWrW1KZeZ4mGzbgHNv/x+AT+hDgnXulczdBjiqFPn3OmIrH8wUUi2fS0/RuYzxSa1hSYslTK7BfS+nIsq11Rn6HJib6OZbyrwg9Y05rIWGp08u2E7UaQO2XWPPUbZxl/rhyaJkWfHVF2vFwf/fDUU/0oHgCeqco9lifGmEdV8aPA76pnXxo8+6VqjBUj7QyPEbwOcf/sZvbPbqax755sZ3PwYN6VLtvcRBKbx+wOAZiayp9e9nM9K4JK9NKhlvWR8RfYL2YnljGdnOZB0eqxZW3q+pC/AZPIx2h9u11zlGBOYmZL3mSlgjte2c6c8aNrAAAgAElEQVQrb95T0o6ek/wuq1CnWfj9jkD/2IPBdob9cBtwlog8W0QaWIuUm/LdyemqeCldt9/PAq8UkVNE5BTgle7eUEiL4TFEs93mE88RPvEcQX5on5XCtm3jzOkjXWlpcZEGXVe9HMJy4I7H4mJXPCpzx1tczIuTQZuh+1tozqPFMW1a088dL7dYR0TqXOL6SISW3PVy3PHC+erjjpeZpFRIIl/50KKCO542rSl0UVwFdzxq3X9cfT994OyQ34ZdxL4DfMoYc7eIXC0ilzqyt4vI3SLyj8DbgZ93zx4GfhO7oN4GXO0PU4ZBEpMTEhKqwe8MRwRjzM3AzcG996nrdwPvLnj2euD6kTFDWgyPObque2Nsrj8Be/fyD7PP55UXuZ2F1ueFblStFguLNZudD/K6wFaLBazOcNy3Q4HnSoEo06FGzbWZib4FbnTAsXPHC2nLxNsCHVzPWPq542l9nqLt0MeNLoKcznBQd7w+ulKvS/a0WblsjobBSojfawQbd2RrHF6H+M7HDa+c/zIdXgJAbWaG++tnsmN7J6cT9Ir73Gut3fHCugLdVMyeLWeorBdR92zu0Eb/sEJdWUW9Ws8C3c/eTunSBrLxC3SGA0fijujronrKEdhM9rRT0Q4yHNeo7BWjGPHOcK0h6QxXEc12m/efLMhP7OORR+CRR4DJSXZs64bhyqn7Qv3Y7GxXNaRcz3poVSM1OuU6pDBTXZjpT5V7XOwKdIb6uVi70eyCZSG8HLxbWg5FEbI9T77PfnpA/ayavx7dqGtX/1PIHRQRHKCEYbo0yuYkFsJLX4flInOjYTDaA5Q1h/XJ9QaCN7vZeqJz516E+2cabN9u/1Ntrnu/0nFotVz0G3drctIdttgXsF/UmvCk2SP3Y1VmIl60zLmNTU1ZO7l6PbsG57ZWICbn2vH9h+1Ab9mjrM8yMXl6uuvnXa9nPOVEy6CP7Plt21yE8oneE+yCqDBFHkC5susnnC8txudE+lYL6o1CfvW4espFPCwXG3xnuHFHto6Qc937/vfZ8bnr4fLL6UxuZt8+S3P2LvsDyX1hWkx2pjWQj5pcJkaF/rxAZfFsqLpl0g4sJpeJj8sUk6PlCjq5Su6Wg/Cn7/UTk0e1gImMVv+4xpAWw4SEhGrY4DvDpDNcI8hc9571LORN1ta01eo1EcyJO3NzXfWfz3jn9UOuItOrzc93d3+qricYg9JVef1Yzug60APmjK41oxGdYa6dAv1YVCfnns3a1XMR0RnmbBk11Fh0xsCwXSDLEBjOn56TsF09j4U6wzD1gKYp02kW2JxWovU2mcMi6QwTjiUy173xozRmH2TXrjO6lfv2cXj6bLZMdXV/E3WnM5yfpzO5Od+Y14HFdIZByK+sPtQ/jY/ndYbj4zndlM4MmBPPInq2nM5wcrJY5+X60KYtGQ++LtanaztbnCcnuwu/MwbOtYNSEYR9Tk9nc+r70CfqOdXCIDpD10+m78xCiTV65hbI6y2DOSnVGfrnYjwsFxt8Z7hxR7aO4XWIr7nbgPsnf+45wPQ0Tz2lFi/tuxwefERMV7TbXCzUU4feSNdhtOhchOowkrTWYQ7YznL6jJoCEY907WmL+OtJqTDAWAjKOd7pRMei+Ym1k+l1/aFYyF+93kuryrnDtNAEarnY4IvhUDMkIlMutM5eEfmOiPxLEdkiIre4CLS3ON/BhAHRbLf51A8Jl1wCl1xiAzvQatkAsR7axW1uLh+1RptXLCfSdRDNOtenrtPmPI5Wi2656DxKUC6NdB2J5JPrQ0W61iYvHWqFka41f/66J1J4a6mranDueOFYetqJlHPjDFEwlp659X16l0D9HPRkWOzJuKijW4/KHQ82tJg8VKRrEfk48L+MMR91ztYTwHuAw8aYa10o71OMMb9W1s5GjHQ9KugAsezbx037zuUSl2hKnx737EAKxCK9uwhPk4cRpcJ2RyKWDdgnLG8sZfT96nyf/WgHaXcY2jL+ho10vXtqytz+kpdUopVPf3rdJZFf9hIuIicDL6HrPL0ELInIZZCF1/k4NrRO6WKYkJCwDpDE5EI8G3gE+HMR+baIfFRETgK2GmMecjQzwNbYwylvcjXoALHs3Mml5+3vimDz8xyZd1/hzEx2qNizi1BRXsJdjN5RejEzPH3MnQKT14n1Q4x2Ofqr2DNFu6XsvhvHSPRlJXxUeaYfH8vlMXyuqJ10mtwfw8xQHXg+8GFjzI8ATwC5DFfGyuBROdwYc52PgnvaaacNwcbxgWa7TfOkk5Dn/C+OzNfsIri42D0wrdfZUj/ClrrNFhdzx8sWvsXFHh1XhlA/VhY2TJnL9NBG9GxhO7nriMtd1raL6K1NcnJj0wjc+HK6uzIXtrDdgweLI4VHTHYqo8C1MFoXC12m+yzib6VCeG3wxXAYrg8CB40xX3flG7GL4cMicrox5iEXnPHQsEwmWHizm838a3tjfJxHHoGtT1uAep0jWNOaSci7qTnXrvB01COnW4pEl4m543mXuh5zGfVcDsqNLudWV693XQB12ZuJgHWN825pZS6A5HMYZ8/FaGOucNp0Zft2u4gErnBFc1SGmDte6HbY066akxqdnGthrh39XMRlERhpEvn1utBVwbJHZoyZEZEfiMhzjTHfBV6OzWx1DzZf8rUch3mTVxrade+qBwxnzN5J57Tzqc3MMMsWADZPRiKiBCg0rSkww/HQydWL6oBCc55oO77/IPF97lDE16lxxX7gPYdKenEMePd0Rfxki0gBbYagXGpaE5jEVJkTzX8OIX1kfDGelg0f3HWDYthl/peAv3InyfuBN2BF70+JyJuA7wOvGbKPhISEtYB0gFIMY8wdTu93vjHm1caYx4wxjxpjXm6MOcsYc9EownEn5OEPVa57hiA//M9WIpqa4szJQ5w5eYjMNs4jpjOM2BkC3ex9Mds8Xw7qovZ3oR2fzgjoyzprXdCnFwFrdLK6TGcYZsfT0AdF7rlKdoa+f2VnmGWVWwE7w9D2Mja3zM7m7AwLdYahftGngPBIOsNKWJ9cJwBdHWKDo7B3LzfN/ihgjbRzeiwdHNWLUJEXNtNNoUTWqam8KFY1A14kg1xONxlmiYN8u5o/TRvLEqdR9FxIGz4X0pZlxxtBpOvoc/0yBhb1WVYHazbStYhcDPwBMAZ81BhzbVD/TuDNQAtrufJGY8z3XV0buMuR3m+MuZQhkRbDdQ6vQ2w+/jiXztzr7u7KE2n/V4eYgXaHGrWQtl7P/ZhrBIuqRtkPxbWT9VP2XEE7VXSGpdDt9uuzgAetV+1HW8ZD33Yqtll1DkZygDJCMVlExoA/Al6BPYy9TURuMsbco8i+Dew2xiyIyFuwqUL/L1f3pDHmgpEw45Ci1mwANNttmiefjDz3APLcA/bm4qJ14YOumOxFTSWC+oWuQ81KU0qkBmBujqVWrRsQJ0imvtSqdfsJo8Do8sxM11QG8pFonJicK5M3rdF95hCKyc5sqOe5sM8If0BXTHaBJLVrXJT3SDm0KczRhonsNcJxltH2ixSusTpJ5PvhRcA+Y8x+57BxA3CZJjDGfNEY4/0Kb8XmR14xpJ3hBkE3UT10MNSgGwXbi77+BzE+3l3AMjqYoNUVqXxklXqdRmuhe39qyuqxxsdhasrWAdRtIqtaa8megIYBFPxzrv+wHaBbnp62i5o2rVlcpDM+YZMoOR1YZ3yi17TGRWqptZa60ao9rY5a49rOyr5dP86dO+0COLUlM1PKxuLMjXQQBV0Od2E9YvLiom3TRZ6BEnOj+Xk7xiwSjePPz5Gav1x5fh58FCO1Kx8Kg50mT4vI7ap8nTHmOlV+BvADVT4IvLikvTcB/12Vx137LeBaY8zfVWWsCGkxTEhIqI7qYvLsqHyTReT1wG7gJ9TtZxljHhCRM4EviMhdxph/GqaftBhuIPg0pM0xofnxj8MPfsCRX3pvlkfl4OwEmzbBiSfWmJ/v/pPf0nKi5vR0tmNsYE88O5Ob8zub8YluWcXLA7KdSI1OtkPLUFYO6+qNnH7T3wvb7bEjpNe+EFWfi/eorqP81hswtaV0LFmfetx9xNFO2bh12fM/2YjT6nvBWK2heNdmsxPO5XIxWtOaB4BnqvJ2dy/oUi4C3gv8hDHmqL9vjHnA/d0vIl8CfgQYajFMOsMNiGa7TfPKK+H00+2C95WvwFe+wvw8PPAAPPkkfO5zcOCA/bBnD+zdS4cajfnDNOYPd7PpzR7KmXTU5g53dY6zh3KmIbW5w9mCUJs7nJWjtLOHumG6Zg/l6mtzh3MhvHxd1q4yl6nNH8npPb1eNHtO02p+FH+5dn39zIPdtuaPZP2E48yepRstJ/xo9PAQmb8cf5p3zV9YF6HN+NPhvIbBaHWGtwFniciznZ3yFcBN+e7kR4A/AS41xhxS908RkU3uehr4Mayzx1BIO8MNCn/K/KtXvJHGU08B9hxgft6+q3v3WpUaAI88BCecYK+9/skfTBQkL/d1uZ1QmTueCkTb065yFwQXtFbtZmravCdMkB72o06/dTv+2Vw7AX+hGU5mXuRoM/7DsYTlMuiAvDEegutsHiLjztWV0Y7KtGaEO0NjTEtE3gZ8Fmtac70x5m4RuRq43RhzE/CfsN6l/5+IQNeE5l8AfyIiHeyG7trgFHpZSIvhBoZdEIXm854HwI/OvAGuvZY/3vdGvv1t+MVfdIRTZ8F99wGwsGh/qBPap1ftbnQ5FL90OayLpfSsbKITmJzk3PTUdQ9CH+wS/noOP4IE9GW0utx3UVRj6RFf673Rq2N1PfV93PRGcpIMI8+OZ4y5Gbg5uPc+dX1RwXNfBZ43MkYckpi8wdFst2nedRfNu+7iut86BBdcwOws/Kt/pYgmJ+G001hcVDmlfO6QwFOlNn8keg32NDgT+VzUbXCLRhhdRpvvhEnudR3kvT9cXa4fJbKGXho5Ws274s/XFXmVeNqwnUwMVeWYJ0rRuH2f0bGFJk6qrmeOCmi16mAkSB4oCQkJCWx43+SNO7KEDPqU+av/27B3L3zyk/uYmbGeKlff/svQajFx4YU8/KQ9Gd08O0tn+w4rjnn7NezJqbcH9CfNGXTGuciJa07c1qfU4Wmsq8ue9ae6qg6c+BecsmqRdWlyCw1Nq/oMbQd7Ts2nn94tq7HETth1Odwd9pTV2PSchGV9Qh091Q/aidHqOYmqEQZFWgwTNgq8DvEjwF9fcAH3/OYdAAh/DVzOE/UT2HqiFfnunXw+Z7sf0AITeE1RjU5WLtORhfqqkFafvnpUpS3VE6q2GvVenWK/PksXsj789aurSpv7R9CHv3Bs/WiHwgZfDJPO8DhDs93m/UDrjjuYB6ym7jHgDv75n8lczzIV3+JiTg0X6vZ03vqejGxhInt628mu++gMNW1Oz+Y9TIjrDHPQEb4Vf7pd/Wy2WDnaUCcXbVchulgX6AFjdTHaonZyZeWS2DMnw2CD6wzTYngcotlu81vAme5jAzt8l1NOIVsM77uvu5vI/ZaCU0z/7vtT4ewH6Sr06WzuACCoy0VjViJsDWva0hVZg1PespNU91yOJz2OkAcN5SqXc9+j00sb8BAenBSpEnQ7Pe26Ocl4CPv0Cef9c7pcr+e/tFG54/nT5CqfdYihlnAR+ffYEDsGG07nDcDpWKfrU4FvAj/rHLET1hB0xGybseEF9vKccwB46dbuDzT3ao+PU2/lE85DNwpLaC6jTUVyImEsYXoRbT0eXVv3o5GJiRHaIv5Cc5SiCDK+3Rzq8UjXofiq2wrb6Wm3orlR33YCnoZCEpPjEJFnAG/Hhtg5D2s4eQXwO8AHjDG7sPLXm0bBaEJCwipjg4vJw3JdB04UkaewCeQfAl4GvM7VfxxoAh8esp+EFYA/ZWZsjAv5Uxqtn+VIy56cbn30HjqnnQvAROsI1hHAHUy0FqBud3a5hFDEDwX8c0WHE1UOOcKDB/2cRtEhQtmhRawPX1f1kKPoWveh60P+dLkfD0V1sXJsPpeNtDOMwzlK/x5wP3YRfBwrFs8ZY7zC4iA2VE/CGkaz3eZWgHq9q/JxIaSiuveI7g2qnfKGKBLfwvuhGBrWh3q6zOwloC0TF8v6HIY29mxV/laKh2VjA+8MhxGTT8EGY3w2cAZwEnDxAM+nJPJrCD5RfWPuEI25Q/Cnf0qNDg2WePjJzdmPttZaYoniuH2Q3/2EdWE5d6ii6orKIb3eDYU7rSLasj5Dej2Wsj7DnV5sHFXHUpX3QedkaGxwMXmYfyUXAd8zxjxijHkK+K/Y6BFTIuJnIxqWB1IS+bWIZrtNc+tWmlu3Iv/vK7Nt4YknKje9IBqz/mn2JFoPolnnaA8ezLUTi2Yd0tbo2DrHTI1OeaTrAwey2zU6hYnrO9R6Il3X9t0bTdKeo9VtlSA37oKo3dE6N9asTm/TXQKoDrVcQqisHCSRH8mu0Qd33aCnycPM0P3AhSIyITakhM+b/EXgckeT8iYnJGwUbPCd4bK5NsZ8XURuBL6FDb39beA64DPADSLyW+7en42C0YRjA32o0qkbagfv58lNO9g87g5Ktm3LDlCYns4foHi7uHqjG8rfi2gh7bZtvSHufdnVZSYi27d30xCoTHAdasVh/+nY0P06+o4Lq59dO9ToWB58/wC7dllj63ojF1oro9WokB0vg+unpscd48HHV/PpDyLZBrPdsZq/XDse2oZzWKzTha4KhhqZMebXgV8Pbu/HJntJWMfwrnvvfNywlSN06sp/2Pu6RmwHM0Rs33K0EZu63Ilv6E/rDYf72N/1nLxqY+nIteYvRBaVuqLNXxmysQ1oH4izx4zWRWwjs/JKLFrpNDnheEWz3eb9Jwty8ve7Cnqnv/N6rJzyvkAnB/TSKr1gNHG9DjulaVUS+ajOUO+IlF4ye1Zfh/zqZw8c6LoXKp1hRqtRQWcY9tMzX2E7YWL4siTynj9dXgmdYRKTE45n+Kx7HQwAtelpFhdhYryjQmW7nU1BYvMaedqs3ouLvq5IzNNicygmByJqLmCqE6+BbvY5z08sMbzeqe08s7sYhhGpl5FEPhx3yHvIU1T0Dfv0df45XV4JMXmw7HjrDmlnmNAXzXabq8eEq8eEI60JJu74arbTyNnJaTHUQdPlUK9nC1fWhhaXg92Fph0EnXrDfqjl+3P3Y+1nffgffrDb0WHCvEhfmR89zrJI4bE5KWqnYP5ipj1DYwPvDNNimJCQUA0jFpNF5GIR+a6I7BORd0XqN4nI37j6r4vITlX3bnf/uyLyU6MYXloMEyqh2W53dYg/NhXXeWlbvEDPVpvNkpvl9I2AzUQ382CeVot5jrZDrVtXoDPM6RoPHsyy49XoZDz4a1/uULP9t1pd+gP7uyG+AjtD/ZwuF0HbGXr+NT9hu34OPG1u3L7eZSn0dTnaucOZnrBDbU3qDEVkDPgj4FXAucBrReTcgOxNwGMuzsEHsHEPcHRXAD+EdfT4Y9feUFif+9mEVYPWIdbohiWcnKQbRsqb2aBEZh2lJtSPKZ0XSrfXU591ZBEzrcn9EKenc6JjrSx7n+8jMOcJaWt04pn1SpA74S4YS0+7ZfpE9WxU/1mQMXBojPY0+UXAPmPMftu03ID1aNNZ7i7DxjYAG1rpQ86m+TLgBpdH+Xsiss+197VhGEo7w4SB4XWITE2xee832Lz3G/YHPz7Bg7NWP6c9EfxCkIun6hbHTNfldIi+nNOnhXH+9O6j7McZiwGor2PtKuRMa3RdWbv94MdK/jAiLOtdlp6jaDtVaEeBwXaG097d1n2uClp7BvADVT5IbxyDjMbFO3gcGxqwyrMDIy2GCcuC92WWFy8gL3ZZ8OaPcMY2ZWbjxOjFRWB+Pr/+aHc8R5vtXrSZjaPVbn2VTWuUO17WDwWmNaG724EDXR5GbVpDxD3Q86Dpykxrwroy2hGJycbAUqtW6QPMendb97luaAZWGElMTlg2vMgMQOsoncnN3HorXHghXZG01WKiDkxOZrvC8fEatW3buoufNiPR3ike27bZhSlmWlMmJlc0rcnx4FHggQIMZ1rTzwsm5MfPQ4zfY+yBYszoMghgYxY8U5VjcQw8zUEX7+Bk4NGKzw6MtDNMSEioBL8YVvlUwG3AWSLybBFpYA9EbgpobsLGNwAb7+ALxhjj7l/hTpufDZwFfGPY8aWdYcJQ6KYhHaP5xBP86Ozn6HApC1h92403wOWXw8RknQlnxNxhIu/Kp+z2Qrc1W991M9O6RO22F4bOirkAovWQkXZ6MD4Rr6vnQ5h1IvyHCGnD6x7+1L1C/iLPZzwod8aRnCQz2p2hMaYlIm8DPouNkn+9MeZuEbkauN0YcxM2rsFfuAOSw9gFE0f3KexhSwt4qzGmPSxPaTFMGAl8TpXX3G3Y1YKJxcMA7Ny5xUque/eysNNFzsa649W854nXlU1P20VwdjbvEeJoMxMTJzJ26g1rRjI52V2QWktdv+aZmW5gB9+uL3t93fR0T7sZT9PTdMYnbB/QrXftZAv37KFuOxFxVBtyZ/3ocfqx6DqvoxwftzzoOrD1btwZf7rsngOoLS50D4OGxAjFZIwxNwM3B/fep64XgX9b8Ow1wDWj4yYthgkjhA/u0Dx6lMNsAeBDH4ILLoDG1FT+UFMvJmrBytzUQhMZj7Au1KWVmdbEzHmK2t22rVvupyOsoDPMmdYUjVOX++k0y/SfYXlt6gzXHNJimDBS+B1i8+tfB+BTO2+EmTfD9u38t/9maf7Nq8l2b9pNLiZKAjlxsEdM1raLBLlMStzd+orJZaLvMsTkkIdYn0VufVXazbUTmZNRoNPJp5reaEiLYcLIodOQXvWA4Yz6Idi3j3r9fEB5fGixGGBqypadCKjFZIrE5PkjVjz0C0AgJqPF5Lm57q7Ji6FTU/l2dZ9TUz1ickard7Zzh7t1BWKyh+7Ht5PNiSr3iMlOHbCaYnLaGSYkJCQ4HNeLoYhcD1wCHHL5kRGRLcDfADuBA8BrjDGPOVeZPwB+GlgAft4Y862VYT1hLaN7yiw0v/lNmJzkc5+zdZde0sn0eR1qvdGrI/qybHcVhgYrcz2bns6L1X5HWdBHDjrkWJk9YFDfFzFbwlh5ED1lBZ3hKLDRd4ZVlAkfozfr3buAzxtjzgI+78pgna7Pcp+rSPmSj3s0222aL3gBC9vP5vd+D37v97ohprIFzhmnaXEybxITD0dVpAvTIcVyAWUdqh4mjErX1k90HoSnKm0PQ1eGEdsZrjn0/baNMV/G2vhoXIZNEI/7+2p1/xPG4lZsprzTR8VswvpEs93md08SNm36Fps2fQsfMTv74cTc8fSP17njZVGxtTuejxThUeCO1zfSdeiOt2/fyrjjOTOi0B0vG1vIXx93vEq0I3LH8wcoVT7rEcvVGW41xjzkrmeAre66yIH6IQI4x+2rAHbs2LFMNhLWC7TrXgeTRczePNnpFX11siiA7duL3fFCEVCbqqiEUIO643V2nW0jXZe442UL9iDueG5sZe54oYtdxp9e4FYpIdR63fVVwdD/Lpx7jFnGcylvckLCOsJxLyYX4GEv/rq/PirlijhQJ2wM+ACxV48JjI+zec9XbYUL+7Sw2PXUyNncuZ2Ups0OSiLhqXJpB1TY/1gIrIw+FpQ0Eva/LNx+ZRSFH1Nl3XY2nqC+7PmVCPufFsM4tAO1ThR/E/BzYnEh8LgSpxMSgK4dovzYqfaGy443Pk7Xja61lNMTZobHSmcIREN4ZfqxINJ1Ufa+nnZbrXyk65h+USMsB9CRrn0/mR2kPjxSessserXX9wU6zVyd0hlm5RWIdL3RF8MqpjWfBF6KDdZ4EJsn+VrgUyLyJuD7wGsc+c1Ys5p9WNOaN6wAzwkbAGHEbLDnHTt3dt3UtE4uGikayk1rpqaipjXR5yq640VNa8JygJwHiXIR1NdZu2XueBE3xGik6+SOtyz0XQyNMa8tqHp5hNYAbx2WqYTjA96X+S0zVuV8JvvpcCZgg4j6335Nh7hX6QOAePJ375I3uTm/CAwSrVr3UyaOxsoRhKKuj6pT2I66jqoDCmij7Y4Ixqzfk+IqSPEME1YVzXabD28TPrxNkOfM2Z3H3ByNurIPdCYyXgTMib4lpjW1A/uz69U2rclE1oJI19q0JmszFH1X2bTmuBeTExISEiCJyQkJKw7vusfYGI16GyYnOTJfy9R6telpWi1o1PP6sCJRMxNJXXAHULo0n1qgnzuet1E81mH/vX3lIGH/++kMR5Qdb6MvhklMTlgz8KfMD85vZvP/+ky3ol7nsce6195cBoj63WZiqYtUrfV1PSY6qo+wXJgdr0B/V2nB0W3F2ila3CN14VhyJkTatGZEOsSNLianxTBhTaHZbnPdMwS5ZFf3xzw3x9OepnSG2t841Oh70xQ6WWJ4rVvLTnZjesDAlW9QnWGZr3QlnWHM9KdIZzg3l5kfef5y/LrnRmlaAxt7MUxicsKagze7WWrZU+bGgQN8Zf4MXnmRi1Ljf231evfXFwRr9fVL2PsNOvnE6+GOMhSFddSaIL9xT0a+Cknkc7ReTC5rp58JkR5LvyT3IxKTj1Vw16KoWAHNBdhAMJuBNnCNMeZvXN3HgJ/A5lkGGz3rjn79pp1hwppEs93mtzcJv71J4JxzeGX9C7ZifLxXTI6IhB1sUna/Vvpyhn5J5HU5RqsxSIissN2idvIJ2Xv5C8XtWFnTjgDHUEwuioqlsQD8nDHmh7BRtf6ziOj/IL9ijLnAffouhJB2hgkJCRVxDA9QLsM6eoCNivUl4NfyvJh71fWDInIIOA0IXJKqI+0ME9YsvC9z89RTkZe7w4y5ufzuQ+nGvH7M3Ya5OSbGO0yMd3WPGUI9oLfx840fONCVCUdpZxjaEmoU2Blm5Qp2hlH94uroDKdF5Hb1uWqAboqiYkUhIi8CGsA/qdvXiMidIvIBEds3LfoAABjWSURBVNlUpdO0M0xY88i57tXreamv1eqG94Lsb4MlmJpiYdEuAuPj2HBfXl+nRFJtdpO1o93xQp1cP31egB53vIh5T49pTT9zmUFMa1bHHW/WGLO7qFJEPgdsi1S9N9+nMSJSGBXLBYr5C+BKY4wf5Luxi2gDuA67q7y6H8NpMUxYF/Cue29/1LBln5OQdu1iaXxzNy6iR7bgAfrHqw9CfLIkt0h4MxxNG4ugo7Pa6WezOrpJocIsdUA+wndJFsCa0n3G+tR8aVpfDvlYawcoxpiLiupE5GEROd0Y81AQFSuk2wx8BnivCybt2/a7yqMi8ufAL1fhKYnJCesGzXabD54qnHnx2Zx58dkANBaPsHmy0xVD/UJIB/bsyTegxMcsKgwqW19oWrO4YGnnDtuPW1Bqs4eyhc9ntQsXQiATjnMiqncnpJM9l7U782A+ws7srM1s5/vwpjOQN6XxtKrsn+tQy66HxTE8QCmKipVBRBrA32Ij698Y1PnwgoKNwr8nfD6GtDNMWFewIrPYwuITMD7O/gM1ztxmFy4OHKA2NUVn2xnU5ub4u7+zt6+4AiUKN7qipC/HEkJFxORoMqlBPVB0EnmNsqg1YVQdlzY0JxaHZY8RmdbAMTtAiUbFEpHdwC8aY97s7r0EOFVEft49501o/kpETgMEuAP4xSqdpsUwISGhEo7VabIx5lHiUbFuB97srv8S+MuC51+2nH7TYpiw7tBNQzpG8y//kjOPHuXBi98IwL7Zc/nap+Etb4HNu3fzavWGd+qNrn4t1Ps50TrTuzmdodbX6XbCZ305Jo7G9HzhdVgO9YAhbU3pHvvqDEPd5DJx3Psmi8j1InJIRPaoe/9JRPa6o+u/1caOIvJuEdknIt8VkZ9aKcYTEprtNs3Xvx5uuCGzi37uc+GEE9yP9i/+gj/8Q/jDP7T0tfkjmYlMbf6ILbsTgdrc4ex0tkYni5LdoZbRZro9pz/MdHKuzi9A4Qe65jU53aO7jpYDF7va3OGurhEbuizTEc7P27JfdF1d1qfWNQ6B5Jscz5t8C3CeMeZ84F7sUTYici5wBeCtwv9YRMZGxm1CQoBmu03zlluYnLRqtH/6J7jvPlf5zGdy4olw4omu7PRs2bUuhzo5nYDe03oUmNaEernooUVZO2Ek7jL++nnIrJAHynGdKtQY82UR2Rnc+wdVvBW43F1fBtxgjDkKfE9E9gEvAr42Em4TEiLwZjcAzW3b+NEnnoBLPsnDL76UKWUrbXdu3WuwuwG9q8sWsMBcRiM0mdHl8ERZ7xYhEJNVuz39hOY84cJaQdwetWnNRheTR/Ev441Yp2qwOZJvVXU+b3IPUt7khIT1hbQYlkBE3os1a/2rQZ81xlyHtQ5n9+7dA+ddTkjQ0Icqbwe2AFsfv5dm09ojXnGFCw47Nwc6N8r8PJ2pLV3dnBcpFxcz0bNnB+g8XsKypvUoe1Y/F5b9quNjFObqfL1uB7UjDPkrONgZFGkxLICz7bkEeLlLBAUpb3LCKsMHiG2eeCJMTXHhhfZ+vZ4Pv6VPjf2JccwDJSom9zlNjonJ4bPhdVgOI3iXnSbHAsLGPGGGRVoMIxCRi4FfBX7CGLOgqm4C/lpE3g+cAZwFfGNoLhMSBkC2ID7xBH/9ocPurj2cWBjfwoRenApc6YrulbnbxZ4PUURbpNeL8VDUfoz3Ij6Wg+M+O57Lm/w14LkictBZhX8IeBpwi4jcISIfATDG3A18CrgH+B/AW40x7RXjPiGhAM12m+ZJJyGnPoKc+ghg049OtI7k6LzLXRZBxtuGzMxUj1oTJrIvQ9WoNTMz+Yx9YaL6VYhas9FNa5abN/nPSuivAa4ZhqmEhFHAR7sBoHWUxswMXz24gx+9sBtyf//809m5k65pija98ffCCDdhlJogSGvRaTOQT0qlonZnUWx81BqVEKrmyzqqzvQ0LC7Go99ot0M9piGRxOSEhIQE0mKYkLCuoU+Z3zJjOOccV+F2Xtv9pmpyMq9bm5zsusL5LHk4XZwqA7nDFk8DeRvDrv2iolVhwqDrAgjk3AZ1OgONTN8Zc8fTB0IpVWglpBBeCccFmu02H94mnHpqO6dna7SczlDr56BSCK8MOuueQlRMDkNttZZ6y/SG8CrKjuevw7IO4ZWy41VD2hkmHDfwOsTa4hOZnu3r327wwheSD58FsHNndwEJdYRhuK9BQni5ZzvUqKl2skjXYR9+ZSnoszDStV6RRhTp+lhlx1stpMUw4biCN7t55+PWNPass1xFYJuXQ0xEzbnOxQ2ui8xwYru0osjUPfaPER6ifZQ8t1wkMTkhYYOh2W7z/pOF958sXHCBuzkzk4/uosTkmGlNKCZDr3FzmZicicJarnTlymJywN9Ki8nHvWlNQkJCgsd6XeiqIC2GCccl/CmzTSFgYHqaI4uNTD1Y277dliGemS5SLhJLh9IZFpX76Qw1Vic73rpDEpMTjms0222uHhMWWg02H7gzu9+pNzJb6kzcpFvWKKoLnyuqz0x4VFnf14FkY/VF5R6zniFxrMRkEdkiIreIyH3u7ykFdG3nAXeHiNyk7j9bRL7ugkz/jUse1RdpMUw47tFst/ndk4TNP35+ZupSO7CfxqJ13fOmNaAy6SnksuwF/sHhQqaz8GXZ8HxEbZUdL8ve5/R9tdlD1BYXui3NHc5nznP1mjbrc0TZ8fxp8jEI7vou4PPGmLOAz7tyDE8aYy5wn0vV/d8BPmCM2QU8BrypSqdJTE5IoJt1r1O3p8y18XHuPLCZ886ja1qjXeM0tItdBLndWSgK65Pogux4mei73Ox4IxKT4ZiJyZcBL3XXHwe+hE0E3xcuPejLgNep55vAh/s9m3aGCQkOXmS+ekxgdpbzt1nj6iUaLNHg8LyNLajNcLx3yBKNHjHVIxYCzD8XirghvY9nGEPsuaKwXqtwmjwtIrerz1UDdLVVJYKfAbYW0I27tm8VkVe7e6cCc8YYv2wXBpgOkXaGCQkJlWFM5R3mrDFmd1GliHwO2Bapem++P2NEpCj487OMMQ+IyJnAF0TkLuDxqgyGSIthQoKC9mW+Wgytlk0+B1b6zGz51I6ttrhAo17H/5xivslLLUvbmJmB7S7NxcwMbDuj2/nMDJ3tO2i1oHHwoG3Le8LMzMD27d0+Z2ao+bIL71Xbvp2lVo3G7CxsU+vM/DxMbh7B7BhgNBH5jDEXFdWJyMMicrox5iEROR04VNDGA+7vfhH5EvAjwH8BpkSk7naHlQNMJzE5ISGCZrvN+4xQmz/CFg6zhcPcdhss0YDZWebnuwckzM/z4GyDpZa9s7BoP37hXGrVaNQ7Nu3A1FR3QZ2czPsmu7oGS7B9u/34ldiH7PJ9bt+eldm2zX7m520f09Pd56AnxNjyYYClip+hcBNwpbu+Evj7kEBEThGRTe56Gvgx4B4Xdf+LdJPURZ+PYVl5k1XdfxAR45hBLD7ojrTvFJHnV2EiIWEtotlu0zz5ZDpTW+hMbeHFs5+hcftXYWqKG29UJi3TT+eMqQUadXtnYtx+vL6vUQ+i4bg4g53JzZYmVq7XrU7R7eg64xM90XI64xOZDtPTZjpNl+fFu+aNDp2Kn6FwLfAKEbkPuMiVEZHdIvJRR/MvgNtF5B+xi9+1xph7XN2vAe902TlPpST+qkYVMflj2MjWn9A3ReSZwCuB+9XtV2FD/Z8FvBh7gvPiKowkJKxF6DSkz/97w6U7H4SZGc4558yMpjZ7KAv5VRT2PxNvZw9Rm5qyhyhzh7OT6k69Ydvxp8Y+2b1bPDNafzAyN5fVhbTMzdlwYD7E1+JCb9ixZWF0YnJpL8Y8Crw8cv924M3u+qvA8wqe349NUTwQ+u4MjTFfBg5Hqj6AzYOilZuXAZ8wFrdiZffTB2UqISFhLcIvhlU+6w/L0hmKyGXAA8aYfwyqngH8QJVL8yb7Y/dHHnlkOWwkJBwTNNttmu0237pM4H/8D9i+nQ99SBH4kPwlyHR9oS2hE3Gjddq2MLQzdOXMrjAsaz3hCO0M02KoICITwHuA9w3TsTHmOmPMbmPM7tNOO22YphISjgma7TbNN72Jhx9rcNllQWVkwYm5yPVDkTteWBejD/vJFuCRIe0MQzwHeDbwjyJyAHt0/S0R2UbKm5ywweEjZv/Kr6ibc3PdzHQK0cWoIDueN5HpccdTGe+yOjq5kF6a1pe9G99oI10b4KmKn/WHge0MjTF3AU/3Zbcg7jbGzDpn6beJyA3Yg5PHlSV5QsKGgHfdq807+97xcW7+0gQXX5z39IjGM3T2f2GUmsxExqMsoo2qj7YT0o5MTD42Byirhb6Locub/FKse81B4NeNMUVH1TcDPw3sAxaAN4yIz4SENQUfMRvgfW3DRYUmxL2I7dLC6DKh4fZydnaxyNnD4zheDAvyJuv6neraAG8dnq2EhIS1h429M0weKAkJy4Q/Zb56TNi1q6sjDOMI5nZloV6wIIRXGPY/o/Xtzx3OPFeyEF6+rMJ7jTKEl8UxMbpeFSTf5ISEIeF1iIfnDJOT3TOSHdvs4pTzAHF6wWik6wKdYbSsI12H7axYCK+0M0xISOiDZrvNB08VPrhJ2HHeZnact5m/27QJ2fQLXH55PtDrUqurB+wX6VrrDIeJdD260+Rj4pu8KkiLYULCiNBst5kH2LkTdu5kPwCzHDyYt//zietDkTq+3JXXlbWjF8XRYGPbGSYxOSFhhNCnzM1XvIKPzXya2267Fh+5vkYn5x3SE/g1Ymgd9XEuWOAGvT841qc+sArSYpiQkFARG1tnmBbDhIQRQweIvYuf47TTugGf/MlwUXrRQcshRisWx5AWw4SEhAFhT5nHaD7nPuB/Z/cXJp/OOL0hvrTOT6Nsgau6+I32AGVjIh2gJCSsIJrtNs1bb+3eaLU4cMBehh4nRafKRafJ+rmwrDG63aIh2RkmJCQsG/pQ5Z2PG84d3w/sBMhyo+joXLEDk/C+rgt9oMMd5ugMriGJyQkJCQkb/AAlickJCccA3nXv/ScL8hznkTI35zIyK/c8L+Z6dzzvqqdCdAFZnb/OlefmsudG6453bOwMRWSLiNwiIve5v6dEaH5SRO5Qn0WfO1lEPiYi31N1F1TpN+0MExKOIfyhil8w7j1gF8Zdu1wOEy/eepc6HelaI4xs7VCjk+VVyTDSSNfHRB/4LuDzxphrReRdrvxrmsAY80XgArCLJzZS1j8okl8xxtw4SKdpMUxIOMbwOsRX3Wp48exn7M2pF0K9zldun+AlP05OiVijYzPe6YMQV9+hRk1dA9RCWtbdafJlwEvd9ceBLxEshgEuB/67MWZhmE6TmJyQsApottv89wuFHW/5GXa85WfoTD8d5uf58R93BE70DSNdZ1CRrqNisopaw+LiiLg+Zu54W1VQ6Blgax/6K4BPBveucemKP+DzK/fDsvMmi8gvicheEblbRH5X3X+3y5v8XRH5qSpMJCQcj2i227zxB8IbfyDU7vgWAO94h6t0SZ6yiDcVE0IBVkxe/YRQ0z7hm/tcpVsRkc+JyJ7IJ5ddxsVI1Rk4c3DZN58HfFbdfjdwDvBCYAvlu8oMy8qbLCI/id3K/rAx5qiIPN3dPxe7Sv8QcAbwORE52xizcY+gEhKOG3g7w0qYNcbsLmzJmMLY4CLysIicbox5yC12h0r6eQ3wt8aYLPGK2lUeFZE/B365CsPLzZv8FmwG+6OOxjN7GXCDMeaoMeZ7WKXmwMmcExKOF/hT5uYLXsCRqR284x3O6LreyHaFWmeYfeqNrpF2QKuvl5syII5jJibfBFzprq8E/r6E9rUEIrLP1S4iArwa2BN5rgfLnaWzgf9DRL4uIv9TRF7o7qe8yQkJy4A3u3nOc57qmtnMHuqaxQTZ8Xyk6ywKtsqkF2bHG22k62OyGF4LvEJE7gMucmVEZLeIfNQTichObDbO/xk8/1cichdwFzAN/FaVTpd7mlzHyuIXYuXyT4nImYM0YIy5DrgOYPfu3YU6gYSE4wXe7KaDoebMY460JpiEXp3h5GSv2U1RwvmRRrpe+dNkY8yjwMsj928H3qzKB4hstowxL1tOv8v9d3EQ+K/G4htYRcI0KW9yQsJQ8DlVjrQmONKaYPOBO21FvZ657gHQanXLrVa+zKhd8Dw2tm/ycmfs74CfBBCRs4EGMIuV9a8QkU0i8mzgLOAbo2A0IeF4gReZ33+yID9syBJEYX2Zl1o1mJ+nUe9Y65rFRVhc7Jbn5/PRsEdmWgPHdaTrWN5k4HrgemduswRc6Y7A7xaRTwH3AC3grekkOSFho2Bj+yYPkzf59QX01wDXDMNUQsLxDh8glrExllqGRr3OY4/B1lOczs657jXq+TQCjbpzx2u1uqfK7iR6eGzsxTB5oCQkrGE0221+e5NwpL6FrX/zQXsw4j5791rd4FJ9gqX6ROaR0qk3MoNsb2oz2gOUlB0vISFhFeB1iE//rbd3by4uZonrG4tHaCweyRbD2tzhHtOa0SEdoCQkJKwimu02/88jkp0cs2cPH/mICw7r7nXGJ6w4PD6ed8cbuZh8nB6gJCQkrA3oiNnvOWp4e/0bUN8NMzMA3Lp3CxdeaGmXWk6fCF0f5pFgfS50VZAWw4SEhIrY2AcoaTFMSFhH6KYhFX6DB3n00Rpbdu4EYHfdSsyNVotGfYns591q5T1ShsL61AdWQVoMExLWIbzr3pbFB2B2HoAbbz+b113RyU6bvUdKI/ReWTY6rNeT4ipIi2FCwjqF1yG+/VHr2v+6H7+fDjuoAQuLtewMpUNtdBvDJCYnJCSsRdgFUQD4DR7niSdgYnGR8amJ7qHJ4mL+dHnZSDrDhISEBIekM0xISFij0K57E/WjgLW2mZ52OsPx8RHpDDf2zjAZXSckbBA0222amzZx7+wWzpi/N7PPXmrVRhi4ZuMaXafFMCFhA6HZbvPXzxXkuScwwQITLNBoLbC5PgqXPH+avDF9k5OYnJCwweDNbr5+lz1lPv10+MpXRtX6+tz1VUFaDBMSNiD0KfOrgZeMpNWBsuOtOyQxOSEhYQCsvM5QRP6ty8feEZHCdKMicrHLz75PRN6l7j/bJavbJyJ/IyKNKv2mxTAhYYPCpyH9O2D7b/zGCFo8ZlFr9gD/BvhyEYGIjAF/BLwKOBd4rcvbDvA7wAeMMbuAx4A3Vek0ickJCRscOtrNcDDAU32phu7FmO8A2LTHhXgRsM8Ys9/R3gBcJiLfAV4GvM7RfRxoAh/u1++aWAy/+c1vzsrY2BPYpFLHC6Y5vsYLx9+Y19p4nzXc449/Fj49XZF4XERuV+XrXHrgUSGWo/3FwKnAnDGmpe5Hc7eHWBOLoTHmNBG53RhTqB/YaDjexgvH35g32niNMRePqi0R+RywLVL1XmPM34+qn0GwJhbDhISE4wvGmIuGbKIoR/ujwJSI1N3usHLu9nSAkpCQsB5xG3CWOzluAFcAN7mUxV8ELnd0VwKVdppraTEcpT5hPeB4Gy8cf2M+3sY7EojIv3Y52v8l8BkR+ay7f4aI3Azgdn1vAz4LfAf4lDHmbtfErwHvFJF9WB3in1Xq1y6kCQkJCcc31tLOMCEhIWHVkBbDhISEBNbAYljkUrPRICIHROQuEbnD21+JyBYRuUVE7nN/T1ltPpcLEbleRA6JyB51Lzo+sfig+87vFJHnrx7ny0fBmJsi8oD7nu8QkZ9Wde92Y/6uiPzU6nCdUIRVXQz7uNRsRPykMeYCZXv2LuDzxpizgM+78nrFx4DQDq1ofK8CznKfq6jgHbBG8TF6xwzWFewC97kZwL3XVwA/5J75Y/f+J6wRrPbOMHOpMcYsATcAl60yT8cSl2HdhXB/X72KvAwFY8yXgcPB7aLxXQZ8wljcirULO/3YcDo6FIy5CJcBNxhjjhpjvgfsw77/CWsEq70YxlxqKrnOrEMY4B9E5JsicpW7t9UY85C7ngG2rg5rK4ai8W307/1tTvy/Xqk+NvqY1z1WezE8nvDjxpjnY0XEt4pILsScMxbdsHZOG318Ch8GngNcADwE/P7qspNQFau9GBa51Gw4GGMecH8PAX+LFZEe9uKh+3to9ThcERSNb8N+78aYh40xbWNMB/hTuqLwhh3zRsFqL4ZRl5pV5mnkEJGTRORp/hp4JTZm201YdyEYwG1oHaFofDcBP+dOlS8EHlfi9LpGoPv8/9u7Y5SGgigKw/8hATcgpM4OsoTUdjZiKylSZBFpXYWlQpp04hq01lo3kerBTTEJWJhKyTPh/1ZwLwMHZoY7c01bZ2g93ya5SDKmXR69Hrs+HdbrQw1V1SXZj9QMgIdvIzXnZASsd++zDYHHqnpJ8gasksyAL+Cmxxp/JckTMAUud6NUS+Cen/t7Bq5olwgb4O7oBf+BAz1Pk0xoRwKfwBygqt6TrIAPoAMWVXW+H4qcIMfxJIn+t8mS9C8YhpKEYShJgGEoSYBhKEmAYShJgGEoSQBsARc3c+FP+05LAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -296,7 +300,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/icmeyer/openmc/openmc/data/resonance_covariance.py:233: UserWarning: Sampling routine does not guarantee positive values for parameters. This can lead to undefined behavior in the reconstruction routine.\n",
+      "/home/romano/openmc/openmc/data/resonance_covariance.py:233: UserWarning: Sampling routine does not guarantee positive values for parameters. This can lead to undefined behavior in the reconstruction routine.\n",
       "  warnings.warn(warn_str)\n"
      ]
     },
@@ -370,51 +374,51 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.031151</td>\n",
+       "      <td>0.030679</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000471</td>\n",
-       "      <td>0.107045</td>\n",
+       "      <td>0.000473</td>\n",
+       "      <td>0.108576</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>2.820921</td>\n",
+       "      <td>2.823843</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000334</td>\n",
-       "      <td>0.098885</td>\n",
+       "      <td>0.000351</td>\n",
+       "      <td>0.086418</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>16.217408</td>\n",
+       "      <td>16.281147</td>\n",
        "      <td>0</td>\n",
        "      <td>1.0</td>\n",
-       "      <td>0.000453</td>\n",
-       "      <td>0.068385</td>\n",
+       "      <td>0.000458</td>\n",
+       "      <td>0.106825</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>16.771021</td>\n",
+       "      <td>16.771760</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.013670</td>\n",
-       "      <td>0.071278</td>\n",
+       "      <td>0.013598</td>\n",
+       "      <td>0.072837</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>20.559685</td>\n",
+       "      <td>20.561545</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.010609</td>\n",
-       "      <td>0.097546</td>\n",
+       "      <td>0.011164</td>\n",
+       "      <td>0.086616</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
@@ -424,11 +428,11 @@
       ],
       "text/plain": [
        "      energy  L    J  neutronWidth  captureWidth  fissionWidthA  fissionWidthB\n",
-       "0   0.031151  0  2.0      0.000471      0.107045            0.0            0.0\n",
-       "1   2.820921  0  2.0      0.000334      0.098885            0.0            0.0\n",
-       "2  16.217408  0  1.0      0.000453      0.068385            0.0            0.0\n",
-       "3  16.771021  0  2.0      0.013670      0.071278            0.0            0.0\n",
-       "4  20.559685  0  2.0      0.010609      0.097546            0.0            0.0"
+       "0   0.030679  0  2.0      0.000473      0.108576            0.0            0.0\n",
+       "1   2.823843  0  2.0      0.000351      0.086418            0.0            0.0\n",
+       "2  16.281147  0  1.0      0.000458      0.106825            0.0            0.0\n",
+       "3  16.771760  0  2.0      0.013598      0.072837            0.0            0.0\n",
+       "4  20.561545  0  2.0      0.011164      0.086616            0.0            0.0"
       ]
      },
      "execution_count": 8,
@@ -486,51 +490,51 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.033838</td>\n",
+       "      <td>0.032858</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000480</td>\n",
-       "      <td>0.103325</td>\n",
+       "      <td>0.000479</td>\n",
+       "      <td>0.105208</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>2.822370</td>\n",
+       "      <td>2.823859</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000367</td>\n",
-       "      <td>0.091599</td>\n",
+       "      <td>0.000361</td>\n",
+       "      <td>0.093748</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>16.243968</td>\n",
+       "      <td>16.203069</td>\n",
        "      <td>0</td>\n",
        "      <td>1.0</td>\n",
-       "      <td>0.000311</td>\n",
-       "      <td>0.089655</td>\n",
+       "      <td>0.000264</td>\n",
+       "      <td>0.015233</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>16.775993</td>\n",
+       "      <td>16.765055</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.013050</td>\n",
-       "      <td>0.084476</td>\n",
+       "      <td>0.013648</td>\n",
+       "      <td>0.076119</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>20.561690</td>\n",
+       "      <td>20.557679</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.011163</td>\n",
-       "      <td>0.086802</td>\n",
+       "      <td>0.011140</td>\n",
+       "      <td>0.097548</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
@@ -540,11 +544,11 @@
       ],
       "text/plain": [
        "      energy  L    J  neutronWidth  captureWidth  fissionWidthA  fissionWidthB\n",
-       "0   0.033838  0  2.0      0.000480      0.103325            0.0            0.0\n",
-       "1   2.822370  0  2.0      0.000367      0.091599            0.0            0.0\n",
-       "2  16.243968  0  1.0      0.000311      0.089655            0.0            0.0\n",
-       "3  16.775993  0  2.0      0.013050      0.084476            0.0            0.0\n",
-       "4  20.561690  0  2.0      0.011163      0.086802            0.0            0.0"
+       "0   0.032858  0  2.0      0.000479      0.105208            0.0            0.0\n",
+       "1   2.823859  0  2.0      0.000361      0.093748            0.0            0.0\n",
+       "2  16.203069  0  1.0      0.000264      0.015233            0.0            0.0\n",
+       "3  16.765055  0  2.0      0.013648      0.076119            0.0            0.0\n",
+       "4  20.557679  0  2.0      0.011140      0.097548            0.0            0.0"
       ]
      },
      "execution_count": 9,
@@ -572,8 +576,8 @@
     {
      "data": {
       "text/plain": [
-       "[<openmc.data.resonance.ReichMoore at 0x14feb8715048>,\n",
-       " <openmc.data.resonance.Unresolved at 0x14feb8f7b128>]"
+       "[<openmc.data.resonance.ReichMoore at 0x14cf93855d68>,\n",
+       " <openmc.data.resonance.Unresolved at 0x14cf938c02e8>]"
       ]
      },
      "execution_count": 10,
@@ -595,7 +599,7 @@
     {
      "data": {
       "text/plain": [
-       "Text(0,0.5,'Cross section (b)')"
+       "Text(0, 0.5, 'Cross section (b)')"
       ]
      },
      "execution_count": 11,
@@ -604,12 +608,14 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -827,14 +833,6 @@
     "scrolled": true
    },
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/icmeyer/openmc/openmc/data/resonance_covariance.py:233: UserWarning: Sampling routine does not guarantee positive values for parameters. This can lead to undefined behavior in the reconstruction routine.\n",
-      "  warnings.warn(warn_str)\n"
-     ]
-    },
     {
      "data": {
       "text/html": [
@@ -868,51 +866,51 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.031065</td>\n",
+       "      <td>0.030488</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000474</td>\n",
-       "      <td>0.107954</td>\n",
+       "      <td>0.000473</td>\n",
+       "      <td>0.108946</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>2.823809</td>\n",
+       "      <td>2.825944</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000334</td>\n",
-       "      <td>0.098218</td>\n",
+       "      <td>0.000328</td>\n",
+       "      <td>0.098328</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>16.769186</td>\n",
+       "      <td>16.773886</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.013987</td>\n",
-       "      <td>0.072910</td>\n",
+       "      <td>0.012984</td>\n",
+       "      <td>0.076779</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>20.556649</td>\n",
+       "      <td>20.565737</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.010814</td>\n",
-       "      <td>0.098780</td>\n",
+       "      <td>0.011628</td>\n",
+       "      <td>0.088958</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>21.654591</td>\n",
+       "      <td>21.646469</td>\n",
        "      <td>0</td>\n",
        "      <td>2.0</td>\n",
-       "      <td>0.000366</td>\n",
-       "      <td>0.117679</td>\n",
+       "      <td>0.000389</td>\n",
+       "      <td>0.127833</td>\n",
        "      <td>0.0</td>\n",
        "      <td>0.0</td>\n",
        "    </tr>\n",
@@ -922,11 +920,11 @@
       ],
       "text/plain": [
        "      energy  L    J  neutronWidth  captureWidth  fissionWidthA  fissionWidthB\n",
-       "0   0.031065  0  2.0      0.000474      0.107954            0.0            0.0\n",
-       "1   2.823809  0  2.0      0.000334      0.098218            0.0            0.0\n",
-       "2  16.769186  0  2.0      0.013987      0.072910            0.0            0.0\n",
-       "3  20.556649  0  2.0      0.010814      0.098780            0.0            0.0\n",
-       "4  21.654591  0  2.0      0.000366      0.117679            0.0            0.0"
+       "0   0.030488  0  2.0      0.000473      0.108946            0.0            0.0\n",
+       "1   2.825944  0  2.0      0.000328      0.098328            0.0            0.0\n",
+       "2  16.773886  0  2.0      0.012984      0.076779            0.0            0.0\n",
+       "3  20.565737  0  2.0      0.011628      0.088958            0.0            0.0\n",
+       "4  21.646469  0  2.0      0.000389      0.127833            0.0            0.0"
       ]
      },
      "execution_count": 15,
@@ -956,7 +954,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/nuclear-data.ipynb b/examples/jupyter/nuclear-data.ipynb
index 09da5a2d0..e13b143e4 100644
--- a/examples/jupyter/nuclear-data.ipynb
+++ b/examples/jupyter/nuclear-data.ipynb
@@ -46,7 +46,7 @@
     {
      "data": {
       "text/plain": [
-       "53.939608986"
+       "53.939608306"
       ]
      },
      "execution_count": 2,
@@ -86,7 +86,7 @@
     {
      "data": {
       "text/plain": [
-       "12.011115164862904"
+       "12.011115164864455"
       ]
      },
      "execution_count": 4,
@@ -189,7 +189,7 @@
     {
      "data": {
       "text/plain": [
-       "{'294K': <openmc.data.function.Tabulated1D at 0x14d02ff8fa58>}"
+       "{'294K': <openmc.data.function.Tabulated1D at 0x1461b4d2f160>}"
       ]
      },
      "execution_count": 8,
@@ -291,7 +291,7 @@
     {
      "data": {
       "text/plain": [
-       "Text(0,0.5,'Cross section (b)')"
+       "Text(0, 0.5, 'Cross section (b)')"
       ]
      },
      "execution_count": 12,
@@ -300,7 +300,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -338,15 +338,15 @@
      "output_type": "stream",
      "text": [
       "[<Reaction: MT=1 (n,total)>,\n",
-      " <Reaction: MT=27 (n,absorption)>,\n",
+      " <Reaction: MT=101 (n,disappear)>,\n",
+      " <Reaction: MT=301 heating>,\n",
       " <Reaction: MT=2 (n,elastic)>,\n",
       " <Reaction: MT=16 (n,2n)>,\n",
       " <Reaction: MT=17 (n,3n)>,\n",
       " <Reaction: MT=22 (n,na)>,\n",
       " <Reaction: MT=24 (n,2na)>,\n",
       " <Reaction: MT=28 (n,np)>,\n",
-      " <Reaction: MT=41 (n,2np)>,\n",
-      " <Reaction: MT=51 (n,n1)>]\n"
+      " <Reaction: MT=41 (n,2np)>]\n"
      ]
     }
    ],
@@ -394,7 +394,7 @@
     {
      "data": {
       "text/plain": [
-       "{'294K': <openmc.data.function.Tabulated1D at 0x14d02f8e9ac8>}"
+       "{'294K': <openmc.data.function.Tabulated1D at 0x1461b4d594e0>}"
       ]
      },
      "execution_count": 15,
@@ -423,7 +423,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -478,7 +478,7 @@
     {
      "data": {
       "text/plain": [
-       "[<openmc.data.correlated.CorrelatedAngleEnergy at 0x14d02f8bef28>]"
+       "[<openmc.data.correlated.CorrelatedAngleEnergy at 0x1461b4a66908>]"
       ]
      },
      "execution_count": 18,
@@ -506,36 +506,36 @@
     {
      "data": {
       "text/plain": [
-       "[<openmc.stats.univariate.Tabular at 0x14d02f8e9b38>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8e9c50>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8e9cf8>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8e9e48>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f2080>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f22e8>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f25f8>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f2978>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f2d68>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f9208>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f96d8>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8f9ba8>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f901160>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f901710>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f901d30>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f9083c8>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f908a90>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f90f1d0>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f90f8d0>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f917080>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f917828>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f91f048>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f91f860>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8a70f0>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8a7978>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8af278>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8afa90>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8b6390>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8b6c88>,\n",
-       " <openmc.stats.univariate.Tabular at 0x14d02f8be5f8>]"
+       "[<openmc.stats.univariate.Tabular at 0x1461b4d59550>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d59630>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d596d8>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d59828>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d59a20>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d59c88>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d59f98>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d63358>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d63748>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d63ba8>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d6b0b8>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d6b588>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4d6bb00>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4aaa0f0>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4aaa710>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4aaad68>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ab1470>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ab1b70>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ab92b0>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ab9a20>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ac1208>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ac19e8>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ac9240>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ac9a90>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4acf358>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4acfc18>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ad7470>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ad7d30>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ae0668>,\n",
+       " <openmc.stats.univariate.Tabular at 0x1461b4ae0f98>]"
       ]
      },
      "execution_count": 19,
@@ -562,7 +562,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -576,7 +576,7 @@
    "source": [
     "for e_in, e_out_dist in zip(dist.energy[::5], dist.energy_out[::5]):\n",
     "    plt.semilogy(e_out_dist.x, e_out_dist.p, label='E={:.2f} MeV'.format(e_in/1e6))\n",
-    "plt.ylim(ymax=1e-6)\n",
+    "plt.ylim(top=1e-6)\n",
     "plt.legend()\n",
     "plt.xlabel('Outgoing energy (eV)')\n",
     "plt.ylabel('Probability/eV')\n",
@@ -600,7 +600,7 @@
     {
      "data": {
       "text/plain": [
-       "Text(0,0.5,'Cross section(b)')"
+       "Text(0, 0.5, 'Cross section(b)')"
       ]
      },
      "execution_count": 21,
@@ -609,7 +609,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -814,7 +814,7 @@
     }
    ],
    "source": [
-    "n2n_group['294K/xs'].value"
+    "n2n_group['294K/xs'][()]"
    ]
   },
   {
@@ -883,7 +883,7 @@
     {
      "data": {
       "text/plain": [
-       "{'0K': <openmc.data.function.ResonancesWithBackground at 0x14d02ba7dda0>}"
+       "{'0K': <openmc.data.function.ResonancesWithBackground at 0x1461b11824a8>}"
       ]
      },
      "execution_count": 29,
@@ -937,8 +937,8 @@
     {
      "data": {
       "text/plain": [
-       "[<openmc.data.resonance.ReichMoore at 0x14d02d198e80>,\n",
-       " <openmc.data.resonance.Unresolved at 0x14d02d20dcc0>]"
+       "[<openmc.data.resonance.ReichMoore at 0x1461b1fcb898>,\n",
+       " <openmc.data.resonance.Unresolved at 0x1461b2692ba8>]"
       ]
      },
      "execution_count": 31,
@@ -992,7 +992,7 @@
     {
      "data": {
       "text/plain": [
-       "Text(0,0.5,'Cross section (b)')"
+       "Text(0, 0.5, 'Cross section (b)')"
       ]
      },
      "execution_count": 33,
@@ -1001,7 +1001,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEOCAYAAACTqoDjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl8VPW5P/DPM9kTkgABkkBYxLBvsrjiVipq2SyIVmvt1Vq99lZttb+29naxy/XWLvb22rr2urS2WndFxLqBuKGyiuwiIBCQhC0QyDYz398fc87MyeTMzJmZc+acST7vvqaZOXPmzJMJfp/57qKUAhERUTSf2wEQEZE3MUEQEZEpJggiIjLFBEFERKaYIIiIyBQTBBERmWKCICIiU0wQRERkigmCiIhMMUEQEZGpXLcDSEefPn3UkCFD3A6DiCirrFy5cr9Sqm+i87I6QQwZMgQrVqxwOwwioqwiIp9ZOY9NTEREZCorE4SIzBaRBxobG90OhYioy8rKBKGUelEpdV15ebnboRARdVlZmSCIiMh5TBBERGSKCYKIiEwxQRARZdChY23Y29jsdhiWZPU8CCKibDPl9tcRCCrsuGOm26EkxBoEEVEGBYLK7RAsY4IgIiJTTBBERGSKCYKIiEwxQRARkSkmCCIiMsUEQUTkkv9etBEX/vEtt8OIifMgiIhc8sBb29wOIS7WIIiIyJRnEoSIjBKR+0TkaRH5ltvxEBF1d44mCBF5SETqRWRd1PELRWSziGwVkVsBQCm1USl1PYBLAUx1Mi4iIkrM6T6IRwD8GcDf9AMikgPgbgDTAewGsFxEFiilNojIHADfAvCow3ERWdbY3I51dY3YWt+EhqOtONLSjqK8HFT0yMeY/uWYPLgXCvNy3A6TyHaOJgil1FsiMiTq8CkAtiqltgGAiPwTwEUANiilFgBYICIvAXjMydiIYmlpD+CD7QexeOM+vPXJfmzffyz8XI5P0KMgFy3tAbT6gwCAssJczJ04AN/+Qi36lRW6FTaR7dwYxTQAwC7D490AThWRcwHMA1AAYFGsF4vIdQCuA4BBgwY5FyV1K/VHWrBkcz3e2FiPd7bux/G2AArzfJh6Yh/Mn1yD8TXlGFlVhoqSfPh8AiC0bPPqXYewYM0ePPbhTjy1cjdumz0al04ZCBFx+TciSp9nhrkqpd4E8KaF8x4A8AAATJkyJXuWRSRPCQYVPq5rxOJN9ViyuR5rdzcCAPqXF+LiSTWYNqofTh9aEbfpqFdJPqaNrMS0kZW4efpw/OjZj/HDZz7Guroj+MWcMeFEQpSt3EgQdQAGGh7XaMeIHNXU6sc7nzTgjY31WLK5AfubWiECTBzYE9+/YAS+OKofRlSWpvTtf3BFCR695lT89l+bcP9b29DSHsBv549nTYKymhsJYjmAYSJyAkKJ4TIAX03mAiIyG8Ds2tpaB8KjruJ4mx8rdhzC+9sOYNm2A/h4dyP8QYWywlycPbwvvjiqH84Z3g+9S/Jteb8cn+BHM0ahINeHuxZvxcDexbjpi8NsuTaRGxxNECLyOIBzAfQRkd0AblNKPSgiNwB4BUAOgIeUUuuTua5S6kUAL06ZMuVau2Om7BQMKmzb34SPdjXi47pGfLT7cDgh5PoE42vKcd3ZQ3H28L6YPLgX8nKcG+F98/Th2H2oGX94bQvGDijDtJGVjr0XkZOcHsV0eYzjixCnI5oolmBQYU9jM7bWN2FrfRM+bQj93Lj3KJpa/QCA4vwcjO0fSginDa3A5MG9UFKQucqyiODXF4/Dhr1H8IOn1+Jf3z0bfXoUZOz9iezimU7qZLCJqWtSSqGp1Y+Dx9rQcLQVdYebsftQM+oON6PO8LO5PRB+Te+SfNT27YF5kwZgfE1PTKgpx9C+PZDjcgdxQW4O/njZSZjzp3fxsxfW4Z4rJrsaD1EqsjJBsInJe4JBhbZAEK3tQbT6A2hpD6Kp1a/d2nG0Rbuv/Tza4seRlnYcaGrDwWNtONDUiv3H2tCmzS0w6lWchwG9inBi3xKcPawvTuxXgtq+PVDbrwcqPPzNfGRVGW6cVos7X9uCd7fux9TaPm6HRJSUrEwQ6Vr52SF8Wt8EhdAoWaUAfbys0u4Ynws9jpzQ6VztTudrRJ5Dp+c6Xz/Wc5HXJh+vUgr+oEIwGPoZ0G8qciz8nFIIBLSf2nlBpeAPhO63BoJobQ+gzR9Eqz+UCEIJIYi2QOeCPRafAD0KclFamIeKHvno0yMfI6pKUVGSj4oe+agoKUCf0gIM6FmI6vKijDYP2e3as4fiyZW78PMF67HoO2c52vdBZLfs/S8vDc+vrsOj73/mdhgZIQLk+gQ5PkGOCHw+iTzWjuXkaD+1Yz4R5JocKy/KQ0FpAQpyfSjIzUFBni9yP9enPdbu5/pQWpiLHgV56FGYqyWE0M/i/JxuM/yzMC8HP5k5Gv/+6Eo8s3I3LjuFkzspe2Rlgki3D+J75w/H9eeeGLpW+JqAaI/0sitchIUfi+HccCydrmM8F9L5evFeE11uRl/PeK2Y1+kmhW+2OH90JSYM7Ik/Ld6KeZNqkJ/LWgRlh6xMEOn2QfQszkfPYpuDIopBRHDzecNw1cPL8dTKXbji1MFuh0RkCb/KEGXAOcP7YuKgnvjz4q2mHfFEXsQEQZQBIoKbpg3D3sYWvPTxHrfDIbKECYIoQ84Z3hcn9i3Bg+9s7zS6jciLsjJBiMhsEXmgsbHR7VCILPP5BN848wSsqzuCD7cfdDscooSyMkEopV5USl1XXl7udihESZk3sQY9i/Pw4Dvb3Q6FKKGsTBBE2aooPweXnzIIr2/ch72NzW6HQxQXEwRRhl1+8iAEFfDUit1uh0IUFxMEUYYNqijGmbV98MTyXQgE2VlN3pWVCYKd1JTtLj9lEOoON+PtTxrcDoUopqxMEOykpmw3fXQlKkry8fiHO90OhSimrEwQRNkuP9eHiyfX4PWN9djf1Op2OESmmCCIXHLxpBoEggoLP+LMavImJggil4yoKsXo6jI8t7rO7VCITDFBELlo3qQB+Gh3Iz5taHI7FKJOmCCIXDRnQn/4BHhuFWsR5D1ZmSA4zJW6in5lhZha2wfPr6lDkHMisk5Tqx+rdx5yOwzHZGWC4DBX6krmTRqA3YeaseKzrlvQdFXf+vtKzL3nPRxr9bsdiiOyMkEQdSUXjKlCcX4OnlvNpTeyzUe7DgMA2gOJN4H6aNfhrNssigmCyGXF+bk4f3QlXl73uaWChrzD6v7vO/Yfw0V3v4tfLlzvcET2YoIg8oBZ4/vj8PF2vLN1v9uhUAoS7f906HgbAODj3dnVb8oEQeQBZw3vg9LCXLy0dq/boVASLFYgLNc0vIYJgsgDCnJzcP7oKryy/nO0+gNuh0NJ6qrjz5ggiDxi1oRqHG3x451P2Mxkt/ZAkJMRU5CVCYLzIKgrmnpiH5QX5WEhm5lsd/tLG/HFO5diz2F3d/HLtppGViYIzoOgrig/14cLx1ThtQ370NLOZiY7fbD9IIBIZ7FdrPYsZGcPRJYmCKKuaub4ajS1+rF0CzcSspPShhmJQ0W1SjSMKXyeI2/vGCYIIg8548QK9C7JZzOTzfSC2e7BRHaNThpy60v427IdtlzLTkwQRB6Sm+PDhWOr8MbGfWhuYzOTXZTW+u/UaFOrFYN47//kil22xGInJggij5k1rhrH2wJYsrne7VC6jHANwuYmpmSvFq+JyYvNT0wQRB5z6tAK9OlRgIVrudOcXfSy17EaRILCPUvnyTFBEHlNjk/wpbFVWLypHsfbuuYqoZkW6aS2V7IFv4rTGOXFJMIEQeRBM8dXo6U9iMWb2MxkB6drEF0VEwSRB508pDf69CjAoo85mskW4VFMzBDJSJggROR0EblbRNaKSIOI7BSRRSLybRHhTDUiB+T4BDPGhZqZuupmNJnkdP9vvKYjwFrneNZ1UovIywC+CeAVABcCqAYwGsBPABQCeEFE5jgdJFF3NHMcm5nsovdB2F8IawW/xet6MQnEk5vg+SuVUtErhzUBWKXd7hSRPo5EFoeIzAYwu7a2NtNvTZQxU4b0Rt/SUDPT7An93Q4nq0W2+3amhE50VbOWLauzr90UtwZhTA4iUiUic7SF8qrMzskUrsVE3UGOTzBjLJuZ7KA3AdldJusFv9XrGs+Lfo0Xu0csdVKLyDcBfAhgHoD5AN4XkW84GRgRATPH90erP4g32MyUFr0wDjr0pT1RH0S2StTEpPs+gIlKqQMAICIVAN4D8JBTgRERMGVwL/QrLcCitXsxh81MKdMThN0Fuf6lP5WaSfRLvNjiZHWY6wEARw2Pj2rHiMhBPp9gxrhqLNlcjyY2M6XNqUI4lctmfR+EiNwiIrcA2ArgAxH5uYjcBuB9AFsyESBRdzdzfHWomWnjPrdDyVp6YRy0uVCO9EFYXO7b1nd3XqIaRKl2+xTA84j8fi8A2O5gXESkmTyoFyrLOGkuHXrB5daXdtNRTJkPI2lx+yCUUr/IVCBEZM7nE3xpbDUe+3Anmlr96FFgteuQdE4nhpT6ILIgQyRqYvqLiIyN8VyJiHxDRK5wJjQi0s0cX402NjOlTO+ctruJKR3RHeZeHOaa6KvI3QB+JiLjAKwD0IDQDOphAMoQGsX0D0cjJKJwM9NLa/fiopMGuB1O1tGHt9o+D0Ibx2R9HkTsEz2Uu8ISNTGtAXCpiPQAMAWhpTaaAWxUSm3OQHxEhMhopn98sBNHW9pRWpjndkhZJTLM1aHrp7AWkxcTQjRLw1yVUk1KqTeVUo8rpZ5nciDKvJnj9GYmTppLntOjmGy9rGdwuW+iLDFpUC9UlRVi4VqOZkqWcqiJKXx9Zy7rOiYIoiyhNzO9taUBR1va3Q4nqyiTe3aIzKRO/rrZUOtggiDKIjPHV6EtEMTrHM2UlMhEOYeun9JrvJ8hLA2oFpHhCK3HNNj4GqXUNIfiIiITEwf2QnV5IV5auxdzJ9a4HU7W8OREOe/nB8uL9T0F4D4AfwEQcC4cIopHb2Z6dNlnONLSjjKOZrIk0gfh0H4QFi+76fOjMZ9bv+cI3tu6H2fUZnyLnZisNjH5lVL3KqU+VEqt1G92BiIiX9Ym5j0hIufbeW2irmTGuOpQM9MGNjNZ5VQTU2SP6xT6IEyOPb1qd1rx2M1qgnhRRP5DRKpFpLd+S/QiEXlIROpFZF3U8QtFZLOIbBWRWwFAGz57LYDrAXwl6d+EqJuYOLAn+mvNTGSNU8t9R18/udd4v43JaoL4N4T6IN4DsFK7rbDwukcQ2ss6TERyEJqh/SWE9re+XERGG075ifY8EZnQm5ne/mQ/Gps5mskKh3ccTXjZLMgFpqxOlDvB5DbUwuveAnAw6vApALYqpbYppdoA/BPARRLyGwAvK6VWJfuLEHUnM8azmSkVjo1iSuG6H9c12h+IzaxuOZonIjeJyNPa7QYRSbV3bACAXYbHu7VjNwI4D8B8Ebk+TizXicgKEVnR0NCQYghE2W3iwJ4Y0LMIL3EJcEv05hy9ielYqx/H29LfgCk8kzpBHcLs+Xc+2Z/2+zvNahPTvQAmA7hHu03WjtlGKXWXUmqyUup6pdR9cc57QCk1RSk1pW/fvnaGQJQ1RAQzxlXh7U8a2MyUBP2b/pjbXsHY216x/bpOe2tLA97cnLmlVqwmiJOVUv+mlFqs3a4GcHKK71kHYKDhcY12jIiSMGNcNdoDCq+xmSkhfbSRcS0mO5qbrK7FZFcC+fpDH+Kqh5fbczELrCaIgIicqD8QkaFIfT7EcgDDROQEEckHcBmABclcQERmi8gDjY3eb8MjcspJWjPTwrV73A4la7i1mmu2spogvg9giYi8KSJLASwG8L1ELxKRxwEsAzBCRHaLyDVKKT+AGwC8AmAjgCeVUuuTCVop9aJS6rry8vJkXkbUpYgIZk/oj7c/2Y8DTa1uh5MdumY57hhLM6mVUm+IyDAAI7RDm5VSCf9FKqUuj3F8EYBFlqMkIlNzJw7AfUs/xcK1e/FvZwxxOxzPc2pHuZTmQdgfhu0SbTk6Tfs5D8BMALXabaZ2zBVsYiIKGVFVilHVZXhuNbvxrHBqR7lMv2+mJGpiOkf7OdvkNsvBuOJiExNRxNyJ/bFm12Fs33/M7VA8TwFo8wftv65NCcBqwsmURFuO3qbd/aVSarvxORE5wbGoiMiyi04agF+/vAnPr67DzdOHux2OpwWVQqvfvvVG05kHkQ2sdlI/Y3LsaTsDIaLUVJYVYuqJffD8mrqsWN/HTUo50/afyjBXs7qC2bLgbkrUBzFSRC4GUC4i8wy3qwAUZiRC87jYB0Fk8OWJA/DZgeNYtfOw26F4nLK1PyD1tVy7QCc1QqOWZgHoiY79D5MAXOtsaLGxD4KoowvGVKIwz4fn2VkdV1DBkZI5Xs2tPRBEc3t2bqOTqA/iBQAviMjpSqllGYqJiJJUWpiH6aOrsHDtHvx01mjk53I3YTO2j2LS2oTiXXbePe9lxcJ8Zqz+K7peRHrqD0Skl4g85FBMRJSCuRP749Dxdry1hYtYxqK0/2VStiYHwHqCGK+UCjduKqUOAZjoTEhElIqzhvVF75J8zokwofcVBJUzcxK66tgAqwnCJyK99AfabnJW97O2HTupiTrLy/HhopP647UN+3DoWJvb4XiKXn4r5dieco5cFQCa2wL4tKHJsevHYzVB3AlgmYj8SkR+hdDOcr91Lqz42ElNZO4rJw9EWyCI59ewFmFGKXu3+gyPYnKwBnHj46vwxTuXdpjgl6kvAFZ3lPsbgHkA9mm3eUqpR50MjIiSN7KqDONryvHE8l2cE2EQGY7qTA3CyU/6na2hjYUChvXJb312rYPvGJHMUIfeAI4ppf4MoIEzqYm86ZIpA7Hp86NYV3fE7VA8x46cuWXfUTz0jrawhMX9IOxgTG1HmtPfDc8Kq1uO3gbghwB+pB3KA/B3p4IiotTNmdAfBbk+PLliV+KTuxk7Oqln3fUOfrlwQ4djTtbW9PWZjG+RqZFYVmsQcwHMAXAMAJRSewCUOhVUIuykJoqtvCgPXxpbhefX1KElSydoOSXUSZ1e4doWCIavlc5Maqv05TecWqo8HqsJok2FUqQCABEpcS6kxNhJTRTfpVMG4miLH6+s/9ztUDxFhf/Phmsp8/t2Mw7RzcT7GVlNEE+KyP0AeorItQBeB/AX58IionScNrQCA3sX4YnlbGYCYOgrsK9xJqiUYSa1PVc1rtV3x8ubsHhTZL9xYzNWpuoSVneU+72ITAdwBKH1mX6mlHrN0ciIKGU+n+CSyQPxh9e2YOeB4xhUUex2SO7SSlRl40S5oMOl9H1LP8V9S4EeBbkZeT8zVjupSwAsVkp9H6GaQ5GI5DkaGRGlZf7kGvgE+OfynW6H4hnplLGbPz+KC//4VvhxsGOvsWP0WkUgmJn3M7LaxPQWgAIRGQDgXwCuBPCIU0ERUfr69yzCtJGVeGL5Lls3yclKho7eVJuD7nx1MzZ9fjT8ON38YLkmY2gei7yft0YxiVLqOEKT5e5VSl0CYIxzYSUIhqOYiCy58vTBOHCsDf9a1707q31aX0EwmPp+ENGb+QSNo5gy3Em9fMch597QwHKCEJHTAVwB4CXtWI4zISXGUUxE1pxV2wdDKorx6LLP3A7FVT6tlA0EU//uHb1fdDDNb/TJvsbLw1y/g9AkueeUUutFZCiAJc6FRUR28PkEXzttMFZ8dggb9nTfmdV6DcIfVLZNagsGDXtSp3DJoMVeZ32kVCDq/EwspWJ1Laa3lFJzlFK/0R5vU0rd5GxoRGSH+ZNrUJDrw98/6L61CL2QDSr7thwNpjnsNBBMfA4QOwllYlQTt50i6uJ6FudjzoT+eH51HY60tLsdjiv0JiZ/GqWqeR+EvgxG8te12mQU6YPoeH4mmpyYIIi6gStPH4zjbQE8t6p7LgNu7KQ2SqeZJt1Rp8kW8NHnRzc5OYEJgqgbGF/TExNqyvHX93ZYbvvuSnJ8xj6IyPFkyujoGkS6fQBWC3hj85iRZ2oQIvJbESkTkTwReUNEGkTka04HR0T2+caZJ2Db/mNYsrne7VBcExrFFClY0ylkO5TvqXRSW3yN2TBXwFs1iPOVUkcAzAKwA0AtgO87FRQR2W/GuGpUlxfiL29vczuUjNO/7QeiahDJlLFmw1zDHcipDHO12gcRYzXXoMVO7nRYTRD6mk0zATyllHJ1hhonyhElLy/Hh6unDsH72w5iXV33+m9HTwTR37qTqkGYdFLrUqmIJFsDiE4IAa80MQFYKCKbAEwG8IaI9AXQ4lxY8XGiHFFqLjtlEEryc/B/3awWoX/Dj54ol0Z+6FBgp5QgTF4U3c9hfGfP9kEopW4FcAaAKUqpdoQ2DrrIycCIyH5lhXn4ysmDsHDtXuxtbHY7nIzRy9LoiXLp9UGkNw/C6lvHbmLySIIQkUsAtCulAiLyE4S2G+3vaGRE5Iirpw5BUCk88u4Ot0PJGL0oDUbtB5FMM42IWR9E6vMgLI9iCr9f1Ou9UoMA8FOl1FERORPAeQAeBHCvc2ERkVMG9i7GjHHV+McHO3H4eJvb4WSEXoBHD3MNBNybB2G1gI9Vg/DSKCZ9reCZAB5QSr0EIN+ZkIjIad/+Qi2aWv145L0dboeSEXrZGkoIkYK1PYmhQNHdAx32pE6hrE621hF9vpdGMdVpW45+BcAiESlI4rVE5DGjqsswfXQlHnpnO452g+U39KI1+lu736YaRCp1COtNTPpifVGv91AT06UAXgFwgVLqMIDe4DwIoqx207RhONLix9+6wVLgseZBpNNMk+4oomQX6/PyKKbjAD4FcIGI3ACgn1LqVUcjIyJHjaspx7kj+uLBd7bjeJvf7XAcZZwHYSxW262W0jBfrE+X2jyI2O9tbE6KuVifV/ogROQ7AP4BoJ92+7uI3OhkYETkvBun1eLgsTY89kHX3rc6Vg0imdVdzeZBRGZSJy/ee5slnOhjXmpiugbAqUqpnymlfgbgNADXOhcWEWXC5MG9ccaJFbhv6ac41tp1axHhPoiotZiSq0HE2VHO5pnUxmdibRjkpVFMgshIJmj3Tef8EVF2+d75I7C/qQ0Pv7vd7VAc03GiXOR4un0Q6azFFL8G0fk5L6/F9DCAD0Tk5yLycwDvIzQXwhVci4nIPpMH98L00ZW4f+k2HDrWNedFRJqYOpaq7UmMYurUxKQiI4xSyTPWaxDaMa82MSml/gDgagAHtdvVSqk/OhlYgni4FhORjb5/wQg0tflx79JP3Q7FEXpR2hYIduyDSKKJqdM1lQrvMxGvwzkWq30Qbo5iyk10gojkAFivlBoJYJXjERFRxg2vLMW8iTV45L0duHrqEFSXF9n+Hk+u2IWivBzMnpD5VXr0srTNH+zQHJTUFqSdRjEBuVqCSKYmoos7iskQY2QehAdHMSmlAgA2i8ggx6MhItfcPH0YoIA7X93iyPV/8PRa3Pj4akeunYj+bbvVH0x5FJPZNXNz9ASRQg0iRlLZ39SKET/5V/hxpAbR8TwvdVL3ArBe201ugX5zMjAiyqyaXsW4euoQPL1yNz7addjtcGwVbmLydyzI/YEglFK4b+mn2Hck/g4GZhsG5eX4tOskX1hHx6K/x4Y9RzocO6j1C3UaxeSFJibNTx2Ngog84YZptXhmVR1+/uJ6PPutMzoN7cxaWlna6u/cSb21vgl3vLwJr23Yh2e+dYblSwaDxiam5GsQLe0B0+PRH/nRltDw41Z/x/NdH8UkIrUiMlUptdR4Q2iY627nwyOiTCotzMMPLhyB1TsP44U1e9wOxzZ6m35bVBNTIKjCTTdHmuOvSWU2kzpXq0Gk0gfRYlKDADrXVHTRyc0Lo5j+COCIyfFG7Tki6mLmT6rB+Jpy/PrljV1m8lzQUIMwdgDvOdwMX4xRQtE6D3NVyNP6IKJHQ/kDwU5NRdHMahAisXaVA1qjzvfCWkyVSqmPow9qx4Y4EhERucrnE9w2ewz2HWnFH1+3v8M6E6NvoqlwJ3WgQw1i1c5D8PlSm8sQVAo+rTRvDyos33EQR7SVcX//6hbMuOttfLLvaMzXR9cIdLEa9aLPP3d43+QCTkGiBNEzznP2j4MjIk+YPLgXvnrqIDz4znZ8vNveCanNMdrenWTspDbmgcbmduTEWMoiWvQ3e2PH9NGWdlxy3zJ8868rAACrdx4CADQ0tca8Xsz3i1WDMCSIX100JiP9Q4kSxAoR6bTmkoh8E8BKZ0IiIi/44YUjUdGjALc+uzatCWXR3Gi2UsYmJkMVoqnVH3MiWiJths9EL7zX1XVMprH6E+KJ9Rpjk9TpJ1Ykfd1UJEoQ3wVwtYi8KSJ3arelCC3e9x3nwyMit5QX5eEXc8Zg/Z4jeMjGdZqaMpwg9ISQl9NxUltpYS6aWvzhpqVETV/RBbexNqIPWbWjWyBmH0SHJqbMjC6LO8xVKbUPwBki8gUAY7XDLymlFjseGRG57ktjq3DeqEr84bUtOG9UJYb27ZH2NY+1ZraJSS+0C3Jz0B7wh4eLlhbk4mirP9zUk2wfRLtJDUIfWZROnojdBxH53DI1+tjqWkxLlFJ/0m5MDkTdhIjgv748FgW5Obj5yY9saWrKeA1C+1mYFyruWtpDv0NpYR6aWvyRhfwSjWKKKpTb/MHwxdu0wjt6FdZkC/L3tx3A8zGGFze3RT77TM1O4b7SRBRXVXkhbp87Fh/tOoy7l6S/mF+m+yD0voWC3BwAkW/ipYW5aG4PhPsSzJbYNoou7I1NPnrSCV8ixSrEjgPH8fiH5ps3HT4eWWk3UxMYmSCIKKFZ4/tj7sQBuGvxJ2kvw3HweGaXFNcLbb0G0RquQYRa2I80hxJW4rWNOhbK7YHI5kP6lq3RtRA7i/H9cUZEOcUzCUJEhorIgyLytNuxEFFnP58zBpWlBfjOP1eHx/unouFoZgs6vQZRlB+qQbSEaxB5AIBXN3wOIPnF74xrKelJxsm5axv2xp945wRHE4SIPCQi9SKyLur4hSKyWUS2isitAKCU2qaUusbJeIgodeVFefjfyydi16Fm/PDptQmbZKLpM5YTLYpnt3ANQm9iiqpBPPzuDgDJHMaQAAAWHklEQVSJO6k79UEEIpPuGmMs02HlE9JHVyViXM6jq/RBPALgQuMBbX+JuwF8CcBoAJeLyGiH4yAiG5w8pDd+eOEIvLzu83DBaoVSkTWPMp0g9BpEYZ7eBxHppDY7zypjgR2dIPSmJyvX1BOXFzmaIJRSbyG0A53RKQC2ajWGNgD/BHCRk3EQkX2uPWsopo+uxH8v2oiVnx2y9Bpj8029S01MkQQRamIqK8o1Pc8q48J/sWaHW1lxtawoL/FJLnGjD2IAgF2Gx7sBDBCRChG5D8BEEflRrBeLyHUiskJEVjQ0NDgdKxFFERH8/pIJqO5ZiBseW2Wp89S4MU/9kUwniNDP6GGuvYrzO56XoDCPbtaJXn7bSE8cVlZcvf/KyQnP6RSLl+ZBZIJS6oBS6nql1IlKqV/HOe8BpdQUpdSUvn2dX6yKiDorL8rDvVdMxsFjbbjhsVUJ50dEvsX7sLexOTzqJxP0vpIirQahL1nRq7jjN/f2JDdYONYa6LAyrBkrCxMO6FmEIRXFcc/R953INDcSRB2AgYbHNdoxIsoiYweU4/a54/D+toP4zb82xT1Xr0GMr+mJoAI27o29yqnd9DK6pCDUpNTcpjUxRfVBJPqy33kjn9gjufRLWRkZJQI8+e+nxz0nna1R0+FGglgOYJiInCAi+QAuA5DU9qUiMltEHmhstHeVSSJKzvzJNfj66YPxl7e348WPYm8wFNA6dE8aGFogev2ezP23q9deSgpCNYhjWu0l2clm0WsxNbX6EyYVKwW7QNCvrND0uRnjqkLnCPDTWaM7vCYTnB7m+jiAZQBGiMhuEblGKeUHcAOAVwBsBPCkUmp9MtdVSr2olLquvLzc/qCJKCk/mTkakwf3wg+eXovNn5vXDPS2+JpeRagqK8SyTw9kLD69EC/O71iDEAFumz066tzYBXqsrUDjidXxbXVoq77ndY/8XMwcV23pNXZyehTT5UqpaqVUnlKqRin1oHZ8kVJquNbfcLuTMRCRs/JzfbjniknoUZiLf390hemcAL2pJccnOG90P7y5uSHmnsx20wv9HloTU7gGgdCwXaNkJvE1tfoTznOI1cSkj6gKBxKDniCKC3JQVW5ey3CSZzqpiSh7VZYV4p4rJmH3oWbc8sSaTp2zekGZ6xPMGt8fze0BPLMqM9va66Hk5/qQlyM4Hq5BCPr0KOhw7vo4s5Wjy/F4iw7qSSlWDcKYIOK1dOkrxpZotZ+BvTO7T1tWJgj2QRB5z8lDeuOns0bjjU31+NPirR2ei9QgfDj1hN6YUFOO+5du67BchVP0QtonoZFM+mKBIkDvko5DXRPtI20UWgk2UjMx851/rjE9rg+5TWRgr2KMHVCG/543znJcdsrKBME+CCJv+vrpgzFv4gD88Y0tWLxpX/i4P5wgQt/cvzt9OHYePI4/L9ka61K20ROEiKCkIDdSg0CoVmG0fEf0vN6I6E5tf1Ch1R9Anx75nc5N1PRUZKxBxDkvP9eHhTeehdOGhnaQ02s8uRb7MNKVlQmCiLxJRHD73HEYVVWG//fUWjQeD/VHGGsQAPCFEf0wd+IA3L1kK5Zsrnc0Jr2VxyeCovyccIKIdsqQ3nhv64G4w1ejHWnxhzu/dc0xrm/UsYkpVNiv/Ml5OCNqK9HoFqr7r5yM3148Hv17ZqapiQmCiGxVlJ+D310yHoePt+F/Xt8CwJAgDN/C/+vLYzGyqhTf/scqfLDNuVFNxiam4vyc8CS96Lb/WROq0RYIYuHavQmvqdc8mlraO11nb2NzwtcXmtQgKnoUoCCqRhM9Ea9faSEuPXkgMiUrEwT7IIi8bUz/clw6ZSAe+3AnGo62dhjFpCspyMVDV52MqvJCfP2hD/GvdZ87EkvQUIMozss1LLLXsWSfPLgXRlWX4a/v7TAd7mpMBPokO7OhrjsOHIs5P0JPAB1GMRlce9bQOL9J5mVlgmAfBJH3XXf2ULQHgnh02Y4Oo5iMKssK8fT1Z2BkdRmu//tK/HrRxg57Pdsh0gcR2RNCf2yMKccnuHrqEGz6/Khps5c+5BQAemrLdDQ2h2oQxt9rW8OxmLHo1yg01BSMieeM2j4dzndyfwkrsjJBEJH3De3bA2cN64vn1+yBX1vnKMdkTaHeJfl44rrTcMWpg3D/W9tw6f3LsLXevqU49EJWRFCc37lpR+/w9Ylg7sQBGNS7GL9/ZUunobrGgry3ttCfvnR4uWFF1h0HjsUcuqr//nnGBBGnm9rl/MAEQUTOmTG2CjsPHse6ulBzsFmCAEJNLrfPHYe7Lp+I7fuPYcb/voM/L/7EltqEMg5zze/cOax/q/dJ6P4t04djw94jWLQuqi/CUFr3KokkBIGE13kSAbbWN3WobRjpM6jzc8xrEF6TlQmCfRBE2eGcEaEVl5dpndCxEoRuzoT+eO3mczB9TCV+/+oWzP7TO1iT5h7YHfog8ju3/euFuZ4wZk/ojxGVpfjDq1s6rFJr/DYfvVS4ft2RVWX4ZF9TzDrB/qbQftzb9sduhurA5TamrEwQ7IMgyg7V5aG1l1bsCG0slChBAEDf0gLc/dVJuP/KyTh0vA1z73kXP1+wPu7M5Xg6jmKKDEnVI8kzNDHpMd48fTi27T+GBYYFCI0d14V5OeHJbiKRlWIH9y7GgWNtCZfs+ChO0htfEynX2MRERF3aSQN7hneRS2ZfgwvGVOG1W87BlacNxl+X7cD0PyzFaxv2JXxdNONEuSKTJS5yfZEmJt35oysxqroMf1q8NVyLMH6ZFwF6FkVqEXoNoqZXaH6C5RoCOjcxLbjhTNwyfXin93QDEwQROWp4ZY/wfV+SG9+UFebhlxeNxTPfOgNlhXm49m8rcP2jK5Pa11rFaGLSO4f1GoRxYT2fT3DTtFps338Mb2wKjWgyltUCCY9kEgBTBocW/Tt1aMeJbqnySrcEEwQROWpIn5Lw/VR3Rps0qBcW3nQmfnDhCCzZXI/z7lyKxz7YGXd5bl30RDmd/s1d74OIzI8ImT66Ev1KC/Dk8tAOyca38knHkUs3TqvF89+eivNG9QsnDqvij2JiHwQRdWHGZSF8aQzZycvx4T/OrcWrN5+N8QPL8Z/PfYzvPflRwqUtjJ3URfmdF9aLJIiOI6Zyc3yYP7kGSzbXd9p32+eTSIIQgc8nOGlgT4gIBveOv31oNLOPRD/GJqYUcBQTUfboWxpZUtuOReYGV5Tg0W+cilumD8dza+pwyf3vdSrAjcJLbkfVIHQ3a+39g032hb5gTBWCCvjVwg1YZ9gFTxB7FdeaZBOE2TGPjH3NygTBUUxE2aNDgkixiSmazye46YvD8H9fn4Kt9U24/IH3UX/UvF8iMg9CTGdSTx9diR13zERpYeemoTH9y1BamIsX1uzBh9sPGl5rmPsQ9ZrqGNuHpoKjmIioSys1fNNOp4nJzBdHVeLhq05B3eFmXPPICtNd6iKd1EBxXudO6nhyc3zhfbSNfBLa5c1Mb5Plv6NNGhS5ZrzaApuYiKhLMxaA+pBSO51+YgXuumwi1u1pxH8++3Gn5ztOlDPMg7CYq4ZUlHQ6JhLaJxpAeBkRXZ+Sgk7nR/vrN06JXMvkeY+0MDFBEFHmOJAfAADnja7ETdOG4dnVdXhlfcdVYRMt1pdIdc/OTUY+QxNT9P4S0bvUGZ02NDQc1ticFS8OjmIioi5v/uQaFOb50LM4cfNLqm6YVouRVaX45Ysb0OqPFNpBQx+EWSd1IoW5nV8T6oMIHT/e2jFBlMTZgvR38ydgxx0zE75nuPmLTUzJ4ygmouzyu/njsfa2C+Lu35yuvBwf/nPGKNQdbsbjH+wMH080US6RApP9o43blbZFDY+Nl4TMh7R2PsgmpjRwFBNRdhGRTvs/O+GsYX0weXAvPPLejvBy3cGYq7lau6bZyCufCPJzQtdq81tPEMniKCYiIpuICL522iDsOHAc730aWkFW76QWkY7LbCdxzWg+iV2DKIpbg7D2rvpZVmaKO4kJgoi6lC+NrUZZYS6eW10HoGMntbGAtlqDMBuaK8YEEVWDKIqxnWgyOJOaiMgBhXk5mDayHxZv2gd/INhholxHyX2b73AsqjZiVGyynEdy72i9f8RpTBBE1OVMG1WJQ8fbsW7PkQ4T5VJhNjQ3GFQx+1QKTTq1kzVrQjX6lhbgitMGp32tdDBBEFGXc9oJofkGy7cf7DBRziidJqb2oEJBjAQhInjs2lNNn7PaYlRdXoTlPz4PJ/TpPEkvk5ggiKjL6VdWiMEVxfhwx8EOfRBGVisUZUWd12jyB4JxR2WdcWKf8D4TRsGg2+OSksMEQURd0oSantiw50h4I6Do7U6tjig6d3hf/G7++A7H/EEVsw8ifH2P9COkIysTBCfKEVEiI6tLUXe4ObwUeHSBXmJxvoKI4JIpAzsca09Qgwi9LvRzomFhvqDbw5KSlJUJghPliCiRUdVlAIC1u0NfJAuihp+aLe9tlT8Qu5NapyeI2788Lnwsy/JDdiYIIqJEhleWAgDW1YUSRHQNIp3RRv6ghRqE1sTUuyQfQ7TNiLIsPzBBEFHXVFVWiPwcHz5taAKATgV6Oru2tQcs9EFol/cZJuixiYmIyANyfIKa3kVoD4QK5VjDUlPhDwQtdFJrP0VMZ0b/9uLxppsReYlzSysSEblscO9ibGs4BiDSxPTU9aej/kjsPaytaA8q+BLMvNNrDT4xX1vp0pMH4tKTB5q80juYIIioyxpcUQKgAXk5Ei7QTx7SO+3rtketv2RGTwo+kfBku+xqYGITExF1YQN7hzqH9WYmuwSsTHjTMoRIZESVHQv5ZRJrEETUZQ3WEoTd2i0kiHCtQQG/uXg8vnrqoHDCyhasQRBRlzW4wqEEYaWJybBraFF+Dk4bWuFILE5igiCiLsvOb+wvf+cs/M9XJgAALjslcedyb23/7WxecCMrm5hEZDaA2bW1tW6HQkQeVpiXg6m1FfjCiH5pX2tUdRlGVZdh7sQaS+f/7ZpTsHhTPXqV5Kf93m4Rt7e0S8eUKVPUihUr3A6DiLqpIbe+BADYccdMlyNJjoisVEpNSXReVtYgiIi84JozT0CxxUX/shETBBFRin46a7TbITiKndRERGSKCYKIiEwxQRARkSkmCCIiMsUEQUREppggiIjIFBMEERGZYoIgIiJTWb3Uhog0APhMe1gOoDHO/eiffQDsT+LtjNe0+nz0MTdjtCO+6FjzkowvEzF69e8c7xj/zt76O8d6riv9nXsqpfomjEAp1SVuAB6Id9/k54pUr2/1+ehjbsZoR3zRMSYbXyZi9OrfOUGs/Dt76O8c67mu+HdOdOtKTUwvJrgf/TOd61t9PvqYmzHaEZ/xvldj9OrfOZs+Q+N9r8aY6fjMjneFv3NcWd3ElA4RWaEsrGboJq/H6PX4AMZoB6/HBzBGp3SlGkSyHnA7AAu8HqPX4wMYox28Hh/AGB3RbWsQREQUX3euQRARURxMEEREZIoJgoiITDFBmBCRc0XkbRG5T0TOdTseMyJSIiIrRGSW27GYEZFR2uf3tIh8y+14zIjIl0XkLyLyhIic73Y8ZkRkqIg8KCJPux2LTvu391fts7vC7XjMePFzM8qGf3tAF0wQIvKQiNSLyLqo4xeKyGYR2Soitya4jALQBKAQwG4PxgcAPwTwpJ2x2RmjUmqjUup6AJcCmOrRGJ9XSl0L4HoAX/FojNuUUtfYHVu0JGOdB+Bp7bOb43RsqcSYqc8tjfgc/bdnm2RnSHr9BuBsAJMArDMcywHwKYChAPIBfARgNIBxABZG3foB8GmvqwTwDw/GNx3AZQCuAjDLi5+h9po5AF4G8FWvxqi97k4Akzwe49Me+u/mRwBO0s55zMm4Uo0xU5+bDfE58m/Prlsuuhil1FsiMiTq8CkAtiqltgGAiPwTwEVKqV8DiNdEcwhAgdfi05q9ShD6j7VZRBYppYJeilG7zgIAC0TkJQCP2RWfXTGKiAC4A8DLSqlVdsZnV4yZkkysCNWqawCsQQZbIZKMcUOm4tIlE5+IbISD//bs0uWamGIYAGCX4fFu7ZgpEZknIvcDeBTAnx2ODUgyPqXUj5VS30Wo0P2LnckhjmQ/w3NF5C7tc1zkdHCapGIEcCOA8wDMF5HrnQzMINnPsUJE7gMwUUR+5HRwUWLF+iyAi0XkXqS+jIRdTGN0+XMzivUZuvFvL2ldrgZhB6XUswj9R+BpSqlH3I4hFqXUmwDedDmMuJRSdwG4y+044lFKHUCondozlFLHAFztdhzxePFzM8qGf3tA96lB1AEYaHhcox3zCq/HBzBGu2RDjLpsiNXrMXo9vri6S4JYDmCYiJwgIvkIdfAucDkmI6/HBzBGu2RDjLpsiNXrMXo9vvjc7iW3+wbgcQB7AbQj1N53jXZ8BoAtCI0o+DHjY4yMMbti9XqMXo8vlRsX6yMiIlPdpYmJiIiSxARBRESmmCCIiMgUEwQREZligiAiIlNMEEREZIoJgroFEQmIyBrDzcqS6hkhoT0zhsZ5/jYR+XXUsZO0Bd8gIq+LSC+n46TuhwmCuotmpdRJhtsd6V5QRNJey0xExgDIUdpqnzE8js57BlymHQdCi0r+R7qxEEVjgqBuTUR2iMgvRGSViHwsIiO14yXaBjAfishqEblIO36ViCwQkcUA3hARn4jcIyKbROQ1EVkkIvNFZJqIPG94n+ki8pxJCFcAeMFw3vkiskyL5ykR6aGU2gLgkIicanjdpYgkiAUALrf3kyFigqDuoyiqicn4jXy/UmoSgHsB/D/t2I8BLFZKnQLgCwB+JyIl2nOTAMxXSp2D0O5qQxDam+NKAKdr5ywBMFJE+mqPrwbwkElcUwGsBAAR6QPgJwDO0+JZAeAW7bzHEao1QEROA3BQKfUJACilDgEoEJGKFD4Xopi43Dd1F81KqZNiPKcv7b4SoQIfAM4HMEdE9IRRCGCQdv81pdRB7f6ZAJ5SoT05PheRJQCglFIi8iiAr4nIwwgljq+bvHc1gAbt/mkIJZp3Q3sZIR/AMu25JwC8JyLfQ8fmJV09gP4ADsT4HYmSxgRBBLRqPwOI/DchAC5WSm02nqg18xyzeN2HEdpQpwWhJOI3OacZoeSjv+drSqlOzUVKqV0ish3AOQAuRqSmoivUrkVkGzYxEZl7BcCN2rakEJGJMc57F6Hd1XwiUgngXP0JpdQeAHsQajZ6OMbrNwKo1e6/D2CqiNRq71kiIsMN5z4O4H8AbFNK7dYPajFWAdiRzC9IlAgTBHUX0X0QiUYx/QpAHoC1IrJee2zmGYSWdt4A4O8AVgFoNDz/DwC7lFIbY7z+JWhJRSnVAOAqAI+LyFqEmpdGGs59CsAYdG5emgzg/Rg1FKKUcblvojRpI42atE7iDwFMVUp9rj33ZwCrlVIPxnhtEUId2lOVUoEU3/9/ASxQSr2R2m9AZI59EETpWygiPRHqVP6VITmsRKi/4nuxXqiUahaR2xDayH5niu+/jsmBnMAaBBERmWIfBBERmWKCICIiU0wQRERkigmCiIhMMUEQEZEpJggiIjL1/wHR9W468kvsQwAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1230,8 +1230,8 @@
     {
      "data": {
       "text/plain": [
-       "{'294K': <openmc.data.function.Tabulated1D at 0x14d02ff8f9b0>,\n",
-       " '0K': <openmc.data.function.Tabulated1D at 0x14d02b7ccc50>}"
+       "{'294K': <openmc.data.function.Tabulated1D at 0x1461b4d2ff60>,\n",
+       " '0K': <openmc.data.function.Tabulated1D at 0x1461b0e59128>}"
       ]
      },
      "execution_count": 36,
@@ -1249,7 +1249,7 @@
    "source": [
     "## Generating data from NJOY\n",
     "\n",
-    "To run OpenMC in continuous-energy mode, you generally need to have ACE files already available that can be converted to OpenMC's native HDF5 format. If you don't already have suitable ACE files or need to generate new data, both the `IncidentNeutron` and `ThermalScattering` classes include `from_njoy()` methods that will run [NJOY](https://njoy.github.io/NJOY2016/) to generate ACE files and then read those files to create OpenMC class instances. The `from_njoy()` methods take as input the name of an ENDF file on disk. By default, it is assumed that you have an executable named `njoy` available on your path. This can be configured with the optional `njoy_exec` argument. Additionally, if you want to show the progress of NJOY as it is running, you can pass `stdout=True`.\n",
+    "To run OpenMC in continuous-energy mode, you generally need to have ACE files already available that can be converted to OpenMC's native HDF5 format. If you don't already have suitable ACE files or need to generate new data, both the `IncidentNeutron` and `ThermalScattering` classes include `from_njoy()` methods that will run [NJOY](https://www.njoy21.io/) to generate ACE files and then read those files to create OpenMC class instances. The `from_njoy()` methods take as input the name of an ENDF file on disk. By default, it is assumed that you have an executable named `njoy` available on your path. This can be configured with the optional `njoy_exec` argument. Additionally, if you want to show the progress of NJOY as it is running, you can pass `stdout=True`.\n",
     "\n",
     "Let's use `IncidentNeutron.from_njoy()` to run NJOY to create data for $^2$H using an ENDF file. We'll specify that we want data specifically at 300, 400, and 500 K."
    ]
@@ -1264,7 +1264,7 @@
      "output_type": "stream",
      "text": [
       "\n",
-      " njoy 2016.44  11Oct18                                       11/09/18 20:25:51\n",
+      " njoy 2016.49  25Jan19                                       07/19/19 06:12:49\n",
       " *****************************************************************************\n",
       "\n",
       " reconr...                                                                0.0s\n",
@@ -1274,21 +1274,23 @@
       "      400.0 deg                                                           0.2s\n",
       "      500.0 deg                                                           0.3s\n",
       "\n",
-      " heatr...                                                                 0.4s\n",
+      " heatr...                                                                 0.3s\n",
       "\n",
-      " purr...                                                                  0.9s\n",
+      " gaspr...                                                                 0.6s\n",
       "\n",
-      " mat =  128                                                               0.9s\n",
+      " purr...                                                                  0.7s\n",
+      "\n",
+      " mat =  128                                                               0.7s\n",
       "\n",
       " ---message from purr---mat  128 has no resonance parameters\n",
       "                          copy as is to nout\n",
       "\n",
-      " acer...                                                                  0.9s\n",
+      " acer...                                                                  0.7s\n",
+      "\n",
+      " acer...                                                                  1.0s\n",
       "\n",
       " acer...                                                                  1.1s\n",
-      "\n",
-      " acer...                                                                  1.3s\n",
-      "                                                                          1.4s\n",
+      "                                                                          1.2s\n",
       " *****************************************************************************\n"
      ]
     }
@@ -1317,10 +1319,10 @@
     {
      "data": {
       "text/plain": [
-       "{'300K': <openmc.data.function.Tabulated1D at 0x14d02ab60ba8>,\n",
-       " '400K': <openmc.data.function.Tabulated1D at 0x14d02b7b64a8>,\n",
-       " '500K': <openmc.data.function.Tabulated1D at 0x14d02b801320>,\n",
-       " '0K': <openmc.data.function.Tabulated1D at 0x14d02b81dba8>}"
+       "{'300K': <openmc.data.function.Tabulated1D at 0x1461b066ebe0>,\n",
+       " '400K': <openmc.data.function.Tabulated1D at 0x1461b23a0978>,\n",
+       " '500K': <openmc.data.function.Tabulated1D at 0x1461b1009400>,\n",
+       " '0K': <openmc.data.function.Tabulated1D at 0x1461b101b358>}"
       ]
      },
      "execution_count": 38,
@@ -1409,7 +1411,7 @@
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x14d02b955cf8>]"
+       "[<matplotlib.lines.Line2D at 0x1461b0ed9978>]"
       ]
      },
      "execution_count": 42,
@@ -1418,7 +1420,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1449,7 +1451,7 @@
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x14d02aac6ac8>]"
+       "[<matplotlib.lines.Line2D at 0x1461b09755c0>]"
       ]
      },
      "execution_count": 43,
@@ -1458,7 +1460,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
diff --git a/examples/jupyter/pandas-dataframes.ipynb b/examples/jupyter/pandas-dataframes.ipynb
index 80a0b880f..7cc2d92e9 100644
--- a/examples/jupyter/pandas-dataframes.ipynb
+++ b/examples/jupyter/pandas-dataframes.ipynb
@@ -99,8 +99,8 @@
    "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",
+    "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",
     "# Use both reflective and vacuum boundaries to make life interesting\n",
@@ -253,7 +253,18 @@
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEVyEhLpgJFNv8T///98iBL0AAAAAWJLR0QDEQxM8gAAAAd0SU1FB+MHEhEuBAW6hPoAAAOeSURBVGje7ZtLkqowFIZPrAsDRz247YAluIosgYEO2h20q3AJDFyAA6wSVnkDCAnkBAK/lH0bTpVVX1mCmsfJRx5E7w6hXn/U64PFWKNkkaIriXNMQWajpNDAO9HJQqJzRmGeUpRLHkVeYOJAEnkut+qT5zxpI/EYtZE26qJI3Uy9x2NY4sOBFDafvNWYD2NSo/H9t6FbJRY+qv///E0GbnowNZGqgkxpX1xf4XkYLzWq+rureyRVpfGYUuBEok/VxI6SxJHFQ4MBi2sEsSoIKktqAlJREUVNhZmscTeMzWVN+4l084h082h6atHApG4/DTrar9AtVdiN1my/Rv9huxLXafJ5+u/G/lIOH1b/3fb9aWdRUKv/GiU9BlUi1vVfYlwm7V5s6j8u2p9UnfHZpsbjGnVOO07CcvxsMm2m06uB93rQbGHajJ++Sb+LW91/s6FBp4sh038njX8hcn3WP/7zP7o9/hf/P9ROEfb7R2ZiVI2fRZletfQkXiieSLSrRCq4u7Dwr28XriGkNt02/rWRLKylN8xaeHKjNJH6pJdHT/+Vbun9f/z3zHbamf13PyS9nP/uLOnlsczKGeO/h0m4RimycrT/fsZt//WQXg55/zWa0oWR3tV/u/7L5S/Wf6389Rr/9ZBeHrXIHliMtfSyuMZOldZX5bS7eBQKheSSXt6fLBWmjrR5Se/qvz7+6y4023/9pJfB0nTpW0uvNyar/5YhZJOpOmj7b2AjRanW29TDf3MD1T08pdelwqv/9viDS3pn89+0i6b/Zl2s/Nfwt9H+++6+8xOi678WPkuKR2IqbVB6o37/3Tv89zLWf33aL9p/5vHf/vzxSv8lxH9v1E7abWSk99pFznRH4eKj8Jevp5McWKxMl8HSX4alt0+Fnf7r4W9bdvwc478v8NeX++/I34+WH1p/cPtZeqD5C82fYP5Gxw90/Pot/jvVX1B/gv1t6YE+P4DPL+jz0+/x32nPz+jzOzp/AM9fCInNnyw90Pk7cP4Qnb9E509f56/T5o/R+Wt0/hydv4fXD5Ye6PoVuH6Grt/N47/+65ezzB+NWL9F14/R9Wt0/Rxev196oPtHwP0r8/iv//6d1X+x/WPw/jUhsf1zSw90/+YZ2z+K7l9d/RfbP43u34b3jy890PMLJ+z8xGv8d/r5kdV/sfNL6Pkp+PzW0gM9PwieX0TPT87rv5P2D/4M//U8v4ueH4bPL6Pnp98b/wAXomzv5H3x5AAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wNy0xOFQyMjo0NjowNC0wNTowMEOkh1cAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDctMThUMjI6NDY6MDQtMDU6MDAy+T/rAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Instantiate a Plot\n",
     "plot = openmc.Plot(plot_id=1)\n",
@@ -263,51 +274,8 @@
     "plot.pixels = [250, 250]\n",
     "plot.color_by = 'material'\n",
     "\n",
-    "# Instantiate a Plots collection and export to \"plots.xml\"\n",
-    "plot_file = openmc.Plots([plot])\n",
-    "plot_file.export_to_xml()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With the plots.xml file, we can now generate and view the plot. OpenMC outputs plots in .ppm format, which can be converted into a compressed format like .png with the convert utility."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run openmc in plotting mode\n",
-    "openmc.plot_geometry(output=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///9yEhLpgJFNv8TqQYT7AAAAAWJLR0QAiAUdSAAAAAd0SU1FB+IKCxApGTbiG9IAAAPZSURBVGje7Zs7buMwEIZ9iey50gyNjQpXKTYudIScgkdQYTfut1idwkdQkQNsYQO2Qj0sPiVK+mlQDmwgwIcgg8Cc4fCTSK5W4OeFkM8rHv+2I/rgxPZEPZgR7XtQxKdXYuUXJSUnBQ/9WCgo4vOSJ+WFUvF7E08mlia+rn7VcKXP8sRszFX8b2MdX2y6v1Tw6MZUw4H4ojfIjD8mvn/qRL5p4+vvlMqvp2EhR8WBzfiz20hXORmP9fi/bM9EeUFvV5H/0yRkeSbiGRfFJErxD9ENdz7Mbhig/h89fvtFdMiI/ePUIXV4lXju8K3DKv9NThOZ3q2KmUy6grxFES8rjeyic+FFQav+ncg3fXjH+Ts+/iibztFqOiZuZP/Z3OafPX40NGgST2r+uvQkXXp6cKvmr+r0e1Eef5um3+JHP3IFF1D/seNZJgaDmvY0Gav1s+2f1fqpIcublfKGt6apotG/NVx3SInWtLX+7Vg/Pv1YqOsnun6JSVdOXT/X7vk75f938QP+8OmSBs0fXtymMhJbf8qlPynYmpKCh7OB1fzNalOj1sl0ZAruHLiA+RM73pDe/VjMVP89+aTXwjyc/x5n+u991895/utrJTy8/06TXh0r/5JOa2JmYmqi4r/vUm/H4wLmT+z4anhr05X+q6KUXhtzr/9qSff5L5uMT//V/NdU4YuBTPa/8P67l/6r44ds+hYuoP5jx9ciy6XTWlibBrmx8V/TdMfjkP+6pOsu/lvM9N90sf7r+f6m/65n+S8p/itN15v0UkW3/+48+PRfJX6S9Joo4g+G/1qYG9KroqP/WypcuvyXPf13wH89/hHef7MB6R3Cqn55U4rv4kfH3zaSgQuYP7HjVf89tXrbO+hfLdr+Ozv/SP1dgtQ/Ov8C+i/3+q/Zf2D/HWi6bjT6rym9I/v/03/b+LHS4cTg/utTsV7/net/Afzz4f0XGX84/2j9xZ4/sePR/of2X7D/o+vPo/sv6h9B/Bfxr9j1Hz2eN/hO8/wfff4A848+f/1A/530/I0+/8PvH9D3H9HnT+R49P0b+v4PfP/4E/wXfP8Mvf9G37/D/ovuP8SeP7Hj0f0vdP8tqP9O339cyv7p3P1fdP8Z3v9G999j13/seMax8x/o+ZN7+O+E8zdP/8XOf8Hnz9Dzb7HnT+x49PxlCp7/BM+fOv13wvnXBfivt2lMvD8TyH/Hnb+Gz3+j589jz5/Y8ej9h4D+W7qQmf57efqv239n3T+C7z+h969i13/seMax+3/o/cMcu/8Y2H9n3p+J6r98pv8m4fwXuH+M3n+OO3++AX9clR+4PhbRAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE4LTEwLTExVDE2OjQxOjI1KzAyOjAwV3beHQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOC0xMC0xMVQxNjo0MToyNSswMjowMCYrZqEAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Convert OpenMC's funky ppm to png\n",
-    "!convert materials-xy.ppm materials-xy.png\n",
-    "\n",
-    "# Display the materials plot inline\n",
-    "Image(filename='materials-xy.png')"
+    "# Show plot\n",
+    "openmc.plot_inline(plot)"
    ]
   },
   {
@@ -319,7 +287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +304,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -370,7 +338,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -396,7 +364,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -419,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -436,122 +404,677 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 16,
    "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",
-      "                   #################     %%%%%%%%%%%%%%%%%\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-2018 MIT and OpenMC contributors\n",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.10.0\n",
-      "          Git SHA1 | 199126b2fcc5cb094f2cc820ae13e1a972cacddd\n",
-      "         Date/Time | 2018-10-11 16:41:25\n",
-      "    OpenMP Threads | 8\n",
+      "           Version | 0.11.0-dev\n",
+      "          Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n",
+      "         Date/Time | 2019-07-18 22:46:04\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 U235 from /home/jan/openmc/nndc_hdf5/U235.h5\n",
-      " Reading U238 from /home/jan/openmc/nndc_hdf5/U238.h5\n",
-      " Reading O16 from /home/jan/openmc/nndc_hdf5/O16.h5\n",
-      " Reading H1 from /home/jan/openmc/nndc_hdf5/H1.h5\n",
-      " Reading B10 from /home/jan/openmc/nndc_hdf5/B10.h5\n",
-      " Reading Zr90 from /home/jan/openmc/nndc_hdf5/Zr90.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for U235\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    0.55921                       \n",
-      "        2/1    0.63816                       \n",
-      "        3/1    0.68834                       \n",
-      "        4/1    0.71192                       \n",
-      "        5/1    0.67935                       \n",
-      "        6/1    0.68254                       \n",
+      "  Bat./Gen.      k            Average k\n",
+      "  =========   ========   ====================\n",
+      "        1/1    0.55921\n",
+      "        2/1    0.63816\n",
+      "        3/1    0.68834\n",
+      "        4/1    0.71192\n",
+      "        5/1    0.67935\n",
+      "        6/1    0.68254\n",
       "        7/1    0.65804    0.67029 +/- 0.01225\n",
       "        8/1    0.66225    0.66761 +/- 0.00756\n",
       "        9/1    0.66336    0.66655 +/- 0.00545\n",
-      "       10/1    0.68037    0.66931 +/- 0.00505\n",
-      "       11/1    0.71728    0.67731 +/- 0.00899\n",
-      "       12/1    0.66098    0.67498 +/- 0.00795\n",
-      "       13/1    0.69969    0.67806 +/- 0.00755\n",
-      "       14/1    0.70998    0.68161 +/- 0.00754\n",
-      "       15/1    0.70092    0.68354 +/- 0.00702\n",
-      "       16/1    0.71586    0.68648 +/- 0.00699\n",
-      "       17/1    0.65949    0.68423 +/- 0.00677\n",
-      "       18/1    0.67696    0.68367 +/- 0.00625\n",
-      "       19/1    0.65444    0.68158 +/- 0.00615\n",
-      "       20/1    0.69766    0.68266 +/- 0.00583\n",
-      " Triggers unsatisfied, max unc./thresh. is 1.17617 for absorption in tally 3\n",
-      " The estimated number of batches is 26\n",
+      "       10/1    0.70686    0.67461 +/- 0.00910\n",
+      "       11/1    0.71753    0.68176 +/- 0.01031\n",
+      "       12/1    0.66967    0.68004 +/- 0.00889\n",
+      "       13/1    0.67800    0.67978 +/- 0.00770\n",
+      "       14/1    0.65634    0.67718 +/- 0.00727\n",
+      "       15/1    0.66891    0.67635 +/- 0.00656\n",
+      "       16/1    0.66281    0.67512 +/- 0.00606\n",
+      "       17/1    0.68160    0.67566 +/- 0.00556\n",
+      "       18/1    0.63835    0.67279 +/- 0.00586\n",
+      "       19/1    0.66200    0.67202 +/- 0.00548\n",
+      "       20/1    0.67156    0.67199 +/- 0.00510\n",
+      " Triggers unsatisfied, max unc./thresh. is 68.3537 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 70089 --- greater than max batches\n",
       " Creating state point statepoint.020.h5...\n",
-      "       21/1    0.64126    0.68007 +/- 0.00603\n",
-      "       22/1    0.69287    0.68082 +/- 0.00572\n",
-      "       23/1    0.70254    0.68203 +/- 0.00552\n",
-      "       24/1    0.68198    0.68203 +/- 0.00523\n",
-      "       25/1    0.67214    0.68153 +/- 0.00498\n",
-      "       26/1    0.68171    0.68154 +/- 0.00474\n",
-      " Triggers satisfied for batch 26\n",
-      " Creating state point statepoint.026.h5...\n",
+      "       21/1    0.67469    0.67216 +/- 0.00478\n",
+      " Triggers unsatisfied, max unc./thresh. is 63.9814 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 65503 --- greater than max batches\n",
+      "       22/1    0.69218    0.67334 +/- 0.00464\n",
+      " Triggers unsatisfied, max unc./thresh. is 64.4829 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 70692 --- greater than max batches\n",
+      "       23/1    0.72838    0.67639 +/- 0.00534\n",
+      " Triggers unsatisfied, max unc./thresh. is 65.1347 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 76371 --- greater than max batches\n",
+      "       24/1    0.68472    0.67683 +/- 0.00507\n",
+      " Triggers unsatisfied, max unc./thresh. is 61.6163 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 72140 --- greater than max batches\n",
+      "       25/1    0.66664    0.67632 +/- 0.00483\n",
+      " Triggers unsatisfied, max unc./thresh. is 59.0208 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 69675 --- greater than max batches\n",
+      "       26/1    0.65315    0.67522 +/- 0.00473\n",
+      " Triggers unsatisfied, max unc./thresh. is 56.5216 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 67094 --- greater than max batches\n",
+      "       27/1    0.63865    0.67356 +/- 0.00480\n",
+      " Triggers unsatisfied, max unc./thresh. is 53.8991 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 63918 --- greater than max batches\n",
+      "       28/1    0.68053    0.67386 +/- 0.00460\n",
+      " Triggers unsatisfied, max unc./thresh. is 51.504 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61017 --- greater than max batches\n",
+      "       29/1    0.71585    0.67561 +/- 0.00474\n",
+      " Triggers unsatisfied, max unc./thresh. is 49.3115 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58364 --- greater than max batches\n",
+      "       30/1    0.67268    0.67549 +/- 0.00455\n",
+      " Triggers unsatisfied, max unc./thresh. is 47.3457 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56046 --- greater than max batches\n",
+      "       31/1    0.67027    0.67529 +/- 0.00437\n",
+      " Triggers unsatisfied, max unc./thresh. is 48.2456 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60524 --- greater than max batches\n",
+      "       32/1    0.67324    0.67522 +/- 0.00421\n",
+      " Triggers unsatisfied, max unc./thresh. is 47.1077 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59922 --- greater than max batches\n",
+      "       33/1    0.66398    0.67481 +/- 0.00408\n",
+      " Triggers unsatisfied, max unc./thresh. is 45.4352 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57807 --- greater than max batches\n",
+      "       34/1    0.66373    0.67443 +/- 0.00395\n",
+      " Triggers unsatisfied, max unc./thresh. is 44.8243 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58273 --- greater than max batches\n",
+      "       35/1    0.68412    0.67476 +/- 0.00383\n",
+      " Triggers unsatisfied, max unc./thresh. is 43.7412 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57404 --- greater than max batches\n",
+      "       36/1    0.66026    0.67429 +/- 0.00374\n",
+      " Triggers unsatisfied, max unc./thresh. is 43.0549 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57471 --- greater than max batches\n",
+      "       37/1    0.67283    0.67424 +/- 0.00362\n",
+      " Triggers unsatisfied, max unc./thresh. is 42.9634 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59073 --- greater than max batches\n",
+      "       38/1    0.69507    0.67487 +/- 0.00356\n",
+      " Triggers unsatisfied, max unc./thresh. is 41.6527 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57259 --- greater than max batches\n",
+      "       39/1    0.68681    0.67522 +/- 0.00347\n",
+      " Triggers unsatisfied, max unc./thresh. is 40.4174 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55547 --- greater than max batches\n",
+      "       40/1    0.65886    0.67476 +/- 0.00340\n",
+      " Triggers unsatisfied, max unc./thresh. is 39.424 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54404 --- greater than max batches\n",
+      "       41/1    0.63736    0.67372 +/- 0.00347\n",
+      " Triggers unsatisfied, max unc./thresh. is 40.094 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57877 --- greater than max batches\n",
+      "       42/1    0.71800    0.67491 +/- 0.00358\n",
+      " Triggers unsatisfied, max unc./thresh. is 39.0603 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56457 --- greater than max batches\n",
+      "       43/1    0.67193    0.67484 +/- 0.00348\n",
+      " Triggers unsatisfied, max unc./thresh. is 38.8448 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57344 --- greater than max batches\n",
+      "       44/1    0.66680    0.67463 +/- 0.00340\n",
+      " Triggers unsatisfied, max unc./thresh. is 38.227 for absorption in tally 3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " WARNING: The estimated number of batches is 56996 --- greater than max batches\n",
+      "       45/1    0.65956    0.67425 +/- 0.00334\n",
+      " Triggers unsatisfied, max unc./thresh. is 37.2591 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55535 --- greater than max batches\n",
+      "       46/1    0.64705    0.67359 +/- 0.00332\n",
+      " Triggers unsatisfied, max unc./thresh. is 37.802 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58594 --- greater than max batches\n",
+      "       47/1    0.67729    0.67368 +/- 0.00324\n",
+      " Triggers unsatisfied, max unc./thresh. is 36.9727 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57419 --- greater than max batches\n",
+      "       48/1    0.68259    0.67389 +/- 0.00317\n",
+      " Triggers unsatisfied, max unc./thresh. is 36.3752 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56901 --- greater than max batches\n",
+      "       49/1    0.64395    0.67320 +/- 0.00317\n",
+      " Triggers unsatisfied, max unc./thresh. is 35.7676 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56296 --- greater than max batches\n",
+      "       50/1    0.68839    0.67354 +/- 0.00312\n",
+      " Triggers unsatisfied, max unc./thresh. is 34.977 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55058 --- greater than max batches\n",
+      "       51/1    0.71108    0.67436 +/- 0.00316\n",
+      " Triggers unsatisfied, max unc./thresh. is 34.453 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54608 --- greater than max batches\n",
+      "       52/1    0.66286    0.67411 +/- 0.00310\n",
+      " Triggers unsatisfied, max unc./thresh. is 33.9781 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54268 --- greater than max batches\n",
+      "       53/1    0.62666    0.67313 +/- 0.00319\n",
+      " Triggers unsatisfied, max unc./thresh. is 33.4946 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 53856 --- greater than max batches\n",
+      "       54/1    0.67124    0.67309 +/- 0.00313\n",
+      " Triggers unsatisfied, max unc./thresh. is 32.8639 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 52927 --- greater than max batches\n",
+      "       55/1    0.67741    0.67317 +/- 0.00306\n",
+      " Triggers unsatisfied, max unc./thresh. is 32.2922 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 52145 --- greater than max batches\n",
+      "       56/1    0.67182    0.67315 +/- 0.00300\n",
+      " Triggers unsatisfied, max unc./thresh. is 31.9136 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 51948 --- greater than max batches\n",
+      "       57/1    0.68764    0.67343 +/- 0.00296\n",
+      " Triggers unsatisfied, max unc./thresh. is 31.3059 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50969 --- greater than max batches\n",
+      "       58/1    0.72310    0.67436 +/- 0.00305\n",
+      " Triggers unsatisfied, max unc./thresh. is 30.8841 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50558 --- greater than max batches\n",
+      "       59/1    0.67689    0.67441 +/- 0.00299\n",
+      " Triggers unsatisfied, max unc./thresh. is 30.5895 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50534 --- greater than max batches\n",
+      "       60/1    0.65890    0.67413 +/- 0.00295\n",
+      " Triggers unsatisfied, max unc./thresh. is 30.0567 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 49693 --- greater than max batches\n",
+      "       61/1    0.69128    0.67443 +/- 0.00291\n",
+      " Triggers unsatisfied, max unc./thresh. is 29.8144 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 49784 --- greater than max batches\n",
+      "       62/1    0.65469    0.67409 +/- 0.00288\n",
+      " Triggers unsatisfied, max unc./thresh. is 29.3138 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 48986 --- greater than max batches\n",
+      "       63/1    0.71839    0.67485 +/- 0.00293\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.9465 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 48604 --- greater than max batches\n",
+      "       64/1    0.69556    0.67520 +/- 0.00291\n",
+      " Triggers unsatisfied, max unc./thresh. is 29.1602 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50174 --- greater than max batches\n",
+      "       65/1    0.70067    0.67563 +/- 0.00289\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.9248 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50204 --- greater than max batches\n",
+      "       66/1    0.67994    0.67570 +/- 0.00284\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.7841 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50545 --- greater than max batches\n",
+      "       67/1    0.74539    0.67682 +/- 0.00301\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.4946 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50346 --- greater than max batches\n",
+      "       68/1    0.67753    0.67683 +/- 0.00296\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.1166 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 49810 --- greater than max batches\n",
+      "       69/1    0.69595    0.67713 +/- 0.00293\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.0441 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50340 --- greater than max batches\n",
+      "       70/1    0.70621    0.67758 +/- 0.00292\n",
+      " Triggers unsatisfied, max unc./thresh. is 27.708 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 49908 --- greater than max batches\n",
+      "       71/1    0.71027    0.67807 +/- 0.00292\n",
+      " Triggers unsatisfied, max unc./thresh. is 27.2979 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 49187 --- greater than max batches\n",
+      "       72/1    0.63710    0.67746 +/- 0.00294\n",
+      " Triggers unsatisfied, max unc./thresh. is 27.3359 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 50071 --- greater than max batches\n",
+      "       73/1    0.70979    0.67794 +/- 0.00294\n",
+      " Triggers unsatisfied, max unc./thresh. is 29.5308 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59306 --- greater than max batches\n",
+      "       74/1    0.65957    0.67767 +/- 0.00291\n",
+      " Triggers unsatisfied, max unc./thresh. is 29.2344 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58976 --- greater than max batches\n",
+      "       75/1    0.66611    0.67751 +/- 0.00287\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.8289 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58183 --- greater than max batches\n",
+      "       76/1    0.66033    0.67726 +/- 0.00284\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.4986 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57670 --- greater than max batches\n",
+      "       77/1    0.68535    0.67738 +/- 0.00280\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.2548 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57486 --- greater than max batches\n",
+      "       78/1    0.71920    0.67795 +/- 0.00282\n",
+      " Triggers unsatisfied, max unc./thresh. is 28.2853 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58410 --- greater than max batches\n",
+      "       79/1    0.67645    0.67793 +/- 0.00278\n",
+      " Triggers unsatisfied, max unc./thresh. is 27.9534 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57829 --- greater than max batches\n",
+      "       80/1    0.68300    0.67800 +/- 0.00275\n",
+      " Triggers unsatisfied, max unc./thresh. is 27.5813 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57060 --- greater than max batches\n",
+      "       81/1    0.69810    0.67826 +/- 0.00272\n",
+      " Triggers unsatisfied, max unc./thresh. is 27.2164 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56301 --- greater than max batches\n",
+      "       82/1    0.68213    0.67831 +/- 0.00269\n",
+      " Triggers unsatisfied, max unc./thresh. is 26.8628 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55570 --- greater than max batches\n",
+      "       83/1    0.68745    0.67843 +/- 0.00265\n",
+      " Triggers unsatisfied, max unc./thresh. is 26.5172 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54852 --- greater than max batches\n",
+      "       84/1    0.65239    0.67810 +/- 0.00264\n",
+      " Triggers unsatisfied, max unc./thresh. is 26.2016 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54241 --- greater than max batches\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "       85/1    0.64990    0.67775 +/- 0.00263\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.9705 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 53963 --- greater than max batches\n",
+      "       86/1    0.68586    0.67785 +/- 0.00260\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.7908 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 53884 --- greater than max batches\n",
+      "       87/1    0.63453    0.67732 +/- 0.00262\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.5271 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 53439 --- greater than max batches\n",
+      "       88/1    0.65402    0.67704 +/- 0.00261\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.321 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 53221 --- greater than max batches\n",
+      "       89/1    0.69063    0.67720 +/- 0.00258\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.8769 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56253 --- greater than max batches\n",
+      "       90/1    0.65729    0.67697 +/- 0.00256\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.7648 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56431 --- greater than max batches\n",
+      "       91/1    0.72355    0.67751 +/- 0.00259\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.5034 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55942 --- greater than max batches\n",
+      "       92/1    0.63010    0.67696 +/- 0.00262\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.2708 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55565 --- greater than max batches\n",
+      "       93/1    0.68610    0.67707 +/- 0.00259\n",
+      " Triggers unsatisfied, max unc./thresh. is 24.9941 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54980 --- greater than max batches\n",
+      "       94/1    0.67618    0.67706 +/- 0.00256\n",
+      " Triggers unsatisfied, max unc./thresh. is 24.7139 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 54365 --- greater than max batches\n",
+      "       95/1    0.68946    0.67719 +/- 0.00253\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.4371 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58240 --- greater than max batches\n",
+      "       96/1    0.70557    0.67751 +/- 0.00252\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.5082 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59216 --- greater than max batches\n",
+      "       97/1    0.64689    0.67717 +/- 0.00252\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.2374 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58603 --- greater than max batches\n",
+      "       98/1    0.70194    0.67744 +/- 0.00251\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.393 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59972 --- greater than max batches\n",
+      "       99/1    0.68278    0.67750 +/- 0.00248\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.5651 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61441 --- greater than max batches\n",
+      "      100/1    0.67066    0.67742 +/- 0.00246\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.3552 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61079 --- greater than max batches\n",
+      "      101/1    0.64907    0.67713 +/- 0.00245\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.3463 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61679 --- greater than max batches\n",
+      "      102/1    0.69810    0.67735 +/- 0.00243\n",
+      " Triggers unsatisfied, max unc./thresh. is 25.1877 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61544 --- greater than max batches\n",
+      "      103/1    0.70659    0.67764 +/- 0.00242\n",
+      " Triggers unsatisfied, max unc./thresh. is 24.9371 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60948 --- greater than max batches\n",
+      "      104/1    0.64152    0.67728 +/- 0.00243\n",
+      " Triggers unsatisfied, max unc./thresh. is 24.6848 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60330 --- greater than max batches\n",
+      "      105/1    0.68117    0.67732 +/- 0.00240\n",
+      " Triggers unsatisfied, max unc./thresh. is 24.4368 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59721 --- greater than max batches\n",
+      "      106/1    0.71963    0.67774 +/- 0.00242\n",
+      " Triggers unsatisfied, max unc./thresh. is 24.2091 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59200 --- greater than max batches\n",
+      "      107/1    0.69488    0.67790 +/- 0.00240\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.9711 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58616 --- greater than max batches\n",
+      "      108/1    0.65697    0.67770 +/- 0.00238\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.8071 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58384 --- greater than max batches\n",
+      "      109/1    0.70032    0.67792 +/- 0.00237\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.5788 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57825 --- greater than max batches\n",
+      "      110/1    0.66571    0.67780 +/- 0.00235\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.5035 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58009 --- greater than max batches\n",
+      "      111/1    0.69676    0.67798 +/- 0.00234\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.3157 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57629 --- greater than max batches\n",
+      "      112/1    0.68219    0.67802 +/- 0.00231\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.1525 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57361 --- greater than max batches\n",
+      "      113/1    0.69025    0.67813 +/- 0.00230\n",
+      " Triggers unsatisfied, max unc./thresh. is 23.0036 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57156 --- greater than max batches\n",
+      "      114/1    0.69241    0.67826 +/- 0.00228\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.792 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56628 --- greater than max batches\n",
+      "      115/1    0.68646    0.67834 +/- 0.00226\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.6864 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56620 --- greater than max batches\n",
+      "      116/1    0.69601    0.67850 +/- 0.00224\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.5007 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 56203 --- greater than max batches\n",
+      "      117/1    0.68761    0.67858 +/- 0.00222\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.3093 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 55749 --- greater than max batches\n",
+      "      118/1    0.71356    0.67889 +/- 0.00223\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.6651 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58054 --- greater than max batches\n",
+      "      119/1    0.69850    0.67906 +/- 0.00221\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.4712 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57570 --- greater than max batches\n",
+      "      120/1    0.70957    0.67933 +/- 0.00221\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.3266 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57331 --- greater than max batches\n",
+      "      121/1    0.69643    0.67947 +/- 0.00220\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.6029 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59269 --- greater than max batches\n",
+      "      122/1    0.67717    0.67945 +/- 0.00218\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.4667 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59062 --- greater than max batches\n",
+      "      123/1    0.68419    0.67949 +/- 0.00216\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.3764 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59089 --- greater than max batches\n",
+      "      124/1    0.69221    0.67960 +/- 0.00214\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.3341 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59364 --- greater than max batches\n",
+      "      125/1    0.73940    0.68010 +/- 0.00218\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.1478 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58868 --- greater than max batches\n",
+      "      126/1    0.66908    0.68001 +/- 0.00217\n",
+      " Triggers unsatisfied, max unc./thresh. is 22.0085 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58615 --- greater than max batches\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      127/1    0.66041    0.67985 +/- 0.00216\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.8274 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58131 --- greater than max batches\n",
+      "      128/1    0.69395    0.67996 +/- 0.00214\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.6537 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57678 --- greater than max batches\n",
+      "      129/1    0.68665    0.68002 +/- 0.00212\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.7739 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58794 --- greater than max batches\n",
+      "      130/1    0.64849    0.67976 +/- 0.00212\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.7492 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59134 --- greater than max batches\n",
+      "      131/1    0.69734    0.67990 +/- 0.00211\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.59 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58738 --- greater than max batches\n",
+      "      132/1    0.69482    0.68002 +/- 0.00210\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.4249 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58302 --- greater than max batches\n",
+      "      133/1    0.68884    0.68009 +/- 0.00208\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.2587 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57853 --- greater than max batches\n",
+      "      134/1    0.63042    0.67971 +/- 0.00210\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.1851 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57902 --- greater than max batches\n",
+      "      135/1    0.69209    0.67980 +/- 0.00209\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.0525 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57623 --- greater than max batches\n",
+      "      136/1    0.69873    0.67995 +/- 0.00208\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.9996 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57774 --- greater than max batches\n",
+      "      137/1    0.70270    0.68012 +/- 0.00207\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.8455 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 57364 --- greater than max batches\n",
+      "      138/1    0.67295    0.68006 +/- 0.00205\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.3716 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60752 --- greater than max batches\n",
+      "      139/1    0.63853    0.67975 +/- 0.00206\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.2124 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60301 --- greater than max batches\n",
+      "      140/1    0.66645    0.67966 +/- 0.00205\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.1279 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60268 --- greater than max batches\n",
+      "      141/1    0.70730    0.67986 +/- 0.00204\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.9845 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59893 --- greater than max batches\n",
+      "      142/1    0.68838    0.67992 +/- 0.00203\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.8774 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59719 --- greater than max batches\n",
+      "      143/1    0.64900    0.67970 +/- 0.00203\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.3772 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 63069 --- greater than max batches\n",
+      "      144/1    0.64490    0.67945 +/- 0.00203\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.2531 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62791 --- greater than max batches\n",
+      "      145/1    0.69221    0.67954 +/- 0.00201\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.2049 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62956 --- greater than max batches\n",
+      "      146/1    0.69481    0.67965 +/- 0.00200\n",
+      " Triggers unsatisfied, max unc./thresh. is 21.0645 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62569 --- greater than max batches\n",
+      "      147/1    0.70394    0.67982 +/- 0.00200\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.9156 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62125 --- greater than max batches\n",
+      "      148/1    0.69482    0.67992 +/- 0.00198\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.7699 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61694 --- greater than max batches\n",
+      "      149/1    0.63886    0.67964 +/- 0.00199\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.6366 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61331 --- greater than max batches\n",
+      "      150/1    0.69377    0.67973 +/- 0.00198\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.5819 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61430 --- greater than max batches\n",
+      "      151/1    0.71045    0.67994 +/- 0.00198\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.5417 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61612 --- greater than max batches\n",
+      "      152/1    0.66093    0.67982 +/- 0.00197\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.4124 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61256 --- greater than max batches\n",
+      "      153/1    0.68564    0.67985 +/- 0.00196\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.3025 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61010 --- greater than max batches\n",
+      "      154/1    0.66961    0.67979 +/- 0.00194\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.2239 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60948 --- greater than max batches\n",
+      "      155/1    0.67099    0.67973 +/- 0.00193\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.0962 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60584 --- greater than max batches\n",
+      "      156/1    0.72742    0.68004 +/- 0.00194\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.9753 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60256 --- greater than max batches\n",
+      "      157/1    0.66458    0.67994 +/- 0.00193\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.8852 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60109 --- greater than max batches\n",
+      "      158/1    0.69052    0.68001 +/- 0.00192\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.7963 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59965 --- greater than max batches\n",
+      "      159/1    0.70643    0.68018 +/- 0.00192\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.6991 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59766 --- greater than max batches\n",
+      "      160/1    0.68576    0.68022 +/- 0.00191\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.6197 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59670 --- greater than max batches\n",
+      "      161/1    0.69854    0.68034 +/- 0.00190\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.8287 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61341 --- greater than max batches\n",
+      "      162/1    0.65983    0.68020 +/- 0.00189\n",
+      " Triggers unsatisfied, max unc./thresh. is 20.0243 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62958 --- greater than max batches\n",
+      "      163/1    0.66316    0.68010 +/- 0.00188\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.8975 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62560 --- greater than max batches\n",
+      "      164/1    0.66179    0.67998 +/- 0.00187\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.895 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62940 --- greater than max batches\n",
+      "      165/1    0.70881    0.68016 +/- 0.00187\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.8013 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62740 --- greater than max batches\n",
+      "      166/1    0.70729    0.68033 +/- 0.00187\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.6876 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62410 --- greater than max batches\n",
+      "      167/1    0.71073    0.68052 +/- 0.00186\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.5695 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 62046 --- greater than max batches\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      168/1    0.69610    0.68061 +/- 0.00185\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.4797 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61857 --- greater than max batches\n",
+      "      169/1    0.67141    0.68056 +/- 0.00184\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.438 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61970 --- greater than max batches\n",
+      "      170/1    0.67727    0.68054 +/- 0.00183\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.3208 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61599 --- greater than max batches\n",
+      "      171/1    0.64150    0.68030 +/- 0.00184\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.2066 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61242 --- greater than max batches\n",
+      "      172/1    0.68758    0.68035 +/- 0.00183\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.114 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61018 --- greater than max batches\n",
+      "      173/1    0.67126    0.68029 +/- 0.00182\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.1545 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61644 --- greater than max batches\n",
+      "      174/1    0.65933    0.68017 +/- 0.00181\n",
+      " Triggers unsatisfied, max unc./thresh. is 19.0415 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 61281 --- greater than max batches\n",
+      "      175/1    0.70572    0.68032 +/- 0.00181\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.9347 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60954 --- greater than max batches\n",
+      "      176/1    0.66175    0.68021 +/- 0.00180\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.8337 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60660 --- greater than max batches\n",
+      "      177/1    0.68714    0.68025 +/- 0.00179\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.7329 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60364 --- greater than max batches\n",
+      "      178/1    0.70181    0.68037 +/- 0.00178\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.6297 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 60048 --- greater than max batches\n",
+      "      179/1    0.66700    0.68030 +/- 0.00177\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.5239 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59711 --- greater than max batches\n",
+      "      180/1    0.68980    0.68035 +/- 0.00176\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.4186 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59374 --- greater than max batches\n",
+      "      181/1    0.69586    0.68044 +/- 0.00176\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.3816 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59473 --- greater than max batches\n",
+      "      182/1    0.68689    0.68048 +/- 0.00175\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.2781 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59139 --- greater than max batches\n",
+      "      183/1    0.69257    0.68054 +/- 0.00174\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.1773 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58819 --- greater than max batches\n",
+      "      184/1    0.69926    0.68065 +/- 0.00173\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.2191 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59422 --- greater than max batches\n",
+      "      185/1    0.67801    0.68063 +/- 0.00172\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.1184 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59096 --- greater than max batches\n",
+      "      186/1    0.67049    0.68058 +/- 0.00171\n",
+      " Triggers unsatisfied, max unc./thresh. is 18.0484 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58965 --- greater than max batches\n",
+      "      187/1    0.68164    0.68058 +/- 0.00170\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.9808 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58848 --- greater than max batches\n",
+      "      188/1    0.66856    0.68052 +/- 0.00170\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.9146 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58736 --- greater than max batches\n",
+      "      189/1    0.71850    0.68073 +/- 0.00170\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.8551 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58665 --- greater than max batches\n",
+      "      190/1    0.67095    0.68067 +/- 0.00169\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.8953 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59250 --- greater than max batches\n",
+      "      191/1    0.70857    0.68082 +/- 0.00169\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.8197 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59068 --- greater than max batches\n",
+      "      192/1    0.65322    0.68067 +/- 0.00169\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.8199 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59387 --- greater than max batches\n",
+      "      193/1    0.67888    0.68066 +/- 0.00168\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.8072 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59620 --- greater than max batches\n",
+      "      194/1    0.72890    0.68092 +/- 0.00169\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.7152 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59319 --- greater than max batches\n",
+      "      195/1    0.64688    0.68074 +/- 0.00169\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.6252 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59029 --- greater than max batches\n",
+      "      196/1    0.68906    0.68078 +/- 0.00168\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.5465 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58810 --- greater than max batches\n",
+      "      197/1    0.69381    0.68085 +/- 0.00167\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.4939 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58764 --- greater than max batches\n",
+      "      198/1    0.70057    0.68095 +/- 0.00167\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.4414 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58717 --- greater than max batches\n",
+      "      199/1    0.67868    0.68094 +/- 0.00166\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.4394 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 59008 --- greater than max batches\n",
+      "      200/1    0.69190    0.68100 +/- 0.00165\n",
+      " Triggers unsatisfied, max unc./thresh. is 17.3511 for absorption in tally 3\n",
+      " WARNING: The estimated number of batches is 58712 --- greater than max batches\n",
+      " Creating state point statepoint.200.h5...\n",
       "\n",
       " =======================>     TIMING STATISTICS     <=======================\n",
       "\n",
-      " Total time for initialization     =  6.5303E-01 seconds\n",
-      "   Reading cross sections          =  5.8105E-01 seconds\n",
-      " Total time in simulation          =  4.6015E+00 seconds\n",
-      "   Time in transport only          =  3.5767E+00 seconds\n",
-      "   Time in inactive batches        =  4.5008E-01 seconds\n",
-      "   Time in active batches          =  4.1514E+00 seconds\n",
-      "   Time synchronizing fission bank =  2.3493E-03 seconds\n",
-      "     Sampling source sites         =  1.7160E-03 seconds\n",
-      "     SEND/RECV source sites        =  4.7010E-04 seconds\n",
-      "   Time accumulating tallies       =  2.3040E-04 seconds\n",
-      " Total time for finalization       =  2.6451E-02 seconds\n",
-      " Total time elapsed                =  5.3123E+00 seconds\n",
-      " Calculation Rate (inactive)       =  27772.9 particles/second\n",
-      " Calculation Rate (active)         =  12646.3 particles/second\n",
+      " Total time for initialization     = 9.3777e-01 seconds\n",
+      "   Reading cross sections          = 8.7757e-01 seconds\n",
+      " Total time in simulation          = 4.0652e+01 seconds\n",
+      "   Time in transport only          = 3.9022e+01 seconds\n",
+      "   Time in inactive batches        = 9.1120e-01 seconds\n",
+      "   Time in active batches          = 3.9741e+01 seconds\n",
+      "   Time synchronizing fission bank = 4.0496e-02 seconds\n",
+      "     Sampling source sites         = 3.3700e-02 seconds\n",
+      "     SEND/RECV source sites        = 6.4404e-03 seconds\n",
+      "   Time accumulating tallies       = 2.0272e-03 seconds\n",
+      " Total time for finalization       = 4.0896e-03 seconds\n",
+      " Total time elapsed                = 4.1621e+01 seconds\n",
+      " Calculation Rate (inactive)       = 13718.1 particles/second\n",
+      " Calculation Rate (active)         = 12267.1 particles/second\n",
       "\n",
       " ============================>     RESULTS     <============================\n",
       "\n",
-      " k-effective (Collision)     =  0.67976 +/-  0.00436\n",
-      " k-effective (Track-length)  =  0.68154 +/-  0.00474\n",
-      " k-effective (Absorption)    =  0.68320 +/-  0.00518\n",
-      " Combined k-effective        =  0.68122 +/-  0.00432\n",
-      " Leakage Fraction            =  0.34011 +/-  0.00283\n",
+      " k-effective (Collision)     = 0.68122 +/- 0.00150\n",
+      " k-effective (Track-length)  = 0.68100 +/- 0.00165\n",
+      " k-effective (Absorption)    = 0.68224 +/- 0.00159\n",
+      " Combined k-effective        = 0.68162 +/- 0.00134\n",
+      " Leakage Fraction            = 0.34047 +/- 0.00082\n",
       "\n"
      ]
     }
@@ -573,7 +1096,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -594,7 +1117,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -629,20 +1152,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[[0.17581417]]\n",
+      "[[[0.16617932]]\n",
       "\n",
-      " [[0.06842901]]\n",
+      " [[0.06455926]]\n",
       "\n",
-      " [[0.30578219]]\n",
+      " [[0.32266365]]\n",
       "\n",
-      " [[0.12436752]]]\n"
+      " [[0.13355528]]]\n"
      ]
     }
    ],
@@ -658,7 +1181,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -710,8 +1233,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>fission</td>\n",
-       "      <td>2.24e-04</td>\n",
-       "      <td>3.94e-05</td>\n",
+       "      <td>1.76e-04</td>\n",
+       "      <td>2.92e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
@@ -721,8 +1244,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>5.46e-04</td>\n",
-       "      <td>9.59e-05</td>\n",
+       "      <td>4.28e-04</td>\n",
+       "      <td>7.12e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
@@ -732,8 +1255,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>fission</td>\n",
-       "      <td>8.42e-05</td>\n",
-       "      <td>6.79e-06</td>\n",
+       "      <td>6.67e-05</td>\n",
+       "      <td>6.94e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -743,8 +1266,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>2.22e-04</td>\n",
-       "      <td>1.65e-05</td>\n",
+       "      <td>1.75e-04</td>\n",
+       "      <td>1.71e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -754,8 +1277,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>fission</td>\n",
-       "      <td>1.85e-04</td>\n",
-       "      <td>2.70e-05</td>\n",
+       "      <td>2.04e-04</td>\n",
+       "      <td>3.80e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
@@ -765,8 +1288,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>4.52e-04</td>\n",
-       "      <td>6.58e-05</td>\n",
+       "      <td>4.96e-04</td>\n",
+       "      <td>9.27e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
@@ -776,8 +1299,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>fission</td>\n",
-       "      <td>6.82e-05</td>\n",
-       "      <td>5.29e-06</td>\n",
+       "      <td>5.76e-05</td>\n",
+       "      <td>6.97e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>7</th>\n",
@@ -787,8 +1310,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>1.81e-04</td>\n",
-       "      <td>1.35e-05</td>\n",
+       "      <td>1.52e-04</td>\n",
+       "      <td>1.91e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>8</th>\n",
@@ -798,8 +1321,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>fission</td>\n",
-       "      <td>2.05e-04</td>\n",
-       "      <td>2.25e-05</td>\n",
+       "      <td>1.80e-04</td>\n",
+       "      <td>3.15e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>9</th>\n",
@@ -809,8 +1332,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>5.00e-04</td>\n",
-       "      <td>5.49e-05</td>\n",
+       "      <td>4.38e-04</td>\n",
+       "      <td>7.68e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>10</th>\n",
@@ -820,8 +1343,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>fission</td>\n",
-       "      <td>7.53e-05</td>\n",
-       "      <td>7.06e-06</td>\n",
+       "      <td>7.19e-05</td>\n",
+       "      <td>9.68e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>11</th>\n",
@@ -831,8 +1354,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>1.99e-04</td>\n",
-       "      <td>1.81e-05</td>\n",
+       "      <td>1.89e-04</td>\n",
+       "      <td>2.49e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>12</th>\n",
@@ -842,8 +1365,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>fission</td>\n",
-       "      <td>2.06e-04</td>\n",
-       "      <td>2.79e-05</td>\n",
+       "      <td>1.91e-04</td>\n",
+       "      <td>3.67e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>13</th>\n",
@@ -853,8 +1376,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>5.03e-04</td>\n",
-       "      <td>6.80e-05</td>\n",
+       "      <td>4.66e-04</td>\n",
+       "      <td>8.93e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>14</th>\n",
@@ -864,8 +1387,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>fission</td>\n",
-       "      <td>6.65e-05</td>\n",
-       "      <td>3.91e-06</td>\n",
+       "      <td>6.78e-05</td>\n",
+       "      <td>9.81e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>15</th>\n",
@@ -875,8 +1398,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>1.75e-04</td>\n",
-       "      <td>1.04e-05</td>\n",
+       "      <td>1.76e-04</td>\n",
+       "      <td>2.44e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>16</th>\n",
@@ -886,8 +1409,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>fission</td>\n",
-       "      <td>2.03e-04</td>\n",
-       "      <td>2.78e-05</td>\n",
+       "      <td>1.56e-04</td>\n",
+       "      <td>2.32e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>17</th>\n",
@@ -897,8 +1420,8 @@
        "      <td>0.00e+00</td>\n",
        "      <td>6.25e-01</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>4.94e-04</td>\n",
-       "      <td>6.78e-05</td>\n",
+       "      <td>3.81e-04</td>\n",
+       "      <td>5.65e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>18</th>\n",
@@ -908,8 +1431,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>fission</td>\n",
-       "      <td>6.26e-05</td>\n",
-       "      <td>5.71e-06</td>\n",
+       "      <td>6.28e-05</td>\n",
+       "      <td>8.06e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>19</th>\n",
@@ -919,8 +1442,8 @@
        "      <td>6.25e-01</td>\n",
        "      <td>2.00e+07</td>\n",
        "      <td>nu-fission</td>\n",
-       "      <td>1.64e-04</td>\n",
-       "      <td>1.53e-05</td>\n",
+       "      <td>1.62e-04</td>\n",
+       "      <td>2.05e-05</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -929,52 +1452,52 @@
       "text/plain": [
        "   mesh 1       energy low [eV] energy high [eV]       score     mean  \\\n",
        "        x  y  z                                                         \n",
-       "0       1  1  1        0.00e+00         6.25e-01     fission 2.24e-04   \n",
-       "1       1  1  1        0.00e+00         6.25e-01  nu-fission 5.46e-04   \n",
-       "2       1  1  1        6.25e-01         2.00e+07     fission 8.42e-05   \n",
-       "3       1  1  1        6.25e-01         2.00e+07  nu-fission 2.22e-04   \n",
-       "4       2  1  1        0.00e+00         6.25e-01     fission 1.85e-04   \n",
-       "5       2  1  1        0.00e+00         6.25e-01  nu-fission 4.52e-04   \n",
-       "6       2  1  1        6.25e-01         2.00e+07     fission 6.82e-05   \n",
-       "7       2  1  1        6.25e-01         2.00e+07  nu-fission 1.81e-04   \n",
-       "8       3  1  1        0.00e+00         6.25e-01     fission 2.05e-04   \n",
-       "9       3  1  1        0.00e+00         6.25e-01  nu-fission 5.00e-04   \n",
-       "10      3  1  1        6.25e-01         2.00e+07     fission 7.53e-05   \n",
-       "11      3  1  1        6.25e-01         2.00e+07  nu-fission 1.99e-04   \n",
-       "12      4  1  1        0.00e+00         6.25e-01     fission 2.06e-04   \n",
-       "13      4  1  1        0.00e+00         6.25e-01  nu-fission 5.03e-04   \n",
-       "14      4  1  1        6.25e-01         2.00e+07     fission 6.65e-05   \n",
-       "15      4  1  1        6.25e-01         2.00e+07  nu-fission 1.75e-04   \n",
-       "16      5  1  1        0.00e+00         6.25e-01     fission 2.03e-04   \n",
-       "17      5  1  1        0.00e+00         6.25e-01  nu-fission 4.94e-04   \n",
-       "18      5  1  1        6.25e-01         2.00e+07     fission 6.26e-05   \n",
-       "19      5  1  1        6.25e-01         2.00e+07  nu-fission 1.64e-04   \n",
+       "0       1  1  1        0.00e+00         6.25e-01     fission 1.76e-04   \n",
+       "1       1  1  1        0.00e+00         6.25e-01  nu-fission 4.28e-04   \n",
+       "2       1  1  1        6.25e-01         2.00e+07     fission 6.67e-05   \n",
+       "3       1  1  1        6.25e-01         2.00e+07  nu-fission 1.75e-04   \n",
+       "4       2  1  1        0.00e+00         6.25e-01     fission 2.04e-04   \n",
+       "5       2  1  1        0.00e+00         6.25e-01  nu-fission 4.96e-04   \n",
+       "6       2  1  1        6.25e-01         2.00e+07     fission 5.76e-05   \n",
+       "7       2  1  1        6.25e-01         2.00e+07  nu-fission 1.52e-04   \n",
+       "8       3  1  1        0.00e+00         6.25e-01     fission 1.80e-04   \n",
+       "9       3  1  1        0.00e+00         6.25e-01  nu-fission 4.38e-04   \n",
+       "10      3  1  1        6.25e-01         2.00e+07     fission 7.19e-05   \n",
+       "11      3  1  1        6.25e-01         2.00e+07  nu-fission 1.89e-04   \n",
+       "12      4  1  1        0.00e+00         6.25e-01     fission 1.91e-04   \n",
+       "13      4  1  1        0.00e+00         6.25e-01  nu-fission 4.66e-04   \n",
+       "14      4  1  1        6.25e-01         2.00e+07     fission 6.78e-05   \n",
+       "15      4  1  1        6.25e-01         2.00e+07  nu-fission 1.76e-04   \n",
+       "16      5  1  1        0.00e+00         6.25e-01     fission 1.56e-04   \n",
+       "17      5  1  1        0.00e+00         6.25e-01  nu-fission 3.81e-04   \n",
+       "18      5  1  1        6.25e-01         2.00e+07     fission 6.28e-05   \n",
+       "19      5  1  1        6.25e-01         2.00e+07  nu-fission 1.62e-04   \n",
        "\n",
        "   std. dev.  \n",
        "              \n",
-       "0   3.94e-05  \n",
-       "1   9.59e-05  \n",
-       "2   6.79e-06  \n",
-       "3   1.65e-05  \n",
-       "4   2.70e-05  \n",
-       "5   6.58e-05  \n",
-       "6   5.29e-06  \n",
-       "7   1.35e-05  \n",
-       "8   2.25e-05  \n",
-       "9   5.49e-05  \n",
-       "10  7.06e-06  \n",
-       "11  1.81e-05  \n",
-       "12  2.79e-05  \n",
-       "13  6.80e-05  \n",
-       "14  3.91e-06  \n",
-       "15  1.04e-05  \n",
-       "16  2.78e-05  \n",
-       "17  6.78e-05  \n",
-       "18  5.71e-06  \n",
-       "19  1.53e-05  "
+       "0   2.92e-05  \n",
+       "1   7.12e-05  \n",
+       "2   6.94e-06  \n",
+       "3   1.71e-05  \n",
+       "4   3.80e-05  \n",
+       "5   9.27e-05  \n",
+       "6   6.97e-06  \n",
+       "7   1.91e-05  \n",
+       "8   3.15e-05  \n",
+       "9   7.68e-05  \n",
+       "10  9.68e-06  \n",
+       "11  2.49e-05  \n",
+       "12  3.67e-05  \n",
+       "13  8.93e-05  \n",
+       "14  9.81e-06  \n",
+       "15  2.44e-05  \n",
+       "16  2.32e-05  \n",
+       "17  5.65e-05  \n",
+       "18  8.06e-06  \n",
+       "19  2.05e-05  "
       ]
      },
-     "execution_count": 22,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -992,12 +1515,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1016,22 +1539,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7f39196c0b00>"
+       "<matplotlib.colorbar.Colorbar at 0x15494902cf28>"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -1066,7 +1589,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -1094,7 +1617,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -1131,8 +1654,8 @@
        "      <td>1</td>\n",
        "      <td>U235</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>3.81e-02</td>\n",
-       "      <td>1.65e-04</td>\n",
+       "      <td>3.80e-02</td>\n",
+       "      <td>1.33e-04</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
@@ -1140,7 +1663,7 @@
        "      <td>U238</td>\n",
        "      <td>scatter</td>\n",
        "      <td>2.33e+00</td>\n",
-       "      <td>9.59e-03</td>\n",
+       "      <td>8.12e-03</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1148,11 +1671,11 @@
       ],
       "text/plain": [
        "   cell nuclide    score     mean  std. dev.\n",
-       "0     1    U235  scatter 3.81e-02   1.65e-04\n",
-       "1     1    U238  scatter 2.33e+00   9.59e-03"
+       "0     1    U235  scatter 3.80e-02   1.33e-04\n",
+       "1     1    U238  scatter 2.33e+00   8.12e-03"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1174,15 +1697,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[[0.00958717]\n",
-      "  [0.00016469]]]\n"
+      "[[[0.00811746]\n",
+      "  [0.00013266]]]\n"
      ]
     }
    ],
@@ -1202,7 +1725,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -1237,32 +1760,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[[0.03500496]]\n",
+      "[[[0.04347272]]\n",
       "\n",
-      " [[0.02745568]]\n",
+      " [[0.04671736]]\n",
       "\n",
-      " [[0.02988488]]\n",
+      " [[0.04878286]]\n",
       "\n",
-      " [[0.04474905]]\n",
+      " [[0.03059582]]\n",
       "\n",
-      " [[0.03697764]]\n",
+      " [[0.04548096]]\n",
       "\n",
-      " [[0.0409214 ]]\n",
+      " [[0.04288085]]\n",
       "\n",
-      " [[0.03366461]]\n",
+      " [[0.02557663]]\n",
       "\n",
-      " [[0.03210393]]\n",
+      " [[0.0419826 ]]\n",
       "\n",
-      " [[0.03216398]]\n",
+      " [[0.05878954]]\n",
       "\n",
-      " [[0.04003553]]]\n"
+      " [[0.04217666]]]\n"
      ]
     }
    ],
@@ -1283,7 +1806,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
@@ -1354,8 +1877,8 @@
        "      <td>3</td>\n",
        "      <td>279</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>6.81e-04</td>\n",
-       "      <td>2.84e-05</td>\n",
+       "      <td>6.26e-04</td>\n",
+       "      <td>4.62e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>559</th>\n",
@@ -1368,8 +1891,8 @@
        "      <td>3</td>\n",
        "      <td>279</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>8.82e-02</td>\n",
-       "      <td>1.86e-03</td>\n",
+       "      <td>8.73e-02</td>\n",
+       "      <td>2.14e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>560</th>\n",
@@ -1382,8 +1905,8 @@
        "      <td>3</td>\n",
        "      <td>280</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>6.65e-04</td>\n",
-       "      <td>3.46e-05</td>\n",
+       "      <td>6.15e-04</td>\n",
+       "      <td>3.12e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>561</th>\n",
@@ -1396,8 +1919,8 @@
        "      <td>3</td>\n",
        "      <td>280</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>8.37e-02</td>\n",
-       "      <td>2.02e-03</td>\n",
+       "      <td>8.06e-02</td>\n",
+       "      <td>1.85e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>562</th>\n",
@@ -1410,8 +1933,8 @@
        "      <td>3</td>\n",
        "      <td>281</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>5.61e-04</td>\n",
-       "      <td>2.91e-05</td>\n",
+       "      <td>6.36e-04</td>\n",
+       "      <td>4.24e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>563</th>\n",
@@ -1424,8 +1947,8 @@
        "      <td>3</td>\n",
        "      <td>281</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>7.52e-02</td>\n",
-       "      <td>1.79e-03</td>\n",
+       "      <td>7.59e-02</td>\n",
+       "      <td>1.93e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>564</th>\n",
@@ -1438,8 +1961,8 @@
        "      <td>3</td>\n",
        "      <td>282</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>4.77e-04</td>\n",
-       "      <td>2.33e-05</td>\n",
+       "      <td>5.30e-04</td>\n",
+       "      <td>2.75e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>565</th>\n",
@@ -1452,8 +1975,8 @@
        "      <td>3</td>\n",
        "      <td>282</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>6.68e-02</td>\n",
-       "      <td>1.14e-03</td>\n",
+       "      <td>6.82e-02</td>\n",
+       "      <td>1.02e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>566</th>\n",
@@ -1466,8 +1989,8 @@
        "      <td>3</td>\n",
        "      <td>283</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>4.64e-04</td>\n",
-       "      <td>2.05e-05</td>\n",
+       "      <td>4.67e-04</td>\n",
+       "      <td>2.84e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>567</th>\n",
@@ -1480,8 +2003,8 @@
        "      <td>3</td>\n",
        "      <td>283</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>6.20e-02</td>\n",
-       "      <td>1.61e-03</td>\n",
+       "      <td>6.42e-02</td>\n",
+       "      <td>1.81e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>568</th>\n",
@@ -1494,8 +2017,8 @@
        "      <td>3</td>\n",
        "      <td>284</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>4.44e-04</td>\n",
-       "      <td>2.93e-05</td>\n",
+       "      <td>4.52e-04</td>\n",
+       "      <td>2.13e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>569</th>\n",
@@ -1508,8 +2031,8 @@
        "      <td>3</td>\n",
        "      <td>284</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>5.47e-02</td>\n",
-       "      <td>1.53e-03</td>\n",
+       "      <td>5.64e-02</td>\n",
+       "      <td>1.20e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>570</th>\n",
@@ -1522,8 +2045,8 @@
        "      <td>3</td>\n",
        "      <td>285</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>3.67e-04</td>\n",
-       "      <td>2.63e-05</td>\n",
+       "      <td>3.85e-04</td>\n",
+       "      <td>1.99e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>571</th>\n",
@@ -1536,8 +2059,8 @@
        "      <td>3</td>\n",
        "      <td>285</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>4.68e-02</td>\n",
-       "      <td>1.52e-03</td>\n",
+       "      <td>4.86e-02</td>\n",
+       "      <td>1.58e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>572</th>\n",
@@ -1550,8 +2073,8 @@
        "      <td>3</td>\n",
        "      <td>286</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>2.76e-04</td>\n",
-       "      <td>1.75e-05</td>\n",
+       "      <td>2.84e-04</td>\n",
+       "      <td>2.16e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>573</th>\n",
@@ -1564,8 +2087,8 @@
        "      <td>3</td>\n",
        "      <td>286</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>3.81e-02</td>\n",
-       "      <td>1.28e-03</td>\n",
+       "      <td>3.91e-02</td>\n",
+       "      <td>1.66e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>574</th>\n",
@@ -1578,8 +2101,8 @@
        "      <td>3</td>\n",
        "      <td>287</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>2.08e-04</td>\n",
-       "      <td>1.69e-05</td>\n",
+       "      <td>2.17e-04</td>\n",
+       "      <td>2.15e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>575</th>\n",
@@ -1592,8 +2115,8 @@
        "      <td>3</td>\n",
        "      <td>287</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>2.85e-02</td>\n",
-       "      <td>1.13e-03</td>\n",
+       "      <td>3.02e-02</td>\n",
+       "      <td>1.71e-03</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>576</th>\n",
@@ -1606,8 +2129,8 @@
        "      <td>3</td>\n",
        "      <td>288</td>\n",
        "      <td>absorption</td>\n",
-       "      <td>1.32e-04</td>\n",
-       "      <td>1.30e-05</td>\n",
+       "      <td>1.50e-04</td>\n",
+       "      <td>1.42e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>577</th>\n",
@@ -1620,8 +2143,8 @@
        "      <td>3</td>\n",
        "      <td>288</td>\n",
        "      <td>scatter</td>\n",
-       "      <td>1.86e-02</td>\n",
-       "      <td>7.12e-04</td>\n",
+       "      <td>1.89e-02</td>\n",
+       "      <td>9.31e-04</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1655,29 +2178,29 @@
        "        mean std. dev.  \n",
        "                        \n",
        "                        \n",
-       "558 6.81e-04  2.84e-05  \n",
-       "559 8.82e-02  1.86e-03  \n",
-       "560 6.65e-04  3.46e-05  \n",
-       "561 8.37e-02  2.02e-03  \n",
-       "562 5.61e-04  2.91e-05  \n",
-       "563 7.52e-02  1.79e-03  \n",
-       "564 4.77e-04  2.33e-05  \n",
-       "565 6.68e-02  1.14e-03  \n",
-       "566 4.64e-04  2.05e-05  \n",
-       "567 6.20e-02  1.61e-03  \n",
-       "568 4.44e-04  2.93e-05  \n",
-       "569 5.47e-02  1.53e-03  \n",
-       "570 3.67e-04  2.63e-05  \n",
-       "571 4.68e-02  1.52e-03  \n",
-       "572 2.76e-04  1.75e-05  \n",
-       "573 3.81e-02  1.28e-03  \n",
-       "574 2.08e-04  1.69e-05  \n",
-       "575 2.85e-02  1.13e-03  \n",
-       "576 1.32e-04  1.30e-05  \n",
-       "577 1.86e-02  7.12e-04  "
+       "558 6.26e-04  4.62e-05  \n",
+       "559 8.73e-02  2.14e-03  \n",
+       "560 6.15e-04  3.12e-05  \n",
+       "561 8.06e-02  1.85e-03  \n",
+       "562 6.36e-04  4.24e-05  \n",
+       "563 7.59e-02  1.93e-03  \n",
+       "564 5.30e-04  2.75e-05  \n",
+       "565 6.82e-02  1.02e-03  \n",
+       "566 4.67e-04  2.84e-05  \n",
+       "567 6.42e-02  1.81e-03  \n",
+       "568 4.52e-04  2.13e-05  \n",
+       "569 5.64e-02  1.20e-03  \n",
+       "570 3.85e-04  1.99e-05  \n",
+       "571 4.86e-02  1.58e-03  \n",
+       "572 2.84e-04  2.16e-05  \n",
+       "573 3.91e-02  1.66e-03  \n",
+       "574 2.17e-04  2.15e-05  \n",
+       "575 3.02e-02  1.71e-03  \n",
+       "576 1.50e-04  1.42e-05  \n",
+       "577 1.89e-02  9.31e-04  "
       ]
      },
-     "execution_count": 30,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1692,7 +2215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
@@ -1738,38 +2261,38 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>mean</th>\n",
-       "      <td>4.17e-04</td>\n",
-       "      <td>2.05e-05</td>\n",
+       "      <td>4.15e-04</td>\n",
+       "      <td>2.29e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
-       "      <td>2.42e-04</td>\n",
-       "      <td>8.32e-06</td>\n",
+       "      <td>2.33e-04</td>\n",
+       "      <td>9.14e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>min</th>\n",
-       "      <td>2.27e-05</td>\n",
-       "      <td>4.04e-06</td>\n",
+       "      <td>1.84e-05</td>\n",
+       "      <td>3.31e-06</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25%</th>\n",
-       "      <td>2.01e-04</td>\n",
-       "      <td>1.40e-05</td>\n",
+       "      <td>2.08e-04</td>\n",
+       "      <td>1.58e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
-       "      <td>4.00e-04</td>\n",
-       "      <td>2.05e-05</td>\n",
+       "      <td>4.10e-04</td>\n",
+       "      <td>2.24e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>75%</th>\n",
-       "      <td>6.08e-04</td>\n",
-       "      <td>2.60e-05</td>\n",
+       "      <td>6.25e-04</td>\n",
+       "      <td>2.93e-05</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>max</th>\n",
-       "      <td>9.38e-04</td>\n",
-       "      <td>4.27e-05</td>\n",
+       "      <td>8.87e-04</td>\n",
+       "      <td>5.06e-05</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1780,16 +2303,16 @@
        "                        \n",
        "                        \n",
        "count 2.89e+02  2.89e+02\n",
-       "mean  4.17e-04  2.05e-05\n",
-       "std   2.42e-04  8.32e-06\n",
-       "min   2.27e-05  4.04e-06\n",
-       "25%   2.01e-04  1.40e-05\n",
-       "50%   4.00e-04  2.05e-05\n",
-       "75%   6.08e-04  2.60e-05\n",
-       "max   9.38e-04  4.27e-05"
+       "mean  4.15e-04  2.29e-05\n",
+       "std   2.33e-04  9.14e-06\n",
+       "min   1.84e-05  3.31e-06\n",
+       "25%   2.08e-04  1.58e-05\n",
+       "50%   4.10e-04  2.24e-05\n",
+       "75%   6.25e-04  2.93e-05\n",
+       "max   8.87e-04  5.06e-05"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1812,14 +2335,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Mann-Whitney Test p-value: 0.3933685843661936\n"
+      "Mann-Whitney Test p-value: 0.3531165056829588\n"
      ]
     }
    ],
@@ -1848,14 +2371,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Mann-Whitney Test p-value: 7.927841393301949e-42\n"
+      "Mann-Whitney Test p-value: 2.835784441937541e-42\n"
      ]
     }
    ],
@@ -1882,14 +2405,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/jan/.local/lib/python3.6/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
+      "/home/romano/.pyenv/versions/3.7.0/lib/python3.7/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
       "A value is trying to be set on a copy of a slice from a DataFrame.\n",
       "Try using .loc[row_indexer,col_indexer] = value instead\n",
       "\n",
@@ -1900,16 +2423,16 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7f39195e74e0>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x154948ffb160>"
       ]
      },
-     "execution_count": 34,
+     "execution_count": 32,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1932,22 +2455,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f39195d7cf8>"
+       "<matplotlib.legend.Legend at 0x154948f326a0>"
       ]
      },
-     "execution_count": 35,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzt3XmUFPW5xvHv2z0zgIAoi4iyiUEUZRUUiRgQF9ALbhjFjZhEo9FojJrgkkS90UOiiVE0QY2oERRJvBEE4wZBJaIIyCZgUBbBFVFWgZnpfu8fVZARZ6CZme6a6Xo+5/SZ7tr6rZqZfrp+VfUrc3dERCS+ElEXICIi0VIQiIjEnIJARCTmFAQiIjGnIBARiTkFgYhIzCkIRDJgZjea2V+irkMkGxQEEhkzO9bMXjez9Wb2hZn928x6VnGZ3zOz6TsNe9TMflOV5br7He7+w6osoyJm5ma22cw2mdmHZvYHM0tmOG9fM1udjbokPhQEEgkz2xuYBIwEGgMHArcC26KsqzxmVpCDt+ni7g2A7wDnAN/PwXuKAAoCic4hAO7+pLun3H2Lu7/o7vO3T2Bml5jZYjPbaGaLzKx7OHy4mb1fZvgZ4fDDgFHAMeG363VmdilwPvDzcNiz4bQHmNnTZrbGzJab2VVl3vcWM/u7mY0xsw3A98JhY8LxbcNv8cPM7AMz+9zMbiozfz0ze8zMvgzr/3mm39rd/T3g30DXMsu7uMx2WGZmPwqH1wf+CRwQrtumcL0SZbbRWjMbb2aNw3nqhuu1Ntw+b5lZ8z3+7UleURBIVP4DpMIPzIFmtm/ZkWZ2NnALcBGwNzAYWBuOfh/oAzQi2IsYY2Yt3H0xcBkww90buPs+7v4gMBb4XThskJklgGeBeQR7Iv2Bn5rZyWVKOA34O7BPOH95jgU6hPP/KgwigF8DbYF2wInABZluFDM7NFy398oM/gz4n3A7XAzcbWbd3X0zMBD4KFy3Bu7+EfAT4HSCvYsDgC+B+8NlDQu3WyugSbi9tmRan+QnBYFEwt03EHyQOvAQsMbMJpb5dvpDgg/vtzzwnruvDOf9m7t/5O5pd38KWAoctQdv3xNo5u63uXuxuy8Lazi3zDQz3P2Z8D0q+qC8NdyTmUcQKl3C4d8F7nD3L919NXBvBjXNMbPNwGJgGvCn7SPcfbK7vx9uh1eAFwnCoiKXATe5+2p330YQqEPCJq4SggD4VrgnNjv8XUiMKQgkMu6+2N2/5+4tgSMIvr3+MRzdiuCb/zeY2UVmNjds2lgXztt0D966DUFzyroyy7gRKNtEsiqD5XxS5vlXQIPw+QE7zZ/JsrqH858DHA3U3z4i3GN6Izygvg44hV2vbxvgH2XWbTGQIli/x4EXgHFm9pGZ/c7MCjOoT/KYgkBqBHdfAjxK8KEOwYfnwTtPZ2ZtCL69Xwk0cfd9gIWAbV9UeYvf6fUqYHnYdLT90dDdT9nFPHviY6BlmdetMpkp/MY/HpgB/ArAzOoATwN3Ac3D9X2OXa/vKmDgTutX190/dPcSd7/V3TsCvQmanC6qxDpKHlEQSCTM7FAzu9bMWoavWwFDgTfCSf4CXGdmR1rgW2EI1Cf48FsTzncx/w0PgE+BlmZWtNOwdmVezwQ2mtkvwgO7STM7oqqnrpYxHrjBzPY1swMJQmtPjAAuMbP9gSKgDsH6lprZQOCkMtN+CjQxs0Zlho0Cbg+3F2bWzMxOC5/3M7NOFpyeuoGgqSi956so+URBIFHZSNAE8mbYNv4GwTf7ayE4DgDcDjwRTvsM0NjdFwG/J/jW/CnQieAsm+2mAu8An5jZ5+Gwh4GOYVPJM+6eIvgm3BVYDnxOEDxlP0yr4jZgdbjslwkOOmd8Wqy7LwBeBa53943AVQTh8iVwHjCxzLRLgCeBZeH6HQDcE07zopltJNi2R4ez7B/Ws4GgyegVguYiiTHTjWlEssvMLgfOdffvRF2LSHm0RyBSzcyshZl9OzyfvwPBXs4/oq5LpCK5uGJSJG6KgAeAg4B1wDjKnA4qUtOoaUhEJObUNCQiEnO1ommoadOm3rZt26jLEBGpVWbPnv25uzfb3XS1Igjatm3LrFmzoi5DRKRWMbOVmUynpiERkZhTEIiIxJyCQEQk5mrFMQIRqf1KSkpYvXo1W7dujbqUvFO3bl1atmxJYWHlOpJVEIhITqxevZqGDRvStm1bzGz3M0hG3J21a9eyevVqDjrooEotQ01DIpITW7dupUmTJgqBamZmNGnSpEp7WgoCEckZhUB2VHW7KghERGJOQSAisdGgQYMdz5977jkOOeQQVq5cyS233MKBBx5I165dad++PWeeeSaLFi3aMW3fvn3p0KEDXbt2pWvXrgwZMiSK8rNGB4sla9oOn1zu8BUjTs1xJSJfN2XKFK666ipeeOEF2rRpA8A111zDddddB8BTTz3F8ccfz4IFC2jWLOihYezYsfTo0SOymrNJewQiEiuvvvoql1xyCZMmTeLgg79xW2wAzjnnHE466SSeeOKJHFcXDe0RiEju/XM4fLKgepe5fycYOGKXk2zbto3TTz+dadOmceihh+5y2u7du7NkyZIdr88//3zq1asHwIknnsidd95Z9ZprCAWBiMRGYWEhvXv35uGHH+aee+7Z5bQ736sln5uGFAQiknu7+eaeLYlEgvHjx9O/f3/uuOMObrzxxgqnffvtt/P2g39nOkYgIrGy1157MXnyZMaOHcvDDz9c7jRPP/00L774IkOHDs1xddHQHoGIxE7jxo15/vnnOe6443acFXT33XczZswYNm/ezBFHHMHUqVN3jIOvHyNo2rQpL7/8ciS1Z4OCQERiY9OmTTuet2rViuXLlwMwePBgbrnllgrnmzZtWpYri5aahkREYk57BFJj6AI0kWhoj0BEJOYUBCIiMacgEBGJOQWBiEjM6WCxiESiopMDKiuTkwoaNGjwtVNIH330UWbNmsV9993HqFGj2GuvvbjooovKnXfatGkUFRXRu3fvaqu5pshaEJhZK+CvQHPAgQfd/R4zaww8BbQFVgDfdfcvs1WHiEgmLrvssl2OnzZtGg0aNKiWICgtLaWgoOZ8D89m01ApcK27dwR6AVeYWUdgODDF3dsDU8LXIiKRuuWWW7jrrrsAuPfee+nYsSOdO3fm3HPPZcWKFYwaNYq7776brl278tprr7FixQqOP/54OnfuTP/+/fnggw8AeP/99+nVqxedOnXi5ptv3nEznGnTptGnTx8GDx5Mx44dATj99NM58sgjOfzww3nwwQd31NKgQQOuv/56Dj/8cE444QRmzpxJ3759adeuHRMnTqz2dc9aJLn7x8DH4fONZrYYOBA4DegbTvYYMA34RbbqEBHZbsuWLXTt2nXH6y+++ILBgwd/Y7oRI0awfPly6tSpw7p169hnn3247LLLaNCgwY6b1wwaNIhhw4YxbNgwRo8ezVVXXcUzzzzD1VdfzdVXX83QoUMZNWrU15Y7Z84cFi5cyEEHHQTA6NGjady4MVu2bKFnz56cddZZNGnShM2bN3P88cdz5513csYZZ3DzzTfz0ksvsWjRIoYNG1ZuzVWRk4PFZtYW6Aa8CTQPQwLgE4KmIxGRrKtXrx5z587d8bjtttvKna5z586cf/75jBkzpsImnBkzZnDeeecBcOGFFzJ9+vQdw88++2yAHeO3O+qoo3aEAAR7Hl26dKFXr16sWrWKpUuXAlBUVMSAAQMA6NSpE9/5zncoLCykU6dOrFixovIboAJZDwIzawA8DfzU3TeUHedBh99ewXyXmtksM5u1Zs2abJcpIrLD5MmTueKKK5gzZw49e/aktLS0WpZbv379Hc+nTZvGyy+/zIwZM5g3bx7dunVj69atQHDfBDMDgq6z69Sps+N5ddVSVlaDwMwKCUJgrLv/Xzj4UzNrEY5vAXxW3rzu/qC793D3HmV7ABQRyaZ0Os2qVavo168fv/3tb1m/fj2bNm2iYcOGbNy4ccd0vXv3Zty4cUBw05o+ffoA0KtXL55++mmAHePLs379evbdd1/22msvlixZwhtvvJHFtdq1bJ41ZMDDwGJ3/0OZUROBYcCI8OeEbNUgIjVXTe1DKpVKccEFF7B+/Xrcnauuuop99tmHQYMGMWTIECZMmMDIkSMZOXIkF198MXfeeSfNmjXjkUceAeCPf/wjF1xwAbfffjsDBgygUaNG5b7PgAEDGDVqFIcddhgdOnSgV69euVzNr7Gdb8dWbQs2OxZ4DVgApMPBNxIcJxgPtAZWEpw++sWultWjRw+fNWtWVuqU7NnTTuTU6Vx+W7x4MYcddljUZWTdV199Rb169TAzxo0bx5NPPsmECdn/vlve9jWz2e6+29usZfOsoemAVTC6f7beV0QkSrNnz+bKK6/E3dlnn30YPXp01CXtVs25okFEJA/06dOHefPmRV3GHlFfQyKSM9lqio67qm5XBYGI5ETdunVZu3atwqCauTtr166lbt26lV6GmoZEJCdatmzJ6tWr0XVB1a9u3bq0bNmy0vMrCEQkJwoLC792Va3UHGoaEhGJOQWBiEjMKQhERGJOQSAiEnMKAhGRmFMQiIjEnIJARCTmFAQiIjGnIBARiTkFgYhIzCkIRERiTkEgIhJzCgIRkZhTEIiIxJyCQEQk5hQEIiIxpyAQEYk5BYGISMwpCEREYk5BICIScwoCEZGYUxCIiMScgkBEJOYUBCIiMacgEBGJOQWBiEjMKQhERGJOQSAiEnMKAhGRmFMQiIjEnIJARCTmFAQiIjGnIBARibmsBYGZjTazz8xsYZlht5jZh2Y2N3yckq33FxGRzGRzj+BRYEA5w+92967h47ksvr+IiGQga0Hg7q8CX2Rr+SIiUj2iOEZwpZnND5uO9o3g/UVEpIyCHL/fn4H/BTz8+Xvg++VNaGaXApcCtG7dOlf1iezQdvjkcoevGHFqtSynMssSyYac7hG4+6funnL3NPAQcNQupn3Q3Xu4e49mzZrlrkgRkZjJaRCYWYsyL88AFlY0rYiI5EbWmobM7EmgL9DUzFYDvwb6mllXgqahFcCPsvX+IiKSmawFgbsPLWfww9l6PxERqRxdWSwiEnMKAhGRmFMQiIjEnIJARCTmcn1BmUi12dWFWuWp6OKtPV2OSL7RHoGISMwpCEREYk5BICIScwoCEZGYUxCIiMScgkBEJOYyCgIz+z8zO9XMFBwiInkm0w/2PwHnAUvNbISZdchiTSIikkMZXVDm7i8DL5tZI2Bo+HwVwc1lxrh7SRZrFKkWunBMpHwZN/WYWRPge8APgbeBe4DuwEtZqUxERHIioz0CM/sH0AF4HBjk7h+Ho54ys1nZKk5ERLIv076GHnL358oOMLM67r7N3XtkoS4REcmRTJuGflPOsBnVWYiIiERjl3sEZrY/cCBQz8y6ARaO2hvYK8u1iYhIDuyuaehkggPELYE/lBm+EbgxSzWJiEgO7TII3P0x4DEzO8vdn85RTSIikkO7axq6wN3HAG3N7Gc7j3f3P5Qzm4iI1CK7axqqH/5skO1CREQkGrtrGnog/HlrbsqR2kZX61ZNRduvottqZns5Ek+Zdjr3OzPb28wKzWyKma0xswuyXZyIiGRfptcRnOTuG4D/AVYA3wKuz1ZRIiKSO5kGwfYmpFOBv7n7+izVIyIiOZZpFxOTzGwJsAW43MyaAVuzV5aIiORKRnsE7j4c6A30CLuc3gycls3CREQkNzLdIwA4lOB6grLz/LWa65G4cmc/vqSZraM+W9lGIetowEfeNOrKRPJept1QPw4cDMwFUuFgR0EgVZFOw/tTYd4TsPxVZtZd841JUm7wx9bQogsceGTwOKAb1NGlLSLVJdM9gh5AR3f3bBYjMbL8NXjhRvhkPtRrDO1P4lez6/CJN2YT9SiihKa2gVb2GVcfCHz0NiyeGMxrCdjvcG4v2I856fbM8fYs9/35b5+IIrInMg2ChcD+wMe7m1DyU3VdOJYkBS/fAtPvhkat4YwH4PAzoaCIv84s/z2uPju8KGrzWvhoDqx+C1bNZFDydc4vmALAF96At9PtdwTD/HQ7NlOvWmrOR7oATcrKNAiaAovMbCawbftAdx+claokL9WhmPsKR8L02dB9GAwYAUV70Jt5/SbQ/sTgAXQZ/izt7UO6J5bSzd6je2Ip/QvfBiDtxnt+AAu8HfPTwWORt2EbRdlYNZFaLdMguCWbRUj+K6CUBwrvpm9yHpxyFxx1SZWX6ST4j7fiP6lWjON4APZmE90S79MtsZQjbDnHJeZzVvI1AEo9mH5++qAdAbHEW1OyR+dMiOSfjP4D3P0VM2sDtHf3l81sLyCZ3dIkfzi3FTxK3+Q8hpf8kBHVEAIV2UADXkl34ZV0lx3vvT9f0DmxjE6J5XS2ZZycnMW5Ng2AzV6HGemOO+b5wJtnrTaRmirTs4YuAS4FGhOcPXQgMAron73SJF+cn5zCeQVTub90MONSxzMip+9ufEITPkk34cV0z3CY09LW0MWWcXRiMX0TczkhbFJanG7FpNQxTEr3YqXvn9NKRaKS6T7xFcBRwJsA7r7UzPbLWlWSNw62D7m5YAyvpDpzV+l3oy4nZKz2/Vjt+zE53Qtw2ton9EvM5ZTkm1xfOJ7rGc+8dDueSvVjQqq3DjxLXss0CLa5e7FZcHpeeFGZTiWVXUqQ5veFf2YLRVxX8iM8466tcs1Y4S14JNWCR1IDacFaTk2+wVnJ17ij8GFuLBjLxFRvnkgdz0JvF3WxItUu0yB4xcxuJLiJ/YnAj4FndzWDmY0m6K30M3c/IhzWGHgKaEvQi+l33f3LypUuNd3Q5FS6JpZxZfFPWMO+UZeTsY9pwl9Sp/KX1Cl0s/cYmpzKGcnpnFcwlVnpQ2BRCg49FRI6TCb5IdOvaMOBNcAC4EfAc8DNu5nnUWBAOcuZ4u7tgSnha8lDjdjEdQXjeT3VkUnpXlGXU0nG296en5f+iKO33c+tJReyH1/C+Ath5JHw5oNQvDnqIkWqLNNO59LAM8CP3X2Iuz+0u6uM3f1V4IudBp8GPBY+fww4fQ/rlVriZwV/oyFfcWvpReTDFb8bqM8jqYH0Lb4bzn4M6jeFf14Pf+gIU/43uNhNpJba3c3rDfg1cCVhaJhZChjp7rdV4v2au/v2q5M/ASo8V8/MLiU4U4nWrVtX4q0kKi1tDeclp/Jk6nje9W/+7mrz7S3TJGj7eAK4hu72Hy5JTebkV3/PlldH8njqJB4qPYW1NKry+0R15a+uOI6n3e0RXAN8G+jp7o3dvTFwNPBtM7umKm8c7lFUuFfh7g+6ew9379GsWbOqvJXk2I+TE0hj3F+a3z2Vz/FDuLzkGk4q/i0vpY/kkuQkpte5mpsKxtCMdVGXJ5Kx3QXBhcBQd1++fYC7LwMuAC6qxPt9amYtAMKfn1ViGVKDHcgazk6+wrhUPz6hSdTl5MR73pKfllzJicV38lz6aC5OPs9rda5meMGT7I2OIUjNt7sgKHT3z3ce6O5rgMJKvN9EYFj4fBgwoRLLkBrssoJnSWP8uTR+3VAt8wO4tuRy+hffxeR0Ly5NTuKVOtfwg+RkiiiJujyRCu0uCIorOQ4zexKYAXQws9Vm9gNgBHCimS0FTghfS55oxCaGJF/lH6ljY7M3UJ6Vvj/XllzOqcV3MD/djl8WjmVK0XUMTryOLr+Rmmh31xF0MbMN5Qw3oO6uZnT3oRWMUrcUeWpocir1rJhHUjufNRxPi70Nw0qGc2xqATcUPMG9RfdxXnoKvyy5mKXeMuryRHbY5R6Buyfdfe9yHg3dvTJNQ5KnCijlooIXmZ46vNwzheJseroTg4pv54aSH9DBVvFc0Q3cUDCW+myJujQRIPMLykR26eTELA6wLxidGhh1KTVSmgRPpvpz/La7+HvqOH5UMJkpda7j1MQbqLlIoqYgkGpxXnIKq9LN+Fe6a9Sl1Ghfsjc3lF7CGdtu5XNvxP1F9/LXwhG0sU+iLk1iTHfkkCprZZ/y7eQ7/L5kSA3uWK5medvbM7j4N1yYfIlrC8bzYtEv+HNqEH8uHVwj76K2pxcB6gK02kX/tVJlZydfIe3G31PfibqUWiVNgsdSJ9N/2108n+7JTwv+j+eLfkGfxPyoS5OYURBIlSRIc3byVV5Jd+bjGJ8yWhVr2JerS67k/OIbSJPg8aIR3Fd4L82/0VWXSHYoCKRKjkvMo4V9wVOpflGXUuv9O92JgcUjuKvkbE5IzGZKnev4fvKfFFAadWmS5xQEUiVDkq+y1hsyJd096lLyQjGF3Jc6gxOLf8db6Q78qvBxphZdy5DkKyRJRV2e5CkFgVRaA77ihMQcJqd6UaLzDqrVKm/OxSU/5+Li61lPfe4qfICXiq6Ht/4C2zZGXZ7kGQWBVNoJiTnUtRImpo6JupQ8Zfwr3Y1BxbdzSfHP2ExdmHwt/P4wmHwdrJwB6XTURUoe0Nc4qbTBydf50Jsw2w+JupQ8Z7yU7sFLxUey4orm8NZDMOevwc8G+0OHAQxKNOCN9GG16pagUnMoCKRS9mEjfRILeDg1UNcO5IxBq57B45S7YOmL8M4/YMHTjCwKmouWp5szx9vzdro9c9LtIVUKSf2by67pL0Qq5ZTkTAotxbOp3ll/r9p8R7Osqbs3dBoSPFKlDLr5z/RKLKJn4l2OS8znrOR0ADbfdivz0gczx4NgeDv9Lb5k74iLl5pGQSCVMjj5Ou+nW/COt4m6FEkWsMDbsSDVjodS/wM4rewzuttSuieW0i3xHpclnqWgIDiesDzdnNnegYmpY3gt3Ul7dKIgkD3XnC84ypZwT+mZ5MON6fOPscqbs8qbMyF9LAB12UZnW0b3RBAOJyRmMyT5Kqu9KQ+VnsqTqeMprtS9piQfKAhkj52SfJOEOc+mdbZQbbGVOsz0w5iZOgxSUEQJJyZmc1HBi9xa+BiXFkzityXnMjHdG4V7/GifUPbYgORbLEm3YpkfEHUpUknFFDI53Ytzin/JecU38rk34t6i+xldeCfN+DLq8iTHFASyRxqzgR72Li+ke0RdilQL4/X0EZxRfBu3lVzIMYlFTKpzE0fau1EXJjmkIJA9ckJyNklzXkz1jLoUqUZpEoxODeT04tvY4nUYV/Sb8B7LEgcKAtkjJydmsdqb6myhPPWut2Zw8W+Y4+35Y+H9nJecEnVJkgMKAslYfbZwbGIBz6d6ogOK+WsD9bmoeDj/SnfljsKHOTPxatQlSZYpCCRj/RJzqWOlvKBmoby3jSIuL/kp01OH87vCB+mXeDvqkiSLdPqoZOzk5Ft87nurb6EI5fIq62IK+VHJzxhX9L+MLBzJ6cW38Z63zGjeiurULSxrJu0RSEaKKKFvYh4vpY4krT+b2NhMPX5YfB1bqMODhX+gIV9FXZJkgf6jJSO9EwtpaFt4Ia1mobj5lMb8uPhqWtkaflf4AOBRlyTVTEEgGTk5MYuNXo/X04dHXYpE4C0/lLtKv8vA5FuclXgt6nKkmikIZPfSKU5MzuZf6a7qjybGHkqdypvpQ7ml8DFa2pqoy5FqpCCQ3fvgDZraBp0tFHNpElxbcjkAdxaoiSifKAhk95ZMYpsXMi3dJepKJGKrvRl3lJ7HMclFnKkmoryhIJBdc4clk5iePoLN1Iu6GqkBxqX6MTvdnpsKx9KITVGXI9VAQSC79ulCWPcBL6qTOQk5CW4q+QGN2MwvCp6MuhypBgoC2bUlzwHGlFT3qCuRGmSJt+aR1ADOTU6jo62IuhypIgWB7NqSSdDqaD6nUdSVSA0zsvQM1lOfGwvGogPHtZuCQCq27gP4ZD4cqm4B5Js2UJ97Ss/k2OQ79E3Mi7ocqQIFgVRsyXPBTwWBVGBs6gSWpffnxoKxJElFXY5UkoJAKrZkEjQ7FJocHHUlUkOVUMBvS4dySOJDzkqqu+raSkEg5fvqC1j5uvYGZLdeSPdgbvpgrir4B4WURl2OVIKCQMq39EXwlIJAMmDcXTqElvY5Q5KvRF2MVEIkQWBmK8xsgZnNNbNZUdQgu7FkEjQ8AFp0i7oSqQVeSXdmTvpbXFnwDEWURF2O7KEo9wj6uXtXd9eVSjVNyRZ4bwocegoktNMomTD+UHo2B9pavpucFnUxsof0Xy7ftGwalHylZiHZI9PTR/BW+hCuKJhAHYqjLkf2QFRB4MCLZjbbzC4tbwIzu9TMZpnZrDVr1OVtrrQdPpmnHh/FBq9H+4c20nb45JzeHlFqs2CvoIV9wTnJf0VdjOyBqILgWHfvDgwErjCz43aewN0fdPce7t6jWbNmua8wphKkOSE5m3+lu1GiW1rLHpqR7sis9CFcWjCZAp1BVGtEEgTu/mH48zPgH8BRUdQh39TD3qWJbeSl1JFRlyK1kvGn0sG0tM8ZnHg96mIkQzkPAjOrb2YNtz8HTgIW5roOKd8pyTfZ6oVMTetsIamcqeluLE635vKCZzHSUZcjGYhij6A5MN3M5gEzgcnu/nwEdcjO0mkGJmcyLd2Vr6gbdTVSaxl/Lh1M+8SHnJSYHXUxkoGcB4G7L3P3LuHjcHe/Pdc1SAVWvUFzW8dzqaOjrkRqucnpo1mZ3o/LCyagnklrPp0+Kv/1zjNs80KmqFlIqihFkgdSg+iaWEbvxDtRlyO7oSCQQDoNiycyLd1Ft6SUavF0qg+f+j5ckZwQdSmyGwoCCax6EzZ+zGQ1C0k12UYRfyk9hW8n36GLvRd1ObILCgIJLHoGknWYktYtKaX6PJHqzzqvz48LJkZdiuyCgkCCZqFFE+FbJ6hZSKrVZurxWOpkTk7Oor2tjrocqYCCQGDFa7DxIzjizKgrkTz0SOnJbPY6/LhAxwpqKgWBwPynoKihOpmTrFhHQ8amTgiuNP5iWdTlSDkUBHFX/FXQLNTxNChUs5Bkx0Olp1BKAUz/Y9SlSDkUBHH37nNQvBG6nBN1JZLH1rAv41PfgblPwPoPoy5HdqIgiLv5T8HeB0KbY6OuRPLcA6lB4Gl4fWTUpchOFARxtmlNcCeyTmfrTmSSdau9GXQ+B2Y/GvztSY2h//44WzA+uEF9ZzULSY70+RmUboU3/hR1JVKGgiCu3GHWI9CyJzSuw8VmAAAKUElEQVTvGHU1EhdN2wcnJrz1F9iyLupqJKQgiKuVr8PapXDk96KuROKmz7WwbQPMfCjqSiSkIIir2Y9AnUZwuC4ikxxr0Rnanwxv3A9b10ddjaAgiKfNa2HRhOCU0aK9oq5G4qjfDbDlS5hxf9SVCAqCeJo7FlLFahaS6BzQLThWMON+2Px51NXEnoIgblIl8OYD0Obb0PzwqKuROOt3E5R8BdPvjrqS2FMQxM2iCbBhNfT+SdSVSNw16wBdzgsOGutq40gpCOLEPbiqs0n74GCdSNT6/iK42njaHVFXEmsKgjhZ8Rp8PBeOuUJXEkvNsE9rOPpH8PZY+HBO1NXElj4N4sIdpo2ABvtDl3Ojrkbkv77zc6jfFP75i+DvVHJOQRAXy1+Blf8OLuZRd9NSk9RtBP1/DatnwvzxUVcTSwqCOHCHqbcHvYx2vyjqakS+qev5wSmlL/1KF5lFQEEQB0smB9+2+lwLhXWjrkbkmxIJOPX3sPmzIAwkpxQE+a5kK7xwIzQ7THsDUrMdeCQcc2XQTfWyaVFXEysKgnw3YySsWwkDR0CyMOpqRHat343Q+GCY+BPYtjHqamJDQZDP1r4Pr/0BDhsE7fpGXY3I7hXWg9P/BOtXw6RrdBZRjigI8lU6Bc/8ONgLGPi7qKsRyVzrXsGewYK/Bc1EknUKgnz1+khY9QacchfsfUDU1YjsmWOvhYOPD64t0IVmWacgyEfLX4Mpt8Fhg4P7EYvUNokEnPkQNGgOT5wDX66MuqK8piDIN1+uhPEXQZNvwWn3g1nUFYlUTv2mcMHfIbUNxp6t7qqzSEGQTzZ+CmPOCo4PnPsE1N076opEqqZZh+Bved1KePTU4G9cqp2CIF9s+gweGwQbPoLznoKm34q6IpHq0fZYOP9vsO4DeGRgcDacVCsFQT74ZCE81D/4Rzl/PLQ5JuqKRKrXQcfBhf+ArevgoX7w3stRV5RXFAS1mTvMeRwePgnSJXDxc8G3J5F81LoXXDI16DNrzFnw3PVQvDnqqvKCgqC2+mxx8M8w8Uo4oCtc8i84sHvUVYlk175t4YdT4OjLYeaDMLJH8GUonYq6slpNQVCbuMPK1+Hv34c/HQOrZsLAO2HYJNi7RdTVieRG0V5BlykXPx/83U+8Eu7rAa/fB199EXV1tVJBFG9qZgOAe4Ak8Bd3HxFFHbXCto3BB/77U+E/z8Pa96CoYXDP4WOvgb0aR12hSDTaHBPsHSx+Ft74E7x4E7z8a2h9DHQYGDQlNT8CCupEXWmNl/MgMLMkcD9wIrAaeMvMJrr7olzXkrHt/Z24A7t4vqNflN09dygthuJNQRtn8WYo3ghffQkbP4INH8P6VfDpQvhyRTBrsgja9A4+/A8/A4rqZ3edRWoDM+g4OHh8shAWPg3v/jPocRcgUQj7HRY0Ke3bBhq1gnqNod6+UG+f4KY4yaIgLJJF/32eKIjVNThR7BEcBbzn7ssAzGwccBpQ/UHw/I0w+5HgeWU/uKNQ1CA4INaiK3S7AFp0C7796MNfpGL7HxE8Tvg1rFsFH86Gj+bAp+8Ex9T+80JwcdoeszAUMviZDeeOCbrbyKIoguBAYFWZ16uBo3eeyMwuBS4NX24ys3er8J5NgVp0WeIG4CPgrWy/US3bLjmlbVOxSm8b+201V1LzVP/fzc39qzJ3m0wmiuQYQSbc/UHgwepYlpnNcvce1bGsfKLtUjFtm4pp21Sstm6bKM4a+hBoVeZ1y3CYiIhEIIogeAtob2YHmVkRcC4wMYI6RESECJqG3L3UzK4EXiA4fXS0u7+T5betliamPKTtUjFtm4pp21SsVm4bc90KTkQk1nRlsYhIzCkIRERiLm+CwMwam9lLZrY0/LlvBdMNC6dZambDygyfZmbvmtnc8LFf7qqvfmY2IFyf98xseDnj65jZU+H4N82sbZlxN4TD3zWzk3NZdy5UdtuYWVsz21Lmb2RUrmvPtgy2zXFmNsfMSs1syE7jyv3fygdV3C6pMn8zNfPEGHfPiwfwO2B4+Hw48NtypmkMLAt/7hs+3zccNw3oEfV6VNO2SALvA+2AImAe0HGnaX4MjAqfnws8FT7vGE5fBzgoXE4y6nWqIdumLbAw6nWIeNu0BToDfwWGlBle4f9WbX9UZbuE4zZFvQ67e+TNHgFBNxWPhc8fA04vZ5qTgZfc/Qt3/xJ4CRiQo/pyaUc3Hu5eDGzvxqOsstvr70B/M7Nw+Dh33+buy4H3wuXli6psm3y3223j7ivcfT6Q3mnefP7fqsp2qRXyKQiau/vH4fNPgOblTFNe9xYHlnn9SLj79sta/o+/u/X82jTuXgqsB5pkOG9tVpVtA3CQmb1tZq+YWZ9sF5tjVfnd5/PfTVXXra6ZzTKzN8ysvC+okauxXUyUx8xeBvYvZ9RNZV+4u5vZnp4Xe767f2hmDYGngQsJdvNEtvsYaO3ua83sSOAZMzvc3TdEXZjUaG3Cz5Z2wFQzW+DuNerGy7Vqj8DdT3D3I8p5TAA+NbMWAOHPz8pZRIXdW7j79p8bgSeo3c0hmXTjsWMaMysAGgFrM5y3Nqv0tgmby9YCuPtsgnbjQ7Jece5U5Xefz383VVq3Mp8tywiORXarzuKqQ60Kgt2YCGw/U2EYMKGcaV4ATjKzfcOzik4CXjCzAjNrCmBmhcD/AAtzUHO2ZNKNR9ntNQSY6sGRrYnAueGZMwcB7YGZOao7Fyq9bcysWXg/DcJvd+0JDormi6p0/1Lu/1aW6sy1Sm+XcHvUCZ83Bb5NNrrcr6qoj1ZX14OgDXcKsBR4GWgcDu9BcBe07dN9n+AA6HvAxeGw+sBsYD7wDuHd06Jepypuj1OA/xB8a70pHHYbMDh8Xhf4W7gdZgLtysx7Uzjfu8DAqNelpmwb4Kzw72MuMAcYFPW6RLBtehK0kW8m2IN8p8y83/jfypdHZbcL0BtYQHCm0QLgB1GvS3kPdTEhIhJz+dQ0JCIilaAgEBGJOQWBiEjMKQhERGJOQSAiEnMKApEyzMzNbEyZ1wVmtsbMJkVZl0g2KQhEvm4zcISZ1Qtfn0j+XCErUi4Fgcg3PQecGj4fCjy5fYSZ1Tez0WY2M+x87rRweFszey3sk36OmfUOh/cN73XxdzNbYmZja3mHhpKHFAQi3zSOoJuNugR9zL9ZZtxNBF1OHAX0A+40s/oEfVud6O7dgXOAe8vM0w34KcG9HtoRdDMgUmPUqt5HRXLB3eeHdyUbSrB3UNZJwGAzuy58XRdoDXwE3GdmXYEUX++Mbqa7rwYws7kENzGZnq36RfaUgkCkfBOBu4C+/PdeBAAGnOXu75ad2MxuAT4FuhDsaW8tM3pbmecp9H8nNYyahkTKNxq41d0X7DT8BeAn29v5zWx7l8KNgI/dPU1wL4tkzioVqSIFgUg53H21u99bzqj/BQqB+Wb2Tvga4E/AMDObBxxKcPaRSK2g3kdFRGJOewQiIjGnIBARiTkFgYhIzCkIRERiTkEgIhJzCgIRkZhTEIiIxNz/Az9dDlO2HzzqAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1985,7 +2508,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/pincell.ipynb b/examples/jupyter/pincell.ipynb
index f8641db13..e50a4a322 100644
--- a/examples/jupyter/pincell.ipynb
+++ b/examples/jupyter/pincell.ipynb
@@ -4,15 +4,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This notebook is intended to demonstrate the basic features of the Python API for constructing input files and running OpenMC. In it, we will show how to create a basic reflective pin-cell model that is equivalent to modeling an infinite array of fuel pins. If you have never used OpenMC, this can serve as a good starting point to learn the Python API. We highly recommend having a copy of the [Python API reference documentation](http://openmc.readthedocs.org/en/latest/pythonapi/index.html) open in another browser tab that you can refer to."
+    "This notebook is intended to demonstrate the basic features of the Python API for constructing input files and running OpenMC. In it, we will show how to create a basic reflective pin-cell model that is equivalent to modeling an infinite array of fuel pins. If you have never used OpenMC, this can serve as a good starting point to learn the Python API. We highly recommend having a copy of the [Python API reference documentation](https://docs.openmc.org/en/stable/pythonapi/index.html) open in another browser tab that you can refer to."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -31,9 +29,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -43,7 +39,7 @@
       "\tID             =\t1\n",
       "\tName           =\tuo2\n",
       "\tTemperature    =\tNone\n",
-      "\tDensity        =\tNone []\n",
+      "\tDensity        =\tNone [sum]\n",
       "\tS(a,b) Tables  \n",
       "\tNuclides       \n",
       "\n"
@@ -65,9 +61,7 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -77,7 +71,7 @@
       "\tID             =\t2\n",
       "\tName           =\t\n",
       "\tTemperature    =\tNone\n",
-      "\tDensity        =\tNone []\n",
+      "\tDensity        =\tNone [sum]\n",
       "\tS(a,b) Tables  \n",
       "\tNuclides       \n",
       "\n"
@@ -99,9 +93,7 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -115,7 +107,7 @@
       "    Parameters\n",
       "    ----------\n",
       "    nuclide : str\n",
-      "        Nuclide to add\n",
+      "        Nuclide to add, e.g., 'Mo95'\n",
       "    percent : float\n",
       "        Atom or weight percent\n",
       "    percent_type : {'ao', 'wo'}\n",
@@ -138,9 +130,7 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Add nuclides to uo2\n",
@@ -159,9 +149,7 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "uo2.set_density('g/cm3', 10.0)"
@@ -179,15 +167,13 @@
   {
    "cell_type": "code",
    "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/romano/openmc/openmc/mixin.py:61: IDWarning: Another Material instance already exists with id=2.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Material instance already exists with id=2.\n",
       "  warn(msg, IDWarning)\n"
      ]
     }
@@ -213,9 +199,7 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "water.add_s_alpha_beta('c_H_in_H2O')"
@@ -231,9 +215,7 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "mats = openmc.Materials([uo2, zirconium, water])"
@@ -249,9 +231,7 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -281,9 +261,7 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -291,7 +269,7 @@
      "text": [
       "<?xml version='1.0' encoding='utf-8'?>\r\n",
       "<materials>\r\n",
-      "  <material id=\"1\" name=\"uo2\">\r\n",
+      "  <material depletable=\"true\" id=\"1\" name=\"uo2\">\r\n",
       "    <density units=\"g/cm3\" value=\"10.0\" />\r\n",
       "    <nuclide ao=\"0.03\" name=\"U235\" />\r\n",
       "    <nuclide ao=\"0.97\" name=\"U238\" />\r\n",
@@ -338,9 +316,7 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -348,7 +324,7 @@
      "text": [
       "<?xml version='1.0' encoding='utf-8'?>\r\n",
       "<materials>\r\n",
-      "  <material id=\"1\" name=\"uo2\">\r\n",
+      "  <material depletable=\"true\" id=\"1\" name=\"uo2\">\r\n",
       "    <density units=\"g/cm3\" value=\"10.0\" />\r\n",
       "    <nuclide ao=\"0.03\" name=\"U235\" />\r\n",
       "    <nuclide ao=\"0.97\" name=\"U238\" />\r\n",
@@ -402,9 +378,7 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -412,24 +386,24 @@
      "text": [
       "<?xml version='1.0' encoding='utf-8'?>\n",
       "<cross_sections>\n",
-      "    <library materials=\"Ac225\" path=\"Ac225.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Ac226\" path=\"Ac226.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Ac227\" path=\"Ac227.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Ag107\" path=\"Ag107.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Ag109\" path=\"Ag109.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Ag110_m1\" path=\"Ag110_m1.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Ag111\" path=\"Ag111.h5\" type=\"neutron\" />\n",
-      "    <library materials=\"Al27\" path=\"Al27.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ac225\" path=\"Ac225.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ac226\" path=\"Ac226.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ac227\" path=\"Ac227.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ag107\" path=\"Ag107.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ag109\" path=\"Ag109.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ag110_m1\" path=\"Ag110_m1.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Ag111\" path=\"Ag111.h5\" type=\"neutron\" />\n",
+      "  <library materials=\"Al27\" path=\"Al27.h5\" type=\"neutron\" />\n",
       "    ...\n",
-      "    <library materials=\"c_O_in_BeO\" path=\"c_O_in_BeO.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_ortho_D\" path=\"c_ortho_D.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_ortho_H\" path=\"c_ortho_H.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_O_in_UO2\" path=\"c_O_in_UO2.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_para_D\" path=\"c_para_D.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_para_H\" path=\"c_para_H.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_H_in_CH4_solid\" path=\"c_H_in_CH4_solid.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_U_in_UO2\" path=\"c_U_in_UO2.h5\" type=\"thermal\" />\n",
-      "    <library materials=\"c_Zr_in_ZrH\" path=\"c_Zr_in_ZrH.h5\" type=\"thermal\" />\n",
+      "  <library materials=\"Cf253\" path=\"wmp/098253.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Cf254\" path=\"wmp/098254.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Es251\" path=\"wmp/099251.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Es252\" path=\"wmp/099252.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Es253\" path=\"wmp/099253.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Es254\" path=\"wmp/099254.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Es254_m1\" path=\"wmp/099254m1.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Es255\" path=\"wmp/099255.h5\" type=\"wmp\" />\n",
+      "  <library materials=\"Fm255\" path=\"wmp/100255.h5\" type=\"wmp\" />\n",
       "</cross_sections>\n"
      ]
     }
@@ -452,9 +426,7 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "uo2_three = openmc.Material()\n",
@@ -485,12 +457,10 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "sph = openmc.Sphere(R=1.0)"
+    "sph = openmc.Sphere(r=1.0)"
    ]
   },
   {
@@ -505,9 +475,7 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "inside_sphere = -sph\n",
@@ -524,9 +492,7 @@
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -552,9 +518,7 @@
   {
    "cell_type": "code",
    "execution_count": 18,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "z_plane = openmc.ZPlane(z0=0)\n",
@@ -571,14 +535,12 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(array([-1., -1.,  0.]), array([ 1.,  1.,  1.]))"
+       "(array([-1., -1.,  0.]), array([1., 1., 1.]))"
       ]
      },
      "execution_count": 19,
@@ -600,9 +562,7 @@
   {
    "cell_type": "code",
    "execution_count": 20,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "cell = openmc.Cell()\n",
@@ -622,9 +582,7 @@
   {
    "cell_type": "code",
    "execution_count": 21,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "cell.fill = water"
@@ -647,9 +605,7 @@
   {
    "cell_type": "code",
    "execution_count": 22,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "universe = openmc.Universe()\n",
@@ -669,18 +625,28 @@
   {
    "cell_type": "code",
    "execution_count": 23,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAD8CAYAAABZ0jAcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5VAxs6QcKmaWlEPFzJL6f9FDUHdRa99+AAAAAElFTkSuQmCC\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fe36e571588>"
+       "<matplotlib.image.AxesImage at 0x1548c7671cf8>"
       ]
      },
+     "execution_count": 23,
      "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -698,18 +664,28 @@
   {
    "cell_type": "code",
    "execution_count": 24,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAD8CAYAAABZ0jAcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fe3a1080048>"
+       "<matplotlib.image.AxesImage at 0x1548c559c080>"
       ]
      },
+     "execution_count": 24,
      "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -727,18 +703,28 @@
   {
    "cell_type": "code",
    "execution_count": 25,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAD8CAYAAABZ0jAcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAD8BJREFUeJzt3X+MHOV9x/HPpwT+qItKwcY4BKtBskIdKaF4ZVxqNbgJ\nCFtNXFetZKuCKIpkUYWoQVUlS0g0f7ZEaSSqhMhprQapIWoVnCBioL6olZtGTrlDxj4HCIYahauL\nDYlME6qkbr/9Y+fCcOzezt48O7/2/ZJWtzszz+4zO7Ofe2Z3Z7+OCAFAKr9QdwcAdAuhAiApQgVA\nUoQKgKQIFQBJESoAkkoSKrYP2D5re37IfNu+3/Yp28dt35Cbd5vt57J5+1L0B0B9Uo1U/lbSbcvM\n3y5pQ3bZK+kBSbJ9kaTPZ/M3Stpje2OiPgGoQZJQiYgjkn64zCI7JT0YfUclXWZ7naTNkk5FxIsR\n8TNJX82WBdBS76joca6W9IPc7ZezaYOm3zjoDmzvVX+Uo1WrVm267rrrJtNTFDc3ofvdNKH7RWFz\nc3OvRsSalbStKlRKi4j9kvZLUq/Xi9nZ2Zp7NAVc0+OOCivOLJk42y+ttG1VobIg6Zrc7Xdl0y4e\nMh1VqytAVmJQXwmaxqjqI+VHJN2RfQq0RdL5iDgj6UlJG2y/2/YlknZny2LSvOTSdl1bnxZLMlKx\n/ZCkmyWttv2ypD9TfxSiiPiipEOSdkg6JekNSR/L5l2wfZekJyRdJOlARJxM0SfkTOOLjNFMbZKE\nSkTsGTE/JH1iyLxD6ocOUprGIBkl/5wQMBPDN2oBJNWaT39QECOUYhafJ0YsyREqXUCQrByHRMkR\nKm1FkKRHwCRBqLQJQVIdAmbFCJU2IEzqxfsvYyFUmowwaRbCpRA+Um4qAqW52DbLYqTSJOys7cGo\nZShCpQkIk/biDd234fCnbgRKd7AtJTFSqQ87YDdxWMRIBUBajFSqxghlOkzxiIWRSpUIlOkzhduc\nUKnKFO5cyEzZtufwZ9KmbIfCEFN0OESoTAphgkGmIFxSlT1dtnSp7T+1fSy7zNv+X9uXZ/NO2z6R\nzetG3Q0CBaN0eB8pPVLJlS69Rf1iYE/afiQivre4TER8RtJnsuU/LOnuiMhXNNwWEa+W7UsjdHhn\nQWJWJ0csKUYq45Yu3SPpoQSP2yyUhsBKdHC/SREqw0qavo3tX1S/kPvXcpND0oztuay0aft0bKdA\nDTq0D1X9Ru2HJf3rkkOfrRGxYPtKSYdtP5sVfH+LfC3l9evXV9PbIjq0M6BmHTkcSjFSGVbSdJDd\nWnLoExEL2d+zkg6qfzj1NhGxPyJ6EdFbs2ZFdaPTI1CQWgf2qRShUqh0qe1flvQBSd/ITVtl+9LF\n65JulTSfoE8AalL68GdY6VLbd2bzv5gtukvSP0bET3LN10o6aHuxL1+JiMfL9qkSHfiPgoZq+WGQ\n+xVJ26XX68XsbI1faSFQUIUaX5q25yKit5K2nPszLgIFVWnpvsbX9Itq6QZGy7Xwa/2MVIogUFC3\nFu2DhMooLdqY6LiW7IuEynJashExRVqwTxIqAJIiVIZpwX8ETKmG75uEyiAN32hAk/dRQmWpBm8s\n4C0auq8SKgCSIlTyGpr8wFAN3GcJFQBJESqLGpj4QCEN23cJFalxGwUYW4P2YUKlQRsDKKUh+zKh\nAiCp6f3pg4akOpBUA34qgZEKgKSmM1QYpaDratzHq6qlfLPt87l6yvcWbZscgYJpUdO+Xkkt5cy/\nRMTvrLAtgJaoo5ZyqrbjY5SCaVPDPl9lLeWbbB+3/Zjt947ZVrb32p61PXvu3LkE3QYwCVW9UfuU\npPUR8T5JfyXp6+PeQSPLngJ4m0pqKUfE6xHx4+z6IUkX215dpG0yHPpgWlW871dSS9n2Vc5qm9re\nnD3ua0XaJkGgYNpV+Bqoqpby70v6I9sXJP23pN3Rr7c6sG3ZPgGoT/drKTNKAd5U8OVOLWUAjdHt\nUGGUArxVBa+JbocKgMoRKgCS6m6ocOgDDDbh10Z3QwVALQgVAEl1M1Q49AGWN8HXSDdDBUBtCBUA\nSXUvVDj0AYqZ0Gule6ECoFbdqfvDCAUY3wTqBDFSAZAUoQIgqW6ECoc+QDkJX0PdCBUAjUGoAEiq\nqrKnf5jV/Dlh+zu235+bdzqbfsx2wd+IBNBUVZU9/XdJH4iIH9neLmm/pBtz87dFxKtl+wKgfpWU\nPY2I70TEj7KbR9Wv75MGb9ICaSR6LVVZ9nTRxyU9lrsdkmZsz9neO6wRZU+Bdqj0G7W2t6kfKltz\nk7dGxILtKyUdtv1sRBxZ2jYi9qt/2KRer9e+uiLAlKik7Kkk2X6fpL+WtDMiXlucHhEL2d+zkg6q\nfzgFoKWqKnu6XtLDkm6PiO/npq+yfenidUm3Spov/Mi8nwKkleA1VVXZ03slXSHpC1lJ5QtZ9bO1\nkg5m094h6SsR8XjZPgGoT7vLnjJSAdILyp4CaBBCBUBS7Q0VDn2AySj52mpvqABoJEIFQFKECoCk\nCBUASREqAJIiVAAkRagASKqdoTJXdweAbtukTZtW2radoQKgsQgVAEkRKgCSIlQAJEWoAEiKUAGQ\nFKECIKmqyp7a9v3Z/OO2byjaFkC7lA6VXNnT7ZI2Stpje+OSxbZL2pBd9kp6YIy2AFqkkrKn2e0H\no++opMtsryvYFkCLpKhQOKjs6Y0Flrm6YFtJ/bKn6o9ytH79eumlcp0GMNyc51Z8Mkxr3qiNiP0R\n0YuI3po1a+ruDoAhUoxUipQ9HbbMxQXaAmiRSsqeZrfvyD4F2iLpfEScKdgWQItUVfb0kKQdkk5J\nekPSx5ZrW7ZPAOrT7rKnACaCsqcAGoNQAZAUoQIgKUIFQFKECoCkCBUASREqAJIiVAAkRagASIpQ\nAZAUoQIgKUIFQFKECoCkCBUASREqAJIiVAAkRagASIpQAZBUqVCxfbntw7afz/7+yoBlrrH9T7a/\nZ/uk7T/Ozfu07QXbx7LLjjL9AVC/siOVfZK+FREbJH0ru73UBUl/EhEbJW2R9IklpU0/FxHXZ5dD\nJfsDoGZlQ2WnpC9n178s6XeXLhARZyLiqez6f0l6Rv3KhAA6qGyorM3q90jSf0pau9zCtn9V0q9L\n+m5u8idtH7d9YNDhU67tXtuztmfPnTtXstsAJmVkqNiesT0/4PKWQurRr/UxtN6H7V+S9DVJn4qI\n17PJD0i6VtL1ks5I+uyw9pQ9BdphZDGxiPjQsHm2X7G9LiLO2F4n6eyQ5S5WP1D+LiIezt33K7ll\nviTp0XE6D6B5yh7+PCLpo9n1j0r6xtIFbFvS30h6JiL+csm8dbmbuyTNl+wPgJqVDZU/l3SL7ecl\nfSi7LdvvtL34Sc5vSrpd0m8P+Oj4PtsnbB+XtE3S3SX7A6BmpWopR8Rrkj44YPp/qF87WRHxbUke\n0v72Mo8PoHn4Ri2ApAgVAEkRKgCSIlQAJEWoAEiKUAGQFKECIClCBUBShAqApAgVAEkRKgCSIlQA\nJEWoAEiKUAGQFKECIClCBUBShAqApAgVAElNvOxpttzp7Ldoj9meHbc9gPaoouzpom1ZadPeCtsD\naIGJlz2dcHsADVNV2dOQNGN7zvbeFbSn7CnQEiNLdNiekXTVgFn35G9ERNgeVvZ0a0Qs2L5S0mHb\nz0bEkTHaKyL2S9ovSb1eb+hyAOpVSdnTiFjI/p61fVDSZklHJBVqD6A9qih7usr2pYvXJd2qN8ub\njmwPoF2qKHu6VtK3bT8t6d8kfTMiHl+uPYD2qqLs6YuS3j9OewDtxTdqASRFqABIilABkBShAiAp\nQgVAUoQKgKQIFQBJESoAkiJUACRFqABIilABkBShAiApQgVAUoQKgKQIFQBJESoAkiJUACRFqABI\nauJlT22/Jyt3unh53fansnmftr2Qm7ejTH8A1G/iZU8j4rms3On1kjZJekPSwdwin1ucHxGHlrYH\n0C5Vlz39oKQXIuKlko8LoKGqKnu6aLekh5ZM+6Tt47YPDDp8AtAuI0PF9ozt+QGXnfnlIiLUr5k8\n7H4ukfQRSf+Qm/yApGslXS/pjKTPLtOeWspAC1RS9jSzXdJTEfFK7r5/ft32lyQ9ukw/qKUMtMDE\ny57m7NGSQ58siBbt0pvlUAG0VBVlTxdrKN8i6eEl7e+zfcL2cUnbJN1dsj8AajbxsqfZ7Z9IumLA\ncreXeXwAzcM3agEkRagASIpQAZAUoQIgKUIFQFKECoCkCBUASREqAJIiVAAkRagASIpQAZAUoQIg\nKUIFQFKECoCkCBUASREqAJIiVAAkRagASIpQAZBU2VrKf2D7pO3/s91bZrnbbD9n+5TtfbnpI2sx\nA2iXsiOVeUm/J+nIsAVsXyTp8+rX/dkoaY/tjdnskbWYAbRLqVCJiGci4rkRi22WdCoiXoyIn0n6\nqvo1mKXxazEDaLhSJToKulrSD3K3X5Z0Y3a9cC1m23sl7c1u/tR2FwuPrZb0at2dmJCurltX1+s9\nK204MlRsz0i6asCseyJiuYqEY4mIsD20nGm+7Knt2YgY+h5OW3V1vaTurluX12ulbUvVUi5oQdI1\nudvvyqZJ0ji1mAG0QBUfKT8paYPtd9u+RNJu9WswS+PVYgbQAmU/Ut5l+2VJvyHpm7afyKb/vJZy\nRFyQdJekJyQ9I+nvI+JkdhcDazEXsL9Mvxusq+sldXfdWK8lHDH0bQwAGBvfqAWQFKECIKlWhErZ\n0wGaquhpCrZP2z5h+1iZj/ombdTz7777s/nHbd9QRz9XosC63Wz7fLaNjtm+t45+jsv2Adtnh33v\na0XbLCIaf5H0a+p/GeefJfWGLHORpBckXSvpEklPS9pYd99HrNd9kvZl1/dJ+oshy52WtLru/o5Y\nl5HPv6Qdkh6TZElbJH237n4nXLebJT1ad19XsG6/JekGSfND5o+9zVoxUonypwM0VZdOUyjy/O+U\n9GD0HZV0Wfb9pKZr475VSEQckfTDZRYZe5u1IlQKGnQ6wNU19aWooqcphKQZ23PZ6QpNVOT5b+M2\nkor3+6bsEOEx2++tpmsTN/Y2q+Lcn0KqOh2gasutV/5GxLKnKWyNiAXbV0o6bPvZ7D8MmuMpSesj\n4se2d0j6uqQNNfepFo0JlZjs6QC1WW69bBc6TSEiFrK/Z20fVH843rRQKfL8N3IbFTCy3xHxeu76\nIdtfsL06Itp+suHY26xLhz/LnQ7QVCNPU7C9yvali9cl3ar+79g0TZHn/xFJd2SfKGyRdD53+Ndk\nI9fN9lW2nV3frP5r67XKe5re+Nus7nefC75DvUv9Y7mfSnpF0hPZ9HdKOrTknervq/9O/T1197vA\nel2h/o9TPS9pRtLlS9dL/U8cns4uJ5u8XoOef0l3Srozu271f7DrBUknNOSTvCZeCqzbXdn2eVrS\nUUk31d3nguv1kKQzkv4ne419vOw242v6AJLq0uEPgAYgVAAkRagASIpQAZAUoQIgKUIFQFKECoCk\n/h+9QcZO3frUoAAAAABJRU5ErkJggg==\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0x7fe36aa15390>"
+       "<matplotlib.image.AxesImage at 0x1548c5576c50>"
       ]
      },
+     "execution_count": 25,
      "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -765,14 +751,12 @@
   {
    "cell_type": "code",
    "execution_count": 26,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "fuel_or = openmc.ZCylinder(R=0.39)\n",
-    "clad_ir = openmc.ZCylinder(R=0.40)\n",
-    "clad_or = openmc.ZCylinder(R=0.46)"
+    "fuel_or = openmc.ZCylinder(r=0.39)\n",
+    "clad_ir = openmc.ZCylinder(r=0.40)\n",
+    "clad_or = openmc.ZCylinder(r=0.46)"
    ]
   },
   {
@@ -785,9 +769,7 @@
   {
    "cell_type": "code",
    "execution_count": 27,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "fuel_region = -fuel_or\n",
@@ -805,17 +787,15 @@
   {
    "cell_type": "code",
    "execution_count": 28,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/romano/openmc/openmc/mixin.py:61: IDWarning: Another Cell instance already exists with id=1.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Cell instance already exists with id=1.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/romano/openmc/openmc/mixin.py:61: IDWarning: Another Cell instance already exists with id=2.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Cell instance already exists with id=2.\n",
       "  warn(msg, IDWarning)\n"
      ]
     }
@@ -843,9 +823,7 @@
   {
    "cell_type": "code",
    "execution_count": 29,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "pitch = 1.26\n",
@@ -865,9 +843,7 @@
   {
    "cell_type": "code",
    "execution_count": 30,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "water_region = +left & -right & +bottom & -top & +clad_or\n",
@@ -887,9 +863,7 @@
   {
    "cell_type": "code",
    "execution_count": 31,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -918,9 +892,7 @@
   {
    "cell_type": "code",
    "execution_count": 32,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "water_region = box & +clad_or"
@@ -936,9 +908,7 @@
   {
    "cell_type": "code",
    "execution_count": 33,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -985,9 +955,7 @@
   {
    "cell_type": "code",
    "execution_count": 34,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "point = openmc.stats.Point((0, 0, 0))\n",
@@ -1004,9 +972,7 @@
   {
    "cell_type": "code",
    "execution_count": 35,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "settings = openmc.Settings()\n",
@@ -1019,9 +985,7 @@
   {
    "cell_type": "code",
    "execution_count": 36,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -1063,9 +1027,7 @@
   {
    "cell_type": "code",
    "execution_count": 37,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "cell_filter = openmc.CellFilter(fuel)\n",
@@ -1084,9 +1046,7 @@
   {
    "cell_type": "code",
    "execution_count": 38,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "t.nuclides = ['U235']\n",
@@ -1103,9 +1063,7 @@
   {
    "cell_type": "code",
    "execution_count": 39,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -1144,7 +1102,6 @@
    "cell_type": "code",
    "execution_count": 40,
    "metadata": {
-    "collapsed": false,
     "scrolled": true
    },
    "outputs": [
@@ -1152,74 +1109,73 @@
      "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",
-      "                   #################     %%%%%%%%%%%%%%%%%\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",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.9.0\n",
-      "          Git SHA1 | 168f202e3ecf48cdd15b541dc396b24465832986\n",
-      "         Date/Time | 2017-12-12 15:10:36\n",
+      "           Version | 0.11.0-dev\n",
+      "          Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n",
+      "         Date/Time | 2019-07-19 06:20:10\n",
       "    OpenMP Threads | 4\n",
       "\n",
       " Reading settings XML file...\n",
-      " Reading materials 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 U235 from /home/romano/openmc/scripts/nndc_hdf5/U235.h5\n",
-      " Reading U238 from /home/romano/openmc/scripts/nndc_hdf5/U238.h5\n",
-      " Reading O16 from /home/romano/openmc/scripts/nndc_hdf5/O16.h5\n",
-      " Reading Zr90 from /home/romano/openmc/scripts/nndc_hdf5/Zr90.h5\n",
-      " Reading Zr91 from /home/romano/openmc/scripts/nndc_hdf5/Zr91.h5\n",
-      " Reading Zr92 from /home/romano/openmc/scripts/nndc_hdf5/Zr92.h5\n",
-      " Reading Zr94 from /home/romano/openmc/scripts/nndc_hdf5/Zr94.h5\n",
-      " Reading Zr96 from /home/romano/openmc/scripts/nndc_hdf5/Zr96.h5\n",
-      " Reading H1 from /home/romano/openmc/scripts/nndc_hdf5/H1.h5\n",
-      " Reading O17 from /home/romano/openmc/scripts/nndc_hdf5/O17.h5\n",
-      " Reading c_H_in_H2O from /home/romano/openmc/scripts/nndc_hdf5/c_H_in_H2O.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for U235\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 Zr90 from /opt/data/hdf5/nndc_hdf5_v15/Zr90.h5\n",
+      " Reading Zr91 from /opt/data/hdf5/nndc_hdf5_v15/Zr91.h5\n",
+      " Reading Zr92 from /opt/data/hdf5/nndc_hdf5_v15/Zr92.h5\n",
+      " Reading Zr94 from /opt/data/hdf5/nndc_hdf5_v15/Zr94.h5\n",
+      " Reading Zr96 from /opt/data/hdf5/nndc_hdf5_v15/Zr96.h5\n",
+      " Reading H1 from /opt/data/hdf5/nndc_hdf5_v15/H1.h5\n",
+      " Reading O17 from /opt/data/hdf5/nndc_hdf5_v15/O17.h5\n",
+      " Reading c_H_in_H2O from /opt/data/hdf5/nndc_hdf5_v15/c_H_in_H2O.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.32572                       \n",
-      "        2/1    1.46138                       \n",
-      "        3/1    1.46068                       \n",
-      "        4/1    1.39592                       \n",
-      "        5/1    1.37519                       \n",
-      "        6/1    1.38777                       \n",
-      "        7/1    1.50242                       \n",
-      "        8/1    1.42042                       \n",
-      "        9/1    1.47458                       \n",
-      "       10/1    1.49148                       \n",
-      "       11/1    1.39339                       \n",
+      "  Bat./Gen.      k            Average k\n",
+      "  =========   ========   ====================\n",
+      "        1/1    1.32572\n",
+      "        2/1    1.46138\n",
+      "        3/1    1.46068\n",
+      "        4/1    1.39592\n",
+      "        5/1    1.37519\n",
+      "        6/1    1.38777\n",
+      "        7/1    1.50242\n",
+      "        8/1    1.42042\n",
+      "        9/1    1.47458\n",
+      "       10/1    1.49148\n",
+      "       11/1    1.39339\n",
       "       12/1    1.40637    1.39988 +/- 0.00649\n",
       "       13/1    1.42972    1.40983 +/- 0.01063\n",
       "       14/1    1.46319    1.42317 +/- 0.01531\n",
@@ -1313,40 +1269,30 @@
       "\n",
       " =======================>     TIMING STATISTICS     <=======================\n",
       "\n",
-      " Total time for initialization     =  1.5898E+00 seconds\n",
-      "   Reading cross sections          =  1.4448E+00 seconds\n",
-      " Total time in simulation          =  8.3458E+00 seconds\n",
-      "   Time in transport only          =  7.7626E+00 seconds\n",
-      "   Time in inactive batches        =  6.6138E-01 seconds\n",
-      "   Time in active batches          =  7.6845E+00 seconds\n",
-      "   Time synchronizing fission bank =  7.1921E-03 seconds\n",
-      "     Sampling source sites         =  4.8562E-03 seconds\n",
-      "     SEND/RECV source sites        =  2.0519E-03 seconds\n",
-      "   Time accumulating tallies       =  2.3785E-04 seconds\n",
-      " Total time for finalization       =  3.0973E-03 seconds\n",
-      " Total time elapsed                =  9.9670E+00 seconds\n",
-      " Calculation Rate (inactive)       =  15120.0 neutrons/second\n",
-      " Calculation Rate (active)         =  11711.9 neutrons/second\n",
+      " Total time for initialization     = 7.5853e-01 seconds\n",
+      "   Reading cross sections          = 7.3383e-01 seconds\n",
+      " Total time in simulation          = 6.5719e+00 seconds\n",
+      "   Time in transport only          = 5.9772e+00 seconds\n",
+      "   Time in inactive batches        = 4.8850e-01 seconds\n",
+      "   Time in active batches          = 6.0834e+00 seconds\n",
+      "   Time synchronizing fission bank = 5.9939e-03 seconds\n",
+      "     Sampling source sites         = 5.1295e-03 seconds\n",
+      "     SEND/RECV source sites        = 7.3640e-04 seconds\n",
+      "   Time accumulating tallies       = 9.9301e-05 seconds\n",
+      " Total time for finalization       = 1.1585e-04 seconds\n",
+      " Total time elapsed                = 7.3346e+00 seconds\n",
+      " Calculation Rate (inactive)       = 20471.0 particles/second\n",
+      " Calculation Rate (active)         = 14794.4 particles/second\n",
       "\n",
       " ============================>     RESULTS     <============================\n",
       "\n",
-      " k-effective (Collision)     =  1.39737 +/-  0.00470\n",
-      " k-effective (Track-length)  =  1.40141 +/-  0.00513\n",
-      " k-effective (Absorption)    =  1.39596 +/-  0.00308\n",
-      " Combined k-effective        =  1.39719 +/-  0.00286\n",
-      " Leakage Fraction            =  0.00000 +/-  0.00000\n",
+      " k-effective (Collision)     = 1.39737 +/- 0.00470\n",
+      " k-effective (Track-length)  = 1.40141 +/- 0.00513\n",
+      " k-effective (Absorption)    = 1.39596 +/- 0.00308\n",
+      " Combined k-effective        = 1.39719 +/- 0.00286\n",
+      " Leakage Fraction            = 0.00000 +/- 0.00000\n",
       "\n"
      ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 40,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1363,23 +1309,20 @@
   {
    "cell_type": "code",
    "execution_count": 41,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\r\n",
       " ============================>     TALLY 1     <============================\r\n",
       "\r\n",
       " Cell 1\r\n",
       "   U235\r\n",
-      "     Total Reaction Rate                  0.731003       +/- 2.53759E-03\r\n",
-      "     Fission Rate                         0.547587       +/- 2.10114E-03\r\n",
-      "     Absorption Rate                      0.657406       +/- 2.45390E-03\r\n",
-      "     (n,gamma)                            0.109821       +/- 3.68054E-04\r\n"
+      "     Total Reaction Rate                  0.731003 +/- 0.00253759\r\n",
+      "     Fission Rate                         0.547587 +/- 0.00210114\r\n",
+      "     Absorption Rate                      0.657406 +/- 0.0024539\r\n",
+      "     (n,gamma)                            0.109821 +/- 0.000368054\r\n"
      ]
     }
    ],
@@ -1399,9 +1342,7 @@
   {
    "cell_type": "code",
    "execution_count": 42,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "p = openmc.Plot()\n",
@@ -1422,9 +1363,7 @@
   {
    "cell_type": "code",
    "execution_count": 43,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -1459,79 +1398,65 @@
   {
    "cell_type": "code",
    "execution_count": 44,
-   "metadata": {
-    "collapsed": false
-   },
+   "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",
-      "                   #################     %%%%%%%%%%%%%%%%%\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",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.9.0\n",
-      "          Git SHA1 | 168f202e3ecf48cdd15b541dc396b24465832986\n",
-      "         Date/Time | 2017-12-12 15:10:46\n",
+      "           Version | 0.11.0-dev\n",
+      "          Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n",
+      "         Date/Time | 2019-07-19 06:20:18\n",
       "    OpenMP Threads | 4\n",
       "\n",
       " Reading settings XML file...\n",
-      " Reading materials 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 tallies XML file...\n",
       " Reading plot XML file...\n",
       "\n",
       " =======================>     PLOTTING SUMMARY     <========================\n",
       "\n",
-      " Plot ID:               1\n",
-      " Plot file:             pinplot.ppm\n",
-      " Universe depth:        -1\n",
-      " Plot Type:             Slice\n",
-      " Origin:                0.0 0.0 0.0\n",
-      " Width:                 1.26000 1.26000\n",
-      " Coloring:              Materials\n",
-      " Basis:                 xy\n",
-      " Pixels:                200 200\n",
+      "Plot ID: 1\n",
+      "Plot file: pinplot.ppm\n",
+      "Universe depth: -1\n",
+      "Plot Type: Slice\n",
+      "Origin: 0 0 0\n",
+      "Width: 1.26 1.26\n",
+      "Coloring: Materials\n",
+      "Basis: XY\n",
+      "Pixels: 200 200 \n",
       "\n",
-      " Processing plot 1: pinplot.ppm ...\n"
+      " Processing plot 1: pinplot.ppm...\n"
      ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 44,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -1548,9 +1473,7 @@
   {
    "cell_type": "code",
    "execution_count": 45,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "!convert pinplot.ppm pinplot.png"
@@ -1567,13 +1490,12 @@
    "cell_type": "code",
    "execution_count": 46,
    "metadata": {
-    "collapsed": false,
     "scrolled": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAgMAAADQNkYNAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///8AAP9yEhL//wDh\n3HbeAAAAAWJLR0QAiAUdSAAAAAd0SU1FB+EMDAgKL8HHtFUAAAKHSURBVGje7dlLjoJAEAZgMrNj\n4z28hKcYFhzBU5hwAFfsTQwJcIqJyzkNcU3SAw2j/agq4Zegk3Rv9Ut3VSt0V0XR/PE1ewQSSCCB\nBHIfSTGT1Hrk00lSj6OYTOrbyCeS/Z3U00hqiLqaQpLaGsUEsrdJ/Zg4kxDTRI8m8afxyPi9Q/ca\nZRLtkiFd5fDqjcmkRdQkZbRR3WhHk4tkCD7aqWFEWyIBDtHBHzaj6OYhEuAQvaxPdRtN7K/MJnpd\nB2WMb39lNunzVW5M0sZezmziTTJOk7Mk8SYZpylY0q/rtLOJ+nBXZpE+xZ+OUM3WSbNF+nW5kygV\nO8GYJPGD/0tAwZCUWtewsoohe3Jdw8p4ciKEuvCk+ySjSGPHb5A++g1F2q0Vv0FSJhQdTEUSLhQ3\nGJtkNGk4woUyBJMTJGFD0cEUNGFC0cFQJJVJRZOMIw1N9mz0Q/wE6RLGRa+UmTKTlDyJKSIlzE7Z\nM0RKmJ0ykxx50lJEyrGdZZPwCdNZJkgpkZgg3bYIQv3cN8YgJ4lcSHKWyNUnibgtemOKRchRIq1P\nUnEn9V5WixBpJ/vtd8mDzTe3/zkiiv4XswQ5yeTikXoCyRcgZ5lcX0YymTSBWOTR08J8XqxK3jZj\n70ze9l+5xkMJeFqu9Rhf45UEvCvXeYkDp4t1jj3AeQw79c0+WwInWOicPPs0Dpz5gZvFOlce4C6G\n3PiAeyVwewXuyMBNHLjvA1UFpHYBVEiAOgxQ7QFqSkjlCqiPAVU4oNYHVBSRuiVQHQVqsEClF6kn\nA1VroDaOVOCBOj/QTUB6FkBnBOm/AF0eoJeEdKyAvhjSfUN6fEgnEehX6pkK7pP/1+ENJJBAAnkF\n+QXfoOhE52QgVwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNy0xMi0xMlQxNToxMDo0NyswNzowMJPh\nN3AAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTctMTItMTJUMTU6MTA6NDcrMDc6MDDivI/MAAAAAElF\nTkSuQmCC\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAgMAAADQNkYNAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEUAAP9yEhL//////wAZPRNOAAAAAWJLR0QCZgt8ZAAAAAd0SU1FB+MHEwEUEnBdK8cAAAI7SURBVGje7ZmxkcIwEEUhcAnuhxIIEIGvAwioxiU4QASU4GougA4gsM6SfNxh766sfx7N3Ix+zJv9X7KxtLtaZWVlZWWl1Fr12sQQpXLaRRMRTKFe2kbk+Na8POpNkbbmWlMqtkwxRsJllIotMxQ56F7neWX8LmrdGtNpPWc//Z4cLsbpfp6xN85XNRA904Sd2V/stXlJ16EFcL4O7Q/SnUPOrK/9xfzSvQ44K0dFhjLCmq0nRYYyvDPrq2rfka4RnVlfoyJ9GdGZ9XUdI89aWGYbpTITNUKYgvLlnXFhSsqXd7bjEcKXc8YhvYEjhdzY/Db9lUKebP4+/b6lkK7m8nNRhDAlE8WFoREuig/DpKej+DAbGmGiuDAUUsgItWR8ejZ/yaZ3+SmET+/zL4JIC8Ys2VpI7/JPkSKEbCnkyiNPCilDyI5A+AVzSzZFVAhRBCKssVvlBRB5W8iNwZCThDymiLyT5F5iSCsh3RSRN5/cfgwxoiikkpFmgqgwopZAPmTkcxnkKCO3BZDQs088/RhykpFHRjLyP5AE70uadz/Z/1iK/2TgYwF9klJ8K4GPeJrTBXDsSXMeS3O2RA69wNEaOMAD1wTgMgJceYCLVZobH3IVBS68wLUauLwDLQKgEYG0O4CmCtC6ARpEQBsKaXYBLTWgcQe0B4EmJNLqBBqqQNsWaA4jLWig0Q2005GmPTAaAAYQyJgDGKYgIxtgMISMn4AhFzJKAwZ2yFgQGT4iI86srKysrD/rC4LWcCSWwIp+AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA3LTE5VDA2OjIwOjE4LTA1OjAwIrpoEwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wNy0xOVQwNjoyMDoxOC0wNTowMFPn0K8AAAAASUVORK5CYII=\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -1592,29 +1514,28 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "That was a little bit cumbersome. Thankfully, OpenMC provides us with a function that does all that \"boilerplate\" work."
+    "That was a little bit cumbersome. Thankfully, OpenMC provides us with a method on the `Plot` class that does all that \"boilerplate\" work."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 47,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAgMAAADQNkYNAAAABGdBTUEAALGPC/xhBQAAACBjSFJN\nAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEX///8AAP9yEhL//wDh\n3HbeAAAAAWJLR0QAiAUdSAAAAAd0SU1FB+EMDAgKL8HHtFUAAAKHSURBVGje7dlLjoJAEAZgMrNj\n4z28hKcYFhzBU5hwAFfsTQwJcIqJyzkNcU3SAw2j/agq4Zegk3Rv9Ut3VSt0V0XR/PE1ewQSSCCB\nBHIfSTGT1Hrk00lSj6OYTOrbyCeS/Z3U00hqiLqaQpLaGsUEsrdJ/Zg4kxDTRI8m8afxyPi9Q/ca\nZRLtkiFd5fDqjcmkRdQkZbRR3WhHk4tkCD7aqWFEWyIBDtHBHzaj6OYhEuAQvaxPdRtN7K/MJnpd\nB2WMb39lNunzVW5M0sZezmziTTJOk7Mk8SYZpylY0q/rtLOJ+nBXZpE+xZ+OUM3WSbNF+nW5kygV\nO8GYJPGD/0tAwZCUWtewsoohe3Jdw8p4ciKEuvCk+ySjSGPHb5A++g1F2q0Vv0FSJhQdTEUSLhQ3\nGJtkNGk4woUyBJMTJGFD0cEUNGFC0cFQJJVJRZOMIw1N9mz0Q/wE6RLGRa+UmTKTlDyJKSIlzE7Z\nM0RKmJ0ykxx50lJEyrGdZZPwCdNZJkgpkZgg3bYIQv3cN8YgJ4lcSHKWyNUnibgtemOKRchRIq1P\nUnEn9V5WixBpJ/vtd8mDzTe3/zkiiv4XswQ5yeTikXoCyRcgZ5lcX0YymTSBWOTR08J8XqxK3jZj\n70ze9l+5xkMJeFqu9Rhf45UEvCvXeYkDp4t1jj3AeQw79c0+WwInWOicPPs0Dpz5gZvFOlce4C6G\n3PiAeyVwewXuyMBNHLjvA1UFpHYBVEiAOgxQ7QFqSkjlCqiPAVU4oNYHVBSRuiVQHQVqsEClF6kn\nA1VroDaOVOCBOj/QTUB6FkBnBOm/AF0eoJeEdKyAvhjSfUN6fEgnEehX6pkK7pP/1+ENJJBAAnkF\n+QXfoOhE52QgVwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNy0xMi0xMlQxNToxMDo0NyswNzowMJPh\nN3AAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTctMTItMTJUMTU6MTA6NDcrMDc6MDDivI/MAAAAAElF\nTkSuQmCC\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAgMAAADQNkYNAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEUAAP9yEhL//////wAZPRNOAAAAAWJLR0QCZgt8ZAAAAAd0SU1FB+MHEwEUEnBdK8cAAAI7SURBVGje7ZmxkcIwEEUhcAnuhxIIEIGvAwioxiU4QASU4GougA4gsM6SfNxh766sfx7N3Ix+zJv9X7KxtLtaZWVlZWWl1Fr12sQQpXLaRRMRTKFe2kbk+Na8POpNkbbmWlMqtkwxRsJllIotMxQ56F7neWX8LmrdGtNpPWc//Z4cLsbpfp6xN85XNRA904Sd2V/stXlJ16EFcL4O7Q/SnUPOrK/9xfzSvQ44K0dFhjLCmq0nRYYyvDPrq2rfka4RnVlfoyJ9GdGZ9XUdI89aWGYbpTITNUKYgvLlnXFhSsqXd7bjEcKXc8YhvYEjhdzY/Db9lUKebP4+/b6lkK7m8nNRhDAlE8WFoREuig/DpKej+DAbGmGiuDAUUsgItWR8ejZ/yaZ3+SmET+/zL4JIC8Ys2VpI7/JPkSKEbCnkyiNPCilDyI5A+AVzSzZFVAhRBCKssVvlBRB5W8iNwZCThDymiLyT5F5iSCsh3RSRN5/cfgwxoiikkpFmgqgwopZAPmTkcxnkKCO3BZDQs088/RhykpFHRjLyP5AE70uadz/Z/1iK/2TgYwF9klJ8K4GPeJrTBXDsSXMeS3O2RA69wNEaOMAD1wTgMgJceYCLVZobH3IVBS68wLUauLwDLQKgEYG0O4CmCtC6ARpEQBsKaXYBLTWgcQe0B4EmJNLqBBqqQNsWaA4jLWig0Q2005GmPTAaAAYQyJgDGKYgIxtgMISMn4AhFzJKAwZ2yFgQGT4iI86srKysrD/rC4LWcCSWwIp+AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA3LTE5VDA2OjIwOjE4LTA1OjAwIrpoEwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wNy0xOVQwNjoyMDoxOC0wNTowMFPn0K8AAAAASUVORK5CYII=\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
+     "execution_count": 47,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "openmc.plot_inline(p)"
+    "p.to_ipython_image()"
    ]
   }
  ],
@@ -1635,9 +1556,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.0"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
 }
diff --git a/examples/jupyter/post-processing.ipynb b/examples/jupyter/post-processing.ipynb
index a6d134b54..22ccb2b5b 100644
--- a/examples/jupyter/post-processing.ipynb
+++ b/examples/jupyter/post-processing.ipynb
@@ -203,7 +203,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -236,63 +236,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Instantiate a Plot\n",
-    "plot = openmc.Plot(plot_id=1)\n",
-    "plot.filename = 'materials-xy'\n",
-    "plot.origin = [0, 0, 0]\n",
-    "plot.width = [1.26, 1.26]\n",
-    "plot.pixels = [250, 250]\n",
-    "plot.color_by = 'material'\n",
-    "\n",
-    "# Instantiate a Plots collection and export to \"plots.xml\"\n",
-    "plot_file = openmc.Plots([plot])\n",
-    "plot_file.export_to_xml()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With the plots.xml file, we can now generate and view the plot. OpenMC outputs plots in .ppm format, which can be converted into a compressed format like .png with the convert utility."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run openmc in plotting mode\n",
-    "openmc.plot_geometry(output=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEVyEhLpgJFNv8T///98iBL0AAAAAWJLR0QDEQxM8gAAAAd0SU1FB+MEAw4yF98MNh4AAAKlSURBVGje7ZrBscIwDETxwSWkn5TAgXCgBPqhBA6kyj/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+0h4eHh4eHh8cW8QcxLJDBvLKoigAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wNC0wM1QxNDo1MDoyMy0wNTowMKoZjXIAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDQtMDNUMTQ6NTA6MjMtMDU6MDDbRDXOAAAAAElFTkSuQmCC\n",
+      "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": [
        "<IPython.core.display.Image object>"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# Convert OpenMC's funky ppm to png\n",
-    "!convert materials-xy.ppm materials-xy.png\n",
-    "\n",
-    "# Display the materials plot inline\n",
-    "Image(filename='materials-xy.png')"
+    "plot = openmc.Plot.from_geometry(geometry)\n",
+    "plot.pixels = (250, 250)\n",
+    "plot.to_ipython_image()"
    ]
   },
   {
@@ -304,7 +266,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -314,7 +276,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +298,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -353,7 +315,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {
     "scrolled": true
    },
@@ -389,21 +351,21 @@
       "                   | 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.10.0\n",
-      "          Git SHA1 | cc09ba4a5bf2edd95624e386b72803d83ddc9f4f\n",
-      "         Date/Time | 2019-04-03 14:50:23\n",
-      "    OpenMP Threads | 2\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 /home/shriwise/opt/openmc/xs/nndc_hdf5/U235.h5\n",
-      " Reading U238 from /home/shriwise/opt/openmc/xs/nndc_hdf5/U238.h5\n",
-      " Reading O16 from /home/shriwise/opt/openmc/xs/nndc_hdf5/O16.h5\n",
-      " Reading H1 from /home/shriwise/opt/openmc/xs/nndc_hdf5/H1.h5\n",
-      " Reading B10 from /home/shriwise/opt/openmc/xs/nndc_hdf5/B10.h5\n",
-      " Reading Zr90 from /home/shriwise/opt/openmc/xs/nndc_hdf5/Zr90.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 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",
@@ -427,67 +389,119 @@
       "       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.03092    1.04065 +/- 0.00310\n",
-      "       16/1    1.04653    1.04163 +/- 0.00271\n",
-      "       17/1    1.04114    1.04156 +/- 0.00229\n",
-      "       18/1    1.06033    1.04391 +/- 0.00307\n",
-      "       19/1    1.04163    1.04365 +/- 0.00272\n",
-      "       20/1    1.04992    1.04428 +/- 0.00251\n",
-      "       21/1    1.01577    1.04169 +/- 0.00345\n",
-      "       22/1    1.03611    1.04122 +/- 0.00318\n",
-      "       23/1    1.03251    1.04055 +/- 0.00300\n",
-      "       24/1    1.03996    1.04051 +/- 0.00278\n",
-      "       25/1    1.06132    1.04190 +/- 0.00294\n",
-      "       26/1    1.03581    1.04152 +/- 0.00277\n",
-      "       27/1    1.05195    1.04213 +/- 0.00268\n",
-      "       28/1    1.03721    1.04186 +/- 0.00254\n",
-      "       29/1    1.03475    1.04148 +/- 0.00243\n",
-      "       30/1    1.03057    1.04094 +/- 0.00237\n",
-      "       31/1    1.04407    1.04109 +/- 0.00226\n",
-      "       32/1    1.04661    1.04134 +/- 0.00217\n",
-      "       33/1    1.03286    1.04097 +/- 0.00210\n",
-      "       34/1    1.01253    1.03978 +/- 0.00234\n",
-      "       35/1    1.03488    1.03959 +/- 0.00225\n",
-      "       36/1    1.02509    1.03903 +/- 0.00223\n",
-      "       37/1    1.03647    1.03894 +/- 0.00215\n",
-      "       38/1    1.06387    1.03983 +/- 0.00226\n",
-      "       39/1    1.02418    1.03929 +/- 0.00224\n",
-      "       40/1    1.05815    1.03992 +/- 0.00226\n",
-      "       41/1    1.04433    1.04006 +/- 0.00219\n",
-      "       42/1    1.04627    1.04025 +/- 0.00213\n",
-      "       43/1    1.05089    1.04057 +/- 0.00209\n",
-      "       44/1    1.02985    1.04026 +/- 0.00205\n",
-      "       45/1    1.06236    1.04089 +/- 0.00209\n",
-      "       46/1    1.04283    1.04094 +/- 0.00203\n",
-      "       47/1    1.04404    1.04103 +/- 0.00197\n",
-      "       48/1    1.05946    1.04151 +/- 0.00198\n",
-      "       49/1    1.03286    1.04129 +/- 0.00194\n",
-      "       50/1    1.07609    1.04216 +/- 0.00208\n",
-      "       51/1    1.02097    1.04164 +/- 0.00210\n",
-      "       52/1    1.08390    1.04265 +/- 0.00228\n",
-      "       53/1    1.01654    1.04204 +/- 0.00231\n",
-      "       54/1    1.02701    1.04170 +/- 0.00228\n",
-      "       55/1    1.04845    1.04185 +/- 0.00223\n",
-      "       56/1    1.05401    1.04212 +/- 0.00220\n",
-      "       57/1    1.04673    1.04221 +/- 0.00216\n",
-      "       58/1    1.04093    1.04219 +/- 0.00211\n",
-      "       59/1    1.03205    1.04198 +/- 0.00208\n",
-      "       60/1    1.05368    1.04221 +/- 0.00205\n",
-      "       61/1    1.02273    1.04183 +/- 0.00204\n",
-      "       62/1    1.03259    1.04165 +/- 0.00201\n",
-      "       63/1    1.06216    1.04204 +/- 0.00201\n",
-      "       64/1    1.03658    1.04194 +/- 0.00198\n",
-      "       65/1    1.02072    1.04155 +/- 0.00198\n",
-      "       66/1    1.03019    1.04135 +/- 0.00195\n",
-      "       67/1    1.05241    1.04155 +/- 0.00193\n",
-      "       68/1    1.05906    1.04185 +/- 0.00192\n",
-      "       69/1    1.05263    1.04203 +/- 0.00190\n",
-      "       70/1    1.02176    1.04169 +/- 0.00189\n",
-      "       71/1    1.03390    1.04157 +/- 0.00187\n",
-      "       72/1    1.05470    1.04178 +/- 0.00185\n",
-      "       73/1    1.03892    1.04173 +/- 0.00182\n",
-      "       74/1    0.98570    1.04086 +/- 0.00199\n",
-      "       75/1    1.02591    1.04063 +/- 0.00198\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"
      ]
     }
    ],
@@ -512,7 +526,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {
     "scrolled": true
    },
@@ -531,9 +545,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "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)"
@@ -548,9 +577,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "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"
    ]
@@ -564,9 +616,52 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "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)"
@@ -581,9 +676,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "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",
@@ -599,7 +709,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -611,9 +721,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x14d12e58cb38>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "fig = plt.subplot(121)\n",
     "fig.imshow(flux.mean)\n",
@@ -630,9 +763,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAE2VJREFUeJzt3X+MZeV93/H3pxiwY0csP7ar7e66i+tVLCeKMZ1SIkeVy9YNPywvfziItCortNJGCWnt0CrGjdQ6VSthqS02akW0NY6XxLEhxBYrB6VBC1bbP8AeDMb8CGGMIburhR0TwHFonBB/+8c86727ndm5d+feucOz75d0Nec85znnPufRnc8889xzz01VIUnq19+adgMkSZNl0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TODRX0SX41yRNJHk/yhSRvTnJhkoeSzCW5M8lZre7ZbX2ubd86yROQJJ3cskGfZBPwr4CZqvop4AzgWuCTwC1V9U7gZWBX22UX8HIrv6XVkyRNyZtGqPeWJH8N/BhwGLgM+Gdt+17gE8BtwI62DHA38N+SpE7yEdwLLrigtm7dOmrbJem09vDDD3+3qtYvV2/ZoK+qQ0n+M/CnwP8F/gh4GHilql5v1Q4Cm9ryJuBA2/f1JK8C5wPfXeo5tm7dyuzs7HJNkSQNSPL8MPWGmbo5l4VR+oXA3wHeCly+otYtHHd3ktkks/Pz8ys9nCRpCcO8GftPgO9U1XxV/TXwJeB9wLokR/8j2AwcasuHgC0Abfs5wEsnHrSq9lTVTFXNrF+/7H8ekqRTNEzQ/ylwaZIfSxJgO/Ak8ADw4VZnJ3BPW97X1mnb7z/Z/LwkabKWDfqqeoiFN1W/AXyr7bMH+BhwY5I5Fubgb2+73A6c38pvBG6aQLslSUPKWhhsz8zMlG/GStJokjxcVTPL1fOTsZLUOYNekjpn0EtS5wx6SercsLdAkMZq601/sGj5czdftcotkfrniF6SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnfOmZpqopW5eJmn1LDuiT/ITSR4deHwvyUeTnJfkviTPtJ/ntvpJcmuSuSSPJbl48qchSVrKMF8O/nRVXVRVFwF/H3gN+DILX/q9v6q2Afs59iXgVwDb2mM3cNskGi5JGs6oc/TbgW9X1fPADmBvK98LXN2WdwB31IIHgXVJNo6ltZKkkY0a9NcCX2jLG6rqcFt+AdjQljcBBwb2OdjKJElTMHTQJzkL+BDweyduq6oCapQnTrI7yWyS2fn5+VF2lSSNYJSrbq4AvlFVL7b1F5NsrKrDbWrmSCs/BGwZ2G9zKztOVe0B9gDMzMyM9EdCa8+4rq7xKwal8Rtl6uYXODZtA7AP2NmWdwL3DJRf166+uRR4dWCKR5K0yoYa0Sd5K/AB4BcHim8G7kqyC3geuKaV3wtcCcyxcIXO9WNrrSRpZEMFfVX9BXD+CWUvsXAVzol1C7hhLK2TJK2Yn4zVG4Jz99Kp8143ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TO+cUjekPzC0mk5Q01ok+yLsndSf44yVNJfibJeUnuS/JM+3luq5sktyaZS/JYkosnewqSpJMZdurm08AfVtW7gPcATwE3Afurahuwv60DXAFsa4/dwG1jbbEkaSTLBn2Sc4B/BNwOUFV/VVWvADuAva3aXuDqtrwDuKMWPAisS7Jx7C2XJA1lmBH9hcA88FtJHknymSRvBTZU1eFW5wVgQ1veBBwY2P9gK5MkTcEwQf8m4GLgtqp6L/AXHJumAaCqCqhRnjjJ7iSzSWbn5+dH2VWSNIJhrro5CBysqofa+t0sBP2LSTZW1eE2NXOkbT8EbBnYf3MrO05V7QH2AMzMzIz0R0LTs9RVLpLWrmVH9FX1AnAgyU+0ou3Ak8A+YGcr2wnc05b3Ade1q28uBV4dmOKRJK2yYa+j/5fA55OcBTwLXM/CH4m7kuwCngeuaXXvBa4E5oDXWl1J0pQMFfRV9Sgws8im7YvULeCGFbZLkjQm3gJBkjpn0EtS5wx6SeqcQS9JnfPuleqSd7WUjnFEL0mdM+glqXMGvSR1zjl6nVacu9fpyBG9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pyXV2pRfmWg1A9H9JLUOYNekjo3VNAneS7Jt5I8mmS2lZ2X5L4kz7Sf57byJLk1yVySx5JcPMkTkCSd3Cgj+n9cVRdV1dHvjr0J2F9V24D9bR3gCmBbe+wGbhtXYyVJo1vJ1M0OYG9b3gtcPVB+Ry14EFiXZOMKnkeStALDBn0Bf5Tk4SS7W9mGqjrcll8ANrTlTcCBgX0PtjJJ0hQMe3nlz1bVoSR/G7gvyR8PbqyqSlKjPHH7g7Eb4O1vf/sou0qSRjDUiL6qDrWfR4AvA5cALx6dkmk/j7Tqh4AtA7tvbmUnHnNPVc1U1cz69etP/QwkSSe1bNAneWuSHz+6DPxT4HFgH7CzVdsJ3NOW9wHXtatvLgVeHZjikSStsmGmbjYAX05ytP7vVtUfJvk6cFeSXcDzwDWt/r3AlcAc8Bpw/dhbLUka2rJBX1XPAu9ZpPwlYPsi5QXcMJbWSZJWzE/GSlLnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOb9KUGLpr0587uarVrkl0vg5opekzhn0ktQ5g16SOmfQS1LnDHpJ6pxX3ZzGlrrSRFJfHNFLUucMeknqnEEvSZ0z6CWpc0MHfZIzkjyS5Ctt/cIkDyWZS3JnkrNa+dltfa5t3zqZpkuShjHKiP4jwFMD658EbqmqdwIvA7ta+S7g5VZ+S6snSZqSoYI+yWbgKuAzbT3AZcDdrcpe4Oq2vKOt07Zvb/UlSVMw7Ij+U8CvAT9s6+cDr1TV6239ILCpLW8CDgC07a+2+pKkKVg26JN8EDhSVQ+P84mT7E4ym2R2fn5+nIeWJA0YZkT/PuBDSZ4DvsjClM2ngXVJjn6ydjNwqC0fArYAtO3nAC+deNCq2lNVM1U1s379+hWdhCRpacsGfVV9vKo2V9VW4Frg/qr658ADwIdbtZ3APW15X1unbb+/qmqsrZYkDW0l19F/DLgxyRwLc/C3t/LbgfNb+Y3ATStroiRpJUa6qVlVfRX4alt+FrhkkTp/Cfz8GNomSRoDPxkrSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUuZHuXqk3pq03/cG0myBpihzRS1LnHNFLJ3Gy/4aeu/mqVWyJdOoc0UtS5wx6SercskGf5M1Jvpbkm0meSPIbrfzCJA8lmUtyZ5KzWvnZbX2ubd862VOQJJ3MMCP6HwCXVdV7gIuAy5NcCnwSuKWq3gm8DOxq9XcBL7fyW1o9SdKULBv0teD7bfXM9ijgMuDuVr4XuLot72jrtO3bk2RsLZYkjWSoOfokZyR5FDgC3Ad8G3ilql5vVQ4Cm9ryJuAAQNv+KnD+OBstSRreUEFfVX9TVRcBm4FLgHet9ImT7E4ym2R2fn5+pYeTJC1hpKtuquoV4AHgZ4B1SY5eh78ZONSWDwFbANr2c4CXFjnWnqqaqaqZ9evXn2LzJUnLGeaqm/VJ1rXltwAfAJ5iIfA/3KrtBO5py/vaOm37/VVV42y0JGl4w3wydiOwN8kZLPxhuKuqvpLkSeCLSf4j8Ahwe6t/O/DbSeaAPwOunUC7palb6lOzfmJWa82yQV9VjwHvXaT8WRbm608s/0vg58fSOknSivnJWEnqnEEvSZ0z6CWpc96muCN+wYikxTiil6TOGfSS1DmDXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOmfQS1LnDHpJ6pxBL0mdG+bLwbckeSDJk0meSPKRVn5ekvuSPNN+ntvKk+TWJHNJHkty8aRPQpK0tGFG9K8D/7qq3g1cCtyQ5N3ATcD+qtoG7G/rAFcA29pjN3Db2FstSRraMF8Ofhg43Jb/PMlTwCZgB/D+Vm0v8FXgY638jqoq4MEk65JsbMeRurfUF8A8d/NVq9wSacFIc/RJtgLvBR4CNgyE9wvAhra8CTgwsNvBViZJmoKhgz7J24DfBz5aVd8b3NZG7zXKEyfZnWQ2yez8/Pwou0qSRjBU0Cc5k4WQ/3xVfakVv5hkY9u+ETjSyg8BWwZ239zKjlNVe6pqpqpm1q9ff6rtlyQtY5irbgLcDjxVVf91YNM+YGdb3gncM1B+Xbv65lLgVefnJWl6ln0zFngf8C+AbyV5tJX9W+Bm4K4ku4DngWvatnuBK4E54DXg+rG2WJI0kmGuuvk/QJbYvH2R+gXcsMJ2SZLGZJgRvdaYpS7fk6TFeAsESeqcQS9JnXPqRlolfmJW0+KIXpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOucnY9cwb14maRwc0UtS5wx6SeqcUzfSlHmzM02aI3pJ6twwXw7+2SRHkjw+UHZekvuSPNN+ntvKk+TWJHNJHkty8SQbL0la3jAj+s8Bl59QdhOwv6q2AfvbOsAVwLb22A3cNp5mSpJO1bJBX1X/C/izE4p3AHvb8l7g6oHyO2rBg8C6JBvH1VhJ0uhOdY5+Q1UdbssvABva8ibgwEC9g61MkjQlK34ztqoKqFH3S7I7yWyS2fn5+ZU2Q5K0hFO9vPLFJBur6nCbmjnSyg8BWwbqbW5l/5+q2gPsAZiZmRn5D4XUOy+71Lic6oh+H7CzLe8E7hkov65dfXMp8OrAFI8kaQqWHdEn+QLwfuCCJAeBfw/cDNyVZBfwPHBNq34vcCUwB7wGXD+BNnfHe9pImqRlg76qfmGJTdsXqVvADSttlCRpfLwFgtQJ5/S1FINeeoNxqk+j8l43ktQ5g16SOmfQS1LnDHpJ6pxvxq4i30TTNHg1jhzRS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqtuJsCrayStJY7oJalzjuil05TX158+DHpJxzmVqUf/OKxtBv0KOBcv6Y3AoJe0Yk4DrW0TCfoklwOfBs4APlNVN0/ieVaLI3dJb2RjD/okZwD/HfgAcBD4epJ9VfXkuJ9L0trmSH9tmMSI/hJgrqqeBUjyRWAHsOaD3pG7tDpG/QMwrt/N0/UPzCSCfhNwYGD9IPAPJ/A8gOEs9WTSv8+jHr+XPwxTezM2yW5gd1v9fpKnp9WWMboA+O60G7GG2B/H2BfHe0P0Rz65ak91qv3xd4epNImgPwRsGVjf3MqOU1V7gD0TeP6pSTJbVTPTbsdaYX8cY18cz/443qT7YxK3QPg6sC3JhUnOAq4F9k3geSRJQxj7iL6qXk/yK8D/ZOHyys9W1RPjfh5J0nAmMkdfVfcC907i2GtcV1NRY2B/HGNfHM/+ON5E+yNVNcnjS5KmzNsUS1LnDPoBSS5P8nSSuSQ3LbL97CR3tu0PJdk6sO3jrfzpJD/XyrYkeSDJk0meSPKRgfqfSHIoyaPtceVqnOMoJtAfb07ytSTfbP3xGwP1L2zHmGvHPGs1znEUq9wfn0vynYHXx0WrcY7DGndfDGw7I8kjSb4yUHbavTYGti3WH6O/NqrKx8L01RnAt4F3AGcB3wTefUKdXwZ+sy1fC9zZlt/d6p8NXNiOcwawEbi41flx4E+OHhP4BPBvpn3eq9wfAd7W6pwJPARc2tbvAq5ty78J/NK0+2DK/fE54MPTPu/V6ouB/W4Efhf4ykDZaffaWKY/Rn5tOKI/5ke3bqiqvwKO3rph0A5gb1u+G9ieJK38i1X1g6r6DjAHXFJVh6vqGwBV9efAUyx8cviNYBL9UVX1/Vb/zPaots9l7Ri0Y149qRM7RavWH5M+kTEYe18AJNkMXAV85uhBTtfXBizeH6fKoD9msVs3nBjKP6pTVa8DrwLnD7Nv+1ftvSyM2o76lSSPJflsknNXfgpjNZH+aP+KPgocAe6rqofaPq+0Yyz1XNO2mv1x1H9qr49bkpw9zpNZoUn9rnwK+DXghwPbT9vXBov3x1EjvTYM+lWQ5G3A7wMfrarvteLbgL8HXAQcBv7LlJq3qqrqb6rqIhY+MX1Jkp+adpum6ST98XHgXcA/AM4DPjalJq6KJB8EjlTVw9Nuy1qwTH+M/Now6I8Z5tYNP6qT5E3AOcBLJ9s3yZkshPznq+pLRytU1Yvtl/yHwP+g/bu2hkykP46qqleAB4DL2z7r2jGWeq5pW83+oE37VVX9APgt1tbrYxJ98T7gQ0meY2Hq47Ikv8Pp+9pYqj9O7bUx7Tcy1sqDhQ+PPcvCGyJH31D5yRPq3MDxb6jc1ZZ/kuPfUHmWY2+23QF8apHn2ziw/KsszNNNvR8m3B/rgXWtzluA/w18sK3/Hse/4fbL0+6DKffHxvYzLPwLf/O0+2CSfXHCvu/n+DcfT7vXxjL9MfJrY+qdtJYewJUsXBnzbeDXW9l/AD7Ult/cXnRzwNeAdwzs++ttv6eBK1rZz7Lw5tpjwKPtcWXb9tvAt9q2fQwE/1p5TKA/fhp4pJ3z48C/G6j/jnaMuXbMs6d9/lPuj/vb6+Nx4HdoV+eslce4++KEY58YbKfda2OZ/hj5teEnYyWpc87RS1LnDHpJ6pxBL0mdM+glqXMGvSR1zqCXpM4Z9JLUOYNekjr3/wC9QY3h+aqkMQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Determine relative error\n",
     "relative_error = np.zeros_like(flux.std_dev)\n",
@@ -659,9 +805,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "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', '<f8'), ('y', '<f8'), ('z', '<f8')]), ('u', [('x', '<f8'), ('y', '<f8'), ('z', '<f8')]), ('E', '<f8'), ('wgt', '<f8'), ('delayed_group', '<i4'), ('particle', '<i4')])"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "sp.source"
    ]
@@ -675,9 +839,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1780128.70101981, 1553436.10501094,  829530.02360943, ...,\n",
+       "        807617.55637656, 6036005.44157462, 4923751.04163063])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "sp.source['E']"
    ]
@@ -691,9 +867,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9999999999999999\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Probability/eV')"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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",
@@ -719,9 +925,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "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": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "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",
@@ -748,7 +977,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/search.ipynb b/examples/jupyter/search.ipynb
index 6031c4c4d..bfdc20695 100644
--- a/examples/jupyter/search.ipynb
+++ b/examples/jupyter/search.ipynb
@@ -35,7 +35,7 @@
     "\n",
     "To perform the search we will use the `openmc.search_for_keff` function.  This function requires a different function be defined which creates an parametrized model to analyze. This model is required to be stored in an `openmc.model.Model` object. The first parameter of this function will be modified during the search process for our critical eigenvalue.\n",
     "\n",
-    "Our model will be a pin-cell from the [Multi-Group Mode Part II](http://openmc.readthedocs.io/en/latest/examples/mg-mode-part-ii.html) assembly, except this time the entire model building process will be contained within a function, and the Boron concentration will be parametrized."
+    "Our model will be a pin-cell from the [Multi-Group Mode Part II](http://docs.openmc.org/en/latest/examples/mg-mode-part-ii.html) assembly, except this time the entire model building process will be contained within a function, and the Boron concentration will be parametrized."
    ]
   },
   {
@@ -64,7 +64,7 @@
     "\n",
     "    # Include the amount of boron in the water based on the ppm,\n",
     "    # neglecting the other constituents of boric acid\n",
-    "    water.add_element('B', ppm_Boron * 1E-6)\n",
+    "    water.add_element('B', ppm_Boron * 1e-6)\n",
     "    \n",
     "    # Instantiate a Materials object\n",
     "    materials = openmc.Materials([fuel, zircaloy, water])\n",
@@ -141,7 +141,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -156,7 +156,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -171,7 +171,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -186,7 +186,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -201,7 +201,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -216,7 +216,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -231,7 +231,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -246,7 +246,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -261,7 +261,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/shriwise/.pyenv/versions/3.6.7/lib/python3.6/site-packages/openmc-0.10.0-py3.6-linux-x86_64.egg/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Universe instance already exists with id=0.\n",
       "  warn(msg, IDWarning)\n"
      ]
     },
@@ -277,7 +277,7 @@
    "source": [
     "# Perform the search\n",
     "crit_ppm, guesses, keffs = openmc.search_for_keff(build_model, bracket=[1000., 2500.],\n",
-    "                                                  tol=1.E-2, bracketed_method='bisect',\n",
+    "                                                  tol=1e-2, bracketed_method='bisect',\n",
     "                                                  print_iterations=True)\n",
     "\n",
     "print('Critical Boron Concentration: {:4.0f} ppm'.format(crit_ppm))"
@@ -344,7 +344,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/tally-arithmetic.ipynb b/examples/jupyter/tally-arithmetic.ipynb
index 35c096ba4..40eb2b05f 100644
--- a/examples/jupyter/tally-arithmetic.ipynb
+++ b/examples/jupyter/tally-arithmetic.ipynb
@@ -10,9 +10,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "import glob\n",
@@ -39,9 +37,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# 1.6 enriched fuel\n",
@@ -74,9 +70,7 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate a Materials collection\n",
@@ -96,14 +90,12 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
+   "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",
+    "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",
     "# Use both reflective and vacuum boundaries to make life interesting\n",
@@ -125,9 +117,7 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create a Universe to encapsulate a fuel pin\n",
@@ -162,9 +152,7 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create root Cell\n",
@@ -189,9 +177,7 @@
   {
    "cell_type": "code",
    "execution_count": 7,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create Geometry and set root Universe\n",
@@ -201,9 +187,7 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Export to \"geometry.xml\"\n",
@@ -220,9 +204,7 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# OpenMC simulation parameters\n",
@@ -256,10 +238,19 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAADFBMVEVyEhLpgJFNv8T///98iBL0AAAAAWJLR0QDEQxM8gAAAAd0SU1FB+MHEhEzAhO1TdMAAAKlSURBVGje7ZrBscIwDETxwSWkn5TAgXCgBPqhBA6kyj/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+0h4eHh4eHh8cW8QcxLJDBvLKoigAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxOS0wNy0xOFQyMjo1MTowMi0wNTowMAMmdtQAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTktMDctMThUMjI6NTE6MDItMDU6MDBye85oAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Instantiate a Plot\n",
     "plot = openmc.Plot(plot_id=1)\n",
@@ -269,51 +260,8 @@
     "plot.pixels = [250, 250]\n",
     "plot.color_by = 'material'\n",
     "\n",
-    "# Instantiate a Plots collection and export to \"plots.xml\"\n",
-    "plot_file = openmc.Plots([plot])\n",
-    "plot_file.export_to_xml()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With the plots.xml file, we can now generate and view the plot. OpenMC outputs plots in .ppm format, which can be converted into a compressed format like .png with the convert utility."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run openmc in plotting mode\n",
-    "openmc.plot_geometry(output=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAD6AgMAAAD1grKuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdC\nAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAxQTFRF\n////chIS6YCRTb/E6kGE+wAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAALKSURB\nVGje7dpLcqQwDAbgHHE2YeEj+D4cwQucBUfo+3CEXoSp8OhuhF70T4qpKXmdr21LogK2Pj7A8QmN\nP+HDhw8fPnz48Kf6VH9G+66vy+je8k19jnf8C5dXIPv86ms56lPdjvaYbyodx3ze+XLE76cXFiD4\nzPji99z0/AJ4n1lfvJ6fnl0A6x+578efMSg1wPr172/jPO5yFXM+Ef78gdblM+WPHyguP//t1/g6\npA0wfln+ho/fwgYYn19C/xwDvwHGc9OvC+hs37DTrwuwfWanXxdQTC9Mvyygs3wjTL8uwPJpn/tN\nDbSGz7T0SBEWw4vLXzbQ6b6RoveIoO6TvPxlA63qs7z8ZQPF9F+SH22vbX8OQKf5Rtv+EgDNJ3X5\n8wZaxWd1+fMGiuFvir8bvjp8J/tGy/6jAmRvhW8fwL3vVT+o3grfPoB7r/IpALI3tz8FoJN84/NV\n873hB8UnM3xzANtf8nb4dwmg3grfFEDJO8JPE0i9Ff4pAYL3pI8mkHor/HMCeO9JH00g9SafEsh7\nT/ppARBvp48UwJnelT5SACd7O31TAlnvKx9SQCd7B58KgPO+8iMFuPWe9E8F8BveWX7bAjzX9y4/\n/Jve+fhsH6Ctv7n8PTzjvY/v9gEOHz58+PBX+6v/f/wPvnd54f3j6venE/yl769Xv7+j3x/o98/V\n32/o9+fl389Xnx+g5x/o+Qt6/oOeP6HnX+j5G3z+h54/ouefV5/foufP6Pk3ev4On/+j9w/o/Qd6\n/4Le/6D3T/D9V67Y/ZsVQBq+s+8f0ftP+P41axXguP9NWgDuu/Cdfv+N3r/D9/9TAID+A7T/Ae2/\ngPs/0P4TtP8F7r9J3AIO9P+g/Udw/9Oygbf7r9D+L7j/DO1/Q/vv4P4/tP8Q7n9E+y/h/k+0/xTu\nf4X7b+H+X7T/+BPuf3aM8OHDhw8fPnz4w/4vzcvgeY10sY0AAAAldEVYdGRhdGU6Y3JlYXRlADIw\nMTgtMDQtMDNUMjE6MTE6MzgtMDQ6MDD1dVTHAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE4LTA0LTAz\nVDIxOjExOjM4LTA0OjAwhCjsewAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Convert OpenMC's funky ppm to png\n",
-    "!convert materials-xy.ppm materials-xy.png\n",
-    "\n",
-    "# Display the materials plot inline\n",
-    "Image(filename='materials-xy.png')"
+    "# Show plot\n",
+    "openmc.plot_inline(plot)"
    ]
   },
   {
@@ -325,10 +273,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate an empty Tallies object\n",
@@ -337,10 +283,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 12,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create Tallies to compute microscopic multi-group cross-sections\n",
@@ -397,10 +341,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 13,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# K-Eigenvalue (infinity) tallies\n",
@@ -413,10 +355,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 14,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Resonance Escape Probability tallies\n",
@@ -428,10 +368,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 15,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Thermal Flux Utilization tallies\n",
@@ -444,10 +382,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 16,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Fast Fission Factor tallies\n",
@@ -459,10 +395,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 17,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Instantiate energy filter to illustrate Tally slicing\n",
@@ -479,18 +413,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/liangjg/.local/lib/python3.5/site-packages/openmc-0.10.0-py3.5.egg/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=6.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=6.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/liangjg/.local/lib/python3.5/site-packages/openmc-0.10.0-py3.5.egg/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=3.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=3.\n",
       "  warn(msg, IDWarning)\n",
-      "/home/liangjg/.local/lib/python3.5/site-packages/openmc-0.10.0-py3.5.egg/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n",
+      "/home/romano/openmc/openmc/mixin.py:71: IDWarning: Another Filter instance already exists with id=2.\n",
       "  warn(msg, IDWarning)\n"
      ]
     }
@@ -509,7 +443,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 19,
    "metadata": {
     "scrolled": true
    },
@@ -518,66 +452,63 @@
      "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",
-      "                   #################     %%%%%%%%%%%%%%%%%\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-2018 Massachusetts Institute of Technology\n",
+      "         Copyright | 2011-2019 MIT and OpenMC contributors\n",
       "           License | http://openmc.readthedocs.io/en/latest/license.html\n",
-      "           Version | 0.10.0\n",
-      "          Git SHA1 | 47fbf8282ea94c138f75219bd10fdb31501d3fb7\n",
-      "         Date/Time | 2018-04-03 21:12:27\n",
-      "     MPI Processes | 1\n",
-      "    OpenMP Threads | 20\n",
+      "           Version | 0.11.0-dev\n",
+      "          Git SHA1 | 61c911cffdae2406f9f4bc667a9a6954748bb70c\n",
+      "         Date/Time | 2019-07-18 22:51:02\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 U235 from /home/liangjg/nucdata/nndc_hdf5/U235.h5\n",
-      " Reading U238 from /home/liangjg/nucdata/nndc_hdf5/U238.h5\n",
-      " Reading O16 from /home/liangjg/nucdata/nndc_hdf5/O16.h5\n",
-      " Reading H1 from /home/liangjg/nucdata/nndc_hdf5/H1.h5\n",
-      " Reading B10 from /home/liangjg/nucdata/nndc_hdf5/B10.h5\n",
-      " Reading Zr90 from /home/liangjg/nucdata/nndc_hdf5/Zr90.h5\n",
-      " Maximum neutron transport energy: 2.00000E+07 eV for U235\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    0.96168                       \n",
-      "        2/1    0.96651                       \n",
-      "        3/1    1.00678                       \n",
-      "        4/1    0.98773                       \n",
-      "        5/1    1.01883                       \n",
-      "        6/1    1.02959                       \n",
+      "  Bat./Gen.      k            Average k\n",
+      "  =========   ========   ====================\n",
+      "        1/1    0.96168\n",
+      "        2/1    0.96651\n",
+      "        3/1    1.00678\n",
+      "        4/1    0.98773\n",
+      "        5/1    1.01883\n",
+      "        6/1    1.02959\n",
       "        7/1    0.99859    1.01409 +/- 0.01550\n",
       "        8/1    1.03441    1.02086 +/- 0.01123\n",
       "        9/1    1.06097    1.03089 +/- 0.01279\n",
@@ -596,28 +527,28 @@
       "\n",
       " =======================>     TIMING STATISTICS     <=======================\n",
       "\n",
-      " Total time for initialization     =  4.9090E-01 seconds\n",
-      "   Reading cross sections          =  4.2387E-01 seconds\n",
-      " Total time in simulation          =  1.4928E+00 seconds\n",
-      "   Time in transport only          =  1.3545E+00 seconds\n",
-      "   Time in inactive batches        =  1.3625E-01 seconds\n",
-      "   Time in active batches          =  1.3565E+00 seconds\n",
-      "   Time synchronizing fission bank =  2.4053E-03 seconds\n",
-      "     Sampling source sites         =  1.6466E-03 seconds\n",
-      "     SEND/RECV source sites        =  5.6159E-04 seconds\n",
-      "   Time accumulating tallies       =  3.3647E-04 seconds\n",
-      " Total time for finalization       =  1.6066E-02 seconds\n",
-      " Total time elapsed                =  2.0336E+00 seconds\n",
-      " Calculation Rate (inactive)       =  91743.2 neutrons/second\n",
-      " Calculation Rate (active)         =  27644.5 neutrons/second\n",
+      " Total time for initialization     = 3.4427e-01 seconds\n",
+      "   Reading cross sections          = 3.1628e-01 seconds\n",
+      " Total time in simulation          = 3.7319e+00 seconds\n",
+      "   Time in transport only          = 3.6302e+00 seconds\n",
+      "   Time in inactive batches        = 4.9601e-01 seconds\n",
+      "   Time in active batches          = 3.2359e+00 seconds\n",
+      "   Time synchronizing fission bank = 2.8100e-03 seconds\n",
+      "     Sampling source sites         = 2.4682e-03 seconds\n",
+      "     SEND/RECV source sites        = 3.2484e-04 seconds\n",
+      "   Time accumulating tallies       = 4.4538e-05 seconds\n",
+      " Total time for finalization       = 9.3656e-04 seconds\n",
+      " Total time elapsed                = 4.0859e+00 seconds\n",
+      " Calculation Rate (inactive)       = 25201.2 particles/second\n",
+      " Calculation Rate (active)         = 11588.7 particles/second\n",
       "\n",
       " ============================>     RESULTS     <============================\n",
       "\n",
-      " k-effective (Collision)     =  1.02889 +/-  0.00492\n",
-      " k-effective (Track-length)  =  1.02842 +/-  0.00527\n",
-      " k-effective (Absorption)    =  1.02637 +/-  0.00349\n",
-      " Combined k-effective        =  1.02700 +/-  0.00291\n",
-      " Leakage Fraction            =  0.01717 +/-  0.00107\n",
+      " k-effective (Collision)     = 1.02889 +/- 0.00492\n",
+      " k-effective (Track-length)  = 1.02842 +/- 0.00527\n",
+      " k-effective (Absorption)    = 1.02637 +/- 0.00349\n",
+      " Combined k-effective        = 1.02700 +/- 0.00291\n",
+      " Leakage Fraction            = 0.01717 +/- 0.00107\n",
       "\n"
      ]
     }
@@ -643,9 +574,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 20,
    "metadata": {
-    "collapsed": true,
     "scrolled": true
    },
    "outputs": [],
@@ -665,13 +595,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -699,7 +642,7 @@
        "0   total  (nu-fission / (absorption + current)) 1.02e+00   6.65e-03"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -729,13 +672,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -770,7 +726,7 @@
        "0  ((absorption + current) / (absorption + current)) 6.94e-01   4.61e-03  "
       ]
      },
-     "execution_count": 24,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -794,13 +750,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -835,7 +804,7 @@
        "0 1.20e+00   9.61e-03  "
       ]
      },
-     "execution_count": 25,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -858,13 +827,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -901,7 +883,7 @@
        "0 7.49e-01   6.09e-03  "
       ]
      },
-     "execution_count": 26,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -922,13 +904,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -965,7 +960,7 @@
        "0 1.66e+00   1.44e-02  "
       ]
      },
-     "execution_count": 27,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -985,13 +980,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1026,7 +1034,7 @@
        "0  ((absorption + current) / (absorption + current)) 9.85e-01   5.51e-03  "
       ]
      },
-     "execution_count": 28,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1045,13 +1053,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1086,7 +1107,7 @@
        "0  (absorption / (absorption + current)) 9.97e-01   7.55e-03  "
       ]
      },
-     "execution_count": 29,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1105,13 +1126,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1148,7 +1182,7 @@
        "0  (((((((absorption + current) / (absorption + c... 1.02e+00   1.88e-02  "
       ]
      },
-     "execution_count": 30,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1169,9 +1203,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 29,
    "metadata": {
-    "collapsed": true,
     "scrolled": true
    },
    "outputs": [],
@@ -1185,13 +1218,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1312,7 +1358,7 @@
        "7     (scatter / flux) 3.36e-03   1.34e-05  "
       ]
      },
-     "execution_count": 32,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1331,18 +1377,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[[  6.65948580e-07]\n",
-      "  [  3.56632881e-01]]\n",
+      "[[[6.65948580e-07]\n",
+      "  [3.56632881e-01]]\n",
       "\n",
-      " [[  7.25130446e-03]\n",
-      "  [  7.92016892e-03]]]\n"
+      " [[7.25130446e-03]\n",
+      "  [7.92016892e-03]]]\n"
      ]
     }
    ],
@@ -1361,16 +1407,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[[ 0.00555547]]\n",
+      "[[[0.00555547]]\n",
       "\n",
-      " [[ 0.00335828]]]\n"
+      " [[0.00335828]]]\n"
      ]
     }
    ],
@@ -1383,15 +1429,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[[ 0.22726611]\n",
-      "  [ 0.00335828]]]\n"
+      "[[[0.22726611]\n",
+      "  [0.00335828]]]\n"
      ]
     }
    ],
@@ -1412,13 +1458,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1491,7 +1550,7 @@
        "3   5.98e-04  "
       ]
      },
-     "execution_count": 36,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1504,13 +1563,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
        "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
        "<table border=\"1\" class=\"dataframe\">\n",
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
@@ -1643,7 +1715,7 @@
        "8   2.90e-03  "
       ]
      },
-     "execution_count": 37,
+     "execution_count": 35,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1673,7 +1745,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.7"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/examples/jupyter/triso.ipynb b/examples/jupyter/triso.ipynb
index 36e0c1f14..1934433e9 100644
--- a/examples/jupyter/triso.ipynb
+++ b/examples/jupyter/triso.ipynb
@@ -10,9 +10,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -33,9 +31,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "fuel = openmc.Material(name='Fuel')\n",
@@ -81,13 +77,11 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Create TRISO universe\n",
-    "spheres = [openmc.Sphere(R=r*1e-4)\n",
+    "spheres = [openmc.Sphere(r=1e-4*r)\n",
     "           for r in [215., 315., 350., 385.]]\n",
     "cells = [openmc.Cell(fill=fuel, region=-spheres[0]),\n",
     "         openmc.Cell(fill=buff, region=+spheres[0] & -spheres[1]),\n",
@@ -107,9 +101,7 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "min_x = openmc.XPlane(x0=-0.5, boundary_type='reflective')\n",
@@ -148,9 +140,7 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "trisos = [openmc.model.TRISO(outer_radius, triso_univ, c) for c in centers]"
@@ -166,9 +156,7 @@
   {
    "cell_type": "code",
    "execution_count": 7,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -199,9 +187,7 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -228,9 +214,7 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -278,9 +262,7 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "box.fill = lattice"
@@ -296,19 +278,18 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
+     "execution_count": 12,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -325,7 +306,7 @@
     "settings.export_to_xml()\n",
     "\n",
     "p = openmc.Plot.from_geometry(geom)\n",
-    "openmc.plot_inline(p)"
+    "p.to_ipython_image()"
    ]
   },
   {
@@ -338,25 +319,24 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQBAMAAABykSv/AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAFVBMVEWAgIA4vPKTUVDpgJFyEhJNv8T///9LU0IfAAAAAWJLR0QGYWa4fQAAAAd0SU1FB+MHEwESG1/bNOUAABwzSURBVHja7V3ZdeO4EhUyMJVByxnIzsByBlL+qYxEYqkdVQBp93un8TXjpkhcLLUvp9O/8W/8G//Gv3HsSMtzvP32LObHE8Xl8n+AJD1hvMb/OpIXjo/nuPxZfnsqc2M5P3Hcvl5I3n57LjPjuSEfn7fn+Pq4/MKWLLt9M53fVxy328f1x7dkT3L53JBbHsdsSTLmuqxjn8/UDXkerusBQBZjsk+M5z87bckTyBPC9+OxAtn/bC0bbZeRPHFcnsRyl+VL68l6PFYkH7sDybT9KtL29MLxQrLHV5fL57ohj8f9dUn8r9TWER+j5fL+pO0vJMJs9wXyuiKPx7YlX/7bnpRzj6/28+B+FIq4CM/uKFJgIP7brtHNhG524VErRXzjz+4I5EW0vuNAVAaASBQgiRIhWQoQ31eT+diLaGUg992AlH9I58qjJCYVA5JsjnMokJWS3DZC8twS/pLI0eoIAcuRR6tdQJG220De6MO2EDBKtTyXPbXtvstADPJLZ92TZhqQexiI9PdEr8jDWKXtkogvYhLasthnCzNEmbNLc07aSxHRqrstX0BDRFmiQDbCsuG4ybLWsKidLvX+yUCSPrsBIFD6lYD0bpkXyE2gJPrBV4AYX1saEFkf6S3FDBD1qnEg3fVsUsSXfrIOA6JPSwRizaLKdTfZ+pCW7qb6gMTUNs7Hu8v5krQ3AfWi0MHzZRzIbRDIic+6dyzSeTVrySrDHJAeH9lr5Im/iPnHx0Ux0L32eAZIk38CWlvsM+XkZ0nBUPlG6e9qD3jY3HZ+tPklc6oC1UpOMraS9u8sNB5lNUNc1ZpYYkDce7TZzIqJ5qArsso5noVlnKhYeBw/Pfe4rTixKBCvckZIerbwuJA0M6bXZhY2olZdwPUsntz7Rq4dv13Klngt5ClMWbJ2FrcpFUngy+OGeJn6P7wPr8i9B34eSD0trkVeMrd1epE6nMAAUg568q5Cx8IjIQkYGAYsXXhH/CcTeCFcLC6tRMW78RW2f0sQED8Fy+pLtou4LnBEC3gCeddM3iqQRrVe//l+dSFJTeo4gseN+GXbLqRMUK+OownkwPv+Ukd1MEcE5WbBeOH4fFEhB2dY3SmPo+TAsqTB254P70sfqfS093uoKx0KJPCrQqkq9/XQU2BhPUDFGDpaVR8JuXWPBVL4ZzQIY8URc+tCIPdDgETJbx2bqfG7mP47M9sZCGUwy4QPK+bW3fdoCarnoAR4irp1F0S1vnTcycFdBSU6IGOwt4UcJF7y65FLJNPfRAxcEIiPs7v0o1We/BP053iB9MgWkbX+KE+5RN7tGP0RTLyOaSduiIw5EauF52bsX72zcSDPH9vwG1xK8WIRA0gf0UiDT5vKTw1ciE10J0sQ9IZ6NESfnSUVIPEbsRp56Ro0guryhqa2JR/GyXrvSxrjQJZmdqdAOt5Q/JYWJ6M8nFwWh2EgJQqTmGYc3lD2mud7vhR3ir5i0mNDd0QxluVD/30P2EXebX1ysT0u9bFlTBzRzJddb6i2kovxgA/I+TLAxlWDMgD44bSgPmdgRSI6gQz6wlQTP/CGeo0JvbAQ3x0Z9BfrTpfioO5+2DvS2UN+R0MRdDdYoZa7BcdnPtJX9NIADssxuR2FMQVTAfJCckwih+Uq3jVsNa/Mvi+Ek7Wc9y/6MRoCBN7x1v477B0IAdHDKcIOLzYwBYr7a3YCUtGM4zjDLYh70HYEMh4F1Bw0fxCSI3D0gUzYL6o7ALLyo1LPepE6dkBK7+VrmpbPnj8NxI7UifhI+Hj++NNrz98FiB6p81KXNh/JgJjSpLX9Umn0BTGDiZsCOyKnAMF6pzQti+6YkTop4iPhr26WleDPlTCjbBZTwjatSJ251LelF3Gr/lBmN7Y1yYzU6Qb/mst6zi7ru9P3Xn8oSzIK4amnbXlXI3Vq6pvTAHGSf/24hdK0NiH5ylY+R4tiYg7CywqNFIJIqiVlKPWt2YNdlrE2YdlqBON3W5g9ENCbOYit+ers+Y5PhS5D6Nclcujjg1oMhZOTTTfb7umqdDPSjYS1jgKRM+LEu7yCrruXVlhXgRoAP9RAYMYgEJQRR992K6mq5dkaJLYdrrNMn0dz+GaAtKuAic9Sj3m7rzWmoTyqqQmzQBDV8gMRzfooxSjTQEF0kH2Us0ery0cEBq6l9oE0vLq/btFh7rJDzi5yIfEg5Mlt6AGdlfIJy0rdetxhjvz2Fky+mjVHEYtMUN0oQBqj6p3dOYb4+rkl/a5xbUx0qqF4dwPIbSVbTQXprfOciIL0Ef4ZxYBapXEHEP8VnhIaAUuQzOA5ro1aZANAAC266z7xMpMJMb7ol6IZvG4X2a0IkHcA5GYCmVOsquAtqZdaSrvrsm8JZhEgU6ruptIpNhjVUZYVPQf5DQCZMz6cDH+gqs+li5shRoDMmYNOup0yM/DvdUsuspTbE1HQZe8AmTPQFSTSn0tc250E4ahAqpRReVqA/J4mTabGa8G8pEuiiPHfsOIMsMm5wmUmjNjGW3XXpVux8oso+RVHGNDxkUeuy6bqYk7JyNywmeZngLiMD28E2yH1jWaBaNFQeafAketIpT8MhMujSqUnnjx8hJV8CIhmcjZMpthIQowPvwIE13ghs5BNCImxgm2Tvn6zdGEayXLlujEy0P0OkJUHhC8qNZKk8UjO/YA0/jZxUdNWrm6PgzUaIK2m6wZd8TvJHWlUgElauu545YJJHINRMqmFg/0h1/eweBVjGPE+XETDcetyYKAc4uktXTA80lkPJeNHXcx/x79NoFwgedWhe7R99ktSILn0T7doEUL+xTBoszjlLuPFWD/pZ9usL3QLeP2il8UU/k1KJv8Bpme5H3nwLj/o7MBIeu7mlbr1g1OngFStlMt9nAj0j7mUTO4Iup8dVqqFdK5T92wIyeSeNIgdgKjy0hA72FammNevS/vbsUpHtqV97wgEmEWylhItXTAyrDCWWSBVAT57kremgUDlaA8gPJuR2K7+RF7nB4I8APgbQ0xMAoIy/g+6JH0gQWmSJMq+DLzLoRn/8LsKkDSSzSIBOTZRHnxXuSNDakXiqcsHJ8oXIFbw3YDGJdyRpblFjgOi+WQAkoEX1pu9Annx3AcAckw4ulnva8D2LeRgLwTI28FA9pEehBzsHzlalvQ7+EJI0Kuf8HCqFS9c5l+ZclgxkKOELUNDHH0hPawJOTyPq+lY6s6Nq6GIuIHwuepeO7K6UltBb0KehQPyzao8F2sXjrktzMpTyyM4jzO3hMRwYNkyZ5yAWFmpAtkB7tnN0jj81mrbaulk1IEo+AkPSTkbtv3mWdI7luge8wBMXwmMESjDSyNRPSY21zCir3xtNjvXX9UorM0RhbvjPU456Kv4CWvk3W/5cflISqIE6cPRgr7yhrznRmF/zZY4vVZbGka5FK166A+k0jlHCfHtGd9Q3ZYWQvhrMQICEFHD5B1e4LUBHc/+HiAgaADYrCV63kgjiIX8tWgHOs4wHqVE/EjlfxD6cM3jw4fUT2Vldqz8z68C6Su6EpB+HeAfBuKxoQiW3sLqjcrMPwvEZWcUdkRk9b8IZBNqrx1xiAPxWDN+kmolIlRYQFAUnccXsgA+cjSQxVmw/Eyj6KASpdnifpCzJ8nHLAIm1nxXaUEg+m9mluNiItx2OxjP/9oAyWEl/eq9lZw/sKxHwOtHE9wS9ypIrwcxLOMxPY6R3F4/unXLxeNCgCX5lolirQ4g7oh14kInvhDtpy0/3+w8Og+EJEMYi0Xyi51AWt6+s4Ta4AhYa1NLGFvTuJELofS34u6JpQhAsVYTUbLgsp/nd+IUPgjkUYBIUlv+U805dsXb5Ap5DsR5nPuumVbfAEXgSTtCqijhqUWUxThdIECEkw7qGyBLpXBHktU+NOKe8ZUfDQKBNcehZisAMYPOIoKwkr6ZUY4BIUX6oDpO+Ygtfi5+z5+Wvrm+RlGdukBqEzl6srl32kotDQVz90LkpPI3vcuuF7LkslZRPkQCG2giZWDWy9/0/LB6/m+Ccv0qDjc5+joJRMl6rAxAipPtMERcUYhgxPoISBUWZhoAQqJm3uC/lGaJ7BYutvsSpapJZwucALuuFZQ5O3dEzeiy2ldS96W4y4+HVFGIi8NmFrqb/CaU6As/ikrovgm/Yu5LvstSQQxiRUFut+KKW6RZ9IAo9elQSw9Ol2GaI7/rVq0VYtcS/YewFzcQUbxAEEewW3rYaY6AFggnD1sa+ZuQZuu2Q6ilD+0K5vYVRQn2DEjCUiQ9WgnJwloKighEVHQ6xfHNmhU2ECJF0sueM6rA2XJ54TQgqdOFvnr9JcGiA4Q4dUgKK+mu7RVptaMlVcTAW3K+qBpoDwhekXcKBMv0PFd0GMhDXlU9fDkI5IPcdfxaZwFhjWrBIyer5UnqhZIXEVKtXmg1vW0FSP2gL2lJKw/aB2Jo+qGaXcCKnBV4ugGuurtJKQ/qAWIsMiDdvajRlWx83moj0tECFErS+RQQS9aSYCOyQahWbPV4zY9JIKC6l8dmAKIetrs3WlSeM+ku1XKsDpYEjaeREy8tmoLtWj0qNXX5SAdIpEIUmfqoF0EuudTj7N3V0ZpPJGG58d/S0IacoFESSgHBRkRsdYp2SbURR/uwNOigKqmzQg0sVfrtrs4iN58YaJ4b+qjggYi1GOSrc96816SAy1AbSv9HpUhIW0P0vpQ2zjpXo6aU+DC9T6I0Y+nsjiFRUdRrlU1hj/BYSZqxrCjul7K1+ZT145mujt1h2LWG3/gps5d6d45xFJ4nS7rxF26Sy51tyaqlfX6JDgGX7NtZQFcjvQAQrUVpAoZskQgINYZC8Mxi9AMLg3vkASDNvyYIAsLdSdHQ+X1TBtQ+kpBAyhnafzx//bGhiW+GyV0uKNYPJuyNNLMEqkCdk/9hMUBzylqx9giOmfuiqjiICBAgL8L5SShnq6cxWuti7sYQII1s6fJpkuIeQN7AaKTgUUDeFWpW0zHQjKmraGAmhwOhqo/ocabOu0Eg45eE3REIRCTLcjYndaeS4ZjhjjuCqNZZByLECNvBhD7ON8keNT4yAOTRTiKakNMEMwlEO0L6HRGBYLO71Euwbyiek0MJdXIB4XfEisFbvCaBNLEfuvSr97tvl/3qAXJM/COPK9JEkdYVgXIGqeEKBFJj8MrjB8Q/ikqELBzqBpvmyobEWggmrBv4EgQiHVC7t14kHorOjgw2V6ICw8jOLhCp55I1mNaWuk/UBa53F6DUTcVCbyF8RyCQpmg6hUlO5BZBQYU+5javUqKeltfTrSs0mV6/7Ia1SR4lIxj2pKSPyN6a6msmJRrVGSTe92O56EBYIeoeDpbXzYHIjEmx/earIBxuXjFKTxMIAgFBFY22L/QZjcPKVgOjmQCrj6jLWlEgjryhGvUr/ZNE8XTLE8siRak0t+s4EE8ElQEEPAN/bPhyKfVTupdEM5pcUYZ94Y0tdKHX6dQbal0my84nAWH9D8RVtIEI6borxfCoPHpaVKhJu9CRQgRiOsuJR5rsUw+J0inOIn7SW4Q2ZhIQ092hRJG742eUpohLDWR33HWpjZm05NbS0loVDb5PnViFQ6EpIuC3XRxet7XpLAfB1xeuTvQtobhRZ2orxmQOC4gSzCltib4Y5bZ+XBGr86oTkFZAv2HA8SW1aNL2RP0XJYkRuEp7E2nUG8sw/ogcPxB9aEmMIeqZ5TuSRePPIt0BCEnXBd6FoBR+ysbhT1i62WtD9N4R6xVK6dKoFL5O+zJaunku2CZ//JMk9dRXFz7nnRWvnuYfPj5iAlGSGIeAhBv4VFlV9wH4gcjpQLrCq79qc9z3+3A2GJVP+2Qta2iZZnEgLYn77jsdkP9Uc+E9sHIuIPbRkmqVRUs3ozbJs1FDY0CSKLpFCzxi49JkR0sTiEZ+UX4DmFis5CZLwQkTFycQXcFTOocEi6ASJ0UtkTHqHFaTGNVwJC1AIFaWlmmWrUDcoG9YW8d1vsKL1QCBfu4zBkJ0/VkvhFqUXLNuLc23iz8ZA8Jbrk6Gu+k1WGHuOJqBIofEgLCiOaAgwyAQWfrVVki3moSAiHkZc1FtvAZrcU6KetGi2bFil930Bg8CoamHdYNFvUhpJ3wKkl/LGzw4aH4YDBEWtlqPdAgxRDVR0fyR+UpSg7XTaAiX6MIuRn+dGXdpGfztXhR/5qkrY6g1HxTzoBGyERIadZed8ZseKYCsGnSgFJcUX1LqvfaL8QNA+pZoULoY5CHKMigBgm40iIju17aIHy2HSb2Js11t1SKbID+2qxst8cvu8g0UOttdVBuIv2+Umic+B6RNpVdyzLgjJ6mTlxYeN8AQY0B6JcfMQLON5H0hA51iNMU5sNLmsyWICDB9VoBlJFaDhjAho6KSwI9oktqZJEAGBEoHc7ZjGIsRu+JQMyx43yQk+4L6U/DtThwecUn14tZVayegxYjw68aqWpe6Xm9gb4e1LEfJsV5ZbRDX1+r3CNyVqgM4Ix8UlRLmsAuQQFMau34PUtDeyPWy9rJsfACISLb8Vc+kajEIJojHI3W9zKJSDnezR8kzmmSKG6JmbW/u69z+NJffyFtgd093RHI4jpanZnN50M6jR9FfsLLBW6fQyybkmoTAA8Sd+ALsMzJ3hQ5HXGvCtJ96/PdQ7VYFB+yONoC0AGLlmDZajQqULWYNoeRxbvq01W6l+ba930BMEN+UqQ9RH3BpMwLE44FafNpq6hGNCuShrgqOIyeXwgLiMtu7tVWH+KYmqJQXIMkKA9n+71uid3o0L3nq1kqOzdloTCA0mzsCxOXaWsAbJntxWUBYYJUM5C4AcZYosEuO7QakFl+p+pf7jjiLRsy4yvmrNCCYjePvblRLX0/skNdVZNhobGpD0CcfxM7PPmLxEVJqwRnrwcNJTiHVDK6JVvtOKnNPODutV6YAsSrECCbTwfQ6tYqUJEnhXgS6AhCo2cNKjvnYn/AirYqUdAOI9NtUMon6+oAkpK22P4SBYOkXXZHmYgGXBOsjUBgeA8LS6ZZhII0bINoj1sfER5qW+RKB3INVlFhgv/uHilQErYD1H0gVPVLmSwUSWd9w1XSyJXRDFKs9tqIUixgLqp6IUHNUdFCOHgyeQEBEgQ7LkayKH9jOxhBDTLu/I5otIJMictJVyRS/RHmpL/bcmOZiPaCFnmetFCuTXhFb/uiiF0CYBWIUt6o3GP6Tv8uI+LWcB5ppYeinHYZYCKeSMcTz7YqZ6HEbEU2VPFBt4uinJhDbuik5NQSlJyA86LWbxA0gSTH2hmThwmtwZiKKEsmmzM+Z8iRFoJjdVqE04QPCHJVKJJvxwc+ugTAcNZWaAO61nLNYi1ipG19eSjiOzaidaKwp1KLEcivmzx0ZOvHQ/hQPdCaG3nirdo+s4SUJEhD/JVnLLX5ljj/Q3a9P5PxEegZIYT1XYnnfr7tqZptZhTgOCJTZq8zh/6ZjpeKCzBCQyjlOJ63E8SSQuGiJLrt/PWs4gFZ0em4MpKPYXjITytv2+92DG8cynVokzZhJbyC6Jq+DQbaGNHtZDQwB+Y4DsVULuDruitVqMWHnjPQKMRZ8u1Q3qSHuAyLrs8NAfN+UIlV0ID4SYkXO7AcEH6StfrHuamc74prZXPyLCwjRkbprN3S0ZMV8VyD0JKVWNVZevHQeuOyR3GLpx5d+3Cy1CnTpy6g9ctA4vH2zz0fYBnQpfsAemZhWP4ZDbxQF1onM28GD3SLKzB6oi6fIWkx1c+hyamMzhsNdJe+t84yU2sM2BOsrDiDORNMXjvdrF4nPsYIbfEiBtdu0m5vFoTn4Ek2dLJCXflK+qaUIwX+Hjq/mKtVVIFfEilJgjMN1GZZ6QZK8Vd3i0OUWRwyRGTwKJ+Dr3aWXusn/zMK+PLqcJ6rLZwACsZeOtkCfN6HUzTZ42Jc2ASqO9aqh+PKcAy14hRp9aEFoJIhiE1yYYGmXl8EBU+r5CzR8RYnt/EUsNkc+29T70S19tJmMvrN3WQWSA7bvN4fyb8UWEiBfW8q4kNjNiH0vPqCVCLUsLTWE/uGxShi+JATknoFIZFPgWnaanN7fC87l7JQR2jeVRyQgpHNzmfQ5JoKrsTIoa0Lp9RYf0tE6Ca1sQs4iEwg6kjuU0JGBbJsrJNh4gbTjRpr5AX8/cMcPGnlEIFIgnthLzwMErLYCJKFmHMuQ0iwOMQ5adHQ6gMAFUIFAsj1k5FG+LUamM2+x67Ij64tyRxbkRN0TiNXfGC12V2nAYrsG5DwBpGvHleLX2Cz7bixktFD4CK5/GgNi23G1+DURiLkhWEZTVogAiVz2TqKRtxhPV7EGDtKPrYV7k7WuCpAI+e1dU7ffOPUVH7QiWPptywrvSIQhdtNRJh0XZEFa3Vd5q3GLuoiI0tXtuxZSLxByJ+StJuK/X2gEZQFUqOc9Op0xKpXErS6cPf/BL8avctOHebZ67hAnEMY3aol+3EQTRdX6FavN2mLnnvUzKJ1AsEgCGkKCV2OFzK/qys2x2CzmLbSC0CZHMWKG5DI+vAimD8gOQ5I+ZY9IInlsfXPQ6xe/CsRjjfcY6JYMxJOfeQyQ5+h91mMy3YD8UM+7SJ96MsvuBNfD+FNANNXWg6R7AJcG+OiTFetTj4fL0ZPPlqOazjCCJpGPd4v2fcih2w37+lpAVQ1Gu0fTA0KfejOfcJWwV16e66so+sfeSMz3Fsv6ABKQFbyI+sdPDoevQ1+jJ4zrRhOn677ODuB9CtNoOZ51Ng95cIDCs+F6LygrMNRIhC7mDg10WzNPXwNxlPCfC69eSwXbsfo3E1QTvGQLRt6Q9JcSmYVw5ux4RFa0BbL8klC57FVTrYI5ydMeVTVTX9ryAAn5jHDwGK5BOaxqrjbjaQGdRPrY7yKKM084HznqNWNl3oqjmMi4SY4kfAmZ8wPD9J8HgHwq0XCCaEOLMOwExBvEYQPRzMiShZJQqX2AhFOOYkCSdANxxYUdgYxKFg4g0sFlFUwp1RqbwflIIGKZL1ZNYpeiIv74oBEgUpNf0jjpxO/MHJDhxu0GEDlcLbGcUyRrDQO5WDvi5a84MLgBkQIIeX0PXBNjTIa174hbUpAZolxjXAAC9JHRCi+FaomRcZZYjNcticHIcpAtBwI1xIkKL++5CYMGRHwndc9in9EmaylFboXSMbTo+siWgG52dMaJ144lGKFdv/mMyuIrKWaMaqEvpdF6IkUhE9Kck57ggBWKMunavDJPT04NkKoStQ2OR0LVKalm7EW3Li5UhJJyYJXa4HJt8lZrxVXNUBh6N1it6kn9p4voM6osQ6vWDkUS9u5xIFZDX1XlZNWkpOIIWq6cycnHgawOUpE46TsiuUtaF/JKnhQgvCjcPkDUxPNyR/i/SEC4qqlmLyr9T/NrBi97/rHyZ4VqidWPFlpRQ20EsIWWKR7J4XJOJj6FN8meOGpX0hsB8CsG37JbIhJ5p7A2iksxkShrtQ+LvtfjIoo19DAxa0nbz/XkcSsAbf8NMaRfgzJDIEaKmRXEtveGrCun/d3jUoQFFn7JSdAHuDEf+6mN23+Plbb6oeEyz0byU34XSfeheFmY30DSn1m8UM9fOkATwL92Q3wjWMzqLx4/FYxz+Ei7OPb+inGExPFv/Bv/xg7jPx00djlxlfHyAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA3LTE5VDA2OjE4OjI3LTA1OjAw0Eg57AAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wNy0xOVQwNjoxODoyNy0wNTowMKEVgVAAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
      },
+     "execution_count": 13,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
     "p.color_by = 'material'\n",
     "p.colors = {graphite: 'gray'}\n",
-    "openmc.plot_inline(p)"
+    "p.to_ipython_image()"
    ]
   }
  ],
@@ -377,7 +357,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,
diff --git a/openmc/mgxs/mgxs.py b/openmc/mgxs/mgxs.py
index 1c8f00f6e..46b004838 100644
--- a/openmc/mgxs/mgxs.py
+++ b/openmc/mgxs/mgxs.py
@@ -2751,7 +2751,7 @@ class TransportXS(MGXS):
             p1_tally = p1_tally.get_slice(filters=[openmc.LegendreFilter],
                                           filter_bins=[('P1',)],
                                           squeeze=True)
-            p1_tally.scores = ['scatter-1']
+            p1_tally._scores = ['scatter-1']
 
             self._rxn_rate_tally = self.tallies['total'] - p1_tally
             self._rxn_rate_tally.sparse = self.sparse

From 481361ae799ae45aae63730530f85f58153db12a Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 8 Jul 2019 14:49:06 -0500
Subject: [PATCH 088/127] Use strings in representation of particle filter

---
 openmc/filter.py                              | 34 ++++++++++++-------
 src/tallies/filter_particle.cpp               | 29 +++++++++++++---
 .../photon_production/inputs_true.dat         |  2 +-
 .../photon_source/inputs_true.dat             |  2 +-
 4 files changed, 49 insertions(+), 18 deletions(-)

diff --git a/openmc/filter.py b/openmc/filter.py
index dbdaf2e19..52ff8638e 100644
--- a/openmc/filter.py
+++ b/openmc/filter.py
@@ -32,7 +32,8 @@ _CURRENT_NAMES = (
     'z-min out', 'z-min in', 'z-max out', 'z-max in'
 )
 
-_PARTICLE_IDS = {'neutron': 1, 'photon': 2, 'electron': 3, 'positron': 4}
+_PARTICLES = {'neutron', 'photon', 'electron', 'positron'}
+
 
 class FilterMeta(ABCMeta):
     def __new__(cls, name, bases, namespace, **kwargs):
@@ -547,10 +548,9 @@ class ParticleFilter(Filter):
 
     Parameters
     ----------
-    bins : str, int, or iterable of Integral
-        The Particles to tally. Either str with particle type or their
-        ID numbers can be used ('neutron' = 1, 'photon' = 2, 'electron' = 3,
-        'positron' = 4).
+    bins : str, or iterable of str
+        The particles to tally represented as strings ('neutron', 'photon',
+        'electron', 'positron').
     filter_id : int
         Unique identifier for the filter
 
@@ -571,16 +571,26 @@ class ParticleFilter(Filter):
     @bins.setter
     def bins(self, bins):
         bins = np.atleast_1d(bins)
-        cv.check_iterable_type('filter bins', bins, (Integral, str))
+        cv.check_iterable_type('filter bins', bins, str)
         for edge in bins:
-            if isinstance(edge, Integral):
-                cv.check_value('filter bin', edge, _PARTICLE_IDS.values())
-            else:
-                cv.check_value('filter bin', edge, _PARTICLE_IDS.keys())
-        bins = np.atleast_1d([b if isinstance(b, Integral) else _PARTICLE_IDS[b]
-                              for b in bins])
+            cv.check_value('filter bin', edge, _PARTICLES)
         self._bins = bins
 
+    @classmethod
+    def from_hdf5(cls, group, **kwargs):
+        if group['type'][()].decode() != cls.short_name.lower():
+            raise ValueError("Expected HDF5 data for filter type '"
+                             + cls.short_name.lower() + "' but got '"
+                             + group['type'][()].decode() + " instead")
+
+        if 'meshes' not in kwargs:
+            raise ValueError(cls.__name__ + " requires a 'meshes' keyword "
+                             "argument.")
+
+        particles = [b.decode() for b in group['bins'][()]]
+        filter_id = int(group.name.split('/')[-1].lstrip('filter '))
+        return cls(particles, filter_id=filter_id)
+
 
 class MeshFilter(Filter):
     """Bins tally event locations onto a regular, rectangular mesh.
diff --git a/src/tallies/filter_particle.cpp b/src/tallies/filter_particle.cpp
index de142489f..eb419fec9 100644
--- a/src/tallies/filter_particle.cpp
+++ b/src/tallies/filter_particle.cpp
@@ -7,12 +7,20 @@ namespace openmc {
 void
 ParticleFilter::from_xml(pugi::xml_node node)
 {
-  auto particles = get_node_array<int>(node, "bins");
+  auto particles = get_node_array<std::string>(node, "bins");
 
   // Convert to vector of Particle::Type
   std::vector<Particle::Type> types;
   for (auto& p : particles) {
-    types.push_back(static_cast<Particle::Type>(p - 1));
+    if (p == "neutron") {
+      types.push_back(Particle::Type::neutron);
+    } else if (p == "photon") {
+      types.push_back(Particle::Type::photon);
+    } else if (p == "electron") {
+      types.push_back(Particle::Type::electron);
+    } else if (p == "positron") {
+      types.push_back(Particle::Type::positron);
+    }
   }
   this->set_particles(types);
 }
@@ -47,9 +55,22 @@ void
 ParticleFilter::to_statepoint(hid_t filter_group) const
 {
   Filter::to_statepoint(filter_group);
-  std::vector<int> particles;
+  std::vector<std::string> particles;
   for (auto p : particles_) {
-    particles.push_back(static_cast<int>(p) + 1);
+    switch (p) {
+    case Particle::Type::neutron:
+      particles.push_back("neutron");
+      break;
+    case Particle::Type::photon:
+      particles.push_back("photon");
+      break;
+    case Particle::Type::electron:
+      particles.push_back("electron");
+      break;
+    case Particle::Type::positron:
+      particles.push_back("positron");
+      break;
+    }
   }
   write_dataset(filter_group, "bins", particles);
 }
diff --git a/tests/regression_tests/photon_production/inputs_true.dat b/tests/regression_tests/photon_production/inputs_true.dat
index f82b4a6a7..1821bea92 100644
--- a/tests/regression_tests/photon_production/inputs_true.dat
+++ b/tests/regression_tests/photon_production/inputs_true.dat
@@ -41,7 +41,7 @@
     <bins>9</bins>
   </filter>
   <filter id="2" type="particle">
-    <bins>2</bins>
+    <bins>photon</bins>
   </filter>
   <tally id="1">
     <filters>1 2</filters>
diff --git a/tests/regression_tests/photon_source/inputs_true.dat b/tests/regression_tests/photon_source/inputs_true.dat
index 425738a47..89f4de0e0 100644
--- a/tests/regression_tests/photon_source/inputs_true.dat
+++ b/tests/regression_tests/photon_source/inputs_true.dat
@@ -36,7 +36,7 @@
 <?xml version='1.0' encoding='utf-8'?>
 <tallies>
   <filter id="1" type="particle">
-    <bins>2</bins>
+    <bins>photon</bins>
   </filter>
   <tally id="1">
     <filters>1</filters>

From 26166553259ae846ebaf92b97769111e149d6f50 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Thu, 18 Jul 2019 16:24:37 -0500
Subject: [PATCH 089/127] Fix use of ENDF_FLOAT_RE in ace.py

---
 openmc/data/ace.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openmc/data/ace.py b/openmc/data/ace.py
index b93de0d24..ee194560b 100644
--- a/openmc/data/ace.py
+++ b/openmc/data/ace.py
@@ -411,7 +411,7 @@ class Library(EqualityMixin):
             # after it). If it's too short, then we apply the ENDF float regular
             # expression. We don't do this by default because it's expensive!
             if xss.size != nxs[1] + 1:
-                datastr = ENDF_FLOAT_RE.sub(r'\1e\2', datastr)
+                datastr = ENDF_FLOAT_RE.sub(r'\1e\2\3', datastr)
                 xss = np.fromstring(datastr, sep=' ')
                 assert xss.size == nxs[1] + 1
 

From 09be1f9293c3517212fa2c31e1d7740b7a0a8467 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Fri, 19 Jul 2019 07:38:24 -0500
Subject: [PATCH 090/127] Update devguide test suite section

---
 docs/source/devguide/tests.rst | 56 ++++++++++++++++++++++------------
 1 file changed, 36 insertions(+), 20 deletions(-)

diff --git a/docs/source/devguide/tests.rst b/docs/source/devguide/tests.rst
index 475d0f69b..b26f5c762 100644
--- a/docs/source/devguide/tests.rst
+++ b/docs/source/devguide/tests.rst
@@ -4,9 +4,6 @@
 Test Suite
 ==========
 
-Running Tests
--------------
-
 The OpenMC test suite consists of two parts, a regression test suite and a unit
 test suite. The regression test suite is based on regression or integrated
 testing where different types of input files are configured and the full OpenMC
@@ -14,27 +11,35 @@ code is executed. Results from simulations are compared with expected
 results. The unit tests are primarily intended to test individual
 functions/classes in the OpenMC Python API.
 
-The test suite relies on the third-party `pytest <https://pytest.org>`_
-package. To run either or both the regression and unit test suites, it is
-assumed that you have OpenMC fully installed, i.e., the :ref:`scripts_openmc`
-executable is available on your :envvar:`PATH` and the :mod:`openmc` Python
-module is importable. In development where it would be onerous to continually
-install OpenMC every time a small change is made, it is recommended to install
-OpenMC in development/editable mode. With setuptools, this is accomplished by
-running::
+Prerequisites
+-------------
 
-    python setup.py develop
+- The test suite relies on the third-party `pytest <https://pytest.org>`_
+  package. To run either or both the regression and unit test suites, it is
+  assumed that you have OpenMC fully installed, i.e., the :ref:`scripts_openmc`
+  executable is available on your :envvar:`PATH` and the :mod:`openmc` Python
+  module is importable. In development where it would be onerous to continually
+  install OpenMC every time a small change is made, it is recommended to install
+  OpenMC in development/editable mode. With setuptools, this is accomplished by
+  running::
 
-or using pip (recommended)::
+      python setup.py develop
 
-    pip install -e .[test]
+  or using pip (recommended)::
 
-It is also assumed that you have cross section data available that is pointed to
-by the :envvar:`OPENMC_CROSS_SECTIONS` environment variables. Furthermore, to
-run unit tests for the :mod:`openmc.data` module, it is necessary to have
-ENDF/B-VII.1 data available and pointed to by the :envvar:`OPENMC_ENDF_DATA`
-environment variable. All data sources can be obtained using the
-``tools/ci/travis-before-script.sh`` script.
+      pip install -e .[test]
+
+- The test suite requires a specific set of cross section data in order for
+  tests to pass. A download URL for the data that OpenMC expects can be found
+  within ``tools/ci/download-xs.sh``.
+- In addition to the HDF5 data, some tests rely on ENDF files. A download URL
+  for those can also be found in ``tools/ci/download-xs.sh``.
+- Some tests require `NJOY <https://www.njoy21.io/NJOY2016>`_ to preprocess
+  cross section data. The test suite assumes that you have an ``njoy``
+  executable available on your :envvar:`PATH`.
+
+Running Tests
+-------------
 
 To execute the test suite, go to the ``tests/`` directory and run::
 
@@ -46,6 +51,17 @@ installed and run::
 
     pytest --cov=../openmc --cov-report=html
 
+Generating XML Inputs
+---------------------
+
+Many of the regression tests rely on the Python API to build an appropriate
+model. However, it can sometimes be desirable to work directly with the XML
+input files rather than having to run a script in order to run the problem/test.
+To build the input files for a test without actually running the test, you can
+run::
+
+    pytest --build-inputs <name-of-test>
+
 Adding Tests to the Regression Suite
 ------------------------------------
 

From dda5393c78a73126c166216686648c9a113243ca Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 08:04:16 -0500
Subject: [PATCH 091/127] Improving error returns in bounding_box function.
 Appying parametrized tests.

---
 src/geometry.cpp                           | 10 ++---
 tests/unit_tests/test_complex_cell_capi.py | 45 ++++++++++++----------
 2 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/src/geometry.cpp b/src/geometry.cpp
index 15118cd04..ea90ba257 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -477,7 +477,7 @@ openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance)
 }
 
 extern "C" int
-openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc) {
+openmc_bounding_box(const char* geom_type, const int32_t index, double* llc, double* urc) {
 
   BoundingBox bbox;
 
@@ -486,23 +486,23 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
 
   if (gtype == "universe") {
     // negative ids only apply to surfaces
-    if (id <= 0) { return OPENMC_E_GEOMETRY; }
+    if (id <= 0) { return OPENMC_E_INVALID_ID; }
     const auto& u = model::universes[model::universe_map.at(id)];
     bbox = u->bounding_box();
   } else if (gtype == "cell") {
     // negative ids only apply to surfaces
-    if (id <= 0) { return OPENMC_E_GEOMETRY; }
+    if (id <= 0) { return OPENMC_E_INVALID_ID; }
     const auto& c = model::cells[model::cell_map.at(id)];
     bbox = c->bounding_box();
   } else if (gtype == "surface") {
-    if (id == 0) { return OPENMC_E_GEOMETRY; }
+    if (id == 0) { return OPENMC_E_INVALID_IDY; }
     const auto& s = model::surfaces[model::surface_map.at(abs(id))];
     bbox = s->bounding_box(id > 0);
   } else {
     std::stringstream msg;
     msg << "Geometry type: " << gtype << " is invalid.";
     set_errmsg(msg);
-    return OPENMC_E_GEOMETRY;
+    return OPENMC_E_INVALID_TYPE;
   }
 
   // set lower left corner values
diff --git a/tests/unit_tests/test_complex_cell_capi.py b/tests/unit_tests/test_complex_cell_capi.py
index 20cda54ae..ebc345f8f 100644
--- a/tests/unit_tests/test_complex_cell_capi.py
+++ b/tests/unit_tests/test_complex_cell_capi.py
@@ -2,9 +2,10 @@ import sys
 
 import numpy as np
 import openmc.capi
+import pytest
 
-
-def test_complex_cell(run_in_tmpdir):
+@pytest.fixture(autouse=True)
+def complex_cell(run_in_tmpdir):
 
     openmc.reset_auto_ids()
 
@@ -51,10 +52,12 @@ def test_complex_cell(run_in_tmpdir):
     c2.region = +s2 & -s5 & +s12 & -s15 & ~(+s3 & -s4 & +s13 & -s14)
 
     c3 = openmc.Cell(fill=zr90)
-    c3.region = ((+s1 & -s7 & +s17 & -s16) | (+s7 & -s6 & +s11 & -s17)) & (-s2 | +s5 | -s12 | +s15)
+    c3.region = ((+s1 & -s7 & +s17 & -s16) | (+s7 & -s6 & +s11 & -s17)) \
+                & (-s2 | +s5 | -s12 | +s15)
 
     c4 = openmc.Cell(fill=n14)
-    c4.region = ((+s1 & -s7 & +s11 & -s17) | (+s7 & -s6 & +s17 & -s16)) & ~(+s2 & -s5 & +s12 & -s15)
+    c4.region = ((+s1 & -s7 & +s11 & -s17) | (+s7 & -s6 & +s17 & -s16)) & \
+                ~(+s2 & -s5 & +s12 & -s15)
 
     model.geometry.root_universe = openmc.Universe()
     model.geometry.root_universe.add_cells([c1, c2, c3, c4])
@@ -72,22 +75,22 @@ def test_complex_cell(run_in_tmpdir):
     openmc.capi.finalize()
     openmc.capi.init()
 
-    inf = sys.float_info.max
-
-    expected_boxes = { 1 : (( -4.,  -4., -inf), ( 4.,  4., inf)),
-                       2 : (( -7.,  -7., -inf), ( 7.,  7., inf)),
-                       3 : ((-10., -10., -inf), (10., 10., inf)),
-                       4 : ((-10., -10., -inf), (10., 10., inf)) }
-
-    for cell_id, cell in openmc.capi.cells.items():
-        cell_box = cell.bounding_box
-
-        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
-        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
-
-        cell_box = openmc.capi.bounding_box("Cell", cell_id)
-
-        assert tuple(cell_box[0]) == expected_boxes[cell_id][0]
-        assert tuple(cell_box[1]) == expected_boxes[cell_id][1]
+    yield
 
     openmc.capi.finalize()
+
+inf = sys.float_info.max
+
+expected_results = ( (1, (( -4.,  -4., -inf), ( 4.,  4., inf))),
+                     (2, (( -7.,  -7., -inf), ( 7.,  7., inf))),
+                     (3, ((-10., -10., -inf), (10., 10., inf))),
+                     (4, ((-10., -10., -inf), (10., 10., inf))) )
+@pytest.mark.parametrize("cell_id,expected_box", expected_results)
+def test_cell_box(cell_id, expected_box):
+    cell_box = openmc.capi.cells[cell_id].bounding_box
+    assert tuple(cell_box[0]) == expected_box[0]
+    assert tuple(cell_box[1]) == expected_box[1]
+
+    cell_box = openmc.capi.bounding_box("Cell", cell_id)
+    assert tuple(cell_box[0]) == expected_box[0]
+    assert tuple(cell_box[1]) == expected_box[1]

From 694bd0cf15efd3467827dbf5247d6afd66a0244a Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 08:53:52 -0500
Subject: [PATCH 092/127] Chaning back to id in bounding_box for now.

---
 src/geometry.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/geometry.cpp b/src/geometry.cpp
index ea90ba257..91e2fc245 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -477,7 +477,7 @@ openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance)
 }
 
 extern "C" int
-openmc_bounding_box(const char* geom_type, const int32_t index, double* llc, double* urc) {
+openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc) {
 
   BoundingBox bbox;
 
@@ -495,7 +495,7 @@ openmc_bounding_box(const char* geom_type, const int32_t index, double* llc, dou
     const auto& c = model::cells[model::cell_map.at(id)];
     bbox = c->bounding_box();
   } else if (gtype == "surface") {
-    if (id == 0) { return OPENMC_E_INVALID_IDY; }
+    if (id == 0) { return OPENMC_E_INVALID_ID; }
     const auto& s = model::surfaces[model::surface_map.at(abs(id))];
     bbox = s->bounding_box(id > 0);
   } else {

From f2199af0eba57a001d196d96bac0ad66d1d1d842 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 09:46:47 -0500
Subject: [PATCH 093/127] Cleaning up error checking in bounding_box. Updating
 expected exceptions in the capi tests.

---
 src/geometry.cpp              | 19 ++++++++++++++-----
 tests/unit_tests/test_capi.py |  6 +++---
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/geometry.cpp b/src/geometry.cpp
index 91e2fc245..ae48a0acb 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -484,18 +484,27 @@ openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double
   std::string gtype(geom_type);
   to_lower(gtype);
 
+  // negative ids only for surfaces
+  if (id < 0 && gtype != "surface") {
+    std::stringstream msg;
+    msg << "Negative ID " << id << " passed to bounding box for "
+        << "non-surface geom type '" << geom_type << "'" << std::endl;
+    set_errmsg(msg);
+    return OPENMC_E_INVALID_ID;
+  }
+  // id should never be zero
+  if (id == 0) {
+    set_errmsg("Invalid ID 0 for surface bounding box.");
+    return OPENMC_E_INVALID_ID;
+  }
+
   if (gtype == "universe") {
-    // negative ids only apply to surfaces
-    if (id <= 0) { return OPENMC_E_INVALID_ID; }
     const auto& u = model::universes[model::universe_map.at(id)];
     bbox = u->bounding_box();
   } else if (gtype == "cell") {
-    // negative ids only apply to surfaces
-    if (id <= 0) { return OPENMC_E_INVALID_ID; }
     const auto& c = model::cells[model::cell_map.at(id)];
     bbox = c->bounding_box();
   } else if (gtype == "surface") {
-    if (id == 0) { return OPENMC_E_INVALID_ID; }
     const auto& s = model::surfaces[model::surface_map.at(abs(id))];
     bbox = s->bounding_box(id > 0);
   } else {
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index b02e43815..aa140a121 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -508,13 +508,13 @@ def test_bounding_box(capi_init):
     assert tuple(urc) == expected_urc
 
     # make sure that proper assertions are raised
-    with pytest.raises(openmc.exceptions.GeometryError):
+    with pytest.raises(openmc.exceptions.InvalidIDError):
         openmc.capi.bounding_box("Cell", -1)
 
-    with pytest.raises(openmc.exceptions.GeometryError):
+    with pytest.raises(openmc.exceptions.InvalidIDError):
         openmc.capi.bounding_box("Surface", 0)
 
-    with pytest.raises(openmc.exceptions.GeometryError):
+    with pytest.raises(openmc.exceptions.InvalidTypeError):
         openmc.capi.bounding_box("Region", 1)
 
 

From 331e198617d7f68fab1ba4af5da0143d07b4e025 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 10:03:22 -0500
Subject: [PATCH 094/127] Adding test for name setting and relying on
 std::string's char* constructor.

---
 src/cell.cpp                  | 3 +--
 src/material.cpp              | 1 -
 tests/unit_tests/test_capi.py | 4 ++++
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/cell.cpp b/src/cell.cpp
index c3877d03b..7cc74ed9f 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1102,8 +1102,7 @@ openmc_cell_set_name(int32_t index, const char* name) {
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  std::string name_str(name);
-  model::cells[index]->set_name(name_str);
+  model::cells[index]->set_name(name);
 
   return 0;
 }
diff --git a/src/material.cpp b/src/material.cpp
index 4f3177907..699649d31 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1400,7 +1400,6 @@ openmc_material_set_name(int32_t index, const char* name) {
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  std::string name_str(name);
   model::materials[index]->set_name(name);
 
   return 0;
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index aa140a121..3fdd4db66 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -75,6 +75,8 @@ def test_cell(capi_init):
     cell.fill = openmc.capi.materials[1]
     assert str(cell) == 'Cell[0]'
     assert cell.name == "Fuel"
+    cell.name = "Not fuel"
+    assert cell.name == "Not fuel"
 
 def test_cell_temperature(capi_init):
     cell = openmc.capi.cells[1]
@@ -124,6 +126,8 @@ def test_material(capi_init):
     m.set_density(0.1, 'g/cm3')
     assert m.density == pytest.approx(0.1)
     assert m.name == "Hot borated water"
+    m.name = "Not hot borated water"
+    assert m.name == "Not hot borated water"
 
 def test_material_add_nuclide(capi_init):
     m = openmc.capi.materials[3]

From 71522fd31024fe6b5d45189740b8560c2af3ca63 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 11:16:16 -0500
Subject: [PATCH 095/127] Check for material temp and use if cell temp is not
 set on the .h5m file.

---
 src/dagmc.cpp | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 78d8bc4fb..29e89b4bc 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -215,17 +215,6 @@ void load_dagmc_geometry()
       model::universes[it->second]->cells_.push_back(i);
     }
 
-    // check for temperature assignment
-    std::string temp_value;
-    if (model::DAG->has_prop(vol_handle, "temp")) {
-      rval = model::DAG->prop_value(vol_handle, "temp", temp_value);
-      MB_CHK_ERR_CONT(rval);
-      double temp = std::stod(temp_value);
-      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * temp));
-    } else {
-      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * settings::temperature_default));
-    }
-
     // MATERIALS
 
     if (model::DAG->is_implicit_complement(vol_handle)) {
@@ -295,6 +284,24 @@ void load_dagmc_geometry()
         legacy_assign_material(mat_value, c);
       }
     }
+
+    // check for temperature assignment
+    std::string temp_value;
+
+    if (c->material_[0] == MATERIAL_VOID) { continue; }
+
+    auto& mat = model::materials[c->material_[0]];
+    if (model::DAG->has_prop(vol_handle, "temp")) {
+      rval = model::DAG->prop_value(vol_handle, "temp", temp_value);
+      MB_CHK_ERR_CONT(rval);
+      double temp = std::stod(temp_value);
+      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * temp));
+    } else if (mat->temperature_ > 0.0) {
+      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * mat->temperature_));
+    } else {
+      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * settings::temperature_default));
+    }
+
   }
 
   // allocate the cell overlap count if necessary

From da152b9b0f31cb81f25d4781025e77a401aef044 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 16:30:01 -0500
Subject: [PATCH 096/127] Updating DagMC s.t. their temperatures can be set
 using material temps. Also addressig a bug in closing an hdf5 dataset and
 adding tests.

---
 src/dagmc.cpp                                 |   2 +-
 src/summary.cpp                               |   1 +
 tests/regression_tests/dagmc/legacy/dagmc.h5m | Bin 1233372 -> 1233364 bytes
 .../dagmc/legacy/inputs_true.dat              |   4 ++-
 tests/regression_tests/dagmc/legacy/test.py   |  28 ++++++++++++++++++
 5 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 29e89b4bc..1e6f3d02a 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -290,7 +290,7 @@ void load_dagmc_geometry()
 
     if (c->material_[0] == MATERIAL_VOID) { continue; }
 
-    auto& mat = model::materials[c->material_[0]];
+    auto& mat = model::materials[model::material_map[c->material_[0]]];
     if (model::DAG->has_prop(vol_handle, "temp")) {
       rval = model::DAG->prop_value(vol_handle, "temp", temp_value);
       MB_CHK_ERR_CONT(rval);
diff --git a/src/summary.cpp b/src/summary.cpp
index 500a5c15c..d2721f97e 100644
--- a/src/summary.cpp
+++ b/src/summary.cpp
@@ -92,6 +92,7 @@ void write_geometry(hid_t file)
 #ifdef DAGMC
   if (settings::dagmc) {
     write_attribute(geom_group, "dagmc", 1);
+    close_group(geom_group);
     return;
   }
 #endif
diff --git a/tests/regression_tests/dagmc/legacy/dagmc.h5m b/tests/regression_tests/dagmc/legacy/dagmc.h5m
index c90b6d674d9b016aba5b8614d952d90205c355f2..fbbe9a34a8c01b245375acaffc5e3f2f33fd60aa 100644
GIT binary patch
delta 769
zcmcb!*!#+2?+F@=S2k)MmSH(-s24l=gUmyDbA3ZIeM3to1_<DQ(uSs1Mut|##+yIL
z#t48_Zw}Cl;e@a@n9FcLOt@hGigCi^-42Qn?gNJzocsz9BlssbIyy2}FfdN8jS`3G
zd*H~!2w{D2g0eQb6p1l@m|PqMGr@7iWQS-ct^{iVurU^llWU?Rz?vqxEZFQ3bBJZ~
zDlhrTnu(R%Gi)Gg9PAKwOjbylu{j}W79-=0$-k2!hHh3!F=FDb*eM7$F#yR$VATTY
zK-DKEug-v~zK~(X&L}dOy8!AWgMwF#OD0PfLZuxFn^>8i9G_fMs{rxzg4#oqSCwlp
zy*WO)rw%H%p>E;knH3LN7<ndF*Fw!%Q2PpKY<C^hoDFrC*ceTar4LWeZd0G!)T#tA
z*P(F1=7{!9tdl3TK}8IDUrpxfg>W`I^jWbnhD@%W0yBQfE2cjuCihH*IAQaKsY+~2
zKBp%CSqycP!je}^Hm4DMgQbTipPH+|sdGjM5@VCAqa-0#KX9C|dBwaSRz{u4zZXNz
z2Wgi%kF5O_(09_ypx$v<c8HCO=OV-?4F-6uO@083(F<#xxJ;mO3y|c1UTnUxuKmV3
zMj&PaVrC#_0b*7lW&>h&Am#vKP9Ww2Vs0Sj0b*Vt=G%T_9sh><=?a?s9NTB;2{>?Z
c@+m-k(lh;`xqx{44+{Yx7To^BLg>j10QS=u!vFvP

delta 774
zcmcbz*!#|6?+F@=cQ$GsmSOq)r6*?c2bqWR#`=b4`i7QF3=qHpr41~s49u)dEjNFV
zjS&E=-W;G8!wF$+Fqh$gm~g@V72}M_yB!oE+y@RbI0Y0SMhHx9baZ5HU|^hF8zm0W
z_rQ^d5yJZ51Z8b<DH3D+F}XMjW`g62$qvy@Tp88^U}G#8C)Y$tfHh5WS+Ln7<`4@D
zNMbTy;uP)$HV{P)b_h!*E2PZWoRBn&k@3Og-^mbDH!GwVF>yES6a*U?faD~wYJqg1
z>I;)sXFye7$gpB(l$p$30Ckf=!7Ii!lcfux(hh}9tW0l?Pp+v|fcSbr?V-u5$~Bn2
z9G~1%2Nl~;w{Y{!iia$WB9p6Yq2?^8eFZeOyAEp3hPq2^lP9$)!3;S(IlE1LGFLBD
zz@c!#=7{!9tdphspdtpnuNXt%#%*@!vtnb6nOr>uX8e>_Oe`lS_e_O2Ve^KmN^DFa
zrzZbd40V&jl2=SFrxARErH3Y;nybNSaz+RoFbtEcqa-1&dEhu<^NM*vtc)g;e=mlb
z57Mr39$EV<pzoxYLA~R!><}B5$VG@z8VvAgoBRM6r5DyZaoIrS79hz1J=uI?UHgr7
zj6lo;#LPg<0>rF9%m&2lK+FNeoIuP4#N0s41H`;Q%(wl<I{ppyT+`=6oX^a#y-QEP
gjf;_gdZC4Y{C1JuLK#f$5!M1gEVw<wTBv3k0MY0`?EnA(

diff --git a/tests/regression_tests/dagmc/legacy/inputs_true.dat b/tests/regression_tests/dagmc/legacy/inputs_true.dat
index 8ca49c324..056a7eb9d 100644
--- a/tests/regression_tests/dagmc/legacy/inputs_true.dat
+++ b/tests/regression_tests/dagmc/legacy/inputs_true.dat
@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='utf-8'?>
 <materials>
-  <material depletable="true" id="40" name="fuel">
+  <material depletable="true" id="40" name="fuel" temperature="320">
     <density units="g/cc" value="11" />
     <nuclide ao="1.0" name="U235" />
   </material>
@@ -22,6 +22,8 @@
       <parameters>-4 -4 -4 4 4 4</parameters>
     </space>
   </source>
+  <verbosity>7</verbosity>
+  <temperature_tolerance>50.0</temperature_tolerance>
   <dagmc>true</dagmc>
 </settings>
 <?xml version='1.0' encoding='utf-8'?>
diff --git a/tests/regression_tests/dagmc/legacy/test.py b/tests/regression_tests/dagmc/legacy/test.py
index b6f2f55e2..38c3c4267 100644
--- a/tests/regression_tests/dagmc/legacy/test.py
+++ b/tests/regression_tests/dagmc/legacy/test.py
@@ -5,10 +5,19 @@ from openmc.stats import Box
 import pytest
 from tests.testing_harness import PyAPITestHarness
 
+import numpy as np
+
 pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
+
+class DAGMCPyAPITestHarness(PyAPITestHarness):
+
+    def _compare_inputs(self):
+        super()._compare_inputs()
+
+
 def test_dagmc():
     model = openmc.model.Model()
 
@@ -16,6 +25,7 @@ def test_dagmc():
     model.settings.batches = 5
     model.settings.inactive = 0
     model.settings.particles = 100
+    model.settings.temperature = {'tolerance': 50.0}
 
     source = openmc.Source(space=Box([-4, -4, -4],
                                      [ 4,  4,  4]))
@@ -34,6 +44,7 @@ def test_dagmc():
     u235.add_nuclide('U235', 1.0, 'ao')
     u235.set_density('g/cc', 11)
     u235.id = 40
+    u235.temperature = 320
 
     water = openmc.Material(name="water")
     water.add_nuclide('H1', 2.0, 'ao')
@@ -46,4 +57,21 @@ def test_dagmc():
     model.materials = mats
 
     harness = PyAPITestHarness('statepoint.5.h5', model=model)
+    model.settings.verbosity = 1
+    harness._build_inputs()
+
+    # check cell temps as well here
+    openmc.capi.init([])
+
+    expected_temps = { 1 : 320.0,  # assigned by material
+                       2 : 300.0,  # assigned in dagmc file
+                       3 : 293.6 } # assigned by default
+
+    for cell_id, temp in expected_temps.items():
+        capi_cell = openmc.capi.cells[cell_id]
+        assert np.isclose(capi_cell.get_temperature(), temp)
+
+    openmc.capi.finalize()
+
+    model.settings.verbosity = 7
     harness.main()

From 89c75a7b8242dfc794fb1073ad58f0dabcd06c73 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 16 Jul 2019 20:56:11 -0500
Subject: [PATCH 097/127] Sharing model between tests.

---
 .../dagmc/legacy/inputs_true.dat              |  1 -
 tests/regression_tests/dagmc/legacy/test.py   | 20 ++++++++-----------
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/tests/regression_tests/dagmc/legacy/inputs_true.dat b/tests/regression_tests/dagmc/legacy/inputs_true.dat
index 056a7eb9d..b2b092cff 100644
--- a/tests/regression_tests/dagmc/legacy/inputs_true.dat
+++ b/tests/regression_tests/dagmc/legacy/inputs_true.dat
@@ -22,7 +22,6 @@
       <parameters>-4 -4 -4 4 4 4</parameters>
     </space>
   </source>
-  <verbosity>7</verbosity>
   <temperature_tolerance>50.0</temperature_tolerance>
   <dagmc>true</dagmc>
 </settings>
diff --git a/tests/regression_tests/dagmc/legacy/test.py b/tests/regression_tests/dagmc/legacy/test.py
index 38c3c4267..1e4107cfb 100644
--- a/tests/regression_tests/dagmc/legacy/test.py
+++ b/tests/regression_tests/dagmc/legacy/test.py
@@ -11,14 +11,8 @@ pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
-
-class DAGMCPyAPITestHarness(PyAPITestHarness):
-
-    def _compare_inputs(self):
-        super()._compare_inputs()
-
-
-def test_dagmc():
+@pytest.fixture(scope="module")
+def dagmc_model():
     model = openmc.model.Model()
 
     # settings
@@ -56,9 +50,10 @@ def test_dagmc():
     mats = openmc.Materials([u235, water])
     model.materials = mats
 
-    harness = PyAPITestHarness('statepoint.5.h5', model=model)
-    model.settings.verbosity = 1
-    harness._build_inputs()
+    yield model
+
+def test_dagmc_temps(dagmc_model):
+    dagmc_model.export_to_xml()
 
     # check cell temps as well here
     openmc.capi.init([])
@@ -73,5 +68,6 @@ def test_dagmc():
 
     openmc.capi.finalize()
 
-    model.settings.verbosity = 7
+def test_dagmc(dagmc_model):
+    harness = PyAPITestHarness('statepoint.5.h5', model=dagmc_model)
     harness.main()

From 347f4d7dd5ce36285206f3717d70ed26e01c5ddd Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Thu, 18 Jul 2019 11:30:32 -0500
Subject: [PATCH 098/127] Separating dagmc cell temperature checks into unit
 tests.

---
 src/dagmc.cpp                                 | 19 +++--
 .../dagmc/legacy/inputs_true.dat              |  3 +-
 tests/regression_tests/dagmc/legacy/test.py   | 35 ++-------
 tests/unit_tests/dagmc/__init__.py            |  0
 tests/unit_tests/dagmc/conftest.py            | 12 +++
 tests/unit_tests/dagmc/dagmc.h5m              |  1 +
 tests/unit_tests/dagmc/test.py                | 75 +++++++++++++++++++
 7 files changed, 106 insertions(+), 39 deletions(-)
 create mode 100644 tests/unit_tests/dagmc/__init__.py
 create mode 100644 tests/unit_tests/dagmc/conftest.py
 create mode 120000 tests/unit_tests/dagmc/dagmc.h5m
 create mode 100644 tests/unit_tests/dagmc/test.py

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 1e6f3d02a..a4ca81fbe 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -35,10 +35,9 @@ const bool dagmc_enabled = false;
 
 #ifdef DAGMC
 
-const std::string DAGMC_FILENAME = "dagmc.h5m";
-
 namespace openmc {
 
+const std::string DAGMC_FILENAME = settings::path_input + "dagmc.h5m";
 
 namespace simulation {
 
@@ -54,8 +53,16 @@ moab::DagMC* DAG;
 } // namespace model
 
 
+void check_dagmc_file() {
+  if (!file_exists(DAGMC_FILENAME)) {
+    fatal_error("Geometry DAGMC file '" + DAGMC_FILENAME + "' does not exist!");
+  }
+}
+
 bool get_uwuw_materials_xml(std::string& s) {
-  UWUW uwuw(DAGMC_FILENAME.c_str());
+  check_dagmc_file();
+
+  UWUW uwuw((settings::path_input + DAGMC_FILENAME).c_str());
 
   std::stringstream ss;
   bool uwuw_mats_present = false;
@@ -376,11 +383,7 @@ void load_dagmc_geometry()
 void read_geometry_dagmc()
 {
   // Check if dagmc.h5m exists
-  std::string filename = settings::path_input + "dagmc.h5m";
-  if (!file_exists(filename)) {
-    fatal_error("Geometry DAGMC file '" + filename + "' does not exist!");
-  }
-
+  check_dagmc_file();
   write_message("Reading DAGMC geometry...", 5);
   load_dagmc_geometry();
 
diff --git a/tests/regression_tests/dagmc/legacy/inputs_true.dat b/tests/regression_tests/dagmc/legacy/inputs_true.dat
index b2b092cff..8ca49c324 100644
--- a/tests/regression_tests/dagmc/legacy/inputs_true.dat
+++ b/tests/regression_tests/dagmc/legacy/inputs_true.dat
@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='utf-8'?>
 <materials>
-  <material depletable="true" id="40" name="fuel" temperature="320">
+  <material depletable="true" id="40" name="fuel">
     <density units="g/cc" value="11" />
     <nuclide ao="1.0" name="U235" />
   </material>
@@ -22,7 +22,6 @@
       <parameters>-4 -4 -4 4 4 4</parameters>
     </space>
   </source>
-  <temperature_tolerance>50.0</temperature_tolerance>
   <dagmc>true</dagmc>
 </settings>
 <?xml version='1.0' encoding='utf-8'?>
diff --git a/tests/regression_tests/dagmc/legacy/test.py b/tests/regression_tests/dagmc/legacy/test.py
index 1e4107cfb..73a3babe6 100644
--- a/tests/regression_tests/dagmc/legacy/test.py
+++ b/tests/regression_tests/dagmc/legacy/test.py
@@ -1,28 +1,25 @@
 import openmc
 import openmc.capi
-from openmc.stats import Box
 
 import pytest
 from tests.testing_harness import PyAPITestHarness
 
-import numpy as np
-
 pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
-@pytest.fixture(scope="module")
-def dagmc_model():
+def test_dagmc():
     model = openmc.model.Model()
 
     # settings
     model.settings.batches = 5
     model.settings.inactive = 0
     model.settings.particles = 100
-    model.settings.temperature = {'tolerance': 50.0}
 
-    source = openmc.Source(space=Box([-4, -4, -4],
-                                     [ 4,  4,  4]))
+    source_box = openmc.stats.Box([-4, -4, -4],
+                                  [ 4,  4,  4])
+    source = openmc.Source(space=source_box)
+
     model.settings.source = source
 
     model.settings.dagmc = True
@@ -38,7 +35,6 @@ def dagmc_model():
     u235.add_nuclide('U235', 1.0, 'ao')
     u235.set_density('g/cc', 11)
     u235.id = 40
-    u235.temperature = 320
 
     water = openmc.Material(name="water")
     water.add_nuclide('H1', 2.0, 'ao')
@@ -50,24 +46,5 @@ def dagmc_model():
     mats = openmc.Materials([u235, water])
     model.materials = mats
 
-    yield model
-
-def test_dagmc_temps(dagmc_model):
-    dagmc_model.export_to_xml()
-
-    # check cell temps as well here
-    openmc.capi.init([])
-
-    expected_temps = { 1 : 320.0,  # assigned by material
-                       2 : 300.0,  # assigned in dagmc file
-                       3 : 293.6 } # assigned by default
-
-    for cell_id, temp in expected_temps.items():
-        capi_cell = openmc.capi.cells[cell_id]
-        assert np.isclose(capi_cell.get_temperature(), temp)
-
-    openmc.capi.finalize()
-
-def test_dagmc(dagmc_model):
-    harness = PyAPITestHarness('statepoint.5.h5', model=dagmc_model)
+    harness = PyAPITestHarness('statepoint.5.h5', model=model)
     harness.main()
diff --git a/tests/unit_tests/dagmc/__init__.py b/tests/unit_tests/dagmc/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit_tests/dagmc/conftest.py b/tests/unit_tests/dagmc/conftest.py
new file mode 100644
index 000000000..621532231
--- /dev/null
+++ b/tests/unit_tests/dagmc/conftest.py
@@ -0,0 +1,12 @@
+
+import pytest
+
+@pytest.fixture(scope='module', autouse=True)
+def setup_dagmc_unit_test(request):
+
+    # Change to test directory
+    olddir = request.fspath.dirpath().chdir()
+    try:
+        yield
+    finally:
+        olddir.chdir()
diff --git a/tests/unit_tests/dagmc/dagmc.h5m b/tests/unit_tests/dagmc/dagmc.h5m
new file mode 120000
index 000000000..0c5ab5da8
--- /dev/null
+++ b/tests/unit_tests/dagmc/dagmc.h5m
@@ -0,0 +1 @@
+../../regression_tests/dagmc/legacy/dagmc.h5m
\ No newline at end of file
diff --git a/tests/unit_tests/dagmc/test.py b/tests/unit_tests/dagmc/test.py
new file mode 100644
index 000000000..2302ab7e4
--- /dev/null
+++ b/tests/unit_tests/dagmc/test.py
@@ -0,0 +1,75 @@
+import glob
+import os
+
+import numpy as np
+import pytest
+
+import openmc
+import openmc.capi
+
+from tests import cdtemp
+
+pytestmark = pytest.mark.skipif(
+    not openmc.capi._dagmc_enabled(),
+    reason="DAGMC CAD geometry is not enabled.")
+
+def test_dagmc_temperatures():
+    model = openmc.model.Model()
+
+    # settings
+    model.settings.batches = 5
+    model.settings.inactive = 0
+    model.settings.particles = 100
+    model.settings.temperature = {'tolerance': 50.0}
+    model.settings.verbosity = 1
+    source_box = openmc.stats.Box([-4, -4, -4],
+                                  [ 4,  4,  4])
+    source = openmc.Source(space=source_box)
+    model.settings.source = source
+
+    model.settings.dagmc = True
+
+    # tally
+    tally = openmc.Tally()
+    tally.scores = ['total']
+    tally.filters = [openmc.CellFilter(1)]
+    model.tallies = [tally]
+
+    # materials
+    u235 = openmc.Material(name="fuel")
+    u235.add_nuclide('U235', 1.0, 'ao')
+    u235.set_density('g/cc', 11)
+    u235.id = 40
+    u235.temperature = 320
+
+    water = openmc.Material(name="water")
+    water.add_nuclide('H1', 2.0, 'ao')
+    water.add_nuclide('O16', 1.0, 'ao')
+    water.set_density('g/cc', 1.0)
+    water.add_s_alpha_beta('c_H_in_H2O')
+    water.id = 41
+
+    mats = openmc.Materials([u235, water])
+    model.materials = mats
+
+    model.export_to_xml()
+
+    # check cell temps as well here
+    openmc.capi.init()
+
+    expected_temps = { 1 : 320.0,  # assigned by material
+                       2 : 300.0,  # assigned in dagmc file
+                       3 : 293.6 } # assigned by default
+
+    for cell_id, temp in expected_temps.items():
+        capi_cell = openmc.capi.cells[cell_id]
+        assert np.isclose(capi_cell.get_temperature(), temp)
+
+    openmc.capi.finalize()
+
+    # cleanup
+    input_files = glob.glob("*.xml")
+    input_files += glob.glob("*.h5")
+    for f in input_files:
+        if os.path.exists(f):
+            os.remove(f)

From 978e7ba94a5da37f54bd4d09914193d0ab72f317 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 08:41:30 -0500
Subject: [PATCH 099/127] Adding a note about setting up tallies for DagMC
 models.

---
 examples/jupyter/cad-based-geometry.ipynb | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/examples/jupyter/cad-based-geometry.ipynb b/examples/jupyter/cad-based-geometry.ipynb
index 6ff79d27c..5c449cd00 100644
--- a/examples/jupyter/cad-based-geometry.ipynb
+++ b/examples/jupyter/cad-based-geometry.ipynb
@@ -236,6 +236,13 @@
     "tallies.export_to_xml()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Note:** Applying tally filters in DagMC models requires prior knowledge of the model. Here, we know that the fuel cell's volume ID in the CAD sofware is 1. To identify cells without use of CAD software, we recommend loading them into the [OpenMC plotter](https://github.com/openmc/plotter) where cell, material, and volume IDs can be identified for native OpenMC and DagMC geometries."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

From d8f9bfdc30983e7f6e988b15561c8ba54904a57d Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 15:10:50 -0500
Subject: [PATCH 100/127] Using map::at() for safety.

---
 src/dagmc.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index a4ca81fbe..06d93fc47 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -140,7 +140,7 @@ void legacy_assign_material(const std::string& mat_string, DAGCell* c)
   }
 
   if (settings::verbosity >= 10) {
-    Material* m = model::materials[model::material_map[c->material_[0]]].get();
+    const auto& m = model::materials[model::material_map.at(c->material_[0])];
     std::stringstream msg;
     msg << "DAGMC material " << mat_string << " was assigned";
     if (mat_found_by_name) {
@@ -297,7 +297,7 @@ void load_dagmc_geometry()
 
     if (c->material_[0] == MATERIAL_VOID) { continue; }
 
-    auto& mat = model::materials[model::material_map[c->material_[0]]];
+    const auto& mat = model::materials[model::material_map.at(c->material_[0])];
     if (model::DAG->has_prop(vol_handle, "temp")) {
       rval = model::DAG->prop_value(vol_handle, "temp", temp_value);
       MB_CHK_ERR_CONT(rval);

From 98804f957ac01a7a51953baf183e5d336a8ea1c0 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 15:11:12 -0500
Subject: [PATCH 101/127] Parametrizing cell temperature test.

---
 tests/unit_tests/dagmc/conftest.py |  1 -
 tests/unit_tests/dagmc/test.py     | 19 ++++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/unit_tests/dagmc/conftest.py b/tests/unit_tests/dagmc/conftest.py
index 621532231..9f012b5fa 100644
--- a/tests/unit_tests/dagmc/conftest.py
+++ b/tests/unit_tests/dagmc/conftest.py
@@ -3,7 +3,6 @@ import pytest
 
 @pytest.fixture(scope='module', autouse=True)
 def setup_dagmc_unit_test(request):
-
     # Change to test directory
     olddir = request.fspath.dirpath().chdir()
     try:
diff --git a/tests/unit_tests/dagmc/test.py b/tests/unit_tests/dagmc/test.py
index 2302ab7e4..7698119fc 100644
--- a/tests/unit_tests/dagmc/test.py
+++ b/tests/unit_tests/dagmc/test.py
@@ -13,7 +13,8 @@ pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
-def test_dagmc_temperatures():
+@pytest.fixture(scope="module", autouse=True)
+def dagmc_model():
     model = openmc.model.Model()
 
     # settings
@@ -54,16 +55,9 @@ def test_dagmc_temperatures():
 
     model.export_to_xml()
 
-    # check cell temps as well here
     openmc.capi.init()
 
-    expected_temps = { 1 : 320.0,  # assigned by material
-                       2 : 300.0,  # assigned in dagmc file
-                       3 : 293.6 } # assigned by default
-
-    for cell_id, temp in expected_temps.items():
-        capi_cell = openmc.capi.cells[cell_id]
-        assert np.isclose(capi_cell.get_temperature(), temp)
+    yield
 
     openmc.capi.finalize()
 
@@ -73,3 +67,10 @@ def test_dagmc_temperatures():
     for f in input_files:
         if os.path.exists(f):
             os.remove(f)
+
+@pytest.mark.parametrize("cell_id,exp_temp", ((1, 320.0),  # assigned by material
+                                              (2, 300.0),  # assigned in dagmc file
+                                              (3, 293.6))) # assigned by default
+def test_dagmc_temperatures(cell_id, exp_temp):
+    cell = openmc.capi.cells[cell_id]
+    assert np.isclose(cell.get_temperature(), exp_temp)

From 51efa1ef7117486c9d6e4f0345ce4b65516c21fd Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 16:13:27 -0500
Subject: [PATCH 102/127] Some self review.

---
 src/dagmc.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 06d93fc47..829af002c 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -61,7 +61,6 @@ void check_dagmc_file() {
 
 bool get_uwuw_materials_xml(std::string& s) {
   check_dagmc_file();
-
   UWUW uwuw((settings::path_input + DAGMC_FILENAME).c_str());
 
   std::stringstream ss;
@@ -295,8 +294,10 @@ void load_dagmc_geometry()
     // check for temperature assignment
     std::string temp_value;
 
+    // no temperature if void
     if (c->material_[0] == MATERIAL_VOID) { continue; }
 
+    // assign cell temperature
     const auto& mat = model::materials[model::material_map.at(c->material_[0])];
     if (model::DAG->has_prop(vol_handle, "temp")) {
       rval = model::DAG->prop_value(vol_handle, "temp", temp_value);

From 8af82192524ab99281c9a591c83f2f8ea0b21d7c Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Fri, 19 Jul 2019 16:14:57 -0500
Subject: [PATCH 103/127] Small change to wording in cad notebook.

---
 examples/jupyter/cad-based-geometry.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/jupyter/cad-based-geometry.ipynb b/examples/jupyter/cad-based-geometry.ipynb
index 5c449cd00..b13c010cb 100644
--- a/examples/jupyter/cad-based-geometry.ipynb
+++ b/examples/jupyter/cad-based-geometry.ipynb
@@ -240,7 +240,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Note:** Applying tally filters in DagMC models requires prior knowledge of the model. Here, we know that the fuel cell's volume ID in the CAD sofware is 1. To identify cells without use of CAD software, we recommend loading them into the [OpenMC plotter](https://github.com/openmc/plotter) where cell, material, and volume IDs can be identified for native OpenMC and DagMC geometries."
+    "**Note:** Applying tally filters in DagMC models requires prior knowledge of the model. Here, we know that the fuel cell's volume ID in the CAD sofware is 1. To identify cells without use of CAD software, load them into the [OpenMC plotter](https://github.com/openmc/plotter) where cell, material, and volume IDs can be identified for native both OpenMC and DagMC geometries."
    ]
   },
   {

From 91fdc10d46415401e658c5ffbbddc6ebba3a49d8 Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 22 Jul 2019 07:12:23 -0500
Subject: [PATCH 104/127] Get rid of erroneous check in
 ParticleFilter.from_hdf5

---
 openmc/filter.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/openmc/filter.py b/openmc/filter.py
index 52ff8638e..8527ca9b9 100644
--- a/openmc/filter.py
+++ b/openmc/filter.py
@@ -583,10 +583,6 @@ class ParticleFilter(Filter):
                              + cls.short_name.lower() + "' but got '"
                              + group['type'][()].decode() + " instead")
 
-        if 'meshes' not in kwargs:
-            raise ValueError(cls.__name__ + " requires a 'meshes' keyword "
-                             "argument.")
-
         particles = [b.decode() for b in group['bins'][()]]
         filter_id = int(group.name.split('/')[-1].lstrip('filter '))
         return cls(particles, filter_id=filter_id)

From 020c0c306fcff9355206fe1c02f41ec8bfb9476b Mon Sep 17 00:00:00 2001
From: Paul Romano <paul.k.romano@gmail.com>
Date: Mon, 22 Jul 2019 10:10:53 -0500
Subject: [PATCH 105/127] Fix bug in delayed group index in MG mode tallies

---
 src/mgxs.cpp                                  |  2 +-
 src/mgxs_interface.cpp                        | 20 ++-----------------
 .../mg_tallies/results_true.dat               |  2 +-
 3 files changed, 4 insertions(+), 20 deletions(-)

diff --git a/src/mgxs.cpp b/src/mgxs.cpp
index 3aac41f35..1fca66308 100644
--- a/src/mgxs.cpp
+++ b/src/mgxs.cpp
@@ -522,7 +522,7 @@ Mgxs::get_xs(int xstype, int gin, const int* gout, const double* mu,
     break;
   case MG_GET_XS_DECAY_RATE:
     if (dg != nullptr) {
-      val = xs_t->decay_rate(a, *dg + 1);
+      val = xs_t->decay_rate(a, *dg);
     } else {
       val = xs_t->decay_rate(a, 0);
     }
diff --git a/src/mgxs_interface.cpp b/src/mgxs_interface.cpp
index c30850e8f..29e5e8b36 100644
--- a/src/mgxs_interface.cpp
+++ b/src/mgxs_interface.cpp
@@ -263,21 +263,13 @@ get_nuclide_xs(int index, int xstype, int gin, const int* gout,
 {
   int gout_c;
   const int* gout_c_p;
-  int dg_c;
-  const int* dg_c_p;
   if (gout != nullptr) {
     gout_c = *gout - 1;
     gout_c_p = &gout_c;
   } else {
     gout_c_p = gout;
   }
-  if (dg != nullptr) {
-    dg_c = *dg - 1;
-    dg_c_p = &dg_c;
-  } else {
-    dg_c_p = dg;
-  }
-  return data::nuclides_MG[index].get_xs(xstype, gin - 1, gout_c_p, mu, dg_c_p);
+  return data::nuclides_MG[index].get_xs(xstype, gin - 1, gout_c_p, mu, dg);
 }
 
 //==============================================================================
@@ -288,21 +280,13 @@ get_macro_xs(int index, int xstype, int gin, const int* gout,
 {
   int gout_c;
   const int* gout_c_p;
-  int dg_c;
-  const int* dg_c_p;
   if (gout != nullptr) {
     gout_c = *gout - 1;
     gout_c_p = &gout_c;
   } else {
     gout_c_p = gout;
   }
-  if (dg != nullptr) {
-    dg_c = *dg - 1;
-    dg_c_p = &dg_c;
-  } else {
-    dg_c_p = dg;
-  }
-  return data::macro_xs[index].get_xs(xstype, gin - 1, gout_c_p, mu, dg_c_p);
+  return data::macro_xs[index].get_xs(xstype, gin - 1, gout_c_p, mu, dg);
 }
 
 //==============================================================================
diff --git a/tests/regression_tests/mg_tallies/results_true.dat b/tests/regression_tests/mg_tallies/results_true.dat
index bc2393f73..50ec653e2 100644
--- a/tests/regression_tests/mg_tallies/results_true.dat
+++ b/tests/regression_tests/mg_tallies/results_true.dat
@@ -1 +1 @@
-15e00a46742e973d7c3c5defe427e6f76a4f1b661538cf54957712751410218dc64301fe12ccb8dbed3f2d51d19b3e99d2b615a3e98c46f9954894e96667dc23
\ No newline at end of file
+508cd056f2d9409a536e487512df34c683720ea45b9100316efb31c19927890c4cacd92f38817d74fcf491bbe4bdb78a0215a798d5a078e0575e3fd94cedf0bd
\ No newline at end of file

From 20d5f4d9c0b7dc59d51cd0e2763ed2b411de5f8a Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 23 Jul 2019 03:04:12 -0500
Subject: [PATCH 106/127] Updating DAGMC filename.

---
 src/dagmc.cpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 829af002c..8618470b2 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -37,7 +37,7 @@ const bool dagmc_enabled = false;
 
 namespace openmc {
 
-const std::string DAGMC_FILENAME = settings::path_input + "dagmc.h5m";
+const std::string DAGMC_FILENAME = "dagmc.h5m";
 
 namespace simulation {
 
@@ -54,8 +54,9 @@ moab::DagMC* DAG;
 
 
 void check_dagmc_file() {
-  if (!file_exists(DAGMC_FILENAME)) {
-    fatal_error("Geometry DAGMC file '" + DAGMC_FILENAME + "' does not exist!");
+  std::string filename = settings::path_input + DAGMC_FILENAME;
+  if (!file_exists(filename)) {
+    fatal_error("Geometry DAGMC file '" + filename + "' does not exist!");
   }
 }
 
@@ -153,14 +154,18 @@ void legacy_assign_material(const std::string& mat_string, DAGCell* c)
 
 void load_dagmc_geometry()
 {
+  check_dagmc_file();
+
   if (!model::DAG) {
     model::DAG = new moab::DagMC();
   }
 
+
+  std::string filename = settings::path_input + DAGMC_FILENAME;
   // --- Materials ---
 
   // create uwuw instance
-  UWUW uwuw(DAGMC_FILENAME.c_str());
+  UWUW uwuw(filename.c_str());
 
   // check for uwuw material definitions
   bool using_uwuw = !uwuw.material_library.empty();
@@ -173,7 +178,7 @@ void load_dagmc_geometry()
   int32_t dagmc_univ_id = 0; // universe is always 0 for DAGMC runs
 
   // load the DAGMC geometry
-  moab::ErrorCode rval = model::DAG->load_file(DAGMC_FILENAME.c_str());
+  moab::ErrorCode rval = model::DAG->load_file(filename.c_str());
   MB_CHK_ERR_CONT(rval);
 
   // initialize acceleration data structures

From 2287d3f418d63e920d5e0a555aeeff8750675e40 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <shriwise@wisc.edu>
Date: Tue, 23 Jul 2019 03:04:34 -0500
Subject: [PATCH 107/127] Update src/dagmc.cpp

Co-Authored-By: Paul Romano <paul.k.romano@gmail.com>
---
 src/dagmc.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dagmc.cpp b/src/dagmc.cpp
index 8618470b2..3f7c170ce 100644
--- a/src/dagmc.cpp
+++ b/src/dagmc.cpp
@@ -300,7 +300,7 @@ void load_dagmc_geometry()
     std::string temp_value;
 
     // no temperature if void
-    if (c->material_[0] == MATERIAL_VOID) { continue; }
+    if (c->material_[0] == MATERIAL_VOID) continue;
 
     // assign cell temperature
     const auto& mat = model::materials[model::material_map.at(c->material_[0])];

From cc3c51627258399aa98883061035d4c29850e014 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 23 Jul 2019 03:10:26 -0500
Subject: [PATCH 108/127] Moving local fixture into test file.

---
 tests/unit_tests/dagmc/conftest.py | 11 -----------
 tests/unit_tests/dagmc/test.py     | 11 ++++++++++-
 2 files changed, 10 insertions(+), 12 deletions(-)
 delete mode 100644 tests/unit_tests/dagmc/conftest.py

diff --git a/tests/unit_tests/dagmc/conftest.py b/tests/unit_tests/dagmc/conftest.py
deleted file mode 100644
index 9f012b5fa..000000000
--- a/tests/unit_tests/dagmc/conftest.py
+++ /dev/null
@@ -1,11 +0,0 @@
-
-import pytest
-
-@pytest.fixture(scope='module', autouse=True)
-def setup_dagmc_unit_test(request):
-    # Change to test directory
-    olddir = request.fspath.dirpath().chdir()
-    try:
-        yield
-    finally:
-        olddir.chdir()
diff --git a/tests/unit_tests/dagmc/test.py b/tests/unit_tests/dagmc/test.py
index 7698119fc..a07bb0297 100644
--- a/tests/unit_tests/dagmc/test.py
+++ b/tests/unit_tests/dagmc/test.py
@@ -13,8 +13,17 @@ pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
+@pytest.fixture(scope='module', autouse=True)
+def setup_dagmc_unit_test(request):
+    # Change to test directory
+    olddir = request.fspath.dirpath().chdir()
+    try:
+        yield
+    finally:
+        olddir.chdir()
+
 @pytest.fixture(scope="module", autouse=True)
-def dagmc_model():
+def dagmc_model(setup_dagmc_unit_test):
     model = openmc.model.Model()
 
     # settings

From dc4646c241d1f136c2abd200d6cda83a422bc89b Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 23 Jul 2019 03:35:40 -0500
Subject: [PATCH 109/127] Using existing function to run dagmc tests in a
 temporary directory.

---
 tests/unit_tests/dagmc/test.py | 34 +++++++++++-----------------------
 1 file changed, 11 insertions(+), 23 deletions(-)

diff --git a/tests/unit_tests/dagmc/test.py b/tests/unit_tests/dagmc/test.py
index a07bb0297..fb5bb584e 100644
--- a/tests/unit_tests/dagmc/test.py
+++ b/tests/unit_tests/dagmc/test.py
@@ -1,5 +1,5 @@
 import glob
-import os
+import shutil
 
 import numpy as np
 import pytest
@@ -13,17 +13,9 @@ pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
-@pytest.fixture(scope='module', autouse=True)
-def setup_dagmc_unit_test(request):
-    # Change to test directory
-    olddir = request.fspath.dirpath().chdir()
-    try:
-        yield
-    finally:
-        olddir.chdir()
-
 @pytest.fixture(scope="module", autouse=True)
-def dagmc_model(setup_dagmc_unit_test):
+def dagmc_model(request):
+
     model = openmc.model.Model()
 
     # settings
@@ -62,21 +54,17 @@ def dagmc_model(setup_dagmc_unit_test):
     mats = openmc.Materials([u235, water])
     model.materials = mats
 
-    model.export_to_xml()
-
-    openmc.capi.init()
-
-    yield
+    # location of  dagmc file in test directory
+    dagmc_file = request.fspath.dirpath() + "/dagmc.h5m"
+    # move to a temporary directory
+    with cdtemp():
+        shutil.copyfile(dagmc_file, "./dagmc.h5m")
+        model.export_to_xml()
+        openmc.capi.init()
+        yield
 
     openmc.capi.finalize()
 
-    # cleanup
-    input_files = glob.glob("*.xml")
-    input_files += glob.glob("*.h5")
-    for f in input_files:
-        if os.path.exists(f):
-            os.remove(f)
-
 @pytest.mark.parametrize("cell_id,exp_temp", ((1, 320.0),  # assigned by material
                                               (2, 300.0),  # assigned in dagmc file
                                               (3, 293.6))) # assigned by default

From 9f41dce1d253b876bf5417dc33771422a5bf549f Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 23 Jul 2019 08:29:37 -0500
Subject: [PATCH 110/127] Return energy in J/s/source neutron for EnergyHelper

Addressing comments in review for #1278

- Documentation cleanup
- Better naming convention regarding ReactionRateHelper
  results cache
- The power in Operator tally unpacking and normalizing is
  no longer converted to eV/s, since the EnergyHelper.energy
  property is now returned in J/s/source neutron
---
 docs/source/pythonapi/deplete.rst |  6 ++---
 openmc/deplete/abc.py             | 34 +++++++++++++-------------
 openmc/deplete/helpers.py         | 40 ++++++++++++++++++++++---------
 openmc/deplete/operator.py        | 16 +++++--------
 4 files changed, 55 insertions(+), 41 deletions(-)

diff --git a/docs/source/pythonapi/deplete.rst b/docs/source/pythonapi/deplete.rst
index 091b25da7..70d48f931 100644
--- a/docs/source/pythonapi/deplete.rst
+++ b/docs/source/pythonapi/deplete.rst
@@ -75,8 +75,8 @@ data, such as number densities and reaction rates for each material.
    :template: myclass.rst
 
    AtomNumber
-   ChainFissHelper
-   DirectRxnRateHelper
+   ChainFissionHelper
+   DirectReactionRateHelper
    OperatorResult
    ReactionRates
    Results
@@ -92,7 +92,7 @@ The following classes are abstract classes that can be used to extend the
    :template: myclass.rst
 
    ReactionRateHelper
-   FissionEnergyHelper
+   EnergyHelper
    TransportOperator
 
 Each of the integrator functions also relies on a number of "helper" functions
diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index b171d9356..ecff16868 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -11,9 +11,9 @@ from abc import ABC, abstractmethod
 from xml.etree import ElementTree as ET
 from warnings import warn
 
-from numpy import zeros, nonzero
+from numpy import nonzero, empty
 
-from openmc.data import DataLibrary
+from openmc.data import DataLibrary, JOULE_PER_EV
 from openmc.checkvalue import check_type
 from .chain import Chain
 
@@ -188,7 +188,7 @@ class ReactionRateHelper(ABC):
 
     @abstractmethod
     def generate_tallies(self, materials, scores):
-        """Use the capi to build tallies needed for reaction rates"""
+        """Use the C API to build tallies needed for reaction rates"""
 
     @property
     def nuclides(self):
@@ -201,13 +201,15 @@ class ReactionRateHelper(ABC):
         self._nuclides = nuclides
         self._rate_tally.nuclides = nuclides
 
-    def _reset_results_cache(self, nnucs, nreact):
-        """Cache for results for a given material"""
+    def _get_results_cache(self, nnucs, nreact):
+        """Cache for results for a given material
+
+        Creates an empty array of shape ``(nnucs, nreact)``
+        if the shape does not match the current cache.
+        """
         if (self._results_cache is None
                 or self._results_cache.shape != (nnucs, nreact)):
-            self._results_cache = zeros((nnucs, nreact))
-        else:
-            self._results_cache.fill(0.0)
+            self._results_cache = empty((nnucs, nreact))
         return self._results_cache
 
     @abstractmethod
@@ -216,6 +218,8 @@ class ReactionRateHelper(ABC):
 
         Parameters
         ----------
+        mat_id : int
+            Unique ID for the requested material
         nuc_index : list of str
             Ordering of desired nuclides
         react_index : list of str
@@ -230,17 +234,13 @@ class ReactionRateHelper(ABC):
 
         Parameters
         ----------
-        energy : float
-            Energy produced in this region [W]
-        number : iterable of float
-            Number density [atoms/b/cm] of each nuclide tracked in the calculation.
             Ordered identically to :attr:`nuclides`
 
         Returns
         -------
-        results : `numpy.ndarray`
-            2D array ``[n_nuclides, n_rxns]`` of reaction rates normalized by
-            the number of nuclides
+        results : numpy.ndarray
+            Array of reactions rates of shape ``(n_nuclides, n_rxns)``
+            normalized by the number of nuclides
         """
 
         mask = nonzero(number)
@@ -266,7 +266,7 @@ class EnergyHelper(ABC):
         All nuclides with desired reaction rates. Ordered to be
         consistent with :class:`openmc.deplete.Operator`
     energy : float
-        Total energy [eV/s] produced in a transport simulation.
+        Total energy [J/s/source neutron] produced in a transport simulation.
         Updated in the material iteration with :meth:`update`.
     """
 
@@ -276,7 +276,7 @@ class EnergyHelper(ABC):
 
     @property
     def energy(self):
-        return self._energy
+        return self._energy * JOULE_PER_EV
 
     def reset(self):
         """Reset energy produced prior to unpacking tallies"""
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index da85312a8..edf0feb06 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -14,7 +14,14 @@ from .abc import ReactionRateHelper, EnergyHelper
 
 
 class DirectReactionRateHelper(ReactionRateHelper):
-    """Class that generates tallies for one-group rates"""
+    """Class that generates tallies for one-group rates
+
+    Attributes
+    ----------
+    nuclides : list of str
+        All nuclides with desired reaction rates. Ordered to be
+        consistent with :class:`openmc.deplete.Operator`
+    """
 
     def generate_tallies(self, materials, scores):
         """Produce one-group reaction rate tally
@@ -41,7 +48,7 @@ class DirectReactionRateHelper(ReactionRateHelper):
         Parameters
         ----------
         mat_id : int
-            Unique id for the requested material
+            Unique ID for the requested material
         nuc_index : iterable of int
             Index for each nuclide in :attr:`nuclides` in the
             desired reaction rate matrix
@@ -50,11 +57,12 @@ class DirectReactionRateHelper(ReactionRateHelper):
 
         Returns
         -------
-        rates : :class:`numpy.ndarray`
-            2D matrix ``(len(nuc_index), len(react_index))`` with the
+        rates : numpy.ndarray
+            Array with shape ``(n_nuclides, n_rxns)`` with the
             reaction rates in this material
         """
-        results = self._reset_results_cache(len(nuc_index), len(react_index))
+        results = self._get_results_cache(len(nuc_index), len(react_index))
+        results.fill(0.0)
         full_tally_res = self._rate_tally.results[mat_id, :, 1]
         for i_tally, (i_nuc, i_react) in enumerate(
                 product(nuc_index, react_index)):
@@ -63,13 +71,23 @@ class DirectReactionRateHelper(ReactionRateHelper):
         return results
 
 
-# ------------------------------------
-# Helpers for obtaining fission energy
-# ------------------------------------
+# ----------------------------
+# Helpers for obtaining energy
+# ----------------------------
 
 
 class ChainFissionHelper(EnergyHelper):
-    """Fission Q-values are pulled from chain"""
+    """Computes energy using fission Q values from depletion chain
+
+    Attributes
+    ----------
+    nuclides : list of str
+        All nuclides with desired reaction rates. Ordered to be
+        consistent with :class:`openmc.deplete.Operator`
+    energy : float
+        Total energy [J/s/source neutron] produced in a transport simulation.
+        Updated in the material iteration with :meth:`update`.
+    """
 
     def __init__(self):
         super().__init__()
@@ -78,8 +96,8 @@ class ChainFissionHelper(EnergyHelper):
     def prepare(self, chain_nucs, rate_index, _materials):
         """Populate the fission Q value vector from a chain.
 
-        Paramters
-        ---------
+        Parameters
+        ----------
         chain_nucs : iterable of :class:`openmc.deplete.Nuclide`
             Nuclides used in this depletion chain. Do not need
             to be ordered
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index 815602247..bb3c96e4f 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -19,7 +19,6 @@ import numpy as np
 
 import openmc
 import openmc.capi
-from openmc.data import JOULE_PER_EV
 from . import comm
 from .abc import TransportOperator, OperatorResult
 from .atom_number import AtomNumber
@@ -138,7 +137,11 @@ class Operator(TransportOperator):
         openmc.reset_auto_ids()
         self.burnable_mats, volume, nuclides = self._get_burnable_mats()
         self.local_mats = _distribute(self.burnable_mats)
-        self._mat_index_map = {}
+
+        # Generate map from local materials => material index
+        self._mat_index_map = {
+            lm: self.burnable_mats.index(lm) for lm in self.local_mats}
+
 
         # Determine which nuclides have incident neutron data
         self.nuclides_with_data = self._get_nuclides_with_data()
@@ -158,7 +161,6 @@ class Operator(TransportOperator):
         self._rate_helper = DirectReactionRateHelper()
         self._energy_helper = ChainFissionHelper()
 
-
     def __call__(self, vec, power, print_out=True):
         """Runs a simulation.
 
@@ -387,10 +389,6 @@ class Operator(TransportOperator):
         self._energy_helper.prepare(
             self.chain.nuclides, self.reaction_rates.index_nuc, materials)
 
-        # Generate map from local materials => material index
-        self._mat_index_map = {
-            lm: self.burnable_mats.index(lm) for lm in self.local_mats}
-
         # Return number density vector
         return list(self.number.get_mat_slice(np.s_[:]))
 
@@ -564,11 +562,9 @@ class Operator(TransportOperator):
             rates[i] = self._rate_helper.divide_by_adens(number)
 
         # Reduce energy produced from all processes
+        # J / s / source neutron
         energy = comm.allreduce(self._energy_helper.energy)
 
-        # Determine power in eV/s
-        power /= JOULE_PER_EV
-
         # Scale reaction rates to obtain units of reactions/sec
         rates *= power / energy
 

From 6ae45931a67df84592e016da8ea85a2b1c111b80 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 23 Jul 2019 11:28:58 -0500
Subject: [PATCH 111/127] Re-document number parameter in
 ReactionRateHelper.divide_by_adens

---
 openmc/deplete/abc.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index ecff16868..c5c086854 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -234,6 +234,8 @@ class ReactionRateHelper(ABC):
 
         Parameters
         ----------
+        number : iterable of float
+            Number density [atoms/b-cm] of each nuclide tracked in the calculation.
             Ordered identically to :attr:`nuclides`
 
         Returns

From 173bea707280f6f110b616db9148b324e6d52320 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 23 Jul 2019 11:43:42 -0500
Subject: [PATCH 112/127] No longer run MOAB tests in CI.

---
 tools/ci/travis-install-dagmc.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/ci/travis-install-dagmc.sh b/tools/ci/travis-install-dagmc.sh
index ca3e8b3c7..1797e9dba 100755
--- a/tools/ci/travis-install-dagmc.sh
+++ b/tools/ci/travis-install-dagmc.sh
@@ -20,7 +20,7 @@ mkdir MOAB && cd MOAB
 git clone -b $MOAB_BRANCH $MOAB_REPO
 mkdir build && cd build
 cmake ../moab -DENABLE_HDF5=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=$MOAB_INSTALL_DIR
-make -j && make -j test install
+make -j && make -j install
 cmake ../moab -DBUILD_SHARED_LIBS=OFF
 make -j install
 rm -rf $HOME/MOAB/moab

From 3183c86bd75b0c97c1b6f16cfee30a035a735c8b Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 23 Jul 2019 12:45:40 -0500
Subject: [PATCH 113/127] Typo fix.

---
 examples/jupyter/candu.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/jupyter/candu.ipynb b/examples/jupyter/candu.ipynb
index 1349e80ad..672d56f89 100644
--- a/examples/jupyter/candu.ipynb
+++ b/examples/jupyter/candu.ipynb
@@ -52,7 +52,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With out materials created, we'll now define key dimensions in our model. These dimensions are taken from the example in section 11.1.3 of the [Serpent manual](http://montecarlo.vtt.fi/download/Serpent_manual.pdf)."
+    "With our materials created, we'll now define key dimensions in our model. These dimensions are taken from the example in section 11.1.3 of the [Serpent manual](http://montecarlo.vtt.fi/download/Serpent_manual.pdf)."
    ]
   },
   {

From 67575b336920f1ad2153f0bb04b3a07d557fe305 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Tue, 23 Jul 2019 14:25:33 -0500
Subject: [PATCH 114/127] Limit number of jobs in MOAB build.

---
 tools/ci/travis-install-dagmc.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/ci/travis-install-dagmc.sh b/tools/ci/travis-install-dagmc.sh
index 1797e9dba..30b55dd89 100755
--- a/tools/ci/travis-install-dagmc.sh
+++ b/tools/ci/travis-install-dagmc.sh
@@ -20,7 +20,7 @@ mkdir MOAB && cd MOAB
 git clone -b $MOAB_BRANCH $MOAB_REPO
 mkdir build && cd build
 cmake ../moab -DENABLE_HDF5=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=$MOAB_INSTALL_DIR
-make -j && make -j install
+make -j2 && make -j install
 cmake ../moab -DBUILD_SHARED_LIBS=OFF
 make -j install
 rm -rf $HOME/MOAB/moab

From d820e6777aef9556c355e183be64032ad269f5b8 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <shriwise@wisc.edu>
Date: Tue, 23 Jul 2019 14:33:35 -0500
Subject: [PATCH 115/127] Apply suggestions from code review

Accessing cell/material names through accessor. Returning a const reference from `name()` accessor in both cases.

Co-Authored-By: Paul Romano <paul.k.romano@gmail.com>
---
 include/openmc/cell.h     | 2 +-
 include/openmc/material.h | 2 +-
 src/cell.cpp              | 2 +-
 src/material.cpp          | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index 752945cee..602da98e7 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -136,7 +136,7 @@ public:
 
   //! Get the name of a cell
   //! \return Cell name
-  std::string name() const { return name_; };
+  const std::string& name() const { return name_; };
 
   //! Set the temperature of a cell instance
   //! \param[in] name Cell name
diff --git a/include/openmc/material.h b/include/openmc/material.h
index aa0a4bad0..652f3db8e 100644
--- a/include/openmc/material.h
+++ b/include/openmc/material.h
@@ -94,7 +94,7 @@ public:
 
   //! Get name
   //! \return Material name
-  std::string name() const { return name_; }
+  const std::string& name() const { return name_; }
 
   //! Set name
   void set_name(const std::string& name) { name_ = name; }
diff --git a/src/cell.cpp b/src/cell.cpp
index 7cc74ed9f..49d8cb1b4 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -1089,7 +1089,7 @@ openmc_cell_get_name(int32_t index, const char** name) {
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  *name = model::cells[index]->name_.data();
+  *name = model::cells[index]->name().data();
 
   return 0;
 }
diff --git a/src/material.cpp b/src/material.cpp
index 699649d31..685fd1da2 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1388,7 +1388,7 @@ openmc_material_get_name(int32_t index, const char** name) {
     return OPENMC_E_OUT_OF_BOUNDS;
   }
 
-  *name = model::materials[index]->name_.data();
+  *name = model::materials[index]->name().data();
 
   return 0;
 }

From 3439797e322a78f88bce137ad77835e3c2fb3706 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Wed, 24 Jul 2019 03:02:10 -0500
Subject: [PATCH 116/127] Update for case where the entire region is a
 complement. Addition of a cell and redefinition of another to test more
 robustly.

---
 include/openmc/cell.h                      |  1 +
 src/cell.cpp                               | 23 +++++++++++++++++-----
 tests/unit_tests/test_complex_cell_capi.py | 15 +++++++-------
 3 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/include/openmc/cell.h b/include/openmc/cell.h
index 602da98e7..db8d60ed4 100644
--- a/include/openmc/cell.h
+++ b/include/openmc/cell.h
@@ -212,6 +212,7 @@ protected:
   bool contains_complex(Position r, Direction u, int32_t on_surface) const;
   BoundingBox bounding_box_simple() const;
   static BoundingBox bounding_box_complex(std::vector<int32_t> rpn);
+  static void apply_demorgan(std::vector<int32_t>& rpn);
 };
 
 //==============================================================================
diff --git a/src/cell.cpp b/src/cell.cpp
index 49d8cb1b4..510002fa9 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -587,8 +587,25 @@ BoundingBox CSGCell::bounding_box_simple() const {
   return bbox;
 }
 
+void CSGCell::apply_demorgan(std::vector<int32_t>& rpn) {
+  for (auto& token : rpn) {
+    if (token < OP_UNION) { token *= -1; }
+    else if (token == OP_UNION) { token = OP_INTERSECTION; }
+    else if (token == OP_INTERSECTION) { token = OP_UNION; }
+  }
+}
+
 BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) {
 
+  // if the last operator is a complement op, there is no
+  // sub-region that the complement connects to. This indicates
+  // that the entire region is a complement and we can apply
+  // De Morgan's laws immediately
+  if ((rpn.back() == OP_COMPLEMENT)) {
+      rpn.pop_back();
+      apply_demorgan(rpn);
+  }
+
   std::reverse(rpn.begin(), rpn.end());
 
   BoundingBox current = model::surfaces[abs(rpn.back()) - 1]->bounding_box(rpn.back() > 0);
@@ -626,11 +643,7 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) {
       // handle complement case using De Morgan's laws
       if (subrpn.back() == OP_COMPLEMENT) {
         subrpn.pop_back();
-        for (auto& token : subrpn) {
-          if (token < OP_UNION) { token *= -1; }
-          else if (token == OP_UNION) { token = OP_INTERSECTION; }
-          else if (token == OP_INTERSECTION) { token = OP_UNION; }
-        }
+        apply_demorgan(subrpn);
         subrpn.push_back(rpn.back());
         rpn.pop_back();
       }
diff --git a/tests/unit_tests/test_complex_cell_capi.py b/tests/unit_tests/test_complex_cell_capi.py
index ebc345f8f..451233d64 100644
--- a/tests/unit_tests/test_complex_cell_capi.py
+++ b/tests/unit_tests/test_complex_cell_capi.py
@@ -46,7 +46,7 @@ def complex_cell(run_in_tmpdir):
     s17 = openmc.YPlane(y0=0.0)
 
     c1 = openmc.Cell(fill=u235)
-    c1.region = +s3 & -s4 & +s13 & -s14
+    c1.region = ~(-s3 | +s4 | ~(+s13 & -s14))
 
     c2 = openmc.Cell(fill=u238)
     c2.region = +s2 & -s5 & +s12 & -s15 & ~(+s3 & -s4 & +s13 & -s14)
@@ -59,8 +59,11 @@ def complex_cell(run_in_tmpdir):
     c4.region = ((+s1 & -s7 & +s11 & -s17) | (+s7 & -s6 & +s17 & -s16)) & \
                 ~(+s2 & -s5 & +s12 & -s15)
 
+    c5 = openmc.Cell(fill=n14)
+    c5.region = ~(+s1 & -s6 & +s11 & -s16)
+
     model.geometry.root_universe = openmc.Universe()
-    model.geometry.root_universe.add_cells([c1, c2, c3, c4])
+    model.geometry.root_universe.add_cells([c1, c2, c3, c4, c5])
 
     model.settings.batches = 10
     model.settings.inactive = 5
@@ -84,13 +87,11 @@ inf = sys.float_info.max
 expected_results = ( (1, (( -4.,  -4., -inf), ( 4.,  4., inf))),
                      (2, (( -7.,  -7., -inf), ( 7.,  7., inf))),
                      (3, ((-10., -10., -inf), (10., 10., inf))),
-                     (4, ((-10., -10., -inf), (10., 10., inf))) )
+                     (4, ((-10., -10., -inf), (10., 10., inf))),
+                     (5, ((-inf, -inf, -inf), (inf, inf, inf))) )
 @pytest.mark.parametrize("cell_id,expected_box", expected_results)
 def test_cell_box(cell_id, expected_box):
+    print("Cell {}".format(cell_id))
     cell_box = openmc.capi.cells[cell_id].bounding_box
     assert tuple(cell_box[0]) == expected_box[0]
     assert tuple(cell_box[1]) == expected_box[1]
-
-    cell_box = openmc.capi.bounding_box("Cell", cell_id)
-    assert tuple(cell_box[0]) == expected_box[0]
-    assert tuple(cell_box[1]) == expected_box[1]

From 3be6520671b7fc2fda51446edeffd5aca0f13225 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Wed, 24 Jul 2019 12:49:02 -0500
Subject: [PATCH 117/127] Removing print statement.

---
 tests/unit_tests/test_complex_cell_capi.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/unit_tests/test_complex_cell_capi.py b/tests/unit_tests/test_complex_cell_capi.py
index 451233d64..e5983d2d5 100644
--- a/tests/unit_tests/test_complex_cell_capi.py
+++ b/tests/unit_tests/test_complex_cell_capi.py
@@ -91,7 +91,6 @@ expected_results = ( (1, (( -4.,  -4., -inf), ( 4.,  4., inf))),
                      (5, ((-inf, -inf, -inf), (inf, inf, inf))) )
 @pytest.mark.parametrize("cell_id,expected_box", expected_results)
 def test_cell_box(cell_id, expected_box):
-    print("Cell {}".format(cell_id))
     cell_box = openmc.capi.cells[cell_id].bounding_box
     assert tuple(cell_box[0]) == expected_box[0]
     assert tuple(cell_box[1]) == expected_box[1]

From 5ad4f94f3adcb2653b7c91d8c6c636e4238d1e96 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Wed, 24 Jul 2019 13:10:03 -0500
Subject: [PATCH 118/127] Removing CAPI function for bounding box of any type.
 Moving to a cell-only function. Tests are adjusted as needed.

---
 include/openmc/capi.h         |  2 +-
 openmc/capi/cell.py           |  7 ++++-
 openmc/capi/core.py           | 27 -------------------
 src/cell.cpp                  | 28 ++++++++++++++++---
 src/geometry.cpp              | 51 -----------------------------------
 tests/unit_tests/test_capi.py | 46 -------------------------------
 6 files changed, 32 insertions(+), 129 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index 3dd9ae697..ded41f738 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -31,7 +31,7 @@ extern "C" {
   int openmc_filter_set_id(int32_t index, int32_t id);
   int openmc_finalize();
   int openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance);
-  int openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc);
+  int openmc_cell_bounding_box(const int32_t index, double* llc, double* urc);
   int openmc_global_bounding_box(double* llc, double* urc);
   int openmc_fission_bank(void** ptr, int64_t* n);
   int openmc_get_cell_index(int32_t id, int32_t* index);
diff --git a/openmc/capi/cell.py b/openmc/capi/cell.py
index af948c92d..de8ee9f43 100644
--- a/openmc/capi/cell.py
+++ b/openmc/capi/cell.py
@@ -49,6 +49,11 @@ _dll.openmc_get_cell_index.argtypes = [c_int32, POINTER(c_int32)]
 _dll.openmc_get_cell_index.restype = c_int
 _dll.openmc_get_cell_index.errcheck = _error_handler
 _dll.cells_size.restype = c_int
+_dll.openmc_cell_bounding_box.argtypes = [c_int,
+                                          POINTER(c_double),
+                                          POINTER(c_double)]
+_dll.openmc_cell_bounding_box.restype = c_int
+_dll.openmc_cell_bounding_box.errcheck = _error_handler
 
 
 class Cell(_FortranObjectWithID):
@@ -187,7 +192,7 @@ class Cell(_FortranObjectWithID):
     def bounding_box(self):
         llc = np.zeros(3)
         urc = np.zeros(3)
-        _dll.openmc_bounding_box(b'Cell', self.id,
+        _dll.openmc_cell_bounding_box(self._index,
                                  llc.ctypes.data_as(POINTER(c_double)),
                                  urc.ctypes.data_as(POINTER(c_double)))
         return llc, urc
diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index c3f5ea1b6..cd7401a23 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -73,11 +73,6 @@ _dll.openmc_simulation_finalize.errcheck = _error_handler
 _dll.openmc_statepoint_write.argtypes = [c_char_p, POINTER(c_bool)]
 _dll.openmc_statepoint_write.restype = c_int
 _dll.openmc_statepoint_write.errcheck = _error_handler
-_dll.openmc_bounding_box.argtypes = [c_char_p, c_int,
-                                     POINTER(c_double),
-                                     POINTER(c_double)]
-_dll.openmc_bounding_box.restype = c_int
-_dll.openmc_bounding_box.errcheck = _error_handler
 _dll.openmc_global_bounding_box.argtypes = [POINTER(c_double),
                                             POINTER(c_double)]
 _dll.openmc_global_bounding_box.restype = c_int
@@ -93,28 +88,6 @@ def global_bounding_box():
 
     return llc, urc
 
-
-def bounding_box(geom_type, geom_id):
-    """Get a bounding box for a geometric object
-
-    Parameters
-    ----------
-    geom_type : str
-        Type of geometry object. One of ('surface', 'cell', 'universe')
-    geom_id : int
-        ID of the object. Can be positive or negative for surfaces.
-    """
-    geomt = c_char_p(geom_type.encode())
-    llc = np.zeros(3)
-    urc = np.zeros(3)
-    _dll.openmc_bounding_box(geomt,
-                             geom_id,
-                             llc.ctypes.data_as(POINTER(c_double)),
-                             urc.ctypes.data_as(POINTER(c_double)))
-
-    return llc, urc
-
-
 def calculate_volumes():
     """Run stochastic volume calculation"""
     _dll.openmc_calculate_volumes()
diff --git a/src/cell.cpp b/src/cell.cpp
index 510002fa9..3c079f7ae 100644
--- a/src/cell.cpp
+++ b/src/cell.cpp
@@ -587,6 +587,7 @@ BoundingBox CSGCell::bounding_box_simple() const {
   return bbox;
 }
 
+
 void CSGCell::apply_demorgan(std::vector<int32_t>& rpn) {
   for (auto& token : rpn) {
     if (token < OP_UNION) { token *= -1; }
@@ -601,11 +602,12 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) {
   // sub-region that the complement connects to. This indicates
   // that the entire region is a complement and we can apply
   // De Morgan's laws immediately
-  if ((rpn.back() == OP_COMPLEMENT)) {
+  if (rpn.back() == OP_COMPLEMENT) {
       rpn.pop_back();
       apply_demorgan(rpn);
   }
 
+  // reverse the rpn to make popping easier
   std::reverse(rpn.begin(), rpn.end());
 
   BoundingBox current = model::surfaces[abs(rpn.back()) - 1]->bounding_box(rpn.back() > 0);
@@ -631,8 +633,6 @@ BoundingBox CSGCell::bounding_box_complex(std::vector<int32_t> rpn) {
       std::vector<int32_t> subrpn;
       subrpn.push_back(one);
       subrpn.push_back(two);
-      int32_t sone = one;
-      int32_t stwo = two;
       // add until last two tokens in the sub-rpn are operators
       // (indicates a right parenthesis)
       while (!((subrpn.back() >= OP_UNION) && (*(subrpn.rbegin() + 1) >= OP_UNION))) {
@@ -1094,6 +1094,28 @@ openmc_cell_get_temperature(int32_t index, const int32_t* instance, double* T)
   return 0;
 }
 
+//! Get the bounding box of a cell
+extern "C" int
+openmc_cell_bounding_box(const int32_t index, double* llc, double* urc) {
+
+  BoundingBox bbox;
+
+  const auto& c = model::cells[index];
+  bbox = c->bounding_box();
+
+  // set lower left corner values
+  llc[0] = bbox.xmin;
+  llc[1] = bbox.ymin;
+  llc[2] = bbox.zmin;
+
+  // set upper right corner values
+  urc[0] = bbox.xmax;
+  urc[1] = bbox.ymax;
+  urc[2] = bbox.zmax;
+
+  return 0;
+}
+
 //! Get the name of a cell
 extern "C" int
 openmc_cell_get_name(int32_t index, const char** name) {
diff --git a/src/geometry.cpp b/src/geometry.cpp
index ae48a0acb..556d10650 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -476,57 +476,6 @@ openmc_find_cell(const double* xyz, int32_t* index, int32_t* instance)
   return 0;
 }
 
-extern "C" int
-openmc_bounding_box(const char* geom_type, const int32_t id, double* llc, double* urc) {
-
-  BoundingBox bbox;
-
-  std::string gtype(geom_type);
-  to_lower(gtype);
-
-  // negative ids only for surfaces
-  if (id < 0 && gtype != "surface") {
-    std::stringstream msg;
-    msg << "Negative ID " << id << " passed to bounding box for "
-        << "non-surface geom type '" << geom_type << "'" << std::endl;
-    set_errmsg(msg);
-    return OPENMC_E_INVALID_ID;
-  }
-  // id should never be zero
-  if (id == 0) {
-    set_errmsg("Invalid ID 0 for surface bounding box.");
-    return OPENMC_E_INVALID_ID;
-  }
-
-  if (gtype == "universe") {
-    const auto& u = model::universes[model::universe_map.at(id)];
-    bbox = u->bounding_box();
-  } else if (gtype == "cell") {
-    const auto& c = model::cells[model::cell_map.at(id)];
-    bbox = c->bounding_box();
-  } else if (gtype == "surface") {
-    const auto& s = model::surfaces[model::surface_map.at(abs(id))];
-    bbox = s->bounding_box(id > 0);
-  } else {
-    std::stringstream msg;
-    msg << "Geometry type: " << gtype << " is invalid.";
-    set_errmsg(msg);
-    return OPENMC_E_INVALID_TYPE;
-  }
-
-  // set lower left corner values
-  llc[0] = bbox.xmin;
-  llc[1] = bbox.ymin;
-  llc[2] = bbox.zmin;
-
-  // set upper right corner values
-  urc[0] = bbox.xmax;
-  urc[1] = bbox.ymax;
-  urc[2] = bbox.zmax;
-
-  return 0;
-}
-
 extern "C" int openmc_global_bounding_box(double* llc, double* urc) {
   auto bbox = model::universes.at(model::root_universe)->bounding_box();
 
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index 3fdd4db66..d1c578ba0 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -475,52 +475,6 @@ def test_position(capi_init):
 
     assert tuple(pos) == (1.3, 2.3, 3.3)
 
-def test_bounding_box(capi_init):
-    inf = sys.float_info.max
-
-    expected_llc = (-inf, -0.63, -inf)
-    expected_urc = (inf, inf, inf)
-
-    llc, urc = openmc.capi.bounding_box("Surface", 5)
-
-    assert tuple(llc) == expected_llc
-    assert tuple(urc) == expected_urc
-
-
-    expected_llc = (-inf, -inf, -inf)
-    expected_urc = (inf, -0.63, inf)
-
-    llc, urc = openmc.capi.bounding_box("Surface", -5)
-
-    assert tuple(llc) == expected_llc
-    assert tuple(urc) == expected_urc
-
-    expected_llc = (-0.39218, -0.39218, -inf)
-    expected_urc = (0.39218, 0.39218, inf)
-
-    llc, urc = openmc.capi.bounding_box("Cell", 1)
-
-    assert tuple(llc) == expected_llc
-    assert tuple(urc) == expected_urc
-
-    expected_llc = (-0.45720, -0.45720, -inf)
-    expected_urc = (0.45720, 0.45720, inf)
-
-    llc, urc = openmc.capi.bounding_box("Cell", 2)
-
-    assert tuple(llc) == expected_llc
-    assert tuple(urc) == expected_urc
-
-    # make sure that proper assertions are raised
-    with pytest.raises(openmc.exceptions.InvalidIDError):
-        openmc.capi.bounding_box("Cell", -1)
-
-    with pytest.raises(openmc.exceptions.InvalidIDError):
-        openmc.capi.bounding_box("Surface", 0)
-
-    with pytest.raises(openmc.exceptions.InvalidTypeError):
-        openmc.capi.bounding_box("Region", 1)
-
 
 def test_global_bounding_box(capi_init):
     inf = sys.float_info.max

From 90db1ab38a3328a3b47d4d6f21161f7987bc396d Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Wed, 24 Jul 2019 13:17:13 -0500
Subject: [PATCH 119/127] Removing limit on number of jobs for MOAB CI build.
 Updates to dagmc unit test file.

---
 tests/unit_tests/dagmc/test.py   | 13 +++++++------
 tools/ci/travis-install-dagmc.sh |  2 +-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/tests/unit_tests/dagmc/test.py b/tests/unit_tests/dagmc/test.py
index fb5bb584e..bfe054dd8 100644
--- a/tests/unit_tests/dagmc/test.py
+++ b/tests/unit_tests/dagmc/test.py
@@ -1,4 +1,3 @@
-import glob
 import shutil
 
 import numpy as np
@@ -13,6 +12,7 @@ pytestmark = pytest.mark.skipif(
     not openmc.capi._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
+
 @pytest.fixture(scope="module", autouse=True)
 def dagmc_model(request):
 
@@ -24,8 +24,8 @@ def dagmc_model(request):
     model.settings.particles = 100
     model.settings.temperature = {'tolerance': 50.0}
     model.settings.verbosity = 1
-    source_box = openmc.stats.Box([-4, -4, -4],
-                                  [ 4,  4,  4])
+    source_box = openmc.stats.Box([ -4, -4, -4 ],
+                                  [  4,  4,  4 ])
     source = openmc.Source(space=source_box)
     model.settings.source = source
 
@@ -65,9 +65,10 @@ def dagmc_model(request):
 
     openmc.capi.finalize()
 
-@pytest.mark.parametrize("cell_id,exp_temp", ((1, 320.0),  # assigned by material
-                                              (2, 300.0),  # assigned in dagmc file
-                                              (3, 293.6))) # assigned by default
+
+@pytest.mark.parametrize("cell_id,exp_temp", ((1, 320.0),   # assigned by material
+                                              (2, 300.0),   # assigned in dagmc file
+                                              (3, 293.6)))  # assigned by default
 def test_dagmc_temperatures(cell_id, exp_temp):
     cell = openmc.capi.cells[cell_id]
     assert np.isclose(cell.get_temperature(), exp_temp)
diff --git a/tools/ci/travis-install-dagmc.sh b/tools/ci/travis-install-dagmc.sh
index 30b55dd89..1797e9dba 100755
--- a/tools/ci/travis-install-dagmc.sh
+++ b/tools/ci/travis-install-dagmc.sh
@@ -20,7 +20,7 @@ mkdir MOAB && cd MOAB
 git clone -b $MOAB_BRANCH $MOAB_REPO
 mkdir build && cd build
 cmake ../moab -DENABLE_HDF5=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=$MOAB_INSTALL_DIR
-make -j2 && make -j install
+make -j && make -j install
 cmake ../moab -DBUILD_SHARED_LIBS=OFF
 make -j install
 rm -rf $HOME/MOAB/moab

From d5eaa3b5b768a67a3c80b4d033ecc7dbc6695db3 Mon Sep 17 00:00:00 2001
From: Patrick Shriwise <pshriwise@gmail.com>
Date: Wed, 24 Jul 2019 14:36:55 -0500
Subject: [PATCH 120/127] Converting double max to np.inf on the Python side
 for bounding boxes.

---
 openmc/capi/cell.py                        |  8 ++++++++
 openmc/capi/core.py                        |  7 +++++++
 tests/unit_tests/test_capi.py              |  7 ++-----
 tests/unit_tests/test_complex_cell_capi.py | 18 ++++++++++--------
 4 files changed, 27 insertions(+), 13 deletions(-)

diff --git a/openmc/capi/cell.py b/openmc/capi/cell.py
index de8ee9f43..784ebd087 100644
--- a/openmc/capi/cell.py
+++ b/openmc/capi/cell.py
@@ -1,3 +1,5 @@
+import sys
+
 from collections.abc import Mapping, Iterable
 from ctypes import c_int, c_int32, c_double, c_char_p, POINTER
 from weakref import WeakValueDictionary
@@ -190,11 +192,17 @@ class Cell(_FortranObjectWithID):
 
     @property
     def bounding_box(self):
+        inf = sys.float_info.max
         llc = np.zeros(3)
         urc = np.zeros(3)
         _dll.openmc_cell_bounding_box(self._index,
                                  llc.ctypes.data_as(POINTER(c_double)),
                                  urc.ctypes.data_as(POINTER(c_double)))
+        llc[llc == inf] = np.inf
+        urc[urc == inf] = np.inf
+        llc[llc == -inf] = -np.inf
+        urc[urc == -inf] = -np.inf
+
         return llc, urc
 
 class _CellMapping(Mapping):
diff --git a/openmc/capi/core.py b/openmc/capi/core.py
index cd7401a23..a470f0665 100644
--- a/openmc/capi/core.py
+++ b/openmc/capi/core.py
@@ -1,3 +1,5 @@
+import sys
+
 from contextlib import contextmanager
 from ctypes import (CDLL, c_bool, c_int, c_int32, c_int64, c_double, c_char_p,
                     c_char, POINTER, Structure, c_void_p, create_string_buffer)
@@ -81,10 +83,15 @@ _dll.openmc_global_bounding_box.errcheck = _error_handler
 
 def global_bounding_box():
     """Calculate a global bounding box for the model"""
+    inf = sys.float_info.max
     llc = np.zeros(3)
     urc = np.zeros(3)
     _dll.openmc_global_bounding_box(llc.ctypes.data_as(POINTER(c_double)),
                                     urc.ctypes.data_as(POINTER(c_double)))
+    llc[llc == inf] = np.inf
+    urc[urc == inf] = np.inf
+    llc[llc == -inf] = -np.inf
+    urc[urc == -inf] = -np.inf
 
     return llc, urc
 
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index d1c578ba0..6953186eb 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -1,6 +1,5 @@
 from collections.abc import Mapping
 import os
-import sys
 
 import numpy as np
 import pytest
@@ -477,10 +476,8 @@ def test_position(capi_init):
 
 
 def test_global_bounding_box(capi_init):
-    inf = sys.float_info.max
-
-    expected_llc = (-0.63, -0.63, -inf)
-    expected_urc = (0.63, 0.63, inf)
+    expected_llc = (-0.63, -0.63, -np.inf)
+    expected_urc = (0.63, 0.63, np.inf)
 
     llc, urc = openmc.capi.global_bounding_box()
 
diff --git a/tests/unit_tests/test_complex_cell_capi.py b/tests/unit_tests/test_complex_cell_capi.py
index e5983d2d5..365ce4808 100644
--- a/tests/unit_tests/test_complex_cell_capi.py
+++ b/tests/unit_tests/test_complex_cell_capi.py
@@ -1,5 +1,3 @@
-import sys
-
 import numpy as np
 import openmc.capi
 import pytest
@@ -82,13 +80,17 @@ def complex_cell(run_in_tmpdir):
 
     openmc.capi.finalize()
 
-inf = sys.float_info.max
 
-expected_results = ( (1, (( -4.,  -4., -inf), ( 4.,  4., inf))),
-                     (2, (( -7.,  -7., -inf), ( 7.,  7., inf))),
-                     (3, ((-10., -10., -inf), (10., 10., inf))),
-                     (4, ((-10., -10., -inf), (10., 10., inf))),
-                     (5, ((-inf, -inf, -inf), (inf, inf, inf))) )
+expected_results = ( (1, (( -4.,  -4., -np.inf),
+                          (  4.,   4.,  np.inf))),
+                     (2, (( -7.,  -7., -np.inf),
+                          (  7.,   7.,  np.inf))),
+                     (3, ((-10., -10., -np.inf),
+                          ( 10.,  10.,  np.inf))),
+                     (4, ((-10., -10., -np.inf),
+                          ( 10.,  10.,  np.inf))),
+                     (5, ((-np.inf, -np.inf, -np.inf),
+                          ( np.inf,  np.inf,  np.inf))) )
 @pytest.mark.parametrize("cell_id,expected_box", expected_results)
 def test_cell_box(cell_id, expected_box):
     cell_box = openmc.capi.cells[cell_id].bounding_box

From 918340a3affa29b3297a2a7bbd188e746f95f0d5 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 15 Jul 2019 15:10:18 -0500
Subject: [PATCH 121/127] Allow user control over Operator.dilute_initial

Users can now pass dilute_initial as an input
argument into the Operator, and directly set
Operator.dilute_initial. Documentation was updated to
include units on the initial default concentration, which
is 1000 atoms per cubic centimeter. The user is allowed
to set this value to zero.

Notes have been added to ResultsList.get_atoms
and get_reaction_rate methods, indicating why there may
be non-zero values when pulling data for isotopes not
initially present.
A similar note was added to the depletion_results.h5
io format file.

Closes #1288
---
 docs/source/io_formats/depletion_results.rst |  7 +++++
 openmc/deplete/abc.py                        | 30 +++++++++++++++-----
 openmc/deplete/operator.py                   | 17 +++++++----
 openmc/deplete/results_list.py               | 18 +++++++++++-
 4 files changed, 58 insertions(+), 14 deletions(-)

diff --git a/docs/source/io_formats/depletion_results.rst b/docs/source/io_formats/depletion_results.rst
index 3c782b1d9..de28b0477 100644
--- a/docs/source/io_formats/depletion_results.rst
+++ b/docs/source/io_formats/depletion_results.rst
@@ -44,3 +44,10 @@ The current version of the depletion results file format is 1.0.
 **/reactions/<name>/**
 
 :Attributes: - **index** (*int*) -- Index user in results for this reaction
+
+.. note::
+
+    The reaction rates for some isotopes not originally present may
+    be non-zero, but should be negligible compared to other atoms.
+    This can be controlled by changing the
+    :class:`openmc.deplete.Operator` ``dilute_initial`` attribute.
diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index c5c086854..6b09543ae 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -10,11 +10,12 @@ from pathlib import Path
 from abc import ABC, abstractmethod
 from xml.etree import ElementTree as ET
 from warnings import warn
+from numbers import Real
 
 from numpy import nonzero, empty
 
 from openmc.data import DataLibrary, JOULE_PER_EV
-from openmc.checkvalue import check_type
+from openmc.checkvalue import check_type, check_greater_than
 from .chain import Chain
 
 OperatorResult = namedtuple('OperatorResult', ['k', 'rates'])
@@ -55,17 +56,21 @@ class TransportOperator(ABC):
     fission_q : dict, optional
         Dictionary of nuclides and their fission Q values [eV]. If not given,
         values will be pulled from the ``chain_file``.
+    dilute_initial : float, optional
+        Initial atom density [atoms/cm^3] to add for nuclides that are zero
+        in initial condition to ensure they exist in the decay chain.
+        Only done for nuclides with reaction rates.
+        Defaults to 1.0e3.
 
     Attributes
     ----------
     dilute_initial : float
-        Initial atom density to add for nuclides that are zero in initial
-        condition to ensure they exist in the decay chain.  Only done for
-        nuclides with reaction rates. Defaults to 1.0e3.
-
+        Initial atom density [atoms/cm^3] to add for nuclides that are zero
+        in initial condition to ensure they exist in the decay chain.
+        Only done for nuclides with reaction rates.
     """
-    def __init__(self, chain_file=None, fission_q=None):
-        self.dilute_initial = 1.0e3
+    def __init__(self, chain_file=None, fission_q=None, dilute_initial=1.0e3):
+        self.dilute_initial = dilute_initial
         self.output_dir = '.'
 
         # Read depletion chain
@@ -89,6 +94,17 @@ class TransportOperator(ABC):
                      FutureWarning)
         self.chain = Chain.from_xml(chain_file, fission_q)
 
+    @property
+    def dilute_initial(self):
+        """Initial atom density for nuclides with zero initial concentration"""
+        return self._dilute_initial
+
+    @dilute_initial.setter
+    def dilute_initial(self, value):
+        check_type("dilute_initial", value, Real)
+        check_greater_than("dilute_initial", value, 0.0, equality=True)
+        self._dilute_initial = value
+
     @abstractmethod
     def __call__(self, vec, print_out=True):
         """Runs a simulation.
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index bb3c96e4f..388317e07 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -76,6 +76,11 @@ class Operator(TransportOperator):
     fission_q : dict, optional
         Dictionary of nuclides and their fission Q values [eV]. If not given,
         values will be pulled from the ``chain_file``.
+    dilute_initial : float, optional
+        Initial atom density [atoms/cm^3] to add for nuclides that are zero
+        in initial condition to ensure they exist in the decay chain.
+        Only done for nuclides with reaction rates.
+        Defaults to 1.0e3.
 
     Attributes
     ----------
@@ -84,9 +89,9 @@ class Operator(TransportOperator):
     settings : openmc.Settings
         OpenMC settings object
     dilute_initial : float
-        Initial atom density to add for nuclides that are zero in initial
-        condition to ensure they exist in the decay chain. Only done for
-        nuclides with reaction rates. Defaults to 1.0e3.
+        Initial atom density [atoms/cm^3] to add for nuclides that
+        are zero in initial condition to ensure they exist in the decay
+        chain. Only done for nuclides with reaction rates.
     output_dir : pathlib.Path
         Path to output directory to save results.
     round_number : bool
@@ -110,11 +115,11 @@ class Operator(TransportOperator):
         Results from a previous depletion calculation
     diff_burnable_mats : bool
         Whether to differentiate burnable materials with multiple instances
-
     """
     def __init__(self, geometry, settings, chain_file=None, prev_results=None,
-                 diff_burnable_mats=False, fission_q=None):
-        super().__init__(chain_file, fission_q)
+                 diff_burnable_mats=False, fission_q=None,
+                 dilute_initial=1.0e3):
+        super().__init__(chain_file, fission_q, dilute_initial)
         self.round_number = False
         self.settings = settings
         self.geometry = geometry
diff --git a/openmc/deplete/results_list.py b/openmc/deplete/results_list.py
index 79203a631..0ce5b0158 100644
--- a/openmc/deplete/results_list.py
+++ b/openmc/deplete/results_list.py
@@ -26,7 +26,15 @@ class ResultsList(list):
                 self.append(Results.from_hdf5(fh, i))
 
     def get_atoms(self, mat, nuc):
-        """Get nuclide concentration over time from a single material
+        """Get number of nuclides over time from a single material
+
+        .. note::
+
+            Initial values for some isotopes that do not appear in
+            initial concentrations may be non-zero, depending on the
+            value of :class:`openmc.deplete.Operator` ``dilute_initial``.
+            The :class:`openmc.deplete.Operator` adds isotopes according
+            to this setting, which can be set to zero.
 
         Parameters
         ----------
@@ -56,6 +64,14 @@ class ResultsList(list):
     def get_reaction_rate(self, mat, nuc, rx):
         """Get reaction rate in a single material/nuclide over time
 
+        .. note::
+
+            Initial values for some isotopes that do not appear in
+            initial concentrations may be non-zero, depending on the
+            value of :class:`openmc.deplete.Operator` ``dilute_initial``
+            The :class:`openmc.deplete.Operator` adds isotopes according
+            to this setting, which can be set to zero.
+
         Parameters
         ----------
         mat : str

From 7885146482936332918f525a719061d90d784437 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Thu, 25 Jul 2019 09:32:13 -0500
Subject: [PATCH 122/127] Fix bug when reaction rate nuclides change through
 depletion

The size of the Operator.reaction_rates does not change through
depletion, but the number of tallied nuclides for reaction
rates may or may not. The DirectReactionRateHelper returns
reaction rates according to the number of nuclides tallied,
a potential subset of all nuclides designated as burnable
by the Operator. This causes IndexErrors if a nuclide is not
tallied at a later step.

Example: 10 nuclides [0-9] are originally tracked by the Operator
and tallied by DirectReactionRateHelper. The Operator.reaction_rates
array will be of shape (n_mat, 10, n_react). Initially, the
DirectReactionRateHelper returns an array of size (10, n_react)
for each material. Then, if nuclide 5 is not in the list of nuclides
passed to the DirectReactionRateHelper at the next step, [decayed to
zero], DirectReactionRateHelper will return an array (9, n_react) and
try to pass tally data for nuclide 9 into row 9 of the reaction rate
array, causing an IndexError.

This commit instructs requires two integers, n_nucs and n_react, to be
passed to the initialization of any ReactionRateHelper, allocating
a single array for storing material-reaction rates. The method
get_material_rates uses this directly and does not re-allocate storage
if len(nuc_index) has changed [like if nuclide 9 has dropped out].
---
 openmc/deplete/abc.py      | 26 ++++++++++----------------
 openmc/deplete/helpers.py  | 17 +++++++++++------
 openmc/deplete/operator.py |  3 ++-
 3 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index c5c086854..d28f79038 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -174,17 +174,23 @@ class ReactionRateHelper(ABC):
     Reaction rates are passed back to the operator for be used in
     an :class:`openmc.deplete.OperatorResult` instance
 
+    Parameters
+    ----------
+    n_nucs : int
+    n_react : int
+        Number of burnable nuclides and reactions tracked
+        by :class:`openmc.deplete.Operator`.
+
     Attributes
     ----------
     nuclides : list of str
-        All nuclides with desired reaction rates. Ordered to be
-        consistent with :class:`openmc.deplete.Operator`
+        All nuclides with desired reaction rates.
     """
 
-    def __init__(self):
+    def __init__(self, n_nucs, n_react):
         self._nuclides = None
         self._rate_tally = None
-        self._results_cache = None
+        self._results_cache = empty((n_nucs, n_react))
 
     @abstractmethod
     def generate_tallies(self, materials, scores):
@@ -201,17 +207,6 @@ class ReactionRateHelper(ABC):
         self._nuclides = nuclides
         self._rate_tally.nuclides = nuclides
 
-    def _get_results_cache(self, nnucs, nreact):
-        """Cache for results for a given material
-
-        Creates an empty array of shape ``(nnucs, nreact)``
-        if the shape does not match the current cache.
-        """
-        if (self._results_cache is None
-                or self._results_cache.shape != (nnucs, nreact)):
-            self._results_cache = empty((nnucs, nreact))
-        return self._results_cache
-
     @abstractmethod
     def get_material_rates(self, mat_id, nuc_index, react_index):
         """Return 2D array of [nuclide, reaction] reaction rates
@@ -236,7 +231,6 @@ class ReactionRateHelper(ABC):
         ----------
         number : iterable of float
             Number density [atoms/b-cm] of each nuclide tracked in the calculation.
-            Ordered identically to :attr:`nuclides`
 
         Returns
         -------
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index edf0feb06..e5935f25b 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -16,11 +16,17 @@ from .abc import ReactionRateHelper, EnergyHelper
 class DirectReactionRateHelper(ReactionRateHelper):
     """Class that generates tallies for one-group rates
 
+    Parameters
+    ----------
+    n_nucs : int
+    n_react : int
+        Number of burnable nuclides and reactions tracked
+        by :class:`openmc.deplete.Operator`.
+
     Attributes
     ----------
     nuclides : list of str
-        All nuclides with desired reaction rates. Ordered to be
-        consistent with :class:`openmc.deplete.Operator`
+        All nuclides with desired reaction rates.
     """
 
     def generate_tallies(self, materials, scores):
@@ -61,14 +67,13 @@ class DirectReactionRateHelper(ReactionRateHelper):
             Array with shape ``(n_nuclides, n_rxns)`` with the
             reaction rates in this material
         """
-        results = self._get_results_cache(len(nuc_index), len(react_index))
-        results.fill(0.0)
+        self._results_cache.fill(0.0)
         full_tally_res = self._rate_tally.results[mat_id, :, 1]
         for i_tally, (i_nuc, i_react) in enumerate(
                 product(nuc_index, react_index)):
-            results[i_nuc, i_react] = full_tally_res[i_tally]
+            self._results_cache[i_nuc, i_react] = full_tally_res[i_tally]
 
-        return results
+        return self._results_cache
 
 
 # ----------------------------
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index bb3c96e4f..6e434e39b 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -158,7 +158,8 @@ class Operator(TransportOperator):
             self.local_mats, self._burnable_nucs, self.chain.reactions)
 
         # Get classes to assist working with tallies
-        self._rate_helper = DirectReactionRateHelper()
+        self._rate_helper = DirectReactionRateHelper(
+            self.reaction_rates.n_nuc, self.reaction_rates.n_react)
         self._energy_helper = ChainFissionHelper()
 
     def __call__(self, vec, power, print_out=True):

From 62865b3a55c544f14cd2d18862c363f759024b7c Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 29 Jul 2019 15:57:29 -0500
Subject: [PATCH 123/127] Documentation fixes for pin func, depletion helpers

---
 docs/source/pythonapi/deplete.rst | 2 +-
 openmc/deplete/abc.py             | 4 ++--
 openmc/deplete/helpers.py         | 4 ++--
 openmc/model/funcs.py             | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/source/pythonapi/deplete.rst b/docs/source/pythonapi/deplete.rst
index 70d48f931..0dcd47ef5 100644
--- a/docs/source/pythonapi/deplete.rst
+++ b/docs/source/pythonapi/deplete.rst
@@ -87,7 +87,7 @@ The following classes are abstract classes that can be used to extend the
 :mod:`openmc.deplete` capabilities:
 
 .. autosummary::
-   :toctree:generated
+   :toctree: generated
    :nosignatures:
    :template: myclass.rst
 
diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index d28f79038..6d3769638 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -177,9 +177,9 @@ class ReactionRateHelper(ABC):
     Parameters
     ----------
     n_nucs : int
+        Number of burnable nuclides tracked by :class:`openmc.deplete.Operator`
     n_react : int
-        Number of burnable nuclides and reactions tracked
-        by :class:`openmc.deplete.Operator`.
+        Number of reactions tracked by :class:`openmc.deplete.Operator`
 
     Attributes
     ----------
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index e5935f25b..66722c00a 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -19,9 +19,9 @@ class DirectReactionRateHelper(ReactionRateHelper):
     Parameters
     ----------
     n_nucs : int
+        Number of burnable nuclides tracked by :class:`openmc.deplete.Operator`
     n_react : int
-        Number of burnable nuclides and reactions tracked
-        by :class:`openmc.deplete.Operator`.
+        Number of reactions tracked by :class:`openmc.deplete.Operator`
 
     Attributes
     ----------
diff --git a/openmc/model/funcs.py b/openmc/model/funcs.py
index 2bd0155b1..bb5d39a2d 100644
--- a/openmc/model/funcs.py
+++ b/openmc/model/funcs.py
@@ -471,7 +471,7 @@ def pin(surfaces, items, subdivisions=None, divide_vols=True,
         to be divided. Will construct equal area rings
     divide_vols : bool
         If this evaluates to ``True``, then volumes of subdivided
-        :class:`openmc.Material`s will also be divided by the
+        :class:`openmc.Material` instances will also be divided by the
         number of divisions.  Otherwise the volume of the
         original material will not be modified before subdivision
     kwargs:

From 52f42ce76c419c63211f1d1850e01cc4aa8713b0 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Tue, 30 Jul 2019 07:50:50 -0500
Subject: [PATCH 124/127] Add NUMPY_EXPERIMENTAL_ARRAY_FUNCTION to .travis.yml

Instruct travis to use pre-numpy 1.17 behavior.
Workaround issue for uncertainties package causing CI
builds to fail

Related: https://github.com/lebigot/uncertainties/issues/89
---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index 096459b00..859fb5d04 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -28,6 +28,7 @@ env:
     - LD_LIBRARY_PATH=$HOME/MOAB/lib:$HOME/DAGMC/lib
     - PATH=$PATH:$HOME/NJOY2016/build
     - COVERALLS_PARALLEL=true
+    - NUMPY_EXPERIMENTAL_ARRAY_FUNCTION=0
 matrix:
   include:
     - python: "3.5"

From 9b7ab0bacb3e2781d64b12756c0e5d416fffdad5 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Thu, 25 Jul 2019 15:49:14 -0500
Subject: [PATCH 125/127] Expose/improve EnergyFunctionFilter through C-API

Add three functions that can be used to modify EnergyFunctionFilters
through the C-API:
- openmc_energyfunc_filter_set_data: set energy and y data
- openmc_energyfunc_filter_get_energy: obtain energies used in
interpolation
- openmc_energyfunc_filter_get_y: obtain ordinate values
These functions are modeled after openmc_energy_filter_[get|set]_bins.

The set_data function relies upon the new
EnergyFunctionFilter::set_data function, which is analogous
to EnergyFilter::set_bins function. Checks are performed
to make sure the energy and ordinate vectors are of equal
size before resetting and populating energy and y
private members.

An EnergyFunctionFilter did exist in openmc.capi, and has
now been flushed out to provide a better __init__ method,
as well as properties for retrieving energies and ordinates
for interpolation.
---
 include/openmc/capi.h                      |  4 +
 include/openmc/tallies/filter_energyfunc.h |  7 ++
 openmc/capi/filter.py                      | 45 ++++++++++
 src/tallies/filter_energyfunc.cpp          | 97 +++++++++++++++++++++-
 tests/unit_tests/test_capi.py              | 31 ++++++-
 5 files changed, 180 insertions(+), 4 deletions(-)

diff --git a/include/openmc/capi.h b/include/openmc/capi.h
index ded41f738..3d2e8f57b 100644
--- a/include/openmc/capi.h
+++ b/include/openmc/capi.h
@@ -21,6 +21,10 @@ extern "C" {
   int openmc_cell_set_temperature(int32_t index, double T, const int32_t* instance);
   int openmc_energy_filter_get_bins(int32_t index, const double** energies, size_t* n);
   int openmc_energy_filter_set_bins(int32_t index, size_t n, const double* energies);
+  int openmc_energyfunc_filter_get_energy(int32_t index, size_t* n, const double** energy);
+  int openmc_energyfunc_filter_get_y(int32_t index, size_t* n, const double** y);
+  int openmc_energyfunc_filter_set_data(int32_t index, size_t n,
+                                        const double* energies, const double* y);
   int openmc_extend_cells(int32_t n, int32_t* index_start, int32_t* index_end);
   int openmc_extend_filters(int32_t n, int32_t* index_start, int32_t* index_end);
   int openmc_extend_materials(int32_t n, int32_t* index_start, int32_t* index_end);
diff --git a/include/openmc/tallies/filter_energyfunc.h b/include/openmc/tallies/filter_energyfunc.h
index 9b8d839f8..df82e659e 100644
--- a/include/openmc/tallies/filter_energyfunc.h
+++ b/include/openmc/tallies/filter_energyfunc.h
@@ -40,6 +40,13 @@ public:
 
   std::string text_label(int bin) const override;
 
+  //----------------------------------------------------------------------------
+  // Accessors
+
+  const std::vector<double>& energy() const { return energy_; }
+  const std::vector<double>& y() const { return y_; }
+  void set_data(gsl::span<const double> energy, gsl::span<const double> y);
+
 private:
   //----------------------------------------------------------------------------
   // Data members
diff --git a/openmc/capi/filter.py b/openmc/capi/filter.py
index bda3c3178..f1f0cdc46 100644
--- a/openmc/capi/filter.py
+++ b/openmc/capi/filter.py
@@ -34,6 +34,18 @@ _dll.openmc_energy_filter_get_bins.errcheck = _error_handler
 _dll.openmc_energy_filter_set_bins.argtypes = [c_int32, c_size_t, POINTER(c_double)]
 _dll.openmc_energy_filter_set_bins.restype = c_int
 _dll.openmc_energy_filter_set_bins.errcheck = _error_handler
+_dll.openmc_energyfunc_filter_set_data.restype = c_int
+_dll.openmc_energyfunc_filter_set_data.errcheck = _error_handler
+_dll.openmc_energyfunc_filter_set_data.argtypes = [
+    c_int32, c_size_t, POINTER(c_double), POINTER(c_double)]
+_dll.openmc_energyfunc_filter_get_energy.resttpe = c_int
+_dll.openmc_energyfunc_filter_get_energy.errcheck = _error_handler
+_dll.openmc_energyfunc_filter_get_energy.argtypes = [
+    c_int32, POINTER(c_size_t), POINTER(POINTER(c_double))]
+_dll.openmc_energyfunc_filter_get_y.resttpe = c_int
+_dll.openmc_energyfunc_filter_get_y.errcheck = _error_handler
+_dll.openmc_energyfunc_filter_get_y.argtypes = [
+    c_int32, POINTER(c_size_t), POINTER(POINTER(c_double))]
 _dll.openmc_filter_get_id.argtypes = [c_int32, POINTER(c_int32)]
 _dll.openmc_filter_get_id.restype = c_int
 _dll.openmc_filter_get_id.errcheck = _error_handler
@@ -201,6 +213,39 @@ class DistribcellFilter(Filter):
 class EnergyFunctionFilter(Filter):
     filter_type = 'energyfunction'
 
+    def __new__(cls, energy=None, y=None, uid=None, new=True, index=None):
+        return super().__new__(cls, uid=uid, new=new, index=index)
+
+    def __init__(self, energy=None, y=None, uid=None, new=True, index=None):
+        if (energy is None) != (y is None):
+            raise AttributeError("Need both energy and y or neither")
+        super().__init__(uid, new, index)
+        if energy is not None:
+            self.set_interp_data(energy, y)
+
+    def set_interp_data(self, energy, y):
+        energy_array = np.asarray(energy)
+        y_array = np.asarray(y)
+        energy_p = energy_array.ctypes.data_as(POINTER(c_double))
+        y_p = y_array.ctypes.data_as(POINTER(c_double))
+
+        _dll.openmc_energyfunc_filter_set_data(
+            self._index, len(energy_array), energy_p, y_p)
+
+    @property
+    def energy(self):
+        return self._get_attr(_dll.openmc_energyfunc_filter_get_energy)
+
+    @property
+    def y(self):
+        return self._get_attr(_dll.openmc_energyfunc_filter_get_y)
+
+    def _get_attr(self, cfunc):
+        array_p = POINTER(c_double)()
+        n = c_size_t()
+        cfunc(self._index, n, array_p)
+        return as_array(array_p, (n.value, ))
+
 
 class LegendreFilter(Filter):
     filter_type = 'legendre'
diff --git a/src/tallies/filter_energyfunc.cpp b/src/tallies/filter_energyfunc.cpp
index 9b28e0f76..cf74d9836 100644
--- a/src/tallies/filter_energyfunc.cpp
+++ b/src/tallies/filter_energyfunc.cpp
@@ -21,12 +21,37 @@ EnergyFunctionFilter::from_xml(pugi::xml_node node)
   if (!check_for_node(node, "energy"))
     fatal_error("Energy grid not specified for EnergyFunction filter.");
 
-  energy_ = get_node_array<double>(node, "energy");
+  auto energy = get_node_array<double>(node, "energy");
 
   if (!check_for_node(node, "y"))
     fatal_error("y values not specified for EnergyFunction filter.");
 
-  y_ = get_node_array<double>(node, "y");
+  auto y = get_node_array<double>(node, "y");
+
+  this->set_data(energy, y);
+}
+
+void
+EnergyFunctionFilter::set_data(gsl::span<const double> energy,
+                               gsl::span<const double> y)
+{
+  // Check for consistent sizes with new data
+  if (energy.size() != y.size()) {
+    fatal_error("Energy grid and y values are not consistent");
+  }
+  energy_.clear();
+  energy_.reserve(energy.size());
+  y_.clear();
+  y_.reserve(y.size());
+
+  // Copy over energy values, ensuring they are valid
+  for (gsl::index i = 0; i < energy.size(); ++i) {
+    if (i > 0 && energy[i] <= energy[i - 1]) {
+      throw std::runtime_error{"Energy bins must be monotonically increasing."};
+    }
+    energy_.push_back(energy[i]);
+    y_.push_back(y[i]);
+  }
 }
 
 void
@@ -65,4 +90,72 @@ EnergyFunctionFilter::text_label(int bin) const
   return out.str();
 }
 
+//==============================================================================
+// C-API functions
+//==============================================================================
+
+extern"C" int
+openmc_energyfunc_filter_set_data(int32_t index, size_t n, const double* energy,
+                                  const double* y)
+{
+  // Ensure this is a valid index to allocated filter
+  if (int err = verify_filter(index)) return err;
+
+  // Get a pointer to the filter
+  const auto& filt_base = model::tally_filters[index].get();
+  // Downcast to EnergyFunctionFilter
+  auto* filt = dynamic_cast<EnergyFunctionFilter*>(filt_base);
+
+  // Check if a valid filter was produced
+  if (!filt) {
+    set_errmsg("Tried to set interpolation data for non-energy function filter.");
+    return OPENMC_E_INVALID_TYPE;
+  }
+
+  filt->set_data({energy, n}, {y, n});
+  return 0;
+}
+
+extern"C" int
+openmc_energyfunc_filter_get_energy(int32_t index, size_t *n, const double** energy)
+{
+  // ensure this is a valid index to allocated filter
+  if (int err = verify_filter(index)) return err;
+
+  // get a pointer to the filter
+  const auto& filt_base = model::tally_filters[index].get();
+  // downcast to EnergyFunctionFilter
+  auto* filt = dynamic_cast<EnergyFunctionFilter*>(filt_base);
+
+  // check if a valid filter was produced
+  if (!filt) {
+    set_errmsg("Tried to set interpolation data for non-energy function filter.");
+    return OPENMC_E_INVALID_TYPE;
+  }
+  *energy = filt->energy().data();
+  *n = filt->energy().size();
+  return 0;
+}
+
+extern"C" int
+openmc_energyfunc_filter_get_y(int32_t index, size_t *n, const double** y)
+{
+  // ensure this is a valid index to allocated filter
+  if (int err = verify_filter(index)) return err;
+
+  // get a pointer to the filter
+  const auto& filt_base = model::tally_filters[index].get();
+  // downcast to EnergyFunctionFilter
+  auto* filt = dynamic_cast<EnergyFunctionFilter*>(filt_base);
+
+  // check if a valid filter was produced
+  if (!filt) {
+    set_errmsg("Tried to set interpolation data for non-energy function filter.");
+    return OPENMC_E_INVALID_TYPE;
+  }
+  *y = filt->y().data();
+  *n = filt->y().size();
+  return 0;
+}
+
 } // namespace openmc
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index 6953186eb..31db130db 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -35,6 +35,14 @@ def pincell_model():
     zernike_tally.scores = ['fission']
     pincell.tallies.append(zernike_tally)
 
+    # Add an energy function tally
+    energyfunc_tally = openmc.Tally()
+    energyfunc_filter = openmc.EnergyFunctionFilter(
+        [0.0, 20e6], [0.0, 20e6])
+    energyfunc_tally.scores = ['fission']
+    energyfunc_tally.filters = [energyfunc_filter]
+    pincell.tallies.append(energyfunc_tally)
+
     # Write XML files in tmpdir
     with cdtemp():
         pincell.export_to_xml()
@@ -170,12 +178,21 @@ def test_settings(capi_init):
 def test_tally_mapping(capi_init):
     tallies = openmc.capi.tallies
     assert isinstance(tallies, Mapping)
-    assert len(tallies) == 2
+    assert len(tallies) == 3
     for tally_id, tally in tallies.items():
         assert isinstance(tally, openmc.capi.Tally)
         assert tally_id == tally.id
 
 
+def test_energy_function_filter(capi_init):
+    """Test special __new__ and __init__ for EnergyFunctionFilter"""
+    efunc = openmc.capi.EnergyFunctionFilter([0.0, 1.0], [0.0, 2.0])
+    assert len(efunc.energy) == 2
+    assert efunc.energy == [0.0, 1.0]
+    assert len(efunc.y) == 2
+    assert efunc.y == [0.0, 2.0]
+
+
 def test_tally(capi_init):
     t = openmc.capi.tallies[1]
     assert t.type == 'volume'
@@ -211,6 +228,16 @@ def test_tally(capi_init):
     assert len(t2.filters[1].bins) == 3
     assert t2.filters[0].order == 5
 
+    t3 = openmc.capi.tallies[3]
+    assert len(t3.filters) == 1
+    t3_f = t3.filters[0]
+    assert isinstance(t3_f, openmc.capi.EnergyFunctionFilter)
+    assert len(t3_f.energy) == 2
+    assert len(t3_f.y) == 2
+    t3_f.set_interp_data([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
+    assert len(t3_f.energy) == 3
+    assert len(t3_f.y) == 3
+
 
 def test_new_tally(capi_init):
     with pytest.raises(exc.AllocationError):
@@ -219,7 +246,7 @@ def test_new_tally(capi_init):
     new_tally.scores = ['flux']
     new_tally_with_id = openmc.capi.Tally(10)
     new_tally_with_id.scores = ['flux']
-    assert len(openmc.capi.tallies) == 4
+    assert len(openmc.capi.tallies) == 5
 
 
 def test_tally_activate(capi_simulation_init):

From 9d952c3c5807e5426155d4ae5bd79a06ea1bd48a Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Fri, 26 Jul 2019 10:14:20 -0500
Subject: [PATCH 126/127] Use a.all() for equality in capi EnergyFunctionFilter
 tests

---
 tests/unit_tests/test_capi.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index 31db130db..57978838f 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -188,9 +188,9 @@ def test_energy_function_filter(capi_init):
     """Test special __new__ and __init__ for EnergyFunctionFilter"""
     efunc = openmc.capi.EnergyFunctionFilter([0.0, 1.0], [0.0, 2.0])
     assert len(efunc.energy) == 2
-    assert efunc.energy == [0.0, 1.0]
+    assert (efunc.energy == [0.0, 1.0]).all()
     assert len(efunc.y) == 2
-    assert efunc.y == [0.0, 2.0]
+    assert (efunc.y == [0.0, 2.0]).all()
 
 
 def test_tally(capi_init):

From 8d920b792a6d0b5f9bb4f97472cc274ff7065c88 Mon Sep 17 00:00:00 2001
From: Andrew Johnson <drewej@protonmail.com>
Date: Mon, 29 Jul 2019 15:39:55 -0500
Subject: [PATCH 127/127] set_interp_data -> set_data for
 capi.EnergyFunctionFilter

Add doctring to set_data method. Update test_capi.py with
this change
---
 openmc/capi/filter.py             | 13 +++++++++++--
 src/tallies/filter_energyfunc.cpp |  6 +++---
 tests/unit_tests/test_capi.py     |  2 +-
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/openmc/capi/filter.py b/openmc/capi/filter.py
index f1f0cdc46..92818a2aa 100644
--- a/openmc/capi/filter.py
+++ b/openmc/capi/filter.py
@@ -221,9 +221,18 @@ class EnergyFunctionFilter(Filter):
             raise AttributeError("Need both energy and y or neither")
         super().__init__(uid, new, index)
         if energy is not None:
-            self.set_interp_data(energy, y)
+            self.set_data(energy, y)
 
-    def set_interp_data(self, energy, y):
+    def set_data(self, energy, y):
+        """Set the interpolation information for the filter
+
+        Parameters
+        ----------
+        energy : numpy.ndarray
+            Independent variable for the interpolation
+        y : numpy.ndarray
+            Dependent variable for the interpolation
+        """
         energy_array = np.asarray(energy)
         y_array = np.asarray(y)
         energy_p = energy_array.ctypes.data_as(POINTER(c_double))
diff --git a/src/tallies/filter_energyfunc.cpp b/src/tallies/filter_energyfunc.cpp
index cf74d9836..3e3fbd909 100644
--- a/src/tallies/filter_energyfunc.cpp
+++ b/src/tallies/filter_energyfunc.cpp
@@ -94,7 +94,7 @@ EnergyFunctionFilter::text_label(int bin) const
 // C-API functions
 //==============================================================================
 
-extern"C" int
+extern "C" int
 openmc_energyfunc_filter_set_data(int32_t index, size_t n, const double* energy,
                                   const double* y)
 {
@@ -116,7 +116,7 @@ openmc_energyfunc_filter_set_data(int32_t index, size_t n, const double* energy,
   return 0;
 }
 
-extern"C" int
+extern "C" int
 openmc_energyfunc_filter_get_energy(int32_t index, size_t *n, const double** energy)
 {
   // ensure this is a valid index to allocated filter
@@ -137,7 +137,7 @@ openmc_energyfunc_filter_get_energy(int32_t index, size_t *n, const double** ene
   return 0;
 }
 
-extern"C" int
+extern "C" int
 openmc_energyfunc_filter_get_y(int32_t index, size_t *n, const double** y)
 {
   // ensure this is a valid index to allocated filter
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index 57978838f..ed0bfd441 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -234,7 +234,7 @@ def test_tally(capi_init):
     assert isinstance(t3_f, openmc.capi.EnergyFunctionFilter)
     assert len(t3_f.energy) == 2
     assert len(t3_f.y) == 2
-    t3_f.set_interp_data([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
+    t3_f.set_data([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
     assert len(t3_f.energy) == 3
     assert len(t3_f.y) == 3