mom_diag_remap Module Reference

Detailed Description

This module is used for runtime remapping of diagnostics to z star, sigma and rho vertical coordinates. It defines the diag_remap_ctrl type which represents a remapping of diagnostics to a particular vertical coordinate. The module is used by the diag mediator module in the following way: 1) _init() is called to initialise a diag_remap_ctrl instance. 2) _configure_axes() is called to read the configuration file and set up the vertical coordinate / axes definitions. 3) _get_axes_info() returns information needed for the diag mediator to define new axes for the remapped diagnostics. 4) _update() is called periodically (whenever h, T or S change) to either create or update the target remapping grids. 5) _do_remap() is called from within a diag post() to do the remapping before the diagnostic is written out.

Data Types
type	diag_remap_ctrl
	This type represents remapping of diagnostics to a particular vertical coordinate. There is one of these types for each vertical coordinate. The vertical axes of a diagnostic will reference an instance of this type indicating how (or if) the diagnostic should be vertically remapped when being posted. More...

Functions/Subroutines
subroutine, public	diag_remap_init (remap_cs, coord_tuple)
	Initialize a diagnostic remapping type with the given vertical coordinate. More...
subroutine, public	diag_remap_end (remap_cs)
	De-init a diagnostic remapping type. Free allocated memory. More...
subroutine, public	diag_remap_diag_registration_closed (remap_cs)
	Inform that all diagnostics have been registered. If _set_active() has not been called on the remapping control structure will be disabled. This saves time in the case that a vertical coordinate was configured but no diagnostics which use the coordinate appeared in the diag_table. More...
subroutine, public	diag_remap_set_active (remap_cs)
	Indicate that this remapping type is actually used by the diag manager. If this is never called then the type will be disabled to save time. See further explanation with diag_remap_registration_closed. More...
subroutine, public	diag_remap_configure_axes (remap_cs, GV, param_file)
	Configure the vertical axes for a diagnostic remapping control structure. Reads a configuration parameters to determine coordinate generation. More...
subroutine, public	diag_remap_get_axes_info (remap_cs, nz, id_layer, id_interface)
	Get layer and interface axes ids for this coordinate Needed when defining axes groups. More...
logical function, public	diag_remap_axes_configured (remap_cs)
	Whether or not the axes for this vertical coordinated has been configured. Configuration is complete when diag_remap_configure_axes() has been successfully called. More...
subroutine, public	diag_remap_update (remap_cs, G, h, T, S, eqn_of_state)
	Build/update target vertical grids for diagnostic remapping. More...
subroutine, public	diag_remap_do_remap (remap_cs, G, h, staggered_in_x, staggered_in_y, mask, missing_value, field, remapped_field)
	Remap diagnostic field to alternative vertical grid. More...
subroutine, public	vertically_reintegrate_diag_field (remap_cs, G, h, staggered_in_x, staggered_in_y, mask, missing_value, field, reintegrated_field)
	Vertically re-grid an already vertically-integrated diagnostic field to alternative vertical grid. More...
subroutine, public	vertically_interpolate_diag_field (remap_cs, G, h, staggered_in_x, staggered_in_y, mask, missing_value, field, interpolated_field)
	Vertically interpolate diagnostic field to alternative vertical grid. More...
subroutine, public	horizontally_average_diag_field (G, h, staggered_in_x, staggered_in_y, is_layer, is_extensive, missing_value, field, averaged_field)
	Horizontally average field. More...

Function/Subroutine Documentation

diag_remap_axes_configured()

logical function, public mom_diag_remap::diag_remap_axes_configured

(

type(diag_remap_ctrl), intent(in)

remap_cs

)

Whether or not the axes for this vertical coordinated has been configured. Configuration is complete when diag_remap_configure_axes() has been successfully called.

Definition at line 210 of file MOM_diag_remap.F90.

  type(diag_remap_ctrl), intent(in) :: remap_cs
  logical :: diag_remap_axes_configured

  diag_remap_axes_configured = remap_cs%configured

diag_remap_configure_axes()

subroutine, public mom_diag_remap::diag_remap_configure_axes	(	type(diag_remap_ctrl), intent(inout)	remap_cs,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file
	)

Configure the vertical axes for a diagnostic remapping control structure. Reads a configuration parameters to determine coordinate generation.

Parameters

[in,out]	remap_cs	Diag remap control structure
[in]	gv	ocean vertical grid structure
[in]	param_file	Parameter file structure

Definition at line 136 of file MOM_diag_remap.F90.

References regrid_consts::coordinatemode(), and mom_string_functions::lowercase().

  type(diag_remap_ctrl),   intent(inout) :: remap_cs !< Diag remap control structure
  type(verticalgrid_type),    intent(in) :: gv !< ocean vertical grid structure
  type(param_file_type),      intent(in) :: param_file !< Parameter file structure
  ! Local variables
  integer :: nzi(4), nzl(4), k
  character(len=200) :: inputdir, string, filename, int_varname, layer_varname
  character(len=40)  :: mod  = "MOM_diag_remap" ! This module's name.
  character(len=8)   :: units, expected_units
  character(len=34)  :: longname, string2

  character(len=256) :: err_msg
  logical :: ierr

  real, allocatable, dimension(:) :: interfaces, layers

  call initialize_regridding(remap_cs%regrid_cs, gv, gv%max_depth, param_file, mod, &
           trim(remap_cs%vertical_coord_name), "DIAG_COORD", trim(remap_cs%diag_coord_name))
  call set_regrid_params(remap_cs%regrid_cs, min_thickness=0., integrate_downward_for_e=.false.)

  remap_cs%nz = get_regrid_size(remap_cs%regrid_cs)

  if (remap_cs%vertical_coord == coordinatemode('SIGMA')) then
    units = 'nondim'
    longname = 'Fraction'
  elseif (remap_cs%vertical_coord == coordinatemode('RHO')) then
    units = 'kg m-3'
    longname = 'Target Potential Density'
  else
    units = 'meters'
    longname = 'Depth'
  endif

  ! Make axes objects
  allocate(interfaces(remap_cs%nz+1))
  allocate(layers(remap_cs%nz))

  interfaces(:) = getcoordinateinterfaces(remap_cs%regrid_cs)
  layers(:) = 0.5 * ( interfaces(1:remap_cs%nz) + interfaces(2:remap_cs%nz+1) )

  remap_cs%interface_axes_id = diag_axis_init(lowercase(trim(remap_cs%diag_coord_name))//'_i', &
                                              interfaces, trim(units), 'z', &
                                              trim(longname)//' at interface', direction=-1)
  remap_cs%layer_axes_id = diag_axis_init(lowercase(trim(remap_cs%diag_coord_name))//'_l', &
                                          layers, trim(units), 'z', &
                                          trim(longname)//' at cell center', direction=-1, &
                                          edges=remap_cs%interface_axes_id)

  ! Axes have now been configured.
  remap_cs%configured = .true.

  deallocate(interfaces)
  deallocate(layers)

Here is the call graph for this function:

diag_remap_diag_registration_closed()

subroutine, public mom_diag_remap::diag_remap_diag_registration_closed

(

type(diag_remap_ctrl), intent(inout)

remap_cs

)

Inform that all diagnostics have been registered. If _set_active() has not been called on the remapping control structure will be disabled. This saves time in the case that a vertical coordinate was configured but no diagnostics which use the coordinate appeared in the diag_table.

Parameters

[in,out]

remap_cs

Diag remapping control structure

Definition at line 115 of file MOM_diag_remap.F90.

References diag_remap_end().

  type(diag_remap_ctrl), intent(inout) :: remap_cs !< Diag remapping control structure

  if (.not. remap_cs%used) then
    call diag_remap_end(remap_cs)
  endif

Here is the call graph for this function:

diag_remap_do_remap()

subroutine, public mom_diag_remap::diag_remap_do_remap	(	type(diag_remap_ctrl), intent(in)	remap_cs,
		type(ocean_grid_type), intent(in)	G,
		real, dimension(:,:,:), intent(in)	h,
		logical, intent(in)	staggered_in_x,
		logical, intent(in)	staggered_in_y,
		real, dimension(:,:,:), pointer	mask,
		real, intent(in)	missing_value,
		real, dimension(:,:,:), intent(in)	field,
		real, dimension(:,:,:), intent(inout)	remapped_field
	)

Remap diagnostic field to alternative vertical grid.

Parameters

[in]	remap_cs	Diagnostic coodinate control structure
[in]	g	Ocean grid structure
[in]	h	The current thicknesses
[in]	staggered_in_x	True is the x-axis location is at u or q points
[in]	staggered_in_y	True is the y-axis location is at v or q points
	mask	A mask for the field
[in]	missing_value	A missing_value to assign land/vanished points
[in]	field	The diagnostic field to be remapped
[in,out]	remapped_field	Field remapped to new coordinate

Definition at line 286 of file MOM_diag_remap.F90.

References mom_error_handler::assert(), regrid_consts::coordinatemode(), and mom_remapping::remapping_core_h().

  type(diag_remap_ctrl),  intent(in) :: remap_cs !< Diagnostic coodinate control structure
  type(ocean_grid_type),  intent(in) :: g !< Ocean grid structure
  real, dimension(:,:,:), intent(in) :: h   !< The current thicknesses
  logical,                intent(in) :: staggered_in_x !< True is the x-axis location is at u or q points
  logical,                intent(in) :: staggered_in_y !< True is the y-axis location is at v or q points
  real, dimension(:,:,:), pointer    :: mask !< A mask for the field
  real,                   intent(in) :: missing_value !< A missing_value to assign land/vanished points
  real, dimension(:,:,:), intent(in) :: field(:,:,:) !< The diagnostic field to be remapped
  real, dimension(:,:,:), intent(inout) :: remapped_field !< Field remapped to new coordinate
  ! Local variables
  real, dimension(remap_cs%nz) :: h_dest
  real, dimension(size(h,3)) :: h_src
  logical :: mask_vanished_layers
  integer :: nz_src, nz_dest
  integer :: i, j, k

  call assert(remap_cs%initialized, 'diag_remap_do_remap: remap_cs not initialized.')
  call assert(size(field, 3) == size(h, 3), &
              'diag_remap_do_remap: Remap field and thickness z-axes do not match.')

  nz_src = size(field,3)
  nz_dest = remap_cs%nz
  mask_vanished_layers = (remap_cs%vertical_coord == coordinatemode('ZSTAR'))
  remapped_field(:,:,:) = missing_value

  if (staggered_in_x .and. .not. staggered_in_y) then
    ! U-points
    do j=g%jsc, g%jec
      do i=g%iscB, g%iecB
        if (associated(mask)) then
          if (mask(i,j,1) == 0.) cycle
        endif
        h_src(:) = 0.5 * (h(i,j,:) + h(i+1,j,:))
        h_dest(:) = 0.5 * (remap_cs%h(i,j,:) + remap_cs%h(i+1,j,:))
        call remapping_core_h(remap_cs%remap_cs, nz_src, h_src(:), field(i,j,:), &
                              nz_dest, h_dest(:), remapped_field(i,j,:))
        if (mask_vanished_layers) then ! This only works for z-like output
          do k=1, nz_dest
            if (h_dest(k) == 0.) remapped_field(i, j, k:nz_dest) = missing_value
          enddo
        endif
      enddo
    enddo
  elseif (staggered_in_y .and. .not. staggered_in_x) then
    ! V-points
    do j=g%jscB, g%jecB
      do i=g%isc, g%iec
        if (associated(mask)) then
          if (mask(i,j,1) == 0.) cycle
        endif
        h_src(:) = 0.5 * (h(i,j,:) + h(i,j+1,:))
        h_dest(:) = 0.5 * (remap_cs%h(i,j,:) + remap_cs%h(i,j+1,:) )
        call remapping_core_h(remap_cs%remap_cs, nz_src, h_src(:), field(i,j,:), &
                              nz_dest, h_dest(:), remapped_field(i,j,:))
        if (mask_vanished_layers) then ! This only works for z-like output
          do k=1, nz_dest
            if (h_dest(k) == 0.) remapped_field(i,j,k) = missing_value
          enddo
        endif
      enddo
    enddo
  elseif ((.not. staggered_in_x) .and. (.not. staggered_in_y)) then
    ! H-points
    do j=g%jsc, g%jec
      do i=g%isc, g%iec
        if (associated(mask)) then
          if (mask(i,j, 1) == 0.) cycle
        endif
        h_dest(:) = remap_cs%h(i,j,:)
        call remapping_core_h(remap_cs%remap_cs, nz_src, h(i,j,:), field(i,j,:), &
                              nz_dest, h_dest(:), remapped_field(i,j,:))
        if (mask_vanished_layers) then ! This only works for z-like output
          do k=1, nz_dest
            if (h_dest(k)==0.) remapped_field(i,j,k) = missing_value
          enddo
        endif
      enddo
    enddo
  else
    call assert(.false., 'diag_remap_do_remap: Unsupported axis combination')
  endif

Here is the call graph for this function:

diag_remap_end()

subroutine, public mom_diag_remap::diag_remap_end

(

type(diag_remap_ctrl), intent(inout)

remap_cs

)

De-init a diagnostic remapping type. Free allocated memory.

Parameters

[in,out]

remap_cs

Diag remapping control structure

Definition at line 98 of file MOM_diag_remap.F90.

Referenced by diag_remap_diag_registration_closed().

  type(diag_remap_ctrl), intent(inout) :: remap_cs !< Diag remapping control structure

  if (allocated(remap_cs%h)) deallocate(remap_cs%h)
  if (allocated(remap_cs%dz)) deallocate(remap_cs%dz)
  remap_cs%configured = .false.
  remap_cs%initialized = .false.
  remap_cs%used = .false.
  remap_cs%nz = 0

Here is the caller graph for this function:

diag_remap_get_axes_info()

subroutine, public mom_diag_remap::diag_remap_get_axes_info	(	type(diag_remap_ctrl), intent(in)	remap_cs,
		integer, intent(out)	nz,
		integer, intent(out)	id_layer,
		integer, intent(out)	id_interface
	)

Get layer and interface axes ids for this coordinate Needed when defining axes groups.

Parameters

[in]	remap_cs	Diagnostic coordinate control structure
[out]	nz	Number of vertical levels for the coordinate
[out]	id_layer	1D-axes id for layer points
[out]	id_interface	1D-axes id for interface points

Definition at line 194 of file MOM_diag_remap.F90.

  type(diag_remap_ctrl), intent(in) :: remap_cs !< Diagnostic coordinate control structure
  integer, intent(out) :: nz !< Number of vertical levels for the coordinate
  integer, intent(out) :: id_layer !< 1D-axes id for layer points
  integer, intent(out) :: id_interface !< 1D-axes id for interface points

  nz = remap_cs%nz
  id_layer = remap_cs%layer_axes_id
  id_interface = remap_cs%interface_axes_id

diag_remap_init()

subroutine, public mom_diag_remap::diag_remap_init	(	type(diag_remap_ctrl), intent(inout)	remap_cs,
		character(len=*), intent(in)	coord_tuple
	)

Initialize a diagnostic remapping type with the given vertical coordinate.

Parameters

[in,out]	remap_cs	Diag remapping control structure
[in]	coord_tuple	A string in form of MODULE_SUFFIX PARAMETER_SUFFIX COORDINATE_NAME

Definition at line 80 of file MOM_diag_remap.F90.

References regrid_consts::coordinatemode(), and mom_string_functions::extractword().

  type(diag_remap_ctrl), intent(inout) :: remap_cs !< Diag remapping control structure
  character(len=*),      intent(in)    :: coord_tuple !< A string in form of
                                                      !! MODULE_SUFFIX PARAMETER_SUFFIX COORDINATE_NAME

  remap_cs%diag_module_suffix = trim(extractword(coord_tuple, 1))
  remap_cs%diag_coord_name = trim(extractword(coord_tuple, 2))
  remap_cs%vertical_coord_name = trim(extractword(coord_tuple, 3))
  remap_cs%vertical_coord = coordinatemode(remap_cs%vertical_coord_name)
  remap_cs%configured = .false.
  remap_cs%initialized = .false.
  remap_cs%used = .false.
  remap_cs%nz = 0

Here is the call graph for this function:

diag_remap_set_active()

subroutine, public mom_diag_remap::diag_remap_set_active

(

type(diag_remap_ctrl), intent(inout)

remap_cs

)

Indicate that this remapping type is actually used by the diag manager. If this is never called then the type will be disabled to save time. See further explanation with diag_remap_registration_closed.

Parameters

[in,out]

remap_cs

Diag remapping control structure

Definition at line 127 of file MOM_diag_remap.F90.

  type(diag_remap_ctrl), intent(inout) :: remap_cs !< Diag remapping control structure

  remap_cs%used = .true.

diag_remap_update()

subroutine, public mom_diag_remap::diag_remap_update	(	type(diag_remap_ctrl), intent(inout)	remap_cs,
		type(ocean_grid_type), pointer	G,
		real, dimension(:, :, :), intent(in)	h,
		real, dimension(:, :, :), intent(in)	T,
		real, dimension(:, :, :), intent(in)	S,
		type(eos_type), intent(in), pointer	eqn_of_state
	)

Build/update target vertical grids for diagnostic remapping.

Note

The target grids need to be updated whenever sea surface height or layer thicknesses changes. In the case of density-based coordinates then technically we should also regenerate the target grid whenever T/S change.

Parameters

[in,out]	remap_cs	Diagnostic coordinate control structure
	g	The ocean's grid type
[in]	s	New thickness, T and S
[in]	eqn_of_state	A pointer to the equation of state

Definition at line 223 of file MOM_diag_remap.F90.

References coord_rho::build_rho_column(), coord_sigma::build_sigma_column(), coord_zlike::build_zstar_column(), regrid_consts::coordinatemode(), mom_regridding::get_rho_cs(), mom_regridding::get_sigma_cs(), mom_regridding::get_zlike_cs(), and mom_error_handler::mom_error().

  type(diag_remap_ctrl), intent(inout) :: remap_cs !< Diagnostic coordinate control structure
  type(ocean_grid_type), pointer :: g !< The ocean's grid type
  real, dimension(:, :, :), intent(in) :: h, t, s !< New thickness, T and S
  type(eos_type), pointer, intent(in) :: eqn_of_state !< A pointer to the equation of state

  ! Local variables
  integer :: i, j, k, nz
  real, dimension(remap_cs%nz + 1) :: zinterfaces
  real, dimension(remap_cs%nz) :: resolution

  ! Note that coordinateMode('LAYER') is never 'configured' so will
  ! always return here.
  if (.not. remap_cs%configured) then
    return
  endif

  nz = remap_cs%nz

  if (.not. remap_cs%initialized) then
    ! Initialize remapping and regridding on the first call
    call initialize_remapping(remap_cs%remap_cs, 'PPM_IH4', boundary_extrapolation=.false.)
    allocate(remap_cs%h(g%isd:g%ied,g%jsd:g%jed, nz))
    remap_cs%initialized = .true.
  endif

  ! Calculate remapping thicknesses for different target grids based on
  ! nominal/target interface locations. This happens for every call on the
  ! assumption that h, T, S has changed.
  do j=g%jsd, g%jed
    do i=g%isd, g%ied
      if (g%mask2dT(i,j)==0.) then
        remap_cs%h(i,j,:) = 0.
        cycle
      endif

      if (remap_cs%vertical_coord == coordinatemode('ZSTAR')) then
        call build_zstar_column(get_zlike_cs(remap_cs%regrid_cs), nz, &
                              g%bathyT(i,j), sum(h(i,j,:)), zinterfaces)
      elseif (remap_cs%vertical_coord == coordinatemode('SIGMA')) then
        call build_sigma_column(get_sigma_cs(remap_cs%regrid_cs), nz, &
                                g%bathyT(i,j), sum(h(i,j,:)), zinterfaces)
      elseif (remap_cs%vertical_coord == coordinatemode('RHO')) then
        call build_rho_column(get_rho_cs(remap_cs%regrid_cs), remap_cs%remap_cs, nz, &
                              g%bathyT(i,j), h(i,j,:), t(i, j, :), s(i, j, :), &
                              eqn_of_state, zinterfaces)
      elseif (remap_cs%vertical_coord == coordinatemode('SLIGHT')) then
!       call build_slight_column(remap_cs%regrid_cs,remap_cs%remap_cs, nz, &
!                             G%bathyT(i,j), sum(h(i,j,:)), zInterfaces)
        call mom_error(fatal,"diag_remap_update: SLIGHT coordinate not coded for diagnostics yet!")
      elseif (remap_cs%vertical_coord == coordinatemode('HYCOM1')) then
!       call build_hycom1_column(remap_cs%regrid_cs, nz, &
!                             G%bathyT(i,j), sum(h(i,j,:)), zInterfaces)
        call mom_error(fatal,"diag_remap_update: HYCOM1 coordinate not coded for diagnostics yet!")
      endif
      remap_cs%h(i,j,:) = zinterfaces(1:nz) - zinterfaces(2:nz+1)
    enddo
  enddo

Here is the call graph for this function:

horizontally_average_diag_field()

subroutine, public mom_diag_remap::horizontally_average_diag_field	(	type(ocean_grid_type), intent(in)	G,
		real, dimension(:,:,:), intent(in)	h,
		logical, intent(in)	staggered_in_x,
		logical, intent(in)	staggered_in_y,
		logical, intent(in)	is_layer,
		logical, intent(in)	is_extensive,
		real, intent(in)	missing_value,
		real, dimension(:,:,:), intent(in)	field,
		real, dimension(:), intent(inout)	averaged_field
	)

Horizontally average field.

Parameters

[in]	g	Ocean grid structure
[in]	h	The current thicknesses
[in]	staggered_in_x	True if the x-axis location is at u or q points
[in]	staggered_in_y	True if the y-axis location is at v or q points
[in]	is_layer	True if the z-axis location is at h points
[in]	is_extensive	True if the z-direction is spatially integrated (over layers)
[in]	missing_value	A missing_value to assign land/vanished points
[in]	field	The diagnostic field to be remapped
[in,out]	averaged_field	Field argument horizontally averaged

Definition at line 517 of file MOM_diag_remap.F90.

References mom_error_handler::assert().

Referenced by mom_diag_mediator::post_xy_average().

  type(ocean_grid_type),  intent(in) :: g !< Ocean grid structure
  real, dimension(:,:,:), intent(in) :: h !< The current thicknesses
  logical,                intent(in) :: staggered_in_x !< True if the x-axis location is at u or q points
  logical,                intent(in) :: staggered_in_y !< True if the y-axis location is at v or q points
  logical,                intent(in) :: is_layer !< True if the z-axis location is at h points
  logical,                intent(in) :: is_extensive !< True if the z-direction is spatially integrated (over layers)
  real,                   intent(in) :: missing_value !< A missing_value to assign land/vanished points
  real, dimension(:,:,:), intent(in) :: field !<  The diagnostic field to be remapped
  real, dimension(:),  intent(inout) :: averaged_field !< Field argument horizontally averaged
  ! Local variables
  real, dimension(size(field, 3)) :: vol_sum, stuff_sum ! nz+1 is needed for interface averages
  real :: v1, v2, total_volume, total_stuff, val
  integer :: i, j, k, nz

  nz = size(field, 3)

  if (staggered_in_x .and. .not. staggered_in_y) then
    if (is_layer) then
      ! U-points
      do k=1,nz
        vol_sum(k) = 0.
        stuff_sum(k) = 0.
        if (is_extensive) then
          do j=g%jsc, g%jec ; do i=g%isc, g%iec
            v1 = g%areaCu(i,j)
            v2 = g%areaCu(i-1,j)
            vol_sum(k) = vol_sum(k) + 0.5 * ( v1 + v2 ) * g%mask2dT(i,j)
            stuff_sum(k) = stuff_sum(k) + 0.5 * ( v1 * field(i,j,k) + v2 * field(i-1,j,k) ) * g%mask2dT(i,j)
          enddo ; enddo
        else ! Intensive
          do j=g%jsc, g%jec ; do i=g%isc, g%iec
            v1 = g%areaCu(i,j) * 0.5 * ( h(i,j,k) + h(i+1,j,k) )
            v2 = g%areaCu(i-1,j) * 0.5 * ( h(i,j,k) + h(i-1,j,k) )
            vol_sum(k) = vol_sum(k) + 0.5 * ( v1 + v2 ) * g%mask2dT(i,j)
            stuff_sum(k) = stuff_sum(k) + 0.5 * ( v1 * field(i,j,k) + v2 * field(i-1,j,k) ) * g%mask2dT(i,j)
          enddo ; enddo
        endif
      enddo
    else ! Interface
      do k=1,nz
        vol_sum(k) = 0.
        stuff_sum(k) = 0.
        do j=g%jsc, g%jec ; do i=g%isc, g%iec
          v1 = g%areaCu(i,j)
          v2 = g%areaCu(i-1,j)
          vol_sum(k) = vol_sum(k) + 0.5 * ( v1 + v2 ) * g%mask2dT(i,j)
          stuff_sum(k) = stuff_sum(k) + 0.5 * ( v1 * field(i,j,k) + v2 * field(i-1,j,k) ) * g%mask2dT(i,j)
        enddo ; enddo
      enddo
    endif
  elseif (staggered_in_y .and. .not. staggered_in_x) then
    if (is_layer) then
      ! V-points
      do k=1,nz
        vol_sum(k) = 0.
        stuff_sum(k) = 0.
        if (is_extensive) then
          do j=g%jsc, g%jec ; do i=g%isc, g%iec
            v1 = g%areaCv(i,j)
            v2 = g%areaCv(i,j-1)
            vol_sum(k) = vol_sum(k) + 0.5 * ( v1 + v2 ) * g%mask2dT(i,j)
            stuff_sum(k) = stuff_sum(k) + 0.5 * ( v1 * field(i,j,k) + v2 * field(i,j-1,k) ) * g%mask2dT(i,j)
          enddo ; enddo
        else ! Intensive
          do j=g%jsc, g%jec ; do i=g%isc, g%iec
            v1 = g%areaCv(i,j) * 0.5 * ( h(i,j,k) + h(i,j+1,k) )
            v2 = g%areaCv(i,j-1) * 0.5 * ( h(i,j,k) + h(i,j-1,k) )
            vol_sum(k) = vol_sum(k) + 0.5 * ( v1 + v2 ) * g%mask2dT(i,j)
            stuff_sum(k) = stuff_sum(k) + 0.5 * ( v1 * field(i,j,k) + v2 * field(i,j-1,k) ) * g%mask2dT(i,j)
          enddo ; enddo
        endif
      enddo
    else ! Interface
      do k=1,nz
        vol_sum(k) = 0.
        stuff_sum(k) = 0.
        do j=g%jsc, g%jec ; do i=g%isc, g%iec
          v1 = g%areaCv(i,j)
          v2 = g%areaCv(i,j-1)
          vol_sum(k) = vol_sum(k) + 0.5 * ( v1 + v2 ) * g%mask2dT(i,j)
          stuff_sum(k) = stuff_sum(k) + 0.5 * ( v1 * field(i,j,k) + v2 * field(i,j-1,k) ) * g%mask2dT(i,j)
        enddo ; enddo
      enddo
    endif
  elseif ((.not. staggered_in_x) .and. (.not. staggered_in_y)) then
    if (is_layer) then
      ! H-points
      do k=1,nz
        vol_sum(k) = 0.
        stuff_sum(k) = 0.
        if (is_extensive) then
          do j=g%jsc, g%jec ; do i=g%isc, g%iec
            if (g%mask2dT(i,j)>0. .and. h(i,j,k)>0.) then
              v1 = g%areaT(i,j)
              vol_sum(k) = vol_sum(k) + v1
              stuff_sum(k) = stuff_sum(k) + v1 * field(i,j,k)
            endif
          enddo ; enddo
        else ! Intensive
          do j=g%jsc, g%jec ; do i=g%isc, g%iec
            if (g%mask2dT(i,j)>0. .and. h(i,j,k)>0.) then
              v1 = g%areaT(i,j) * h(i,j,k)
              vol_sum(k) = vol_sum(k) + v1
              stuff_sum(k) = stuff_sum(k) + v1 * field(i,j,k)
            endif
          enddo ; enddo
        endif
      enddo
    else ! Interface
      do k=1,nz
        vol_sum(k) = 0.
        stuff_sum(k) = 0.
        do j=g%jsc, g%jec ; do i=g%isc, g%iec
          val = field(i,j,k)
          if (g%mask2dT(i,j)>0. .and. val/=missing_value) then
            v1 = g%areaT(i,j)
            vol_sum(k) = vol_sum(k) + v1
            stuff_sum(k) = stuff_sum(k) + v1 * field(i,j,k)
          endif
        enddo ; enddo
      enddo
    endif
  else
    call assert(.false., 'horizontally_average_diag_field: Q point averaging is not coded yet.')
  endif

  call sum_across_pes(vol_sum, nz)
  call sum_across_pes(stuff_sum, nz)

  do k=1,nz
    if (vol_sum(k)>0.) then
      averaged_field(k) = stuff_sum(k) / vol_sum(k)
    else
      averaged_field(k) = missing_value
    endif
  enddo

Here is the call graph for this function:

Here is the caller graph for this function:

vertically_interpolate_diag_field()

subroutine, public mom_diag_remap::vertically_interpolate_diag_field	(	type(diag_remap_ctrl), intent(in)	remap_cs,
		type(ocean_grid_type), intent(in)	G,
		real, dimension(:,:,:), intent(in)	h,
		logical, intent(in)	staggered_in_x,
		logical, intent(in)	staggered_in_y,
		real, dimension(:,:,:), pointer	mask,
		real, intent(in)	missing_value,
		real, dimension(:,:,:), intent(in)	field,
		real, dimension(:,:,:), intent(inout)	interpolated_field
	)

Vertically interpolate diagnostic field to alternative vertical grid.

Parameters

[in]	remap_cs	Diagnostic coodinate control structure
[in]	g	Ocean grid structure
[in]	h	The current thicknesses
[in]	staggered_in_x	True is the x-axis location is at u or q points
[in]	staggered_in_y	True is the y-axis location is at v or q points
	mask	A mask for the field
[in]	missing_value	A missing_value to assign land/vanished points
[in]	field	The diagnostic field to be remapped
[in,out]	interpolated_field	Field argument remapped to alternative coordinate

Definition at line 444 of file MOM_diag_remap.F90.

References mom_error_handler::assert(), and mom_diag_vkernels::interpolate_column().

  type(diag_remap_ctrl),  intent(in) :: remap_cs !< Diagnostic coodinate control structure
  type(ocean_grid_type),  intent(in) :: g !< Ocean grid structure
  real, dimension(:,:,:), intent(in) :: h   !< The current thicknesses
  logical,                intent(in) :: staggered_in_x !< True is the x-axis location is at u or q points
  logical,                intent(in) :: staggered_in_y !< True is the y-axis location is at v or q points
  real, dimension(:,:,:), pointer    :: mask !< A mask for the field
  real,                   intent(in) :: missing_value !< A missing_value to assign land/vanished points
  real, dimension(:,:,:), intent(in) :: field !<  The diagnostic field to be remapped
  real, dimension(:,:,:), intent(inout) :: interpolated_field !< Field argument remapped to alternative coordinate
  ! Local variables
  real, dimension(remap_cs%nz) :: h_dest
  real, dimension(size(h,3)) :: h_src
  integer :: nz_src, nz_dest
  integer :: i, j, k

  call assert(remap_cs%initialized, 'vertically_interpolate_diag_field: remap_cs not initialized.')
  call assert(size(field, 3) == size(h, 3)+1, &
              'vertically_interpolate_diag_field: Remap field and thickness z-axes do not match.')

  interpolated_field(:,:,:) = missing_value

  nz_src = size(h,3)
  nz_dest = remap_cs%nz

  if (staggered_in_x .and. .not. staggered_in_y) then
    ! U-points
    do j=g%jsc, g%jec
      do i=g%iscB, g%iecB
        if (associated(mask)) then
          if (mask(i,j,1) == 0.) cycle
        endif
        h_src(:) = 0.5 * (h(i,j,:) + h(i+1,j,:))
        h_dest(:) = 0.5 * ( remap_cs%h(i,j,:) + remap_cs%h(i+1,j,:) )
        call interpolate_column(nz_src, h_src, field(i,j,:), &
                                nz_dest, h_dest, missing_value, interpolated_field(i,j,:))
      enddo
    enddo
  elseif (staggered_in_y .and. .not. staggered_in_x) then
    ! V-points
    do j=g%jscB, g%jecB
      do i=g%isc, g%iec
        if (associated(mask)) then
          if (mask(i,j,1) == 0.) cycle
        endif
        h_src(:) = 0.5 * (h(i,j,:) + h(i,j+1,:))
        h_dest(:) = 0.5 * ( remap_cs%h(i,j,:) + remap_cs%h(i,j+1,:) )
        call interpolate_column(nz_src, h_src, field(i,j,:), &
                                nz_dest, h_dest, missing_value, interpolated_field(i,j,:))
      enddo
    enddo
  elseif ((.not. staggered_in_x) .and. (.not. staggered_in_y)) then
    ! H-points
    do j=g%jsc, g%jec
      do i=g%isc, g%iec
        if (associated(mask)) then
          if (mask(i,j, 1) == 0.) cycle
        endif
        h_src(:) = h(i,j,:)
        h_dest(:) = remap_cs%h(i,j,:)
        call interpolate_column(nz_src, h_src, field(i,j,:), &
                                nz_dest, h_dest, missing_value, interpolated_field(i,j,:))
      enddo
    enddo
  else
    call assert(.false., 'vertically_interpolate_diag_field: Q point remapping is not coded yet.')
  endif

Here is the call graph for this function:

vertically_reintegrate_diag_field()

subroutine, public mom_diag_remap::vertically_reintegrate_diag_field	(	type(diag_remap_ctrl), intent(in)	remap_cs,
		type(ocean_grid_type), intent(in)	G,
		real, dimension(:,:,:), intent(in)	h,
		logical, intent(in)	staggered_in_x,
		logical, intent(in)	staggered_in_y,
		real, dimension(:,:,:), pointer	mask,
		real, intent(in)	missing_value,
		real, dimension(:,:,:), intent(in)	field,
		real, dimension(:,:,:), intent(inout)	reintegrated_field
	)

Vertically re-grid an already vertically-integrated diagnostic field to alternative vertical grid.

Parameters

[in]	remap_cs	Diagnostic coodinate control structure
[in]	g	Ocean grid structure
[in]	h	The current thicknesses
[in]	staggered_in_x	True is the x-axis location is at u or q points
[in]	staggered_in_y	True is the y-axis location is at v or q points
	mask	A mask for the field
[in]	missing_value	A missing_value to assign land/vanished points
[in]	field	The diagnostic field to be remapped
[in,out]	reintegrated_field	Field argument remapped to alternative coordinate

Definition at line 373 of file MOM_diag_remap.F90.

References mom_error_handler::assert(), and mom_diag_vkernels::reintegrate_column().

  type(diag_remap_ctrl),  intent(in) :: remap_cs !< Diagnostic coodinate control structure
  type(ocean_grid_type),  intent(in) :: g !< Ocean grid structure
  real, dimension(:,:,:), intent(in) :: h   !< The current thicknesses
  logical,                intent(in) :: staggered_in_x !< True is the x-axis location is at u or q points
  logical,                intent(in) :: staggered_in_y !< True is the y-axis location is at v or q points
  real, dimension(:,:,:), pointer    :: mask !< A mask for the field
  real,                   intent(in) :: missing_value !< A missing_value to assign land/vanished points
  real, dimension(:,:,:), intent(in) :: field !<  The diagnostic field to be remapped
  real, dimension(:,:,:), intent(inout) :: reintegrated_field !< Field argument remapped to alternative coordinate
  ! Local variables
  real, dimension(remap_cs%nz) :: h_dest
  real, dimension(size(h,3)) :: h_src
  integer :: nz_src, nz_dest
  integer :: i, j, k

  call assert(remap_cs%initialized, 'vertically_reintegrate_diag_field: remap_cs not initialized.')
  call assert(size(field, 3) == size(h, 3), &
              'vertically_reintegrate_diag_field: Remap field and thickness z-axes do not match.')

  nz_src = size(field,3)
  nz_dest = remap_cs%nz
  reintegrated_field(:,:,:) = missing_value

  if (staggered_in_x .and. .not. staggered_in_y) then
    ! U-points
    do j=g%jsc, g%jec
      do i=g%iscB, g%iecB
        if (associated(mask)) then
          if (mask(i,j,1) == 0.) cycle
        endif
        h_src(:) = 0.5 * (h(i,j,:) + h(i+1,j,:))
        h_dest(:) = 0.5 * ( remap_cs%h(i,j,:) + remap_cs%h(i+1,j,:) )
        call reintegrate_column(nz_src, h_src, field(i,j,:), &
                                nz_dest, h_dest, missing_value, reintegrated_field(i,j,:))
      enddo
    enddo
  elseif (staggered_in_y .and. .not. staggered_in_x) then
    ! V-points
    do j=g%jscB, g%jecB
      do i=g%isc, g%iec
        if (associated(mask)) then
          if (mask(i,j,1) == 0.) cycle
        endif
        h_src(:) = 0.5 * (h(i,j,:) + h(i,j+1,:))
        h_dest(:) = 0.5 * ( remap_cs%h(i,j,:) + remap_cs%h(i,j+1,:) )
        call reintegrate_column(nz_src, h_src, field(i,j,:), &
                                nz_dest, h_dest, missing_value, reintegrated_field(i,j,:))
      enddo
    enddo
  elseif ((.not. staggered_in_x) .and. (.not. staggered_in_y)) then
    ! H-points
    do j=g%jsc, g%jec
      do i=g%isc, g%iec
        if (associated(mask)) then
          if (mask(i,j, 1) == 0.) cycle
        endif
        h_src(:) = h(i,j,:)
        h_dest(:) = remap_cs%h(i,j,:)
        call reintegrate_column(nz_src, h_src, field(i,j,:), &
                                nz_dest, h_dest, missing_value, reintegrated_field(i,j,:))
      enddo
    enddo
  else
    call assert(.false., 'vertically_reintegrate_diag_field: Q point remapping is not coded yet.')
  endif

Here is the call graph for this function: