mom_spatial_means Module Reference

Functions/Subroutines
real function, public	global_area_mean (var, G)
real function, public	global_area_integral (var, G)
real function, dimension(gv %ke), public	global_layer_mean (var, h, G, GV)
real function, public	global_volume_mean (var, h, G, GV)
subroutine, public	global_i_mean (array, i_mean, G, mask)
subroutine, public	global_j_mean (array, j_mean, G, mask)
subroutine, public	adjust_area_mean_to_zero (array, G, scaling)
	Adjust 2d array such that area mean is zero without moving the zero contour. More...

Function/Subroutine Documentation

adjust_area_mean_to_zero()

subroutine, public mom_spatial_means::adjust_area_mean_to_zero	(	real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(inout)	array,
		type(ocean_grid_type), intent(inout)	G,
		real, intent(out), optional	scaling
	)

Adjust 2d array such that area mean is zero without moving the zero contour.

Parameters

[in,out]	g	Grid structure
[in,out]	array	2D array to be adjusted
[out]	scaling	The scaling factor used

Definition at line 290 of file MOM_spatial_means.F90.

  type(ocean_grid_type),            intent(inout) :: g       !< Grid structure
  real, dimension(SZI_(G),SZJ_(G)), intent(inout) :: array   !< 2D array to be adjusted
  real, optional,                   intent(out)   :: scaling !< The scaling factor used
  ! Local variables
  real, dimension(SZI_(G), SZJ_(G)) :: posvals, negvals, areaxposvals, areaxnegvals
  integer :: i,j
  real :: areaintposvals, areaintnegvals, posscale, negscale

  areaxposvals(:,:) = 0.
  areaxnegvals(:,:) = 0.

  do j=g%jsc,g%jec ; do i=g%isc,g%iec
    posvals(i,j) = max(0., array(i,j))
    areaxposvals(i,j) = g%areaT(i,j) * posvals(i,j)
    negvals(i,j) = min(0., array(i,j))
    areaxnegvals(i,j) = g%areaT(i,j) * negvals(i,j)
  enddo ; enddo

  areaintposvals = reproducing_sum( areaxposvals )
  areaintnegvals = reproducing_sum( areaxnegvals )

  posscale = 0.0 ; negscale = 0.0
  if ((areaintposvals>0.).and.(areaintnegvals<0.)) then ! Only adjust if possible
    if (areaintposvals>-areaintnegvals) then ! Scale down positive values
      posscale = - areaintnegvals / areaintposvals
      do j=g%jsc,g%jec ; do i=g%isc,g%iec
        array(i,j) = (posscale * posvals(i,j)) + negvals(i,j)
      enddo ; enddo
    elseif (areaintposvals<-areaintnegvals) then ! Scale down negative values
      negscale = - areaintposvals / areaintnegvals
      do j=g%jsc,g%jec ; do i=g%isc,g%iec
        array(i,j) = posvals(i,j) + (negscale * negvals(i,j))
      enddo ; enddo
    endif
  endif
  if (present(scaling)) scaling = posscale - negscale

global_area_integral()

real function, public mom_spatial_means::global_area_integral	(	real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(in)	var,
		type(ocean_grid_type), intent(in)	G
	)

Parameters

[in]

g

The ocean's grid structure

Definition at line 62 of file MOM_spatial_means.F90.

Referenced by mom_forcing_type::forcing_diagnostics().

  type(ocean_grid_type),             intent(in)  :: g    !< The ocean's grid structure
  real, dimension(SZI_(G), SZJ_(G)), intent(in)  :: var
  real, dimension(SZI_(G), SZJ_(G))              :: tmpforsumming
  real :: global_area_integral

  integer :: i, j, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec

  tmpforsumming(:,:) = 0.
  do j=js,je ; do i=is, ie
    tmpforsumming(i,j) = ( var(i,j) * (g%areaT(i,j) * g%mask2dT(i,j)) )
  enddo ; enddo
  global_area_integral = reproducing_sum( tmpforsumming )

Here is the caller graph for this function:

global_area_mean()

real function, public mom_spatial_means::global_area_mean	(	real, dimension(szi_(g), szj_(g)), intent(in)	var,
		type(ocean_grid_type), intent(in)	G
	)

Parameters

[in]

g

The ocean's grid structure

Definition at line 45 of file MOM_spatial_means.F90.

Referenced by mom_diagnostics::calculate_diagnostic_fields(), and mom_forcing_type::forcing_diagnostics().

  type(ocean_grid_type),             intent(in)  :: g    !< The ocean's grid structure
  real, dimension(SZI_(G), SZJ_(G)), intent(in)  :: var
  real, dimension(SZI_(G), SZJ_(G))              :: tmpforsumming
  real :: global_area_mean

  integer :: i, j, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec

  tmpforsumming(:,:) = 0.
  do j=js,je ; do i=is, ie
    tmpforsumming(i,j) = ( var(i,j) * (g%areaT(i,j) * g%mask2dT(i,j)) )
  enddo ; enddo
  global_area_mean = reproducing_sum( tmpforsumming ) * g%IareaT_global

Here is the caller graph for this function:

global_i_mean()

subroutine, public mom_spatial_means::global_i_mean	(	real, dimension(szi_(g),szj_(g)), intent(in)	array,
		real, dimension(szj_(g)), intent(out)	i_mean,
		type(ocean_grid_type), intent(inout)	G,
		real, dimension(szi_(g),szj_(g)), intent(in), optional	mask
	)

Parameters

[in,out]

g

The ocean's grid structure

Definition at line 133 of file MOM_spatial_means.F90.

References mom_error_handler::mom_error(), mom_coms::query_efp_overflow_error(), and mom_coms::reset_efp_overflow_error().

Referenced by mom_sponge::apply_sponge().

  type(ocean_grid_type),            intent(inout) :: g    !< The ocean's grid structure
  real, dimension(SZI_(G),SZJ_(G)), intent(in)    :: array
  real, dimension(SZJ_(G)),         intent(out)   :: i_mean
  real, dimension(SZI_(G),SZJ_(G)), optional, intent(in) :: mask

!    This subroutine determines the global mean of a field along rows of
!  constant i, returning it in a 1-d array using the local indexing.

! Arguments: array - The 2-d array whose i-mean is to be taken.
!  (out)     i_mean - Global mean of array along its i-axis.
!  (in)      G - The ocean's grid structure.
!  (in)      mask - An array used for weighting the i-mean.

  type(efp_type), allocatable, dimension(:) :: asum, mask_sum
  real :: mask_sum_r
  integer :: is, ie, js, je, idg_off, jdg_off
  integer :: i, j

  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  idg_off = g%idg_offset ; jdg_off = g%jdg_offset

  call reset_efp_overflow_error()

  allocate(asum(g%jsg:g%jeg))
  if (present(mask)) then
    allocate(mask_sum(g%jsg:g%jeg))

    do j=g%jsg,g%jeg
      asum(j) = real_to_efp(0.0) ; mask_sum(j) = real_to_efp(0.0)
    enddo

    do i=is,ie ; do j=js,je
      asum(j+jdg_off) = asum(j+jdg_off) + real_to_efp(array(i,j)*mask(i,j))
      mask_sum(j+jdg_off) = mask_sum(j+jdg_off) + real_to_efp(mask(i,j))
    enddo ; enddo

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_i_mean overflow error occurred before sums across PEs.")

    call efp_list_sum_across_pes(asum(g%jsg:g%jeg), g%jeg-g%jsg+1)
    call efp_list_sum_across_pes(mask_sum(g%jsg:g%jeg), g%jeg-g%jsg+1)

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_i_mean overflow error occurred during sums across PEs.")

    do j=js,je
      mask_sum_r = efp_to_real(mask_sum(j+jdg_off))
      if (mask_sum_r == 0.0 ) then ; i_mean(j) = 0.0 ; else
        i_mean(j) = efp_to_real(asum(j+jdg_off)) / mask_sum_r
      endif
    enddo

    deallocate(mask_sum)
  else
    do j=g%jsg,g%jeg ; asum(j) = real_to_efp(0.0) ; enddo

    do i=is,ie ; do j=js,je
      asum(j+jdg_off) = asum(j+jdg_off) + real_to_efp(array(i,j))
    enddo ; enddo

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_i_mean overflow error occurred before sum across PEs.")

    call efp_list_sum_across_pes(asum(g%jsg:g%jeg), g%jeg-g%jsg+1)

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_i_mean overflow error occurred during sum across PEs.")

    do j=js,je
      i_mean(j) = efp_to_real(asum(j+jdg_off)) / real(g%ieg-g%isg+1)
    enddo
  endif

  deallocate(asum)

Here is the call graph for this function:

Here is the caller graph for this function:

global_j_mean()

subroutine, public mom_spatial_means::global_j_mean	(	real, dimension(szi_(g),szj_(g)), intent(in)	array,
		real, dimension(szi_(g)), intent(out)	j_mean,
		type(ocean_grid_type), intent(inout)	G,
		real, dimension(szi_(g),szj_(g)), intent(in), optional	mask
	)

Parameters

[in,out]

g

The ocean's grid structure

Definition at line 211 of file MOM_spatial_means.F90.

References mom_error_handler::mom_error(), mom_coms::query_efp_overflow_error(), and mom_coms::reset_efp_overflow_error().

  type(ocean_grid_type),            intent(inout) :: g    !< The ocean's grid structure
  real, dimension(SZI_(G),SZJ_(G)), intent(in)    :: array
  real, dimension(SZI_(G)),         intent(out)   :: j_mean
  real, dimension(SZI_(G),SZJ_(G)), optional, intent(in) :: mask

!    This subroutine determines the global mean of a field along rows of
!  constant j, returning it in a 1-d array using the local indexing.

! Arguments: array - The 2-d array whose j-mean is to be taken.
!  (out)     j_mean - Global mean of array along its j-axis.
!  (in)      G - The ocean's grid structure.
!  (in)      mask - An array used for weighting the j-mean.

  type(efp_type), allocatable, dimension(:) :: asum, mask_sum
  real :: mask_sum_r
  integer :: is, ie, js, je, idg_off, jdg_off
  integer :: i, j

  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  idg_off = g%idg_offset ; jdg_off = g%jdg_offset

  call reset_efp_overflow_error()

  allocate(asum(g%isg:g%ieg))
  if (present(mask)) then
    allocate (mask_sum(g%isg:g%ieg))

    do i=g%isg,g%ieg
      asum(i) = real_to_efp(0.0) ; mask_sum(i) = real_to_efp(0.0)
    enddo

    do i=is,ie ; do j=js,je
      asum(i+idg_off) = asum(i+idg_off) + real_to_efp(array(i,j)*mask(i,j))
      mask_sum(i+idg_off) = mask_sum(i+idg_off) + real_to_efp(mask(i,j))
    enddo ; enddo

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_j_mean overflow error occurred before sums across PEs.")

    call efp_list_sum_across_pes(asum(g%isg:g%ieg), g%ieg-g%isg+1)
    call efp_list_sum_across_pes(mask_sum(g%isg:g%ieg), g%ieg-g%isg+1)

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_j_mean overflow error occurred during sums across PEs.")

    do i=is,ie
      mask_sum_r = efp_to_real(mask_sum(i+idg_off))
      if (mask_sum_r == 0.0 ) then ; j_mean(i) = 0.0 ; else
        j_mean(i) = efp_to_real(asum(i+idg_off)) / mask_sum_r
      endif
    enddo

    deallocate(mask_sum)
  else
    do i=g%isg,g%ieg ; asum(i) = real_to_efp(0.0) ; enddo

    do i=is,ie ; do j=js,je
      asum(i+idg_off) = asum(i+idg_off) + real_to_efp(array(i,j))
    enddo ; enddo

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_j_mean overflow error occurred before sum across PEs.")

    call efp_list_sum_across_pes(asum(g%isg:g%ieg), g%ieg-g%isg+1)

    if (query_efp_overflow_error()) call mom_error(fatal, &
      "global_j_mean overflow error occurred during sum across PEs.")

    do i=is,ie
      j_mean(i) = efp_to_real(asum(i+idg_off)) / real(g%jeg-g%jsg+1)
    enddo
  endif

  deallocate(asum)

Here is the call graph for this function:

global_layer_mean()

real function, dimension( gv %ke), public mom_spatial_means::global_layer_mean	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)	var,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV
	)

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h	Layer thicknesses, in H (usually m or kg m-2)

Definition at line 79 of file MOM_spatial_means.F90.

Referenced by mom_diagnostics::calculate_diagnostic_fields().

  type(ocean_grid_type),                     intent(in)  :: g    !< The ocean's grid structure
  type(verticalgrid_type),                   intent(in)  :: gv   !< The ocean's vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: var
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: h    !< Layer thicknesses, in H (usually m or kg m-2)
  real, dimension(SZK_(GV))                   :: global_layer_mean

  real, dimension(SZI_(G), SZJ_(G), SZK_(GV)) :: tmpforsumming, weight
  real, dimension(SZK_(GV)) :: scalarij, weightij
  real, dimension(SZK_(GV)) :: global_temp_scalar, global_weight_scalar
  integer :: i, j, k, is, ie, js, je, nz
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke

  tmpforsumming(:,:,:) = 0. ; weight(:,:,:) = 0.

  do k=1,nz ; do j=js,je ; do i=is,ie
    weight(i,j,k)  =  h(i,j,k) * (g%areaT(i,j) * g%mask2dT(i,j))
    tmpforsumming(i,j,k) =  var(i,j,k) * weight(i,j,k)
  enddo ; enddo ; enddo

  global_temp_scalar   = reproducing_sum(tmpforsumming,sums=scalarij)
  global_weight_scalar = reproducing_sum(weight,sums=weightij)

  do k=1, nz
    global_layer_mean(k) = scalarij(k) / weightij(k)
  enddo

Here is the caller graph for this function:

global_volume_mean()

real function, public mom_spatial_means::global_volume_mean	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)	var,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV
	)

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h	Layer thicknesses, in H (usually m or kg m-2)

Definition at line 108 of file MOM_spatial_means.F90.

Referenced by mom_diagnostics::calculate_diagnostic_fields().

  type(ocean_grid_type),                     intent(in)  :: g    !< The ocean's grid structure
  type(verticalgrid_type),                   intent(in)  :: gv   !< The ocean's vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: var
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: h    !< Layer thicknesses, in H (usually m or kg m-2)
  real :: global_volume_mean

  real :: weight_here
  real, dimension(SZI_(G), SZJ_(G)) :: tmpforsumming, sum_weight
  integer :: i, j, k, is, ie, js, je, nz
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke

  tmpforsumming(:,:) = 0. ; sum_weight(:,:) = 0.

  do k=1,nz ; do j=js,je ; do i=is,ie
    weight_here  =  h(i,j,k) * (g%areaT(i,j) * g%mask2dT(i,j))
    tmpforsumming(i,j) = tmpforsumming(i,j) + var(i,j,k) * weight_here
    sum_weight(i,j) = sum_weight(i,j) + weight_here
  enddo ; enddo ; enddo
  global_volume_mean = (reproducing_sum(tmpforsumming)) / &
                       (reproducing_sum(sum_weight))

Here is the caller graph for this function: