diff --git a/compass/ocean/tests/drying_slope/__init__.py b/compass/ocean/tests/drying_slope/__init__.py
index be23b0dc2f..56583b2ff8 100644
--- a/compass/ocean/tests/drying_slope/__init__.py
+++ b/compass/ocean/tests/drying_slope/__init__.py
@@ -15,7 +15,7 @@ def __init__(self, mpas_core):
         super().__init__(mpas_core=mpas_core, name='drying_slope')
 
         for resolution in [0.25, 1]:
-            for coord_type in ['sigma']:
+            for coord_type in ['sigma', 'single_layer']:
                 self.add_test_case(
                     Default(test_group=self, resolution=resolution,
                             coord_type=coord_type))
diff --git a/compass/ocean/tests/drying_slope/default/__init__.py b/compass/ocean/tests/drying_slope/default/__init__.py
index 7e50af7dfb..0108f7c63b 100644
--- a/compass/ocean/tests/drying_slope/default/__init__.py
+++ b/compass/ocean/tests/drying_slope/default/__init__.py
@@ -2,6 +2,7 @@
 from compass.ocean.tests.drying_slope.initial_state import InitialState
 from compass.ocean.tests.drying_slope.forward import Forward
 from compass.ocean.tests.drying_slope.viz import Viz
+from compass.validate import compare_variables
 
 
 class Default(TestCase):
@@ -43,13 +44,21 @@ def __init__(self, test_group, resolution, coord_type):
         subdir = f'{res_name}/{coord_type}/{name}'
         super().__init__(test_group=test_group, name=name,
                          subdir=subdir)
-
-        self.add_step(InitialState(test_case=self))
-        for damping_coeff in [0.0025, 0.01]:
+        self.add_step(InitialState(test_case=self, coord_type=coord_type))
+        if coord_type == 'single_layer':
             self.add_step(Forward(test_case=self, resolution=resolution,
                                   cores=4, threads=1,
-                                  damping_coeff=damping_coeff))
-        self.add_step(Viz(test_case=self))
+                                  coord_type=coord_type))
+            damping_coeffs = None
+        else:
+            damping_coeffs = [0.0025, 0.01]
+            for damping_coeff in damping_coeffs:
+                self.add_step(Forward(test_case=self, resolution=resolution,
+                                      cores=4, threads=1,
+                                      damping_coeff=damping_coeff,
+                                      coord_type=coord_type))
+        self.damping_coeffs = damping_coeffs
+        self.add_step(Viz(test_case=self, damping_coeffs=damping_coeffs))
 
     def configure(self):
         """
@@ -67,3 +76,18 @@ def configure(self):
                    'mesh cells in the y direction')
         config.set('drying_slope', 'dc', f'{dc}', comment='the distance '
                    'between adjacent cell centers')
+
+    def validate(self):
+        """
+        Validate variables against a baseline
+        """
+        damping_coeffs = self.damping_coeffs
+        variables = ['layerThickness', 'normalVelocity']
+        if damping_coeffs is not None:
+            for damping_coeff in damping_coeffs:
+                compare_variables(test_case=self, variables=variables,
+                                  filename1=f'forward_{damping_coeff}/'
+                                            'output.nc')
+        else:
+            compare_variables(test_case=self, variables=variables,
+                              filename1='forward/output.nc')
diff --git a/compass/ocean/tests/drying_slope/drying_slope.cfg b/compass/ocean/tests/drying_slope/drying_slope.cfg
index 4bc41c4e2f..31c514c747 100644
--- a/compass/ocean/tests/drying_slope/drying_slope.cfg
+++ b/compass/ocean/tests/drying_slope/drying_slope.cfg
@@ -4,9 +4,6 @@
 # Number of vertical levels
 vert_levels = 10
 
-# The type of vertical coordinate (e.g. z-level, z-star)
-coord_type = sigma
-
 # config options for drying slope test cases
 [drying_slope]
 
diff --git a/compass/ocean/tests/drying_slope/forward.py b/compass/ocean/tests/drying_slope/forward.py
index f7646c55bd..e3bd47131f 100644
--- a/compass/ocean/tests/drying_slope/forward.py
+++ b/compass/ocean/tests/drying_slope/forward.py
@@ -8,7 +8,8 @@ class Forward(Step):
     test cases.
     """
     def __init__(self, test_case, resolution, name='forward', subdir=None,
-                 cores=1, min_cores=None, threads=1, damping_coeff=None):
+                 cores=1, min_cores=None, threads=1, damping_coeff=None,
+                 coord_type='sigma'):
         """
         Create a new test case
 
@@ -58,6 +59,8 @@ def __init__(self, test_case, resolution, name='forward', subdir=None,
             res_name = f'{int(resolution)}km'
         self.add_namelist_file('compass.ocean.tests.drying_slope',
                                f'namelist.{res_name}.forward')
+        self.add_namelist_file('compass.ocean.tests.drying_slope',
+                               f'namelist.{coord_type}.forward')
         if damping_coeff is not None:
             # update the Rayleigh damping coeff to the requested value
             options = {'config_Rayleigh_damping_coeff': f'{damping_coeff}'}
diff --git a/compass/ocean/tests/drying_slope/initial_state.py b/compass/ocean/tests/drying_slope/initial_state.py
index b373fc5143..847f83cad2 100644
--- a/compass/ocean/tests/drying_slope/initial_state.py
+++ b/compass/ocean/tests/drying_slope/initial_state.py
@@ -14,7 +14,7 @@ class InitialState(Step):
     A step for creating a mesh and initial condition for drying slope test
     cases
     """
-    def __init__(self, test_case):
+    def __init__(self, test_case, coord_type='sigma'):
         """
         Create the step
 
@@ -26,6 +26,8 @@ def __init__(self, test_case):
         super().__init__(test_case=test_case, name='initial_state', cores=1,
                          min_cores=1, threads=1)
 
+        self.coord_type = coord_type
+
         self.add_namelist_file('compass.ocean.tests.drying_slope',
                                'namelist.init', mode='init')
 
@@ -45,6 +47,18 @@ def run(self):
         config = self.config
         logger = self.logger
 
+        config = self.config
+        section = config['vertical_grid']
+        coord_type = self.coord_type
+        if coord_type == 'single_layer':
+            options = {'config_tidal_boundary_vert_levels': '1'}
+            self.update_namelist_at_runtime(options)
+        else:
+            vert_levels = section.get('vert_levels')
+            options = {'config_tidal_boundary_vert_levels': f'{vert_levels}',
+                       'config_tidal_boundary_layer_type': f"'{coord_type}'"}
+            self.update_namelist_at_runtime(options)
+
         section = config['drying_slope']
         nx = section.getint('nx')
         ny = section.getint('ny')
diff --git a/compass/ocean/tests/drying_slope/namelist.forward b/compass/ocean/tests/drying_slope/namelist.forward
index f4f986b33e..f8ad67b824 100644
--- a/compass/ocean/tests/drying_slope/namelist.forward
+++ b/compass/ocean/tests/drying_slope/namelist.forward
@@ -18,9 +18,6 @@ config_zero_drying_velocity=.true.
 config_verify_not_dry=.true.
 config_thickness_flux_type='upwind'
 config_use_cvmix=.false.
-config_Rayleigh_friction=.true.
-config_Rayleigh_damping_depth_variable=.true.
-config_Rayleigh_damping_coeff=0.0025
 config_use_implicit_bottom_drag=.false.
 config_use_debugTracers=.true.
 config_check_ssh_consistency=.true.
diff --git a/compass/ocean/tests/drying_slope/namelist.init b/compass/ocean/tests/drying_slope/namelist.init
index e0937b6b87..f1ff98bfc2 100644
--- a/compass/ocean/tests/drying_slope/namelist.init
+++ b/compass/ocean/tests/drying_slope/namelist.init
@@ -1,6 +1,5 @@
 config_init_configuration='tidal_boundary'
 config_ocean_run_mode = 'init'
-config_tidal_boundary_vert_levels=10
 config_tidal_boundary_layer_type='sigma'
 config_tidal_start_dry=.true.
 config_tidal_boundary_left_bottom_depth=0.0
diff --git a/compass/ocean/tests/drying_slope/namelist.sigma.forward b/compass/ocean/tests/drying_slope/namelist.sigma.forward
new file mode 100644
index 0000000000..0ceddce6ce
--- /dev/null
+++ b/compass/ocean/tests/drying_slope/namelist.sigma.forward
@@ -0,0 +1,4 @@
+config_Rayleigh_friction=.true.
+config_Rayleigh_damping_depth_variable=.true.
+config_use_bulk_wind_stress = .false.
+config_pressure_gradient_type = 'pressure_and_zmid'
diff --git a/compass/ocean/tests/drying_slope/namelist.single_layer.forward b/compass/ocean/tests/drying_slope/namelist.single_layer.forward
new file mode 100644
index 0000000000..908750664c
--- /dev/null
+++ b/compass/ocean/tests/drying_slope/namelist.single_layer.forward
@@ -0,0 +1,9 @@
+config_use_explicit_bottom_drag = .true.
+config_explicit_bottom_drag_coeff = 3.0e-3
+config_disable_thick_vadv = .true.
+config_disable_thick_sflux = .true.
+config_disable_vel_hmix = .true.
+config_disable_vel_vmix = .true.
+config_disable_vel_vadv = .true.
+config_disable_tr_all_tend = .true.
+config_pressure_gradient_type = 'ssh_gradient'
diff --git a/compass/ocean/tests/drying_slope/viz/__init__.py b/compass/ocean/tests/drying_slope/viz/__init__.py
index 7852c15bf9..46a96ba7a8 100644
--- a/compass/ocean/tests/drying_slope/viz/__init__.py
+++ b/compass/ocean/tests/drying_slope/viz/__init__.py
@@ -26,7 +26,7 @@ class Viz(Step):
     datatypes : list of str
         The sources of data for comparison to the MPAS-Ocean run
     """
-    def __init__(self, test_case):
+    def __init__(self, test_case, damping_coeffs=None):
         """
         Create the step
 
@@ -37,22 +37,25 @@ def __init__(self, test_case):
         """
         super().__init__(test_case=test_case, name='viz')
 
-        damping_coeffs = [0.0025, 0.01]
         times = ['0.05', '0.15', '0.25', '0.30', '0.40', '0.50']
         datatypes = ['analytical', 'ROMS']
         self.damping_coeffs = damping_coeffs
         self.times = times
         self.datatypes = datatypes
 
-        for damping_coeff in damping_coeffs:
-            self.add_input_file(filename=f'output_{damping_coeff}.nc',
-                                target=f'../forward_{damping_coeff}/output.nc')
-            for time in times:
-                for datatype in datatypes:
-                    filename = f'r{damping_coeff}d{time}-{datatype.lower()}'\
-                               '.csv'
-                    self.add_input_file(filename=filename, target=filename,
-                                        database='drying_slope')
+        if damping_coeffs is None:
+            self.add_input_file(filename='output.nc',
+                                target='../forward/output.nc')
+        else:
+            for coeff in damping_coeffs:
+                self.add_input_file(filename=f'output_{coeff}.nc',
+                                    target=f'../forward_{coeff}/output.nc')
+                for time in times:
+                    for datatype in datatypes:
+                        filename = f'r{coeff}d{time}-{datatype.lower()}'\
+                                   '.csv'
+                        self.add_input_file(filename=filename, target=filename,
+                                            database='drying_slope')
 
     def run(self):
         """
@@ -60,6 +63,8 @@ def run(self):
         """
         section = self.config['paths']
         datapath = section.get('ocean_database_root')
+        section = self.config['vertical_grid']
+        vert_levels = section.get('vert_levels')
         section = self.config['drying_slope_viz']
         generate_movie = section.getboolean('generate_movie')
 
@@ -93,27 +98,35 @@ def _plot_ssh_time_series(self, outFolder='.'):
         markersize = 20
 
         damping_coeffs = self.damping_coeffs
-        fig1, ax1 = plt.subplots(nrows=len(damping_coeffs), ncols=1,
-                                 figsize=figsize, dpi=100)
-        for i, damping_coeff in enumerate(damping_coeffs):
-            ds = xarray.open_dataset(f'output_{damping_coeff}.nc')
+        if damping_coeffs is None:
+            naxes = 1
+            ncFilename = ['output.nc']
+        else:
+            naxes = len(damping_coeffs)
+            ncFilename = [f'output_{damping_coeff}.nc'
+                          for damping_coeff in damping_coeffs]
+        fig, _ = plt.subplots(nrows=naxes, ncols=1, figsize=figsize, dpi=100)
+
+        for i in range(naxes):
+            ax = plt.subplot(naxes, 1, i+1)
+            ds = xarray.open_dataset(ncFilename[i])
             ssh = ds.ssh
             ympas = ds.ssh.where(ds.tidalInputMask).mean('nCells').values
             xmpas = numpy.linspace(0, 1.0, len(ds.xtime))*12.0
-            ax1[i].plot(xmpas, ympas, marker='o', label='MPAS-O forward',
-                        color=colors['MPAS-O'])
-            ax1[i].plot(xSsh, ySsh, lw=3, label='analytical',
-                        color=colors['analytical'])
-            ax1[i].set_ylabel('Tidal amplitude (m)')
+            ax.plot(xmpas, ympas, marker='o', label='MPAS-O forward',
+                    color=colors['MPAS-O'])
+            ax.plot(xSsh, ySsh, lw=3, label='analytical',
+                    color=colors['analytical'])
+            ax.set_ylabel('Tidal amplitude (m)')
+            ax.set_xlabel('Time (hrs)')
+            ax.legend(frameon=False)
+            ax.label_outer()
             ds.close()
 
-        ax1[0].legend(frameon=False)
-        ax1[1].set_xlabel('Time (hrs)')
-
-        fig1.suptitle('Tidal amplitude forcing (right side)')
-        fig1.savefig(f'{outFolder}/ssh_t.png', bbox_inches='tight', dpi=200)
+        fig.suptitle('Tidal amplitude forcing (right side)')
+        fig.savefig(f'{outFolder}/ssh_t.png', bbox_inches='tight', dpi=200)
 
-        plt.close(fig1)
+        plt.close(fig)
 
     def _plot_ssh_validation(self, outFolder='.'):
         """
@@ -125,31 +138,38 @@ def _plot_ssh_validation(self, outFolder='.'):
         locs = [7.2, 2.2, 0.2, 1.2, 4.2, 9.3]
         locs = 0.92 - numpy.divide(locs, 11.)
 
-        times = self.times
         damping_coeffs = self.damping_coeffs
+        times = self.times
         datatypes = self.datatypes
 
-        fig2, ax2 = plt.subplots(nrows=len(damping_coeffs), ncols=1,
-                                 sharex=True, sharey=True)
-        fig2.text(0.04, 0.5, 'Channel depth (m)', va='center',
-                  rotation='vertical')
-        fig2.text(0.5, 0.02, 'Along channel distance (km)', ha='center')
+        if damping_coeffs is None:
+            naxes = 1
+            nhandles = 1
+            ncFilename = ['output.nc']
+        else:
+            naxes = len(damping_coeffs)
+            nhandles = len(datatypes) + 1
+            ncFilename = [f'output_{damping_coeff}.nc'
+                          for damping_coeff in damping_coeffs]
 
         xBed = numpy.linspace(0, 25, 100)
         yBed = 10.0/25.0*xBed
 
-        for i, damping_coeff in enumerate(damping_coeffs):
-            ds = xarray.open_dataset(f'output_{damping_coeff}.nc')
+        fig, _ = plt.subplots(nrows=naxes, ncols=1, sharex=True)
+
+        for i in range(naxes):
+            ax = plt.subplot(naxes, 1, i+1)
+            ds = xarray.open_dataset(ncFilename[i])
             ds = ds.drop_vars(numpy.setdiff1d([j for j in ds.variables],
                                               ['yCell', 'ssh']))
 
-            ax2[i].plot(xBed, yBed, '-k', lw=3)
-            ax2[i].text(0.5, 5, 'r = ' + str(damping_coeff))
-            ax2[i].set_xlim(0, 25)
-            ax2[i].set_ylim(-1, 11)
-            ax2[i].invert_yaxis()
-            ax2[i].spines['top'].set_visible(False)
-            ax2[i].spines['right'].set_visible(False)
+            ax.plot(xBed, yBed, '-k', lw=3)
+            ax.set_xlim(0, 25)
+            ax.set_ylim(-1, 11)
+            ax.invert_yaxis()
+            ax.spines['top'].set_visible(False)
+            ax.spines['right'].set_visible(False)
+            ax.label_outer()
 
             for atime, ay in zip(times, locs):
 
@@ -162,28 +182,32 @@ def _plot_ssh_validation(self, outFolder='.'):
                 x = ymean.yCell.values/1000.0
                 y = ymean.ssh.values
 
-                mpas = ax2[i].plot(x, -y, label='MPAS-O',
-                                   color=colors['MPAS-O'])
-                ax2[i].text(1, ay, atime + ' days', size=8,
-                            transform=ax2[i].transAxes)
-
-                # Plot comparison data
-                for datatype in datatypes:
-                    datafile = f'./r{damping_coeff}d{atime}-'\
-                               f'{datatype.lower()}.csv'
-                    data = pd.read_csv(datafile, header=None)
-                    ax2[i].scatter(data[0], data[1], marker='.',
+                mpas = ax.plot(x, -y, label='MPAS-O', color=colors['MPAS-O'])
+                ax.text(1, ay, atime + ' days', size=8,
+                        transform=ax.transAxes)
+                if damping_coeffs is not None:
+                    ax.text(0.5, 5, 'r = ' + str(damping_coeffs[i]))
+                    # Plot comparison data
+                    for datatype in datatypes:
+                        datafile = f'./r{damping_coeffs[i]}d{atime}-'\
+                                   f'{datatype.lower()}.csv'
+                        data = pd.read_csv(datafile, header=None)
+                        ax.scatter(data[0], data[1], marker='.',
                                    color=colors[datatype], label=datatype)
+            ax.legend(frameon=False, loc='lower left')
 
             ds.close()
 
-        h, l0 = ax2[0].get_legend_handles_labels()
-        ax2[0].legend(h[0:3], l0[0:3], frameon=False, loc='lower left')
-        h, l1 = ax2[1].get_legend_handles_labels()
-        ax2[1].legend(h[0:3], l1[0:3], frameon=False, loc='lower left')
+            h, l0 = ax.get_legend_handles_labels()
+            ax.legend(h[:nhandles], l0[:nhandles], frameon=False,
+                      loc='lower left')
 
-        fig2.savefig(f'{outFolder}/ssh_depth_section.png', dpi=200)
-        plt.close(fig2)
+        fig.text(0.04, 0.5, 'Channel depth (m)', va='center',
+                 rotation='vertical')
+        fig.text(0.5, 0.02, 'Along channel distance (km)', ha='center')
+
+        fig.savefig(f'{outFolder}/ssh_depth_section.png', dpi=200)
+        plt.close(fig)
 
     def _plot_ssh_validation_for_movie(self, outFolder='.'):
         """
@@ -199,8 +223,18 @@ def _plot_ssh_validation_for_movie(self, outFolder='.'):
         locs = [7.2, 2.2, 0.2, 1.2, 4.2, 9.3]
         locs = 0.92 - numpy.divide(locs, 11.)
 
-        times = self.times
         damping_coeffs = self.damping_coeffs
+        if damping_coeffs is None:
+            naxes = 1
+            nhandles = 1
+            ncFilename = ['output.nc']
+        else:
+            naxes = len(damping_coeffs)
+            nhandles = naxes + 2
+            ncFilename = [f'output_{damping_coeff}.nc'
+                          for damping_coeff in damping_coeffs]
+
+        times = self.times
         datatypes = self.datatypes
 
         xBed = numpy.linspace(0, 25, 100)
@@ -212,16 +246,11 @@ def _plot_ssh_validation_for_movie(self, outFolder='.'):
 
             plottime = int((float(itime)/0.2 + 1e-16)*24.0)
 
-            fig2, ax2 = plt.subplots(nrows=len(damping_coeffs), ncols=1,
-                                     sharex=True, sharey=True)
-            ax2[0].set_title(f't = {itime:.3f} days')
-            fig2.text(0.04, 0.5, 'Channel depth (m)', va='center',
-                      rotation='vertical')
-            fig2.text(0.5, 0.02, 'Along channel distance (km)', ha='center')
-
-            for i, damping_coeff in enumerate(damping_coeffs):
+            fig, _ = plt.subplots(nrows=naxes, ncols=1, sharex=True)
 
-                ds = xarray.open_dataset(f'output_{damping_coeff}.nc')
+            for i in range(naxes):
+                ax = plt.subplot(naxes, 1, i+1)
+                ds = xarray.open_dataset(ncFilename[i])
                 ds = ds.drop_vars(numpy.setdiff1d([j for j in ds.variables],
                                                   ['yCell', 'ssh']))
 
@@ -232,39 +261,44 @@ def _plot_ssh_validation_for_movie(self, outFolder='.'):
                                 dim=xarray.ALL_DIMS)
                 x = ymean.yCell.values/1000.0
                 y = ymean.ssh.values
-                ax2[i].plot(xBed, yBed, '-k', lw=3)
-                mpas = ax2[i].plot(x, -y, label='MPAS-O',
-                                   color=colors['MPAS-O'])
-
-                ax2[i].text(0.5, 5, 'r = ' + str(damping_coeff))
-                ax2[i].set_ylim(-1, 11)
-                ax2[i].set_xlim(0, 25)
-                ax2[i].invert_yaxis()
-                ax2[i].spines['top'].set_visible(False)
-                ax2[i].spines['right'].set_visible(False)
-
-                # Plot comparison data
-                for atime, ay in zip(times, locs):
-                    ax2[i].text(1, ay, f'{atime} days', size=8,
-                                transform=ax2[i].transAxes)
-
-                    for datatype in datatypes:
-                        datafile = f'./r{damping_coeff}d{atime}-'\
-                                   f'{datatype.lower()}.csv'
-                        data = pd.read_csv(datafile, header=None)
-                        ax2[i].scatter(data[0], data[1], marker='.',
+                ax.plot(xBed, yBed, '-k', lw=3)
+                mpas = ax.plot(x, -y, label='MPAS-O', color=colors['MPAS-O'])
+
+                ax.set_ylim(-1, 11)
+                ax.set_xlim(0, 25)
+                ax.invert_yaxis()
+                ax.spines['top'].set_visible(False)
+                ax.spines['right'].set_visible(False)
+                ax.legend(frameon=False, loc='lower left')
+                ax.set_title(f't = {itime:.3f} days')
+                if damping_coeffs is not None:
+                    ax.text(0.5, 5, 'r = ' + str(damping_coeffs[i]))
+                    # Plot comparison data
+                    for atime, ay in zip(times, locs):
+                        ax.text(1, ay, f'{atime} days', size=8,
+                                transform=ax.transAxes)
+
+                        for datatype in datatypes:
+                            datafile = f'./r{damping_coeffs[i]}d{atime}-'\
+                                       f'{datatype.lower()}.csv'
+                            data = pd.read_csv(datafile, header=None)
+                            ax.scatter(data[0], data[1], marker='.',
                                        color=colors[datatype], label=datatype)
 
+                h, l0 = ax.get_legend_handles_labels()
+                ax.legend(h[0:nhandles], l0[0:nhandles], frameon=False,
+                          loc='lower left')
+                ax.set_title(f't = {itime:.3f} days')
+
                 ds.close()
 
-            h, l0 = ax2[0].get_legend_handles_labels()
-            ax2[0].legend(h[0:3], l0[0:3], frameon=False, loc='lower left')
-            h, l1 = ax2[1].get_legend_handles_labels()
-            ax2[1].legend(h[0:3], l1[0:3], frameon=False, loc='lower left')
+            fig.text(0.04, 0.5, 'Channel depth (m)', va='center',
+                     rotation='vertical')
+            fig.text(0.5, 0.02, 'Along channel distance (km)', ha='center')
+
+            fig.savefig(f'{outFolder}/ssh_depth_section_{ii:03d}.png', dpi=200)
 
-            fig2.savefig(f'{outFolder}/ssh_depth_section_{ii:03d}.png',
-                         dpi=200)
-            plt.close(fig2)
+            plt.close(fig)
             ii += 1
 
     def _images_to_movies(self, outFolder='.', framesPerSecond=30,
diff --git a/docs/developers_guide/ocean/test_groups/drying_slope.rst b/docs/developers_guide/ocean/test_groups/drying_slope.rst
index b574b2559c..d4267dd523 100644
--- a/docs/developers_guide/ocean/test_groups/drying_slope.rst
+++ b/docs/developers_guide/ocean/test_groups/drying_slope.rst
@@ -22,6 +22,9 @@ duration, bottom drag, and tidal forcing options, as well as shared
 ``streams.init`` and ``streams.forward`` files that defines ``mesh``, ``input``,
 ``restart``, ``forcing`` and ``output`` streams.
 
+Namelist options specific to resolutions and vertical coordinates are given in
+``namelist.${RES}.*`` and ``namelist.${COORD}*`` files.
+
 initial_state
 ~~~~~~~~~~~~~
 
@@ -32,11 +35,12 @@ defines a step for setting up the initial state for each test case.
 First, a mesh appropriate for the resolution is generated using
 :py:func:`mpas_tools.planar_hex.make_planar_hex_mesh()`.  Then, the mesh is
 culled to remove periodicity in the y direction. MPAS-Ocean is then run in init
-mode. During this run, the vertical grid is set up with ``sigma`` coordinates,
-ssh is initialized using the tidal forcing config options, and temperature and 
-salinity are set to constant values by default. (Namelist options may be
-modified to produce a plug of different temperature values from the background,
-but this is not employed in this test case.)
+mode. If the vertical coordinate is ``sigma``, the vertical grid configured
+accordingly during init mode. During this init mode run, ssh is initialized
+using the tidal forcing config options, and temperature and salinity are set
+to constant values by default. (Namelist options may be modified to produce a
+plug of different temperature values from the background, but this is not
+employed in this test case.)
 
 forward
 ~~~~~~~
@@ -54,12 +58,13 @@ viz
 The class :py:class:`compass.ocean.tests.drying_slope.viz.Viz`
 defines a visualization step which serves the purpose of validation. This
 validation is tailored for the default config options and the two Rayleigh
-damping coefficients set by the default test case, 0.0025 and 0.01. One plot
-verifies that the time evolution of the ssh forcing at the boundary matches the
-analytical solution intended to drive the test case. Another plot compares the
-time evolution of the ssh profile across the channel between the analytical
-solution, MPAS-Ocean and ROMS. Similar plots are used to create a movie showing
-the solution from MPAS-Ocean at more fine-grained time intervals. 
+damping coefficients set by the default sigma-coordinate test case, 0.0025 and
+0.01. One plot verifies that the time evolution of the ssh forcing at the
+boundary matches the analytical solution intended to drive the test case. 
+Another plot compares the time evolution of the ssh profile across the channel
+between the analytical solution, MPAS-Ocean and ROMS. Similar plots are used
+to create a movie showing the solution from MPAS-Ocean at more fine-grained
+time intervals. 
 
 
 .. _dev_ocean_drying_slope_default:
@@ -70,7 +75,8 @@ default
 The :py:class:`compass.ocean.tests.drying_slope.default.Default`
 test performs two 12-hour runs on 4 cores. It doesn't contain any
 :ref:`dev_validation`. This class accepts resolution and coordinate type
-``coord_type`` as arguments, though currently only the ``sigma`` coordinate
-type is supported. This case is hard-coded to run two cases at different values
-of ``config_Rayleigh_damping_coeff``, 0.0025 and 0.01, for which there is
-comparison data. 
+``coord_type`` as arguments. Both ``sigma`` and ``single_layer`` coordinate
+types are supported. For ``sigma`` coordinates, this case is hard-coded to run
+two cases at different values of ``config_Rayleigh_damping_coeff``, 0.0025 and
+0.01, for which there is comparison data. The ``single_layer`` case runs at one
+value of the explicit bottom drag coefficient. 
diff --git a/docs/users_guide/ocean/test_groups/drying_slope.rst b/docs/users_guide/ocean/test_groups/drying_slope.rst
index 3344f64506..4d3f4ab399 100644
--- a/docs/users_guide/ocean/test_groups/drying_slope.rst
+++ b/docs/users_guide/ocean/test_groups/drying_slope.rst
@@ -28,11 +28,14 @@ factors of 0.0025 and 0.01 are applied in separate simulations.
 By default, there are 10 vertical layers. The sigma vertical coordinate is
 used. Horizontal resolution of 250m and 1 km are available.
 
-The test group includes 1 test case.  The test case has 4 steps,
-``initial_state``, which defines the mesh and initial conditions for the model,
-two ``forward`` steps, one for each Rayleigh damping coefficient, and a ``viz``
-which performs visualization of the ssh field and comparison with the analytical
-solution as well as the solution from the ROMS model.
+The test group includes 1 test case.  The test case has 4 steps. The
+``initial_state`` defines the mesh and initial conditions for the model. For
+the ``sigma`` vertical coordiante, two ``forward`` steps are run, one for each
+Rayleigh damping coefficient; for the ``single_layer`` case, one ``forward``
+step is run at one value of the explicit bottom drag coefficient. The ``viz``
+step performs visualization of the ssh field. For the ``sigma`` case, the
+``viz`` step also produces a comparison plot with the analytical solution as
+well as the solution from the ROMS model.
 
 .. image:: images/drying_slope_validation.png
    :width: 500 px