Repository: CORE-GATECH-GROUP/serpent-tools

Issue:
API Remove support for SERPENT 1 detectors
After a discussion with @DanKotlyar, we decided that support for SERPENT 1 detectors will be removed at release 0.8.0. Notice will be sent out to all users in the 0.7.1 release notice.

Discussion:

Patch:
diff --git a/.gitignore b/.gitignore
index 924c6e3..b27f41f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -63,8 +63,4 @@ ENV/
 # pycharm
 .idea/*
 
-# vim
-.*.swp
-
-# Ctag file
-tags
+/docs/*/generated/
diff --git a/docs/_templates/mydetector.rst b/docs/_templates/mydetector.rst
new file mode 100644
index 0000000..8b20c98
--- /dev/null
+++ b/docs/_templates/mydetector.rst
@@ -0,0 +1,18 @@
+{{ fullname }}
+{{ underline }}
+
+.. currentmodule:: {{ module }}
+
+
+.. warning::
+
+    Serpent 1 detectors are not supported as of 0.8.0
+
+.. autoclass:: {{ objname }}
+    :members: 
+
+    .. automethod:: plot
+
+    .. automethod:: spectrumPlot
+
+    .. automethod:: meshPlot
diff --git a/docs/conf.py b/docs/conf.py
index c5babe4..c63d716 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -33,14 +33,14 @@ from _version import get_versions
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    'matplotlib.sphinxext.plot_directive',
     'sphinx.ext.autodoc',
-    'sphinx.ext.doctest',
-    'sphinx.ext.coverage',
     'sphinx.ext.mathjax',
+    'sphinx.ext.autosummary',
     'sphinx.ext.napoleon',
     'sphinx.ext.intersphinx',
-    'sphinx.ext.extlinks']
+    'sphinx.ext.extlinks',
+    'matplotlib.sphinxext.plot_directive',
+]
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -188,9 +188,12 @@ texinfo_documents = [
 ]
 
 # -- Options for auto documentation --------------------------------------
-autodoc_default_options = {
-    'members': 'inherited-members',
-}
+
+# Autogenerate stub files for autosummary
+autosummary_generate = True
+
+autodoc_mock_imports = ["serpentTools"]
+
 
 # -- Links to external documentation
 intersphinx_mapping = {
@@ -211,7 +214,7 @@ rst_prolog = """
 .. |HomogUniv-gc| replace:: :attr:`~serpentTools.objects.HomogUniv.gc`
 .. |HomogUniv-gcUnc| replace:: :attr:`~serpentTools.objects.HomogUniv.gcUnc`
 .. |ResultsReader| replace:: :class:`~serpentTools.ResultsReader`
-.. |Detector| replace:: :class:`~serpentTools.objects.Detector`
+.. |Detector| replace:: :class:`~serpentTools.Detector`
 .. |DetectorReader| replace:: :class:`~serpentTools.DetectorReader`
 .. |DepletionReader| replace:: :class:`~serpentTools.DepletionReader`
 .. |DepmtxReader| replace:: :class:`~serpentTools.DepmtxReader`
diff --git a/docs/containers/detectors.rst b/docs/containers/detectors.rst
index 84db174..424caf7 100644
--- a/docs/containers/detectors.rst
+++ b/docs/containers/detectors.rst
@@ -1,9 +1,16 @@
 .. _api-detectors:
 
+.. currentmodule:: serpentTools
+
 
 Detectors
 ---------
 
+.. warning::
+
+    Serpent 1 detectors are not supported as of 0.8.0
+
+
 .. note::
 
     Energy grids are stored in order of increasing
@@ -11,12 +18,14 @@ Detectors
     columns of this array correspond to lower bound, upper bound,
     and mid-point of that energy group
 
-.. autoclass:: serpentTools.objects.Detector
-
-.. autoclass:: serpentTools.objects.CartesianDetector
-
-.. autoclass:: serpentTools.objects.HexagonalDetector
 
-.. autoclass:: serpentTools.objects.CylindricalDetector
+.. autosummary::
+    :toctree: generated
+    :nosignatures:
+    :template: mydetector.rst
 
-.. autoclass:: serpentTools.objects.SphericalDetector
+    Detector
+    CartesianDetector
+    HexagonalDetector
+    CylindricalDetector
+    SphericalDetector
diff --git a/docs/examples/Detector.rst b/docs/examples/Detector.rst
index 97abb10..f5314a3 100644
--- a/docs/examples/Detector.rst
+++ b/docs/examples/Detector.rst
@@ -1,13 +1,13 @@
-.. |DetBins| replace:: :attr:`~serpentTools.objects.Detector.bins`
-.. |DetIndx| replace:: :attr:`~serpentTools.objects.Detector.indexes`
-.. |DetTallies| replace:: :attr:`~serpentTools.objects.Detector.tallies`
-.. |DetErrors| replace:: :attr:`~serpentTools.objects.Detector.errors`
-.. |DetGrids| replace:: :attr:`~serpentTools.objects.Detector.grids`
-.. |DetSlice| replace:: :meth:`~serpentTools.objects.Detector.slice`
-.. |plot| replace:: :meth:`~serpentTools.objects.Detector.plot`
-.. |mesh| replace:: :meth:`~serpentTools.objects.Detector.meshPlot`
-.. |spectrum| replace:: :meth:`~serpentTools.objects.Detector.spectrumPlot`
-.. |hexDet| replace:: :class:`~serpentTools.objects.HexagonalDetector` 
+.. |DetBins| replace:: :attr:`~serpentTools.Detector.bins`
+.. |DetIndx| replace:: :attr:`~serpentTools.Detector.indexes`
+.. |DetTallies| replace:: :attr:`~serpentTools.Detector.tallies`
+.. |DetErrors| replace:: :attr:`~serpentTools.Detector.errors`
+.. |DetGrids| replace:: :attr:`~serpentTools.Detector.grids`
+.. |DetSlice| replace:: :meth:`~serpentTools.Detector.slice`
+.. |plot| replace:: :meth:`~serpentTools.Detector.plot`
+.. |mesh| replace:: :meth:`~serpentTools.Detector.meshPlot`
+.. |spectrum| replace:: :meth:`~serpentTools.Detector.spectrumPlot`
+.. |hexDet| replace:: :class:`~serpentTools.HexagonalDetector` 
 
 .. _detector-example:
 
@@ -46,10 +46,10 @@ lattice bins.
     >>> pin = serpentTools.readDataFile(pinFile)
     >>> bwr = serpentTools.readDataFile(bwrFile)
     >>> print(pin.detectors)
-    {'nodeFlx': <serpentTools.objects.Detector object at 0x7f6df2162b70>}
+    {'nodeFlx': <serpentTools.Detector object at 0x7f6df2162b70>}
     >>> print(bwr.detectors)
-    {'xymesh': <serpentTools.objects.Detector object at 0x7f6df2162a90>, 
-     'spectrum': <serpentTools.objects.Detector object at 0x7f6df2162b00>}
+    {'xymesh': <serpentTools.Detector object at 0x7f6df2162a90>, 
+     'spectrum': <serpentTools.Detector object at 0x7f6df2162b00>}
 
 These detectors were defined for a single fuel pin with 16 axial layers
 and a separate BWR assembly, with a description of the detectors provided in
@@ -103,11 +103,6 @@ Here, only three columns, shown as rows for readability, are changing:
 -  column 10: tally column
 -  column 11: errors
 
-.. note::
-
-    For SERPENT-1, there would be an additional column 12 that
-    contained the scores for each bin
-
 Detectors can also be obtained by indexing into the |DetectorReader|, as
 
 .. code::
@@ -115,14 +110,11 @@ Detectors can also be obtained by indexing into the |DetectorReader|, as
     >>> nf = pin['nodeFlx']
     >>> assert nf is nodeFlx
 
-Once each detector is given this binned tally data, the
-:meth:`~serpentTools.objects.Detector.reshape`
-method is called to recast the
-|DetTallies|, |DetErrors|, and, if applicable,
-the :attr:`~serpentTools.objects.Detector.scores` columns into
-individual, multidimensional arrays. For this case,
-since the only variable bin quantity is that of the universe, these
-will all be 1D arrays.
+Tally data is reshaped corresponding to the bin information provided
+by Serpent. The tally and errors columns are recast into multi-dimensional
+arrays where each dimension is some unique bin type like energy or spatial
+bin index. For this case, since the only variable bin quantity is that
+of the universe, the ``tallies`` and ``errors`` attributes will be 1D arrays.
 
 .. code:: 
     
@@ -138,36 +130,21 @@ will all be 1D arrays.
            0.00251, 0.00282, 0.00307, 0.00359, 0.00415, 0.00511, 0.00687,
            0.00809, 0.01002])
 
-Bin information is retained through the |DetIndx| attribute. This is an 
-:class:`~collections.OrderedDict` as the keys are placed according to their column
-position. These positions can be found in the SERPENT Manual, and are
-provided in the ``DET_COLS`` tuple.
-
 .. note:: 
     
     Python and numpy arrays are zero-indexed, meaning the first item
     is accessed with ``array[0]``, rather than ``array[1]``.
 
-.. code:: 
-    
-    >>> from serpentTools.objects import DET_COLS
-    >>> print(DET_COLS)
-    ('value', 'energy', 'universe', 'cell', 'material', 'lattice', 'reaction',
-    'zmesh', 'ymesh', 'xmesh', 'tally', 'error', 'scores')
-    >>> print(DET_COLS.index('cell'))
-    3
-    >>> nodeFlx.indexes
-    OrderedDict([('universe',
-                  array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15]))])
-
-Each item in the |DetIndx| ordered dictionary corresponds to the
-unique values of that bin in the original |DetBins| array. Here,
-``universe`` is the first item and contains an equal number of elements
-to the size of the first (and only) axis in the ``nodeFlx`` tally matrix
+Bin information is retained through the |DetIndx| attribute.
+Each entry indicates what bin type is changing along that dimension of
+``tallies`` and ``errors``.  Here, ``universe`` is the first item and
+indicates that the first dimension of ``tallies`` and ``errors`` 
+corresponds to a changing universe bin.
 
 .. code:: 
 
-    >>> assert nodeFlx.indexes['universe'].size == nodeFlx.tallies.size
+    >>> nodeFlx.indexes
+    ("universe", )
 
 For detectors that include some grid matrices, such as spatial or energy
 meshes ``DET<name>E``, these arrays are stored in the |DetGrids| dictionary
@@ -175,7 +152,7 @@ meshes ``DET<name>E``, these arrays are stored in the |DetGrids| dictionary
 .. code:: 
     
     >>> spectrum = bwr.detectors['spectrum']
-    >>> print(spectrum.grids['E'][:5, :])
+    >>> print(spectrum.grids['E'][:5])
     [[1.00002e-11 4.13994e-07 2.07002e-07]
      [4.13994e-07 5.31579e-07 4.72786e-07]
      [5.31579e-07 6.25062e-07 5.78320e-07]
@@ -196,33 +173,30 @@ fission and capture rates (two ``dr`` arguments) in an XY mesh.
 .. code:: 
     
     >>> xy = bwr.detectors['xymesh']
-    >>> for key in xy.indexes:
-    ...     print(key, xy.indexes[key])
-    energy [0 1]
-    ymesh [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
-    xmesh [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
+    >>> xy.indexes
+    ('energy', 'ymesh', 'xmesh')
 
 Traversing the first axis in the |DetTallies| array corresponds to
-changing the value of the ``reaction``. The second axis corresponds to
+changing the value of the ``energy``. The second axis corresponds to
 changing ``ymesh`` values, and the final axis reflects changes in
 ``xmesh``.
 
 .. code:: 
     
     >>> print(xy.bins.shape)
-    >>> print(xy.tallies.shape)
-    >>> print(xy.bins[:5, 10])
-    >>> print(xy.tallies[0, 0, :5])
     (800, 12)
+    >>> print(xy.tallies.shape)
     (2, 20, 20)
+    >>> print(xy.bins[:5, 10])
     [8.19312e+17 7.18519e+17 6.90079e+17 6.22241e+17 5.97257e+17]
+    >>> print(xy.tallies[0, 0, :5])
     [8.19312e+17 7.18519e+17 6.90079e+17 6.22241e+17 5.97257e+17]
 
 Slicing
 ~~~~~~~
 
-As the detectors produced by SERPENT can contain multiple bin types, as
-seen in ``DET_COLS``, obtaining data from the tally data can become
+As the detectors produced by SERPENT can contain multiple bin types,
+obtaining data from the tally data can become
 complicated. This retrieval can be simplified using the |DetSlice| method. 
 This method takes an argument indicating what bins (keys in |DetIndx|)
 to fix at what position.
@@ -236,9 +210,7 @@ reaction tally is stored in column 1.
 
 .. code:: 
     
-    >>> print(spectrum.indexes['reaction'])
     >>> spectrum.slice({'reaction': 1})[:20]
-    [0 1]
     array([3.66341e+22, 6.53587e+20, 3.01655e+20, 1.51335e+20, 3.14546e+20,
            7.45742e+19, 4.73387e+20, 2.82554e+20, 9.89379e+19, 9.49670e+19,
            8.98272e+19, 2.04606e+20, 3.58272e+19, 1.44708e+20, 7.25499e+19,
@@ -492,8 +464,8 @@ from hexagonal detectors in
     >>> hexFile = 'hexplot_det0.m'
     >>> hexR = serpentTools.readDataFile(hexFile)
     >>> hexR.detectors
-    {'hex2': <serpentTools.objects.HexagonalDetector at 0x7f1ad03d5da0>,
-    'hex3': <serpentTools.objects.HexagonalDetector at 0x7f1ad03d5c88>}
+    {'hex2': <serpentTools.HexagonalDetector at 0x7f1ad03d5da0>,
+    'hex3': <serpentTools.HexagonalDetector at 0x7f1ad03d5c88>}
 
 Here, two |hexDet| objects are produced, with similar
 |DetTallies| and slicing methods as demonstrated above.
@@ -535,12 +507,11 @@ Here, two |hexDet| objects are produced, with similar
             [ 3.       ,  1.732051 ]]),
      'Z': array([[0., 0., 0.]])}
     >>> hex2.indexes
-    OrderedDict([('ycoord', array([0, 1, 2, 3, 4])),
-                 ('xcoord', array([0, 1, 2, 3, 4]))])
+    ('ycoord', 'xcoord')
 
 Creating hexagonal mesh plots with these objects requires setting the
-:attr:`~serpentTools.objects.HexagonalDetector.pitch`
-and :attr:`~serpentTools.objects.HexagonalDetector.hexType` attributes.
+:attr:`~serpentTools.HexagonalDetector.pitch`
+and :attr:`~serpentTools.HexagonalDetector.hexType` attributes.
 
 .. code:: 
     
diff --git a/examples/Detector.ipynb b/examples/Detector.ipynb
index 637713d..36eacc1 100644
--- a/examples/Detector.ipynb
+++ b/examples/Detector.ipynb
@@ -59,8 +59,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'nodeFlx': <serpentTools.objects.detectors.Detector object at 0x7fd09d5530b8>}\n",
-      "{'xymesh': <serpentTools.objects.detectors.CartesianDetector object at 0x7fd09d553208>, 'spectrum': <serpentTools.objects.detectors.Detector object at 0x7fd09d553198>}\n"
+      "{'nodeFlx': <serpentTools.detectors.Detector object at 0x7fe29eba2290>}\n",
+      "{'xymesh': <serpentTools.detectors.CartesianDetector object at 0x7fe29eb984d0>, 'spectrum': <serpentTools.detectors.Detector object at 0x7fe29f58ee50>}\n"
      ]
     }
    ],
@@ -139,9 +139,7 @@
     "\n",
     "* column 0: universe column\n",
     "* column 10: tally column\n",
-    "* column 11: errors\n",
-    "\n",
-    "*Note* For SERPENT-1, there would be an additional column 12 that contained the scores for each bin"
+    "* column 11: errors"
    ]
   },
   {
@@ -165,7 +163,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Once each detector is given this binned tally data, the `reshape` method is called to recast the tallies, errors, and, if applicable, the scores columns into individual, multidimensional arrays. For this case, since the only variable bin quantity is that of the universe, these will all be 1D arrays."
+    "Tally data is reshaped corresponding to the bin information provided by Serpent. The tally and error columns are recast into multi-dimensional arrays where each dimension is some unique bin type like energy or spatial bin index. For this case, since the only variable bin quantity is that of the changing universe, the ``tallies`` and ``errors`` attributes will be 1D arrays."
    ]
   },
   {
@@ -219,44 +217,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Bin information is retained through the `indexes` attribute. This is an [`OrderedDictionary`](https://docs.python.org/2/library/collections.html#collections.OrderedDict), as the keys are placed according to their column position. These postions can be found in the SERPENT Manual, and are provided in the `DET_COLS` tuple.\n",
+    "Note: Python and numpy arrays are zero-indexed, meaning the first item is accessed with `array[0]`, rather than `array[1]`.\n",
     "\n",
-    "Note: Python and numpy arrays are zero-indexed, meaning the first item is accessed with `array[0]`, rather than `array[1]`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "('value', 'energy', 'universe', 'cell', 'material', 'lattice', 'reaction', 'zmesh', 'ymesh', 'xmesh', 'tally', 'error', 'scores')\n",
-      "3\n"
-     ]
-    }
-   ],
-   "source": [
-    "from serpentTools.objects.detectors import DET_COLS\n",
-    "print(DET_COLS)\n",
-    "print(DET_COLS.index('cell'))"
+    "Bin information is retained through the ``indexes`` attribute. Each entry indicates what bin type is changing along that dimension of ``tallies`` and ``errors``. Here, ``universe`` is the first item and indicates that the first dimension of ``tallies`` corresponds to a changing universe bin."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "OrderedDict([('universe',\n",
-       "              array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15]))])"
+       "('universe',)"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -265,23 +242,6 @@
     "nodeFlx.indexes"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Each item in the `indexes` ordered dictionary corresponds to the unique values of that bin in the original `bin` array.\n",
-    "Here, `universe` is the first item and contains an equal number of elements to the size of the first (and only) axis in the nodeFlx tally matrix"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "assert nodeFlx.indexes['universe'].size == nodeFlx.tallies.size"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -291,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -327,23 +287,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "energy [0 1]\n",
-      "ymesh [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
-      "xmesh [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n"
-     ]
+     "data": {
+      "text/plain": [
+       "('energy', 'ymesh', 'xmesh')"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
     "xy = bwr.detectors['xymesh']\n",
-    "for key in xy.indexes:\n",
-    "    print(key, xy.indexes[key])"
+    "xy.indexes"
    ]
   },
   {
@@ -355,7 +315,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -381,23 +341,16 @@
    "metadata": {},
    "source": [
     "### Slicing\n",
-    "As the detectors produced by SERPENT can contain multiple bin types, as seen in `DET_COLS`, obtaining data from the tally data can become complicated. This retrieval can be simplified using the `slice` method. This method takes an argument indicating what bins (keys in `indexes`) to fix at what position.\n",
+    "As the detectors produced by SERPENT can contain multiple bin types, obtaining data from the tally data can become complicated. This retrieval can be simplified using the `slice` method. This method takes an argument indicating what bins (keys in `indexes`) to fix at what position.\n",
     "\n",
     "If we want to retrive the tally data for the capture reaction in the `spectrum` detector, you would instruct the `slice` method to use column 1 along the axis that corresponds to the reaction bin, as the fission reaction corresponded to reaction tally 2 in the original matrix. Since python and numpy arrays are zero indexed, the second reaction tally is stored in column 1."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0 1]\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
@@ -407,13 +360,12 @@
        "       6.31722e+20, 2.89445e+20, 2.15484e+20, 3.59303e+20, 3.15000e+20])"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "print(spectrum.indexes['reaction'])\n",
     "spectrum.slice({'reaction': 1})[:20]"
    ]
   },
@@ -426,7 +378,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 13,
    "metadata": {
     "scrolled": true
    },
@@ -439,7 +391,7 @@
        "       0.02165, 0.0192 , 0.02048, 0.01715, 0.02055, 0.0153 ])"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -482,17 +434,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8VOX1x/HPyU7CngUQkICsYVEg\n7OKGClYRq6iAIBQEaV2r/bW21qVqbbWLW91QLIiyuhVrC+4FWRNQlrBIQJYAIQlLWELIdn5/zERj\nCMkAubkzk/N+veaVyZ07mS9L5sy9z33OI6qKMcYYU5kQtwMYY4zxf1YsjDHGVMmKhTHGmCpZsTDG\nGFMlKxbGGGOqZMXCGGNMlaxYGGOMqZIVC2OMMVWyYmGMMaZKYW4HqC5xcXGamJjodgxjjAkoq1at\nylHV+Kr2C5pikZiYSGpqqtsxjDEmoIjIDl/2s9NQxhhjqmTFwhhjTJWsWBhjjKmSFQtjjDFVsmJh\njDGmSlYsjDHGVMmKhTHGmCoFzTwL457C4hJmp+xi/9EThIeGEBYihIWGEB4qhIWEEBYq39//8baT\n9w0PFUJDPI81qR9FRJh9njHGH1ixMGdl3+F87py5mpTtB6v9ZzdvWIc/39CVge2qnFxqjHGYFQtz\nxpZt3c9ds77m2IkinhtxAdd0O4fC4hKKSpSi77/qj7YVFitFJd6v3u2FxSUUld1eUsLxghJe/2ob\nY6auZGTvc3nw6k7UjbT/rsa4xX77zGlTVV753zb+snATiXExzJzYh/ZN6gEQGhJaba9zfY/m/O3j\nzbz+1Xcs+jabp27oxoXt4qrt5xtjfGcnhM1pyT1eyMQ3V/HUgk1c1bUZ8++88PtCUd2iwkN58Ook\n3pncj8iwEEZPXcGD76/j6IkiR17PGHNqViyMz9L25DL0ha/4cnMWD1+TxD9Gdq+RU0M9WzXmP/cM\n5LYLWzNz5U4GP7OIpek5jr+uMeYHViyMT+am7OL6l5ZyoqiYObf3ZfyFrRGRGnv9qPBQfn9NEvNu\n70dEWAijXl/B7z9YxzE7yjCmRlixMJXKLyzm1++s4dfvrqVnq0Z8dPdAerZq7Fqe5MTG/OfugUy4\nsDVvr9jJ4GcXsXSrHWUY4zQrFuaUdu7P4/qXljI3NYM7L23LjAl9iKsb6XYs6kSE8tA1ScyZ1I+w\nEGHUayt4+F/r7SjDGAdZsTAV+mTDPq5+YTEZB/OYOjaZXw3uQGhIzZ128kXv1o357z0X8bMBicxY\nvoMhzy1i+bb9bscyJihZsTA/UlRcwlMLNjHxzVRaxUbz0d0DGdSpiduxTqlORCiPDO3M7Il9EYQR\nU5bzyL/Wk1dgRxnGVCcrFuZ72UdOMGbqSl7+cisje5/LO5P707JxtNuxfNKnTSwL7h3IuP6JTF+2\ngyHPLmaFHWUYU22sWBgAUrYf4OrnF7N650H+euP5/On6rkSFV98Eu5oQHRHGo9d2ZvakvgDcPGU5\nj85Ps6MMY6qBFYtaTlV5ffE2RkxZTnREKB/cMYDhPVu4Heus9PUeZYzt14ppS7dz1XOLWfndAbdj\nGRPQrFjUYkfyC7lj5mqe+GgjgzomMP+uC+nUrL7bsapFdEQYfxjWhVkT+1Kiys1TlvH4vzdQVFzi\ndjRjApL1hqqlNmce4edvrWLHgTx+95OOTBzYpkYn2dWUfufFsuCei/jzfzcx9avv2HUgj+dHdg+4\nU2zGuM2OLGqhVTsOct2LSzhyooiZt/Vh0kXnBWWhKBUTGcbj13Xh0aFJfLxhH+OnpVh/KWNOk6PF\nQkSGiMhmEUkXkQcqePwiEVktIkUiMrzcY2NFZIv3NtbJnLVJQVEJD7y7lsYxEXx014X0aRPrdqQa\nM25Aa565+XxWfHeAW15bzoFjBW5HMiZgOFYsRCQUeBG4CkgCRopIUrnddgLjgJnlntsYeAToA/QG\nHhGRRk5lrU1eW7yNLVlHeeK6LiTUj3I7To37afcWvDq6J5syj3DTq8vYm3vc7UjGBAQnjyx6A+mq\nuk1VC4DZwLCyO6jqdlVdC5QfdRwMfKKqB1T1IPAJMMTBrLXC9pxjPP/ZFq7u2oxLOya4Hcc1lyc1\n4c3xvdmXm8/wl5exLfuo25GM8XtOFovmwK4y32d4tzn9XFMBVeWhf60nIjSEh4eWP8Crffq0iWXW\npL7kFxZz4yvLWL871+1Ixvg1J4tFRSOmWp3PFZFJIpIqIqnZ2dmnFa62mb9mD4u35PDrIR1oUgtP\nP1WkS/MGzJvcj6jwUEZOWW4zvo2phJPFIgNoWeb7FsCe6nyuqk5R1WRVTY6Pjz/joMHuUF4Bj/97\nA+e3bMioPq3cjuNX2sTXZd7kfiTUj+TWN1by2cZ9bkcyxi85WSxSgHYi0lpEIoARwHwfn7sQuFJE\nGnkHtq/0bjNn4KkFmziYV8iTP+3id51j/cE5Deswb3J/OjStx6QZq/jg691uRzLG7zhWLFS1CLgT\nz5v8RmCuqqaJyGMici2AiPQSkQzgRuBVEUnzPvcA8DiegpMCPObdZk5TyvYDzFq5iwkXtqbzOQ3c\njuO3GsdEMHNiX3onNubeOd8wbcl3bkcyxq+Iqq/DCP4tOTlZU1NT3Y7hVwqKSrj6+cXkFRTzyX0X\nER1hE/arkl9YzF2zvuaTDfu49/J23DOoXVBPWDRGRFapanJV+9kM7iBWOqfisWGdrVD4KCo8lJdv\n6cHwni149tMt/OHDDZSUBMcHKmPOhr2DBKnSORU/6drUrxcv8kdhoSE8fUM36keF88aS78g9XsjT\nw7sRHmqfrUztZcUiCJXOqQgPDeGRoZ3djhOQQkKEh67pRKPocP72ybccyS/kH6N6WANCU2vZR6Ug\nZHMqqoeIcNegdjw+rDOfbcri1jdWcji/0O1YxrjCikWQyc0r/H5OxS02p6JajOmXyLM3X8DqHQcZ\nOWU5OUdPuB3JmBpnxSLI/NnmVDhi2AXNee3WZNKzjnLTK8vYfcgaEJraxYpFEEndfoBZK3fanAqH\nXNoxgbdu60P20RMMf3kp6VnWgNDUHlYsgkRBUQm/e38dzRvW4d7L27kdJ2j1SmzM7El9KSwu4aZX\nl7Fx72G3IxlTI6xYBInXFm/j2302p6ImdD6nAfMm9yciNIRb31jJzv15bkcyxnFWLILAjv02p6Km\ntY6LYcaE3hQUlTDmjRVkH7FBbxPcrFgEOFXl9x/YnAo3tGtSjzfG9SLr8AnG2mW1JshZsQhwNqfC\nXT1bNeLl0T34dt8RJk5PJb+w2O1IxjjCikUAszkV/uGSDgn87abzWfHdAe6e9TVFxeVXCTYm8Fmx\nCGA2p8J/DLugOY8MTeLjDfv4/QfrCZZuzsaUsstmAlTpnIqJA21Ohb/42YDW7D9awD++SKdxTAS/\nHtLR7UjGVBsrFgHox3Mq2rsdx5Rx/5Xt2X+sgJe+3ErjmAhuG9jG7UjGVAsrFgGodE7F1LHJxETa\nP6E/ERGeuK4LB48V8MRHG4mtG8FPu7dwO5YxZ83GLAJM6ZyKq7rYnAp/FRoiPDviAvq1ieX/5q3l\ni01Zbkcy5qxZsQggNqcicESFhzLl1p50bFaPn7+9ilU7bAl5E9isWASQ0jkV/ze4A00b2JwKf1cv\nKpxpP+tN0/pR/OyfKWzOPOJ2JGPOmBWLAPH9nIoWDRjd1+ZUBIq4upHMmNCHqPBQbn1jBRkHrY+U\nCUxWLALE93Mqru9qcyoCTMvG0bw5oTfHC4q5depK9tviSSYAWbEIAKVzKsYPSLQ5FQGqY9P6vDGu\nF7sPHWfcP1M4eqLI7UjGnBYrFgHg7598S9P6UTanIsAlJzbm5dE92LD3MLfPSOVEkfWRMoHDioWf\n+y7nGEu37mdMv1Y2pyIIXNaxCU/f0I0l6fv55ZxvKC6xtiAmMNi7j5+bnbKT0BDhxp42sStY3NCz\nBQfzPJP2Gkav54/XdUHExqGMf7Ni4ccKikp4JzWDyzslkGDtx4PKbQPbkHO0gFf+t5W4upHcd4Wd\nYjT+zYqFH/tkwz72HytgZO9z3Y5iHPCbIR04cOwEz3+2hdiYCMb2T3Q7kjGnZMXCj81auZPmDesw\nsF2821GMA0SEJ3/alYN5hTz6YRoNo8MZdkFzt2MZUyFHB7hFZIiIbBaRdBF5oILHI0VkjvfxFSKS\n6N0eLiLTRWSdiGwUkd86mdMf7dh/jK/ScxjRq6XNqwhiYaEhvDCyO70SG3P/3DUs+jbb7UjGVMix\nYiEiocCLwFVAEjBSRJLK7TYBOKiqbYFngKe8228EIlW1K9ATuL20kNQWs1N2eQa2k1u6HcU4LCo8\nlNfHJtM2oS53vL2a9Kyjbkcy5iROHln0BtJVdZuqFgCzgWHl9hkGTPfefwcYJJ7LQhSIEZEwoA5Q\nABx2MKtfKSgqYV7qLi7rmGA9oGqJ+lHhTB3Xi8jwEG6bnsKhvAK3IxnzI04Wi+bArjLfZ3i3VbiP\nqhYBuUAsnsJxDNgL7AT+qqonte0UkUkikioiqdnZwXP4/tnGfeQcLWCUDWzXKs0b1uHVMT3Zcyif\nO2auptDW8jZ+xMliUdGJ9vIzkE61T2+gGDgHaA3cLyInLTmmqlNUNVlVk+Pjg2cQeObKnZzTIIqL\n2gfPn8n4pmerxvzxp11Ykr6fx/+9we04xnzPyWKRAZQ94d4C2HOqfbynnBoAB4BRwAJVLVTVLGAJ\nkOxgVr+x60Aei7fkcHOvc21gu5a6Mbklky5qw5vLdvDW8h1uxzEGcLZYpADtRKS1iEQAI4D55faZ\nD4z13h8OfK6qiufU02XiEQP0BTY5mNVvzE7ZSYjATb1sxnZt9pshHbm0QzyPzk9j6dYct+MY41yx\n8I5B3AksBDYCc1U1TUQeE5FrvbtNBWJFJB24Dyi9vPZFoC6wHk/R+aeqrnUqq78oLC5hbmoGl3VM\noFmDOm7HMS4KDRGeG9mdxLgYfvH2anbsP+Z2JFPLieeDfOBLTk7W1NRUt2OclQXrM5n81iqmjk22\n9bUNANtzjnHdS0uIqxvJ+7/oT72ocLcjmSAjIqtUtcrT/NZ11o/MWrmTZg2iuKRDgttRjJ9IjIvh\npVt6sD3nGPfMti61xj1WLPzErgN5LNqSzc02Y9uU0/+8OB65tjOfb8ri6QW1YujO+CHrDeUn5qbu\nQoCbbMa2qcCYvq34NvMIry7aRrsm9RhuLetNDbMjCz9QWFzCnJRdXNohgXMa2sC2qdjDQ5Pof14s\nv3tvHat2nDRH1RhHWbHwA59vyiLryAlrRW4qFR4awku39KBZwyhun7GK3YeOux3J1CJWLPzArJU7\naVo/iks62IxtU7mG0RFMHZvMicISJk5PJa+gyO1IppawYuGyjIN5/O/bbG7q1ZKwUPvnMFVrm1CP\n50d1Z1PmYe6fu4YSu0LK1AB7d3LZ3BRPr8Wbe9nAtvHdpR0S+N1POvHf9Zk8+9kWt+OYWsCuhnJR\nUXEJc1J3cUn7eJrbwLY5TRMubM3mzCM8/9kW2jepyzXdznE7kglidmThoi82Z7PvsA1smzMjIjzx\n0y70bNWIX81bw7qMXLcjmSBmxcJFs1buJKFeJJd1tBnb5sxEhoXyyuiexMZEMvHNVLIO57sdyQQp\nKxYu2X3oOF9uzuJmG9g2Zym+XiSv3ZpM7vFCJs5YRX5hsduRTBCydymXzE3ZhWIztk31SDqnPs/c\nfAFrdh3it++tI1gahBr/4dMAt4gMBjoD3y8IrapPOhUq2BUVlzA3dRcXtYunZeNot+OYIDGkS1Pu\nv6I9f/vkW9o3qcfPLznP7UgmiFR5ZCEiL+FZoOg+oA4wGmjrcK6g9r9vs9mbm28D26ba3XlZW4ae\nfw5PL9zEJxv2uR3HBBFfTkNdqKqjgP2q+hDQB88SqeYMzVq5k/h6kQzqZAPbpnqJCH8Z3o2uzRtw\n7+yv2ZR52O1IJkj4UixKG9Dki0hTIB9IdCxRkNube5zPN2VxU3ILwm1g2zggKjyUKWOSiYkM47bp\nqew/esLtSCYI+PJu9V8RaQj8FfgG2A6862SoYDY3JQMFRvSyU1DGOU0bRPHarclkHznB7TNWcaLI\nrpAyZ8eXYvGEqh5S1XlAa6Ar8JCzsYJTcYkyJ2UnA21g29SA81s25G83nU/qjoN2hZQ5a74Ui5Wl\nd1T1uKoeKLvN+G7Rt9nsyc1nVG+7XNbUjGu6ncO9l7fjvdW7eeV/29yOYwLYKS+dFZEEoBlQR0S6\nAqVrfdYH7GPxGZi5cidxdSMZ1KmJ21FMLXLPoHZszT7G0ws30SY+hsGdm7odyQSgyuZZXA2Mx3Pl\n00tlth/BTkOdtszcfD7flMXtF7WxgW1To0qvkNp5II97Z3/DvMn96NK8gduxTIA55buWqv5TVQcC\nE1R1YJnbT7zjF+Y0zEvdRXGJ2sC2cUVUeCivjelJw+hw6yFlzkiVH3FVda6IDBaR+0Tkd6W3mggX\nLIpLlNkpuxjYLo5zY+0MnnFHQv0oXh9rPaTMmbEZ3DVg8ZZsdh86bjO2jes6n9OAZ26+gLUZh/jV\nvDV2hZTxmc3grgGzVu4krm4El9vAtvEDgzs35deDO/LvtXt5zlbZMz6yGdwO23c4n083ZjG8Z0si\nwmxg2/iHyRe34YYeLXj20y18uGaP23FMAPCl62z5GdzFwJuOpgoiPwxs29wK4z9EhCev78LOA8f4\n1bw1tGwczQUtG7ody/gxXwa4Hy0/g1tVf+vLDxeRISKyWUTSReSBCh6PFJE53sdXiEhimce6icgy\nEUkTkXUiElX++f6upESZtXIXA9rGkhgX43YcY36kdJW9hPqeVfb2HDpe9ZNMrXXKYiEi15a/AVcA\nF3rvV0pEQoEXgauAJGCkiCSV220CcFBV2wLPAE95nxsGvAVMVtXOwCVA4Wn/6Vy2OD3HBraNX4ut\nG8nUsb04XlDMbdNTOXaiyO1Ixk9VdmRxo/f2c2AGnjf2CXhOQU3w4Wf3BtJVdZuqFgCzgWHl9hkG\nTPfefwcYJCICXAmsVdU1AKq6X1UD7jq/WSt2EhsTwZVJNmPW+K/2TerxwqjubMo8zC/nfENJiV0h\nZU5W2aS8Mao6Bs8n+iRVHaaqw/CsmOfLx4/mwK4y32d4t1W4j6oWAblALNAeUBFZKCKrReTXvv6B\n/EXW4Xw+3biP4T1b2MC28XuXdkjg91cn8fGGffzl481uxzF+yJcB7jaqurvM93uADj48TyrYVv4j\ny6n2CQMuBHoBecBnIrJKVT/70ZNFJgGTAM49179O9cxblUFRiXKzDWybAPGzAYmkZx/l5S+3cl58\nXYb3tCvkzQ98+ci7SEQ+EpHRInILMB9Y5MPzMoCy75Qt8BSaCvfxjlM0AA54t/9PVXNUNQ/4D9Cj\n/Auo6hRVTVbV5Pj4eB8i1YySEmV2yk76tYmlTXxdt+MY4xMR4Q/Xdqb/ebH89r21pGw/4HYk40d8\nKRZ3ANPwTMbri2fM4g4fnpcCtBOR1iISAYzAU2jKmo9ndjjAcOBz9UwpXQh0E5FobxG5GNjgw2v6\nhSVbc9h14Dgj+/jX0Y4xVQkPDeGlW3rQolE0t89Yxa4DeW5HMn7Cl0tnVVXnqepd3ts89aFHgHcM\n4k48b/wbgbmqmiYij5W5mmoqECsi6XjaiTzgfe5B4O94Cs43wGpV/ehM/oBumLVyJ42iwxnc2WZs\nm8DTMDqCqWOTKSouYcL0FI7kB9yFiMYBEiy9YZKTkzU1NdXtGBzOLyT58U8Z3bcVDw8tf6WwMYFj\nSXoOt76xkoHt4nj91mTCrLV+UPKOBydXtZ/961ezLzZlUVBcwtXd7HJZE9gGtI3jsWGd+XJzNk/+\nZ5PbcYzLfOk6O8Q798H44OO0fcTXi6R7y0ZuRzHmrN3SpxU/G5DIG0u+Y+aKnW7HMS7y5chiHLBF\nRJ4UkXYO5wlo+YXFfLE5iyuTmhASYvXVBIcHf9KJi9vH8/C/1rM0PcftOMYlvgxwjwCSgd3ALBFZ\nLCLjRcSaHZXz1ZYc8gqKbY1jE1TCQkN4YVR3WsfFMPmtVWzLPup2JOMCn8YsVPUQMBPPJbTnAiOB\nNSLyC+eiBZ6FaZnUjwqjb5tYt6MYU63qR4UzdWwvwkJDGD8thYPHCtyOZGqYL2MWV4nIPGAxUA/o\nq6pXAOcDv3E4X8AoKi7h0437GNSpibX3MEHp3NhopozpyZ5D+Ux+axUFRSVuRzI1yJd3tTHAy6ra\nRVX/pKp7AVT1GDDR0XQBZOX2AxzMK7S5FSaoJSc25unh3Vjx3QEefH+dLctai1TZG8q7pOqpHvu4\neuMEroXrM4kKD+Gi9v7TdsQYJ1zXvTnbso/y/OfpnJdQl8kXn+d2JFMDTlksROQgJzf+A0/zP1XV\nxo6lCjCqyscb9nFRu3iiI3zpzWhMYLv38vZszTnGUws2kRgbw5AudlFHsKvsNFQcEF/BrXS78Vqb\nkcve3Hz7hTG1RkiI8Lcbz+f8Fg25d87XrMvIdTuScVhlxSKmipvxWpCWSViIMKijjVeY2iMqPJQp\nt/YkNiaS295MITM33+1IxkGVFYs0YL33a/nbeuejBQZVZeH6TPq2iaVBdLjbcYypUQn1onh9bDJH\n84uYMD3FlmUNYpWtlNdSVc/1fi1/s97bXulZR9mWc4zBdgrK1FKdmtXnH6N6sHHvYe6d8w3Ftixr\nUPJpQoCINBCRHiLSv/TmdLBAsTAtE4Ark+wUlKm9Lu2YwEPXJPHJhn08vcCaDgajKi/dEZEJeNaa\naA6sw7PU6XLgEkeTBYgFaZn0OLchTepHuR3FGFeN65/ItuxjvLpoG63jYhjR205ABBNfjizuxdMb\naruqDgR6AnsdTRUgMg7msX73YesFZQyeZVkfGZrEwHZx/P4DazoYbHwpFvmqehxARCJUNQ3o6Gys\nwPBx2j4AKxbGeIWFhvDiLT2s6WAQOmWx8K59DbBXRBoCHwILReRdYF9NhPN3C9Iy6di0HolxdiWx\nMaXqR4XzxjhrOhhsKjuyWAmgqteq6iFVfQh4AngbGFYT4fxZztETpG4/wJV2VGHMSVo2tqaDwaay\nYnHS6j2q+pmqvqeqJxzMFBA+3bCPEoUhViyMqZA1HQwulV0NFS8i953qQVX9uwN5AsbCtExaNq5D\np2b13I5ijN+6rntztuUc4/nPttAmvi4/v8SaDgaqyopFKFCXCo4warsj+YUsSd/P2P6tsOXJjanc\nLy9vx7bsozy1YBOt46IZ0qWZ25HMGaisWOxV1cdqLEkA+WJzNgXFJXYVlDE+EBH+euP57D50nHvn\nfMO8htF0bdHA7VjmNJ3WmIXxWJiWSVzdSHqc28jtKMYEhKjwUKaMSSY2JpIJ01PYm3vc7UjmNFVW\nLAbVWIoAkl9YzJebsriycxNCQqyeGuOr+HqRvDGuF3kFxUyYlmpNBwNMZY0ED9RkkECxJD2HYwXF\ndgrKmDPQoWk9XhjVnU2Zh7lntjUdDCQ+NRI0P1iwPpN6UWH0axPrdhRjAtKlHRJ4+JokPt24j6es\n6WDAsDVAT0NRcQmfbtzHoI4JRIRZnTXmTI0b0JptOceYsmgbLRvVYUy/RLcjmSo4+o4nIkNEZLOI\npIvIAxU8Hikic7yPrxCRxHKPnysiR0XkV07m9FXK9oMczCu0U1DGVIOHr0liUMcEHvpXGvNSd7kd\nx1TBsWIhIqHAi8BVQBIwUkSSyu02ATioqm2BZ4Cnyj3+DPBfpzKeroVpmUSGhXBxB1uC3JizVdp0\ncGC7OH7z7lrmr9njdiRTCSePLHoD6aq6TVULgNmc3FNqGDDde/8dYJB4Z7mJyHXANjzLuLpOVVmY\nlslF7eOJjrCzd8ZUh9JLapMTG/PLOd+wYH2m25HMKThZLJoDZY8tM7zbKtxHVYuAXCBWRGKA3wB/\ncDDfaVmbkcve3HzrBWVMNasTEcob43rRrUUD7pq1mi82ZbkdyVTAyWJR0SSE8tfJnWqfPwDPqGql\nzfBFZJKIpIpIanZ29hnG9M3CtExCQ4RBnRIcfR1jaqO6kWFM+1lvOjStx+1vrWKJLZzkd5wsFhlA\nyzLftwDKn5T8fh/v+hkNgANAH+BpEdmOZ6W+34nIneVfQFWnqGqyqibHxzs7jrAwLZO+bRrTMDrC\n0dcxprZqUCecGeP70Do2htump7LyO5vq5U+cLBYpQDsRaS0iEcAIYH65feYDY733hwOfq8dAVU1U\n1UTgWeBJVf2Hg1krlZ51hK3Zx+wUlDEOaxQTwVu39aFZwyjGT0vhm12H3I5kvBwrFt4xiDuBhcBG\nYK6qponIYyJyrXe3qXjGKNKB+4CTLq/1Bwu9y6dekWTFwhinxdeLZOZtfWkcE8GtU1ewfneu25EM\nIMGyIElycrKmpqY68rOHvvAVYaHC+78Y4MjPN8acLONgHje9sozjhcXMub0f7ZvY2jFOEJFVqppc\n1X42DbkKuw8dZ93uXJuIZ0wNa9EompkT+xIeGsKo11awLbvS612Mw6xYVGGh97pvKxbG1LzEuBhm\nTuyDqnLL6yvYdSDP7Ui1lhWLKixMy6RDk3q0jotxO4oxtVLbhHrMmNCHvIJiRr2+3NbCcIkVi0rs\nP3qClO0HGNy5idtRjKnVks6pz4wJvTl0rJBbXltB1pF8tyPVOlYsKvHpxn2UKAzuYqegjHFbtxYN\nmTa+F5mH8xn9+goOHCtwO1KtYsWiEgvT9tGiUR2SmtV3O4oxBujZqjFTx/Zix/48Rr++gty8Qrcj\n1RpWLE7hSH4hX23JYXDnpnh7Gxpj/EC/82KZcmsy6VlHufWfKzmSbwWjJlixOIUvN2dTUFzCEDsF\nZYzfubh9PC/e0oO03bmMn5ZCXoGt5+00KxansDAtk7i6EfQ4t5HbUYwxFbgiqQnPjejOqh0Hmfhm\nKvmFxW5HCmpWLCqQX1jMF5uyuCKpKaEhdgrKGH91dbdm/PXG81m6dT8/f2sVBUUlbkcKWlYsKrB0\naw7HCortklljAsD1PVrw5E+78sXmbO6atZrCYisYTrBiUYEF6zOpFxlG//Pi3I5ijPHByN7n8ujQ\nJBam7ePe2d/YEYYDbH3QcoqKS/h0YxaXdUogIsxqqTGBYtyA1hSVKE98tJHD+YW8MronMZH2Fldd\n7N2wnJTtBzlwrMB6QRkTgG5ADdcGAAAO7klEQVQb2Ianh3dj6db9jHptOfuPnnA7UtCwYlHOwrRM\nIsNCuLi9syvvGWOccVNyS14d3ZNNmUe48ZVlZBy05oPVwYpFGarKx2mZDGwXb4evxgSwy5Oa8NZt\nfcg5eoIbXl7Kt/uOuB0p4FmxKGPd7lz25ObbVVDGBIFeiY2ZO7kfADe+soxVO2xN77NhxaKMhWmZ\nhIYIl3eyYmFMMOjYtD7vTO5P45gIbnl9BZ9v2ud2pIBlxaKMBesz6dO6MY1iItyOYoypJi0bRzNv\ncj/aJdRj4pureGdVhtuRApIVC6/0rCNszT5mvaCMCUJxdSOZNakv/drE8qt5a5iyaKvbkQKOFQuv\nhWmew9Mrk6xYGBOM6kaGMXVcMtd0a8aT/9nEn/6zEVV1O1bAsEt+vBamZXJBy4Y0bRDldhRjjEMi\nw0J5fkR3YmMieHXRNnKOFvDnG7oSHmqfm6tif0PA7kPHWZuRaxPxjKkFQkKER6/tzH1XtOfd1Rnc\nPmMVxwusY21VrFgAH6dlAtgls8bUEiLC3YPa8cR1Xfhicxajp9qqe1WxYoHnFFT7JnVpE1/X7SjG\nmBo0um8rXhrVg3UZudz46lIyc/PdjuS3an2x2H/0BCu/O2CnoIyppa7q2oxp43ux51A+N7y8lK3Z\nR92O5JdqfbHYcyifxLgYKxbG1GL9z4tj9qS+nCgq5sZXlrFm1yG3I/mdWl8surZowOf3X0Lnc+q7\nHcUY46IuzRvwzuT+xESGMvK15Szeku12JL9S64tFKRFbPtWY2i4xLoZ3J/enVWwM46elMH/NHrcj\n+Q1Hi4WIDBGRzSKSLiIPVPB4pIjM8T6+QkQSvduvEJFVIrLO+/UyJ3MaY0yphPpRzLm9L93PbcQ9\ns79m2pLv3I7kFxwrFiISCrwIXAUkASNFJKncbhOAg6raFngGeMq7PQcYqqpdgbHADKdyGmNMefWj\nwnlzfG+u6NSERz/cwIPvr6v1S7U6eWTRG0hX1W2qWgDMBoaV22cYMN17/x1gkIiIqn6tqqXHf2lA\nlIhEOpjVGGN+JCo8lJdH9+Tnl5zH2yt2MvK15ew7XHsvrXWyWDQHdpX5PsO7rcJ9VLUIyAViy+1z\nA/C1qtr6iMaYGhUaIvxmSEdeHNWDjXsPc80LX9XadTGcLBYVjRiX79pV6T4i0hnPqanbK3wBkUki\nkioiqdnZduWCMcYZV3drxvu/GEB0RCgjpiznreU7al0TQieLRQbQssz3LYDylxZ8v4+IhAENgAPe\n71sA7wO3qmqF/YRVdYqqJqtqcny8rZltjHFOh6b1mH/HhVzYNo7ff7Ce37y7lvzC2tNTyslikQK0\nE5HWIhIBjADml9tnPp4BbIDhwOeqqiLSEPgI+K2qLnEwozHG+KxBdDhTx/bi7svaMjc1g5tfXcbe\n3ONux6oRjhUL7xjEncBCYCMwV1XTROQxEbnWu9tUIFZE0oH7gNLLa+8E2gIPicg33luCU1mNMcZX\nISHCfVd24NUxPdmafYyhL3zFim373Y7lOAmW827JycmamprqdgxjTC2SnnWESTNWsXN/Hr+/uhNj\n+ycG3ARfEVmlqslV7WczuI0x5gy1TajHB3cM4JIOCTz64Qbun7cmaMcxrFgYY8xZqB8VzpQxPfnl\n5e15b/Vuhr+ylIyDeW7HqnZWLIwx5iyFhAj3XN6OqWOT2ZGTx9AXvmJpeo7bsaqVFQtjjKkmgzo1\n4V93DiCubiSjp67g9cXbgmY+hhULY4ypRm3i6/L+HQMY3LkpT3y0kbtnf0NeQZHbsc6aFQtjjKlm\ndSPDeOmWHvzf4A78e+0ern9pKTv3B/Y4hhULY4xxgIhwx6Vt+ee4Xuw5dJyh//iKRd8GblsiKxbG\nGOOgSzok8OFdF9KsQRRj/7mSl75MD8hxDCsWxhjjsFaxMbz3i/5c3bUZTy/YzPhpKWQfCaxG2lYs\njDGmBkRHhPHCyO784drOLN26nyHPLuLTDfvcjuUzKxbGGFNDRISx/RP58K4LSagfxW1vpvK799cF\nxNVSViyMMaaGtW9Sjw/u6M+ki9owa+VOrnnhK9Zl5Lodq1JWLIwxxgWRYaH87iedeHtCH44XFPPT\nl5bw4hfpFJf45+C3FQtjjHFR/7ZxLLjnIgZ3acpfFm5m5JTlftlbyoqFMca4rEF0OP8Y2Z2/3Xg+\nG/Ye5qpnF/PB17vdjvUjViyMMcYPiAg39GzBf+8ZSIem9bh3zjfcPetrco8Xuh0NsGJhjDF+pWXj\naGZP6sv9V7Tno3V7+clzi1nuByvxWbEwxhg/ExYawl2D2vHuz/sTHiqMfG05Ty3YREFRiWuZrFgY\nY4yfuqBlQz66eyA3J7fk5S+3cv3LS0jPOupKFisWxhjjx2Iiw/jzDd14dUxPdh88zjUvLGbG8h01\n3l/KioUxxgSAwZ2bsvDei+jdOpaHPljPbdNTyTlac/2lrFgYY0yASKgfxbRxvXhkaBKL03MY8uwi\nPt9UM/2lrFgYY0wACQkRfjagNR/eeSFxdSMZPy2VJ/69wfnXdfwVjDHGVLsOTevxrzsHMHFga1rF\nxTj+emGOv4IxxhhHRIaF8uDVSTXyWnZkYYwxpkpWLIwxxlTJioUxxpgqOVosRGSIiGwWkXQReaCC\nxyNFZI738RUikljmsd96t28WkcFO5jTGGFM5x4qFiIQCLwJXAUnASBEpPxIzATioqm2BZ4CnvM9N\nAkYAnYEhwEven2eMMcYFTh5Z9AbSVXWbqhYAs4Fh5fYZBkz33n8HGCQi4t0+W1VPqOp3QLr35xlj\njHGBk8WiObCrzPcZ3m0V7qOqRUAuEOvjc40xxtQQJ4uFVLCtfOerU+3jy3MRkUkikioiqdnZ2WcQ\n0RhjjC+cnJSXAbQs830LYM8p9skQkTCgAXDAx+eiqlOAKQAiki0iO84ibxyQcxbPd5q/5wP/z+jv\n+cD/M/p7PrCMp6uVLzs5WSxSgHYi0hrYjWfAelS5feYDY4FlwHDgc1VVEZkPzBSRvwPnAO2AlZW9\nmKrGn01YEUlV1eSz+RlO8vd84P8Z/T0f+H9Gf88HltEpjhULVS0SkTuBhUAo8IaqponIY0Cqqs4H\npgIzRCQdzxHFCO9z00RkLrABKALuUNVip7IaY4ypnKO9oVT1P8B/ym17uMz9fODGUzz3j8Afncxn\njDHGNzaD+wdT3A5QBX/PB/6f0d/zgf9n9Pd8YBkdITW9NJ8xxpjAY0cWxhhjqlTri0VV/avcJiIt\nReQLEdkoImkico/bmSoiIqEi8rWI/NvtLBURkYYi8o6IbPL+XfZzO1NZIvJL77/vehGZJSJRfpDp\nDRHJEpH1ZbY1FpFPRGSL92sjP8z4F++/81oReV9EGvpTvjKP/UpEVETi3Mh2ump1sfCxf5XbioD7\nVbUT0Be4ww8zAtwDbHQ7RCWeAxaoakfgfPwoq4g0B+4GklW1C56rB0e4mwqAaXh6s5X1APCZqrYD\nPvN+76ZpnJzxE6CLqnYDvgV+W9OhypjGyfkQkZbAFcDOmg50pmp1scC3/lWuUtW9qrrae/8Injc5\nv2p9IiItgKuB193OUhERqQ9chOdSbVS1QFUPuZvqJGFAHe/k1GgqmIRa01R1EZ5L2ssq289tOnBd\njYYqp6KMqvqxt30QwHI8k3pdcYq/Q/A0Tv01FXSm8Fe1vVgEVA8qbwv37sAKd5Oc5Fk8//FL3A5y\nCm2AbOCf3lNlr4uI84sW+0hVdwN/xfMpcy+Qq6ofu5vqlJqo6l7wfJABElzOU5XxwH/dDlGWiFwL\n7FbVNW5nOR21vVj41IPKH4hIXeBd4F5VPex2nlIicg2Qpaqr3M5SiTCgB/CyqnYHjuH+6ZPvec/7\nDwNa4+lYECMio91NFfhE5EE8p3HfdjtLKRGJBh4EHq5qX39T24uFTz2o3CYi4XgKxduq+p7becoZ\nAFwrItvxnMa7TETecjfSSTKADFUtPSJ7B0/x8BeXA9+paraqFgLvAf1dznQq+0SkGYD3a5bLeSok\nImOBa4Bb1L/mB5yH50PBGu/vTAtgtYg0dTWVD2p7sfi+f5WIROAZVJzvcqYf8a7vMRXYqKp/dztP\near6W1VtoaqJeP7+PldVv/pUrKqZwC4R6eDdNAhPKxl/sRPoKyLR3n/vQfjRAHw5pf3c8H79l4tZ\nKiQiQ4DfANeqap7becpS1XWqmqCqid7fmQygh/f/qF+r1cXCOwhW2r9qIzBXVdPcTXWSAcAYPJ/Y\nv/HefuJ2qAB0F/C2iKwFLgCedDnP97xHPO8Aq4F1eH4vXZ/hKyKz8DT57CAiGSIyAfgzcIWIbMFz\nNc+f/TDjP4B6wCfe35dX/CxfQLIZ3MYYY6pUq48sjDHG+MaKhTHGmCpZsTDGGFMlKxbGGGOqZMXC\nGGNMlaxYGOMlIsXeSy3XiMhqEenv3X6OiLxzmj/rSxE5rTWWReTo6exvTE1ydFlVYwLMcVW9AEBE\nBgN/Ai5W1T3AcFeTGeMyO7IwpmL1gYPgaeBYuh6BiIwTkfdEZIF3TYenq/pBInJURP7oPWJZLiJN\nvNtbi8gyEUkRkcfLPef/vNvXisgfvNt6eb+PEpEY7/oXXar9T25MBaxYGPODOt7TUJvwtFt//BT7\nXQDcDHQFbvauTVCZGGC5qp4PLAImerc/h6e5YS/g+3YPInIl0A5PC/0LgJ4icpGqpuBpt/EE8DTw\nlqqetKiOMU6wYmHMD46r6gXeBZKGAG96ezWV95mq5qpqPp4eU62q+LkFQOkKgquARO/9AcAs7/0Z\nZfa/0nv7Gk8LkI54igfAY3jabCTjKRjG1AgbszCmAqq6zLvcZXwFD58oc7+Yqn+PCst0Pi2/f0X9\ndgT4k6q+WsFjjYG6QDgQhafdujGOsyMLYyogIh3xLG+638GXWcIPy6feUmb7QmC8dw0TRKS5iJQu\nMjQFeAjPGg1POZjNmB+xIwtjflBHRL7x3hdgrKoWV3wmqlrcA8wUkXvwrFcCeJYFFZFOwDLvax8F\nRntbbxep6kzv+vFLReQyVf3cqYDGlLKus8YYY6pkp6GMMcZUyYqFMcaYKlmxMMYYUyUrFsYYY6pk\nxcIYY0yVrFgYY4ypkhULY4wxVbJiYYwxpkr/D2iow2TbDbFKAAAAAElFTkSuQmCC\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"
     }
    ],
@@ -502,17 +456,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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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"
     }
    ],
@@ -531,17 +487,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEKCAYAAAA4t9PUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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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"
     }
    ],
@@ -572,17 +530,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEYCAYAAABSnD3BAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMEyLAAAAAElFTkSuQmCC\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"
     }
    ],
@@ -605,17 +565,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEQCAYAAABFtIg2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niIjoKEkiIiI6SpKIiIiOkiQiIqKj/w/dVhz7kUZNiwAAAABJRU5ErkJggg==\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"
     }
    ],
@@ -639,17 +601,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAERCAYAAABowZDXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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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"
     }
    ],
@@ -698,17 +662,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7MAAAEVCAYAAAAyxLK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\npB01ZkVERERERCTt/H+5ie+7fzfy7QAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x288 with 3 Axes>"
       ]
      },
-     "metadata": {},
+     "metadata": {
+      "needs_background": "light"
+     },
      "output_type": "display_data"
     }
    ],
@@ -731,17 +697,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEOCAYAAACaQSCZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSJI6MTAkSZ0YGJKkTv4CW7ucsX2pLgIAAAAASUVORK5CYII=\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"
     }
    ],
@@ -754,17 +722,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEnCAYAAABcy78jAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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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"
     }
    ],
@@ -790,17 +760,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'hex2': <serpentTools.objects.detectors.HexagonalDetector at 0x7fd09bfa2b70>,\n",
-       " 'hex3': <serpentTools.objects.detectors.HexagonalDetector at 0x7fd09bfa2ac8>}"
+       "{'hex2': <serpentTools.detectors.HexagonalDetector at 0x7fe2b1baec50>,\n",
+       " 'hex3': <serpentTools.detectors.HexagonalDetector at 0x7fe29f43b0d0>}"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -820,7 +790,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -833,7 +803,7 @@
        "       [0.198196, 0.198623, 0.195612, 0.174804, 0.178053]])"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -845,63 +815,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'COORD': array([[-3.       , -1.732051 ],\n",
-       "        [-2.5      , -0.8660254],\n",
-       "        [-2.       ,  0.       ],\n",
-       "        [-1.5      ,  0.8660254],\n",
-       "        [-1.       ,  1.732051 ],\n",
-       "        [-2.       , -1.732051 ],\n",
-       "        [-1.5      , -0.8660254],\n",
-       "        [-1.       ,  0.       ],\n",
-       "        [-0.5      ,  0.8660254],\n",
-       "        [ 0.       ,  1.732051 ],\n",
-       "        [-1.       , -1.732051 ],\n",
-       "        [-0.5      , -0.8660254],\n",
-       "        [ 0.       ,  0.       ],\n",
-       "        [ 0.5      ,  0.8660254],\n",
-       "        [ 1.       ,  1.732051 ],\n",
-       "        [ 0.       , -1.732051 ],\n",
-       "        [ 0.5      , -0.8660254],\n",
-       "        [ 1.       ,  0.       ],\n",
-       "        [ 1.5      ,  0.8660254],\n",
-       "        [ 2.       ,  1.732051 ],\n",
-       "        [ 1.       , -1.732051 ],\n",
-       "        [ 1.5      , -0.8660254],\n",
-       "        [ 2.       ,  0.       ],\n",
-       "        [ 2.5      ,  0.8660254],\n",
-       "        [ 3.       ,  1.732051 ]]), 'Z': array([[0., 0., 0.]])}"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "hex2.grids"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "OrderedDict([('ycoord', array([0, 1, 2, 3, 4])),\n",
-       "             ('xcoord', array([0, 1, 2, 3, 4]))])"
+       "('ycoord', 'xcoord')"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -919,7 +842,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -929,17 +852,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEKCAYAAAD+XoUoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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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"
     }
    ],
@@ -949,17 +874,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEKCAYAAAD+XoUoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzAripG9mVhAnfTOzgjjpm5kV5DsEhvNSVaGdkgAAAABJRU5ErkJggg==\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"
     }
    ],
@@ -1020,7 +947,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.7.4"
   }
  },
  "nbformat": 4,
diff --git a/serpentTools/__init__.py b/serpentTools/__init__.py
index 668ecb6..92591d3 100644
--- a/serpentTools/__init__.py
+++ b/serpentTools/__init__.py
@@ -1,4 +1,5 @@
 # flake8: noqa
+from serpentTools.detectors import *
 from serpentTools.parsers import *
 from serpentTools.messages import *
 from serpentTools.data import *
diff --git a/serpentTools/_compat.py b/serpentTools/_compat.py
index 3ba52a0..60de40d 100644
--- a/serpentTools/_compat.py
+++ b/serpentTools/_compat.py
@@ -8,6 +8,6 @@ Provided objects:
 import six
 
 if six.PY2:
-    from collections import Iterable, Callable
+    from collections import Iterable, Callable, Mapping
 else:
-    from collections.abc import Iterable, Callable
+    from collections.abc import Iterable, Callable, Mapping
diff --git a/serpentTools/detectors.py b/serpentTools/detectors.py
new file mode 100644
index 0000000..c8eb59d
--- /dev/null
+++ b/serpentTools/detectors.py
@@ -0,0 +1,1500 @@
+"""
+Module containing classes for storing detector data.
+
+``SERPENT`` is capable of producing detectors, or tallies from MCNP,
+with a variety of bin structures. These include, but are not limited to,
+material regions, reaction types, energy bins, spatial meshes, and
+universe bins.
+
+The detectors contained in this module are tasked with storing such
+data and proving easy access to the data, as well as the underlying
+bins used to define the detector.
+
+Detector Types
+--------------
+
+* :class:`~serpentTools.objects.detectors.Detector`
+* :class:`~serpentTools.objects.detectors.CartesianDetector`
+* :class:`~serpentTools.objects.detectors.HexagonalDetector`
+* :class:`~serpentTools.objects.detectors.CylindricalDetector`
+* :class:`~serpentTools.objects.detectors.SphericalDetector`
+"""
+
+from math import sqrt, pi
+from warnings import warn
+from numbers import Real
+
+from six import iteritems
+from numpy import (
+    unique, empty, inf, hstack, arange, log, divide, asfortranarray,
+    ndarray, asarray,
+)
+from matplotlib.patches import RegularPolygon
+from matplotlib.collections import PatchCollection
+from matplotlib.pyplot import gca
+
+from serpentTools.messages import (
+    warning, SerpentToolsException, error, BAD_OBJ_SUBJ,
+    debug,
+)
+from serpentTools.objects.base import NamedObject
+from serpentTools.plot import plot, cartMeshPlot
+from serpentTools.utils import (
+    magicPlotDocDecorator, formatPlot, setAx_xlims, setAx_ylims,
+    addColorbar, normalizerFactory, DETECTOR_PLOT_LABELS,
+    compareDictOfArrays,
+)
+from serpentTools.utils.compare import getLogOverlaps
+from serpentTools.io.hooks import matlabHook
+# PY2 compatibility
+from serpentTools._compat import Mapping
+
+__all__ = ['Detector', 'CartesianDetector', 'HexagonalDetector',
+           'CylindricalDetector', 'SphericalDetector']
+
+
+class Detector(NamedObject):
+    """Class for storing detector data with multiple bins
+
+    For detectors with spatial meshes, including rectilinear,
+    hexagonal, cylindrical, or spherical meshes, refer to companion
+    classes :class:`serpentTools.CartesianDetector`,
+    :class:`serpentTools.HexagonalDetector`,
+    :class:`serpentTools.CylindricalDetector`, or
+    :class:`serpentTools.SphericalDetector`
+
+    If simply the tally bins are available, it is recommended
+    to use the :meth:`fromTallyBins` class method. This will
+    reshape the data and separate the mean tally [second to last
+    column] and relative errors [last column].
+
+    Parameters
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray, optional
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray, optional
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray, optional
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : iterable of string, optional
+        Iterable naming the bins that correspond to reshaped
+        :attr:`tally` and :attr:`errors`.
+    grids : dict, optional
+        Supplemental grids that may be supplied to this detector,
+        including energy points or spatial coordinates.
+
+    Attributes
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray or None
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray or float or None
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray or float or None
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : tuple or None
+        Iterable naming the bins that correspond to reshaped
+        :attr:`tally` and :attr:`errors`. The tuple
+        ``(energy, ymesh, xmesh)`` indicates that :attr:`tallies`
+        should have three dimensions corresponding to various
+        energy, y-position, and x-position bins. Must be set
+        after :attr:`tallies` or :attr:`errors` and agree with
+        the shape of each
+    grids : dict
+        Dictionary containing grid information for binned quantities like
+        energy or time.
+    energy : numpy.ndarray or None
+        Potential underlying energy grid in MeV. Will be ``(n_ene, 3)``, where
+        ``n_ene`` is the number of values in the energy grid. Each
+        row ``energy[j]`` will be the low point, high point, and mid point
+        of the energy bin ``j``.
+
+    Raises
+    ------
+    ValueError
+        If some spatial grid is found in ``indexes`` during creation. This
+        class is ill-suited for these problems. Refer to the companion
+        classes mentioned above.
+    IndexError
+        If the shapes of ``bins``, ``tallies``, and ``errors`` are inconsistent
+    """
+
+    DET_COLS = (
+        'value', 'time', 'energy', 'universe', 'cell', 'material', 'lattice',
+        'reaction', 'zmesh', 'ymesh', 'xmesh', 'tally', 'error')
+
+    _CBAR_LABELS = {
+        'tallies': 'Tally data',
+        'errors': 'Relative Uncertainty',
+    }
+
+    def __init__(self, name, bins=None, tallies=None, errors=None,
+                 indexes=None, grids=None):
+        NamedObject.__init__(self, name)
+        self._bins = None
+        self._tallies = None
+        self._errors = None
+        self.bins = bins
+        self.tallies = tallies
+        self.errors = errors
+        self._indexes = None
+        if indexes is not None:
+            self.indexes = indexes
+        self.grids = grids
+
+    @property
+    def bins(self):
+        return self._bins
+
+    @bins.setter
+    def bins(self, value):
+        if value is None:
+            self._bins = None
+            return
+
+        # Coerce to numpy array, check shape
+        # Ensure data is ordered columnwise,  and
+        # the array owns the underlying data
+        bins = asfortranarray(value).copy()
+        if len(bins.shape) != 2 or (
+                len(bins.shape) == 2 and bins.shape[1] not in {12, 13}):
+            raise ValueError(
+                "Data does not appear to be Serpent 2 detector data. Shape "
+                "should be (N, 12) or (N, 13), is {}".format(bins.shape))
+
+        # Check that this is not a Serpent 1 detector
+        if bins[0, -3] != 1:
+            raise ValueError(
+                "Data does not appear to be Serpent 2 detector data. Appears "
+                "to have a scores column, indicated unsupported Serpent 1 "
+                "data: {}.".format(bins[0]))
+
+        self._bins = bins
+
+    @property
+    def tallies(self):
+        return self._tallies
+
+    @tallies.setter
+    def tallies(self, tallies):
+        if tallies is None:
+            self._tallies = tallies
+            return
+
+        if not isinstance(tallies, (Real, ndarray)):
+            raise TypeError("Tallies must be array or scalar, not {}".format(
+                type(tallies)))
+
+        if self._tallies is None:
+            self._tallies = tallies
+            return
+
+        # Handle scalar / single values arrays
+        # TODO Kind of clunky. Maybe a dedicated ScalarDetector?
+
+        if isinstance(tallies, Real):
+            if isinstance(self._tallies, Real):
+                self._tallies = tallies
+            else:
+                raise TypeError("Tallies are current array, not scalar")
+        else:
+            if isinstance(self._tallies, Real):
+                raise TypeError("Tallies are currently scalar, nor array")
+            if tallies.shape != self._tallies.shape:
+                raise IndexError(
+                    "Shape of tally data is not consistent. Should be {}, "
+                    "is {}".format(self._tallies.shape, tallies.shape))
+            self._tallies = tallies
+
+    @property
+    def errors(self):
+        return self._errors
+
+    @errors.setter
+    def errors(self, errors):
+        if errors is None:
+            self._errors = errors
+            return
+
+        if not isinstance(errors, (Real, ndarray)):
+            raise TypeError(
+                "Tallies must be array or scalar, not {}".format(type(errors)))
+
+        if self._errors is None:
+            self._errors = errors
+            return
+
+        # Handle scalar / single values arrays
+        # TODO Kind of clunky. Maybe a dedicated ScalarDetector?
+
+        if isinstance(errors, Real):
+            if isinstance(self._errors, Real):
+                self._errors = errors
+            else:
+                raise TypeError("Tallies are current array, not scalar")
+        else:
+            if isinstance(self._errors, Real):
+                raise TypeError("Tallies are currently scalar, nor array")
+            if errors.shape != self._errors.shape:
+                raise IndexError(
+                    "Shape of tally data is not consistent. Should be {}, "
+                    "is {}".format(self._errors.shape, errors.shape))
+            self._errors = errors
+
+    @property
+    def energy(self):
+        return self.grids.get("E")
+
+    @property
+    def grids(self):
+        return self._grids
+
+    @grids.setter
+    def grids(self, grids):
+        if grids is None:
+            self._grids = {}
+        else:
+            if not isinstance(grids, Mapping):
+                raise TypeError(
+                    "Grids must be Mapping type, not {}".format(type(grids)))
+            self._grids = grids
+
+    @property
+    def indexes(self):
+        return self._indexes
+
+    @indexes.setter
+    def indexes(self, ix):
+        if self._tallies is None:
+            if self._errors is None:
+                raise AttributeError("Tally and error attributes not set")
+            nItems = len(self._errors.shape)
+        else:
+            nItems = len(self._tallies.shape)
+        if len(ix) != nItems:
+            raise ValueError(
+                "Expected {} items for indexes, got {}".format(
+                    nItems, len(ix)))
+        self._indexes = tuple(ix)
+
+    @classmethod
+    def fromTallyBins(cls, name, bins, grids=None):
+        """Create a detector instance from 2D detector data
+
+        Parameters
+        ----------
+        name : str
+            Name of this detector
+        bins : numpy.ndarray
+            2D array taken from Serpent. Expected to have
+            either 12 or 13 columns, where the latter indicates
+            a time bin has been added.
+        grids : dict, optional
+            Dictionary of underlying energy, space, and/or time data.
+
+        Returns
+        -------
+        Detector
+
+        Raises
+        ------
+        ValueError
+            If the tally data does not appear to be Serpent 2 tally data
+
+        """
+        bins = asfortranarray(bins)
+        if len(bins.shape) != 2:
+            raise ValueError(
+                "Array does not appear to be Serpent tally data. Shape is {}, "
+                "should be 2D".format(bins.shape))
+
+        if bins.shape[1] not in (12, 13):
+            raise ValueError(
+                "Array does not appear to be Serpent tally data. Expected 12 "
+                " or 13 columns, not {}".format(bins.shape[1]))
+
+        if grids is None:
+            grids = {}
+        elif not isinstance(grids, Mapping):
+            raise TypeError("Grid data is not dictionary-like")
+
+        det = cls(name, bins=bins, grids=grids)
+
+        tallies, errors, indexes = det.reshapedBins()
+
+        det.tallies = tallies
+        det.errors = errors
+        det.indexes = indexes
+
+        return det
+
+    def reshapedBins(self):
+        """Obtain multi-dimensional tally, error, and index data
+
+        Returns
+        -------
+        tallies : numpy.ndarray
+            Potentially multi-dimensional array corresponding to
+            tally data along each bin index
+        errors : numpy.ndarray
+            Potentially multi-dimensional array corresponding to
+            tally relative error along each bin index
+        indexes : list of str
+            Ordering of named bin information, e.g. ``"xmesh"``,
+            ``"energy"``, corresponding to axis in ``tallies`` and ``errors``
+
+        Examples
+        --------
+
+        A detector is created with a single bin with two bins values.
+        These could represent tallying two different reaction rates
+
+        >>> import numpy
+        >>> from serpentTools import Detector
+        >>> bins = numpy.ones((2, 12))
+        >>> bins[1, 0] = 2
+        >>> bins[1, 4] = 2
+        >>> bins[:, -2:] = [
+        ...     [5.0,  0.1],
+        ...     [10.0, 0.2]]
+        >>> det = Detector("reshape", bins=bins)
+        >>> tallies, errors, indexes = det.reshapedBins()
+        >>> tallies
+        array([5.0, 10.0])
+        >>> errors
+        array([0.1, 0.2])
+        >>> indexes
+        ["reaction", ]
+
+        """
+        assert self.bins is not None, "No bin data present on {}".format(self)
+
+        if self.bins.shape[0] == 1:
+            return self.bins[0, -2], self.bins[0, -1], {}
+
+        shape = []
+        indexes = []
+
+        # See if the time column has been inserted
+        nameStart = 2 if self.bins.shape[1] == 12 else 1
+        for colIx, indexName in enumerate(self.DET_COLS[nameStart:-2],
+                                          start=1):
+            uniqueVals = unique(self.bins[:, colIx])
+            if len(uniqueVals) > 1:
+                indexes.append(indexName)
+                shape.append(len(uniqueVals))
+
+        tallies = self.bins[:, -2].reshape(shape)
+        errors = self.bins[:, -1].reshape(shape)
+
+        return tallies, errors, indexes
+
+    def slice(self, fixed, data='tallies'):
+        """
+        Return a view of the reshaped array where certain axes are fixed
+
+        Parameters
+        ----------
+        fixed: dict
+            dictionary to aid in the restriction on the multidimensional
+            array. Keys correspond to the various grids present in
+            :attr:`indexes` while the values are used to
+        data: {'tallies', 'errors'}
+            Which data set to slice
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            View into the respective data where certain dimensions
+            have been removed
+
+        Raises
+        ------
+        AttributeError
+            If ``data`` is not supported
+
+        """
+        if data not in {"tallies", "errors"}:
+            raise AttributeError(
+                'Data argument {} not in allowed options'
+                '\ntallies, errors')
+        work = getattr(self, data)
+        if work is None:
+            raise AttributeError("{} not setup on {}".format(data, self))
+        if not fixed:
+            return work
+        return work[self._getSlices(fixed)]
+
+    def _getSlices(self, fixed):
+        """
+        Return a list of slice operators for each axis in reshaped data
+
+        Parameters
+        ----------
+        fixed: dict or None
+            Dictionary where keys are strings pointing to dimensions in
+        """
+        keys = set(fixed)
+        slices = tuple()
+        for key in self.indexes:
+            if key in keys:
+                slices += fixed[key],
+                keys.remove(key)
+            else:
+                slices += slice(None),
+        if any(keys):
+            warning(
+                'Could not find arguments in index that match the following'
+                ' requested slice keys: {}'.format(', '.join(keys)))
+        return slices
+
+    def _getPlotGrid(self, qty):
+        grids = self.grids.get(qty[0].upper())
+        if grids is not None:
+            return hstack((grids[:, 0], grids[-1, 1]))
+        nItems = self.tallies.shape[self.indexes.index(qty)]
+        return arange(nItems + 1)
+
+    def _getPlotXData(self, qty, ydata):
+        binIndex = arange(len(ydata))
+        xlabel = DETECTOR_PLOT_LABELS.get(qty, 'Bin Index')
+        if qty is None:
+            return binIndex, xlabel
+        xdata = self.grids.get(qty[0].upper())
+        if xdata is not None:
+            return xdata[:, 0], xlabel
+        return binIndex, xlabel
+
+    def _compare(self, other, lower, upper, sigma):
+        myShape = self.tallies.shape
+        otherShape = other.tallies.shape
+        if myShape != otherShape:
+            error("Detector tallies do not have identical shapes"
+                  + BAD_OBJ_SUBJ.format('tallies', myShape, otherShape))
+            return False
+        similar = compareDictOfArrays(self.grids, other.grids, 'grids',
+                                      lower=lower, upper=upper)
+
+        similar &= getLogOverlaps('tallies', self.tallies, other.tallies,
+                                  self.errors, other.errors, sigma,
+                                  relative=True)
+        return similar
+
+    @magicPlotDocDecorator
+    def spectrumPlot(self, fixed=None, ax=None, normalize=True, xlabel=None,
+                     ylabel=None, steps=True, logx=True, logy=False,
+                     loglog=False, sigma=3, labels=None, legend=None, ncol=1,
+                     title=None, **kwargs):
+        """
+        Quick plot of the detector value as a function of energy.
+
+        Parameters
+        ----------
+        fixed: None or dict
+            Dictionary controlling the reduction in data
+        {ax}
+        normalize: bool
+            Normalize quantities per unit lethargy
+        {xlabel}
+        {ylabel}
+        steps: bool
+            Plot tally as constant inside bin
+        {logx}
+        {logy}
+        {loglog}
+        {sigma}
+        {labels}
+        {legend}
+        {ncol}
+        {title}
+        {kwargs} :py:func:`matplotlib.pyplot.plot` or
+            :py:func:`matplotlib.pyplot.errorbar`
+
+        Returns
+        -------
+        {rax}
+
+        Raises
+        ------
+        :class:`~serpentTools.SerpentToolsException`
+            if number of rows in data not equal to
+            number of energy groups
+
+        See Also
+        --------
+        * :meth:`slice`
+        """
+        slicedTallies = self.slice(fixed, 'tallies').copy()
+        if len(slicedTallies.shape) > 2:
+            raise SerpentToolsException(
+                'Sliced data cannot exceed 2-D for spectrum plot, not '
+                '{}'.format(slicedTallies.shape)
+            )
+        elif len(slicedTallies.shape) == 1:
+            slicedTallies = slicedTallies.reshape(slicedTallies.size, 1)
+        lowerE = self.grids['E'][:, 0]
+        if normalize:
+            lethBins = log(
+                divide(self.grids['E'][:, -1], lowerE))
+            for indx in range(slicedTallies.shape[1]):
+                scratch = divide(slicedTallies[:, indx], lethBins)
+                slicedTallies[:, indx] = scratch / scratch.max()
+
+        if steps:
+            if 'drawstyle' in kwargs:
+                debug('Defaulting to drawstyle specified in kwargs as {}'
+                      .format(kwargs['drawstyle']))
+            else:
+                kwargs['drawstyle'] = 'steps-post'
+
+        if sigma:
+            slicedErrors = sigma * self.slice(fixed, 'errors').copy()
+            slicedErrors = slicedErrors.reshape(slicedTallies.shape)
+            slicedErrors *= slicedTallies
+        else:
+            slicedErrors = None
+        ax = plot(lowerE, slicedTallies, ax=ax, labels=labels,
+                  yerr=slicedErrors, **kwargs)
+        if ylabel is None:
+            ylabel = 'Tally data'
+            ylabel += ' normalized per unit lethargy' if normalize else ''
+            ylabel += r' $\pm{}\sigma$'.format(sigma) if sigma else ''
+
+        if legend is None and labels:
+            legend = True
+        ax = formatPlot(ax, loglog=loglog, logx=logx, ncol=ncol,
+                        xlabel=xlabel or "Energy [MeV]", ylabel=ylabel,
+                        legend=legend, title=title)
+        return ax
+
+    @magicPlotDocDecorator
+    def plot(self, xdim=None, what='tallies', sigma=None, fixed=None, ax=None,
+             xlabel=None, ylabel=None, steps=False, labels=None, logx=False,
+             logy=False, loglog=False, legend=None, ncol=1, title=None,
+             **kwargs):
+        """
+        Simple plot routine for 1- or 2-D data
+
+        Parameters
+        ----------
+        xdim: str, optional
+            Plot the data corresponding to changing this bin,
+            e.g. ``"energy"``. Must exist in :attr:`indexes`
+        what: {'tallies', 'errors'}
+            Primary data to plot
+        {sigma}
+        fixed: None or dict
+            Dictionary controlling the reduction in data down to one dimension
+        {ax}
+        {xlabel} If ``xdim`` is given and ``xlabel`` is ``None``, then
+            ``xdim`` will be applied to the x-axis.
+        {ylabel}
+        steps: bool
+            If true, plot the data as constant inside the respective bins.
+            Sets ``drawstyle`` to be ``steps-post`` unless ``drawstyle``
+            given in ``kwargs``
+        {labels}
+        {logx}
+        {logy}
+        {loglog}
+        {legend}
+        {ncol}
+        {title}
+        {kwargs} :py:func:`~matplotlib.pyplot.plot` or
+            :py:func:`~matplotlib.pyplot.errorbar` function.
+
+        Returns
+        -------
+        {rax}
+
+        Raises
+        ------
+        :class:`~serpentTools.SerpentToolsException`
+            If data contains more than 2 dimensions
+        AttributeError
+            If plot data or :attr:`indexes` set up.
+
+        See Also
+        --------
+        * :meth:`slice`
+        * :meth:`spectrumPlot`
+          better options for plotting energy spectra
+        """
+
+        if xdim is not None and fixed and self.indexes is None:
+            raise AttributeError(
+                "indexes not setup. Unsure how to slice and plot")
+
+        if sigma and what == "errors":
+            raise ValueError("Refusing to plot error bars on uncertainties")
+
+        data = self.slice(fixed, what)
+        if len(data.shape) > 2:
+            raise SerpentToolsException(
+                'Data must be constrained to 1- or 2-D, not {}'
+                .format(data.shape))
+        elif len(data.shape) == 1:
+            data = data.reshape(data.size, 1)
+
+        if sigma:
+            yerr = (self.slice(fixed, 'errors').reshape(data.shape)
+                    * data * sigma)
+        else:
+            yerr = None
+
+        xdata, autoX = self._getPlotXData(xdim, data)
+        xlabel = xlabel or autoX
+        ylabel = ylabel or "Tally data"
+        ax = ax or gca()
+
+        if steps:
+            kwargs.setdefault("drawstyle", "steps-post")
+
+        ax = plot(xdata, data, ax, labels, yerr, **kwargs)
+
+        if legend is None and labels:
+            legend = True
+
+        ax = formatPlot(ax, loglog=loglog, logx=logx, logy=logy, ncol=ncol,
+                        xlabel=xlabel, ylabel=ylabel, legend=legend,
+                        title=title)
+        return ax
+
+    @magicPlotDocDecorator
+    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
+                 cmap=None, cbarLabel=None, logColor=False, xlabel=None,
+                 ylabel=None, logx=False, logy=False, loglog=False,
+                 title=None, thresh=None, **kwargs):
+        """
+        Plot tally data as a function of two bin types on a cartesian mesh.
+
+        Parameters
+        ----------
+        xdim: str
+            Primary dimension - will correspond to x-axis on plot
+        ydim: str
+            Secondary dimension - will correspond to y-axis on plot
+        what: {'tallies', 'errors'}
+            Color meshes from tally data or uncertainties
+        fixed: None or dict
+            Dictionary controlling the reduction in data down to one dimension
+        {ax}
+        {cmap}
+        logColor: bool
+            If true, apply a logarithmic coloring to the data positive
+            data
+        {xlabel}
+        {ylabel}
+        {logx}
+        {logy}
+        {loglog}
+        {title}
+        {mthresh}
+        cbarLabel: str
+            Label to apply to colorbar. If not given, infer from ``what``
+        {kwargs} :py:func:`~matplotlib.pyplot.pcolormesh`
+
+        Returns
+        -------
+        {rax}
+
+        Raises
+        ------
+        :class:`serpentTools.SerpentToolsException`
+            If data to be plotted, with or without constraints, is not 1D
+        KeyError
+            If ``fixed`` is given and ``xdim`` or ``ydim`` are contained
+            in ``fixed``
+        AttributeError
+            If the data set by ``what`` not in the allowed selection
+        ValueError
+            If the data contains negative quantities and ``logColor`` is
+            ``True``
+
+        See Also
+        --------
+        * :meth:`slice`
+        * :func:`matplotlib.pyplot.pcolormesh`
+        """
+        if fixed:
+            if xdim in fixed:
+                raise KeyError("Cannot constrain {} and use as x data for "
+                               "plot".format(xdim))
+            if ydim in fixed:
+                raise KeyError("Cannot constrain {} and use as y data for "
+                               "plot".format(ydim))
+        data = self.slice(fixed, what)
+        if len(data.shape) != 2:
+            raise SerpentToolsException(
+                'Data must be 2D for mesh plot, currently is {}.\nConstraints:'
+                '{}'.format(data.shape, fixed)
+            )
+        xgrid = self._getPlotGrid(xdim)
+        ygrid = self._getPlotGrid(ydim)
+        if data.shape != (ygrid.size - 1, xgrid.size - 1):
+            data = data.T
+        if cbarLabel is None:
+            cbarLabel = self._CBAR_LABELS[what]
+        ax = cartMeshPlot(
+            data, xgrid, ygrid, ax, cmap, logColor,
+            cbarLabel=cbarLabel, thresh=thresh, **kwargs)
+        if xlabel is None:
+            xlabel = DETECTOR_PLOT_LABELS.get(xdim, xdim)
+        if ylabel is None:
+            ylabel = DETECTOR_PLOT_LABELS.get(ydim, ydim)
+        ax = formatPlot(ax, loglog=loglog, logx=logx, logy=logy,
+                        xlabel=xlabel, ylabel=ylabel,
+                        title=title)
+        return ax
+
+    def _gather_matlab(self, reconvert):
+        """Gather bins and grids for exporting to matlab"""
+
+        converter = deconvert if reconvert else prepToMatlab
+
+        data = {
+            converter(self.name, 'bins'): self.bins,
+        }
+
+        for key, value in iteritems(self.grids):
+            data[converter(self.name, key)] = value
+
+        return data
+
+
+Detector.toMatlab = matlabHook
+
+
+class CartesianDetector(Detector):
+    """Class for storing detector data with Cartesian grid
+
+    If simply the tally bins are available, it is recommended
+    to use the :meth:`fromTallyBins` class method. This will
+    reshape the data and separate the mean tally [second to last
+    column] and relative errors [last column].
+
+    .. note::
+
+        In order to get full functionality from this class,
+        :attr:`x`, :attr:`y`, and :attr:`z` must be set.
+        All grids are expected to be ``(N, 3)`` arrays, not
+        necessarily of equal shape.
+
+    Parameters
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : dict or None
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``. Optional
+    x : numpy.ndarray, optional
+        Directly set the x grid
+    y : numpy.ndarray, optional
+        Directly set the y grid
+    z : numpy.ndarray, optional
+        Directly set the z grid
+    grids : dict, optional
+        Supplemental grids that may be supplied to this detector,
+        including energy points or spatial coordinates. If spatial
+        grids are not provided directly with the ``x``, ``y``, or
+        ``z`` arguments, the grids will be pulled from this dictionary
+        in the following manner.
+
+        * Key ``"X"`` denotes the :attr:`x` grid
+        * Key ``"Y"`` denotes the :attr:`y` grid
+        * Key ``"Z"`` denotes the :attr:`z` grid
+
+        If the keys are not present, or the grids are directly provided,
+        no actions are taken.
+
+    Attributes
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray or None
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray or None
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray or None
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : dict
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``.
+    energy : numpy.ndarray or None
+        Potential underlying energy grid in MeV. Will be ``(n_ene, 3)``, where
+        ``n_ene`` is the number of values in the energy grid. Each
+        row ``energy[j]`` will be the low point, high point, and mid point
+        of the energy bin ``j``.
+    x : numpy.ndarray or None
+        X grid
+    y : numpy.ndarray or None
+        Y grid
+    z : numpy.ndarray or None
+        Z grid
+
+    Raises
+    ------
+    ValueError
+        If the values for ``x``, ``y``, and ``z`` are not 2D arrays
+        with 3 columns
+    """
+
+    def __init__(self, name, bins=None, tallies=None, errors=None,
+                 indexes=None, grids=None, x=None, y=None, z=None):
+        Detector.__init__(self, name, bins, tallies, errors, indexes, grids)
+        self._x = None
+        self._y = None
+        self._z = None
+        x = x if x is not None else self.grids.get("X")
+        y = y if y is not None else self.grids.get("Y")
+        z = z if z is not None else self.grids.get("Z")
+        if x is not None:
+            self.x = x
+        if y is not None:
+            self.y = y
+        if z is not None:
+            self.z = z
+
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        value = asfortranarray(value)
+        if self._x is None:
+            if len(value.shape) != 2 or value.shape[1] != 3:
+                raise ValueError(
+                    "Expected shape of x grid to be (N, 3), not {}".format(
+                        value.shape))
+        elif value.shape != self._x.shape:
+            raise ValueError(
+                "Expected shape of x grid to be {}, not {}".format(
+                    value.shape, self.x.shape))
+        self._x = value
+
+    @property
+    def y(self):
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        value = asfortranarray(value)
+        if self._y is None:
+            if len(value.shape) != 2 or value.shape[1] != 3:
+                raise ValueError(
+                    "Expected shape of y grid to be (N, 3), not {}".format(
+                        value.shape))
+        elif value.shape != self._y.shape:
+            raise ValueError(
+                "Expected shape of y grid to be {}, not {}".format(
+                    value.shape, self.y.shape))
+        self._y = value
+
+    @property
+    def z(self):
+        return self._z
+
+    @z.setter
+    def z(self, value):
+        value = asfortranarray(value)
+        if self._z is None:
+            if len(value.shape) != 2 or value.shape[1] != 3:
+                raise ValueError(
+                    "Expected shape of z grid to be (N, 3), not {}".format(
+                        value.shape))
+        elif value.shape != self._z.shape:
+            raise ValueError(
+                "Expected shape of z grid to be {}, not {}".format(
+                    value.shape, self.z.shape))
+        self._z = value
+
+    @magicPlotDocDecorator
+    def meshPlot(self, xdim='x', ydim='y', what='tallies', fixed=None, ax=None,
+                 cmap=None, cbarLabel=None, logColor=False, xlabel=None,
+                 ylabel=None, logx=False, logy=False, loglog=False,
+                 title=None, thresh=None, **kwargs):
+        """
+        Plot tally data as a function of two bin types on a cartesian mesh.
+
+        Parameters
+        ----------
+        xdim: str
+            Primary dimension - will correspond to x-axis on plot. Defaults
+            to "x"
+        ydim: str
+            Secondary dimension - will correspond to y-axis on plot. Defaults
+            to "y"
+        what: {'tallies', 'errors'}
+            Color meshes from tally data or uncertainties
+        fixed: None or dict
+            Dictionary controlling the reduction in data down to one dimension
+        {ax}
+        {cmap}
+        logColor: bool
+            If true, apply a logarithmic coloring to the data positive
+            data
+        {xlabel}
+        {ylabel}
+        {logx}
+        {logy}
+        {loglog}
+        {title}
+        {mthresh}
+        cbarLabel: str
+            Label to apply to colorbar. If not given, infer from ``what``
+        {kwargs} :py:func:`~matplotlib.pyplot.pcolormesh`
+
+        Returns
+        -------
+        {rax}
+
+        Raises
+        ------
+        :class:`serpentTools.SerpentToolsException`
+            If data to be plotted, with or without constraints, is not 1D
+        KeyError
+            If ``fixed`` is given and ``xdim`` or ``ydim`` are contained
+            in ``fixed``
+        AttributeError
+            If the data set by ``what`` not in the allowed selection
+        ValueError
+            If the data contains negative quantities and ``logColor`` is
+            ``True``
+
+        See Also
+        --------
+        * :meth:`slice`
+        * :func:`matplotlib.pyplot.pcolormesh`
+        """
+        Detector.meshPlot(
+            self, xdim=xdim, ydim=ydim, what=what, fixed=fixed, ax=ax,
+            cmap=cmap, cbarLabel=cbarLabel, logColor=logColor, xlabel=xlabel,
+            ylabel=ylabel, logx=logx, logy=logy, loglog=loglog,
+            title=title, thresh=thresh, **kwargs)
+
+    def _getPlotGrid(self, qty):
+        if qty is not None and hasattr(self, qty[0]):
+            grid = getattr(self, qty[0])
+            if grid is not None:
+                return hstack((grid[:, 0], grid[-1, 1]))
+            raise AttributeError("{} not set".format(qty[0], stacklevel=2))
+        return Detector._getPlotGrid(self, qty)
+
+    def _getPlotXData(self, qty, ydata):
+        if qty is not None and hasattr(self, qty[0]):
+            grid = getattr(self, qty[0])
+            if grid is not None:
+                return grid[:, 0], DETECTOR_PLOT_LABELS.get(qty, "Bin Index")
+            raise AttributeError("{} not set".format(qty[0], stacklevel=2))
+        return Detector._getPlotXData(self, qty, ydata)
+
+
+class HexagonalDetector(Detector):
+    """Class for storing detector data with a hexagonal grid
+
+    If simply the tally bins are available, it is recommended
+    to use the :meth:`fromTallyBins` class method. This will
+    reshape the data and separate the mean tally [second to last
+    column] and relative errors [last column].
+
+    .. note::
+
+        In order to get full functionality from this class,
+        :attr:`z`, :attr:`centers`, :attr:`pitch`, and :attr:`hexType`
+        must be set.  This can be done by having ``"Z"`` and
+        ``"COORDS"`` as keys in ``grids`` and passing ``pitch`` and
+        ``hexType`` directly, or by setting the attributes directly.
+        Z grid is expected to be ``(N, 3)`` array.
+
+    Parameters
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray, optional
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray, optional
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray, optional
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : dict, optional
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``
+    centers : numpy.ndarray, optional
+        ``(N, 2)`` array with centers of each hexagonal element
+    pitch : float, optional
+        Center to center distance between adjacent hexagons
+    hexType : {2, 3}, optional
+        Integer orientation, identical to Serpent detector structure. 2
+        corresponds to a hexagon with flat faces perpendicular to y-axis.
+        3 corresponds to a flat faces perpendicular to x-axis
+    grids : dict, optional
+        Supplemental grids that may be supplied to this detector,
+        including energy points or spatial coordinates.
+
+    Attributes
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray or None
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray or None
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    pitch : float or None
+        Center to center distance between hexagons. Must be set before
+        calling :meth:`hexPlot`
+    hexType : {2, 3} or None
+        Integer orientation, identical to Serpent detector structure. 2
+        corresponds to a hexagon with flat faces perpendicular to y-axis.
+        3 corresponds to a flat faces perpendicular to x-axis
+    errors : numpy.ndarray or None
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : dict or None
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``.
+    energy : numpy.ndarray or None
+        Potential underlying energy grid in MeV. Will be ``(n_ene, 3)``, where
+        ``n_ene`` is the number of values in the energy grid. Each
+        row ``energy[j]`` will be the low point, high point, and mid point
+        of the energy bin ``j``.
+    coords: numpy.ndarray or None
+        Centers of hexagonal meshes in XY plane
+    z : numpy.ndarray or None
+        Z Grid
+
+    """
+
+    DET_COLS = (
+        'value', 'time', 'energy', 'universe', 'cell', 'material', 'lattice',
+        'reaction', 'zmesh', 'ycoord', 'xcoord', 'tally', 'error')
+
+    def __init__(self, name, bins=None, tallies=None, errors=None,
+                 indexes=None, z=None, centers=None, pitch=None, hexType=None,
+                 grids=None):
+
+        Detector.__init__(self, name, bins, tallies, errors, indexes, grids)
+
+        if pitch is not None:
+            self.pitch = pitch
+        else:
+            self._pitch = None
+
+        if hexType is not None:
+            self.hexType = hexType
+        else:
+            self._hexType = None
+
+        self._z = None
+        self._centers = None
+
+        z = z if z is not None else self.grids.get("Z")
+        if z is not None:
+            self.z = z
+
+        centers = centers if centers is not None else self.grids.get("COORD")
+        if centers is not None:
+            self.centers = centers
+
+    @property
+    def z(self):
+        return self._z
+
+    @z.setter
+    def z(self, value):
+        value = asfortranarray(value)
+        if self._z is None:
+            if len(value.shape) != 2 or value.shape[1] != 3:
+                raise ValueError(
+                    "Expected shape of z grid to be (N, 3), not {}".format(
+                        value.shape))
+        elif value.shape != self._z.shape:
+            raise ValueError(
+                "Expected shape of z grid to be {}, not {}".format(
+                    value.shape, self.z.shape))
+        self._z = value
+
+    @property
+    def pitch(self):
+        return self._pitch
+
+    @pitch.setter
+    def pitch(self, value):
+        if isinstance(value, Real):
+            if value <= 0:
+                raise ValueError("Pitch must be positive")
+        else:
+            raise TypeError(
+                "Cannot set pitch to {}. Must be positive value".format(
+                    type(value)))
+        self._pitch = value
+
+    @property
+    def hexType(self):
+        return self._hexType
+
+    @hexType.setter
+    def hexType(self, value):
+        if value not in {2, 3}:
+            raise ValueError(
+                "Hex type must be 2 or 3, not {}".format(value))
+        self._hexType = value
+
+    @property
+    def centers(self):
+        return self._centers
+
+    @centers.setter
+    def centers(self, value):
+        value = asarray(value)
+
+        if self._centers is None:
+            if len(value.shape) != 2 or value.shape[1] != 2:
+                raise ValueError(
+                    "Expected centers to have shape (N, 2), got {}".format(
+                        value.shape))
+        else:
+            if value.shape != self._centers.shape:
+                raise ValueError(
+                    "Expected centers to have shape {}, got {}".format(
+                        self._centers.shape, value.shape))
+        self._centers = value
+
+    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
+                 cmap=None, logColor=False, xlabel=None, ylabel=None,
+                 logx=False, logy=False, loglog=False, title=None, **kwargs):
+        opts = dict(what=what,
+                    fixed=fixed,
+                    ax=ax,
+                    cmap=cmap,
+                    logColor=logColor,
+                    xlabel=xlabel,
+                    logx=logx,
+                    logy=logy,
+                    loglog=loglog,
+                    title=title,
+                    **kwargs)
+        if any(arg in {"ycoord", "xcoord"} for arg in (xdim, ydim)):
+            warn("Use hexPlot if plotting xcoord vs ycoord")
+            return self.hexPlot(**opts)
+        return Detector.meshPlot(self, xdim, ydim, **opts)
+
+    meshPlot.__doc__ = Detector.meshPlot.__doc__
+
+    @magicPlotDocDecorator
+    def hexPlot(self, what='tallies', fixed=None, ax=None, cmap=None,
+                logColor=False, xlabel=None, ylabel=None, logx=False,
+                logy=False, loglog=False, title=None, normalizer=None,
+                cbarLabel=None, borderpad=2.5, **kwargs):
+        """
+        Create and return a hexagonal mesh plot.
+
+        Parameters
+        ----------
+        what: {'tallies', 'errors'}
+            Quantity to plot
+        fixed: None or dict
+            Dictionary of slicing arguments to pass to :meth:`slice`
+        {ax}
+        {cmap}
+        {logColor}
+        {xlabel}
+        {ylabel}
+        {logx}
+        {logy}
+        {loglog}
+        {title}
+        borderpad: int or float
+            Percentage of total plot to apply as a border. A value of
+            zero means that the extreme edges of the hexagons will touch
+            the x and y axis.
+        {kwargs} :class:`matplotlib.patches.RegularPolygon`
+
+        Raises
+        ------
+        AttributeError
+            If :attr:`pitch` and :attr:`hexType` are not set.
+        """
+        if self.centers is None or self.pitch is None or self.hexType is None:
+            raise AttributeError("centers, pitch, and hexType not set")
+
+        if fixed and ('xcoord' in fixed or 'ycoord' in fixed):
+            raise KeyError("Refusing to restrict along one of the hexagonal "
+                           "dimensions {x/y}coord")
+
+        if not isinstance(borderpad, Real) or borderpad < 0:
+            raise ValueError(
+                "borderpad should be postive, not {}".format(borderpad))
+
+        kwargs.setdefault("ec", "k")
+        kwargs.setdefault("edgecolor", "k")
+        alpha = kwargs.get('alpha')
+
+        data = self.slice(fixed, what)
+
+        ny = getattr(self, what).shape[self.indexes.index("ycoord")]
+        nx = getattr(self, what).shape[self.indexes.index("xcoord")]
+
+        if data.shape != (ny, nx):
+            raise IndexError("Constrained data does not agree with hexagonal "
+                             "grid structure. Coordinate grid: {}. "
+                             "Constrained shape: {}"
+                             .format((ny, nx), data.shape))
+
+        patches = empty(ny * nx, dtype=object)
+        values = empty(ny * nx)
+        coords = self.centers
+
+        ax = ax or gca()
+        xmax, ymax = [-inf, ] * 2
+        xmin, ymin = [inf, ] * 2
+        radius = self.pitch / sqrt(3)
+        rotation = 0 if self.hexType == 2 else (pi / 2)
+
+        for pos, (xy, val) in enumerate(zip(coords, data.flat)):
+            values[pos] = val
+            h = RegularPolygon(xy, 6, radius, rotation, **kwargs)
+            verts = h.get_verts()
+            vmins = verts.min(0)
+            vmaxs = verts.max(0)
+            xmax = max(xmax, vmaxs[0])
+            xmin = min(xmin, vmins[0])
+            ymax = max(ymax, vmaxs[1])
+            ymin = min(ymin, vmins[1])
+            patches[pos] = h
+
+        normalizer = normalizerFactory(values, normalizer, logColor,
+                                       coords[:, 0], coords[:, 1])
+        pc = PatchCollection(patches, cmap=cmap, alpha=alpha)
+        pc.set_array(values)
+        pc.set_norm(normalizer)
+        ax.add_collection(pc)
+
+        addColorbar(ax, pc, None, cbarLabel)
+
+        formatPlot(ax, loglog=loglog, logx=logx, logy=logy,
+                   xlabel=xlabel or "X [cm]",
+                   ylabel=ylabel or "Y [cm]", title=title)
+
+        setAx_xlims(ax, xmin, xmax, pad=borderpad)
+        setAx_ylims(ax, ymin, ymax, pad=borderpad)
+
+        return ax
+
+
+class CylindricalDetector(Detector):
+    """Class for storing detector data with a cylindrical mesh
+
+    If simply the tally bins are available, it is recommended
+    to use the :meth:`fromTallyBins` class method. This will
+    reshape the data and separate the mean tally [second to last
+    column] and relative errors [last column].
+
+    Parameters
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray, optional
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray, optional
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray, optional
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : collections.OrderedDict, optinal
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``
+    grids : dict, optional
+        Supplemental grids that may be supplied to this detector,
+        including energy points or spatial coordinates.
+
+    Attributes
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : collections.OrderedDict
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``.
+    energy : numpy.ndarray or None
+        Potential underlying energy grid in MeV. Will be ``(n_ene, 3)``, where
+        ``n_ene`` is the number of values in the energy grid. Each
+        row ``energy[j]`` will be the low point, high point, and mid point
+        of the energy bin ``j``.
+
+    """
+
+    # column indices in full (time-bin included) bins matrix
+    DET_COLS = (
+        'value', 'time', 'energy', 'universe', 'cell', 'material', 'lattice',
+        'reaction', 'zmesh', 'phi', 'rmesh', 'tally', 'error')
+
+    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
+                 cmap=None, logColor=False, xlabel=None, ylabel=None,
+                 logx=False, logy=False, loglog=False, title=None, **kwargs):
+        if any(arg in {"rmesh", "phi"} for arg in (xdim, ydim)):
+            warn("Cylindrical plotting is not fully supported. See GitHub "
+                 "issue 169")
+        return Detector.meshPlot(
+            self, xdim, ydim, what=what, fixed=fixed, ax=ax, cmap=cmap,
+            logColor=logColor, xlabel=xlabel, logx=logx, logy=logy,
+            loglog=loglog, title=title, **kwargs)
+
+    meshPlot.__doc__ = Detector.meshPlot.__doc__
+
+
+class SphericalDetector(Detector):
+    """Class for storing detector data with multiple bins
+
+    If simply the tally bins are available, it is recommended
+    to use the :meth:`fromTallyBins` class method. This will
+    reshape the data and separate the mean tally [second to last
+    column] and relative errors [last column].
+
+    Parameters
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : dict
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``. Optional
+    grids : dict
+        Supplemental grids that may be supplied to this detector,
+        including energy points or spatial coordinates.
+
+    Attributes
+    ----------
+    name : str
+        Name of this detector
+    bins : numpy.ndarray
+        Full 2D tally data from detector file, including tallies and
+        errors in last two columns
+    tallies : numpy.ndarray
+        Reshaped tally data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin.
+    errors : numpy.ndarray
+        Reshaped error data such that each dimension corresponds
+        to a unique bin, such as energy or spatial bin. Note:
+        this is a relative error as it would appear in the
+        output file
+    indexes : dict
+        Dictionary mapping the bin name to its corresponding
+        axis in :attr:`tallies` and :attr:`errors`, e.g.
+        ``{"energy": 0}``.
+    energy : numpy.ndarray or None
+        Potential underlying energy grid in MeV. Will be ``(n_ene, 3)``, where
+        ``n_ene`` is the number of values in the energy grid. Each
+        row ``energy[j]`` will be the low point, high point, and mid point
+        of the energy bin ``j``.
+    """
+
+    DET_COLS = (
+        'value', 'time', 'energy', 'universe', 'cell', 'material', 'lattice',
+        'reaction', 'theta', 'phi', 'rmesh', 'tally', 'error')
+
+    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
+                 cmap=None, logColor=False, xlabel=None, ylabel=None,
+                 logx=False, logy=False, loglog=False, title=None, **kwargs):
+        if any(arg in {"theta", "phi", "rmesh"} for arg in (xdim, ydim)):
+            warn("Spherical mesh plotting is not fully supported.")
+        return Detector.meshPlot(
+            self, xdim, ydim, what=what, fixed=fixed, ax=ax, cmap=cmap,
+            logColor=logColor, xlabel=xlabel, logx=logx, logy=logy,
+            loglog=loglog, title=title, **kwargs)
+
+    meshPlot.__doc__ = Detector.meshPlot.__doc__
+
+
+def detectorFactory(name, bins, grids=None):
+    grids = {} if grids is None else grids
+    if "X" in grids:
+        detClass = CartesianDetector
+    elif "COORD" in grids:
+        detClass = HexagonalDetector
+    elif "R" in grids:
+        detClass = CylindricalDetector if "Z" in grids else SphericalDetector
+    else:
+        # fall back to base detector
+        detClass = Detector
+    return detClass.fromTallyBins(name, bins, grids)
+
+
+def deconvert(detectorName, quantity):
+    """Restore the original name of the detector data"""
+    return "DET{}{}".format(
+        detectorName, "" if quantity == "bins" else quantity)
+
+
+def prepToMatlab(detectorName, quantity):
+    """Create a name of a variable for MATLAB"""
+    return detectorName + "_" + quantity
diff --git a/serpentTools/objects/__init__.py b/serpentTools/objects/__init__.py
index 10e3fb5..1cd0130 100644
--- a/serpentTools/objects/__init__.py
+++ b/serpentTools/objects/__init__.py
@@ -2,5 +2,4 @@
 # flake8: noqa
 from serpentTools.objects.materials import *
 from serpentTools.objects.containers import *
-from serpentTools.objects.detectors import *
 from serpentTools.objects.xsdata import *
diff --git a/serpentTools/objects/base.py b/serpentTools/objects/base.py
index 66116f7..414d934 100644
--- a/serpentTools/objects/base.py
+++ b/serpentTools/objects/base.py
@@ -1,27 +1,16 @@
 """
 Collection of base classes from which other objects inherit.
 """
-from abc import ABCMeta, abstractmethod
-
-from six import add_metaclass
-
-from numpy import arange, hstack, log, divide
-from matplotlib.pyplot import gca
 
 from serpentTools.messages import (
-    debug, warning, SerpentToolsException, info,
-    error,
-    BAD_OBJ_SUBJ,
-
+    warning, info,
 )
-from serpentTools.plot import plot, cartMeshPlot
 from serpentTools.utils import (
-    magicPlotDocDecorator, formatPlot, DETECTOR_PLOT_LABELS,
     compareDocDecorator, DEF_COMP_LOWER, DEF_COMP_SIGMA,
-    DEF_COMP_UPPER, compareDictOfArrays,
+    DEF_COMP_UPPER
 )
 from serpentTools.utils.compare import (
-    getLogOverlaps, finalCompareMsg,
+    finalCompareMsg,
 )
 from serpentTools.settings import rc
 
@@ -143,452 +132,8 @@ class NamedObject(BaseObject):
     """Class for named objects like materials and detectors."""
 
     def __init__(self, name):
+        BaseObject.__init__(self)
         self.name = name
 
     def __str__(self):
         return '<{} {}>'.format(self.__class__.__name__, self.name)
-
-
-@add_metaclass(ABCMeta)
-class DetectorBase(NamedObject):
-    """
-    Base class for classes that store detector data
-
-    Parameters
-    ----------
-    {params:s}
-
-    Attributes
-    ----------
-    {attrs:s}
-    """
-
-    _CBAR_LABELS = {
-        'tallies': 'Tally data',
-        'errors': 'Relative Uncertainty',
-        'scores': 'Tally scores',
-    }
-
-    baseParams = """name: str
-        Name of this detector"""
-    baseAttrs = """grids: dict
-        Dictionary with additional data describing energy grids or mesh points
-    tallies: None, float, or {np}
-        Reshaped tally data to correspond to the bins used
-    errors: None, float, or {np}
-        Reshaped relative error data corresponding to bins used
-    scores: None, float, or {np}
-        Reshaped array of tally scores. SERPENT 1 only
-    indexes: None or :class:`collections.OrderedDict`
-        Collection of unique indexes for each requested bin
-    """.format(np=':class:`numpy.ndarray`') + baseParams
-    __doc__ = __doc__.format(params=baseParams, attrs=baseAttrs)
-
-    def __init__(self, name):
-        NamedObject.__init__(self, name)
-        self.tallies = None
-        self.errors = None
-        self.scores = None
-        self.grids = {}
-        self.indexes = None
-        self._map = None
-
-    @abstractmethod
-    def _isReshaped(self):
-        raise NotImplementedError
-
-    def slice(self, fixed, data='tallies'):
-        """
-        Return a view of the reshaped array where certain axes are fixed
-
-        Parameters
-        ----------
-        fixed: dict
-            dictionary to aid in the restriction on the multidimensional
-            array. Keys correspond to the various grids present in
-            ``indexes`` while the values are used to
-        data: {'tallies', 'errors', 'scores'}
-            Which data set to slice
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            View into the respective data where certain dimensions
-            have been removed
-
-        Raises
-        ------
-        :class:`~serpentTools.SerpentToolsException`
-            If the data has not been reshaped or is None [e.g. scores]
-        KeyError
-            If the data set to slice not in the allowed selection
-
-        """
-        if not self._isReshaped():
-            raise SerpentToolsException(
-                'Slicing requires detector to be reshaped')
-        if data not in self._map:
-            raise KeyError(
-                'Data argument {} not in allowed options'
-                '\n{}'.format(data, ', '.join(self._map.keys())))
-        work = self._map[data]
-        if work is None:
-            raise SerpentToolsException(
-                '{} data for detector {} is None. '
-                'Cannot perform slicing'.format(data, self.name))
-        if not fixed:
-            return work
-        return work[self._getSlices(fixed)]
-
-    def _getSlices(self, fixed):
-        """
-        Return a list of slice operators for each axis in reshaped data
-
-        Parameters
-        ----------
-        fixed: dict
-            Dictionary where keys are strings pointing to dimensions in
-        """
-        fixed = fixed if fixed is not None else {}
-        keys = set(fixed.keys())
-        slices = tuple()
-        for key in self.indexes:
-            if key in keys:
-                slices += fixed[key],
-                keys.remove(key)
-            else:
-                slices += slice(0, len(self.indexes[key])),
-        if any(keys):
-            warning(
-                'Could not find arguments in index that match the following'
-                ' requested slice keys: {}'.format(', '.join(keys)))
-        return slices
-
-    @magicPlotDocDecorator
-    def spectrumPlot(self, fixed=None, ax=None, normalize=True, xlabel=None,
-                     ylabel=None, steps=True, logx=True, logy=False,
-                     loglog=False, sigma=3, labels=None, legend=None, ncol=1,
-                     title=None, **kwargs):
-        """
-        Quick plot of the detector value as a function of energy.
-
-        Parameters
-        ----------
-        fixed: None or dict
-            Dictionary controlling the reduction in data
-        {ax}
-        normalize: bool
-            Normalize quantities per unit lethargy
-        {xlabel}
-        {ylabel}
-        steps: bool
-            Plot tally as constant inside bin
-        {logx}
-        {logy}
-        {loglog}
-        {sigma}
-        {labels}
-        {legend}
-        {ncol}
-        {title}
-        {kwargs} :py:func:`matplotlib.pyplot.plot` or
-            :py:func:`matplotlib.pyplot.errorbar`
-
-        Returns
-        -------
-        {rax}
-
-        Raises
-        ------
-        :class:`~serpentTools.SerpentToolsException`
-            if number of rows in data not equal to
-            number of energy groups
-
-        See Also
-        --------
-        * :meth:`slice`
-        """
-        slicedTallies = self.slice(fixed, 'tallies').copy()
-        if len(slicedTallies.shape) > 2:
-            raise SerpentToolsException(
-                'Sliced data cannot exceed 2-D for spectrum plot, not '
-                '{}'.format(slicedTallies.shape)
-            )
-        elif len(slicedTallies.shape) == 1:
-            slicedTallies = slicedTallies.reshape(slicedTallies.size, 1)
-        lowerE = self.grids['E'][:, 0]
-        if normalize:
-            lethBins = log(
-                divide(self.grids['E'][:, -1], lowerE))
-            for indx in range(slicedTallies.shape[1]):
-                scratch = divide(slicedTallies[:, indx], lethBins)
-                slicedTallies[:, indx] = scratch / scratch.max()
-
-        if steps:
-            if 'drawstyle' in kwargs:
-                debug('Defaulting to drawstyle specified in kwargs as {}'
-                      .format(kwargs['drawstyle']))
-            else:
-                kwargs['drawstyle'] = 'steps-post'
-
-        if sigma:
-            slicedErrors = sigma * self.slice(fixed, 'errors').copy()
-            slicedErrors = slicedErrors.reshape(slicedTallies.shape)
-            slicedErrors *= slicedTallies
-        else:
-            slicedErrors = None
-        ax = plot(lowerE, slicedTallies, ax=ax, labels=labels,
-                  yerr=slicedErrors, **kwargs)
-        if ylabel is None:
-            ylabel = 'Tally data'
-            ylabel += ' normalized per unit lethargy' if normalize else ''
-            ylabel += r' $\pm{}\sigma$'.format(sigma) if sigma else ''
-
-        if legend is None and labels:
-            legend = True
-        ax = formatPlot(ax, loglog=loglog, logx=logx, ncol=ncol,
-                        xlabel=xlabel or "Energy [MeV]", ylabel=ylabel,
-                        legend=legend, title=title)
-        return ax
-
-    @magicPlotDocDecorator
-    def plot(self, xdim=None, what='tallies', sigma=None, fixed=None, ax=None,
-             xlabel=None, ylabel=None, steps=False, labels=None, logx=False,
-             logy=False, loglog=False, legend=None, ncol=1, title=None,
-             **kwargs):
-        """
-        Simple plot routine for 1- or 2-D data
-
-        Parameters
-        ----------
-        xdim: None or str
-            If not None, use the array under this key in ``indexes`` as
-            the x axis
-        what: {'tallies', 'errors', 'scores'}
-            Primary data to plot
-        {sigma}
-        fixed: None or dict
-            Dictionary controlling the reduction in data down to one dimension
-        {ax}
-        {xlabel} If ``xdim`` is given and ``xlabel`` is ``None``, then
-            ``xdim`` will be applied to the x-axis.
-        {ylabel}
-        steps: bool
-            If true, plot the data as constant inside the respective bins.
-            Sets ``drawstyle`` to be ``steps-post`` unless ``drawstyle``
-            given in ``kwargs``
-        {labels}
-        {logx}
-        {logy}
-        {loglog}
-        {legend}
-        {ncol}
-        {title}
-        {kwargs} :py:func:`~matplotlib.pyplot.plot` or
-            :py:func:`~matplotlib.pyplot.errorbar` function.
-
-        Returns
-        -------
-        {rax}
-
-        Raises
-        ------
-        :class:`~serpentTools.SerpentToolsException`
-            If data contains more than 2 dimensions
-
-        See Also
-        --------
-        * :meth:`slice`
-        * :meth:`spectrumPlot`
-          better options for plotting energy spectra
-        """
-
-        data = self.slice(fixed, what)
-        if len(data.shape) > 2:
-            raise SerpentToolsException(
-                'Data must be constrained to 1- or 2-D, not {}'
-                .format(data.shape))
-        elif len(data.shape) == 1:
-            data = data.reshape(data.size, 1)
-
-        if sigma:
-            if what != 'errors':
-                yerr = (self.slice(fixed, 'errors').reshape(data.shape)
-                        * data * sigma)
-            else:
-                warning(
-                    'Will not plot error bars on the error plot. Data to be '
-                    'plotted: {}.  Sigma: {}'.format(what, sigma))
-                yerr = None
-        else:
-            yerr = None
-
-        xdata, autoX = self._getPlotXData(xdim, data)
-        xlabel = xlabel or autoX
-        ylabel = ylabel or "Tally data"
-        ax = ax or gca()
-
-        if steps:
-            if 'drawstyle' in kwargs:
-                debug('Defaulting to drawstyle specified in kwargs as {}'
-                      .format(kwargs['drawstyle']))
-            else:
-                kwargs['drawstyle'] = 'steps-post'
-        ax = plot(xdata, data, ax, labels, yerr, **kwargs)
-
-        if legend is None and labels:
-            legend = True
-
-        ax = formatPlot(ax, loglog=loglog, logx=logx, logy=logy, ncol=ncol,
-                        xlabel=xlabel, ylabel=ylabel, legend=legend,
-                        title=title)
-        return ax
-
-    @magicPlotDocDecorator
-    def meshPlot(self, xdim='x', ydim='y', what='tallies', fixed=None, ax=None,
-                 cmap=None, cbarLabel=None, logColor=False, xlabel=None,
-                 ylabel=None, logx=False, logy=False, loglog=False,
-                 title=None, thresh=None, **kwargs):
-        """
-        Plot tally data as a function of two bin types on a cartesian mesh.
-
-        Parameters
-        ----------
-        xdim: str
-            Primary dimension - will correspond to x-axis on plot
-        ydim: str
-            Secondary dimension - will correspond to y-axis on plot
-        what: {'tallies', 'errors', 'scores'}
-            Color meshes from tally data, uncertainties, or scores
-        fixed: None or dict
-            Dictionary controlling the reduction in data down to one dimension
-        {ax}
-        {cmap}
-        logColor: bool
-            If true, apply a logarithmic coloring to the data positive
-            data
-        {xlabel}
-        {ylabel}
-        {logx}
-        {logy}
-        {loglog}
-        {title}
-        {mthresh}
-        cbarLabel: str
-            Label to apply to colorbar. If not given, infer from ``what``
-        {kwargs} :py:func:`~matplotlib.pyplot.pcolormesh`
-
-        Returns
-        -------
-        {rax}
-
-        Raises
-        ------
-        :class:`serpentTools.SerpentToolsException`
-            If data to be plotted, with or without constraints, is not 1D
-        KeyError
-            If the data set by ``what`` not in the allowed selection
-        ValueError
-            If the data contains negative quantities and ``logColor`` is
-            ``True``
-
-        See Also
-        --------
-        * :meth:`slice`
-        * :func:`serpentTools.plot.cartMeshPlot`
-        * :func:`matplotlib.pyplot.pcolormesh`
-        """
-        if fixed:
-            for qty, name in zip((xdim, ydim), ('x', 'y')):
-                if qty in fixed:
-                    raise SerpentToolsException(
-                        'Requested {} dimension {} is one of the axis to be '
-                        'constrained. '
-                        .format(name, qty))
-
-        data = self.slice(fixed, what)
-        dShape = data.shape
-        if len(dShape) != 2:
-            raise SerpentToolsException(
-                'Data must be 2D for mesh plot, currently is {}.\nConstraints:'
-                '{}'.format(dShape, fixed)
-            )
-        xgrid = self._getGrid(xdim)
-        ygrid = self._getGrid(ydim)
-        if data.shape != (ygrid.size - 1, xgrid.size - 1):
-            data = data.T
-        if cbarLabel is None:
-            cbarLabel = self._CBAR_LABELS[what]
-        ax = cartMeshPlot(
-            data, xgrid, ygrid, ax, cmap, logColor,
-            cbarLabel=cbarLabel, thresh=thresh, **kwargs)
-        if xlabel is None:
-            xlabel = DETECTOR_PLOT_LABELS.get(xdim, xdim)
-        if ylabel is None:
-            ylabel = DETECTOR_PLOT_LABELS.get(ydim, ydim)
-        ax = formatPlot(ax, loglog=loglog, logx=logx, logy=logy,
-                        xlabel=xlabel, ylabel=ylabel,
-                        title=title)
-        return ax
-
-    def _getGrid(self, qty):
-        grids = self._inGridsAs(qty)
-        if grids is not None:
-            lowBounds = grids[:, 0]
-            return hstack((lowBounds, grids[-1, 1]))
-        if qty not in self.indexes:
-            raise KeyError("No index {} found on detector. Bin indexes: {}"
-                           .format(qty, ', '.join(self.indexes.keys())))
-        bins = self.indexes[qty]
-        return hstack((bins, len(bins)))
-
-    def _dimInGrids(self, key):
-        return key[0].upper() in self.grids
-
-    def _inGridsAs(self, qty):
-        if self._dimInGrids(qty):
-            return self.grids[qty[0].upper()]
-        return None
-
-    def _getPlotXData(self, qty, ydata):
-        fallbackX = arange(len(ydata))
-        xlabel = DETECTOR_PLOT_LABELS.get(qty, 'Bin Index')
-        if qty is None:
-            return fallbackX, xlabel
-        xdata = self._inGridsAs(qty)
-        if xdata is not None:
-            return xdata[:, 0], xlabel
-        if qty in self.indexes:
-            return self.indexes[qty], xlabel
-        return fallbackX, xlabel
-
-    def _compare(self, other, lower, upper, sigma):
-        myShape = self.tallies.shape
-        otherShape = other.tallies.shape
-        if myShape != otherShape:
-            error("Detector tallies do not have identical shapes"
-                  + BAD_OBJ_SUBJ.format('tallies', myShape, otherShape))
-            return False
-        similar = compareDictOfArrays(self.grids, other.grids, 'grids',
-                                      lower=lower, upper=upper)
-
-        similar &= getLogOverlaps('tallies', self.tallies, other.tallies,
-                                  self.errors, other.errors, sigma,
-                                  relative=True)
-        hasScores = [obj.scores is not None for obj in (self, other)]
-
-        similar &= hasScores[0] == hasScores[1]
-
-        if not any(hasScores):
-            return similar
-        if all(hasScores):
-            similar &= getLogOverlaps('scores', self.scores, other.scores,
-                                      self.errors, other.errors, sigma,
-                                      relative=True)
-            return similar
-        firstK, secondK = "first", "second"
-        if hasScores[1]:
-            firstK, secondK = secondK, firstK
-        error("{} detector has scores while {} does not"
-              .format(firstK.capitalize(), secondK))
-        return similar
diff --git a/serpentTools/objects/detectors.py b/serpentTools/objects/detectors.py
index 3f3eccc..3b80328 100644
--- a/serpentTools/objects/detectors.py
+++ b/serpentTools/objects/detectors.py
@@ -1,583 +1,5 @@
-"""
-Module containing classes for storing detector data.
-
-``SERPENT`` is capable of producing detectors, or tallies from MCNP,
-with a variety of bin structures. These include, but are not limited to,
-material regions, reaction types, energy bins, spatial meshes, and
-universe bins.
-
-The detectors contained in this module are tasked with storing such
-data and proving easy access to the data, as well as the underlying
-bins used to define the detector.
-
-Detector Types
---------------
-
-* :class:`~serpentTools.objects.detectors.Detector`
-* :class:`~serpentTools.objects.detectors.CartesianDetector`
-* :class:`~serpentTools.objects.detectors.HexagonalDetector`
-* :class:`~serpentTools.objects.detectors.CylindricalDetector`
-* :class:`~serpentTools.objects.detectors.SphericalDetector`
-"""
-
-from math import sqrt, pi
 from warnings import warn
-from collections import OrderedDict
-
-from six import iteritems
-from numpy import unique, array, empty, inf
-from matplotlib.figure import Figure
-from matplotlib.patches import RegularPolygon
-from matplotlib.collections import PatchCollection
-from matplotlib.pyplot import gca
-
-from serpentTools.messages import warning, SerpentToolsException
-from serpentTools.objects.base import DetectorBase
-from serpentTools.utils import (
-    magicPlotDocDecorator, formatPlot, setAx_xlims, setAx_ylims,
-    addColorbar, normalizerFactory, linkToWiki,
-)
-from serpentTools.io.hooks import matlabHook
-
-__all__ = ['Detector', 'CartesianDetector', 'HexagonalDetector',
-           'CylindricalDetector', 'SphericalDetector']
-
-
-DET_COLS = (
-    'value', 'time', 'energy', 'universe',
-    'cell', 'material', 'lattice',
-    'reaction', 'zmesh', 'ymesh', 'xmesh',
-    'tally', 'error', 'scores',
-)
-"""Name of the columns of the data"""
-
-
-class Detector(DetectorBase):
-    docAttrs = """bins: :class:`numpy.ndarray`
-        Tally data directly from ``SERPENT`` file"""
-    __doc__ = """
-    Class that stores data from a detector without a spatial mesh.
-
-    Parameters
-    ----------
-    {params:s}
-
-    Attributes
-    ----------
-    {docAttrs:s}
-    {baseAttrs:s}
-    """.format(params=DetectorBase.baseParams,
-               docAttrs=docAttrs,
-               baseAttrs=DetectorBase.baseAttrs)
-
-    def __init__(self, name):
-        DetectorBase.__init__(self, name)
-        self.bins = None
-        self.__reshaped = False
-
-    def _isReshaped(self):
-        return self.__reshaped
-
-    def addTallyData(self, bins, hasTime=False):
-        """Add tally data to this detector"""
-        self.__reshaped = False
-        self.bins = bins
-        self.reshape(hasTime)
-
-    def reshape(self, hasTime=False):
-        """
-        Reshape the tally data into a multidimensional array
-
-        This method reshapes the tally and uncertainty data into arrays
-        where the array axes correspond to specific bin types.
-        If a detector was set up to tally two group flux in a 5 x 5
-        xy mesh, then the resulting tally data would be in a 50 x 12/13
-        matrix in the original ``detN.m`` file.
-        The tally data and relative error would be rebroadcasted into
-        2 x 5 x 5 arrays, and the indexing information is stored in
-        ``self.indexes``
-
-        Returns
-        -------
-        shape: list
-            Dimensionality of the resulting array
-
-        Raises
-        ------
-        SerpentToolsException:
-            If the bin data has not been loaded
-        """
-        if self.bins is None:
-            raise SerpentToolsException('Tally data for detector {} has not '
-                                        'been loaded'.format(self.name))
-        if self.__reshaped:
-            warning('Data has already been reshaped')
-            return
-        shape = []
-        tallyCol = 10
-        errorCol = 11
-        scoreCol = 12
-        if hasTime:
-            tallyCol += 1
-            errorCol += 1
-            scoreCol += 1
-        self.indexes = OrderedDict()
-        hasScores = self.bins.shape[1] == (scoreCol + 1)
-
-        if self.bins.shape[0] == 1:
-            # single tally value
-            self.tallies = self.bins[0, tallyCol]
-            self.errors = self.bins[0, errorCol]
-            if hasScores:
-                self.scores = self.bins[0, scoreCol]
-        else:
-            for tallyIx, colIx in enumerate(
-                    range(1, tallyCol),
-                    start=1 if hasTime else 2):
-                uniqueVals = unique(self.bins[:, colIx])
-                if len(uniqueVals) > 1:
-                    indexName = self._indexName(tallyIx)
-                    self.indexes[indexName] = array(uniqueVals, dtype=int) - 1
-                    shape.append(len(uniqueVals))
-            self.tallies = self.bins[:, tallyCol].reshape(shape)
-            self.errors = self.bins[:, errorCol].reshape(shape)
-            if hasScores:
-                self.scores = self.bins[:, scoreCol].reshape(shape)
-        self._map = {'tallies': self.tallies, 'errors': self.errors,
-                     'scores': self.scores}
-        self.__reshaped = True
-        return shape
-
-    def _indexName(self, indexPos):
-        """Return the name of this index position"""
-        if hasattr(self, '_INDEX_MAP') and indexPos in self._INDEX_MAP:
-            return self._INDEX_MAP[indexPos]
-        return DET_COLS[indexPos]
-
-    def _gather_matlab(self, reconvert):
-        """Gather bins and grids for exporting to matlab"""
-
-        converter = deconvert if reconvert else prepToMatlab
-
-        data = {
-            converter(self.name, 'bins'): self.bins,
-        }
-
-        for key, value in iteritems(self.grids):
-            data[converter(self.name, key)] = value
-
-        return data
-
-
-Detector.toMatlab = matlabHook
-
-
-class CartesianDetector(Detector):
-    __doc__ = """
-    Class that stores detector data containing cartesian meshing.
-
-    .. versionadded:: 0.5.1
-
-    Parameters
-    ----------
-    {params:s}
-
-    Attributes
-    ----------
-    {docAttrs:s}
-    {baseAttrs:s}
-
-    See Also
-    --------
-    {seeAlso:s}
-    """.format(params=DetectorBase.baseParams, docAttrs=Detector.docAttrs,
-               baseAttrs=DetectorBase.baseAttrs, seeAlso='* ' + linkToWiki(
-                   'Input_syntax_manual#det_dx',
-                   'Setting up a cartesian mesh detector'))
-    pass
-
-
-class HexagonalDetector(Detector):
-    docSeeAlso = '* ' + linkToWiki('Input_syntax_manual#det_dh',
-                                   'Setting up a hexagonal detector')
-    docAttrs = """pitch: None or int
-        Mesh size [cm]
-    hexType: None or {2, 3}
-        Type of hexagonal mesh.
-
-            2. Flat face perpendicular to x-axis
-            3. Flat face perpendicular to y-axis."""
-    __doc__ = """
-    Class that stores detector data containing a hexagonal meshing.
-
-    .. versionadded:: 0.5.1
-
-    Parameters
-    ----------
-    {params:s}
-
-    Attributes
-    ----------
-    {docAttrs:s}
-    {detAttrs:s}
-    {baseAttrs:s}
-
-    See Also
-    --------
-    {seeAlso:s}""".format(seeAlso=docSeeAlso, docAttrs=docAttrs,
-                          params=DetectorBase.baseParams,
-                          detAttrs=Detector.docAttrs,
-                          baseAttrs=DetectorBase.baseAttrs)
-
-    # column indicies in full (time-bin included) bins matrix
-    _INDEX_MAP = {
-        9: 'ycoord',
-        10: 'xcoord',
-    }
-
-    _NON_CART = _INDEX_MAP.values()
-
-    def __init__(self, name):
-        Detector.__init__(self, name)
-        self.__pitch = None
-        self.__hexType = None
-        self.__hexRot = None
-
-    @property
-    def pitch(self):
-        return self.__pitch
-
-    @pitch.setter
-    def pitch(self, value):
-        f = float(value)
-        if f <= 0:
-            raise ValueError("Pitch must be positive")
-        self.__pitch = f
-
-    @property
-    def hexType(self):
-        return self.__hexType
-
-    @hexType.setter
-    def hexType(self, value):
-        if value not in {2, 3}:
-            raise ValueError("Hex type must be 2 or 3, not {}"
-                             .format(value))
-        self.__hexType = value
-        self.__hexRot = 0 if value == 2 else (pi / 2)
-
-    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
-                 cmap=None, logColor=False, xlabel=None, ylabel=None,
-                 logx=False, logy=False, loglog=False, title=None, **kwargs):
-        opts = dict(what=what,
-                    fixed=fixed,
-                    ax=ax,
-                    cmap=cmap,
-                    logColor=logColor,
-                    xlabel=xlabel,
-                    logx=logx,
-                    logy=logy,
-                    loglog=loglog,
-                    title=title,
-                    **kwargs)
-        if xdim in self._NON_CART or ydim in self._NON_CART:
-            return self.hexPlot(**opts)
-        return DetectorBase.meshPlot(self, xdim, ydim, **opts)
-
-    meshPlot.__doc__ = DetectorBase.meshPlot.__doc__
-
-    @magicPlotDocDecorator
-    def hexPlot(self, what='tallies', fixed=None, ax=None, cmap=None,
-                logColor=False, xlabel=None, ylabel=None, logx=False,
-                logy=False, loglog=False, title=None, normalizer=None,
-                cbarLabel=None, borderpad=2.5, **kwargs):
-        """
-        Create and return a hexagonal mesh plot.
-
-        Parameters
-        ----------
-        what: {'tallies', 'errors', 'scores'}
-            Quantity to plot
-        fixed: None or dict
-            Dictionary of slicing arguments to pass to :meth:`slice`
-        {ax}
-        {cmap}
-        {logColor}
-        {xlabel}
-        {ylabel}
-        {logx}
-        {logy}
-        {loglog}
-        {title}
-        borderpad: int or float
-            Percentage of total plot to apply as a border. A value of
-            zero means that the extreme edges of the hexagons will touch
-            the x and y axis.
-        {kwargs} :class:`matplotlib.patches.RegularPolygon`
-
-        Raises
-        ------
-        AttributeError
-            If :attr:`pitch` and :attr:`hexType` are not set.
-        """
-        borderpad = max(0, float(borderpad))
-        if fixed and ('xcoord' in fixed or 'ycoord' in fixed):
-            raise KeyError("Refusing to restrict along one of the hexagonal "
-                           "dimensions {x/y}coord")
-        for attr in {'pitch', 'hexType'}:
-            if getattr(self, attr) is None:
-                raise AttributeError("{} is not set.".format(attr))
-
-        for key in {'color', 'fc', 'facecolor', 'orientation'}:
-            checkClearKwargs(key, 'hexPlot', **kwargs)
-        ec = kwargs.get('ec', None) or kwargs.get('edgecolor', None)
-        if ec is None:
-            ec = 'k'
-        kwargs['ec'] = kwargs['edgecolor'] = ec
-        if 'figure' in kwargs and kwargs['figure'] is not None:
-            fig = kwargs['figure']
-            if not isinstance(fig, Figure):
-                raise TypeError(
-                    "Expected 'figure' to be of type Figure, is {}"
-                    .format(type(fig)))
-            if len(fig.axes) != 1 and not ax:
-                raise TypeError("Don't know where to place the figure since"
-                                "'figure' argument has multiple axes.")
-            if ax and fig.axes and ax not in fig.axes:
-                raise IndexError("Passed argument for 'figure' and 'ax', "
-                                 "but ax is not attached to figure.")
-            ax = ax or (fig.axes[0] if fig.axes else gca())
-        alpha = kwargs.get('alpha', None)
-
-        ny = len(self.indexes['ycoord'])
-        nx = len(self.indexes['xcoord'])
-        data = self.slice(fixed, what)
-        if data.shape != (ny, nx):
-            raise IndexError("Constrained data does not agree with hexagonal "
-                             "grid structure. Coordinate grid: {}. "
-                             "Constrained shape: {}"
-                             .format((ny, nx), data.shape))
-        nItems = ny * nx
-        patches = empty(nItems, dtype=object)
-        values = empty(nItems)
-        coords = self.grids['COORD']
-
-        ax = ax or gca()
-        pos = 0
-        xmax, ymax = [-inf, ] * 2
-        xmin, ymin = [inf, ] * 2
-        radius = self.pitch / sqrt(3)
-
-        for xy, val in zip(coords, data.flat):
-            values[pos] = val
-            h = RegularPolygon(xy, 6, radius, self.__hexRot, **kwargs)
-            verts = h.get_verts()
-            vmins = verts.min(0)
-            vmaxs = verts.max(0)
-            xmax = max(xmax, vmaxs[0])
-            xmin = min(xmin, vmins[0])
-            ymax = max(ymax, vmaxs[1])
-            ymin = min(ymin, vmins[1])
-            patches[pos] = h
-            pos += 1
-        normalizer = normalizerFactory(values, normalizer, logColor,
-                                       coords[:, 0], coords[:, 1])
-        pc = PatchCollection(patches, cmap=cmap, alpha=alpha)
-        pc.set_array(values)
-        pc.set_norm(normalizer)
-        ax.add_collection(pc)
-
-        addColorbar(ax, pc, None, cbarLabel)
-
-        formatPlot(ax, loglog=loglog, logx=logx, logy=logy,
-                   xlabel=xlabel or "X [cm]",
-                   ylabel=ylabel or "Y [cm]", title=title,
-                   )
-        setAx_xlims(ax, xmin, xmax, pad=borderpad)
-        setAx_ylims(ax, ymin, ymax, pad=borderpad)
-
-        return ax
-
-
-class CylindricalDetector(Detector):
-    docSeeAlso = "* " + linkToWiki('Input_syntax_manual#det_dn',
-                                   'Setting up a curvilinear detector')
-    __doc__ = """
-    Class that stores detector data containing a cylindrical mesh.
-
-    .. versionadded:: 0.5.1
-
-    Parameters
-    ----------
-    {params:s}
-
-    Attributes
-    ----------
-    {detAttrs:s}
-    {baseAttrs:s}
-
-    See Also
-    --------
-    {seeAlso:s}""".format(
-        params=DetectorBase.baseParams, detAttrs=Detector.docAttrs,
-        baseAttrs=DetectorBase.baseAttrs, seeAlso=docSeeAlso)
-    # column indices in full (time-bin included) bins matrix
-    _INDEX_MAP = {
-        9: 'phi',
-        10: 'rmesh'
-    }
-
-    _NON_CART = _INDEX_MAP.values()
-
-    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
-                 cmap=None, logColor=False, xlabel=None, ylabel=None,
-                 logx=False, logy=False, loglog=False, title=None, **kwargs):
-        if xdim in self._NON_CART or ydim in self._NON_CART:
-            warnMeshPlot('Cylindrical', 169)
-        return DetectorBase.meshPlot(self,
-                                     xdim, ydim,
-                                     what=what,
-                                     fixed=fixed,
-                                     ax=ax,
-                                     cmap=cmap,
-                                     logColor=logColor,
-                                     xlabel=xlabel,
-                                     logx=logx,
-                                     logy=logy,
-                                     loglog=loglog,
-                                     title=title,
-                                     **kwargs)
-
-    meshPlot.__doc__ = DetectorBase.meshPlot.__doc__
-
-
-class SphericalDetector(Detector):
-    __doc__ = """
-    Class that stores detector data containing a spherical mesh.
-
-    .. versionadded:: 0.5.1
-
-    Paramters
-    ---------
-    {params:s}
-
-    Attributes
-    ----------
-    {detAttrs:s}
-    {baseAttrs:s}
-
-    See Also
-    --------
-    {seeAlso:s}""".format(
-        params=DetectorBase.baseParams, detAttrs=Detector.docAttrs,
-        baseAttrs=DetectorBase.baseAttrs,
-        seeAlso=CylindricalDetector.docSeeAlso)
-
-    # column indices in full (time-bin included) bins matrix
-    _INDEX_MAP = {
-        8: 'theta',
-        9: 'phi',
-        10: 'rmesh',
-    }
-
-    _NON_CART = _INDEX_MAP.values()
-
-    def meshPlot(self, xdim, ydim, what='tallies', fixed=None, ax=None,
-                 cmap=None, logColor=False, xlabel=None, ylabel=None,
-                 logx=False, logy=False, loglog=False, title=None, **kwargs):
-        if xdim in self._NON_CART or ydim in self._NON_CART:
-            warnMeshPlot('Spherical', 169)
-        return DetectorBase.meshPlot(self,
-                                     xdim, ydim,
-                                     what=what,
-                                     fixed=fixed,
-                                     ax=ax,
-                                     cmap=cmap,
-                                     logColor=logColor,
-                                     xlabel=xlabel,
-                                     logx=logx,
-                                     logy=logy,
-                                     loglog=loglog,
-                                     title=title,
-                                     **kwargs)
-
-    meshPlot.__doc__ = DetectorBase.meshPlot.__doc__
-
-
-DET_UNIQUE_GRIDS = {
-    CartesianDetector: {'X', 'Y'},
-    HexagonalDetector: {"COORD"},
-}
-
-
-def _getDetectorType(dataDict):
-    if not dataDict:
-        return Detector
-    for cls, uniqGrids in iteritems(DET_UNIQUE_GRIDS):
-        if any([key in uniqGrids for key in dataDict]):
-            return cls
-    if 'R' in dataDict:
-        return CylindricalDetector if 'Z' in dataDict else SphericalDetector
-    return CartesianDetector if 'Z' in dataDict else Detector
-
-
-def detectorFactory(name, dataDict):
-    """
-    Return a proper Detector subclass depending upon the attached grids
-
-    Parameters
-    ----------
-    name: str
-        Name of this specific detector.
-    dataDict: dict
-        Dictionary of detector data. Expects at least ``'tally'``
-
-    Returns
-    -------
-    object:
-        Subclass of :class:`serpentTools.objects.base.DetectorBase`
-        depending on grid data passed
-
-    Raises
-    ------
-    KeyError:
-        If ``'tally'`` is missing from the data dictionary
-    """
-    tallyD = dataDict.pop('tally')
-    detCls = _getDetectorType(dataDict)
-    det = detCls(name)
-    det.addTallyData(tallyD, 'T' in dataDict)
-    for gridK, value in iteritems(dataDict):
-        det.grids[gridK] = value
-    return det
-
-
-def warnMeshPlot(plotType, ghIssue):
-    msg = ("{} plotting is not fully supported yet - #{}"
-           .format(plotType, ghIssue))
-    warn(msg, FutureWarning)
-
-
-def checkClearKwargs(key, fName, **kwargs):
-    """Log a warning and clear non-None values from kwargs"""
-    if key in kwargs and kwargs[key] is not None:
-        warning("{} will be set by {}. Worry not.".format(key, fName))
-        kwargs[key] = None
-
-
-# Functions for converting varible names for matlab
-
-_DET_FMT_ORIG = "DET{}{}"
-_DET_FMT_CC = "{}_{}"
-
-
-def deconvert(detectorName, quantity):
-    """Restore the original name of the detector data"""
-    if quantity == 'bins':
-        return _DET_FMT_ORIG.format(detectorName, '')
-    return _DET_FMT_ORIG.format(detectorName, quantity)
-
+from serpentTools.detectors import *
 
-def prepToMatlab(detectorName, quantity):
-    """Create a name of a variable for MATLAB"""
-    return _DET_FMT_CC.format(detectorName, quantity)
+warn("Importing from serpentTools.objects.detectors is deprecated. "
+     "Prefer serpentTools.detectors")
diff --git a/serpentTools/parsers/detector.py b/serpentTools/parsers/detector.py
index 516dd89..063be38 100644
--- a/serpentTools/parsers/detector.py
+++ b/serpentTools/parsers/detector.py
@@ -1,17 +1,19 @@
 """Parser responsible for reading the ``*det<n>.m`` files"""
 
+from warnings import warn
 from six import iteritems
 from numpy import empty
 
 from serpentTools.utils import str2vec
 from serpentTools.utils.compare import getKeyMatchingShapes
 from serpentTools.engines import KeywordParser
-from serpentTools.objects.detectors import detectorFactory
+from serpentTools.detectors import detectorFactory
 from serpentTools.parsers.base import BaseReader
-from serpentTools.messages import error, debug, warning, SerpentToolsException
-from serpentTools.settings import rc
+from serpentTools.messages import SerpentToolsException
 
 
+# After py2 removal, subclass this from collections.abc.Mapping
+# Gain full dictionary-like behavior by defining a few methods
 class DetectorReader(BaseReader):
     """
     Parser responsible for reading and working with detector files.
@@ -23,63 +25,63 @@ class DetectorReader(BaseReader):
 
     Attributes
     ----------
-    {attrs:s}
-    """
-    docAttrs = """detectors: dict
+    detectors : dict
         Dictionary where key, value pairs correspond to detector names
         and their respective :class:`~serpentTools.objects.detector.Detector`
-        representations."""
-    __doc__ = __doc__.format(attrs=docAttrs)
+        instances
+    """
 
     def __init__(self, filePath):
         BaseReader.__init__(self, filePath, 'detector')
         self.detectors = {}
-        if not self.settings['names']:
-            self._loadAll = True
-        else:
-            self._loadAll = False
-        self.__numCols = 13 if rc['serpentVersion'][0] == '1' else 12
 
     def __getitem__(self, name):
         """Retrieve a detector from :attr:`detectors`"""
         return self.detectors[name]
 
+    def __len__(self):
+        return len(self.detectors)
+
+    def __contains__(self, key):
+        return key in self.detectors
+
+    def __iter__(self):
+        return iter(self.detectors)
+
     def iterDets(self):
         """Yield name, detector pairs by iterating over :attr:`detectors`."""
-        for name, detector in iteritems(self.detectors):
-            yield name, detector
+        for key, det in iteritems(self.detectors):
+            yield key, det
 
     def _read(self):
         """Read the file and store the detectors."""
-        recentName = None
-        lenRecent = 0
-        recentGrids = {}
-        keys = ['DET']
-        separators = ['\n', '];']
-        with KeywordParser(self.filePath, keys, separators) as parser:
+        currentName = ""
+        grids = {}
+        bins = None
+        with KeywordParser(self.filePath, ["DET"], ["\n", "];"]) as parser:
             for chunk in parser.yieldChunks():
                 name, data = cleanDetChunk(chunk)
-                if recentName is None or name[:lenRecent] != recentName:
-                    if recentName is not None:
-                        self.__processDet(recentName, recentGrids)
-                    recentName = name
-                    lenRecent = len(name)
-                    recentGrids = {'tally': data}
-                    continue
-                gridName = name[lenRecent:]
-                recentGrids[gridName] = data
-            self.__processDet(recentName, recentGrids)
-
-    def __processDet(self, name, grids):
+                if currentName and name[:len(currentName)] != currentName:
+                    self._processDet(currentName, bins, grids)
+                    bins = data
+                    grids = {}
+                    currentName = name
+                elif bins is None:
+                    currentName = name
+                    bins = data
+                else:
+                    gridName = name[len(currentName):]
+                    grids[gridName] = data
+            self._processDet(currentName, bins, grids)
+
+    def _processDet(self, name, bins, grids):
         """Add this detector with it's grid data to the reader."""
-        if not self._loadAll and name in self.settings['names']:
-            debug("Skipping detector {} due to setting <detector.names>"
-                  .format(name))
+        if self.settings['names'] and name in self.settings['names']:
             return
         if name in self.detectors:
             raise KeyError("Detector {} already stored on reader"
                            .format(name))
-        self.detectors[name] = detectorFactory(name, grids)
+        self.detectors[name] = detectorFactory(name, bins, grids)
 
     def _precheck(self):
         """ Count how many detectors are in the file."""
@@ -90,11 +92,11 @@ class DetectorReader(BaseReader):
                     continue
                 if 'DET' in sline[0]:
                     return
-        error("No detectors found in {}".format(self.filePath))
+        warn("No detectors in pre-checking {}".format(self.filePath))
 
     def _postcheck(self):
         if not self.detectors:
-            warning("No detectors stored from file {}".format(self.filePath))
+            warn("No detectors stored from file {}".format(self.filePath))
 
     def _compare(self, other, lower, upper, sigma):
         """Compare two detector readers."""
@@ -114,8 +116,8 @@ class DetectorReader(BaseReader):
         """Collect data from all detectors for exporting to matlab"""
         data = {}
 
-        for detector in self.detectors.values():
-            data.update(detector._gather_matlab(reconvert))
+        for det in self.detectors.values():
+            data.update(det._gather_matlab(reconvert))
 
         return data
 
diff --git a/serpentTools/samplers/base.py b/serpentTools/samplers/base.py
index 821d5af..602b5f3 100644
--- a/serpentTools/samplers/base.py
+++ b/serpentTools/samplers/base.py
@@ -39,41 +39,34 @@ def extendFiles(files):
 
 
 class Sampler(object):
-    docFiles = """files: str or iterable
-            Single file or iterable (list) of files from which to read.
-            Supports file globs, ``*det0.m`` expands to all files that
-            end with ``det0.m``"""
-    docAttrs = """files: set
-        Unordered set containing full paths of unique files read
-    settings: dict
-        Dictionary of sampler-wide settings
-    parsers: set
-        Unordered set of all parsers that were successful
-    map: dict
-        Dictionary where key, value pairs are files and their corresponding
-        parsers"""
-
-    __doc__ = """
-    Base class for reading multiple files of of a similar type
+    """Base class for reading multiple files of of a similar type
 
     Parameters
     ----------
-    {files:s}
-    parser: subclass of BaseReader
+    files: str or iterable
+        Single file or iterable (list) of files from which to read.
+        Supports file globs, ``*det0.m`` expands to all files that
+        end with ``det0.m``
+parser: subclass of BaseReader
         Class that will be used to read all files
 
     Attributes
     ----------
-    {attrs:s}
+    files: set
+        Unordered set containing full paths of unique files read
+    settings: dict
+        Dictionary of sampler-wide settings
+    parsers: set
+        Unordered set of all parsers that were successful
+    map: dict
+        Dictionary where key, value pairs are files and their corresponding
+        parsers
 
     Raises
     ------
     serpentTools.messages.SamplerError
         If ``parser`` is not a subclass of ``BaseReader``
-    """.format(files=docFiles, attrs=docAttrs)
-
-    docSkipChecks = """These tests can be skipped by setting
-    ``<sampler.skipPrecheck>`` to be ``False``"""
+    """
 
     def __init__(self, files, parser):
         if not issubclass(parser, BaseReader):
diff --git a/serpentTools/samplers/depletion.py b/serpentTools/samplers/depletion.py
index e3ef397..adc8511 100644
--- a/serpentTools/samplers/depletion.py
+++ b/serpentTools/samplers/depletion.py
@@ -36,15 +36,25 @@ class DepletionSampler(DepPlotMixin, Sampler):
     2. Metadata keys are consistent for all parsers
     3. Isotope names and ZZAAA metadata are equal for all parsers
 
-    {skip:s}
+    These tests can be skipped by settings ``<sampler.skipPrecheck>`` to be
+    ``False``.
 
     Parameters
     ----------
-    {files:s}
+    files: str or iterable
+        Single file or iterable (list) of files from which to read.
+        Supports file globs, ``*dep.m`` expands to all files that
+        end with ``dep.m``
 
     Attributes
     ----------
-    {depAttr:s}
+    materials: dict
+        Dictionary with material names as keys and the corresponding
+        :py:class:`~serpentTools.objects.materials.DepletedMaterial` class
+        for that material as values
+    metadata: dict
+        Dictionary with file-wide data names as keys and the
+        corresponding data, e.g. ``'zai'``: [list of zai numbers]
     metadataUncs: dict
         Dictionary containing uncertainties in file-wide metadata,
         such as burnup schedule
@@ -52,10 +62,17 @@ class DepletionSampler(DepPlotMixin, Sampler):
         Dictionary where key, value pairs are name of metadata and
         metadata arrays for all runs. Arrays with be of one greater dimension,
         as the first index corresponds to the file index.
-    {samplerAttr:s}
-
-    """.format(files=Sampler.docFiles, samplerAttr=Sampler.docAttrs,
-               skip=Sampler.docSkipChecks, depAttr=DepletionReader.docAttrs)
+    files: set
+        Unordered set containing full paths of unique files read
+    settings: dict
+        Dictionary of sampler-wide settings
+    parsers: set
+        Unordered set of all parsers that were successful
+    map: dict
+        Dictionary where key, value pairs are files and their corresponding
+        parsers
+
+    """
 
     def __init__(self, files):
         self.materials = {}
diff --git a/serpentTools/samplers/detector.py b/serpentTools/samplers/detector.py
index 9a4502a..78bd384 100644
--- a/serpentTools/samplers/detector.py
+++ b/serpentTools/samplers/detector.py
@@ -1,24 +1,22 @@
 """
 Class to read and process a batch of similar detector files
 """
-from six import iteritems
-from six.moves import range
+from collections import defaultdict
+import warnings
 
-from numpy import empty, empty_like, square, sqrt, sum, where
+from six import iteritems
+from numpy import empty, square, sqrt, allclose, asarray
 from matplotlib import pyplot
 
-from serpentTools.messages import (MismatchedContainersError, warning,
-                                   SamplerError, SerpentToolsException)
-from serpentTools.utils import magicPlotDocDecorator
+from serpentTools.messages import SerpentToolsException
+from serpentTools.utils import magicPlotDocDecorator, formatPlot
 from serpentTools.parsers.detector import DetectorReader
-from serpentTools.objects.base import DetectorBase
-from serpentTools.samplers.base import (Sampler, SampledContainer,
-                                        SPREAD_PLOT_KWARGS)
+from serpentTools.detectors import Detector
+from serpentTools.samplers.base import Sampler, SPREAD_PLOT_KWARGS
 
 
 class DetectorSampler(Sampler):
-    __doc__ = """
-    Class responsible for reading multiple detector files
+    """Class responsible for reading multiple detector files
 
     The following checks are performed to ensure that all detectors are
     of similar structure and content
@@ -26,19 +24,32 @@ class DetectorSampler(Sampler):
         1. Each parser must have the same detectors
         2. The reshaped tally data must be of the same size for all detectors
 
-    {skip:s}
+    These tests can be skipped by settings ``<sampler.skipPrecheck>`` to be
+    ``False``.
 
     Parameters
     ----------
-    {files:s}
+    files: str or iterable
+        Single file or iterable (list) of files from which to read.
+        Supports file globs, ``*det0.m`` expands to all files that
+        end with ``det0.m``
 
     Attributes
     ----------
-    {detAttrs:s}
-    {samplerAttrs:s}
-
-    """.format(detAttrs=DetectorReader.docAttrs, samplerAttrs=Sampler.docAttrs,
-               files=Sampler.docFiles, skip=Sampler.docSkipChecks)
+    detectors : dict
+        Dictionary of key, values pairs for detector names and corresponding
+        :class:`~serpentTools.samplers.SampledDetector` instances
+    files: set
+        Unordered set containing full paths of unique files read
+    settings: dict
+        Dictionary of sampler-wide settings
+    parsers: set
+        Unordered set of all parsers that were successful
+    map: dict
+        Dictionary where key, value pairs are files and their corresponding
+        parsers
+
+    """
 
     def __init__(self, files):
         self.detectors = {}
@@ -69,18 +80,16 @@ class DetectorSampler(Sampler):
                 self._raiseErrorMsgFromDict(misMatches, 'shape', 'detector')
 
     def _process(self):
-        numParsers = len(self.parsers)
+        individualDetectors = defaultdict(list)
         for parser in self:
             for detName, detector in parser.iterDets():
-                if detName not in self.detectors:
-                    self.detectors[detName] = SampledDetector(detName,
-                                                              numParsers)
-                self.detectors[detName].loadFromContainer(detector)
-        for _detName, sampledDet in self.iterDets():
-            sampledDet.finalize()
+                individualDetectors[detName].append(detector)
+        for name, detList in iteritems(individualDetectors):
+            self.detectors[name] = SampledDetector.fromDetectors(
+                name, detList)
 
     def _free(self):
-        for _detName, sampledDet in self.iterDets():
+        for sampledDet in self.detectors.values():
             sampledDet.free()
 
     def iterDets(self):
@@ -88,122 +97,124 @@ class DetectorSampler(Sampler):
             yield name, detector
 
 
-class SampledDetector(SampledContainer, DetectorBase):
-    __doc__ = """
+class SampledDetector(Detector):
+    """
     Class to store aggregated detector data
 
-    .. note ::
-
-        :py:func:`~serpentTools.samplers.detector.SampledDetector.free`
-        sets ``allTallies``, ``allErrors``, and ``allScores`` to
-        ``None``. {free:s}
-
     Parameters
     ----------
-    {detParams:s}
-    numFiles: int
-        Number of files that have been/will be read
+    name : str
+        Name of the detector to be sampled
+    allTallies : numpy.ndarray or iterable of arrays
+        Array of tally data for each individual detector
+    allErrors : numpy.ndarray or iterable of arrays
+        Array of absolute tally errors for individual detectors
+    indexes : iterable of string, optional
+        Iterable naming the bins that correspond to reshaped
+        :attr:`tally` and :attr:`errors`.
+    grids : dict, optional
+        Additional grid information, like spatial or energy-wise
+        grid information.
 
     Attributes
     ----------
-    {detAttrs:s}
-
-
-    """.format(detAttrs=DetectorBase.baseAttrs, free=SampledContainer.docFree,
-               detParams=DetectorBase.baseParams)
-
-    def __init__(self, name, numFiles):
-        SampledContainer.__init__(self, numFiles, DetectorBase)
-        DetectorBase.__init__(self, name)
-        self.allTallies = None
-        self.allErrors = None
-        self.allScores = None
-
-    def _isReshaped(self):
-        return True
-
-    def _loadFromContainer(self, detector):
-        """
-        Load data from a detector
-
-        Parameters
-        ----------
-        detector
-
-        Returns
-        -------
-
-        """
-        if detector.name != self.name:
-            warning("Attempting to read from detector with dissimilar names: "
-                    "Base: {}, incoming: {}".format(self.name, detector.name))
-        if not self._index:
-            self.__shape = tuple([self.N] + list(detector.tallies.shape))
-            self.__allocate(detector.scores is not None)
-        if self.__shape[1:] != detector.tallies.shape:
-            raise MismatchedContainersError(
-                "Incoming detector {} tally data shape does not match "
-                "sampled shape. Base: {}, incoming: {}".format(
-                    detector.name, self.__shape[1:], detector.tallies.shape))
-        self.__load(detector.tallies, detector.errors, detector.scores,
-                    detector.name)
-        if self.indexes is None:
-            self.indexes = detector.indexes
-        if not self.grids:
-            self.grids = detector.grids
-
-    def __allocate(self, scoreFlag):
-        self.allTallies = empty(self.__shape)
-        self.allErrors = empty_like(self.allTallies)
-        if scoreFlag:
-            self.allScores = empty_like(self.allTallies)
-
-    def free(self):
-        self.allTallies = None
-        self.allScores = None
-        self.allErrors = None
-
-    def __load(self, tallies, errors, scores, oName):
-        index = self._index
-        otherHasScores = scores is not None
-        selfHasScores = self.allScores is not None
-        if otherHasScores and selfHasScores:
-            self.allScores[index, ...] = scores
-        elif otherHasScores and not selfHasScores:
-            warning("Incoming detector {} has score data, while base does "
-                    "not. Skipping score data".format(oName))
-        elif not otherHasScores and selfHasScores:
-            raise MismatchedContainersError(
-                "Incoming detector {} does not have score data, while base "
-                "does.".format(oName)
-            )
-        self.allTallies[index] = tallies
-        self.allErrors[index] = tallies * errors
-
-    def _finalize(self):
-        if self.allTallies is None:
-            raise SamplerError(
-                "Detector data has not been loaded and cannot be processed")
-        N = self._index
-        self.tallies = self.allTallies[:N].mean(axis=0)
-        self.__computeErrors(N)
-
-        self.scores = (self.allScores[:N].mean(
-            axis=0) if self.allScores is not None else None)
-        self._map = {'tallies': self.tallies, 'errors': self.errors,
-                     'scores': self.scores}
-
-    def __computeErrors(self, N):
-        nonZeroT = where(self.tallies > 0)
-        zeroIndx = where(self.tallies == 0)
-        self.errors = sqrt(sum(square(self.allErrors), axis=0)) / N
-        self.errors[nonZeroT] /= self.tallies[nonZeroT]
-        self.errors[zeroIndx] = 0
+    name : str
+        Name of this detector
+    tallies : numpy.ndarray
+        Average of tallies from all detectors
+    errors : numpy.ndarray
+        Uncertainty on :attr:`tallies` after propagating uncertainty from all
+        individual detectors
+    deviation : numpy.ndarray
+        Deviation across all tallies
+    allTallies : numpy.ndarray
+        Array of tally data from sampled detectors. First dimension is the
+        file index ``i``, followed by the tally array for detector ``i``.
+    allErrors : numpy.ndarray
+        Array of uncertainties for sampled detectors. Structure is identical
+        to :attr:`allTallies`
+    grids : dict or None
+        Dictionary of additional grid information
+    indexes : tuple or None
+        Iterable naming the bins that correspond to reshaped
+        :attr:`tally` and :attr:`errors`. The tuple
+        ``(energy, ymesh, xmesh)`` indicates that :attr:`tallies`
+        should have three dimensions corresponding to various
+        energy, y-position, and x-position bins. Must be set
+        after :attr:`tallies` or :attr:`errors` and agree with
+        the shape of each
+
+    See Also
+    --------
+    :meth:`fromDetectors`
+
+    """
+
+    def __init__(self, name, allTallies, allErrors, indexes=None, grids=None):
+        # average tally data, propagate uncertainty
+        self._allTallies = allTallies
+        self._allErrors = allErrors
+        tallies = self.allTallies.mean(axis=0)
+
+        # propagate absolute uncertainty
+        # assume no covariance
+        inner = square(allErrors).sum(axis=0)
+        errors = sqrt(inner) / allTallies.shape[0]
+        nz = tallies.nonzero()
+        errors[nz] /= tallies[nz]
+
+        Detector.__init__(self, name, tallies=tallies, errors=errors,
+                          grids=grids, indexes=indexes)
+        self.deviation = self.allTallies.std(axis=0)
+
+    @property
+    def allTallies(self):
+        return self._allTallies
+
+    @allTallies.setter
+    def allTallies(self, tallies):
+        if tallies is None:
+            self._allTallies = None
+            return
+
+        tallies = asarray(tallies)
+
+        if self._allTallies is None:
+            self._allTallies = tallies
+            return
+
+        if tallies.shape != self._tallies.shape:
+            raise ValueError("Expected shape to be {}, is {}".format(
+                self._allTallies.shape, tallies.shape))
+
+        self._allTallies = tallies
+
+    @property
+    def allErrors(self):
+        return self._allErrors
+
+    @allErrors.setter
+    def allErrors(self, errors):
+        if errors is None:
+            self._allErrors = None
+            return
+
+        errors = asarray(errors)
+
+        if self._allErrors is None:
+            self._allErrors = errors
+            return
+
+        if errors.shape != self._errors.shape:
+            raise ValueError("Expected shape to be {}, is {}".format(
+                self._allErrors.shape, errors.shape))
+
+        self._allErrors = errors
 
     @magicPlotDocDecorator
     def spreadPlot(self, xdim=None, fixed=None, ax=None, xlabel=None,
                    ylabel=None, logx=False, logy=False, loglog=False,
-                   autolegend=True):
+                   legend=True):
         """
         Plot the mean tally value against all sampled detector data.
 
@@ -219,8 +230,7 @@ class SampledDetector(SampledContainer, DetectorBase):
         {logx}
         {logy}
         {loglog}
-        autolegend: bool
-            If true, apply a label to this plot.
+        {legend}
 
         Returns
         -------
@@ -228,7 +238,7 @@ class SampledDetector(SampledContainer, DetectorBase):
 
         Raises
         ------
-        :class:`~serpentTools.SamplerError`
+        AttributeError
             If ``allTallies`` is None, indicating this object has been
             instructed to free up data from all sampled files
         :class:`~serpentTools.SerpentToolsException`
@@ -237,8 +247,9 @@ class SampledDetector(SampledContainer, DetectorBase):
 
         """
         if self.allTallies is None:
-            raise SamplerError("Data from all sampled files has been freed "
-                               "and cannot be used in this plot method")
+            raise AttributeError(
+                "allTallies is None, cannot plot all tally data")
+
         samplerData = self.slice(fixed, 'tallies')
         slices = self._getSlices(fixed)
         if len(samplerData.shape) != 1:
@@ -248,19 +259,98 @@ class SampledDetector(SampledContainer, DetectorBase):
         xdata, autoX = self._getPlotXData(xdim, samplerData)
         xlabel = xlabel or autoX
         ax = ax or pyplot.gca()
-        N = self._index
-        allTallies = self.allTallies.copy(order='F')
-        for n in range(N):
-            plotData = allTallies[n][slices]
-            ax.plot(xdata, plotData, **SPREAD_PLOT_KWARGS)
-
-        ax.plot(xdata, samplerData, label='Mean value - N={}'.format(N))
-        if autolegend:
-            ax.legend()
-        ax.set_xlabel(xlabel)
-        ax.set_ylabel(ylabel or "Tally Data")
-        if loglog or logx:
-            ax.set_xscale('log')
-        if loglog or logy:
-            ax.set_yscale('log')
+        for data in self.allTallies:
+            ax.plot(xdata, data[slices], **SPREAD_PLOT_KWARGS)
+
+        ax.plot(xdata, samplerData, label='Mean value - N={}'.format(
+            self.allTallies.shape[0]))
+        formatPlot(ax, logx=logx, logy=logy, loglog=loglog, xlabel=xlabel,
+                   ylabel=ylabel, legend=legend)
         return ax
+
+    @classmethod
+    def fromDetectors(cls, name, detectors):
+        """
+        Create a :class:`SampledDetector` from similar detectors
+
+        Parameters
+        ----------
+        name : str
+            Name of this detector
+        detectors : iterable of :class:`serpentTools.Detector`
+            Iterable that contains detectors to be averaged. These
+            should be structured identically, in shape of the tally
+            data and the underlying grids and indexes.
+
+        Returns
+        -------
+        SampledDetector
+
+        Raises
+        ------
+        TypeError
+            If something other than a :class:`serpentTools.Detector` is found
+        ValueError
+            If tally data are not shaped consistently
+        KeyError
+            If some grid or index information is missing
+        AttributeError
+            If one detector is missing grids entirely but grids are
+            present on other grids
+        """
+        shape = None
+        indexes = None
+        grids = {}
+        differentGrids = set()
+
+        for d in detectors:
+            if not isinstance(d, Detector):
+                raise TypeError(
+                    "All items should be Detector. Found {}".format(type(d)))
+
+            if shape is None:
+                shape = d.tallies.shape
+            elif shape != d.tallies.shape:
+                raise ValueError(
+                    "Shapes do not agree. Found {} and {}".format(
+                        shape, d.tallies.shape))
+
+            # Inspect tally structure via indexes
+            if indexes is None and d.indexes is not None:
+                indexes = d.indexes
+            else:
+                if d.indexes != indexes:
+                    raise KeyError(
+                        "Detector indexes do not agree. Found {} and "
+                        "{}".format(d.indexes, indexes))
+
+            # Inspect tally structure via grids
+            if d.grids and not grids:
+                grids = d.grids
+            elif not d.grids and grids:
+                raise AttributeError(
+                    "Detector {} is missing grid structure".format(d))
+            elif d.grids and grids:
+                for key, refGrid in iteritems(grids):
+                    thisGrid = d.grids.get(key)
+                    if thisGrid is None:
+                        raise KeyError(
+                            "Detector {} is missing {} grid".format(d, key))
+                    if not allclose(refGrid, thisGrid):
+                        differentGrids.add(key)
+
+        if differentGrids:
+            warnings.warn(
+                "Found some potentially different grids {}".format(
+                    ", ".join(differentGrids)), RuntimeWarning)
+
+        shape = (len(detectors), ) + shape
+
+        allTallies = empty(shape)
+        allErrors = empty(shape)
+
+        for ix, d in enumerate(detectors):
+            allTallies[ix] = d.tallies
+            allErrors[ix] = d.tallies * d.errors
+
+        return cls(name, allTallies, allErrors, indexes=indexes, grids=grids)


Test patch:
diff --git a/tests/test_detector.py b/tests/test_detector.py
index 099fd13..9193d6a 100644
--- a/tests/test_detector.py
+++ b/tests/test_detector.py
@@ -10,7 +10,7 @@ from numpy import arange, array
 from numpy.testing import assert_equal
 from serpentTools.parsers import read
 from serpentTools.data import getFile
-from serpentTools.objects.detectors import (
+from serpentTools.detectors import (
     CartesianDetector, HexagonalDetector, CylindricalDetector)
 
 from tests import compareDictOfArrays
@@ -51,13 +51,7 @@ class DetectorHelper(TestCase):
         """Verify that the detector tally index is properly constructed."""
         for detName, expectedIndex in iteritems(self.EXPECTED_INDEXES):
             actualIndex = self.detectors[detName].indexes
-            expectedKeys = list(expectedIndex.keys())
-            actualKeys = list(actualIndex.keys())
-            self.assertListEqual(actualKeys, expectedKeys)
-            for key in expectedIndex:
-                assert_equal(
-                    actualIndex[key], expectedIndex[key],
-                    err_msg="Key: {}, Detector: {}".format(key, detName))
+            self.assertEqual(actualIndex, expectedIndex)
 
     def test_detectorSlice(self):
         """Verify that the detector slicing is working well."""
@@ -119,11 +113,7 @@ class CartesianDetectorTester(DetectorHelper):
     EXPECTED_GRIDS = {
         DET_NAME: _EXPECTED_GRIDS
     }
-    _INDEXES = OrderedDict([
-        ['reaction', arange(2)],
-        ['ymesh', arange(5)],
-        ['xmesh', arange(5)],
-    ])
+    _INDEXES = ("reaction", "ymesh", "xmesh")
     EXPECTED_INDEXES = {DET_NAME: _INDEXES}
 
     SLICING = {DET_NAME: {
@@ -165,10 +155,7 @@ class HexagonalDetectorTester(DetectorHelper):
         'hex2': HexagonalDetector,
         'hex3': HexagonalDetector,
     }
-    _INDEXES = OrderedDict([
-        ['ycoord', arange(5)],
-        ['xcoord', arange(5)],
-    ])
+    _INDEXES = ("ycoord", "xcoord")
     EXPECTED_INDEXES = {'hex2': _INDEXES}
     EXPECTED_INDEXES['hex3'] = EXPECTED_INDEXES['hex2']
 
@@ -252,10 +239,7 @@ class CylindricalDetectorTester(DetectorHelper):
         'Z': array([[0.00000E+00, 0.00000E+00, 0.00000E+00]])
     }
     EXPECTED_GRIDS = {DET_NAME: _EXPECTED_GRIDS}
-    _INDEXES = OrderedDict([
-        ['phi', arange(4)],
-        ['rmesh', arange(5)],
-    ])
+    _INDEXES = ("phi", "rmesh")
     EXPECTED_INDEXES = {DET_NAME: _INDEXES}
 
     SLICING = {
diff --git a/tests/test_detectors.py b/tests/test_detectors.py
new file mode 100644
index 0000000..f60aaeb
--- /dev/null
+++ b/tests/test_detectors.py
@@ -0,0 +1,233 @@
+"""
+Test various aspects of the detectors classes
+"""
+
+import numpy
+import pytest
+from serpentTools import detectors
+
+@pytest.fixture(scope="module")
+def meshedBinData():
+    bins = numpy.ones((25, 12), order="f")
+    bins[:, -1] = range(25)
+    bins[:, -2] = range(25)
+    bins[:, -3] = numpy.tile(range(1, 6), 5)
+    bins[:, -4] = numpy.repeat(range(1, 6), 5)
+
+    tallies = numpy.arange(25).reshape(5, 5)
+    errors = tallies.copy()
+
+    return bins, tallies, errors
+
+
+def testDetectorProperties(meshedBinData):
+    bins, tallies, errors = meshedBinData
+
+    detector = detectors.Detector(
+        "test", bins=bins, tallies=tallies, errors=errors)
+
+    # Modify the tally data
+    detector.tallies = detector.tallies * 2
+    assert (detector.tallies == tallies * 2).all()
+
+    detector.errors = detector.errors * 2
+    assert (detector.errors == errors * 2).all()
+
+    energies = numpy.arange(bins.shape[0] * 3).reshape(bins.shape[0], 3)
+    energyDet = detectors.Detector(
+        "energy", bins=bins, grids={"E": energies})
+
+    assert (energyDet.energy == energies).all()
+
+    # Test setting indexes
+
+    detector.indexes = tuple(range(len(tallies.shape)))
+
+    with pytest.raises(ValueError, match="indexes"):
+        detector.indexes = detector.indexes[:1]
+
+@pytest.mark.parametrize("how", ["bins", "grids", "bare", "init"])
+def testCartesianDetector(meshedBinData, how):
+
+    xgrid = numpy.empty((5, 3))
+    xgrid[:, 0] = range(5)
+    xgrid[:, 1] = xgrid[:, 0] + 1
+    xgrid[:, 2] = xgrid[:, 0] + 0.5
+
+    ygrid = xgrid.copy()
+
+    zgrid = numpy.array([[-1, 1, 0]])
+
+    bins, tallies, errors = meshedBinData
+
+    grids = {"X": xgrid.copy(), "Y": ygrid.copy(), "Z": zgrid.copy()}
+
+    if how == "bare":
+        detector = detectors.CartesianDetector("xy_bare")
+        detector.bins = bins
+        detector.tallies = tallies
+        detector.errors = errors
+        detector.x = grids["X"]
+        detector.y = grids["Y"]
+        detector.z = grids["Z"]
+    elif how == "grids":
+        detector = detectors.CartesianDetector(
+            "xy_full", bins=bins, tallies=tallies, errors=errors,
+            grids=grids)
+    elif how == "init":
+        detector = detectors.CartesianDetector(
+            "xy_full", bins=bins, tallies=tallies, errors=errors,
+            x=grids["X"], y=grids["Y"], z=grids["Z"])
+    elif how == "bins":
+        detector = detectors.CartesianDetector.fromTallyBins(
+            "xyBins", bins=bins, grids=grids)
+
+    # Modify the tally data
+    detector.tallies = tallies * 2
+    assert (detector.tallies == tallies * 2).all()
+
+    detector.errors = errors * 2
+    assert (detector.errors == errors * 2).all()
+
+    assert (detector.x == xgrid).all()
+    assert (detector.y == ygrid).all()
+    assert (detector.z == zgrid).all()
+
+    # Emulate scaling by some conversion factor
+    detector.x *= 100
+    assert (detector.x == xgrid * 100).all()
+    detector.y *= 100
+    assert (detector.y == ygrid * 100).all()
+    detector.z *= 100
+    assert (detector.z == zgrid * 100).all()
+
+    # Test failure modes
+
+    for gridk in ["x", "y", "z"]:
+        msg = ".*shape of {} grid".format(gridk)
+        with pytest.raises(ValueError, match=msg):
+            setattr(detector, gridk, [1, 2, 3])
+
+    # Test setting indexes
+
+    detector.indexes = tuple(range(len(tallies.shape)))
+
+    with pytest.raises(ValueError, match="indexes"):
+        detector.indexes = detector.indexes[:1]
+
+@pytest.mark.parametrize("how", ["grids", "bins", "bare", "init"])
+def testHexagonalDetector(meshedBinData, how):
+    centers = numpy.array([
+        [-3.000000E+00, -1.732051E+00],
+        [-2.500000E+00, -8.660254E-01],
+        [-2.000000E+00, 0.000000E+00],
+        [-1.500000E+00, 8.660254E-01],
+        [-1.000000E+00, 1.732051E+00],
+        [-2.000000E+00, -1.732051E+00],
+        [-1.500000E+00, -8.660254E-01],
+        [-1.000000E+00, 0.000000E+00],
+        [-5.000000E-01, 8.660254E-01],
+        [0.000000E+00, 1.732051E+00],
+        [-1.000000E+00, -1.732051E+00],
+        [-5.000000E-01, -8.660254E-01],
+        [0.000000E+00, 0.000000E+00],
+        [5.000000E-01, 8.660254E-01],
+        [1.000000E+00, 1.732051E+00],
+        [0.000000E+00, -1.732051E+00],
+        [5.000000E-01, -8.660254E-01],
+        [1.000000E+00, 0.000000E+00],
+        [1.500000E+00, 8.660254E-01],
+        [2.000000E+00, 1.732051E+00],
+        [1.000000E+00, -1.732051E+00],
+        [1.500000E+00, -8.660254E-01],
+        [2.000000E+00, 0.000000E+00],
+        [2.500000E+00, 8.660254E-01],
+        [3.000000E+00, 1.732051E+00],
+    ])
+    z = numpy.array([[0, 0, 0]])
+
+    bins, tallies, errors = meshedBinData
+
+    pitch = 1.0
+    hexType = 2
+
+    if how == "init":
+        detector = detectors.HexagonalDetector(
+            "hexInit", bins=bins, tallies=tallies, errors=errors,
+            z=z, centers=centers, pitch=pitch, hexType=hexType)
+    elif how == "grids":
+        detector = detectors.HexagonalDetector(
+            "hexGrids", bins=bins, tallies=tallies, errors=errors,
+            grids={"Z": z, "COORD": centers})
+    elif how == "bins":
+        detector = detectors.HexagonalDetector.fromTallyBins(
+            "hexBins", bins, grids={"Z": z, "COORD": centers})
+    elif how == "bare":
+        detector = detectors.HexagonalDetector("hexBins")
+        detector.bins = bins
+        detector.tallies = tallies
+        detector.errors = errors
+        detector.z = z
+        detector.centers = centers
+
+    if how != "init":
+        detector.pitch = pitch
+        detector.hexType = hexType
+
+    assert (detector.bins == bins).all()
+    assert (detector.tallies == tallies).all()
+    assert (detector.errors == errors).all()
+    assert (detector.z == z).all()
+    assert (detector.centers == centers).all()
+    assert detector.pitch == pitch
+    assert detector.hexType == hexType
+
+    detector.tallies = detector.tallies * 2
+    detector.errors = detector.errors * 2
+    detector.z = detector.z * 2
+    detector.centers = detector.centers * 2
+    detector.pitch = detector.pitch * 2
+
+    assert (detector.tallies == tallies * 2).all()
+    assert (detector.errors == errors * 2).all()
+    assert (detector.z == z * 2).all()
+    assert (detector.centers == centers * 2).all()
+    assert detector.pitch == pitch * 2
+
+    # Test failure modes
+
+    with pytest.raises(ValueError, match="Hex type"):
+        detector.hexType = -1
+
+    with pytest.raises(ValueError, match="Pitch must be positive"):
+        detector.pitch = 0
+
+    with pytest.raises(ValueError, match="Pitch must be positive"):
+        detector.pitch = -1
+
+    with pytest.raises(TypeError, match="Cannot set pitch"):
+        detector.pitch = [1, 2]
+
+    with pytest.raises(ValueError, match="Expected centers"):
+        detector.centers = detector.centers[:5]
+
+    with pytest.raises(ValueError, match="Expected shape of z"):
+        detector.z = [[-1, 0, -0.5], [0, 1, 0.5]]
+
+
+@pytest.fixture(scope="module")
+def binsWithScores():
+    bins = numpy.ones((2, 13))
+    bins[0, -3] = 1.5
+    return bins
+
+def testNoScores(binsWithScores):
+
+    with pytest.raises(ValueError, match=".*scores"):
+        detectors.Detector("scored", bins=binsWithScores)
+
+    with pytest.raises(ValueError, match=".*scores"):
+        detectors.Detector("scored").bins = binsWithScores
+
+    with pytest.raises(ValueError, match=".*scores"):
+        detectors.Detector.fromTallyBins("scored", bins=binsWithScores)
diff --git a/tests/test_toMatlab.py b/tests/test_toMatlab.py
index 1b96c8f..19d9ecd 100644
--- a/tests/test_toMatlab.py
+++ b/tests/test_toMatlab.py
@@ -3,21 +3,22 @@ Tests for testing the MATLAB conversion functions
 """
 
 from six import BytesIO, iteritems
-from numpy import arange
+from numpy import arange, ones
 from numpy.testing import assert_array_equal
-from serpentTools.objects import Detector
+from serpentTools import Detector
 from serpentTools.data import getFile, readDataFile
 from serpentTools.parsers import DepmtxReader
 
 from tests import MatlabTesterHelper
 
+
 class Det2MatlabHelper(MatlabTesterHelper):
     """Helper class for testing detector to matlab conversion"""
 
     NBINS = 10
     NCOLS = 12
     # approximate some detector data
-    BINS = arange(
+    BINS = ones(
         NCOLS * NBINS, dtype=float).reshape(NBINS, NCOLS)
     # emulate energy grid
     GRID = arange(3 * NBINS).reshape(NBINS, 3)
@@ -32,7 +33,7 @@ class Det2MatlabHelper(MatlabTesterHelper):
     def setUp(self):
         MatlabTesterHelper.setUp(self)
 
-        from serpentTools.objects.detectors import deconvert, prepToMatlab
+        from serpentTools.detectors import deconvert, prepToMatlab
         # instance methods and/or rename them
         # potential issues sending putting many such functions in this
         # test suite