Detailed Description

Functions and routines to take area, volume, mass-weighted, layerwise, zonal or meridional means.

Functions/Subroutines
real function, public	global_area_mean (var, G, scale)
	Return the global area mean of a variable. This uses reproducing sums. More...

real function, public	global_area_integral (var, G, scale)
	Return the global area integral of a variable. This uses reproducing sums. More...

real function, dimension(gv %ke), public	global_layer_mean (var, h, G, GV, scale)
	Return the layerwise global thickness-weighted mean of a variable. This uses reproducing sums. More...

real function, public	global_volume_mean (var, h, G, GV, scale)
	Find the global thickness-weighted mean of a variable. This uses reproducing sums. More...

real function, public	global_mass_integral (h, G, GV, var, on_PE_only, scale)
	Find the global mass-weighted integral of a variable. This uses reproducing sums. More...

subroutine, public	global_i_mean (array, i_mean, G, mask, scale, tmp_scale)
	Determine the global mean of a field along rows of constant i, returning it in a 1-d array using the local indexing. This uses reproducing sums. More...

subroutine, public	global_j_mean (array, j_mean, G, mask, scale, tmp_scale)
	Determine the global mean of a field along rows of constant j, returning it in a 1-d array using the local indexing. This uses reproducing sums. More...

subroutine, public	adjust_area_mean_to_zero (array, G, scaling, unit_scale)
	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(in)	G,
		real, intent(out), optional	scaling,
		real, intent(in), optional	unit_scale
	)

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

Parameters

[in]	g	Grid structure
[in,out]	array	2D array to be adjusted
[out]	scaling	The scaling factor used
[in]	unit_scale	A rescaling factor for the variable

Definition at line 357 of file MOM_spatial_means.F90.

   type(ocean_grid_type),            intent(in)    :: 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
   real,                   optional, intent(in)    :: unit_scale !< A rescaling factor for the variable
   ! Local variables
   real, dimension(SZI_(G), SZJ_(G)) :: posVals, negVals, areaXposVals, areaXnegVals
   integer :: i,j
   real :: scalefac  ! A scaling factor for the variable.
   real :: I_scalefac ! The Adcroft reciprocal of scalefac
   real :: areaIntPosVals, areaIntNegVals, posScale, negScale
  
   scalefac = 1.0 ; if (present(unit_scale)) scalefac = unit_scale
   i_scalefac = 0.0 ; if (scalefac /= 0.0) i_scalefac = 1.0 / scalefac
  
   areaxposvals(:,:) = 0.
   areaxnegvals(:,:) = 0.
  
   do j=g%jsc,g%jec ; do i=g%isc,g%iec
     posvals(i,j) = max(0., scalefac*array(i,j))
     areaxposvals(i,j) = g%US%L_to_m**2*g%areaT(i,j) * posvals(i,j)
     negvals(i,j) = min(0., scalefac*array(i,j))
     areaxnegvals(i,j) = g%US%L_to_m**2*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)) * i_scalefac
       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))) * i_scalefac
       enddo ; enddo
     endif
   endif
   if (present(scaling)) scaling = posscale - negscale
  

Referenced by mom_surface_forcing_mct::convert_iob_to_fluxes(), and mom_surface_forcing_nuopc::convert_iob_to_fluxes().

Here is the caller graph for this function:

◆ 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,
		real, intent(in), optional	scale
	)

Return the global area integral of a variable. This uses reproducing sums.

Parameters

[in]	g	The ocean's grid structure
[in]	var	The variable to integrate
[in]	scale	A rescaling factor for the variable

Definition at line 52 of file MOM_spatial_means.F90.

   type(ocean_grid_type),             intent(in)  :: G    !< The ocean's grid structure
   real, dimension(SZI_(G), SZJ_(G)), intent(in)  :: var  !< The variable to integrate
   real,                    optional, intent(in)  :: scale !< A rescaling factor for the variable
   real, dimension(SZI_(G), SZJ_(G))              :: tmpForSumming
   real :: global_area_integral
  
   real :: scalefac  ! An overall scaling factor for the areas and variable.
   integer :: i, j, is, ie, js, je
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  
   scalefac = g%US%L_to_m**2 ; if (present(scale)) scalefac = g%US%L_to_m**2*scale
  
   tmpforsumming(:,:) = 0.
   do j=js,je ; do i=is, ie
     tmpforsumming(i,j) = var(i,j) * (scalefac * g%areaT(i,j) * g%mask2dT(i,j))
   enddo ; enddo
   global_area_integral = reproducing_sum(tmpforsumming)
  

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

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,
		real, intent(in), optional	scale
	)

Return the global area mean of a variable. This uses reproducing sums.

Parameters

[in]	g	The ocean's grid structure
[in]	var	The variable to average
[in]	scale	A rescaling factor for the variable

Definition at line 29 of file MOM_spatial_means.F90.

   type(ocean_grid_type),             intent(in)  :: G    !< The ocean's grid structure
   real, dimension(SZI_(G), SZJ_(G)), intent(in)  :: var  !< The variable to average
   real,                    optional, intent(in)  :: scale !< A rescaling factor for the variable
  
   real, dimension(SZI_(G), SZJ_(G))              :: tmpForSumming
   real :: global_area_mean
  
   real :: scalefac  ! An overall scaling factor for the areas and variable.
   integer :: i, j, is, ie, js, je
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  
   scalefac = g%US%L_to_m**2 ; if (present(scale)) scalefac = g%US%L_to_m**2*scale
  
   tmpforsumming(:,:) = 0.
   do j=js,je ; do i=is,ie
     tmpforsumming(i,j) = var(i,j) * (scalefac * g%areaT(i,j) * g%mask2dT(i,j))
   enddo ; enddo
   global_area_mean = reproducing_sum(tmpforsumming) * g%IareaT_global
  

Referenced by mom_forcing_type::forcing_diagnostics(), and mom_internal_tides::sum_en().

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,
		real, intent(in), optional	scale,
		real, intent(in), optional	tmp_scale
	)

Determine the global mean of a field along rows of constant i, returning it in a 1-d array using the local indexing. This uses reproducing sums.

Parameters

[in,out]	g	The ocean's grid structure
[in]	array	The variable being averaged
[out]	i_mean	Global mean of array along its i-axis
[in]	mask	An array used for weighting the i-mean
[in]	scale	A rescaling factor for the output variable
[in]	tmp_scale	A rescaling factor for the internal calculations that is removed from the output

Definition at line 186 of file MOM_spatial_means.F90.

   type(ocean_grid_type),            intent(inout) :: G    !< The ocean's grid structure
   real, dimension(SZI_(G),SZJ_(G)), intent(in)    :: array  !< The variable being averaged
   real, dimension(SZJ_(G)),         intent(out)   :: i_mean !< Global mean of array along its i-axis
   real, dimension(SZI_(G),SZJ_(G)), &
                           optional, intent(in)    :: mask  !< An array used for weighting the i-mean
   real,                   optional, intent(in)    :: scale !< A rescaling factor for the output variable
   real,                   optional, intent(in)    :: tmp_scale !< A rescaling factor for the internal
                                                            !! calculations that is removed from the output
  
   ! Local variables
   type(EFP_type), allocatable, dimension(:) :: asum, mask_sum
   real :: scalefac  ! A scaling factor for the variable.
   real :: unscale   ! A factor for undoing any internal rescaling before output.
   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
  
   scalefac = 1.0 ; if (present(scale)) scalefac = scale
   unscale = 1.0
   if (present(tmp_scale)) then ; if (tmp_scale /= 0.0) then
     scalefac = scalefac * tmp_scale ; unscale = 1.0 / tmp_scale
   endif ; endif
   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(scalefac*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(scalefac*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
  
   if (unscale /= 1.0) then ; do j=js,je ; i_mean(j) = unscale*i_mean(j) ; enddo ; endif
  
   deallocate(asum)
  

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().

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( g %isd: g %ied, g %jsd: g %jed), intent(in)	array,
		real, dimension( g %isd: g %ied), intent(out)	j_mean,
		type(ocean_grid_type), intent(inout)	G,
		real, dimension( g %isd: g %ied, g %jsd: g %jed), intent(in), optional	mask,
		real, intent(in), optional	scale,
		real, intent(in), optional	tmp_scale
	)

Determine the global mean of a field along rows of constant j, returning it in a 1-d array using the local indexing. This uses reproducing sums.

Parameters

[in,out]	g	The ocean's grid structure
[in]	array	The variable being averaged
[out]	j_mean	Global mean of array along its j-axis
[in]	mask	An array used for weighting the j-mean
[in]	scale	A rescaling factor for the output variable
[in]	tmp_scale	A rescaling factor for the internal calculations that is removed from the output

Definition at line 272 of file MOM_spatial_means.F90.

   type(ocean_grid_type),            intent(inout) :: G    !< The ocean's grid structure
   real, dimension(SZI_(G),SZJ_(G)), intent(in)    :: array  !< The variable being averaged
   real, dimension(SZI_(G)),         intent(out)   :: j_mean !<  Global mean of array along its j-axis
   real, dimension(SZI_(G),SZJ_(G)), &
                           optional, intent(in)    :: mask  !< An array used for weighting the j-mean
   real,                   optional, intent(in)    :: scale !< A rescaling factor for the output variable
   real,                   optional, intent(in)    :: tmp_scale !< A rescaling factor for the internal
                                                            !! calculations that is removed from the output
  
   ! Local variables
   type(EFP_type), allocatable, dimension(:) :: asum, mask_sum
   real :: mask_sum_r
   real :: scalefac  ! A scaling factor for the variable.
   real :: unscale   ! A factor for undoing any internal rescaling before output.
   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
  
   scalefac = 1.0 ; if (present(scale)) scalefac = scale
   unscale = 1.0
   if (present(tmp_scale)) then ; if (tmp_scale /= 0.0) then
     scalefac = scalefac * tmp_scale ; unscale = 1.0 / tmp_scale
   endif ; endif
   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(scalefac*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(scalefac*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
  
   if (unscale /= 1.0) then ; do i=is,ie ; j_mean(i) = unscale*j_mean(i) ; enddo ; endif
  
   deallocate(asum)
  

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

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,
		real, intent(in), optional	scale
	)

Return the layerwise global thickness-weighted mean of a variable. This uses reproducing sums.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	var	The variable to average
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	scale	A rescaling factor for the variable

Definition at line 74 of file MOM_spatial_means.F90.

   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  !< The variable to average
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in)  :: h    !< Layer thicknesses [H ~> m or kg m-2]
   real,                            optional, intent(in)  :: scale !< A rescaling factor for the variable
   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
   real :: scalefac  ! A scaling factor for the variable.
   integer :: i, j, k, is, ie, js, je, nz
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
  
   scalefac = 1.0 ; if (present(scale)) scalefac = scale
   tmpforsumming(:,:,:) = 0. ; weight(:,:,:) = 0.
  
   do k=1,nz ; do j=js,je ; do i=is,ie
     weight(i,j,k)  =  (gv%H_to_m * h(i,j,k)) * (g%US%L_to_m**2*g%areaT(i,j) * g%mask2dT(i,j))
     tmpforsumming(i,j,k) =  scalefac * 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
  

◆ global_mass_integral()

real function, public mom_spatial_means::global_mass_integral	(	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,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, gv %ke), intent(in), optional	var,
		logical, intent(in), optional	on_PE_only,
		real, intent(in), optional	scale
	)

Find the global mass-weighted integral of a variable. This uses reproducing sums.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	var	The variable being integrated
[in]	on_pe_only	If present and true, the sum is only done on the local PE, and it is not order invariant.
[in]	scale	A rescaling factor for the variable

Returns: The mass-weighted integral of var (or 1) in kg times the units of var

Definition at line 138 of file MOM_spatial_means.F90.

   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)  :: h    !< Layer thicknesses [H ~> m or kg m-2]
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                  optional, intent(in)  :: var  !< The variable being integrated
   logical,       optional, intent(in)  :: on_PE_only  !< If present and true, the sum is only
                                 !! done on the local PE, and it is _not_ order invariant.
   real,          optional, intent(in)  :: scale !< A rescaling factor for the variable
   real :: global_mass_integral  !< The mass-weighted integral of var (or 1) in
                                 !! kg times the units of var
  
   real, dimension(SZI_(G), SZJ_(G)) :: tmpForSumming
   real :: scalefac  ! An overall scaling factor for the areas and variable.
   logical :: global_sum
   integer :: i, j, k, is, ie, js, je, nz
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
  
   scalefac = g%US%L_to_m**2 ; if (present(scale)) scalefac = g%US%L_to_m**2*scale
   tmpforsumming(:,:) = 0.0
  
   if (present(var)) then
     do k=1,nz ; do j=js,je ; do i=is,ie
       tmpforsumming(i,j) = tmpforsumming(i,j) + var(i,j,k) * &
                 ((gv%H_to_kg_m2 * h(i,j,k)) * (scalefac*g%areaT(i,j) * g%mask2dT(i,j)))
     enddo ; enddo ; enddo
   else
     do k=1,nz ; do j=js,je ; do i=is,ie
       tmpforsumming(i,j) = tmpforsumming(i,j) + &
                 ((gv%H_to_kg_m2 * h(i,j,k)) * (scalefac*g%areaT(i,j) * g%mask2dT(i,j)))
     enddo ; enddo ; enddo
   endif
   global_sum = .true. ; if (present(on_pe_only)) global_sum = .not.on_pe_only
   if (global_sum) then
     global_mass_integral = reproducing_sum(tmpforsumming)
   else
     global_mass_integral = 0.0
     do j=js,je ; do i=is,ie
       global_mass_integral = global_mass_integral + tmpforsumming(i,j)
     enddo ; enddo
   endif
  

Referenced by mom::get_ocean_stocks().

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,
		real, intent(in), optional	scale
	)

Find the global thickness-weighted mean of a variable. This uses reproducing sums.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	var	The variable being averaged
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	scale	A rescaling factor for the variable

Returns: The thickness-weighted average of var

Definition at line 107 of file MOM_spatial_means.F90.

   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  !< The variable being averaged
   real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), &
                            intent(in)  :: h    !< Layer thicknesses [H ~> m or kg m-2]
   real,          optional, intent(in)  :: scale !< A rescaling factor for the variable
   real :: global_volume_mean  !< The thickness-weighted average of var
  
   real :: scalefac  ! A scaling factor for the variable.
   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
  
   scalefac = 1.0 ; if (present(scale)) scalefac = scale
   tmpforsumming(:,:) = 0. ; sum_weight(:,:) = 0.
  
   do k=1,nz ; do j=js,je ; do i=is,ie
     weight_here  =  (gv%H_to_m * h(i,j,k)) * (g%US%L_to_m**2*g%areaT(i,j) * g%mask2dT(i,j))
     tmpforsumming(i,j) = tmpforsumming(i,j) + scalefac * 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))
  

Referenced by mom_diagnostics::calculate_diagnostic_fields().

Here is the caller graph for this function:

Detailed Description

Functions/Subroutines

Function/Subroutine Documentation

◆ adjust_area_mean_to_zero()

◆ global_area_integral()

◆ global_area_mean()

◆ global_i_mean()

◆ global_j_mean()

◆ global_layer_mean()

◆ global_mass_integral()

◆ global_volume_mean()