diff --git a/.circleci/config.yml b/.circleci/config.yml
index 2535bd28e..57e9cc4ca 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -24,7 +24,7 @@ commands:
 jobs:
   python36:
     docker:
-      - image: icepack/firedrake-python3.6:0.5.3
+      - image: icepack/firedrake-python3.6:0.5.5
     working_directory: ~/icepack
     steps:
       - build
@@ -32,7 +32,7 @@ jobs:
       - realtest
   python38:
     docker:
-      - image: icepack/firedrake-python3.8:0.5.3
+      - image: icepack/firedrake-python3.8:0.5.5
     working_directory: ~/icepack
     steps:
       - build
diff --git a/README.md b/README.md
index b49c61bb5..c4591d4cd 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 
-# icepack [![CircleCI](https://circleci.com/gh/icepack/icepack/tree/master.svg?style=svg)](https://circleci.com/gh/icepack/icepack/tree/master) [![codecov](https://codecov.io/gh/icepack/icepack/branch/master/graph/badge.svg)](https://codecov.io/gh/icepack/icepack)
+# icepack [![CircleCI](https://circleci.com/gh/icepack/icepack/tree/master.svg?style=svg)](https://circleci.com/gh/icepack/icepack/tree/master) [![codecov](https://codecov.io/gh/icepack/icepack/branch/master/graph/badge.svg)](https://codecov.io/gh/icepack/icepack) [![DOI](https://zenodo.org/badge/45697304.svg)](https://zenodo.org/badge/latestdoi/45697304)
 
 icepack is a library for modeling the flow of ice sheets and glaciers using the finite element method.
 For more information and installation instructions, see the [project webpage](https://icepack.github.io).
diff --git a/icepack/datasets.py b/icepack/datasets.py
index 3a9546c0d..926bcc321 100644
--- a/icepack/datasets.py
+++ b/icepack/datasets.py
@@ -135,7 +135,7 @@ def fetch_larsen_outline():
 def fetch_mosaic_of_antarctica():
     r"""Fetch the MODIS optical image mosaic of Antarctica"""
     return nsidc_data.fetch(
-        "moa750_2009_hp1_v01.1.tif.gz",
+        "moa750_2009_hp1_v02.0.tif.gz",
         downloader=_earthdata_downloader,
         processor=pooch.Decompress(),
     )
diff --git a/icepack/models/__init__.py b/icepack/models/__init__.py
index 74bcd14cb..dcfee05de 100644
--- a/icepack/models/__init__.py
+++ b/icepack/models/__init__.py
@@ -16,6 +16,7 @@
 from icepack.models.damage_transport import DamageTransport
 from icepack.models.heat_transport import HeatTransport3D
 from icepack.models.shallow_ice import ShallowIce
+from icepack.models.age_transport import AgeTransport
 
 __all__ = [
     "IceShelf",
diff --git a/icepack/models/age_transport.py b/icepack/models/age_transport.py
new file mode 100644
index 000000000..5dc7401bc
--- /dev/null
+++ b/icepack/models/age_transport.py
@@ -0,0 +1,76 @@
+# Copyright (C) 2020-2021 by Andrew Hoffman <hoffmaao@uw.edu>
+#
+# This file is part of icepack.
+#
+# icepack is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The full text of the license can be found in the file LICENSE in the
+# icepack source directory or at <http://www.gnu.org/licenses/>.
+
+r"""Description of the age transport model.
+"""
+
+from operator import itemgetter
+import firedrake
+from firedrake import (
+    inner, grad, div, dx, ds, ds_tb, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional
+)
+from icepack.constants import year
+from icepack.utilities import eigenvalues, vertical_velocity, add_kwarg_wrapper
+
+def velocity_3D(**kwargs):
+    u, h = itemgetter("velocity", "thickness")(kwargs)
+
+    Q = h.function_space()
+    V = u.function_space()
+    mesh = Q.mesh()
+    xdegree_u, zdegree_u = u.ufl_element().degree()
+    W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])
+    w = firedrake.interpolate(vertical_velocity(u,h),W)
+    V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1)
+    u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w)))
+    return u3D 
+
+
+class AgeTransport:
+    def __init__(
+        self,
+        max_age=2000000.0,
+        velocity_3D=velocity_3D
+    ):
+        self.max_age = max_age
+        self.velocity_3D = add_kwarg_wrapper(velocity_3D)
+
+
+        
+    def flux(self, **kwargs):
+        u, h, q = itemgetter("velocity", "thickness", "age")(kwargs)
+
+        u3D = self.velocity_3D(**kwargs)
+
+        Q = h.function_space()
+        U = q.function_space()
+        mesh = Q.mesh()
+        
+        φ = firedrake.TestFunction(U)
+
+        xdegree_u, zdegree_u = u.ufl_element().degree()
+        degree_h = h.ufl_element().degree()[0]
+        degree = (xdegree_u + degree_h, 2 * zdegree_u + 1)
+        metadata = {'quadrature_degree': degree}
+        ice_front_ids = tuple(kwargs.pop('ice_front_ids', ()))
+
+        u3D = self.velocity_3D(**kwargs)
+
+        n = firedrake.FacetNormal(mesh)
+        u_n = max_value(0, inner(u3D, n))
+        f = q * u_n
+        q_inflow=firedrake.Constant(0.0)
+        flux_faces_v = (f('+') - f('-')) * (φ('+') - φ('-')) * dS_v
+        flux_cells = -q * div(u3D * φ) * dx
+        flux_v = q * max_value(0, inner(u3D, n)) * φ * ds_v
+        flux_tb = q * max_value(0, inner(u3D, n)) * φ * ds_tb
+        return flux_cells + flux_faces_v + flux_tb + flux_v
diff --git a/icepack/models/hybrid.py b/icepack/models/hybrid.py
index d5fa8d4db..99c0ad5b1 100644
--- a/icepack/models/hybrid.py
+++ b/icepack/models/hybrid.py
@@ -217,22 +217,25 @@ def action(self, **kwargs):
         ice_front_ids = tuple(kwargs.pop("ice_front_ids", ()))
         side_wall_ids = tuple(kwargs.pop("side_wall_ids", ()))
 
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
+        ds_b = firedrake.ds_b(domain=mesh, metadata=metadata)
+        ds_v = firedrake.ds_v(domain=mesh)
+
         viscosity = self.viscosity(**kwargs) * dx
         gravity = self.gravity(**kwargs) * dx
         friction = self.friction(**kwargs) * ds_b
 
-        ds_w = ds_v(domain=mesh, subdomain_id=side_wall_ids)
-        side_friction = self.side_friction(**kwargs) * ds_w
+        side_friction = self.side_friction(**kwargs) * ds_v(side_wall_ids)
         if get_mesh_axes(mesh) == "xyz":
-            penalty = self.penalty(**kwargs) * ds_w
+            penalty = self.penalty(**kwargs) * ds_v(side_wall_ids)
         else:
             penalty = 0.0
 
         xdegree_u, zdegree_u = u.ufl_element().degree()
         degree_h = h.ufl_element().degree()[0]
         degree = (xdegree_u + degree_h, 2 * zdegree_u + 1)
-        metadata = {"quadrature_degree": degree}
-        ds_t = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata)
+        ds_t = firedrake.ds_v(ice_front_ids, metadata={"quadrature_degree": degree})
         terminus = self.terminus(**kwargs) * ds_t
 
         return viscosity + friction + side_friction - gravity - terminus + penalty
@@ -243,6 +246,11 @@ def scale(self, **kwargs):
         The positive part of the action functional is used as a dimensional
         scale to determine when to terminate an optimization algorithm.
         """
+        u = kwargs["velocity"]
+        mesh = u.ufl_domain()
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
+        ds_b = firedrake.ds_b(domain=mesh, metadata=metadata)
         return self.viscosity(**kwargs) * dx + self.friction(**kwargs) * ds_b
 
     def quadrature_degree(self, **kwargs):
diff --git a/icepack/models/ice_shelf.py b/icepack/models/ice_shelf.py
index 1b9bd7d42..e88031ceb 100644
--- a/icepack/models/ice_shelf.py
+++ b/icepack/models/ice_shelf.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2017-2020 by Daniel Shapero <shapero@uw.edu>
+# Copyright (C) 2017-2021 by Daniel Shapero <shapero@uw.edu>
 #
 # This file is part of icepack.
 #
@@ -12,7 +12,7 @@
 
 from operator import itemgetter
 import firedrake
-from firedrake import inner, grad, dx, ds
+from firedrake import inner, grad
 from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g
 from icepack.models.viscosity import viscosity_depth_averaged as viscosity
 from icepack.models.friction import side_friction, normal_flow_penalty
@@ -130,15 +130,16 @@ def action(self, **kwargs):
         ice_front_ids = tuple(kwargs.pop("ice_front_ids", ()))
         side_wall_ids = tuple(kwargs.pop("side_wall_ids", ()))
 
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
+        ds = firedrake.ds(domain=mesh, metadata=metadata)
+
         viscosity = self.viscosity(**kwargs) * dx
         gravity = self.gravity(**kwargs) * dx
 
-        ds_w = ds(domain=mesh, subdomain_id=side_wall_ids)
-        side_friction = self.side_friction(**kwargs) * ds_w
-        penalty = self.penalty(**kwargs) * ds_w
-
-        ds_t = ds(domain=mesh, subdomain_id=ice_front_ids)
-        terminus = self.terminus(**kwargs) * ds_t
+        side_friction = self.side_friction(**kwargs) * ds(side_wall_ids)
+        penalty = self.penalty(**kwargs) * ds(side_wall_ids)
+        terminus = self.terminus(**kwargs) * ds(ice_front_ids)
 
         return viscosity + side_friction - gravity - terminus + penalty
 
@@ -148,6 +149,8 @@ def scale(self, **kwargs):
         The positive part of the action functional is used as a dimensional
         scale to determine when to terminate an optimization algorithm.
         """
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
         return self.viscosity(**kwargs) * dx
 
     def quadrature_degree(self, **kwargs):
diff --git a/icepack/models/ice_stream.py b/icepack/models/ice_stream.py
index f9d2e9c17..97ce4bb73 100644
--- a/icepack/models/ice_stream.py
+++ b/icepack/models/ice_stream.py
@@ -12,7 +12,7 @@
 
 from operator import itemgetter
 import firedrake
-from firedrake import inner, dx, ds
+from firedrake import inner
 from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g
 from icepack.models.viscosity import viscosity_depth_averaged as viscosity
 from icepack.models.friction import bed_friction, side_friction, normal_flow_penalty
@@ -108,19 +108,21 @@ def action(self, **kwargs):
         ice_front_ids = tuple(kwargs.pop("ice_front_ids", ()))
         side_wall_ids = tuple(kwargs.pop("side_wall_ids", ()))
 
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
+        ds = firedrake.ds(domain=mesh, metadata=metadata)
+
         viscosity = self.viscosity(**kwargs) * dx
         friction = self.friction(**kwargs) * dx
         gravity = self.gravity(**kwargs) * dx
 
-        ds_w = ds(domain=mesh, subdomain_id=side_wall_ids)
-        side_friction = self.side_friction(**kwargs) * ds_w
+        side_friction = self.side_friction(**kwargs) * ds(side_wall_ids)
         if get_mesh_axes(mesh) == "xy":
-            penalty = self.penalty(**kwargs) * ds_w
+            penalty = self.penalty(**kwargs) * ds(side_wall_ids)
         else:
             penalty = 0.0
 
-        ds_t = ds(domain=mesh, subdomain_id=ice_front_ids)
-        terminus = self.terminus(**kwargs) * ds_t
+        terminus = self.terminus(**kwargs) * ds(ice_front_ids)
 
         return viscosity + friction + side_friction - gravity - terminus + penalty
 
@@ -130,6 +132,8 @@ def scale(self, **kwargs):
         The positive part of the action functional is used as a dimensional
         scale to determine when to terminate an optimization algorithm.
         """
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
         return (self.viscosity(**kwargs) + self.friction(**kwargs)) * dx
 
     def quadrature_degree(self, **kwargs):
diff --git a/icepack/models/shallow_ice.py b/icepack/models/shallow_ice.py
index 39b2ebd17..f3e3b9b09 100644
--- a/icepack/models/shallow_ice.py
+++ b/icepack/models/shallow_ice.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2020 by Jessica Badgeley <badgeley@uw.edu>
+# Copyright (C) 2020-2021 by Jessica Badgeley <badgeley@uw.edu>
 #
 # This file is part of icepack.
 #
@@ -12,7 +12,7 @@
 
 from operator import itemgetter
 import firedrake
-from firedrake import inner, grad, dx
+from firedrake import inner, grad
 from icepack.constants import ice_density as ρ_I, gravity as g, glen_flow_law as n
 from icepack.models.mass_transport import Continuity
 from icepack.utilities import add_kwarg_wrapper
@@ -129,6 +129,8 @@ def action(self, **kwargs):
             All other keyword arguments will be passed on to the
             'mass', 'gravity' and 'penalty' functionals
         """
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
         mass = self.mass(**kwargs) * dx
         gravity = self.gravity(**kwargs) * dx
         penalty = self.penalty(**kwargs) * dx
@@ -140,13 +142,14 @@ def scale(self, **kwargs):
         The positive part of the action functional is used as a dimensional
         scale to determine when to terminate an optimization algorithm.
         """
+        metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)}
+        dx = firedrake.dx(metadata=metadata)
         return (self.mass(**kwargs) + self.penalty(**kwargs)) * dx
 
     def quadrature_degree(self, **kwargs):
         r"""Return the quadrature degree necessary to integrate the action
         functional accurately"""
-        u, h, s = itemgetter("velocity", "thickness", "surface")(kwargs)
+        u, h = itemgetter("velocity", "thickness")(kwargs)
         degree_u = u.ufl_element().degree()
         degree_h = h.ufl_element().degree()
-        degree_s = s.ufl_element().degree()
-        return int((n + 1) * degree_h + n * degree_s + degree_u)
+        return int((2 * n + 1) * degree_h + degree_u)
diff --git a/icepack/registry-nsidc.txt b/icepack/registry-nsidc.txt
index e5c529570..bc50b42ba 100644
--- a/icepack/registry-nsidc.txt
+++ b/icepack/registry-nsidc.txt
@@ -1,6 +1,6 @@
 antarctic_ice_vel_phase_map_v01.nc fa0957618b8bd98099f4a419d7dc0e3a2c562d89e9791b4d0ed55e6017f52416 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0754.001/1996.01.01/antarctic_ice_vel_phase_map_v01.nc
 BedMachineAntarctica_2020-07-15_v02.nc 71ff97f8fb034fbfe235cd1cad044eeea2ae1543e82115afbd886a24c1e71069 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0756.002/1970.01.01/BedMachineAntarctica_2020-07-15_v02.nc
-moa750_2009_hp1_v01.1.tif.gz 90d1718ea0971795ec102482c47f308ba08ba2b88383facb9fe210877e80282c https://daacdata.apps.nsidc.org/pub/DATASETS/nsidc0593_moa2009/geotiff/moa750_2009_hp1_v01.1.tif.gz
+moa750_2009_hp1_v02.0.tif.gz 90d1718ea0971795ec102482c47f308ba08ba2b88383facb9fe210877e80282c https://daacdata.apps.nsidc.org/pub/DATASETS/nsidc0593_moa2009_v02/geotiff/moa750_2009_hp1_v02.0.tif.gz
 
 greenland_vel_mosaic200_2015_2016_vx_v02.1.tif 77b8eb65a4718da055bb048b75c35b48ca43d76b5bffb650932128d60ed28598 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0478.002/2015.09.01/greenland_vel_mosaic200_2015_2016_vx_v02.1.tif
 greenland_vel_mosaic200_2015_2016_vy_v02.1.tif fb5dbc07d032de9b1bdb0b990ed02a384964d73a150529515038139efb1e3193 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0478.002/2015.09.01/greenland_vel_mosaic200_2015_2016_vy_v02.1.tif
diff --git a/icepack/solvers/__init__.py b/icepack/solvers/__init__.py
index 13e0fd672..fc4391f08 100644
--- a/icepack/solvers/__init__.py
+++ b/icepack/solvers/__init__.py
@@ -13,11 +13,13 @@
 from .flow_solver import FlowSolver, ImplicitEuler, LaxWendroff
 from .heat_transport import HeatTransportSolver
 from .damage_solver import DamageSolver
+from .age_solver import AgeSolver
 
 __all__ = [
-    "FlowSolver",
-    "ImplicitEuler",
-    "LaxWendroff",
-    "HeatTransportSolver",
-    "DamageSolver",
+    'FlowSolver',
+    'ImplicitEuler',
+    'LaxWendroff',
+    'HeatTransportSolver',
+    'DamageSolver',
+    'AgeSolver'
 ]
diff --git a/icepack/solvers/age_solver.py b/icepack/solvers/age_solver.py
new file mode 100644
index 000000000..c178f9e59
--- /dev/null
+++ b/icepack/solvers/age_solver.py
@@ -0,0 +1,111 @@
+# Copyright (C) 2020-2021 by Andrew Hoffman <hoffmaao@uw.edu>
+#
+# This file is part of icepack.
+#
+# icepack is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The full text of the license can be found in the file LICENSE in the
+# icepack source directory or at <http://www.gnu.org/licenses/>.
+
+r"""Description of the age solver used to calculate the layer slopes
+"""
+
+import firedrake
+from firedrake import (
+    dx,
+    LinearVariationalProblem,
+    LinearVariationalSolver,
+    max_value,
+    min_value
+)
+
+class AgeSolver:
+    def __init__(self, model):
+        self._model = model
+        self._fields = {}
+    @property
+    def model(self):
+        r"""The age transport model that this object solves"""
+        return self._model
+    @property
+    def fields(self):
+        r"""The dictionary of all fields that are part of the simulation"""
+        return self._fields
+    def _setup(self, **kwargs):
+        for name, field in kwargs.items():
+            if name in self._fields.keys():
+                self._fields[name].assign(field)
+            else:
+                if isinstance(field, firedrake.Constant):
+                    self._fields[name] = firedrake.Constant(field)
+                elif isinstance(field, firedrake.Function):
+                    self._fields[name] = field.copy(deepcopy=True)
+                else:
+                    raise TypeError('Input fields must be Constant or Function!')
+
+        # Create symbolic representations of the flux and sources of damage
+        dt = firedrake.Constant(1.0)
+        flux = self.model.flux(**self.fields)
+
+        # Create the finite element mass matrix
+        q = self.fields.get('age', self.fields.get('age'))
+        Q = q.function_space()
+        φ, ψ = firedrake.TrialFunction(Q), firedrake.TestFunction(Q)
+        M = φ * ψ * dx
+
+        L1 = -dt * flux
+        q1 = firedrake.Function(Q)
+        q2 = firedrake.Function(Q)
+        L2 = firedrake.replace(L1, {q: q1})
+        L3 = firedrake.replace(L1, {q: q2})
+
+        dq = firedrake.Function(Q)
+        
+        parameters = {
+            'solver_parameters': {
+                'ksp_type': 'preonly',
+                'pc_type': 'bjacobi',
+                'sub_pc_type': 'ilu'
+            }
+        }
+
+        problem1 = LinearVariationalProblem(M, L1, dq)
+        problem2 = LinearVariationalProblem(M, L2, dq)
+        problem3 = LinearVariationalProblem(M, L3, dq)
+        solver1 = LinearVariationalSolver(problem1, **parameters)
+        solver2 = LinearVariationalSolver(problem2, **parameters)
+        solver3 = LinearVariationalSolver(problem3, **parameters)
+
+        self._solvers = [solver1, solver2, solver3]
+        self._stages = [q1, q2]
+        self._age_change = dq
+        self._timestep = dt
+        
+    def solve(self, dt, **kwargs):
+        if not hasattr(self, '_solvers'):
+            self._setup(**kwargs)
+        else:
+            for name, field in kwargs.items():
+                self.fields[name].assign(field)
+
+        δt = self._timestep
+        δt.assign(dt)
+        q = self.fields.get('age', self.fields.get('age'))
+
+        solver1, solver2, solver3 = self._solvers
+        q1, q2 = self._stages
+        dq = self._age_change
+
+        solver1.solve()
+        q1.assign(q + dq)
+        solver2.solve()
+        q2.assign(3/4 * q + 1/4 * (q1 + dq))
+        solver3.solve()
+        q.assign(1/3 * q + 2/3 * (q2 + dq))
+        
+        max_age = firedrake.Constant(self.model.max_age)
+        q.project(min_value(max_value(q + firedrake.Constant(δt), firedrake.Constant(0.0)), max_age))
+        return q.copy(deepcopy=True)
diff --git a/icepack/solvers/damage_solver.py b/icepack/solvers/damage_solver.py
index 3ddc23b5e..59152c527 100644
--- a/icepack/solvers/damage_solver.py
+++ b/icepack/solvers/damage_solver.py
@@ -48,7 +48,10 @@ def _setup(self, **kwargs):
                 elif isinstance(field, firedrake.Function):
                     self._fields[name] = field.copy(deepcopy=True)
                 else:
-                    raise TypeError("Input fields must be Constant or Function!")
+                    raise TypeError(
+                        "Input %s field has type %s, must be Constant or Function!"
+                        % (name, type(field))
+                    )
 
         # Create symbolic representations of the flux and sources of damage
         dt = firedrake.Constant(1.0)
diff --git a/icepack/solvers/flow_solver.py b/icepack/solvers/flow_solver.py
index 241ac4b22..affbd5f06 100644
--- a/icepack/solvers/flow_solver.py
+++ b/icepack/solvers/flow_solver.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2020 by Daniel Shapero <shapero@uw.edu>
+# Copyright (C) 2020-2021 by Daniel Shapero <shapero@uw.edu>
 #
 # This file is part of icepack.
 #
@@ -167,7 +167,10 @@ def setup(self, **kwargs):
                 elif isinstance(field, firedrake.Function):
                     self._fields[name] = field.copy(deepcopy=True)
                 else:
-                    raise TypeError("Input fields must be Constant or Function!")
+                    raise TypeError(
+                        "Input %s field has type %s, must be Constant or Function!"
+                        % (name, type(field))
+                    )
 
         # Create homogeneous BCs for the Dirichlet part of the boundary
         u = self._fields["velocity"]
@@ -236,7 +239,10 @@ def setup(self, **kwargs):
                 elif isinstance(field, firedrake.Function):
                     self._fields[name] = field.copy(deepcopy=True)
                 else:
-                    raise TypeError("Input fields must be Constant or Function!")
+                    raise TypeError(
+                        "Input %s field has type %s, must be Constant or Function!"
+                        % (name, type(field))
+                    )
 
         # Create homogeneous BCs for the Dirichlet part of the boundary
         u = self._fields["velocity"]
@@ -255,9 +261,7 @@ def setup(self, **kwargs):
         action = self._model.action(**self._fields, **_kwargs)
         F = firedrake.derivative(action, u)
 
-        degree = self._model.quadrature_degree(**self._fields)
-        params = {"form_compiler_parameters": {"quadrature_degree": degree}}
-        problem = firedrake.NonlinearVariationalProblem(F, u, bcs, **params)
+        problem = firedrake.NonlinearVariationalProblem(F, u, bcs)
         self._solver = firedrake.NonlinearVariationalSolver(
             problem, solver_parameters=self._solver_parameters
         )
@@ -301,7 +305,10 @@ def setup(self, **kwargs):
                 elif isinstance(field, firedrake.Function):
                     self._fields[name] = field.copy(deepcopy=True)
                 else:
-                    raise TypeError("Input fields must be Constant or Function!")
+                    raise TypeError(
+                        "Input %s field has type %s, must be Constant or Function!"
+                        % (name, type(field))
+                    )
 
         dt = firedrake.Constant(1.0)
         dh_dt = self._continuity(dt, **self._fields)
@@ -358,7 +365,10 @@ def setup(self, **kwargs):
                 elif isinstance(field, firedrake.Function):
                     self._fields[name] = field.copy(deepcopy=True)
                 else:
-                    raise TypeError("Input fields must be Constant or Function!")
+                    raise TypeError(
+                        "Input %s field has type %s, must be Constant or Function!"
+                        % (name, type(field))
+                    )
 
         dt = firedrake.Constant(1.0)
         h = self._fields["thickness"]
diff --git a/icepack/solvers/heat_transport.py b/icepack/solvers/heat_transport.py
index 94f6f0315..b888cee19 100644
--- a/icepack/solvers/heat_transport.py
+++ b/icepack/solvers/heat_transport.py
@@ -45,7 +45,10 @@ def _setup(self, **kwargs):
                 elif isinstance(field, firedrake.Function):
                     self._fields[name] = field.copy(deepcopy=True)
                 else:
-                    raise TypeError("Input fields must be Constant or Function!")
+                    raise TypeError(
+                        "Input %s field has type %s, must be Constant or Function!"
+                        % (name, type(field))
+                    )
 
         dt = Constant(1.0)
 
diff --git a/icepack/utilities.py b/icepack/utilities.py
index 59e24669e..7bb655faa 100644
--- a/icepack/utilities.py
+++ b/icepack/utilities.py
@@ -128,12 +128,61 @@ def lift3d(q2d, Q3D):
     return q3d
 
 
+def vertically_integrate(q,h):
+    r"""
+    q : firedrake.Function
+        integrand
+    h : firedrake.Function
+        ice thickness
+    """
+    def weight(n,ζ):
+        norm=(1/sympy.integrate(_legendre(n,ζ)**2,(ζ,0,1)))**.5
+        return sympy.lambdify(ζ,norm*_legendre(n,ζ),'numpy')
+
+    def coefficient(n,q,ζ,ζsym,Q):
+        a_n=depth_average(q,weight=weight(n,ζsym)(ζ))
+        a_n3d=lift3d(a_n,Q)
+        return a_n3d
+
+    def recurrance_relation(n,ζ):
+        if n>0:
+            return sympy.lambdify(ζ,(1/(2*(2*n+1)))*(_legendre(n+1,ζ)-_legendre(n-1,ζ)),'numpy')
+        elif n==0:
+            return sympy.lambdify(ζ,ζ,'numpy')
+        if n<0:
+            raise ValueError("n must be positive")
+
+    Q=h.function_space()
+    mesh=Q.mesh()
+    x,y,ζ=firedrake.SpatialCoordinate(mesh)
+    xdegree_q,zdegree_q=q.ufl_element().degree()
+
+    ζsym = sympy.symbols('ζsym', real=True, positive=True)
+
+    q_int=sum([coefficient(k,q,ζ,ζsym,Q) * recurrance_relation(k,ζsym)(ζ) for k in range(zdegree_q)])
+    return q_int
+
+def vertical_velocity(u,h,m=0.0):
+    r"""
+    u : firedrake.Function
+        ice velocity
+    h : firedrake.Function
+        ice thickness
+    m : firedrake.Function
+        basal vertical velocity
+    """
+    Q = h.function_space()
+    mesh = Q.mesh()
+    xdegree_u, zdegree_u = u.ufl_element().degree()
+    W = firedrake.FunctionSpace(mesh,family='CG',degree=xdegree_u,vfamily='GL',vdegree=zdegree_u)
+    u_div = firedrake.interpolate(u[0].dx(0)+u[1].dx(1),W)
+    return (m/h-vertically_integrate(u_div,h))
+
+
 def add_kwarg_wrapper(func):
     signature = inspect.signature(func)
-    if any(
-        str(signature.parameters[param].kind) == "VAR_KEYWORD"
-        for param in signature.parameters
-    ):
+    if any(str(signature.parameters[param].kind) == 'VAR_KEYWORD'
+           for param in signature.parameters):
         return func
 
     params = signature.parameters
@@ -143,3 +192,4 @@ def wrapper(*args, **kwargs):
         return func(*args, **kwargs_)
 
     return wrapper
+
diff --git a/notebooks/tutorials/10-age-advection.ipynb b/notebooks/tutorials/10-age-advection.ipynb
new file mode 100644
index 000000000..9e87be36d
--- /dev/null
+++ b/notebooks/tutorials/10-age-advection.ipynb
@@ -0,0 +1,582 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import firedrake\n",
+    "import icepack, icepack.models, icepack.plot\n",
+    "from icepack.constants import ice_density as ρ_I, water_density as ρ_W"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Lx, Ly = 50e3, 12e3\n",
+    "nx, ny = 48, 32\n",
+    "mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)\n",
+    "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)\n",
+    "V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from icepack.constants import (ice_density as ρ_I, water_density as ρ_W,\n",
+    "                               gravity as g)\n",
+    "\n",
+    "x, y, ζ = firedrake.SpatialCoordinate(mesh)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b_in, b_out = 200, -400\n",
+    "b = firedrake.interpolate(b_in - (b_in - b_out) * x / Lx, Q)\n",
+    "\n",
+    "s_in, s_out = 850, 50\n",
+    "s0 = firedrake.interpolate(s_in - (s_in - s_out) * x / Lx, Q)\n",
+    "\n",
+    "h0 = firedrake.interpolate(s0 - b, Q)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "h_in = s_in - b_in\n",
+    "δs_δx = (s_out - s_in) / Lx\n",
+    "τ_D = -ρ_I * g * h_in * δs_δx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u_in, u_out = 0.0, 2400\n",
+    "velocity_x = u_in + (u_out - u_in) * (x/Lx)**2\n",
+    "u0 = firedrake.interpolate(firedrake.as_vector((velocity_x, 0)), V)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "age=firedrake.interpolate(firedrake.Constant(0.0),Q3D)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "temp = 255.0\n",
+    "A = firedrake.Constant(icepack.rate_factor(temp))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from icepack.constants import weertman_sliding_law as m\n",
+    "C = firedrake.interpolate((0.95 - 0.40 * firedrake.sin(10*firedrake.pi*x/Lx)) * τ_D / 20.0**(1/m),Q)\n",
+    "\n",
+    "p_W = ρ_W * g * firedrake.max_value(0, h0 - s0)\n",
+    "p_I = ρ_I * g * h0\n",
+    "ϕ = 1 - p_W / p_I"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "beta = firedrake.interpolate(C,Q)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import icepack.models.hybrid\n",
+    "def friction(**kwargs):\n",
+    "    u = kwargs['velocity']\n",
+    "    h = kwargs['thickness']\n",
+    "    s = kwargs['surface']\n",
+    "    C = kwargs['friction']\n",
+    "    \n",
+    "    p_W = ρ_W * g * firedrake.max_value(0, h - s)\n",
+    "    p_I = ρ_I * g * h\n",
+    "    ϕ = 1 - p_W / p_I\n",
+    "    return icepack.models.hybrid.bed_friction(\n",
+    "        velocity=u, \n",
+    "        friction=C * ϕ\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = icepack.models.HybridModel(friction=friction)\n",
+    "opts = {'dirichlet_ids': [1], 'side_wall_ids': [3, 4]}\n",
+    "solver = icepack.solvers.FlowSolver(model, **opts)\n",
+    "\n",
+    "u0 = solver.diagnostic_solve(\n",
+    "    velocity=u0,\n",
+    "    thickness=h0,\n",
+    "    surface=s0,\n",
+    "    fluidity=A,\n",
+    "    friction=C\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "age_model = icepack.models.AgeTransport()\n",
+    "age_solver = icepack.solvers.AgeSolver(age_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tqdm\n",
+    "import os\n",
+    "num_years = 2000\n",
+    "timesteps_per_year = .2\n",
+    "\n",
+    "δt = 1.0 / timesteps_per_year\n",
+    "num_timesteps = int(num_years * timesteps_per_year)\n",
+    "\n",
+    "a = firedrake.interpolate(firedrake.Constant(1.0), Q)\n",
+    "h = h0.copy(deepcopy=True)\n",
+    "u = u0.copy(deepcopy=True)\n",
+    "s = icepack.compute_surface(thickness=h, bed=b)\n",
+    "\n",
+    "if not os.path.exists('degree-5.h5'):\n",
+    "    for step in tqdm.trange(num_timesteps):\n",
+    "        h = solver.prognostic_solve(\n",
+    "            δt,\n",
+    "            thickness=h,\n",
+    "            velocity=u,\n",
+    "            accumulation=a,\n",
+    "            thickness_inflow=h0\n",
+    "        )\n",
+    "        s = icepack.compute_surface(thickness=h, bed=b)\n",
+    "    \n",
+    "        u = solver.diagnostic_solve(\n",
+    "            velocity=u,\n",
+    "            thickness=h,\n",
+    "            surface=s,\n",
+    "            fluidity=A,\n",
+    "            friction=C\n",
+    "        )\n",
+    "    \n",
+    "    with firedrake.DumbCheckpoint(\n",
+    "        'degree-5', mode=firedrake.FILE_CREATE\n",
+    "    ) as checkpoint:\n",
+    "        checkpoint.store(h, name='thickness')\n",
+    "        checkpoint.store(s, name='surface')\n",
+    "        checkpoint.store(u, name='velocity')\n",
+    "\n",
+    "else:    \n",
+    "    with firedrake.DumbCheckpoint(\n",
+    "        'degree-5', mode=firedrake.FILE_READ\n",
+    "    ) as checkpoint:\n",
+    "        checkpoint.load(h, name='thickness')\n",
+    "        checkpoint.load(s, name='surface')\n",
+    "        checkpoint.load(u, name='velocity')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(6305,)"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "h.dat.data.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "1\n",
+      "2\n",
+      "3\n",
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "Q3D = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])\n",
+    "w=firedrake.interpolate(h*icepack.utilities.vertical_velocity(u,h),Q3D)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "xs = np.array([(Lx * k / nx, 0, .5) for k in range(nx + 1)])\n",
+    "ss = np.array(s.at(xs, tolerance=1e-10))\n",
+    "hs = np.array(h.at(xs, tolerance=1e-10))\n",
+    "bs = np.array(b.at(xs, tolerance=1e-10))\n",
+    "\n",
+    "fig, axes = plt.subplots()\n",
+    "axes.plot(xs[:, 0], bs, color='black')\n",
+    "axes.plot(xs[:, 0], ss - hs, color='blue')\n",
+    "axes.plot(xs[:, 0], ss, color='blue')\n",
+    "plt.show(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.collections import LineCollection\n",
+    "from matplotlib.colors import ListedColormap, BoundaryNorm\n",
+    "\n",
+    "nz=20\n",
+    "\n",
+    "xz = np.array([(Lx * k / nx, 0, i)  for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n",
+    "wM= np.array(w.at(xz, tolerance=1e-10))\n",
+    "wM=np.reshape(wM,(49,nz));\n",
+    "xz=np.reshape(xz,(49,nz,3));\n",
+    "hz=np.reshape(np.repeat(hs,nz),(49,nz));\n",
+    "hz=np.multiply(xz[:,:,2],hz);\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots()\n",
+    "for i in range(0,nz):\n",
+    "    points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n",
+    "    segments = np.concatenate([points[:-1], points[1:]], axis=1)\n",
+    "    norm = plt.Normalize(-5, 0)\n",
+    "    lc = LineCollection(segments, cmap='viridis', norm=norm)\n",
+    "    # Set the values used for colormapping\n",
+    "    lc.set_array(np.squeeze(wM[:,nz-1-i]))\n",
+    "    lc.set_linewidth(2)\n",
+    "    line = axs.add_collection(lc)\n",
+    "axs.set_xlim(xz.min(), xz.max())\n",
+    "axs.set_ylim(bs.min(), ss.max())\n",
+    "axs.plot(xs[:, 0], bs, color='black')\n",
+    "fig.colorbar(line, ax=axs,label=r'vertical velocity.$(m\\dota^{-1})$')\n",
+    "axs.set_ylabel('elevation.(m)')\n",
+    "axs.set_xlabel('distance.(km)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 50000/50000 [14:32:07<00:00,  1.05s/it]  \n"
+     ]
+    }
+   ],
+   "source": [
+    "import tqdm\n",
+    "\n",
+    "num_years = 500000.0\n",
+    "timesteps_per_year = 0.1\n",
+    "\n",
+    "δt = 1.0 / timesteps_per_year\n",
+    "num_timesteps = int(num_years * timesteps_per_year)\n",
+    "\n",
+    "for step in tqdm.trange(num_timesteps):\n",
+    "    age = age_solver.solve(δt,velocity=u,thickness=h,age=age)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "xz = np.array([(Lx * k / nx, 0, i)  for k in range(nx + 1) for i in np.arange(0,1.0,1.0/nz)])\n",
+    "ageM= np.array(age.at(xz, tolerance=1e-10))\n",
+    "ageM=np.reshape(ageM,(49,nz));\n",
+    "xz=np.reshape(xz,(49,nz,3));"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots()\n",
+    "for i in range(0,nz):\n",
+    "    points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n",
+    "    segments = np.concatenate([points[:-1], points[1:]], axis=1)\n",
+    "    norm = plt.Normalize(0,7000)\n",
+    "    lc = LineCollection(segments, cmap='viridis', norm=norm)\n",
+    "    # Set the values used for colormapping\n",
+    "    lc.set_array(np.squeeze(ageM[:,nz-1-i]))\n",
+    "    lc.set_linewidth(2)\n",
+    "    line = axs.add_collection(lc)\n",
+    "axs.set_xlim(xz.min(), xz.max())\n",
+    "axs.set_ylim(bs.min(), ss.max())\n",
+    "axs.plot(xs[:, 0], bs, color='black')\n",
+    "fig.colorbar(line, ax=axs,label=r'age.$(m\\dota^{-1})$')\n",
+    "axs.set_ylabel('elevation.(m)')\n",
+    "axs.set_xlabel('distance.(km)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-6052891.767930022"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "np.min(age.dat.data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 2.61333974e+03,  1.17069687e+03,  7.34421997e+02, ...,\n",
+       "        2.28430834e+06,  8.62113463e+04, -3.96973319e+05])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "age.dat.data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "age_model = icepack.models.AgeTransport()\n",
+    "age_solver = icepack.solvers.AgeSolver(age_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Method of characteristics\n",
+    "We use the method of characteristics to solve the age equation, which can be written as\n",
+    "\n",
+    "$$\\vec{u}\\cdot\\nabla \\mathcal{A} + \\frac{\\partial\\mathcal{A}}{\\partial t} = 1$$.\n",
+    "\n",
+    "We want to transform this linear first-order PDE into an ODE along the appropriate curve; i.e. something of the form\n",
+    "\n",
+    "$$\\frac{d}{ds} \\mathcal{A}(x(s),t(s) = F(\\mathcal{A},x(s),t(s))$$\n",
+    "\n",
+    "where (x(s),t(s)) is the characteristic volume. Using the chain rule, we can rewrite this description of the age evolution as\n",
+    "\n",
+    "$$\\frac{d}{ds} \\mathcal{A}(x(s),t(s) = \\frac{\\partial \\mathcal{A}}{\\partial x} \\frac{d x}{d s} +\\frac{\\partial \\mathcal{A}}{\\partial y} \\frac{d y}{d s} +\\frac{\\partial \\mathcal{A}}{\\partial z} \\frac{d z}{d s} + \\frac{\\partial \\mathcal{A}}{\\partial t} \\frac{dt}{ds}.$$\n",
+    "\n",
+    "If we set $\\frac{d t}{d s} = 1$ and $\\frac{d \\vec{x}}{d s} = \\vec{u}$, we see that \n",
+    "\n",
+    "$$\\frac{d}{ds} \\mathcal{A}(x(s),t(s) = \\vec{u}\\cdot\\nabla \\mathcal{A}+ \\frac{\\partial\\mathcal{A}}{\\partial t}, $$ \n",
+    "\n",
+    "which is just the left hand side of the PDE we started with. Thus, \n",
+    "\n",
+    "$$\\frac{d \\mathcal{A}}{ds} = 1$$\n",
+    "\n",
+    "$$\\frac{d t}{ds} = 1$$\n",
+    "\n",
+    "$$\\frac{d x}{ds} = \\vec{u}$$\n",
+    "\n",
+    "and the original PDE becomes a system of ordinary differential equations that we can solve with respect to s.\n",
+    "\n",
+    "Letting $t(s=0)=0$, we know $t=s$.\n",
+    "\n",
+    "Letting $x(s=0)=x_0$, we know $x=us+x_0=ut+x_0$\n",
+    "\n",
+    "Letting $\\mathcal{A}(s=0)=f(x_0)+s$, we know $\\mathcal{A}(x(t),t)=f(x_0)+t=f(x-ut)+t$\n",
+    "\n",
+    "In 3D, this is $\\mathcal{A}(x(t),t)==f(x_0,y_0,z_0)+t=f(x-ut,y-vt,z-wt)+t$\n",
+    "\n",
+    "\n",
+    "$\\frac{d}{dt}(A(x(t),t)) = \\frac{\\partial}{\\partial t}(A(x(t),t) + \\frac{\\partial}{\\partial x}(A(x(t),t)x’(t)$\n",
+    "\n",
+    "$x = x_0 + ut$\\\n",
+    "$y = y_0 + vt$\\\n",
+    "$z = z_0 + wt$\\\n",
+    "$a = a_0 + t$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "firedrake",
+   "language": "python",
+   "name": "firedrake"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/tutorials/age_model_test.ipynb b/notebooks/tutorials/age_model_test.ipynb
new file mode 100644
index 000000000..1f8f9fb7c
--- /dev/null
+++ b/notebooks/tutorials/age_model_test.ipynb
@@ -0,0 +1,308 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e7a6fbb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import firedrake\n",
+    "import icepack, icepack.models, icepack.plot\n",
+    "from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b5215d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Lx, Ly = 1e3, 1e3\n",
+    "nx, ny = 20, 20\n",
+    "mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)\n",
+    "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f3d9428",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)\n",
+    "V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6)\n",
+    "Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ded40a3b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x, y, ζ = firedrake.SpatialCoordinate(mesh)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b333544",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b = firedrake.interpolate(firedrake.Constant(0.0), Q)\n",
+    "s = firedrake.interpolate(firedrake.Constant(1000), Q)\n",
+    "h = firedrake.interpolate(s - b, Q)\n",
+    "\n",
+    "ux = firedrake.Constant(40)\n",
+    "uy = firedrake.Constant(0)\n",
+    "uz = firedrake.Constant(-40)\n",
+    "u = firedrake.interpolate(firedrake.as_vector((ux, uy)), V)\n",
+    "w = firedrake.interpolate(uz/h,Q3D)\n",
+    "\n",
+    "num_years = 10.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4bcc677",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create a mask assuming age propogation from upper left to lower right\n",
+    "x_eval_min = 0 + ux.dat.data[0] * num_years\n",
+    "#x_eval_max = Lx\n",
+    "y_eval_min = 0 + uy.dat.data[0] * num_years\n",
+    "#y_eval_max = Ly\n",
+    "#z_eval_min = 0\n",
+    "z_eval_max = (h.dat.data[0] + uz.dat.data[0] * num_years) / h.dat.data[0]\n",
+    "\n",
+    "#if (x_eval_max <= x_eval_min) or (y_eval_max <= y_eval_min) or (z_eval_max <= z_eval_min):\n",
+    "#    raise ValueError('No points to evaluate.')\n",
+    "    \n",
+    "mask_x = firedrake.conditional(x<x_eval_min,0,1)\n",
+    "mask_y = firedrake.conditional(y<y_eval_min,0,1)\n",
+    "mask_z = firedrake.conditional(ζ>z_eval_max,0,1)\n",
+    "mask = mask_x * mask_y * mask_z\n",
+    "\n",
+    "fig, axes = icepack.plot.subplots()\n",
+    "colors = icepack.plot.tripcolor(firedrake.interpolate(mask, Q3D), axes=axes)\n",
+    "fig.colorbar(colors, label='mask')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c43e4bbd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def velocity_3D(**kwargs):\n",
+    "    u = kwargs['velocity']\n",
+    "    h = kwargs['thickness']\n",
+    "    uz = kwargs['uz']\n",
+    "    \n",
+    "    Q = h.function_space()\n",
+    "    V = u.function_space()\n",
+    "    mesh = Q.mesh()\n",
+    "    xdegree_u, zdegree_u = u.ufl_element().degree()\n",
+    "    W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])\n",
+    "    w = firedrake.interpolate(uz/h,W)\n",
+    "    V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1)\n",
+    "    u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w)))\n",
+    "    \n",
+    "    return u3D"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8061ed45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "u3D = velocity_3D(velocity=u, thickness=h, uz=uz)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "679e063f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "age_model = icepack.models.AgeTransport(velocity_3D=velocity_3D)\n",
+    "age_solver = icepack.solvers.AgeSolver(age_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32dae83c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tqdm\n",
+    "import numpy as np\n",
+    "\n",
+    "x0=0\n",
+    "y0=0\n",
+    "z0=900\n",
+    "age0=0\n",
+    "\n",
+    "timesteps_per_year = [5.0, 6.0, 7.0, 8.0, 9.0, 10.0]\n",
+    "\n",
+    "L1s = []\n",
+    "\n",
+    "for tpy in timesteps_per_year:\n",
+    "    \n",
+    "    age = firedrake.interpolate(firedrake.Constant(0.0),Q3D)\n",
+    "\n",
+    "    δt = 1.0 / tpy\n",
+    "    num_timesteps = int(num_years * tpy)\n",
+    "    \n",
+    "    num_age = np.zeros((num_timesteps,1))*np.nan\n",
+    "    ana_age = np.zeros((num_timesteps,1))*np.nan\n",
+    "    ts = np.zeros((num_timesteps,1))*np.nan\n",
+    "\n",
+    "    for step in tqdm.trange(num_timesteps):\n",
+    "        age = age_solver.solve(δt,velocity=u,thickness=h,age=age,uz=uz)\n",
+    "        t = step*δt\n",
+    "        ts[step] = t\n",
+    "        num_age[step] = age.at(x0+ux*t,y0+uy*t,(z0+uz*t)/1000,tolerance=1e-10)\n",
+    "        ana_age[step] = age0+t\n",
+    "    \n",
+    "    num_sol = firedrake.interpolate(age*mask, Q3D)\n",
+    "    ana_sol = firedrake.interpolate((age0+t)*mask, Q3D)\n",
+    "\n",
+    "    J = (num_sol-ana_sol) * firedrake.dx\n",
+    "    L1 = firedrake.assemble(J)\n",
+    "    L1s += [L1]\n",
+    "    print(tpy, L1)\n",
+    "    \n",
+    "    #plt.figure()\n",
+    "    #plt.plot(ts,num_age,label=\"numerical\")\n",
+    "    #plt.plot(ts,ana_age,label=\"analytical\")\n",
+    "    #plt.legend()\n",
+    "\n",
+    "    plt.figure()\n",
+    "    plt.plot(ts,num_age-ana_age,label=\"numerical-analytical\")\n",
+    "    plt.legend()\n",
+    "    plt.title(str(tpy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74af964c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.plot(1/np.array(timesteps_per_year),L1s,'ko')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2467b21d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(num_sol.dat.data.max())\n",
+    "print(ana_sol.dat.data.max())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3d5b6949",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib.collections import LineCollection\n",
+    "from matplotlib.colors import ListedColormap, BoundaryNorm\n",
+    "\n",
+    "nz=20\n",
+    "\n",
+    "xs = np.array([(Lx * k / nx, 0, .5) for k in range(nx + 1)])\n",
+    "ss = np.array(s.at(xs, tolerance=1e-10))\n",
+    "hs = np.array(h.at(xs, tolerance=1e-10))\n",
+    "bs = np.array(b.at(xs, tolerance=1e-10))\n",
+    "\n",
+    "xz = np.array([(Lx * k / nx, 0, i)  for k in range(nx + 1) for i in np.arange(0,1.0,1.0/nz)])\n",
+    "ageM= np.array(age.at(xz, tolerance=1e-10))\n",
+    "ageM=np.reshape(ageM,(21,nz));\n",
+    "xz=np.reshape(xz,(21,nz,3));\n",
+    "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n",
+    "hz=np.multiply(xz[:,:,2],hz);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6b3b892",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axs = plt.subplots()\n",
+    "for i in range(0,nz):\n",
+    "    points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n",
+    "    segments = np.concatenate([points[:-1], points[1:]], axis=1)\n",
+    "    norm = plt.Normalize(0,20)\n",
+    "    lc = LineCollection(segments, cmap='RdBu', norm=norm)\n",
+    "    # Set the values used for colormapping\n",
+    "    lc.set_array(np.squeeze(ageM[:,nz-1-i]))\n",
+    "    lc.set_linewidth(2)\n",
+    "    line = axs.add_collection(lc)\n",
+    "axs.set_xlim(xz.min(), xz.max())\n",
+    "axs.set_ylim(bs.min(), ss.max())\n",
+    "axs.plot(xs[:, 0], bs, color='black')\n",
+    "fig.colorbar(line, ax=axs,label=r'age $(years)$')\n",
+    "axs.set_ylabel('elevation (m)')\n",
+    "axs.set_xlabel('distance (m)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b99f076",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axes = icepack.plot.subplots()\n",
+    "colors = icepack.plot.tripcolor(firedrake.interpolate(num_sol-ana_sol, Q3D), axes=axes)\n",
+    "fig.colorbar(colors, label='masked age')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "firedrake",
+   "language": "python",
+   "name": "firedrake"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/test/age_transport_test.py b/test/age_transport_test.py
new file mode 100644
index 000000000..f3728dbe1
--- /dev/null
+++ b/test/age_transport_test.py
@@ -0,0 +1,177 @@
+# Copyright (C) 2021 by Jessica Badgeley <badgeley@uw.edu> and
+# Andrew Hoffman <hoffmaao@uw.edu>
+#
+# This file is part of icepack.
+#
+# icepack is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The full text of the license can be found in the file LICENSE in the
+# icepack source directory or at <http://www.gnu.org/licenses/>.
+
+import firedrake
+from firedrake import (
+    interpolate,
+    conditional,
+    Constant,
+    dx,
+    assemble,
+)
+import icepack
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Test our numerical solver against a simple, analytical solution.
+num_years = 10.0
+Lx, Ly = 1.e3, 1.e3
+ux = Constant(40.)
+uy = Constant(0.)
+uz = Constant(-40.)
+dts = [1/5.0, 1/6.0, 1/7.0, 1/8.0, 1/9.0]
+dx_constant = 50.
+dxs = [100., 75., 50., 40., 30.]
+dt_constant = 3./25.
+age0 = 0.
+
+def velocity_3D(**kwargs):
+    u = kwargs['velocity']
+    h = kwargs['thickness']
+    uz = kwargs['uz']
+    Q = h.function_space()
+    V = u.function_space()
+    mesh = Q.mesh()
+    xdegree_u, zdegree_u = u.ufl_element().degree()
+    W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])
+    w = firedrake.interpolate(uz/h,W)
+    V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1)
+    u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w)))
+    return u3D
+
+def create_mask(x, y, ζ, h):
+    x_min = ux.dat.data[0] * num_years
+    y_min = uy.dat.data[0] * num_years
+    ζ_max = (h.dat.data[0] + uz.dat.data[0] * num_years) / h.dat.data[0]
+    mask_x = conditional(x < x_min, 0, 1)
+    mask_y = conditional(y < y_min, 0, 1)
+    mask_ζ = conditional(ζ > ζ_max, 0, 1)
+    return mask_x * mask_y * mask_ζ
+
+def create_mesh_function_spaces(nx, ny):
+    mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)
+    mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
+    Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)
+    V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6)
+    # Would this go faster if I decreased the vdegree, which would probably be okay since I'm using a constant vertical velocity)
+    Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])
+    return mesh, Q, V, Q3D
+
+def create_variables(Q, V, Q3D):
+    b = interpolate(firedrake.Constant(0.0), Q)
+    s = interpolate(firedrake.Constant(Lx), Q)
+    h = interpolate(s - b, Q)
+    u = interpolate(firedrake.as_vector((ux, uy)), V)
+    w = interpolate(uz/h, Q3D)
+    return b, s, h, u, w
+
+def norm(v):
+    return icepack.norm(v, norm_type="L2")
+
+def test_diagnostic_solver_convergence_time():
+    nx, ny = int(Lx/dx_constant), int(Ly/dx_constant)
+    mesh, Q, V, Q3D = create_mesh_function_spaces(nx, ny)
+    b, s, h, u, w = create_variables(Q, V, Q3D)
+    x, y, ζ = firedrake.SpatialCoordinate(mesh)
+    mask = create_mask(x, y, ζ, h)
+    u3D = velocity_3D(velocity=u, thickness=h, uz=uz)
+    age_model = icepack.models.AgeTransport(velocity_3D=velocity_3D)
+    age_solver = icepack.solvers.AgeSolver(age_model)
+    
+    errors = []
+
+    for dt in dts:
+        
+        age = interpolate(Constant(age0),Q3D) 
+        num_timesteps = int(num_years / dt)
+
+        for step in range(num_timesteps):
+            
+            t = step*dt
+            age = age_solver.solve(dt,velocity=u,thickness=h,age=age,uz=uz)            
+        age_num = interpolate(age * mask, Q3D)
+        age_exact = interpolate((age0 + t) * mask, Q3D)
+
+        #errors = [assemble((age_exact - age_num) * dx)/assemble(age_exact * dx)
+        #errors += [assemble((age_num - age_exact) * dx)]
+        errors += [norm(age_exact - age_num) / norm(age_exact)]
+
+    print(dts)
+    print(errors)    
+
+    plt.figure()
+    plt.plot(dts, errors, 'ko')
+    plt.show()
+
+    log_dt = np.log2(np.array(dts))
+    log_error = np.log2(np.array(errors))
+    print(log_dt)
+    print(log_error)
+    slope, intercept = np.polyfit(log_dt, log_error, 1)
+
+    plt.figure()
+    plt.plot(log_dt, log_error, 'ko')
+    plt.show()
+
+    print(f"error ~= {slope:g} * dt + {intercept:g}")
+    assert slope > 0
+
+def test_diagnostic_solver_convergence_space():
+    
+    num_timesteps = int(num_years / dt_constant)
+    errors = []
+
+    for dx_val in dxs:
+    
+        nx, ny = int(Lx/dx_val), int(Ly/dx_val)
+        mesh, Q, V, Q3D = create_mesh_function_spaces(nx, ny)
+        b, s, h, u, w = create_variables(Q, V, Q3D)
+        x, y, ζ = firedrake.SpatialCoordinate(mesh)
+        mask = create_mask(x, y, ζ, h)
+        u3D = velocity_3D(velocity=u, thickness=h, uz=uz)
+        age_model = icepack.models.AgeTransport(velocity_3D=velocity_3D)
+        age_solver = icepack.solvers.AgeSolver(age_model)   
+
+        age = interpolate(Constant(age0),Q3D)
+
+        for step in range(num_timesteps):
+
+            t = dt_constant * step
+            age = age_solver.solve(dt_constant,velocity=u,thickness=h,age=age,uz=uz)
+
+        age_num = interpolate(age * mask, Q3D)
+        age_exact = interpolate((age0 + t) * mask, Q3D)
+
+        #errors = [assemble((age_exact - age_num) * dx)/assemble(age_exact * dx)
+        errors += [assemble((age_num - age_exact) * dx)]
+        #errors += [norm(age_exact - age_num) / norm(age_exact)]
+
+    print(dxs)
+    print(errors)    
+
+    plt.figure()
+    plt.plot(dxs, errors, 'ko')
+    plt.show()
+
+    log_dx = np.log2(np.array(dxs))
+    log_error = np.log2(np.array(errors))
+    print(log_dx)
+    print(log_error)
+    slope, intercept = np.polyfit(log_dx, log_error, 1)
+
+    plt.figure()
+    plt.plot(log_dx, log_error, 'ko')
+    plt.show()
+
+    print(f"error ~= {slope:g} * dx + {intercept:g}")
+    assert slope > 0
diff --git a/test/vertical_velocity_test.py b/test/vertical_velocity_test.py
new file mode 100644
index 000000000..ad4f78831
--- /dev/null
+++ b/test/vertical_velocity_test.py
@@ -0,0 +1,52 @@
+# Copyright (C) 2021 by Jessica Badgeley <badgeley@uw.edu>
+#
+# This file is part of icepack.
+#
+# icepack is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The full text of the license can be found in the file LICENSE in the
+# icepack source directory or at <http://www.gnu.org/licenses/>.
+
+import numpy as np
+import firedrake
+import icepack
+import icepack.utilities
+from icepack.constants import (ice_density as ρ_I, water_density as ρ_W,
+                               gravity as g, glen_flow_law as n)
+
+Lx, Ly = 20e3, 20e3
+nx, ny = 48, 48
+
+mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)
+mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)
+
+Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)
+Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=6)
+V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=5)
+# note we should call the families in the vertical velocity solver.
+
+x, y, ζ = firedrake.SpatialCoordinate(mesh)
+
+u_inflow=1.0
+v_inflow=2.0
+mu=.003
+mv=.001
+
+b=firedrake.interpolate(firedrake.Constant(0.0),Q)
+s=firedrake.interpolate(firedrake.Constant(1000.0),Q)
+h = firedrake.interpolate(s-b,Q)
+u=firedrake.interpolate(firedrake.as_vector((mu*x+u_inflow,mv*y+v_inflow)),V)
+
+m=-0.01
+
+def analytic_vertical_velocity(h,ζ,mu,mv,m,Q3D):
+        return firedrake.interpolate(firedrake.Constant(m)-(firedrake.Constant(mu+mv)*h*ζ),Q3D)
+
+w=firedrake.interpolate(icepack.utilities.vertical_velocity(u,h,m=m)*h,Q3D)
+w_analytic=analytic_vertical_velocity(h,ζ,mu,mv,m,Q3D)
+
+
+assert(np.mean(np.abs(w.dat.data-w_analytic.dat.data))<10e-10)