MOM_boundary_update.F90

Go to the documentation of this file.

! This file is part of MOM6. See LICENSE.md for the license.
!> Controls where open boundary conditions are applied
module mom_boundary_update
 
! This file is part of MOM6. See LICENSE.md for the license.
 
use mom_cpu_clock,             only : cpu_clock_id, cpu_clock_begin, cpu_clock_end, clock_routine
use mom_diag_mediator,         only : time_type
use mom_error_handler,         only : mom_mesg, mom_error, fatal, warning
use mom_file_parser,           only : get_param, log_version, param_file_type, log_param
use mom_grid,                  only : ocean_grid_type
use mom_dyn_horgrid,           only : dyn_horgrid_type
use mom_open_boundary,         only : ocean_obc_type, update_obc_segment_data
use mom_open_boundary,         only : obc_registry_type, file_obc_cs
use mom_open_boundary,         only : register_file_obc, file_obc_end
use mom_unit_scaling,          only : unit_scale_type
use mom_verticalgrid,          only : verticalgrid_type
use mom_tracer_registry,       only : tracer_registry_type
use mom_variables,             only : thermo_var_ptrs
use tidal_bay_initialization,  only : tidal_bay_set_obc_data, register_tidal_bay_obc
use tidal_bay_initialization,  only : tidal_bay_obc_end, tidal_bay_obc_cs
use kelvin_initialization,     only : kelvin_set_obc_data, register_kelvin_obc
use kelvin_initialization,     only : kelvin_obc_end, kelvin_obc_cs
use shelfwave_initialization,  only : shelfwave_set_obc_data, register_shelfwave_obc
use shelfwave_initialization,  only : shelfwave_obc_end, shelfwave_obc_cs
use dyed_channel_initialization, only : dyed_channel_update_flow, register_dyed_channel_obc
use dyed_channel_initialization, only : dyed_channel_obc_end, dyed_channel_obc_cs
 
implicit none ; private
 
#include <MOM_memory.h>
 
public call_obc_register, obc_register_end
public update_obc_data
 
!> The control structure for the MOM_boundary_update module
type, public :: update_obc_cs ; private
  logical :: use_files = .false.        !< If true, use external files for the open boundary.
  logical :: use_kelvin = .false.       !< If true, use the Kelvin wave open boundary.
  logical :: use_tidal_bay = .false.    !< If true, use the tidal_bay open boundary.
  logical :: use_shelfwave = .false.    !< If true, use the shelfwave open boundary.
  logical :: use_dyed_channel = .false. !< If true, use the dyed channel open boundary.
  !>@{ Pointers to the control structures for named OBC specifications
  type(file_obc_cs), pointer :: file_obc_csp => null()
  type(kelvin_obc_cs), pointer :: kelvin_obc_csp => null()
  type(tidal_bay_obc_cs), pointer :: tidal_bay_obc_csp => null()
  type(shelfwave_obc_cs), pointer :: shelfwave_obc_csp => null()
  type(dyed_channel_obc_cs), pointer :: dyed_channel_obc_csp => null()
  !!@}
end type update_obc_cs
 
integer :: id_clock_pass !< A CPU time clock ID
 
! character(len=40)  :: mdl = "MOM_boundary_update" ! This module's name.
 
contains
 
!> The following subroutines and associated definitions provide the
!! machinery to register and call the subroutines that initialize
!! open boundary conditions.
subroutine call_obc_register(param_file, CS, OBC)
  type(param_file_type),     intent(in) :: param_file !< Parameter file to parse
  type(update_obc_cs),       pointer    :: cs         !< Control structure for OBCs
  type(ocean_obc_type),      pointer    :: obc        !< Open boundary structure
 
  ! Local variables
  character(len=40)  :: mdl = "MOM_boundary_update" ! This module's name.
  ! This include declares and sets the variable "version".
# include "version_variable.h"
  if (associated(cs)) then
    call mom_error(warning, "call_OBC_register called with an associated "// &
                            "control structure.")
    return
  else ; allocate(cs) ; endif
 
  call log_version(param_file, mdl, version, "")
 
  call get_param(param_file, mdl, "USE_FILE_OBC", cs%use_files, &
                 "If true, use external files for the open boundary.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_TIDAL_BAY_OBC", cs%use_tidal_bay, &
                 "If true, use the tidal_bay open boundary.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_KELVIN_WAVE_OBC", cs%use_Kelvin, &
                 "If true, use the Kelvin wave open boundary.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_SHELFWAVE_OBC", cs%use_shelfwave, &
                 "If true, use the shelfwave open boundary.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_DYED_CHANNEL_OBC", cs%use_dyed_channel, &
                 "If true, use the dyed channel open boundary.", &
                 default=.false.)
 
  if (cs%use_files) cs%use_files = &
    register_file_obc(param_file, cs%file_OBC_CSp, &
               obc%OBC_Reg)
  if (cs%use_tidal_bay) cs%use_tidal_bay = &
    register_tidal_bay_obc(param_file, cs%tidal_bay_OBC_CSp, &
               obc%OBC_Reg)
  if (cs%use_Kelvin) cs%use_Kelvin = &
    register_kelvin_obc(param_file, cs%Kelvin_OBC_CSp, &
               obc%OBC_Reg)
  if (cs%use_shelfwave) cs%use_shelfwave = &
    register_shelfwave_obc(param_file, cs%shelfwave_OBC_CSp, &
               obc%OBC_Reg)
  if (cs%use_dyed_channel) cs%use_dyed_channel = &
    register_dyed_channel_obc(param_file, cs%dyed_channel_OBC_CSp, &
               obc%OBC_Reg)
 
end subroutine call_obc_register
 
!> Calls appropriate routine to update the open boundary conditions.
subroutine update_obc_data(OBC, G, GV, US, tv, h, CS, Time)
  type(ocean_grid_type),                    intent(in)    :: g    !< Ocean grid structure
  type(verticalgrid_type),                  intent(in)    :: gv   !< Ocean vertical grid structure
  type(unit_scale_type),                    intent(in)    :: us   !< A dimensional unit scaling type
  type(thermo_var_ptrs),                    intent(in)    :: tv   !< Thermodynamics structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(inout) :: h    !< layer thicknesses [H ~> m or kg m-2]
  type(ocean_obc_type),                     pointer       :: obc  !< Open boundary structure
  type(update_obc_cs),                      pointer       :: cs   !< Control structure for OBCs
  type(time_type),                          intent(in)    :: time !< Model time
 
  ! Local variables
  logical :: read_obc_eta = .false.
  logical :: read_obc_uv = .false.
  logical :: read_obc_ts = .false.
  integer :: i, j, k, itt, is, ie, js, je, isd, ied, jsd, jed, nz
  integer :: isd_off, jsd_off
  integer :: isdb, iedb, jsdb, jedb
  character(len=40)  :: mdl = "update_OBC_data" ! This subroutine's name.
  character(len=200) :: filename, obc_file, inputdir ! Strings for file/path
 
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB
 
! Something here... with CS%file_OBC_CSp?
! if (CS%use_files) &
!     call update_OBC_segment_data(G, GV, OBC, tv, h, Time)
  if (cs%use_tidal_bay) &
      call tidal_bay_set_obc_data(obc, cs%tidal_bay_OBC_CSp, g, h, time)
  if (cs%use_Kelvin)  &
      call kelvin_set_obc_data(obc, cs%Kelvin_OBC_CSp, g, gv, us, h, time)
  if (cs%use_shelfwave) &
      call shelfwave_set_obc_data(obc, cs%shelfwave_OBC_CSp, g, h, time)
  if (cs%use_dyed_channel) &
      call dyed_channel_update_flow(obc, cs%dyed_channel_OBC_CSp, g, time)
  if (obc%needs_IO_for_data)  &
      call update_obc_segment_data(g, gv, us, obc, tv, h, time)
 
end subroutine update_obc_data
 
!> Clean up the OBC registry.
subroutine obc_register_end(CS)
  type(update_obc_cs),       pointer    :: cs !< Control structure for OBCs
 
  if (cs%use_files) call file_obc_end(cs%file_OBC_CSp)
  if (cs%use_tidal_bay) call tidal_bay_obc_end(cs%tidal_bay_OBC_CSp)
  if (cs%use_Kelvin) call kelvin_obc_end(cs%Kelvin_OBC_CSp)
 
  if (associated(cs)) deallocate(cs)
end subroutine obc_register_end
 
!> \namespace mom_boundary_update
!! This module updates the open boundary arrays when time-varying.
!! It caused a circular dependency with the tidal_bay setup when
!! MOM_open_boundary.
!!
!! A small fragment of the grid is shown below:
!!
!!    j+1  x ^ x ^ x   At x:  q, CoriolisBu
!!    j+1  > o > o >   At ^:  v, tauy
!!    j    x ^ x ^ x   At >:  u, taux
!!    j    > o > o >   At o:  h, bathyT, buoy, tr, T, S, Rml, ustar
!!    j-1  x ^ x ^ x
!!        i-1  i  i+1  At x & ^:
!!           i  i+1    At > & o:
!!
!! The boundaries always run through q grid points (x).
 
end module mom_boundary_update