kappa_shear_compute Subroutine

public pure subroutine kappa_shear_compute(grid, this, ms, dt, wet_t, wet_u, wet_v)

Run kappa-shear over the domain: fill this%kd_int (interface diffusivity). Call at thermo cadence with the thermo dt. Outer shim: dereferences the tracer-registry hTr arrays on the host (the array-of-DT indirection blocks NVHPC device codegen), then forwards to the column kernel. Velocities reach the kernel as the C-grid face arrays, face-averaged to tracer points inside (same source as the PP81 interior shear).

Vertex mode (at_vertex): solves the columns at C-grid corners from the NATIVE face velocities (no centre average), then averages the corner Kd back to tracer points — two kernels with kd_corner as the required carrier. Needs the metrics wet masks (halo-valid wet_T + face masks); fail-loud if absent.

Arguments

Type IntentOptional Attributes Name
type(hgrid_t), intent(in) :: grid
type(ocean_kappa_shear_t), intent(inout) :: this
type(multilayer_state_t), intent(in) :: ms
real(kind=wp), intent(in) :: dt
real(kind=wp), intent(in), optional :: wet_t(:,:)

Halo-valid tracer-cell wet mask (metrics%wet_T), (nx,ny).
real(kind=wp), intent(in), optional :: wet_u(:,:)

u-face open mask (metrics%wet_u), (nx+1,ny).
real(kind=wp), intent(in), optional :: wet_v(:,:)

v-face open mask (metrics%wet_v), (nx,ny+1).

Calls

proc~~kappa_shear_compute~~CallsGraph proc~kappa_shear_compute kappa_shear_compute proc~kappa_shear_column_kernel kappa_shear_column_kernel proc~kappa_shear_compute->proc~kappa_shear_column_kernel proc~kappa_shear_vertex_kernel kappa_shear_vertex_kernel proc~kappa_shear_compute->proc~kappa_shear_vertex_kernel proc~kappa_shear_vertex_scatter kappa_shear_vertex_scatter proc~kappa_shear_compute->proc~kappa_shear_vertex_scatter local local proc~kappa_shear_column_kernel->local proc~ks_precompute ks_precompute proc~kappa_shear_column_kernel->proc~ks_precompute proc~ks_solve_column ks_solve_column proc~kappa_shear_column_kernel->proc~ks_solve_column proc~massless_build_maps massless_build_maps proc~kappa_shear_column_kernel->proc~massless_build_maps proc~massless_interp_back massless_interp_back proc~kappa_shear_column_kernel->proc~massless_interp_back proc~massless_merge_fields massless_merge_fields proc~kappa_shear_column_kernel->proc~massless_merge_fields proc~kappa_shear_vertex_kernel->local proc~ks_gather_corner ks_gather_corner proc~kappa_shear_vertex_kernel->proc~ks_gather_corner proc~kappa_shear_vertex_kernel->proc~ks_precompute proc~kappa_shear_vertex_kernel->proc~ks_solve_column proc~kappa_shear_vertex_kernel->proc~massless_build_maps proc~kappa_shear_vertex_kernel->proc~massless_interp_back proc~kappa_shear_vertex_kernel->proc~massless_merge_fields proc~kappa_shear_vertex_scatter->local proc~eos_specvol_derivs eos_specvol_derivs proc~ks_solve_column->proc~eos_specvol_derivs proc~ks_adaptive_dt ks_adaptive_dt proc~ks_solve_column->proc~ks_adaptive_dt proc~ks_find_kappa_tke ks_find_kappa_tke proc~ks_solve_column->proc~ks_find_kappa_tke proc~ks_projected_state ks_projected_state proc~ks_solve_column->proc~ks_projected_state proc~ks_src_func ks_src_func proc~ks_solve_column->proc~ks_src_func proc~roquet_spv_point roquet_spv_point proc~eos_specvol_derivs->proc~roquet_spv_point proc~ks_adaptive_dt->proc~ks_projected_state proc~ks_adaptive_dt->proc~ks_src_func proc~ks_find_kappa_tke->proc~ks_src_func

Called by

proc~~kappa_shear_compute~~CalledByGraph proc~kappa_shear_compute kappa_shear_compute proc~vmix_apply_in_stage vmix_apply_in_stage proc~vmix_apply_in_stage->proc~kappa_shear_compute proc~run_stage run_stage proc~run_stage->proc~vmix_apply_in_stage proc~run_stage_split run_stage_split proc~run_stage_split->proc~vmix_apply_in_stage proc~ocean_dyn_step ocean_dyn_step proc~ocean_dyn_step->proc~run_stage proc~ocean_dyn_step_split ocean_dyn_step_split proc~ocean_dyn_step_split->proc~run_stage_split proc~engine_step engine_step proc~engine_step->proc~ocean_dyn_step proc~engine_step->proc~ocean_dyn_step_split proc~driver_run_ocean driver_run_ocean proc~driver_run_ocean->proc~engine_step proc~rdb_ocean_step rdb_ocean_step proc~rdb_ocean_step->proc~engine_step

Source Code

   pure subroutine kappa_shear_compute(grid, this, ms, dt, wet_t, wet_u, wet_v)
      !! Run kappa-shear over the domain: fill `this%kd_int` (interface
      !! diffusivity).  Call at thermo cadence with the thermo dt.
      !! Outer shim: dereferences the tracer-registry hTr arrays on the
      !! host (the array-of-DT indirection blocks NVHPC device codegen),
      !! then forwards to the column kernel.  Velocities reach the
      !! kernel as the C-grid face arrays, face-averaged to tracer
      !! points inside (same source as the PP81 interior shear).
      !!
      !! Vertex mode (`at_vertex`): solves the columns at C-grid corners
      !! from the NATIVE face velocities (no centre average), then
      !! averages the corner Kd back to tracer points — two kernels with
      !! `kd_corner` as the required carrier.  Needs the metrics wet
      !! masks (halo-valid `wet_T` + face masks); fail-loud if absent.
      type(hgrid_t), intent(in) :: grid
      type(ocean_kappa_shear_t), intent(inout) :: this
      type(multilayer_state_t), intent(in) :: ms
      real(wp), intent(in) :: dt
      ! assumed-shape-ok: host shim only — forwarded to the flat kernels
      ! as explicit-shape dummies; thermo cadence.
      real(wp), intent(in), optional :: wet_t(:, :)
         !! Halo-valid tracer-cell wet mask (`metrics%wet_T`), (nx,ny).
      real(wp), intent(in), optional :: wet_u(:, :)  ! assumed-shape-ok: host shim; thermo cadence
         !! u-face open mask (`metrics%wet_u`), (nx+1,ny).
      real(wp), intent(in), optional :: wet_v(:, :)  ! assumed-shape-ok: host shim; thermo cadence
         !! v-face open mask (`metrics%wet_v`), (nx,ny+1).

      if (ms%idx_temperature <= 0 .or. ms%idx_salinity <= 0) return

      if (this%at_vertex) then
         if (.not. (present(wet_t) .and. present(wet_u) .and. present(wet_v))) then
            error stop "kappa_shear_compute: at_vertex requires the wet_t/wet_u/wet_v masks"
         end if
         call kappa_shear_vertex_kernel(this, grid%nx_total, grid%ny_total, &
                                        ms%nz_ml, dt, &
                                        ms%h_layer, ms%u_face_x_layer, &
                                        ms%v_face_y_layer, &
                                        ms%tracers(ms%idx_temperature)%hTr, &
                                        ms%tracers(ms%idx_salinity)%hTr, &
                                        wet_t, wet_u, wet_v)
         call kappa_shear_vertex_scatter(grid%nx_total, grid%ny_total, &
                                         ms%nz_ml + 1, &
                                         this%vertex_geometric_mean, &
                                         this%vertex_geomean_kdmin, &
                                         wet_t, this%kd_corner, &
                                         this%kd_int, this%tke_int)
      else
         call kappa_shear_column_kernel(grid, this, ms, &
                                        ms%tracers(ms%idx_temperature)%hTr, &
                                        ms%tracers(ms%idx_salinity)%hTr, dt)
      end if
   end subroutine kappa_shear_compute