Remove time integrator as argument

Remove time integrator as argument, add to config options

Author: cbegeman

polaris/ocean/tasks/drying_slope/__init__.py

@@ -110,7 +110,6 @@ def add_drying_slope_tasks(component):
             baroclinic = Baroclinic(component=component, resolution=resolution,
                                     init=init, subdir=f'{indir}/{method}',
                                     coord_type=coord_type, method=method,
-                                    forcing_type=forcing_type,
-                                    time_integrator='split_explicit')
+                                    forcing_type=forcing_type)
             baroclinic.set_shared_config(config, link=config_filename)
             component.add_task(baroclinic)

polaris/ocean/tasks/drying_slope/baroclinic/__init__.py

@@ -21,8 +21,7 @@ class Baroclinic(Task):
     def __init__(self, component, resolution, init, subdir,
                  coord_type='sigma',
                  forcing_type='linear_drying', method='ramp',
-                 drag_type='constant_and_rayleigh',
-                 time_integrator='split_explicit'):
+                 drag_type='constant_and_rayleigh'):
         """
         Create the test case
 
@@ -52,9 +51,6 @@ def __init__(self, component, resolution, init, subdir,
 
         drag_type : str, optional
             The bottom drag type to apply as a namelist option
-
-        time_integrator : str, optional
-            The time integration scheme to apply as a namelist option
         """
         name = f'baroclinic_{method}'
         if drag_type == 'loglaw':
@@ -69,7 +65,7 @@ def __init__(self, component, resolution, init, subdir,
                     ntasks=None,
                     min_tasks=None, openmp_threads=1, resolution=resolution,
                     forcing_type=forcing_type, coord_type=coord_type,
-                    time_integrator=time_integrator, drag_type=drag_type,
+                    drag_type=drag_type,
                     damping_coeff=1.0e-4, baroclinic=True, method=method))
 
         self.add_step(

polaris/ocean/tasks/drying_slope/barotropic/__init__.py

@@ -26,7 +26,7 @@ class Barotropic(Task):
     def __init__(self, component, resolution, init, subdir,
                  coord_type='sigma',
                  drag_type='constant_and_rayleigh', forcing_type='tidal_cycle',
-                 time_integrator='RK4', method='ramp'):
+                 method='ramp'):
         """
         Create the test case
 
@@ -56,9 +56,6 @@ def __init__(self, component, resolution, init, subdir,
 
         drag_type : str, optional
             The bottom drag type to apply as a namelist option
-
-        time_integrator : str, optional
-            The time integration scheme to apply as a namelist option
         """
         mesh_name = resolution_to_subdir(resolution)
         name = f'barotropic_{method}_{mesh_name}'
@@ -86,9 +83,10 @@ def __init__(self, component, resolution, init, subdir,
                         name=f'{step_name}_{mesh_name}',
                         resolution=resolution,
                         forcing_type=forcing_type, coord_type=coord_type,
-                        time_integrator=time_integrator, drag_type=drag_type,
+                        drag_type=drag_type,
                         damping_coeff=damping_coeff, baroclinic=False,
-                        method=method)
+                        method=method,
+                        graph_target=f'{init.path}/culled_graph.info')
                     symlink = None
                 self.add_step(forward_step, symlink=symlink)
         else:
@@ -97,7 +95,7 @@ def __init__(self, component, resolution, init, subdir,
                 component=component, init=init, indir=subdir, ntasks=None,
                 min_tasks=None, openmp_threads=1, resolution=resolution,
                 forcing_type=forcing_type, coord_type=coord_type,
-                time_integrator=time_integrator, drag_type=drag_type,
+                drag_type=drag_type,
                 damping_coeff=1.0e-4, baroclinic=False,
                 method=method)
             self.add_step(forward_step)

polaris/ocean/tasks/drying_slope/drying_slope.cfg

@@ -25,9 +25,6 @@ min_layer_thickness = ${drying_slope_barotropic:thin_film_thickness}
 # config options for all drying slope test cases
 [drying_slope]
 
-# time integration scheme
-time_integrator = RK4
-
 # time step per resolution (s/km), since dt is proportional to resolution
 rk4_dt_per_km = 30
 
@@ -46,6 +43,9 @@ background_temperature = 20.0
 # config options for barotropic drying slope test cases
 [drying_slope_barotropic]
 
+# time integration scheme
+time_integrator = RK4
+
 # the width of the domain in km
 lx = 6.
 
@@ -79,6 +79,9 @@ thin_film_thickness = 1.0e-3
 # config options for barotropic drying slope test cases
 [drying_slope_baroclinic]
 
+# time integration scheme
+time_integrator = split_explicit
+
 # the width of the domain in km
 lx = 12.
 

polaris/ocean/tasks/drying_slope/forward.py

@@ -28,10 +28,11 @@ class Forward(OceanModelStep):
     """
     def __init__(self, component, resolution, init, name='forward',
                  subdir=None, indir=None, ntasks=None, min_tasks=None,
-                 openmp_threads=1, time_integrator='rk4', damping_coeff=None,
+                 openmp_threads=1, damping_coeff=None,
                  coord_type='sigma', forcing_type='tidal_cycle',
                  drag_type='constant_and_rayleigh', baroclinic=False,
-                 method='ramp', run_time_steps=None):
+                 method='ramp', run_time_steps=None,
+                 graph_target='graph.info'):
         """
         Create a new task
 
@@ -92,55 +93,33 @@ def __init__(self, component, resolution, init, name='forward',
                 raise ValueError('Damping coefficient must be specified with '
                                  f'drag type {drag_type}')
 
+        self.damping_coeff = damping_coeff
+        self.drag_type = drag_type
         self.baroclinic = baroclinic
+        self.coord_type = coord_type
+        self.forcing_type = forcing_type
+        self.method = method
         self.resolution = resolution
         self.run_time_steps = run_time_steps
+        self.yaml_filename = 'forward.yaml'
         super().__init__(component=component, name=name, subdir=subdir,
                          indir=indir, ntasks=ntasks, min_tasks=min_tasks,
-                         openmp_threads=openmp_threads)
-
-        self.add_input_file(filename='initial_state.nc',
-                            work_dir_target=f'{init.path}/initial_state.nc')
-        self.add_input_file(filename='graph.info',
-                            work_dir_target=f'{init.path}/culled_graph.info')
-        self.add_input_file(filename='forcing.nc',
-                            work_dir_target=f'{init.path}/forcing.nc')
+                         openmp_threads=openmp_threads,
+                         graph_target=graph_target)
 
         self.add_yaml_file('polaris.ocean.config', 'output.yaml')
-
-        self.add_yaml_file('polaris.ocean.tasks.drying_slope',
-                           'forward.yaml')
-
-        options = dict()
-        if coord_type == 'single_layer':
+        if self.coord_type == 'single_layer':
             self.add_yaml_file('polaris.ocean.config', 'single_layer.yaml')
-            options['config_disable_thick_sflux'] = True
-            options['config_disable_vel_hmix'] = True
-
-        if method == 'ramp':
-            options['config_zero_drying_velocity_ramp'] = True
-
-        options['config_implicit_bottom_drag_type'] = drag_type
-        # for drag types not specified here, defaults are used or given in
-        # forward.yaml
-        if drag_type == 'constant':
-            options['config_implicit_constant_bottom_drag_coeff'] = \
-                3.0e-3   # type: ignore[assignment]
-        elif drag_type == 'constant_and_rayleigh':
-            # update the damping coefficient to the requested value *after*
-            # loading forward.yaml
-            options['config_Rayleigh_damping_coeff'] = damping_coeff
-
-        if baroclinic:
+        if self.baroclinic:
             self.add_yaml_file('polaris.ocean.tasks.drying_slope',
                                'baroclinic.yaml')
+        self.add_yaml_file('polaris.ocean.tasks.drying_slope',
+                           self.yaml_filename)
 
-        forcing_dict = {'tidal_cycle': 'monochromatic',
-                        'linear_drying': 'linear'}
-
-        options['config_tidal_forcing_model'] = \
-            forcing_dict[forcing_type]   # type: ignore[assignment]
-        self.add_model_config_options(options=options)
+        self.add_input_file(filename='initial_state.nc',
+                            work_dir_target=f'{init.path}/initial_state.nc')
+        self.add_input_file(filename='forcing.nc',
+                            work_dir_target=f'{init.path}/forcing.nc')
 
         self.add_output_file(
             filename='output.nc',
@@ -184,48 +163,78 @@ def dynamic_model_config(self, at_setup):
         """
         super().dynamic_model_config(at_setup)
 
-        config = self.config
-
-        options = dict()
+        if self.baroclinic:
+            section = self.config['vertical_grid']
+            vert_levels = section.getint('vert_levels')
+            section = self.config['drying_slope_baroclinic']
+            time_integrator = section.get('time_integrator')
+            thin_film_thickness = section.getfloat('min_column_thickness') / \
+                vert_levels
+        else:
+            section = self.config['drying_slope_barotropic']
+            time_integrator = section.get('time_integrator')
+            thin_film_thickness = section.getfloat('thin_film_thickness')
 
         # dt is proportional to resolution: default 30 seconds per km
-        section = config['drying_slope']
-        time_integrator = section.get('time_integrator')
-        options['config_time_integrator'] = time_integrator
-
+        section = self.config['drying_slope']
         if time_integrator == 'RK4':
             dt_per_km = section.getfloat('rk4_dt_per_km')
-        if time_integrator == 'split_explicit':
+        elif time_integrator == 'split_explicit':
             dt_per_km = section.getfloat('split_dt_per_km')
             # btr_dt is also proportional to resolution
-            btr_dt_per_km = config.getfloat('drying_slope', 'btr_dt_per_km')
+            btr_dt_per_km = section.getfloat('btr_dt_per_km')
             btr_dt = btr_dt_per_km * self.resolution
-            options['config_btr_dt'] = \
-                time.strftime('%H:%M:%S', time.gmtime(btr_dt))
             self.btr_dt = btr_dt
+        else:
+            print(f'Time integrator {time_integrator} not supported')
+        btr_dt_str = time.strftime('%H:%M:%S', time.gmtime(self.btr_dt))
+
         dt = dt_per_km * self.resolution
         # https://stackoverflow.com/a/1384565/7728169
-        options['config_dt'] = \
-            time.strftime('%H:%M:%S', time.gmtime(dt))
+        dt_str = time.strftime('%H:%M:%S', time.gmtime(dt))
         self.dt = dt
 
         if self.run_time_steps is not None:
-            options['run_duration'] = time.strftime(
+            run_duration_str = time.strftime(
                 '%H:%M:%S', time.gmtime(dt * self.run_time_steps))
-
-        if self.baroclinic:
-            section = self.config['vertical_grid']
-            vert_levels = section.getint('vert_levels')
-            section = self.config['drying_slope_baroclinic']
-            thin_film_thickness = section.getfloat('min_column_thickness') / \
-                vert_levels
         else:
-            section = self.config['drying_slope_barotropic']
-            thin_film_thickness = section.getfloat('thin_film_thickness')
-        options['config_drying_min_cell_height'] = thin_film_thickness
-        options['config_zero_drying_velocity_ramp_hmin'] = \
-            thin_film_thickness
-        options['config_zero_drying_velocity_ramp_hmax'] = \
-            thin_film_thickness * 10.
+            run_duration_str = '0000_12:00:01'
+
+        replacements = dict(
+            time_integrator=time_integrator,
+            dt=dt_str,
+            btr_dt=btr_dt_str,
+            run_duration=run_duration_str,
+            hmin=f'{thin_film_thickness}',
+            ramp_hmin=f'{thin_film_thickness}',
+            ramp_hmax=f'{1.}',
+        )
+
+        mpas_options = dict()
+        if self.method == 'ramp':
+            mpas_options['config_zero_drying_velocity_ramp'] = True
+
+        mpas_options['config_implicit_bottom_drag_type'] = self.drag_type
+        # for drag types not specified here, defaults are used or given in
+        # forward.yaml
+        if self.drag_type == 'constant':
+            mpas_options['config_implicit_constant_bottom_drag_coeff'] = \
+                3.0e-3   # type: ignore[assignment]
+        elif self.drag_type == 'constant_and_rayleigh':
+            # update the damping coefficient to the requested value *after*
+            # loading forward.yaml
+            mpas_options['config_Rayleigh_damping_coeff'] = self.damping_coeff
 
-        self.add_model_config_options(options=options)
+        forcing_dict = {'tidal_cycle': 'monochromatic',
+                        'linear_drying': 'linear'}
+
+        mpas_options['config_tidal_forcing_model'] = \
+            forcing_dict[self.forcing_type]   # type: ignore[assignment]
+
+        print(mpas_options)
+        self.add_model_config_options(options=mpas_options,
+                                      config_model='mpas-ocean')
+        print(replacements)
+        self.add_yaml_file('polaris.ocean.tasks.drying_slope',
+                           self.yaml_filename,
+                           template_replacements=replacements)

polaris/ocean/tasks/drying_slope/forward.yaml

@@ -1,10 +1,17 @@
-omega:
+ocean:
+  time_management:
+    config_run_duration: {{ run_duration }}
+  time_integration:
+    config_dt: {{ dt }}
+    config_time_integrator: {{ time_integrator }}
+
+mpas-ocean:
   io:
     config_write_output_on_startup: false
+  split_explicit_ts:
+    config_btr_dt: {{ btr_dt }}
   cvmix:
     config_use_cvmix: false
-  time_management:
-    config_run_duration: 0000_12:00:01
   tidal_forcing:
     config_use_tidal_forcing: true
     config_use_tidal_forcing_tau: 60.0
@@ -16,15 +23,20 @@ omega:
     config_Rayleigh_damping_depth_variable: true
   wetting_drying:
     config_use_wetting_drying: true
+    config_drying_min_cell_height: {{ hmin }}
     config_prevent_drying: true
     config_zero_drying_velocity: true
-    config_zero_drying_velocity_ramp: true
+    config_zero_drying_velocity_ramp_hmin: {{ ramp_hmin }}
+    config_zero_drying_velocity_ramp_hmax: {{ ramp_hmax }}
     config_verify_not_dry: true
   ALE_vertical_grid:
     config_vert_coord_movement: impermeable_interfaces
     config_ALE_thickness_proportionality: weights_only
   advection:
     config_thickness_flux_type: upwind
+  debug:
+    config_disable_thick_sflux: true
+    config_disable_vel_hmix: true
   streams:
     mesh:
       filename_template: initial_state.nc
@@ -47,6 +59,7 @@ omega:
       - tracers
       - xtime
       - daysSinceStartOfSim
+      - upwindFactor
       - normalVelocity
       - velocityX
       - velocityY