mom_ale_sponge Module Reference

Detailed Description

This module contains the routines used to apply sponge layers when using the ALE mode.

Applying sponges requires the following:

1. initialize_ALE_sponge
2. set_up_ALE_sponge_field (tracers) and set_up_ALE_sponge_vel_field (vel)
3. apply_ALE_sponge
4. init_ALE_sponge_diags (not being used for now)
5. ALE_sponge_end (not being used for now)

Data Types
type	ale_sponge_cs
	ALE sponge control structure. More...
interface	initialize_ale_sponge
	Ddetermine the number of points which are within sponges in this computational domain. More...
type	p2d
	A structure for creating arrays of pointers to 2D arrays with extra gridding information. More...
type	p3d
	A structure for creating arrays of pointers to 3D arrays with extra gridding information. More...
interface	set_up_ale_sponge_field
	Store the reference profile at h points for a variable. More...
interface	set_up_ale_sponge_vel_field
	This subroutine stores the reference profile at u and v points for a vector. More...

Functions/Subroutines
subroutine	initialize_ale_sponge_fixed (Iresttime, G, param_file, CS, data_h, nz_data)
	This subroutine determines the number of points which are within sponges in this computational domain. Only points that have positive values of Iresttime and which mask2dT indicates are ocean points are included in the sponges. It also stores the target interface heights. More...
integer function, public	get_ale_sponge_nz_data (CS)
	Return the number of layers in the data with a fixed ALE sponge, or 0 if there are no sponge columns on this PE. More...
subroutine, public	get_ale_sponge_thicknesses (G, data_h, sponge_mask, CS)
	Return the thicknesses used for the data with a fixed ALE sponge. More...
subroutine	initialize_ale_sponge_varying (Iresttime, G, param_file, CS)
	This subroutine determines the number of points which are within sponges in this computational domain. Only points that have positive values of Iresttime and which mask2dT indicates are ocean points are included in the sponges. More...
subroutine, public	init_ale_sponge_diags (Time, G, diag, CS)
	Initialize diagnostics for the ALE_sponge module. More...
subroutine	set_up_ale_sponge_field_fixed (sp_val, G, f_ptr, CS)
	This subroutine stores the reference profile at h points for the variable whose address is given by f_ptr. More...
subroutine	set_up_ale_sponge_field_varying (filename, fieldname, Time, G, GV, f_ptr, CS)
	This subroutine stores the reference profile at h points for the variable whose address is given by filename and fieldname. More...
subroutine	set_up_ale_sponge_vel_field_fixed (u_val, v_val, G, u_ptr, v_ptr, CS)
	This subroutine stores the reference profile at u and v points for the variable whose address is given by u_ptr and v_ptr. More...
subroutine	set_up_ale_sponge_vel_field_varying (filename_u, fieldname_u, filename_v, fieldname_v, Time, G, US, CS, u_ptr, v_ptr)
	This subroutine stores the reference profile at uand v points for the variable whose address is given by u_ptr and v_ptr. More...
subroutine, public	apply_ale_sponge (h, dt, G, GV, US, CS, Time)
	This subroutine applies damping to the layers thicknesses, temp, salt and a variety of tracers for every column where there is damping. More...
subroutine, public	ale_sponge_end (CS)
	This subroutine deallocates any memory associated with the ALE_sponge module. More...

Function/Subroutine Documentation

ale_sponge_end()

subroutine, public mom_ale_sponge::ale_sponge_end

(

type(ale_sponge_cs), pointer

CS

)

This subroutine deallocates any memory associated with the ALE_sponge module.

Parameters

cs	A pointer to the control structure that is set by a previous call to initialize_sponge.

Definition at line 1049 of file MOM_ALE_sponge.F90.

  type(ALE_sponge_CS), pointer :: CS !< A pointer to the control structure that is
                                     !! set by a previous call to initialize_sponge.
 
  integer :: m
 
  if (.not.associated(cs)) return
 
  if (associated(cs%col_i)) deallocate(cs%col_i)
  if (associated(cs%col_i_u)) deallocate(cs%col_i_u)
  if (associated(cs%col_i_v)) deallocate(cs%col_i_v)
  if (associated(cs%col_j)) deallocate(cs%col_j)
  if (associated(cs%col_j_u)) deallocate(cs%col_j_u)
  if (associated(cs%col_j_v)) deallocate(cs%col_j_v)
 
  if (associated(cs%Iresttime_col)) deallocate(cs%Iresttime_col)
  if (associated(cs%Iresttime_col_u)) deallocate(cs%Iresttime_col_u)
  if (associated(cs%Iresttime_col_v)) deallocate(cs%Iresttime_col_v)
 
  do m=1,cs%fldno
    if (associated(cs%Ref_val(cs%fldno)%p)) deallocate(cs%Ref_val(cs%fldno)%p)
  enddo
 
  deallocate(cs)
 

apply_ale_sponge()

subroutine, public mom_ale_sponge::apply_ale_sponge	(	real, dimension(szi_(g),szj_(g),szk_(g)), intent(inout)	h,
		real, intent(in)	dt,
		type(ocean_grid_type), intent(inout)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(ale_sponge_cs), pointer	CS,
		type(time_type), intent(in), optional	Time
	)

This subroutine applies damping to the layers thicknesses, temp, salt and a variety of tracers for every column where there is damping.

Parameters

[in,out]	g	The ocean's grid structure (in).
[in]	gv	ocean vertical grid structure
[in]	us	A dimensional unit scaling type
[in,out]	h	Layer thickness [H ~> m or kg m-2] (in)
[in]	dt	The amount of time covered by this call [s].
	cs	A pointer to the control structure for this module that is set by a previous call to initialize_sponge (in).
[in]	time	The current model date

Definition at line 845 of file MOM_ALE_sponge.F90.

  type(ocean_grid_type),     intent(inout) :: G  !< The ocean's grid structure (in).
  type(verticalGrid_type),   intent(in)    :: GV !< ocean vertical grid structure
  type(unit_scale_type),     intent(in)    :: US !< A dimensional unit scaling type
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                             intent(inout) :: h  !< Layer thickness [H ~> m or kg m-2] (in)
  real,                      intent(in)    :: dt !< The amount of time covered by this call [s].
  type(ALE_sponge_CS),       pointer       :: CS !< A pointer to the control structure for this module
                                                 !! that is set by a previous call to initialize_sponge (in).
  type(time_type), optional, intent(in)    :: Time !< The current model date
 
  real :: damp                                  ! The timestep times the local damping coefficient [nondim].
  real :: I1pdamp                               ! I1pdamp is 1/(1 + damp). [nondim].
  real :: Idt                                   ! 1.0/dt [s-1].
  real :: m_to_Z                                ! A unit conversion factor from m to Z.
  real, allocatable, dimension(:) :: tmp_val2   ! data values on the original grid
  real, dimension(SZK_(G)) :: tmp_val1          ! data values remapped to model grid
  real :: hu(SZIB_(G), SZJ_(G), SZK_(G))        ! A temporary array for h at u pts
  real :: hv(SZI_(G), SZJB_(G), SZK_(G))        ! A temporary array for h at v pts
  real, allocatable, dimension(:,:,:) :: sp_val ! A temporary array for fields
  real, allocatable, dimension(:,:,:) :: mask_z ! A temporary array for field mask at h pts
  integer :: c, m, nkmb, i, j, k, is, ie, js, je, nz, nz_data
  real, allocatable, dimension(:), target :: z_in, z_edges_in
  real :: missing_value
  real :: h_neglect, h_neglect_edge
 
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
 
  if (.not.associated(cs)) return
 
  if (gv%Boussinesq) then
    h_neglect = gv%m_to_H*1.0e-30 ; h_neglect_edge = gv%m_to_H*1.0e-10
  else
    h_neglect = gv%kg_m2_to_H*1.0e-30 ; h_neglect_edge = gv%kg_m2_to_H*1.0e-10
  endif
 
  if (cs%new_sponges) then
    if (.not. present(time)) &
         call mom_error(fatal,"apply_ALE_sponge: No time information provided")
 
! Interpolate new grid in time-space
    do m=1,cs%fldno
 
      nz_data = cs%Ref_val(m)%nz_data
      allocate(sp_val(g%isd:g%ied,g%jsd:g%jed,1:nz_data))
      allocate(mask_z(g%isd:g%ied,g%jsd:g%jed,1:nz_data))
      sp_val(:,:,:)=0.0
      mask_z(:,:,:)=0.0
 
      call horiz_interp_and_extrap_tracer(cs%Ref_val(cs%fldno)%id,time, 1.0,g,sp_val,mask_z,z_in,z_edges_in, &
                                          missing_value,.true., .false.,.false., m_to_z=us%m_to_Z)
 
!      call pass_var(sp_val,G%Domain)
!      call pass_var(mask_z,G%Domain)
 
 
      do c=1,cs%num_col
        i = cs%col_i(c) ; j = cs%col_j(c)
        cs%Ref_val(m)%p(1:nz_data,c) = sp_val(i,j,1:nz_data)
        do k=2,nz_data
!          if (mask_z(i,j,k)==0.) &
          if (cs%Ref_val(m)%h(k,c) <= 0.001*gv%m_to_H) &
            ! some confusion here about why the masks are not correct returning from horiz_interp
            ! reverting to using a minimum thickness criteria
            cs%Ref_val(m)%p(k,c) = cs%Ref_val(m)%p(k-1,c)
        enddo
      enddo
 
      deallocate(sp_val, mask_z)
    enddo
  else
    nz_data = cs%nz_data
  endif
 
  allocate(tmp_val2(nz_data))
 
  do m=1,cs%fldno
    do c=1,cs%num_col
! c is an index for the next 3 lines but a multiplier for the rest of the loop
! Therefore we use c as per C code and increment the index where necessary.
      i = cs%col_i(c) ; j = cs%col_j(c)
      damp = dt*cs%Iresttime_col(c)
      i1pdamp = 1.0 / (1.0 + damp)
      tmp_val2(1:nz_data) = cs%Ref_val(m)%p(1:nz_data,c)
      if (cs%new_sponges) then
        call remapping_core_h(cs%remap_cs, nz_data, cs%Ref_val(m)%h(1:nz_data,c), tmp_val2, &
                 cs%nz, h(i,j,:), tmp_val1, h_neglect, h_neglect_edge)
      else
        call remapping_core_h(cs%remap_cs,nz_data, cs%Ref_h%p(1:nz_data,c), tmp_val2, &
                 cs%nz, h(i,j,:), tmp_val1, h_neglect, h_neglect_edge)
      endif
      !Backward Euler method
      cs%var(m)%p(i,j,1:cs%nz) = i1pdamp * (cs%var(m)%p(i,j,1:cs%nz) + tmp_val1 * damp)
 
    enddo
  enddo
 
  ! for debugging
  !c=CS%num_col
  !do m=1,CS%fldno
  !   write(*,*) 'APPLY SPONGE,m,CS%Ref_h(:,c),h(i,j,:),tmp_val2,tmp_val1',&
  !               m,CS%Ref_h(:,c),h(i,j,:),tmp_val2,tmp_val1
  !enddo
 
  if (cs%sponge_uv) then
 
    ! u points
    do j=cs%jsc,cs%jec; do i=cs%iscB,cs%iecB; do k=1,nz
       hu(i,j,k) = 0.5 * (h(i,j,k) + h(i+1,j,k))
    enddo ; enddo ; enddo
 
    if (cs%new_sponges) then
      if (.not. present(time)) &
         call mom_error(fatal,"apply_ALE_sponge: No time information provided")
 
      nz_data = cs%Ref_val_u%nz_data
      allocate(sp_val(g%isdB:g%iedB,g%jsd:g%jed,1:nz_data))
      allocate(mask_z(g%isdB:g%iedB,g%jsd:g%jed,1:nz_data))
! Interpolate from the external horizontal grid and in time
      call horiz_interp_and_extrap_tracer(cs%Ref_val_u%id,time, 1.0,g,sp_val,mask_z,z_in,z_edges_in, &
                                     missing_value, .true., .false., .false., m_to_z=us%m_to_Z)
 
!      call pass_var(sp_val,G%Domain)
!      call pass_var(mask_z,G%Domain)
 
      do c=1,cs%num_col
! c is an index for the next 3 lines but a multiplier for the rest of the loop
! Therefore we use c as per C code and increment the index where necessary.
        i = cs%col_i(c) ; j = cs%col_j(c)
        cs%Ref_val_u%p(1:nz_data,c) = sp_val(i,j,1:nz_data)
      enddo
 
      deallocate (sp_val, mask_z)
 
      nz_data = cs%Ref_val_v%nz_data
      allocate(sp_val(g%isd:g%ied,g%jsdB:g%jedB,1:nz_data))
      allocate(mask_z(g%isd:g%ied,g%jsdB:g%jedB,1:nz_data))
! Interpolate from the external horizontal grid and in time
      call horiz_interp_and_extrap_tracer(cs%Ref_val_v%id,time, 1.0,g,sp_val,mask_z,z_in,z_edges_in, &
                                     missing_value, .true., .false., .false., m_to_z=us%m_to_Z)
 
!      call pass_var(sp_val,G%Domain)
!      call pass_var(mask_z,G%Domain)
 
      do c=1,cs%num_col
! c is an index for the next 3 lines but a multiplier for the rest of the loop
! Therefore we use c as per C code and increment the index where necessary.
        i = cs%col_i(c) ; j = cs%col_j(c)
        cs%Ref_val_v%p(1:nz_data,c) = sp_val(i,j,1:nz_data)
      enddo
 
      deallocate (sp_val, mask_z)
 
    else
      nz_data = cs%nz_data
    endif
 
    do c=1,cs%num_col_u
       i = cs%col_i_u(c) ; j = cs%col_j_u(c)
       damp = dt*cs%Iresttime_col_u(c)
       i1pdamp = 1.0 / (1.0 + damp)
       if (cs%new_sponges) nz_data = cs%Ref_val(m)%nz_data
       tmp_val2(1:nz_data) = cs%Ref_val_u%p(1:nz_data,c)
       if (cs%new_sponges) then
         call remapping_core_h(cs%remap_cs, nz_data, cs%Ref_val_u%h(:,c), tmp_val2, &
                  cs%nz, hu(i,j,:), tmp_val1, h_neglect, h_neglect_edge)
       else
         call remapping_core_h(cs%remap_cs, nz_data, cs%Ref_hu%p(:,c), tmp_val2, &
                  cs%nz, hu(i,j,:), tmp_val1, h_neglect, h_neglect_edge)
       endif
       !Backward Euler method
       cs%var_u%p(i,j,:) = i1pdamp * (cs%var_u%p(i,j,:) + tmp_val1 * damp)
    enddo
 
    ! v points
    do j=cs%jscB,cs%jecB; do i=cs%isc,cs%iec; do k=1,nz
       hv(i,j,k) = 0.5 * (h(i,j,k) + h(i,j+1,k))
    enddo ; enddo ; enddo
 
    do c=1,cs%num_col_v
       i = cs%col_i_v(c) ; j = cs%col_j_v(c)
       damp = dt*cs%Iresttime_col_v(c)
       i1pdamp = 1.0 / (1.0 + damp)
       tmp_val2(1:nz_data) = cs%Ref_val_v%p(1:nz_data,c)
       if (cs%new_sponges) then
         call remapping_core_h(cs%remap_cs, cs%nz_data, cs%Ref_val_v%h(:,c), tmp_val2, &
                  cs%nz, hv(i,j,:), tmp_val1, h_neglect, h_neglect_edge)
       else
         call remapping_core_h(cs%remap_cs, cs%nz_data, cs%Ref_hv%p(:,c), tmp_val2, &
                  cs%nz, hv(i,j,:), tmp_val1, h_neglect, h_neglect_edge)
       endif
       !Backward Euler method
       cs%var_v%p(i,j,:) = i1pdamp * (cs%var_v%p(i,j,:) + tmp_val1 * damp)
    enddo
 
  endif
 
  deallocate(tmp_val2)
 

get_ale_sponge_nz_data()

integer function, public mom_ale_sponge::get_ale_sponge_nz_data

(

type(ale_sponge_cs), pointer

CS

)

Return the number of layers in the data with a fixed ALE sponge, or 0 if there are no sponge columns on this PE.

Parameters

cs	A pointer that is set to point to the control structure for the ALE_sponge module.

Returns

The number of layers in the fixed sponge data.

Definition at line 326 of file MOM_ALE_sponge.F90.

  type(ALE_sponge_CS),   pointer       :: CS !< A pointer that is set to point to the control
                                             !! structure for the ALE_sponge module.
  integer :: get_ALE_sponge_nz_data  !< The number of layers in the fixed sponge data.
 
  if (associated(cs)) then
    get_ale_sponge_nz_data = cs%nz_data
  else
    get_ale_sponge_nz_data = 0
  endif

get_ale_sponge_thicknesses()

subroutine, public mom_ale_sponge::get_ale_sponge_thicknesses	(	type(ocean_grid_type), intent(in)	G,
		real, dimension(:,:,:), intent(inout), allocatable	data_h,
		logical, dimension(szi_(g),szj_(g)), intent(out)	sponge_mask,
		type(ale_sponge_cs), pointer	CS
	)

Return the thicknesses used for the data with a fixed ALE sponge.

Parameters

[in]	g	The ocean's grid structure (in).
[in,out]	data_h	The thicknesses of the sponge input layers [H ~> m or kg m-2].
[out]	sponge_mask	A logical mask that is true where
	cs	A pointer that is set to point to the control structure for the ALE_sponge module.

Definition at line 339 of file MOM_ALE_sponge.F90.

  type(ocean_grid_type), intent(in)    :: G !< The ocean's grid structure (in).
  real, allocatable, dimension(:,:,:), &
                         intent(inout) :: data_h !< The thicknesses of the sponge input layers [H ~> m or kg m-2].
  logical, dimension(SZI_(G),SZJ_(G)), &
                         intent(out)   :: sponge_mask !< A logical mask that is true where
                                                 !! sponges are being applied.
  type(ALE_sponge_CS),   pointer       :: CS !< A pointer that is set to point to the control
                                             !! structure for the ALE_sponge module.
  integer :: c, i, j, k
 
  if (allocated(data_h)) call mom_error(fatal, &
    "get_ALE_sponge_thicknesses called with an allocated data_h.")
 
  if (.not.associated(cs)) then
    ! There are no sponge points on this PE.
    allocate(data_h(g%isd:g%ied,g%jsd:g%jed,1)) ; data_h(:,:,:) = -1.0
    sponge_mask(:,:) = .false.
    return
  endif
 
  allocate(data_h(g%isd:g%ied,g%jsd:g%jed,cs%nz_data)) ; data_h(:,:,:) = -1.0
  sponge_mask(:,:) = .false.
 
  do c=1,cs%num_col
    i = cs%col_i(c) ; j = cs%col_j(c)
    sponge_mask(i,j) = .true.
    do k=1,cs%nz_data
      data_h(i,j,k) = cs%Ref_h%p(k,c)
    enddo
  enddo
 

init_ale_sponge_diags()

subroutine, public mom_ale_sponge::init_ale_sponge_diags	(	type(time_type), intent(in), target	Time,
		type(ocean_grid_type), intent(in)	G,
		type(diag_ctrl), intent(inout), target	diag,
		type(ale_sponge_cs), pointer	CS
	)

Initialize diagnostics for the ALE_sponge module.

Parameters

[in]	time	The current model time
[in]	g	The ocean's grid structure
[in,out]	diag	A structure that is used to regulate diagnostic output.
	cs	ALE sponge control structure

Definition at line 539 of file MOM_ALE_sponge.F90.

  type(time_type), target, intent(in)    :: Time !< The current model time
  type(ocean_grid_type),   intent(in)    :: G    !< The ocean's grid structure
  type(diag_ctrl), target, intent(inout) :: diag !< A structure that is used to regulate diagnostic
                                                 !! output.
  type(ALE_sponge_CS),     pointer       :: CS   !< ALE sponge control structure
 
  if (.not.associated(cs)) return
 
  cs%diag => diag
 

initialize_ale_sponge_fixed()

subroutine mom_ale_sponge::initialize_ale_sponge_fixed	(	real, dimension(szi_(g),szj_(g)), intent(in)	Iresttime,
		type(ocean_grid_type), intent(in)	G,
		type(param_file_type), intent(in)	param_file,
		type(ale_sponge_cs), pointer	CS,
		real, dimension(szi_(g),szj_(g),nz_data), intent(in)	data_h,
		integer, intent(in)	nz_data
	)

This subroutine determines the number of points which are within sponges in this computational domain. Only points that have positive values of Iresttime and which mask2dT indicates are ocean points are included in the sponges. It also stores the target interface heights.

Parameters

[in]	g	The ocean's grid structure.
[in]	nz_data	The total number of sponge input layers.
[in]	iresttime	The inverse of the restoring time [s-1].
[in]	param_file	A structure indicating the open file to parse for model parameter values.
	cs	A pointer that is set to point to the control structure for this module (in/out).
[in]	data_h	The thicknesses of the sponge input layers [H ~> m or kg m-2].

Definition at line 141 of file MOM_ALE_sponge.F90.

 
  type(ocean_grid_type),            intent(in) :: G !< The ocean's grid structure.
  integer,                          intent(in) :: nz_data !< The total number of sponge input layers.
  real, dimension(SZI_(G),SZJ_(G)), intent(in) :: Iresttime !< The inverse of the restoring time [s-1].
  type(param_file_type),            intent(in) :: param_file !< A structure indicating the open file
                                                             !! to parse for model parameter values.
  type(ALE_sponge_CS),              pointer    :: CS !< A pointer that is set to point to the control
                                                     !! structure for this module (in/out).
  real, dimension(SZI_(G),SZJ_(G),nz_data), intent(in) :: data_h !< The thicknesses of the sponge
                                                     !! input layers [H ~> m or kg m-2].
 
 
! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "MOM_sponge"  ! This module's name.
  logical :: use_sponge
  real, allocatable, dimension(:,:,:) :: data_hu !< thickness at u points [H ~> m or kg m-2]
  real, allocatable, dimension(:,:,:) :: data_hv !< thickness at v points [H ~> m or kg m-2]
  real, allocatable, dimension(:,:) :: Iresttime_u !< inverse of the restoring time at u points [s-1]
  real, allocatable, dimension(:,:) :: Iresttime_v !< inverse of the restoring time at v points [s-1]
  logical :: bndExtrapolation = .true. ! If true, extrapolate boundaries
  integer :: i, j, k, col, total_sponge_cols, total_sponge_cols_u, total_sponge_cols_v
  character(len=10)  :: remapScheme
  if (associated(cs)) then
    call mom_error(warning, "initialize_sponge called with an associated "// &
                            "control structure.")
    return
  endif
 
! Set default, read and log parameters
  call log_version(param_file, mdl, version, "")
  call get_param(param_file, mdl, "SPONGE", use_sponge, &
                 "If true, sponges may be applied anywhere in the domain. "//&
                 "The exact location and properties of those sponges are "//&
                 "specified from MOM_initialization.F90.", default=.false.)
 
  if (.not.use_sponge) return
 
  allocate(cs)
 
  call get_param(param_file, mdl, "SPONGE_UV", cs%sponge_uv, &
                 "Apply sponges in u and v, in addition to tracers.", &
                 default=.false.)
 
  call get_param(param_file, mdl, "REMAPPING_SCHEME", remapscheme, &
                 "This sets the reconstruction scheme used "//&
                 " for vertical remapping for all variables.", &
                 default="PLM", do_not_log=.true.)
 
  call get_param(param_file, mdl, "BOUNDARY_EXTRAPOLATION", bndextrapolation, &
                 "When defined, a proper high-order reconstruction "//&
                 "scheme is used within boundary cells rather "//&
                 "than PCM. E.g., if PPM is used for remapping, a "//&
                 "PPM reconstruction will also be used within boundary cells.", &
                 default=.false., do_not_log=.true.)
 
  cs%new_sponges = .false.
  cs%nz = g%ke
  cs%isc = g%isc ; cs%iec = g%iec ; cs%jsc = g%jsc ; cs%jec = g%jec
  cs%isd = g%isd ; cs%ied = g%ied ; cs%jsd = g%jsd ; cs%jed = g%jed
  cs%iscB = g%iscB ; cs%iecB = g%iecB; cs%jscB = g%jscB ; cs%jecB = g%jecB
 
  ! number of columns to be restored
  cs%num_col = 0 ; cs%fldno = 0
  do j=g%jsc,g%jec ; do i=g%isc,g%iec
    if ((iresttime(i,j)>0.0) .and. (g%mask2dT(i,j)>0)) &
      cs%num_col = cs%num_col + 1
  enddo ; enddo
 
  if (cs%num_col > 0) then
    allocate(cs%Iresttime_col(cs%num_col)) ; cs%Iresttime_col = 0.0
    allocate(cs%col_i(cs%num_col))         ; cs%col_i = 0
    allocate(cs%col_j(cs%num_col))         ; cs%col_j = 0
    ! pass indices, restoring time to the CS structure
    col = 1
    do j=g%jsc,g%jec ; do i=g%isc,g%iec
      if ((iresttime(i,j)>0.0) .and. (g%mask2dT(i,j)>0)) then
        cs%col_i(col) = i ; cs%col_j(col) = j
        cs%Iresttime_col(col) = iresttime(i,j)
        col = col +1
      endif
    enddo ; enddo
    ! same for total number of arbritary layers and correspondent data
    cs%nz_data = nz_data
    allocate(cs%Ref_h%p(cs%nz_data,cs%num_col))
    do col=1,cs%num_col ; do k=1,cs%nz_data
      cs%Ref_h%p(k,col) = data_h(cs%col_i(col),cs%col_j(col),k)
    enddo ; enddo
  endif
 
  total_sponge_cols = cs%num_col
  call sum_across_pes(total_sponge_cols)
 
! Call the constructor for remapping control structure
  call initialize_remapping(cs%remap_cs, remapscheme, boundary_extrapolation=bndextrapolation)
 
  call log_param(param_file, mdl, "!Total sponge columns at h points", total_sponge_cols, &
                 "The total number of columns where sponges are applied at h points.")
 
  if (cs%sponge_uv) then
 
    allocate(data_hu(g%isdB:g%iedB,g%jsd:g%jed,nz_data)); data_hu(:,:,:)=0.0
    allocate(data_hv(g%isd:g%ied,g%jsdB:g%jedB,nz_data)); data_hv(:,:,:)=0.0
    allocate(iresttime_u(g%isdB:g%iedB,g%jsd:g%jed)); iresttime_u(:,:)=0.0
    allocate(iresttime_v(g%isd:g%ied,g%jsdB:g%jedB)); iresttime_v(:,:)=0.0
 
    ! u points
    cs%num_col_u = 0 ; !CS%fldno_u = 0
    do j=cs%jsc,cs%jec; do i=cs%iscB,cs%iecB
       data_hu(i,j,:) = 0.5 * (data_h(i,j,:) + data_h(i+1,j,:))
       iresttime_u(i,j) = 0.5 * (iresttime(i,j) + iresttime(i+1,j))
       if ((iresttime_u(i,j)>0.0) .and. (g%mask2dCu(i,j)>0)) &
          cs%num_col_u = cs%num_col_u + 1
    enddo ; enddo
 
    if (cs%num_col_u > 0) then
 
       allocate(cs%Iresttime_col_u(cs%num_col_u)) ; cs%Iresttime_col_u = 0.0
       allocate(cs%col_i_u(cs%num_col_u))         ; cs%col_i_u = 0
       allocate(cs%col_j_u(cs%num_col_u))         ; cs%col_j_u = 0
 
       ! pass indices, restoring time to the CS structure
       col = 1
       do j=cs%jsc,cs%jec ; do i=cs%iscB,cs%iecB
         if ((iresttime_u(i,j)>0.0) .and. (g%mask2dCu(i,j)>0)) then
           cs%col_i_u(col) = i ; cs%col_j_u(col) = j
           cs%Iresttime_col_u(col) = iresttime_u(i,j)
           col = col +1
         endif
       enddo ; enddo
 
       ! same for total number of arbritary layers and correspondent data
 
       allocate(cs%Ref_hu%p(cs%nz_data,cs%num_col_u))
       do col=1,cs%num_col_u ; do k=1,cs%nz_data
         cs%Ref_hu%p(k,col) = data_hu(cs%col_i_u(col),cs%col_j_u(col),k)
       enddo ; enddo
    endif
    total_sponge_cols_u = cs%num_col_u
    call sum_across_pes(total_sponge_cols_u)
    call log_param(param_file, mdl, "!Total sponge columns at u points", total_sponge_cols_u, &
                "The total number of columns where sponges are applied at u points.")
 
    ! v points
    cs%num_col_v = 0 ; !CS%fldno_v = 0
    do j=cs%jscB,cs%jecB; do i=cs%isc,cs%iec
      data_hv(i,j,:) = 0.5 * (data_h(i,j,:) + data_h(i,j+1,:))
      iresttime_v(i,j) = 0.5 * (iresttime(i,j) + iresttime(i,j+1))
      if ((iresttime_v(i,j)>0.0) .and. (g%mask2dCv(i,j)>0)) &
        cs%num_col_v = cs%num_col_v + 1
    enddo ; enddo
 
    if (cs%num_col_v > 0) then
 
      allocate(cs%Iresttime_col_v(cs%num_col_v)) ; cs%Iresttime_col_v = 0.0
      allocate(cs%col_i_v(cs%num_col_v))         ; cs%col_i_v = 0
      allocate(cs%col_j_v(cs%num_col_v))         ; cs%col_j_v = 0
 
      ! pass indices, restoring time to the CS structure
      col = 1
      do j=cs%jscB,cs%jecB ; do i=cs%isc,cs%iec
        if ((iresttime_v(i,j)>0.0) .and. (g%mask2dCv(i,j)>0)) then
          cs%col_i_v(col) = i ; cs%col_j_v(col) = j
          cs%Iresttime_col_v(col) = iresttime_v(i,j)
          col = col +1
        endif
      enddo ; enddo
 
      ! same for total number of arbritary layers and correspondent data
      allocate(cs%Ref_hv%p(cs%nz_data,cs%num_col_v))
      do col=1,cs%num_col_v ; do k=1,cs%nz_data
        cs%Ref_hv%p(k,col) = data_hv(cs%col_i_v(col),cs%col_j_v(col),k)
      enddo ; enddo
    endif
    total_sponge_cols_v = cs%num_col_v
    call sum_across_pes(total_sponge_cols_v)
    call log_param(param_file, mdl, "!Total sponge columns at v points", total_sponge_cols_v, &
                 "The total number of columns where sponges are applied at v points.")
  endif
 

initialize_ale_sponge_varying()

subroutine mom_ale_sponge::initialize_ale_sponge_varying ( real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(in)  Iresttime, type(ocean_grid_type), intent(in)  G, type(param_file_type), intent(in)  param_file, type(ale_sponge_cs), pointer  CS  )

private

This subroutine determines the number of points which are within sponges in this computational domain. Only points that have positive values of Iresttime and which mask2dT indicates are ocean points are included in the sponges.

Parameters

[in]	g	The ocean's grid structure.
[in]	iresttime	The inverse of the restoring time [s-1].
[in]	param_file	A structure indicating the open file to parse for model parameter values.
	cs	A pointer that is set to point to the control structure for this module (in/out).

Definition at line 376 of file MOM_ALE_sponge.F90.

 
  type(ocean_grid_type),            intent(in) :: G !< The ocean's grid structure.
  real, dimension(SZI_(G),SZJ_(G)), intent(in) :: Iresttime !< The inverse of the restoring time [s-1].
  type(param_file_type),            intent(in) :: param_file !< A structure indicating the open file to parse
                                                             !! for model parameter values.
  type(ALE_sponge_CS),              pointer    :: CS !< A pointer that is set to point to the control
                                                     !! structure for this module (in/out).
 
 
 
! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "MOM_sponge"  ! This module's name.
  logical :: use_sponge
    real, allocatable, dimension(:,:) :: Iresttime_u !< inverse of the restoring time at u points [s-1]
  real, allocatable, dimension(:,:) :: Iresttime_v !< inverse of the restoring time at v points [s-1]
  logical :: bndExtrapolation = .true. ! If true, extrapolate boundaries
  integer :: i, j, k, col, total_sponge_cols, total_sponge_cols_u, total_sponge_cols_v
  character(len=10)  :: remapScheme
  if (associated(cs)) then
    call mom_error(warning, "initialize_sponge called with an associated "// &
                            "control structure.")
    return
  endif
 
! Set default, read and log parameters
  call log_version(param_file, mdl, version, "")
  call get_param(param_file, mdl, "SPONGE", use_sponge, &
                 "If true, sponges may be applied anywhere in the domain. "//&
                 "The exact location and properties of those sponges are "//&
                 "specified from MOM_initialization.F90.", default=.false.)
 
  if (.not.use_sponge) return
 
  allocate(cs)
 
  call get_param(param_file, mdl, "SPONGE_UV", cs%sponge_uv, &
                 "Apply sponges in u and v, in addition to tracers.", &
                 default=.false.)
 
  call get_param(param_file, mdl, "REMAPPING_SCHEME", remapscheme, &
                 "This sets the reconstruction scheme used "//&
                 " for vertical remapping for all variables.", &
                 default="PLM", do_not_log=.true.)
 
  call get_param(param_file, mdl, "BOUNDARY_EXTRAPOLATION", bndextrapolation, &
                 "When defined, a proper high-order reconstruction "//&
                 "scheme is used within boundary cells rather "//&
                 "than PCM. E.g., if PPM is used for remapping, a "//&
                 "PPM reconstruction will also be used within boundary cells.", &
                 default=.false., do_not_log=.true.)
 
  cs%new_sponges = .true.
  cs%nz = g%ke
  cs%isc = g%isc ; cs%iec = g%iec ; cs%jsc = g%jsc ; cs%jec = g%jec
  cs%isd = g%isd ; cs%ied = g%ied ; cs%jsd = g%jsd ; cs%jed = g%jed
  cs%iscB = g%iscB ; cs%iecB = g%iecB; cs%jscB = g%jscB ; cs%jecB = g%jecB
 
  ! number of columns to be restored
  cs%num_col = 0 ; cs%fldno = 0
  do j=g%jsc,g%jec ; do i=g%isc,g%iec
    if ((iresttime(i,j)>0.0) .and. (g%mask2dT(i,j)>0)) &
      cs%num_col = cs%num_col + 1
  enddo ; enddo
 
 
  if (cs%num_col > 0) then
    allocate(cs%Iresttime_col(cs%num_col)) ; cs%Iresttime_col = 0.0
    allocate(cs%col_i(cs%num_col))         ; cs%col_i = 0
    allocate(cs%col_j(cs%num_col))         ; cs%col_j = 0
    ! pass indices, restoring time to the CS structure
    col = 1
    do j=g%jsc,g%jec ; do i=g%isc,g%iec
      if ((iresttime(i,j)>0.0) .and. (g%mask2dT(i,j)>0)) then
        cs%col_i(col) = i ; cs%col_j(col) = j
        cs%Iresttime_col(col) = iresttime(i,j)
        col = col +1
      endif
    enddo ; enddo
  endif
 
  total_sponge_cols = cs%num_col
  call sum_across_pes(total_sponge_cols)
 
! Call the constructor for remapping control structure
  call initialize_remapping(cs%remap_cs, remapscheme, boundary_extrapolation=bndextrapolation)
 
  call log_param(param_file, mdl, "!Total sponge columns at h points", total_sponge_cols, &
                 "The total number of columns where sponges are applied at h points.")
 
  if (cs%sponge_uv) then
 
     allocate(iresttime_u(g%isdB:g%iedB,g%jsd:g%jed)); iresttime_u(:,:)=0.0
     allocate(iresttime_v(g%isd:g%ied,g%jsdB:g%jedB)); iresttime_v(:,:)=0.0
 
     ! u points
     cs%num_col_u = 0 ; !CS%fldno_u = 0
     do j=cs%jsc,cs%jec; do i=cs%iscB,cs%iecB
        iresttime_u(i,j) = 0.5 * (iresttime(i,j) + iresttime(i+1,j))
        if ((iresttime_u(i,j)>0.0) .and. (g%mask2dCu(i,j)>0)) &
           cs%num_col_u = cs%num_col_u + 1
     enddo ; enddo
 
     if (cs%num_col_u > 0) then
 
        allocate(cs%Iresttime_col_u(cs%num_col_u)) ; cs%Iresttime_col_u = 0.0
        allocate(cs%col_i_u(cs%num_col_u))         ; cs%col_i_u = 0
        allocate(cs%col_j_u(cs%num_col_u))         ; cs%col_j_u = 0
 
        ! pass indices, restoring time to the CS structure
        col = 1
        do j=cs%jsc,cs%jec ; do i=cs%iscB,cs%iecB
          if ((iresttime_u(i,j)>0.0) .and. (g%mask2dCu(i,j)>0)) then
            cs%col_i_u(col) = i ; cs%col_j_u(col) = j
            cs%Iresttime_col_u(col) = iresttime_u(i,j)
            col = col +1
          endif
        enddo ; enddo
 
        ! same for total number of arbritary layers and correspondent data
 
     endif
     total_sponge_cols_u = cs%num_col_u
     call sum_across_pes(total_sponge_cols_u)
     call log_param(param_file, mdl, "!Total sponge columns at u points", total_sponge_cols_u, &
                 "The total number of columns where sponges are applied at u points.")
 
     ! v points
     cs%num_col_v = 0 ; !CS%fldno_v = 0
     do j=cs%jscB,cs%jecB; do i=cs%isc,cs%iec
        iresttime_v(i,j) = 0.5 * (iresttime(i,j) + iresttime(i,j+1))
        if ((iresttime_v(i,j)>0.0) .and. (g%mask2dCv(i,j)>0)) &
           cs%num_col_v = cs%num_col_v + 1
     enddo ; enddo
 
     if (cs%num_col_v > 0) then
 
        allocate(cs%Iresttime_col_v(cs%num_col_v)) ; cs%Iresttime_col_v = 0.0
        allocate(cs%col_i_v(cs%num_col_v))         ; cs%col_i_v = 0
        allocate(cs%col_j_v(cs%num_col_v))         ; cs%col_j_v = 0
 
        ! pass indices, restoring time to the CS structure
        col = 1
        do j=cs%jscB,cs%jecB ; do i=cs%isc,cs%iec
          if ((iresttime_v(i,j)>0.0) .and. (g%mask2dCv(i,j)>0)) then
            cs%col_i_v(col) = i ; cs%col_j_v(col) = j
            cs%Iresttime_col_v(col) = iresttime_v(i,j)
            col = col +1
          endif
        enddo ; enddo
 
     endif
     total_sponge_cols_v = cs%num_col_v
     call sum_across_pes(total_sponge_cols_v)
     call log_param(param_file, mdl, "!Total sponge columns at v points", total_sponge_cols_v, &
                 "The total number of columns where sponges are applied at v points.")
  endif
 

set_up_ale_sponge_field_fixed()

subroutine mom_ale_sponge::set_up_ale_sponge_field_fixed ( real, dimension( g %isd: g %ied, g %jsd: g %jed,cs%nz_data), intent(in)  sp_val, type(ocean_grid_type), intent(in)  G, real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in), target  f_ptr, type(ale_sponge_cs), pointer  CS  )

private

This subroutine stores the reference profile at h points for the variable whose address is given by f_ptr.

Parameters

[in]	g	Grid structure
	cs	ALE sponge control structure (in/out).
[in]	sp_val	Field to be used in the sponge, it has arbritary number of layers.
[in]	f_ptr	Pointer to the field to be damped

Definition at line 554 of file MOM_ALE_sponge.F90.

  type(ocean_grid_type), intent(in) :: G  !< Grid structure
  type(ALE_sponge_CS),   pointer    :: CS !< ALE sponge control structure (in/out).
  real, dimension(SZI_(G),SZJ_(G),CS%nz_data), &
                         intent(in) :: sp_val !< Field to be used in the sponge, it has arbritary number of layers.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                 target, intent(in) :: f_ptr !< Pointer to the field to be damped
 
  integer :: j, k, col
  character(len=256) :: mesg ! String for error messages
 
  if (.not.associated(cs)) return
 
  cs%fldno = cs%fldno + 1
 
  if (cs%fldno > max_fields_) then
    write(mesg,'("Increase MAX_FIELDS_ to at least ",I3," in MOM_memory.h or decrease &
           &the number of fields to be damped in the call to &
           &initialize_sponge." )') cs%fldno
    call mom_error(fatal,"set_up_ALE_sponge_field: "//mesg)
  endif
 
  ! stores the reference profile
  allocate(cs%Ref_val(cs%fldno)%p(cs%nz_data,cs%num_col))
  cs%Ref_val(cs%fldno)%p(:,:) = 0.0
  do col=1,cs%num_col
    do k=1,cs%nz_data
      cs%Ref_val(cs%fldno)%p(k,col) = sp_val(cs%col_i(col),cs%col_j(col),k)
    enddo
  enddo
 
  cs%var(cs%fldno)%p => f_ptr
 

set_up_ale_sponge_field_varying()

subroutine mom_ale_sponge::set_up_ale_sponge_field_varying ( character(len=*), intent(in)  filename, character(len=*), intent(in)  fieldname, type(time_type), intent(in)  Time, type(ocean_grid_type), intent(in)  G, type(verticalgrid_type), intent(in)  GV, real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in), target  f_ptr, type(ale_sponge_cs), pointer  CS  )

private

This subroutine stores the reference profile at h points for the variable whose address is given by filename and fieldname.

Parameters

[in]	filename	The name of the file with the time varying field data
[in]	fieldname	The name of the field in the file with the time varying field data
[in]	time	The current model time
[in]	g	Grid structure (in).
[in]	gv	ocean vertical grid structure
[in]	f_ptr	Pointer to the field to be damped (in).
	cs	Sponge control structure (in/out).

Definition at line 591 of file MOM_ALE_sponge.F90.

  character(len=*),        intent(in) :: filename !< The name of the file with the
                                                  !! time varying field data
  character(len=*),        intent(in) :: fieldname !< The name of the field in the file
                                                  !! with the time varying field data
  type(time_type),         intent(in) :: Time  !< The current model time
  type(ocean_grid_type),   intent(in) :: G     !< Grid structure (in).
  type(verticalGrid_type), intent(in) :: GV    !< ocean vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                   target, intent(in) :: f_ptr !< Pointer to the field to be damped (in).
  type(ALE_sponge_CS),     pointer    :: CS    !< Sponge control structure (in/out).
 
  ! Local variables
  real, allocatable, dimension(:,:,:) :: sp_val !< Field to be used in the sponge
  real, allocatable, dimension(:,:,:) :: mask_z !< Field mask for the sponge data
  real, allocatable, dimension(:), target :: z_in, z_edges_in ! Heights [Z ~> m].
  real :: missing_value
  integer :: j, k, col
  integer :: isd,ied,jsd,jed
  integer :: nPoints
  integer, dimension(4) :: fld_sz
  integer :: nz_data !< the number of vertical levels in this input field
  character(len=256) :: mesg ! String for error messages
 
  ! Local variables for ALE remapping
  real, dimension(:), allocatable :: hsrc ! Source thicknesses [Z ~> m].
  real, dimension(:), allocatable :: tmpT1d
  real :: zTopOfCell, zBottomOfCell ! Heights [Z ~> m].
  type(remapping_CS) :: remapCS ! Remapping parameters and work arrays
 
  if (.not.associated(cs)) return
 
  ! Call this in case it was not previously done.
  call time_interp_external_init()
 
  isd = g%isd; ied = g%ied; jsd = g%jsd; jed = g%jed
  cs%fldno = cs%fldno + 1
 
   if (cs%fldno > max_fields_) then
    write(mesg,'("Increase MAX_FIELDS_ to at least ",I3," in MOM_memory.h or decrease &
           &the number of fields to be damped in the call to &
           &initialize_sponge." )') cs%fldno
    call mom_error(fatal,"set_up_ALE_sponge_field: "//mesg)
  endif
 
  ! get a unique id for this field which will allow us to return an array
  ! containing time-interpolated values from an external file corresponding
  ! to the current model date.
 
  cs%Ref_val(cs%fldno)%id = init_external_field(filename, fieldname)
  fld_sz(1:4)=-1
  fld_sz = get_external_field_size(cs%Ref_val(cs%fldno)%id)
  nz_data = fld_sz(3)
  cs%Ref_val(cs%fldno)%nz_data = nz_data !< each individual sponge field is assumed to reside on a different grid
  cs%Ref_val(cs%fldno)%num_tlevs = fld_sz(4)
 
  allocate( sp_val(isd:ied,jsd:jed, nz_data) )
  allocate( mask_z(isd:ied,jsd:jed, nz_data) )
 
  ! initializes the current reference profile array
  allocate(cs%Ref_val(cs%fldno)%p(nz_data,cs%num_col))
  cs%Ref_val(cs%fldno)%p(:,:) = 0.0
  allocate( cs%Ref_val(cs%fldno)%h(nz_data,cs%num_col) )
  cs%Ref_val(cs%fldno)%h(:,:) = 0.0
 
  ! Interpolate external file data to the model grid
  ! I am hard-wiring this call to assume that the input grid is zonally re-entrant
  ! In the future, this should be generalized using an interface to return the
  ! modulo attribute of the zonal axis (mjh).
 
 ! call horiz_interp_and_extrap_tracer(CS%Ref_val(CS%fldno)%id,Time, 1.0,G,sp_val,mask_z,z_in,z_edges_in, &
 !                                     missing_value, .true., .false., .false., m_to_Z=US%m_to_Z)
 
! Do not think halo updates are needed (mjh)
!  call pass_var(sp_val,G%Domain)
!  call pass_var(mask_z,G%Domain)
 
! Done with horizontal interpolation.
! Now remap to model coordinates
! First we reserve a work space for reconstructions of the source data
  allocate( hsrc(nz_data) )
  allocate( tmpt1d(nz_data) )
 
  do col=1,cs%num_col
    ! Build the source grid
    ztopofcell = 0. ; zbottomofcell = 0. ; npoints = 0; hsrc(:) = 0.0; tmpt1d(:) = -99.9
    do k=1,nz_data
      if (mask_z(cs%col_i(col),cs%col_j(col),k) == 1.0) then
        zbottomofcell = -min( z_edges_in(k+1), g%bathyT(cs%col_i(col),cs%col_j(col)) )
!        tmpT1d(k) = sp_val(CS%col_i(col),CS%col_j(col),k)
      elseif (k>1) then
        zbottomofcell = -g%bathyT(cs%col_i(col),cs%col_j(col))
!        tmpT1d(k) = tmpT1d(k-1)
!      else ! This next block should only ever be reached over land
!        tmpT1d(k) = -99.9
      endif
      hsrc(k) = ztopofcell - zbottomofcell
      if (hsrc(k)>0.) npoints = npoints + 1
      ztopofcell = zbottomofcell ! Bottom becomes top for next value of k
    enddo
    ! In case data is deeper than model
    hsrc(nz_data) = hsrc(nz_data) + ( ztopofcell + g%bathyT(cs%col_i(col),cs%col_j(col)) )
    cs%Ref_val(cs%fldno)%h(1:nz_data,col) = 0.
    cs%Ref_val(cs%fldno)%p(1:nz_data,col) = -1.e24
    cs%Ref_val(cs%fldno)%h(1:nz_data,col) = gv%Z_to_H*hsrc(1:nz_data)
!    CS%Ref_val(CS%fldno)%p(1:nz_data,col) = tmpT1d(1:nz_data)
  enddo
 
  cs%var(cs%fldno)%p => f_ptr
 
  deallocate( hsrc )
  deallocate( tmpt1d )
  deallocate(sp_val, mask_z)
 

set_up_ale_sponge_vel_field_fixed()

subroutine mom_ale_sponge::set_up_ale_sponge_vel_field_fixed ( real, dimension( g %isdb: g %iedb, g %jsd: g %jed,cs%nz_data), intent(in)  u_val, real, dimension( g %isd: g %ied, g %jsdb: g %jedb,cs%nz_data), intent(in)  v_val, type(ocean_grid_type), intent(in)  G, real, dimension( g %isdb: g %iedb, g %jsd: g %jed, g %ke), intent(in), target  u_ptr, real, dimension( g %isd: g %ied, g %jsdb: g %jedb, g %ke), intent(in), target  v_ptr, type(ale_sponge_cs), pointer  CS  )

private

This subroutine stores the reference profile at u and v points for the variable whose address is given by u_ptr and v_ptr.

Parameters

[in]	g	Grid structure (in).
	cs	Sponge structure (in/out).
[in]	u_val	u field to be used in the sponge, it has arbritary number of layers.
[in]	v_val	v field to be used in the sponge, it has arbritary number of layers.
[in]	u_ptr	u pointer to the field to be damped
[in]	v_ptr	v pointer to the field to be damped

Definition at line 709 of file MOM_ALE_sponge.F90.

  type(ocean_grid_type), intent(in) :: G  !< Grid structure (in).
  type(ALE_sponge_CS),   pointer    :: CS !< Sponge structure (in/out).
  real, dimension(SZIB_(G),SZJ_(G),CS%nz_data), &
                         intent(in) :: u_val !< u field to be used in the sponge, it has arbritary number of layers.
  real, dimension(SZI_(G),SZJB_(G),CS%nz_data), &
                         intent(in) :: v_val !< v field to be used in the sponge, it has arbritary number of layers.
  real, dimension(SZIB_(G),SZJ_(G),SZK_(G)), target, intent(in) :: u_ptr !< u pointer to the field to be damped
  real, dimension(SZI_(G),SZJB_(G),SZK_(G)), target, intent(in) :: v_ptr !< v pointer to the field to be damped
 
  integer :: j, k, col
  character(len=256) :: mesg ! String for error messages
 
  if (.not.associated(cs)) return
 
  ! stores the reference profile
  allocate(cs%Ref_val_u%p(cs%nz_data,cs%num_col_u))
  cs%Ref_val_u%p(:,:) = 0.0
  do col=1,cs%num_col_u
    do k=1,cs%nz_data
      cs%Ref_val_u%p(k,col) = u_val(cs%col_i_u(col),cs%col_j_u(col),k)
    enddo
  enddo
 
  cs%var_u%p => u_ptr
 
  allocate(cs%Ref_val_v%p(cs%nz_data,cs%num_col_v))
  cs%Ref_val_v%p(:,:) = 0.0
  do col=1,cs%num_col_v
    do k=1,cs%nz_data
      cs%Ref_val_v%p(k,col) = v_val(cs%col_i_v(col),cs%col_j_v(col),k)
    enddo
  enddo
 
  cs%var_v%p => v_ptr
 

set_up_ale_sponge_vel_field_varying()

subroutine mom_ale_sponge::set_up_ale_sponge_vel_field_varying ( character(len=*), intent(in)  filename_u, character(len=*), intent(in)  fieldname_u, character(len=*), intent(in)  filename_v, character(len=*), intent(in)  fieldname_v, type(time_type), intent(in)  Time, type(ocean_grid_type), intent(inout)  G, type(unit_scale_type), intent(in)  US, type(ale_sponge_cs), pointer  CS, real, dimension( g %isdb: g %iedb, g %jsd: g %jed, g %ke), intent(in), target  u_ptr, real, dimension( g %isd: g %ied, g %jsdb: g %jedb, g %ke), intent(in), target  v_ptr  )

private

This subroutine stores the reference profile at uand v points for the variable whose address is given by u_ptr and v_ptr.

Parameters

[in]	filename_u	File name for u field
[in]	fieldname_u	Name of u variable in file
[in]	filename_v	File name for v field
[in]	fieldname_v	Name of v variable in file
[in]	time	Model time
[in,out]	g	Ocean grid (in)
[in]	us	A dimensional unit scaling type
	cs	Sponge structure (in/out).
[in]	u_ptr	u pointer to the field to be damped (in).
[in]	v_ptr	v pointer to the field to be damped (in).

Definition at line 750 of file MOM_ALE_sponge.F90.

  character(len=*), intent(in)    :: filename_u  !< File name for u field
  character(len=*), intent(in)    :: fieldname_u !< Name of u variable in file
  character(len=*), intent(in)    :: filename_v  !< File name for v field
  character(len=*), intent(in)    :: fieldname_v !< Name of v variable in file
  type(time_type),  intent(in)    :: Time        !< Model time
  type(ocean_grid_type), intent(inout) :: G      !< Ocean grid (in)
  type(unit_scale_type), intent(in)    :: US     !< A dimensional unit scaling type
  type(ALE_sponge_CS), pointer    :: CS          !< Sponge structure (in/out).
  real, dimension(SZIB_(G),SZJ_(G),SZK_(G)), target, intent(in) :: u_ptr !< u pointer to the field to be damped (in).
  real, dimension(SZI_(G),SZJB_(G),SZK_(G)), target, intent(in) :: v_ptr !< v pointer to the field to be damped (in).
  ! Local variables
  real, allocatable, dimension(:,:,:) :: u_val !< U field to be used in the sponge.
  real, allocatable, dimension(:,:,:) :: mask_u !< U field mask for the sponge data.
  real, allocatable, dimension(:,:,:) :: v_val !< V field to be used in the sponge.
  real, allocatable, dimension(:,:,:) :: mask_v !< V field mask for the sponge data.
 
  real, allocatable, dimension(:), target :: z_in, z_edges_in
  real :: missing_value
 
  integer :: j, k, col
  integer :: isd, ied, jsd, jed
  integer :: isdB, iedB, jsdB, jedB
  integer, dimension(4) :: fld_sz
  character(len=256) :: mesg ! String for error messages
 
  if (.not.associated(cs)) return
 
  isd = g%isd; ied = g%ied; jsd = g%jsd; jed = g%jed
  isdb = g%isdB; iedb = g%iedB; jsdb = g%jsdB; jedb = g%jedB
 
  ! get a unique id for this field which will allow us to return an array
  ! containing time-interpolated values from an external file corresponding
  ! to the current model date.
 
  cs%Ref_val_u%id = init_external_field(filename_u, fieldname_u)
  fld_sz(1:4)=-1
  fld_sz = get_external_field_size(cs%Ref_val_u%id)
  cs%Ref_val_u%nz_data = fld_sz(3)
  cs%Ref_val_u%num_tlevs = fld_sz(4)
 
  cs%Ref_val_v%id = init_external_field(filename_v, fieldname_v)
  fld_sz(1:4)=-1
  fld_sz = get_external_field_size(cs%Ref_val_v%id)
  cs%Ref_val_v%nz_data = fld_sz(3)
  cs%Ref_val_v%num_tlevs = fld_sz(4)
 
  allocate( u_val(isdb:iedb,jsd:jed, fld_sz(3)) )
  allocate( mask_u(isdb:iedb,jsd:jed, fld_sz(3)) )
  allocate( v_val(isd:ied,jsdb:jedb, fld_sz(3)) )
  allocate( mask_v(isd:ied,jsdb:jedb, fld_sz(3)) )
 
  ! Interpolate external file data to the model grid
  ! I am hard-wiring this call to assume that the input grid is zonally re-entrant
  ! In the future, this should be generalized using an interface to return the
  ! modulo attribute of the zonal axis (mjh).
 
  call horiz_interp_and_extrap_tracer(cs%Ref_val_u%id,time, 1.0,g,u_val,mask_u,z_in,z_edges_in,&
                                     missing_value,.true.,.false.,.false., m_to_z=us%m_to_Z)
 
!!! TODO: add a velocity interface! (mjh)
 
  ! Interpolate external file data to the model grid
  ! I am hard-wiring this call to assume that the input grid is zonally re-entrant
  ! In the future, this should be generalized using an interface to return the
  ! modulo attribute of the zonal axis (mjh).
 
  call horiz_interp_and_extrap_tracer(cs%Ref_val_v%id,time, 1.0,g,v_val,mask_v,z_in,z_edges_in, &
                                     missing_value,.true.,.false.,.false., m_to_z=us%m_to_Z)
 
  ! stores the reference profile
  allocate(cs%Ref_val_u%p(fld_sz(3),cs%num_col_u))
  cs%Ref_val_u%p(:,:) = 0.0
  do col=1,cs%num_col_u
    do k=1,fld_sz(3)
      cs%Ref_val_u%p(k,col) = u_val(cs%col_i_u(col),cs%col_j_u(col),k)
    enddo
  enddo
 
  cs%var_u%p => u_ptr
 
  allocate(cs%Ref_val_v%p(fld_sz(3),cs%num_col_v))
  cs%Ref_val_v%p(:,:) = 0.0
  do col=1,cs%num_col_v
    do k=1,fld_sz(3)
      cs%Ref_val_v%p(k,col) = v_val(cs%col_i_v(col),cs%col_j_v(col),k)
    enddo
  enddo
 
  cs%var_v%p => v_ptr