shelfwave_initialization Module Reference

Detailed Description

Configures the model for the idealized shelfwave test case.

Data Types
type	shelfwave_obc_cs
	Control structure for shelfwave open boundaries. More...

Functions/Subroutines
logical function, public	register_shelfwave_obc (param_file, CS, OBC_Reg)
	Add shelfwave to OBC registry. More...
subroutine, public	shelfwave_obc_end (CS)
	Clean up the shelfwave OBC from registry. More...
subroutine, public	shelfwave_initialize_topography (D, G, param_file, max_depth, US)
	Initialization of topography. More...
subroutine, public	shelfwave_set_obc_data (OBC, CS, G, h, Time)
	This subroutine sets the properties of flow at open boundary conditions. More...

Variables
character(len=40)	mdl = "shelfwave_initialization"
	This module's name.

Function/Subroutine Documentation

register_shelfwave_obc()

logical function, public shelfwave_initialization::register_shelfwave_obc	(	type(param_file_type), intent(in)	param_file,
		type(shelfwave_obc_cs), pointer	CS,
		type(obc_registry_type), pointer	OBC_Reg
	)

Add shelfwave to OBC registry.

Parameters

[in]	param_file	parameter file.
	cs	shelfwave control structure.
	obc_reg	OBC registry.

Definition at line 44 of file shelfwave_initialization.F90.

  type(param_file_type),    intent(in) :: param_file !< parameter file.
  type(shelfwave_obc_cs),   pointer    :: cs         !< shelfwave control structure.
  type(obc_registry_type),  pointer    :: obc_reg    !< OBC registry.
  logical                              :: register_shelfwave_obc
  ! Local variables
  real :: kk, ll, pi, len_lat

  character(len=32)  :: casename = "shelfwave"       !< This case's name.

  pi = 4.0*atan(1.0)

  if (associated(cs)) then
    call mom_error(warning, "register_shelfwave_OBC called with an "// &
                            "associated control structure.")
    return
  endif
  allocate(cs)

  ! Register the tracer for horizontal advection & diffusion.
  call register_obc(casename, param_file, obc_reg)
  call get_param(param_file, mdl,"F_0",cs%f0, &
                 do_not_log=.true.)
  call get_param(param_file, mdl,"LENLAT",len_lat, &
                 do_not_log=.true.)
  call get_param(param_file, mdl,"SHELFWAVE_X_WAVELENGTH",cs%Lx, &
                 "Length scale of shelfwave in x-direction.",&
                 units="Same as x,y", default=100.)
  call get_param(param_file, mdl,"SHELFWAVE_Y_LENGTH_SCALE",cs%Ly, &
                 "Length scale of exponential dropoff of topography "//&
                 "in the y-direction.", &
                 units="Same as x,y", default=50.)
  call get_param(param_file, mdl,"SHELFWAVE_Y_MODE",cs%jj, &
                 "Cross-shore wave mode.",               &
                 units="nondim", default=1.)
  cs%alpha = 1. / cs%Ly
  cs%ll = 2. * pi / cs%Lx
  cs%kk = cs%jj * pi / len_lat
  cs%omega = 2 * cs%alpha * cs%f0 * cs%ll / &
             (cs%kk*cs%kk + cs%alpha*cs%alpha + cs%ll*cs%ll)
  register_shelfwave_obc = .true.

shelfwave_initialize_topography()

subroutine, public shelfwave_initialization::shelfwave_initialize_topography	(	real, dimension(g%isd:g%ied,g%jsd:g%jed), intent(out)	D,
		type(dyn_horgrid_type), intent(in)	G,
		type(param_file_type), intent(in)	param_file,
		real, intent(in)	max_depth,
		type(unit_scale_type), intent(in), optional	US
	)

Initialization of topography.

Parameters

[in]	g	The dynamic horizontal grid type
[out]	d	Ocean bottom depth in m or Z if US is present
[in]	param_file	Parameter file structure
[in]	max_depth	Maximum model depth in the units of D
[in]	us	A dimensional unit scaling type

Definition at line 98 of file shelfwave_initialization.F90.

  type(dyn_horgrid_type),          intent(in)  :: g !< The dynamic horizontal grid type
  real, dimension(G%isd:G%ied,G%jsd:G%jed), &
                                   intent(out) :: d !< Ocean bottom depth in m or Z if US is present
  type(param_file_type),           intent(in)  :: param_file !< Parameter file structure
  real,                            intent(in)  :: max_depth !< Maximum model depth in the units of D
  type(unit_scale_type), optional, intent(in)  :: us !< A dimensional unit scaling type

  ! Local variables
  real :: m_to_z  ! A dimensional rescaling factor.
  integer   :: i, j
  real      :: y, rly, ly, h0

  m_to_z = 1.0 ; if (present(us)) m_to_z = us%m_to_Z

  call get_param(param_file, mdl,"SHELFWAVE_Y_LENGTH_SCALE",ly, &
                 default=50., do_not_log=.true.)
  call get_param(param_file, mdl,"MINIMUM_DEPTH", h0, &
                 default=10., units="m", scale=m_to_z, do_not_log=.true.)

  rly = 0. ; if (ly>0.) rly = 1. / ly

  do j=g%jsc,g%jec ; do i=g%isc,g%iec
    ! Compute normalized zonal coordinates (x,y=0 at center of domain)
    y = ( g%geoLatT(i,j) - g%south_lat )
    d(i,j) = h0 * exp(2 * rly * y)
  enddo ; enddo

shelfwave_obc_end()

subroutine, public shelfwave_initialization::shelfwave_obc_end

(

type(shelfwave_obc_cs), pointer

CS

)

Clean up the shelfwave OBC from registry.

Parameters

cs	shelfwave control structure.

Definition at line 89 of file shelfwave_initialization.F90.

  type(shelfwave_obc_cs), pointer    :: cs         !< shelfwave control structure.

  if (associated(cs)) then
    deallocate(cs)
  endif

shelfwave_set_obc_data()

subroutine, public shelfwave_initialization::shelfwave_set_obc_data	(	type(ocean_obc_type), pointer	OBC,
		type(shelfwave_obc_cs), pointer	CS,
		type(ocean_grid_type), intent(in)	G,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h,
		type(time_type), intent(in)	Time
	)

This subroutine sets the properties of flow at open boundary conditions.

Parameters

	obc	This open boundary condition type specifies whether, where, and what open boundary conditions are used.
	cs	tidal bay control structure.
[in]	g	The ocean's grid structure.
[in]	h	layer thickness.
[in]	time	model time.

Definition at line 129 of file shelfwave_initialization.F90.

  type(ocean_obc_type),   pointer    :: obc  !< This open boundary condition type specifies
                                             !! whether, where, and what open boundary
                                             !! conditions are used.
  type(shelfwave_obc_cs), pointer    :: cs   !< tidal bay control structure.
  type(ocean_grid_type),  intent(in) :: g    !< The ocean's grid structure.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)),  intent(in) :: h !< layer thickness.
  type(time_type),        intent(in) :: time !< model time.

  ! The following variables are used to set up the transport in the shelfwave example.
  real :: my_amp, time_sec
  real :: cos_wt, cos_ky, sin_wt, sin_ky, omega, alpha
  real :: x, y, jj, kk, ll
  character(len=40)  :: mdl = "shelfwave_set_OBC_data" ! This subroutine's name.
  integer :: i, j, k, is, ie, js, je, isd, ied, jsd, jed, n
  integer :: isdb, iedb, jsdb, jedb
  type(obc_segment_type), pointer :: segment => null()

  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB

  if (.not.associated(obc)) return

  time_sec = time_type_to_real(time)
  omega = cs%omega
  alpha = cs%alpha
  my_amp = 1.0
  jj = cs%jj
  kk = cs%kk
  ll = cs%ll
  do n = 1, obc%number_of_segments
    segment => obc%segment(n)
    if (.not. segment%on_pe) cycle
    if (segment%direction /= obc_direction_w) cycle

    isdb = segment%HI%IsdB ; iedb = segment%HI%IedB
    jsd = segment%HI%jsd ; jed = segment%HI%jed
    do j=jsd,jed ; do i=isdb,iedb
      x = g%geoLonCu(i,j) - g%west_lon
      y = g%geoLatCu(i,j) - g%south_lat
      sin_wt = sin(ll*x - omega*time_sec)
      cos_wt = cos(ll*x - omega*time_sec)
      sin_ky = sin(kk * y)
      cos_ky = cos(kk * y)
      segment%normal_vel_bt(i,j) = g%US%m_s_to_L_T*my_amp * exp(- alpha * y) * cos_wt * &
           (alpha * sin_ky + kk * cos_ky)
!     segment%tangential_vel_bt(I,j) = G%US%m_s_to_L_T*my_amp * ll * exp(- alpha * y) * sin_wt * sin_ky
!     segment%vorticity_bt(I,j) = my_amp * exp(- alpha * y) * cos_wt * sin_ky&
!           (ll*ll + kk*kk + alpha*alpha)
    enddo ; enddo
  enddo