drain_reconstruct_hprev Subroutine

private pure subroutine drain_reconstruct_hprev(nx, ny, nz, areaT, iareaT, h_end, uhtr, vhtr, hprev)

hprev = max(0, areaT·h_end + div(uhtr,vhtr)) · iareaT, then the vanishing-layer hatch hprev += max(0, 1e-13·hprev − h_end) (Adcroft & Hallberg 2006; reuse of VANISHING_LAYER_TOL thinking).

Arguments

Type IntentOptional Attributes Name
integer, intent(in) :: nx
integer, intent(in) :: ny
integer, intent(in) :: nz
real(kind=wp), intent(in) :: areaT(nx,ny)
real(kind=wp), intent(in) :: iareaT(nx,ny)
real(kind=wp), intent(in) :: h_end(nx,ny,nz)
real(kind=wp), intent(in) :: uhtr(nx+1,ny,nz)
real(kind=wp), intent(in) :: vhtr(nx,ny+1,nz)
real(kind=wp), intent(inout) :: hprev(nx,ny,nz)

Calls

proc~~drain_reconstruct_hprev~~CallsGraph proc~drain_reconstruct_hprev drain_reconstruct_hprev local local proc~drain_reconstruct_hprev->local

Called by

proc~~drain_reconstruct_hprev~~CalledByGraph proc~drain_reconstruct_hprev drain_reconstruct_hprev proc~continuity_tracer_drain continuity_tracer_drain proc~continuity_tracer_drain->proc~drain_reconstruct_hprev proc~ocean_dyn_flush_tracer_window ocean_dyn_flush_tracer_window proc~ocean_dyn_flush_tracer_window->proc~continuity_tracer_drain proc~ocean_dyn_step ocean_dyn_step proc~ocean_dyn_step->proc~continuity_tracer_drain proc~ocean_dyn_step_split ocean_dyn_step_split proc~ocean_dyn_step_split->proc~continuity_tracer_drain proc~driver_run_ocean driver_run_ocean proc~driver_run_ocean->proc~ocean_dyn_flush_tracer_window proc~engine_step engine_step proc~driver_run_ocean->proc~engine_step proc~engine_step->proc~ocean_dyn_step proc~engine_step->proc~ocean_dyn_step_split proc~rdb_ocean_set_tracer rdb_ocean_set_tracer proc~rdb_ocean_set_tracer->proc~ocean_dyn_flush_tracer_window proc~driver_run driver_run proc~driver_run->proc~driver_run_ocean proc~rdb_ocean_step rdb_ocean_step proc~rdb_ocean_step->proc~engine_step

Variables

Type Visibility Attributes Name Initial
real(kind=wp), private :: eps_h
integer, private :: i
integer, private :: j
integer, private :: k
real(kind=wp), private :: vol

Source Code

   pure subroutine drain_reconstruct_hprev(nx, ny, nz, areaT, iareaT, h_end, &
                                           uhtr, vhtr, hprev)
      !! hprev = max(0, areaT·h_end + div(uhtr,vhtr)) · iareaT, then the
      !! vanishing-layer hatch `hprev += max(0, 1e-13·hprev − h_end)`
      !! (Adcroft & Hallberg 2006; reuse of VANISHING_LAYER_TOL thinking).
      integer, intent(in) :: nx, ny, nz
      real(wp), intent(in) :: areaT(nx, ny), iareaT(nx, ny)
      real(wp), intent(in) :: h_end(nx, ny, nz)
      real(wp), intent(in) :: uhtr(nx + 1, ny, nz)
      real(wp), intent(in) :: vhtr(nx, ny + 1, nz)
      real(wp), intent(inout) :: hprev(nx, ny, nz)
      integer :: i, j, k
      real(wp) :: vol, eps_h
      do concurrent(k=1:nz, j=1:ny, i=1:nx) local(vol, eps_h)
         vol = areaT(i, j)*h_end(i, j, k) &
               + (uhtr(i + 1, j, k) - uhtr(i, j, k)) &
               + (vhtr(i, j + 1, k) - vhtr(i, j, k))
         hprev(i, j, k) = max(0.0_wp, vol)*iareaT(i, j)
         eps_h = max(0.0_wp, 1.0e-13_wp*hprev(i, j, k) - h_end(i, j, k))
         hprev(i, j, k) = hprev(i, j, k) + eps_h
      end do
   end subroutine drain_reconstruct_hprev