@@ -854,6 +854,9 @@ astropy.io.misc
   unicode strings.  Now those columns are first encoded to UTF-8 and
   written as byte strings. [#7024, #8017]
 
+- Fixed a bug with serializing the bounding_box of models initialized 
+  with ``Quantities`` . [#8052]
+
 astropy.io.fits
 ^^^^^^^^^^^^^^^
 
@@ -873,6 +876,9 @@ astropy.modeling
 - Fix behaviour of certain models with units, by making certain unit-related
   attributes readonly. [#7210]
 
+- Fixed an issue with validating a ``bounding_box`` whose items are 
+  ``Quantities``. [#8052]
+
 astropy.nddata
 ^^^^^^^^^^^^^^
 
 
@@ -9,7 +9,7 @@
 from ...types import AstropyAsdfType
 
 
-__all__ = ['TransformType', 'IdentityType', 'ConstantType', 'DomainType']
+__all__ = ['TransformType', 'IdentityType', 'ConstantType']
 
 
 class TransformType(AstropyAsdfType):
@@ -25,21 +25,11 @@ def _from_tree_base_transform_members(cls, model, node, ctx):
         if 'name' in node:
             model = model.rename(node['name'])
 
-        # TODO: Remove domain in a later version.
-        if 'domain' in node:
-            model.bounding_box = cls._domain_to_bounding_box(node['domain'])
-        elif 'bounding_box' in node:
-            model.bounding_box = node['bounding_box']
+        if 'bounding_box' in node:
+            model.bounding_box = yamlutil.tagged_tree_to_custom_tree(node['bounding_box'], ctx)
 
         return model
 
-    @classmethod
-    def _domain_to_bounding_box(cls, domain):
-        bb = tuple([(item['lower'], item['upper']) for item in domain])
-        if len(bb) == 1:
-            bb = bb[0]
-        return bb
-
     @classmethod
     def from_tree_transform(cls, node, ctx):
         raise NotImplementedError(
@@ -70,7 +60,7 @@ def _to_tree_base_transform_members(cls, model, node, ctx):
                 bb = list(bb)
             else:
                 bb = [list(item) for item in model.bounding_box]
-            node['bounding_box'] = bb
+            node['bounding_box'] = yamlutil.custom_tree_to_tagged_tree(bb, ctx)
 
 
     @classmethod
@@ -129,20 +119,6 @@ def to_tree_transform(cls, data, ctx):
         }
 
 
-class DomainType(AstropyAsdfType):
-    # TODO: Is this used anywhere? Can it be removed?
-    name = "transform/domain"
-    version = '1.0.0'
-
-    @classmethod
-    def from_tree(cls, node, ctx):
-        return node
-
-    @classmethod
-    def to_tree(cls, data, ctx):
-        return data
-
-
 class GenericModel(mappings.Mapping):
     def __init__(self, n_inputs, n_outputs):
         mapping = tuple(range(n_inputs))
 
@@ -6,9 +6,10 @@
 
 from asdf import yamlutil
 
-from astropy import modeling
+from ...... import modeling
+from ...... import units as u
 from .basic import TransformType
-
+from ......tests.helper import assert_quantity_allclose
 
 __all__ = ['TabularType']
 
@@ -24,26 +25,25 @@ class TabularType(TransformType):
     def from_tree_transform(cls, node, ctx):
         lookup_table = node.pop("lookup_table")
         dim = lookup_table.ndim
-        name = node.get('name', None)
         fill_value = node.pop("fill_value", None)
         if dim == 1:
             # The copy is necessary because the array is memory mapped.
             points = (node['points'][0][:],)
             model = modeling.models.Tabular1D(points=points, lookup_table=lookup_table,
                                               method=node['method'], bounds_error=node['bounds_error'],
-                                              fill_value=fill_value, name=name)
+                                              fill_value=fill_value)
         elif dim == 2:
             points = tuple([p[:] for p in node['points']])
             model = modeling.models.Tabular2D(points=points, lookup_table=lookup_table,
                                               method=node['method'], bounds_error=node['bounds_error'],
-                                              fill_value=fill_value, name=name)
+                                              fill_value=fill_value)
 
         else:
             tabular_class = modeling.models.tabular_model(dim, name)
             points = tuple([p[:] for p in node['points']])
             model = tabular_class(points=points, lookup_table=lookup_table,
                                   method=node['method'], bounds_error=node['bounds_error'],
-                                  fill_value=fill_value, name=name)
+                                  fill_value=fill_value)
 
         return model
 
@@ -60,8 +60,15 @@ def to_tree_transform(cls, model, ctx):
 
     @classmethod
     def assert_equal(cls, a, b):
-        assert_array_equal(a.lookup_table, b.lookup_table)
-        assert_array_equal(a.points, b.points)
+        if isinstance(a.lookup_table, u.Quantity):
+            assert_quantity_allclose(a.lookup_table, b.lookup_table)
+            assert_quantity_allclose(a.points, b.points)
+            for i in range(len(a.bounding_box)):
+                assert_quantity_allclose(a.bounding_box[i], b.bounding_box[i])
+        else:
+            assert_array_equal(a.lookup_table, b.lookup_table)
+            assert_array_equal(a.points, b.points)
+            assert_array_equal(a.bounding_box, b.bounding_box)
         assert (a.method == b.method)
         if a.fill_value is None:
             assert b.fill_value is None
 
@@ -139,3 +139,20 @@ def test_linear1d_quantity(tmpdir):
     model = astmodels.Linear1D(1*u.nm, 1*(u.nm/u.pixel))
     tree = {'model': model}
     helpers.assert_roundtrip_tree(tree, tmpdir)
+
+
+def test_tabular_model_units(tmpdir):
+    points = np.arange(0, 5) * u.pix
+    values = [1., 10, 2, 45, -3] * u.nm
+    model = astmodels.Tabular1D(points=points, lookup_table=values)
+    tree = {'model': model}
+    helpers.assert_roundtrip_tree(tree, tmpdir)
+    table = np.array([[3.,  0.,  0.],
+                      [0.,  2.,  0.],
+                      [0.,  0.,  0.]]) * u.nm
+    points = ([1, 2, 3], [1, 2, 3]) * u.pix
+    model2 = astmodels.Tabular2D(points, lookup_table=table,
+                                 bounds_error=False, fill_value=None,
+                                 method='nearest')
+    tree = {'model': model2}
+    helpers.assert_roundtrip_tree(tree, tmpdir)
@@ -473,26 +473,40 @@ def validate(cls, model, bounding_box):
         nd = model.n_inputs
 
         if nd == 1:
-            if (not isiterable(bounding_box)
-                    or np.shape(bounding_box) not in ((2,), (1, 2))):
-                raise ValueError(
-                    "Bounding box for {0} model must be a sequence of length "
-                    "2 consisting of a lower and upper bound, or a 1-tuple "
-                    "containing such a sequence as its sole element.".format(
-                        model.name))
+            MESSAGE = "Bounding box for {0} model must be a sequence of length "
+            "2 consisting of a lower and upper bound, or a 1-tuple "
+            "containing such a sequence as its sole element.".format(model.name)
+
+            try:
+                valid_shape = np.shape(bounding_box) in ((2,), (1, 2))
+            except TypeError:
+                # np.shape does not work with lists of Quantities
+                valid_shape = np.shape([b.to_value() for b in bounding_box]) in ((2,), (1, 2))
+            except ValueError:
+                raise ValueError(MESSAGE)
+
+            if not isiterable(bounding_box) or not valid_shape:
+                raise ValueError(MESSAGE)
 
             if len(bounding_box) == 1:
                 return cls((tuple(bounding_box[0]),))
             else:
                 return cls(tuple(bounding_box))
         else:
-            if (not isiterable(bounding_box)
-                    or np.shape(bounding_box) != (nd, 2)):
-                raise ValueError(
-                    "Bounding box for {0} model must be a sequence of length "
-                    "{1} (the number of model inputs) consisting of pairs of "
-                    "lower and upper bounds for those inputs on which to "
-                    "evaluate the model.".format(model.name, nd))
+            MESSAGE = "Bounding box for {0} model must be a sequence of length "
+            "{1} (the number of model inputs) consisting of pairs of "
+            "lower and upper bounds for those inputs on which to "
+            "evaluate the model.".format(model.name, nd)
+
+            try:
+                valid_shape = all([len(i) == 2 for i in bounding_box])
+            except TypeError:
+                valid_shape = False
+            if len(bounding_box) != nd:
+                valid_shape = False
+
+            if not isiterable(bounding_box) or not valid_shape:
+                    raise ValueError(MESSAGE)
 
             return cls(tuple(bounds) for bounds in bounding_box)